Apple Inc.

Stephen J McPolin

Peter H Van Der Veen

Shawn R Woodtke

Joseph A Sarlo

Denis J Palmans

Stephane Couture

Andrew C Boyd

Gilberto Gemin

Aleksandar Ristovski

Gianluca Guida

In an embodiment, an operating system includes a device manager that is a central repository of device information. Device drivers may communicate with the device manager over respective channels, and may request channel identifiers (Cids) to communicate with resources related to the respective devices. The device manager may provide values for resource access (or handles that the resources may use to access values). In an embodiment, the device drivers do not have the ability to allocate resources for a peripheral device. Accordingly, the security of the system may be increased. Furthermore, the resource allocation may be centrally located, simplifying the process of updating resource allocation when needed. Additionally, the device manager may delay response to requests from a given device driver until its dependencies are clear (e.g., other device drivers and hardware initializations). Thus, startup scripts may be avoided in some embodiments.

Device manager providing resource control and synchronization

In an embodiment, an operating system for a computer system includes a kernel that assigns code sequences to execute on various processors. The kernel itself may execute on a processor as well. Specifically, in one embodiment, the kernel may execute on a processor with a relatively low instructions per clock (IPC) design. At least a portion of other processors in the system may have higher IPC designs, and processors with higher IPC designs may be used to execute some of the code sequences. A given code sequence executing on a processor may queue multiple messages to other code sequences, which the kernel may asynchronously read and schedule the targeted code sequences for execution in response to the messages. Rather than synchronously preparing a message and making a call to send the message, the executing code sequences may continue executing and queuing messages until the code has completed or is in need of a result from one of the messages.

Asynchronous kernel

In an embodiment, an operating system is defined in terms of a set of actors, each of which implements one or more capabilities built into the system. The actors may establish channels between them for communication of messages between the actors. Some actors may interpose between other actors. These other actors may, in some cases, interpose on channels used by the base actor. In some embodiments, some channels may be interposed while others may be monitored by the interposing actor but may still communicate directly with the underlying actor. Some channels may not be affected by the interposition (e.g. the channels may not be interposed or monitored), in an embodiment. Other examples of interposition may include debugging, simulation, and sandboxing.

Interposition

In an embodiment, an operating system includes a device manager that is a central repository of device information. Device drivers may communicate with the device manager over respective channels, and may request channel identifiers (Cids) to communicate with resources related to the respective devices. The device manager may provide values for resource access (or handles that the resources may use to access values). In an embodiment, the device drivers do not have the ability to allocate resources for a peripheral device. Accordingly, the security of the system may be increased. Furthermore, the resource allocation may be centrally located, simplifying the process of updating resource allocation when needed. Additionally, the device manager may delay response to requests from a given device driver until its dependencies are clear (e.g. other device drivers and hardware initializations). Thus, startup scripts may be avoided in some embodiments.

In an embodiment, an operating system for a computer system assigns each independently-schedulable code sequence to an activity. An activity may thus be associated with a group of related code sequences, such as threads that communicate with each other (whether or not they are part of the same program). When a code sequence is ready to be scheduled and it is not part of the current activity, it may preempt the current activity if the activity for the code sequence is not enabled and is not masked by the enabled activities. Each activity may define which other activities it masks. A flexible scheduling scheme may be devised based on the mask assignments for each activity.

Scheduling threads based on mask assignments for activities

In an embodiment, an operating system for a computer system is built on a set of capabilities. Each capability includes at least one pointer to a function that implements the capability. One or more actors are defined which use one or more of the capabilities, and which may be connected to other actors for communication through channels. The channels may be created and maintained by a channel actor. In an embodiment, one or more actors may be assembled to create a composed actor. The actors within the composed actor still communicate over the channels defined between the internal actors, but may pass channel identifiers for actors outside the composed actor, so that the actors within the composed actor communicate with the outside actors as if they were one single actor. Arbitrarily complex actors may be formed in this fashion, while still maintaining the stability and safety of the initial actors.

Growing community of inventors

Nepean, Canada

Stephen J McPolin