Ex Parte 5694604 et al - Page 102


                Appeal 2007-2127                                                                                  
                Reexamination Control No. 90/006,621                                                              
                3.     Krantz discloses that OS/2 is multitasking (pages 58-59):                                  
                              In a multitasking environment, an application does not have to                      
                       execute tasks one at a time or synchronously.  Instead, the application                    
                       can have more than one task active at a time.  It can have one task                        
                       reading the keyboard and another task reading data from the disk.                          
                       While data from the disk is still waiting to be read in, the application                   
                       can be using the processor to get input from the keyboard and do                           
                       whatever is needed.  Because timing relationship between all the tasks                     
                       is not known at every point in time, the tasks are said to be executing                    
                       asynchronously.                                                                            
                4.     OS/2 can multitask "sessions, processes, and threads" (page 59).                           
                5.     Krantz discloses: "The application that is currently receiving keyboard                    
                input and displaying data on the screen is called the foreground session.                         
                The rest of the programs in the OS/2 system are called background                                 
                sessions."  (Page 59.)                                                                            
                6.     Krantz discloses (page 63):                                                                
                              A process owns "units of execution."  A unit of execution is                        
                       called a thread.  It can be thought of as a series of program                              
                       instructions that are executed one after another.  We can equate an                        
                       application in the DOS environment to a single thread of execution                         
                       because the entire program executes synchronously from beginning to                        
                       end.  In the DOS environment, there can never be two sets of program                       
                       instructions being executed 'at the same time' or asynchronously.  In                      
                       OS/2, all the sets of program instructions that execute independently                      
                       of one another (asynchronously) are called threads.                                        
                7.     Krantz discloses (page 64):                                                                
                              When two threads are executing asynchronously to each other,                        
                       it means that each thread does not know what the other thread is                           
                       currently doing.  For example, one thread of a process could be                            
                       reading from the keyboard and writing to the display and another                           
                       thread of the same process could be reading from a file and writing to                     

                                                       102                                                        

Page:  Previous  95  96  97  98  99  100  101  102  103  104  105  106  107  108  109  Next

Last modified: September 9, 2013