Abstract:
A method and system in a multithreaded processor for processing events without interrupt notifications. In one aspect of the present invention, an operating system creates a thread to execute on a stream of the processor. During execution of the thread, the thread executes a loop that determines whether an event has occurred and, in response to determining whether an event has occurred, assigns a different thread to process the event so that multiple events can be processed in parallel and so that interrupts are not needed to signal that the event has occurred. Another aspect of the present invention provides a method and system for processing asynchronously occurring events without interrupt notifications. To achieve this processing, a first thread is executed to generate a notification that the event has occurred upon receipt of the asynchronously occurring event. A second thread is also executed that loops determining whether a notification has been generated and, in response to determining that a notification has been generated, performing the processing necessary for the event.

Description:
TECHNICAL FIELD 
     The present invention relates to the processing of events by an operating system. 
     BACKGROUND OF THE INVENTION 
     Parallel computer architectures generally provide multiple processors that can each be executing different tasks simultaneously. One such parallel computer architecture is referred to as a multithreaded architecture (MTA). The MTA supports not only multiple processors but also multiple streams executing simultaneously in each processor. The processors of an MTA computer are interconnected via an interconnection network. Each processor can communicate with every other processor through the interconnection network. FIG. 1 provides a high-level overview of an MTA computer. Each processor  101  is connected to the interconnection network and memory  102 . Each processor contains a complete set of registers  101   a  for each stream. In addition, each processor also supports multiple protection domains  101   b  so that multiple user programs can be executing simultaneously within that processor. 
     Each MTA processor can execute multiple threads of execution simultaneously. Each thread of execution executes on one of the 128 streams supported by an MTA processor. Every clock time period, the processor selects a stream that is ready to execute and allows it to issue its next instruction. Instruction interpretation is pipelined by the processor, the network, and the memory. Thus, a new instruction from a different stream may be issued in each time period without interfering with other instructions that are in the pipeline. When an instruction finishes, the stream to which it belongs becomes ready to execute the next instruction. Each instruction may contain up to three operations (i.e., a memory reference operation, an arithmetic operation, and a control operation) that are executed simultaneously. 
     The state of a stream includes one 64-bit Stream Status Word (“SSW”), 32 64-bit General Registers (“R0-R31”), and eight 32-bit Target Registers (“T0-T7”). Each MTA processor has 128 sets of SSWs, of general registers, and of target registers. Thus, the state of each stream is immediately accessible by the processor without the need to reload registers when an instruction of a stream is to be executed. 
     The MTA uses program addresses that are 32 bits long. The lower half of an SSW contains the program counter (“PC”) for the stream. The upper half of the SSW contains various mode flags (e.g., floating point rounding, lookahead disable), a trap disable mask (e.g., data alignment and floating point overflow), and the four most recently generated condition codes. The 32 general registers are available for general-purpose computations. Register R0 is special, however, in that it always contains a 0. The loading of register R0 has no effect on its contents. The instruction set of the MTA processor uses the eight target registers as branch targets. However, most control transfer operations only use the low 32 bits to determine a new program counter. One target register (T0) points to the trap handler, which may be an unprivileged program. When a trap occurs, the trapping stream starts executing instructions at the program location indicated by register T0. Trap handling is lightweight and independent of the operating system and other streams. A user program can install trap handlers for each thread to achieve specific trap capabilities and priorities without loss of efficiency. 
     Each MTA processor supports as many as 16 active protection domains that define the program memory, data memory, and number of streams allocated to the computations using that processor. Each executing stream is assigned to a protection domain, but which domain (or which processor, for that matter) need not be known by the user program. 
     The MTA divides memory into program memory, which contains the instructions that form the program, and data memory, which contains the data of the program. The MTA uses a program mapping system and a data mapping system to map addresses used by the program to physical addresses in memory. The mapping systems use a program page map and a data segment map. The entries of the data segment map and program page map specify the location of the segment in physical memory along with the level of privilege needed to access the segment. 
     The number of streams available to a program is regulated by three quantities slim, scur, and sres associated with each protection domain. The current numbers of streams executing in the protection domain is indicated by scur; it is incremented when a stream is created and decremented when a stream quits. A create can only succeed when the incremented scur does not exceed sres, the number of streams reserved in the protection domain. The operations for creating, quitting, and reserving streams are unprivileged. Several streams can be reserved simultaneously. The stream limit slim is an operating system limit on the number of streams the protection domain can reserve. 
     When a stream executes a CREATE operation to create a new stream, the operation increments scur, initializes the SSW for the new stream based on the SSW of the creating stream and an offset in the CREATE operation, loads register (T0), and loads three registers of the new stream from general purpose registers of the creating stream. The MTA processor can then start executing the newly created stream. A QUIT operation terminates the stream that executes it and decrements both sres and scur. A QUIT_PRESERVE operation only decrements scur, which gives up a stream without surrendering its reservation. 
     The MTA supports four levels of privilege: user, supervisor, kernel, and IPL. The IPL level is the highest privilege level. All levels use the program page and data segment maps for address translation, and represent increasing levels of privilege. The data segment map entries define the minimum levels needed to read and write each segment, and the program page map entries define the exact level needed to execute from each page. Each stream in a protection domain may be executing at a different privileged level. 
     Two operations are provided to allow an executing stream to change its privilege level. A “LEVEL_ENTER lev” operation sets the current privilege level to the program page map level if the current level is equal to lev. The LEVEL_ENTER operation is located at every entry point that can accept a call from a different privilege level. A trap occurs if the current level is not equal to lev. The “LEVEL_RETURN lev” operation is used to return to the original privilege level. A trap occurs if lev is greater than the current privilege level. 
     An exception is an unexpected condition raised by an event that occurs in a user program, the operating system, or the hardware. These unexpected conditions include various floating point conditions (e.g., divide by zero), the execution of a privileged operation by a non-privileged stream, and the failure of a stream create operation. Each stream has an exception register. When an exception is detected, then a bit in the exception register corresponding to that exception is set. If a trap for that exception is enabled, then control is transferred to the trap handler whose address is stored in register T0. If the trap is currently disabled, then control is transferred to the trap handler when the trap is eventually enabled assuming that the bit is still set in the exception register. The operating system can execute an operation to raise a domain_signal exception in all streams of a protection domain. If the trap for the domain_signal is enabled, then each stream will transfer control to its trap handler. 
     Each memory location in an MTA computer has four access state bits in addition to a 64-bit value. These access state bits allow the hardware to implement several useful modifications to the usual semantics of memory reference. These access state bits are two data trap bits, one full/empty bit, and one forward bit. The two data trap bits allow for application-specific lightweight traps, the forward bit implements invisible indirect addressing, and the full/empty bit is used for lightweight synchronization. The behavior of these access state bits can be overridden by a corresponding set of bits in the pointer value used to access the memory. The data trap bits in the access state are independent of each other and are available for use, for example, by a language implementer. If a trap bit is set in a memory location, then an exception will be raised whenever that location is accessed if the trap bit is not disabled in the pointer. If the corresponding trap bit in the pointer is not disabled, then a trap will occur. 
     The forward bit implements a kind of “invisible indirection.” Unlike normal indirection, forwarding is controlled by both the pointer and the location pointed to. If the forward bit is set in the memory location and forwarding is not disabled in the pointer, the value found in the location is interpreted as a pointer to the target of the memory reference rather than the target itself. Dereferencing continues until either the pointer found in the memory location disables forwarding or the addressed location has its forward bit cleared. 
     The full/empty bit supports synchronization behavior of memory references. The synchronization behavior can be controlled by the full/empty control bits of a pointer or of a load or store operation. The four values for the full/empty control bits are shown below. 
     
       
         
               
               
               
               
               
             
           
               
                   
                   
               
               
                   
                 VALUE 
                 MODE 
                 LOAD 
                 STORE 
               
               
                   
                   
               
             
             
               
                   
                 0 
                 normal 
                 read regardless 
                 write regardless 
               
               
                   
                   
                   
                   
                 and set full 
               
               
                   
                 1 
                   
                 reserved 
                 reserved 
               
               
                   
                 2 
                 future 
                 wait for full 
                 wait for full 
               
               
                   
                   
                   
                 and leave full 
                 and leave full 
               
               
                   
                 3 
                 sync 
                 wait for full 
                 wait for empty 
               
               
                   
                   
                   
                 and set empty 
                 and set full 
               
               
                   
                   
               
             
          
         
       
     
     When the access control mode (i.e., synchronization mode) is future, loads and stores wait for the full/empty bit of memory location to be accessed to be set to full before the memory location can be accessed. When the access control mode is sync, loads are treated as “consume” operations and stores are treated as “produce” operations. A load waits for the full/empty bit to be set to full and then sets the full/empty bit to empty as it reads, and a store waits for the full/empty bit to be set to empty and then sets the full/empty bit to full as it writes. A forwarded location (i.e., its forward bit is set) that is not disabled (i.e., by the access control of a pointer) and that is empty (i.e., full/empty bit is set to empty) is treated as “unavailable” until its full/empty bit is set to full, irrespective of access control. 
     The full/empty bit may be used to implement arbitrary indivisible memory operations. The MTA also provides a single operation that supports extremely brief mutual exclusion during “integer add to memory.” The FETCH_ADD operation loads the value from a memory location and stores the sum of that value and another value back into the memory location. 
     Each protection domain has a retry limit that specifies how many times a memory access can fail in testing full/empty bit before a data blocked exception is raised. If the trap for the data blocked exception is enabled, then a trap occurs. The trap handler can determine whether to continue to retry the memory access or to perform some other action. If the trap is not enabled, then the next instruction after the instruction that caused the data blocked exception is executed. 
     A speculative load occurs typically when a compiler generates code to issue a load operation for a data value before it is known whether the data value will actually be accessed by the program. The use of speculative loads helps reduce the memory latency that would result if the load operation was only issued when it was known for sure whether the program actually was going to access the data value. Because a load is speculative in the sense that the data value may not actually be accessed by the program, it is possible that a speculative load will load a data value that the program does not access. The following statements indicate program statement for which a compiler may generate a speculative load: 
     if i&lt;N 
     x=buffer[i] 
     endif 
     The following statement illustrate the speculative load that is placed before the “if” statement. 
     r=buffer[i] 
     if i&lt;N 
     x=r 
     endif 
     The compiler generated code to load the data value for buffer[i] into a general register “r” and placed it before the code generated for the “if” statement condition. The load of the data value could cause an exception. For example, if the index i was so large that an invalid memory location was being accessed. If the “if” statement condition is satisfied, then the exception would have eventually occurred, but at a later time. In addition, if the “if” statement condition is not satisfied, then no exception would occur. To prevent a speculative load from causing an exception to occur or occur too early, the MTA has a “poison” bit for each general register. Whenever a load occurs, the poison bit is set or cleared depending on whether an exception would have been raised. If the data in a general register is then used while the corresponding poison bit is set, then an exception is raised at the time of use. In the above example, the “r=buffer[i]” statement would not raise an exception, but would set the corresponding poison bit if the address is invalid. An exception, however, would be raised when the “x=r” statement is executed accessing that general register because its poison bit is set. The deferring of the exceptions and setting of the poison bits can be disabled by a speculative load flag in the SSW. 
     FIG. 2A illustrates the layout of the 64-bit exception register. The upper 32-bits contain the exception flags, and the lower 32 bits contain the poison bits. Bits  40 - 44  contain the flags for the user exceptions, which include a create stream exception, a privileged instruction exception, a data alignment exception, and a data blocked exception. A data blocked exception is raised when a data memory retry exception, a trap 0 exception, a trap 1 exception, or a long memory latency timeout is generated. The program handling a data blocked exception is responsible for determining the cause of the data blocked exception. The exception register contains one poison bit for each of the 32 general registers. If the poison bit is set, then an attempt to access the content of the corresponding register will raise an exception. 
     FIG. 2B illustrates the layout of the 64-bit stream status word. The lower 32 bits contain the program counter, bits  32 - 39  contain mode bits, bits  40 - 51  contain a trap mask, and bits  5 - 63  contain the condition codes of the last four instructions executed. Bit  37  within the mode bits indicates whether speculative loads are enabled or disabled. Bit  48  within the trap mask indicates whether a trap on a user exception is enabled (bits  40 - 44  of the SSW). Thus, traps for the user exceptions are enabled or disabled as a group. 
     FIG. 2C illustrates the layout of a word of memory and in particular a pointer stored in a word of memory. Each word of memory contains a 64-bit value and a 4-bit access state. The 4-bit access state is described above. When the 64-bit value is used to point to a location in memory, it is referred to a “pointer.” The lower 48 bits of the pointer contains the address of the memory location to be accessed, and the upper 16 bits of the pointer contain access control bits. The access control bits indicate how to process the access state bits of the addressed memory location. One forward disable bit indicates whether forwarding is disabled, two full/empty control bits indicate the synchronization mode; and four trap 0 and 1 disable bits indicate whether traps are disabled for stores and loads, separately. If the forward disable bit is set, then no forwarding occurs regardless of the setting of the forward enable bit in the access state of the addressed memory location. If the trap 1 store disable bit is set, then a trap will not occur on a store operation, regardless of the setting of the trap 1 enable bit of the access state of the addressed memory location. The trap 1 load disable, trap 0 store disable, and trap 0 load disable bits operate in an analogous manner. Certain operations include a 5-bit access control operation field that supersedes the access control field of a pointer. The 5-bit access control field of an operation includes a forward disable bit, two full/empty control bits, a trap 1 disable bit, and a trap 0 disable bit. The bits effect the same behavior as described for the access control pointer field, except that each trap disable bit disables or enables traps on any access and does not distinguish load operations from store operations. 
     When a memory operation fails (e.g., synchronized access failure), an MTA processor saves the state of the operation. A trap handler can access that state. That memory operation can be redone by executing a redo operation (i.e., DATA_OP_REDO) passing the saved state as parameters of the operation. After the memory operation is redone (assuming it does not fail again), the trapping stream can continue its execution at the instruction after the trapping instruction. 
     An MTA computer system may include I/O processors to control the input/output to and from external sources. These I/O processors execute IOP instructions that control the transferring out of data from memory to the external sources and the transferring in of data from the external sources to memory. These external sources may include a network, a disk drive, and a keyboard. FIG. 3 is a block diagram illustrating an I/O processor. An I/O processor  301  supports the simultaneous execution of four instruction streams: a load stream  302 , an out stream  303 , a store stream  304 , and an in stream  305 . The I/O processor also includes an out buffer  306  and an in buffer  307 . Control word  308  contains a pointer to an instruction segment  309 . The instruction segment contains the IOP instructions that are to be executed by the streams. The load stream and the store stream move data between memory  310  and the buffers. The out stream and the in stream move data between the buffers and the external sources, such as a redundant array of inexpensive disks  311 . When the computer is booted, the boot routine may load the control word with a pointer to the instruction segment. Device drivers interact with the streams to effect the input and output of data. 
     FIG. 4 illustrates the format of an instruction segment. The instruction segment contains two words for each of the four streams. One word is a status word (xx_status$) and the other word is a next program counter (xx_next_pc$) that points to the next instruction to be executed by the stream. Each stream fetches and executes instructions in a linear fashion. If an exceptional event occurs during the execution of instruction, the stream performs a “link operation” with the device driver to inform it of the exception. The link operation is defined as a write to the stream status word, followed by a read from the program counter. The device driver and the stream access the status word and the program counter using a synchronization mode of sync. In general, a device driver waits until the status word is written by the stream indicating that a stream event has occurred, and a stream then waits until the next program counter is written by the device driver indicating its next instructions to execute. 
     Conventional computer architectures support the concept of an interrupt. An interrupt occurs in response to an event occurring within the computer system or external to the computer system. Events occurring within the computer system that may cause an interrupt include a page fault, division by zero, an unauthorized attempt to execute a privileged instruction, or at timer expiration. Events occurring external to the computer system that may cause an interrupt include receipt of a packet of network data or keyboard entry of data. When such an event occurs, the processor saves the program counter of the currently executing program and starts executing instructions at a designated location. That designated location is the entry point of an interrupt handling routine. The interrupt handling routine performs the processing necessary to respond to that event. When the interrupt handling routine completes its processing, it restores the saved program counter so that the interrupted program can resume execution. In contrast to these conventional computer architectures, the MTA does not support such interrupts. However, these external events still need to be processed in a timely manner. 
     Operating systems for conventional computer systems use interrupts to control the overall execution of the operating system and the user programs. The operating systems, in response to an interrupt resulting from a time period expiration, may swap out the currently executing user program and swap in another user program. Also, the operating systems in response to an interrupt resulting from user input, may either immediately swap in the user program waiting for the input or, alternatively, set a flag so that the operating system may swap in the user program during the next timer expiration interrupt processing. 
     The appendix contains the “Principles of Operation” of the MTA, which provides a more detailed description of the MTA. 
     SUMMARY OF THE INVENTION 
     Embodiments of the present invention provide a method and system in a multithreaded processor for processing events without interrupt notifications. In one aspect of the present invention, an operating system creates a thread to execute on a stream of the processor. During execution of the thread, the thread executes a loop that determines whether an event has occurred and, in response to determining whether an event has occurred, assigns a different thread to process the event so that multiple events can be processed in parallel and so that interrupts are not needed to signal that the event has occurred. The events may include a timer expiration or the unblocking of a thread that now can be assigned to a stream for execution. 
     Another aspect of the present invention provides a method and system for processing asynchronously occurring events without interrupt notifications. To achieve this processing, a first thread (e.g., device driver) is executed to generate a notification that the event has occurred upon receipt of the asynchronously occurring event. A second thread is also executed that loops determining whether a notification has been generated and, in response to determining that a notification has been generated, performing the processing necessary for the event. If multiple second threads are created then various asynchronous events can be processed in parallel. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 provides a high-level overview of an MTA computer. Each processor  101  is connected to the interconnection network and memory  102 . 
     FIG. 2A illustrates the layout of the 64-bit exception register. 
     FIG. 2B illustrates the layout of the 64-bit stream status word. 
     FIG. 2C illustrates the layout of a word of memory and in particular a pointer stored in a word of memory. 
     FIG. 3 is a block diagram illustrating an I/O processor. 
     FIG. 4 illustrates the format of an instruction segment. 
     FIG. 5 is a blocked diagram illustrating components of an operating system executing on a multithreaded processor. 
     FIG. 6 is the block diagram illustrating the team list data structure. 
     FIG. 7 is a flow diagram of an example listener daemon. 
     FIG. 8 is a flow diagram of an example checkRestart function. 
     FIG. 9 is a flow diagram of an example restartDaemonMain function. 
     FIG. 10 is a flow diagram of an example VP daemon. 
     FIG. 11 is a flow diagram that illustrates the processing of an example load stream. 
     FIG. 12 is a flow diagram that illustrates the processing of an example load device driver. 
     FIG. 13 is a flow diagram illustrating the processing of an example store device driver. 
     FIG. 14 illustrates the processing of the store stream. 
     FIG. 15 is a flow diagram illustrating a callback routine. 
     FIG. 16 illustrates a technique for reducing the number of issued instructions while in such a loop. 
     FIG. 17 is a flow diagram illustrating another technique for reducing the number of instructions executed by a looping routine. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Embodiments of the present invention provide techniques for operating system processing on a computer system that supports limited or no interrupts. The operating system of the present invention controls its overall execution and the execution of user programs without relying on interrupts. The operating system of the present invention uses various special-purpose threads, referred to as “daemons,” to perform operating system activities in parallel on behalf of the operating system. The daemons of the operating system include a virtual processor daemons (“VP daemons”), kernel daemons, supervisor daemons, and a listener daemon. The operating system uses the VP daemons to perform work (e.g., invoke a function) on behalf of the operating system. The VP daemons loop awaiting for work to be queued up by the operating system and when the work is queued, a VP daemon performs the work on behalf of the operating system. The unit of work that is queued is referred to as a “continuation,” and the queue is referred to as a “continuation queue.” In one embodiment, the VP daemons do not block. Rather, if a VP daemon executes a continuation that becomes blocked (e.g., waiting for a synchronized read), then rather than blocking itself the VP daemon places the blocked continuation in a blocked continuation queue and starts execution of another continuation from the continuation queue. Eventually, when the blocked continuation becomes unblocked either that VP daemon or another will continue with the execution of the continuation that is now unblocked. In an interrupt-based operating system, such units of work would typically be performed by an interrupt routine. Therefore, the use of VP daemons allows the units of work to be performed in an interrupt-free environment and in parallel. 
     The operating system creates kernel daemons and supervisor daemons to perform various activities in parallel. For example, the operating system may create a kernel daemon to schedule tasks and may create a supervisor daemon to execute a device driver. Eventually, a kernel daemon or a supervisor daemon may become blocked (e.g., waiting for an event). In an interrupt-based environment, the occurrence of the event may generate an interrupt, and the interrupt routine could then start the execution of the now unblocked daemon. Similarly, a thread of a user program may become blocked (e.g., waiting for a response to a read request). In an interrupt-based environment, an interrupt routine invoked when the read request is satisfied could start the execution of the user thread that was blocked. However, in an interrupt-free environment, the restarting of the daemons and the user threads cannot be performed by an interrupt routine. 
     One embodiment of the present invention uses a listener daemon to effect this restarting in an interrupt-free environment. More generally, the listener daemon loops checking for occurrences of events that would normally generate an interrupt in an interrupt-based environment. When the occurrence of an event is detected, the listener daemon can then perform processing similar to that performed in response to the interrupts of conventional computer systems, such as restarting an unblocked kernel daemon, supervisor daemon, or user thread. For example, the listener daemon may loop checking to see if a thread that has been blocked waiting for keyboard input has become unblocked, because the keyboard input has been received. The listener daemon can then assign the unblocked thread to a stream for execution. As the listener daemon loops, it also checks a timer queue to determine if any thread has requested that a certain unit of work be performed at a certain time. If so, the listener daemon sends a message to a timeout daemon that receives the message and starts a supervisor daemon to perform the work. In this way, the timer expiration interrupts of conventional computers can be simulated. 
     The operating system in one embodiment also provides for the processing data asynchronously received from an external source both in parallel and without interrupts. The device driver for processing the received data maintains a list of callback routines to be invoked when each type of asynchronous event occurs (e.g., data received for a certain task). When that event occurs, the device driver invokes the appropriate callback routine for that event. The callback routine places on the continuation queue a request for a unit of work to be performed to handle the asynchronous event. A VP daemon eventually removes the request from the continuation queue and starts performing that unit of work. Depending on the frequency in which data is received asynchronously, several VP daemons may be simultaneously executing units of work that are processing the asynchronously received data. This simultaneous execution effects the parallel processing of data received asynchronously and without interrupts. 
     FIG. 5 is a blocked diagram illustrating components of an operating system executing on a multithreaded processor. The same components may be executing simultaneously on other processors in a multiprocessor environment. The operating system includes various daemons and data structures. The listener daemon  501  loops checking the team list data structure  502  for kernel daemons  504 , supervisor daemons  505 , and user threads that are now unblocked and need to be restarted. The listener daemon also checks the timeout queue  503  to determine whether any timers have expired. If a timer has expired, the listener daemon sends a message to the timeout daemon  506 . The timeout daemon creates a supervisor daemon to perform the work to respond to the timer expiration. The VP daemons  507  loops checking the continuation queue  508  and the unblocked continuation queue  509 . The unblocked continuation queues hold those continuations that have been started, but became blocked and are now unblocked. When a queue is not empty, a VP daemon starts executing or restarts executing the unit of work indicated on the queue. The device drivers  510  interface with the I/O processors  511 . When a device driver receives an indication of an event from an I/O processor, the device driver invokes a callback routine  512  for processing that event. The callback routine may generate a request for unit of work to be performed and place that request on the continuation queue. 
     Listener Daemon 
     The listener daemon of a processor has access to a team list data structure that contains an entry for each domain. Each task (i.e., an executing user program) may have threads executing on different processors simultaneously. The collection of threads of a task executing on the same processor are referred to as a “team.” Each entry points to a team data structure that contains information relating to the team executing within that domain. The operating system executes in one of the domains and the corresponding entry points to a data structure for the operating system that may contain information relating to the kernel and supervisor daemons. FIG. 6 is the block diagram illustrating the team list data structure. Access to the team list data structure  601  is controlled by the TeamListLock$ synchronization variable  602 . The team list data structure entries point to the team data structure for the team currently executing in that domain. If no team is currently executing in that domain, then the entry is null. The team data structures  603  contain a pointer (pblockedthreads) to a linked list of thread data structures  604  of threads of the team that are currently blocked. The team data structure also contains a pointer (punblockedthreads) to a linked list of thread data structures of threads of the team that are currently unblocked and waiting to be assigned to a stream for execution. The team data structure also contains a restartRequestCount variable that indicates that number of unblocked threads on the linked list. 
     FIG. 7 is a flow diagram of an example listener daemon. The listener daemon loops determining whether any kernel daemons, supervisor daemons, or user threads have been unblocked by an external event and are ready to continue execution. If so, the listener daemon restarts those daemons and threads. The listener daemon also checks the timeout queue to determine whether any timers have expired. In step  701 , the listener daemon invokes the checkRestart routine passing a pointer to a “team” data structure for the kernel daemons. The checkRestart routine determines whether to start the execution of any unblocked threads. In step  702 , the listener daemon invokes the checkRestart function passing a pointer to a “team” data structure for the supervisor daemons. In steps  703 - 707 , the listener daemon loops checking whether each team that is currently executing in a protection domain has any unblocked threads that need to be restarted. In step  703 , the listener daemon selects the next team starting with the first. In step  704 , if all the teams have already been selected, then the listener daemon continues at step  708 , else the listener daemon continues at step  705 . In step  705 , the listener daemon locks the team list using the TeamListLock$ synchronization variable. In step  706 , the listener daemon invokes the checkRestart function passing a pointer to the team data structure of the selected team. In step  707 , the listener daemon unlocks the team list data structures by writing to the TeamListLock$ synchronization variable and loops to step  703  to select the next team. In step  708 , the listener daemon checks the timeout queue to determine if any timers have expired. If so, the listener daemon sends a message to the timeout daemon to process the timer expiration. The timeout daemon then creates a daemon to process each timer expiration. In one embodiment, the timeout queue is sorted by expiration time and contains an indicate of the unit of work (e.g., function) to be performed to process the timeout. 
     FIG. 8 is a flow diagram of an example checkRestart function. This function is passed a pointer to a team data structure that may need to have a thread restarted. In step  801 , if the restartRequestCount of the passed team data structure is greater than zero, then the function continues that step  802 , else the function returns because there are no unblocked threads. In step  802 , the function decrements the restartRequestCount variable. In step  803 , the function instantiates a data structure for a restart daemon. The restart daemon will be executed in a different stream and start execution of the unblocked thread. In step  805 , the routine invokes a function to create the daemon passing indication of a restartDaemonMain function to indicate where the daemon should start its execution. The function returns. 
     FIG. 9 is a flow diagram of an example restartDaemonMain function. This function is passed an indication of the domain in which the thread is to be re-started. User threads are started in the domain of the user program. In step  901 , if the passed domain is equal to the current domain, then the function continues at step  903 , else the function changes the domain in step  902 . In step  903 , the function restarts the thread by invoking a routine previously registered with the operating system by the “team” to handle unblocked threads. 
     VP Daemon 
     FIG. 10 is a flow diagram of an example VP daemon. The VP daemon loops checking whether any continuations that were previously blocked are now unblocked and whether any new continuations are ready to be executed. If so, the VP daemon either continues with the execution of the continuation or starts the execution of the new continuation. A VP daemon may also determine that additional VP daemons are needed to help servicing the continuation queue and unblocked continuation queue. If so, the VP daemon can create a new VP daemon. Conversely, if a VP daemon determines that too many VP daemons are currently executing, the VP daemon can quit. One skilled art would appreciate that various algorithms can be used to create and quit VP daemons. In step  1001 , if the unblocked queue is empty, then the VP daemon continues at step  1004 , else that the VP daemon continues step  1002 . The restarting of unblocked continuations is given priority over the starting of new continuations. In step  1002 , the daemon removes the continuation request from the unblocked continuation queue. In step  1003 , the VP daemon continues with performing the unblocked continuation. When the work of the continuation is complete or the continuation again blocks, the VP daemon loops to step  1001  to again check the queues. In step  1004 , if the continuation queue is empty, then VP daemon loops to step  1001  to again check the queues, else the. VP daemon continues that step  1005 . In step  1005 , the VP daemon removes a continuation request from the continuation queue. In step  1006 , the VP daemon performs the new continuation request. When the work of the new continuation request is complete or the continuation blocks, the VP daemon loops to step  1001  to again check the queue. 
     I/O Processing 
     One aspect of the present invention provides for the parallel processing of asynchronously received events. In the following example of this parallel processing, data is received asynchronously from an external source. The load stream for the I/O processor through which the data is received, notifies a device driver using a synchronization variable that the data has been received. The device driver then determines which callback routine has been designated by the operating system to handle that data and invokes that callback routine. The callback routine then places a continuation request on the continuation queue, which is eventually processed by a VP daemon. Because multiple VP daemons can be executing simultaneously, multiple VP daemons can be processing different occurrences of asynchronously received data simultaneously. In the following, the processing of a load stream and load device driver are described to illustrate the processing when a request to read data is sent to an external source. Then the processing of the store stream and store device driver are described to illustrate the processing of the asynchronously received data. 
     FIG. 11 is a flow diagram that illustrates the processing of an example load stream. As discussed in the background, the load stream retrieves data from memory and stores the retrieved data in the out buffer for outputting to an external source. The load stream coordinates the transferring out of data with the device driver using the load_status$ and load_next_pc$ synchronization variables of the instruction buffer. In step  1101 , the load stream reads from the load_next_pc$ synchronization variable. The corresponding device driver for the load stream writes the program counter for the next instruction that the load stream is to execute. The load stream waits until the synchronization variable is written. In step  1102 , the load stream executes the IOP instructions pointed to by the program counter. In step  1103 , the load stream writes to the load_status$ synchronization variable. The writing to this synchronization variable notifies the corresponding device driver that an event occurred that may need to be processed by the device driver. The load stream then loops to step  1101  to wait until the device driver notifies the load stream which instructions to execute next. 
     FIG. 12 is a flow diagram that illustrates the processing of an example load device driver. When an application program invokes an operating system call to request a read from an external source, the operating system places the request on a queue for the load device driver. The load device driver loops checking that queue and processing the requests. In step  1201 , if the queue is empty, the device driver loops until a request is placed in the queue. When a request is placed in the queue, the device driver continues at step  1202 . In step  1202 , the device driver removes a request from the queue. In step  1203 , the device driver writes the program counter for the load stream to the load_next_pc$ synchronization variable, which directs the load stream to start processing that request. In step  1204 , the load device driver reads from the load_status$ synchronization variable which waits until the load stream completes the request. In step  1205 , the load device driver processes the read status and then loops to step  1201  to remove the next request from the queue. The load driver may be optimized to construct an IOP program to process multiple requests and to overlap the construction of the IOP program with the IOP output processing. 
     FIG. 13 is a flow diagram illustrating the processing of an example store device driver. The store device driver may receive data from the store stream that was in response to a read request (e.g., a network packet). The store device driver maintains a list of callback routines that are to be invoked to process the received data. These callback routines may place a continuation on the continuation queue. A VP daemon eventually performs that unit of work specified by the continuation. In step  1301 , the store device driver reads the store_status$ synchronization variable, which waits until the store stream receives information. In step  1302 , the store device driver identifies the callback routine to process the data. In step  1303 , the store device driver invokes the identified callback routine. In step  1304 , the store device driver writes a program counter to the store_next_pc$ synchronization variable and loops to step  1301  to wait for the next notification from the store stream. 
     FIG. 14 illustrates the processing of the store stream. In step  1401 , the store stream reads from the store_next_pc$ synchronization variable. In step  1402 , the store stream executes the IOP instructions at the indicated program counter. These instructions may indicate to wait until data is received and then store that data in memory. In step  1403 , the store stream writes a status to the store_status$ synchronization variable to notify the store device driver that data has been received. The store stream then loops to step  1401  to wait for the setting of its program counter. 
     FIG. 15 is a flow diagram illustrating a callback routine. In step  1501 , the callback routine creates a continuation. In step  1502 , the callback routine adds the created continuation to the continuation queue to be scheduled for execution by a VP daemon. The callback routine then returns. 
     Reducing Instruction Issues 
     When daemons such as the listener daemon, VP daemons, or timeout daemon are executing, they can consume considerable processor resources in their loop checking on whether work needs to be performed. More generally, many computer programs execute loops checking for a certain event or condition to occur. Such looping may be wasteful of processor resources when the events or conditions do not occur frequently relative to the time it takes to process the event or condition. Thus, considerable processor resources may be spent looping until the next event or condition occurs. In a conventional interrupt-based environment, a looping program can block for a certain period of time waiting for a timer interrupt. The program can then check for the event or condition. Alternatively, the program may not need to loop and can instead wait for an interrupt signaling the occurrence of the event or condition. To reduce the overhead of such looping in an interrupt-free environment, various techniques can be used to reduce the number of instructions issued while waiting for the event or condition to occur. FIG. 16 illustrates a technique for reducing the number of issued instructions while in such a loop. Prior to checking to determine whether the event or condition has occurred, the looping routine executes an instruction to access a memory location through a chain of forwarding words  1601 . Each of the forwarding words have their forward bits set and contain a pointer to another of the forwarding words, except for the last word in the chain. The last word in the chain does not have its forward bit set. When the looping routine executes an instruction to access the word through this chain of forwarding words, the memory subsystem will spend an amount of time linearly related to be number of forwarding words in the chain in accessing the data. The stream executing the looping routine will not issue additional instructions until the forwarding is resolved by the memory subsystem. Thus, the rate in which the looping routine issues instructions will be reduced when the length of the chain increased. Other streams will thus be allowed to issue instructions at a faster rate because of the fewer instructions being issued by the stream executing the looping routine. 
     FIG. 17 is a flow diagram illustrating another technique for reducing the number of instructions executed by a looping routine. This technique utilizes the delay in issuing an instruction that results from accessing a word with a synchronization mode of sync. The routine issues a read (or write) to a word with its full/empty bit set to empty (or full) with a synchronization mode of sync. A retry-limit exception will eventually be raised. The routine can then re-execute the read (or write) to continue delaying the issuance of instructions. The routine may also count the number of retry-limit exceptions to effectively control the length of the delay before continuing with the main work of the routine. In step  1701 , the routine disables the data blocked trap so that the routine can handle the retry-limit exception. In step  1702 , the routine reads the delay$ synchronization variable. The full/empty bit of this synchronization variable is initialize to empty and is never set to full. Thus, this read will eventually raise a retry-limit exception. In step  1703 , if the retry-limit exception has been raised, then the routine continues at step  1704 . Step  1703  may be unnecessary if the only way the read can complete is when the retry-limit exception is raised. In step  1704 , the routine increments a counter that keeps track of the number of retry-limit exceptions that have been raised and clears the retry limit exception. In step  1705 , if the counter equals a predefined limit, then the routine continues at step  1706 , else routine loops to step  1702  to read the delay$ synchronization variable. In step  1706 , the routine sets the counter to zero and enables the data blocked trap. In step  1707 , the routine performs its processing that was delayed. For example, the listener daemon may check the team list to determine whether there any unblocked threads. The routine then loops to step  1701  to restart the delay in issuing instructions. 
     From the foregoing it will be appreciated that, although specific embodiments of the invention have been described herein for purposes of illustration, various modifications may be made without deviating from the spirit and scope of the invention. Accordingly, the invention is not limited except as by the appended claims.