Systems and methods for managing shared resources in a computer system

• US 8,028,298 B2
• Filed: 08/18/2003
• Issued: 09/27/2011
• Est. Priority Date: 08/16/2002
• Status: Expired due to Fees

• Current Assignee: Synaptics Incorporated
• Original Assignee: Conexant Systems Incorporated (Synaptics Incorporated)
• Inventors: Moore, Mark Justin
• Primary Examiner(s): WU, QING YUAN
• Application Number:
  US10/642,309
• Publication Number:
  US 20060168589A1
• Time in Patent Office: 2,962 Days
• Field of Search: 719314-315
• US Class Current: 719/315
• CPC Class Codes: G06F 2209/547 Messaging middleware
• CPC Class Codes: G06F 9/45537 Provision of facilities of other operating environments, e.g. WINE I/O emulation G06F13/105
• CPC Class Codes: G06F 9/546 Message passing systems or structures, e.g. queues

Abstract

An operating system is provided wherein a plurality of objects are established and registered in response to requests from hardware or software associated with the computer system. The objects include at least one type, at least one attribute, and a handle. The plurality of objects are then manipulated to effect processing and exchange of information.

Claims

1. A method for managing shared resources in a computer system, comprising:

establishing and registering a plurality of objects in response to requests from hardware or software associated with the computer system, the objects including at least one type, at least one attribute, and a handle;

establishing a plurality of message pool objects, wherein the plurality of message pool objects comprise pools of free messages that can be allocated;

manipulating the plurality of objects to effect processing and exchange of information;

receiving, at a message pool interface, a request by a first task object through a first task object interface for a message allocation;

allocating a message from a free message pool of the pools of free messages to the first task object;

sending the message from the first task object through the first task object interface directly to a second task object through a second task object interface, wherein the message includes a message to arm an interrupt enabled in the second task object, the second task object including an interrupt object and the second task object interface including an interrupt interface;

performing processing by the second task object in response to the received message, wherein the processing includes disabling an interrupt;

returning the message by the second task object via the second task object interface, wherein returning further comprises one of the following;

returning the message by the second task object through the second task object interface directly to the free message pool through the message pool interface upon completion of processing; and

returning the message by the second task object through the second task object interface to the first task object through the first task object interface upon completion of processing in which the first task object through the first task object interface subsequently returns the message to the free message pool through the message pool interface.

2. The method of claim 1, further comprising:

establishing a plurality of task objects;

allocating messages from at least one free message pool object in response to requests from one or more task objects, wherein the messages include blocks of information that can be passed to other task objects;

exchanging the messages between the plurality of task objects, thereby effecting requests for processing; and

returning the messages to the free message pool object upon completion of processing.

3. The method of claim 2, further comprising:

the plurality of task objects include at least a task type and an interface type, the interface type enabling request and release of messages; and

the plurality of message pool objects include at least a pool type and an interface type.

4. The method of claim 2, wherein exchanging the messages between the plurality of task objects, thereby effecting requests for processing further comprises at least one of:

putting a message to an interface, getting a message from an interface, and waiting for a message to arrive on an interface.

5. The method of claim 3, further comprising:

receiving, at a message pool interface, a request by a first task object interface for a message allocation;

allocating a message from the free message pool to the first task object;

sending an arm interrupt message from the first task object interface to a interrupt object interface;

disabling an interrupt with the arm interrupt message by the interrupt object; and

returning the message to the first task object interface.

6. The method of claim 1, further comprising:

defining a plurality of top-level tasks from the plurality of objects;

providing each of the plurality of top-level tasks with a private memory resource; and

enabling access of the private memory resource to any subtask created by a top-level task.

7. The method of claim 1, further comprising:

allocating a memory space to a parent task;

establishing at least one subtask to the parent task;

enabling access of the memory space to the at least one subtask; and

preventing access of the memory space to tasks not associated with the parent task.

8. The method of claim 7, further comprising:

allocating a memory space to a subtask; and

preventing access of the memory space to a parent task of the subtask.

9. The method of claim 1, further comprising:

establishing an object instance for each of the plurality of objects; and

establishing an object handle for each object instance, the object handle referencing a data structure used to implement the object instance.

10. The method of claim 9, wherein the object handle is a pointer value.

11. The method of claim 9, further comprising:

establishing at least one derived object type, based upon the object instance;

establishing object attributes for the at least one derived object type; and

accessing any established object attributes with the object handle.

12. The method of claim 11, further comprising appending data structures associated with the at least one derived object type to the data structure used to implement the object instance.

13. The method of claim 1, further comprising:

establishing an object instance for each of the plurality of objects;

establishing at least one derived object type, based upon the object instance;

establishing object attributes for the at least one derived object type; and

establishing an object handle for each derived object type, the object handles referencing a data structure used to implement the object instance.

14. The method of claim 1, further comprising:

organizing the plurality of objects as files in a global file system, wherein files in the system contain references to objects in memory; and

referencing each of the plurality of objects in relation to a plurality of top level object types.

15. The method of claim 14, wherein the plurality of top level object types include tasks, interfaces, pools, mutexes, semaphores, interrupts, and memory.

