Ex Parte 5694604 et al - Page 35


                Appeal 2007-2127                                                                                  
                Reexamination Control No. 90/006,621                                                              
                                    j. Thread scheduling and dispatching                                          
                       Threads are scheduled for execution by the operating system                                
                scheduler, which distributes processor cycles to all active threads according                     
                to some scheduling scheme, and threads are dispatched by the dispatcher,                          
                which institutes the thread context switch to save the state of the running                       
                thread and load the saved state for the new thread.  The scheduler,                               
                dispatcher, and preemptive scheduling scheme are described in Nguyen,                             
                Advanced Programmer's Guide to OS/2, page 11:                                                     
                              All the threads that are active within the system at any time                       
                       form a pool from which the operating system dispatches threads one                         
                       at a time, in a round-robin fashion.  A dispatched thread temporarily                      
                       has the CPU all to itself.  Thread dispatching is performed by a                           
                       module of the operating system called the Dispatcher/Scheduler.  The                       
                       Dispatcher institutes the task switch necessary to execute the next                        
                       thread, while the Scheduler distributes processor cycles to all the                        
                       active threads within the system.                                                          
                              Notice that we have been speaking of active threads and                             
                       dispatched threads.  These are not the same thing.  At any given time                      
                       within the system there will be a number of active threads, but only                       
                       one dispatched thread.  In fact it is more proper to speak of the active                   
                       threads within the system as the set of ready threads, and the                             
                       dispatched thread as the running thread.  A third state in which a                         
                       thread can be found is the waiting state.  A waiting thread is one                         
                       which is waiting for an external event (such as the completion of an                       
                       I/O operation).  When the external event occurs (when the I/O                              
                       operation has been completed) the operating system places the waiting                      
                       thread back into the pool of ready threads.  See figure 1.3 for the state                  
                       diagram for a thread.                                                                      





                                                       35                                                         

Page:  Previous  28  29  30  31  32  33  34  35  36  37  38  39  40  41  42  Next

Last modified: September 9, 2013