16. A computer-readable storage medium incorporating one or more instructions, that when executed for a computer, causes the computer to manage shared resources in a computer system, comprising:

one or more instructions for establishing and registering a plurality of objects in response to requests from hardware or software associated with the computer system, the objects including at least one type, at least one attribute, a handle;

one or more instructions for establishing a plurality of message pool objects, wherein the plurality of message pool objects comprise pools of free messages that can be allocated; and

one or more instructions for manipulating the plurality of objects to effect processing and exchange of information;

one or more instructions for receiving, at a message pool interface, a request by a first task object through a first task object interface for a message allocation;

one or more instructions for allocating a message from a free message pool of the pools of free messages to the first task object;

one or more instructions for sending the message from the first task object through the first task object interface directly to a second task object through a second task object interface, wherein the message includes a message to arm an interrupt enabled in the second task object, the second task object including an interrupt object and the second task object interface including an interrupt interface;

one or more instructions for performing processing by the second task object in response to the received message receipt, wherein the processing includes disabling an interrupt;

one or more instructions for returning the message by the second task object via the second task object interface, wherein returning further comprises one of the following;

returning the message by the second task object through the second task object interface directly to the free message pool through the message pool interface upon completion of processing; and

returning the message by the second task object through the second task object interface to the first task object through the first task object interface upon completion of processing, in which the first task object through the first task object interface subsequently returns the message to the free message pool through the message pool interface.

17. The computer-readable storage medium of claim 16, the program further comprising:

one or more instructions for establishing a plurality of task objects;

one or more instructions for allocating messages from at least one free message pool object in response to requests from one or more task objects, wherein the messages include blocks of information that can be passed to other task objects;

one or more instructions for exchanging the messages between the plurality of task objects, thereby effecting requests for processing; and

one or more instructions for returning the messages to the free message pool object upon completion of processing.

18. The computer-readable storage medium of claim 17, the program further comprising:

one or more instructions for the plurality of task objects include at least a task type and an interface type, the interface type enabling request and release of messages; and

the plurality of message pool objects include at least a pool type and an interface type.

19. The computer-readable storage medium of claim 17, wherein the one or more instructions for exchanging the messages between the plurality of task objects, thereby effecting requests for processing further comprise at least one of:

one or more instructions for putting a message to an interface, getting a message from an interface, and waiting for a message to arrive on an interface.

20. The computer-readable storage medium of claim 18, the program further comprising:

one or more instructions for receiving, at a message pool interface, a request by a first task object interface for a message allocation;

one or more instructions for allocating a message from the free message pool to the first task object;

one or more instructions for sending an arm interrupt message from the first task object interface to a interrupt object interface;

one or more instructions for disabling an interrupt with the arm interrupt message by the interrupt object; and

one or more instructions for returning the message to the first task object interface.

21. The computer-readable storage medium of claim 16, the program further comprising:

one or more instructions for defining a plurality of top-level tasks from the plurality of objects;

one or more instructions for providing each of the plurality of top-level tasks with a private memory resource; and

one or more instructions for enabling access of the private memory resource to any subtask created by a top-level task.

22. The computer-readable storage medium of claim 16, the program further comprising:

one or more instructions for allocating a memory space to a parent task;

one or more instructions for establishing at least one subtask to the parent task;

one or more instructions for enabling access of the memory space to the at least one subtask; and

one or more instructions for preventing access of the memory space to tasks not associated with the parent task.

23. The computer-readable storage medium of claim 22, the program further comprising:

one or more instructions for allocating a memory space to a subtask; and

one or more instructions for preventing access of the memory space to a parent task of the subtask.

24. The computer-readable storage medium of claim 16, the program further comprising:

one or more instructions for establishing an object instance for each of the plurality of objects; and

one or more instructions for establishing an object handle for each object instance, the object handle referencing a data structure used to implement the object instance.

25. The computer-readable storage medium of claim 24, wherein the object handle is a pointer value.

26. The computer-readable storage medium of claim 24, the program further comprising:

one or more instructions for establishing at least one derived object type, based upon the object instance;

one or more instructions for establishing object attributes for the at least one derived object type; and

one or more instructions for accessing any established object attributes with the object handle.

27. The computer-readable storage medium of claim 26, the program further comprising one or more instructions for appending data structures associated with the at least one derived object type to the data structure used to implement the object instance.

28. The computer-readable storage medium of claim 16, the program further comprising:

one or more instructions for establishing an object instance for each of the plurality of objects;

one or more instructions for establishing at least one derived object type, based upon the object instance;

one or more instructions for establishing object attributes for the at least one derived object type; and

one or more instructions for establishing an object handle for each derived object type, the object handles referencing a data structure used to implement the object instance.

29. The computer-readable storage medium of claim 16, the program further comprising:

one or more instructions for organizing the plurality of objects as files in a global file system, wherein files in the system contain references to objects in memory; and

one or more instructions for referencing each of the plurality of objects in relation to a plurality of top level object types.

30. The computer-readable storage medium of claim 29, wherein the plurality of top level object types include tasks, interfaces, pools, mutexes, semaphores, interrupts, and memory.