Patent Publication Number: US-9430352-B2

Title: Information processing apparatus, computer product, and information processing method

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
     This application is a continuation application of International Application PCT/JP2010/070317, filed on Nov. 15, 2010 and designating the U.S., the entire contents of which are incorporated herein by reference. 
    
    
     FIELD 
     The embodiment discussed herein is related to an information processing apparatus, a computer product, and an information processing method that control thread execution. 
     BACKGROUND 
     According to a conventional technique (first conventional technique), when multiple threads are assigned to CPUs of a single-core processor system or multi-core processor system, the order of execution of threads is determined based on priority levels defined for individual threads (see, for example, Japanese Laid-Open Patent Application No. S63-068934). 
     According to another technique (second conventional technique), when multiple threads are assigned, each of the threads is executed for a given interval sequentially (see, for example, Japanese Laid-Open Patent Application No. 2000-276360 and C. L. Lui, James W. LAYLAND, “Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment”, Journal of the Association for Computing Machinery, Vol. 20, No. 1, January 1973). 
     The first conventional technique, however, poses a problem that when the power consumed for standby by a low-priority thread among multiple threads is large, power consumption increases. The second conventional technique poses a problem that because threads are switched at each given interval, contention occurs over access of a cache in a CPU in which execution information of each thread is temporarily stored. 
     For example, during execution of a given thread by the CPU, execution information of the given thread is stored to the cache. When the given thread is switched with another tread to be executed, the execution information of the given thread in the cache is overwritten by execution information for the other thread. Then, when the other thread is switched with the given thread to be executed, the execution information of the other thread in the cache is overwritten by the execution information for the given thread. This process leads to a problem of a decline in execution performance and a decrease in throughput. 
     SUMMARY 
     According to an aspect of an embodiment, an information processing apparatus includes a processor configured to detect an unexecuted first thread and an unexecuted second thread; calculate standby power consumption of the first thread in a case of executing the second thread followed by the first thread, based on an execution period of the second thread and standby power consumption per unit time of the first thread; calculate standby power consumption of the second thread in a case of executing the first thread followed by the second thread, based on an execution period of the first thread and standby power consumption per unit time of the second thread; and determine an order of execution of the first thread and the second thread, based on comparison of the standby power consumption of first thread and the standby power consumption of the second thread. 
     The object and advantages of the invention will be realized and attained by means of the elements and combinations particularly pointed out in the claims. 
     It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory and are not restrictive of the invention. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         FIG. 1  is an explanatory diagram of one embodiment of the present invention; 
         FIG. 2  is an explanatory diagram of a case where an execution deadline is defined for a first thread; 
         FIG. 3  is a block diagram of hardware of an information processing apparatus; 
         FIG. 4  is an explanatory diagram of an example of a thread table  400 ; 
         FIG. 5  is an explanatory diagram of an example of an assignment management table  500 ; 
         FIG. 6  is a functional diagram of an information processing apparatus  300 ; 
         FIG. 7  is an explanatory diagram of an example of detection of the generation of thread #0; 
         FIG. 8  is an explanatory diagram of an example of updating of the assignment management table  500 ; 
         FIGS. 9, 10, and 11  are flowcharts of an information processing procedure by the information processing apparatus  300 ; 
         FIGS. 12 and 13  are flowcharts of a detailed procedure of an execution sequence determining process (step S 907 ) in  FIG. 9 ; 
         FIG. 14  is a flowchart of an information processing procedure executed by each OS when a thread is assigned; and 
         FIG. 15  is a flowchart of an information processing procedure executed by each OS when a thread is completed. 
     
    
    
     DESCRIPTION OF EMBODIMENTS 
     Preferred embodiments of an information processing apparatus, program, and method according to the present invention will be explained with reference to the accompanying drawings. 
       FIG. 1  is an explanatory diagram of one embodiment of the present invention. An unexecuted first thread and an unexecuted second thread will be described as an example. In  FIG. 1 , the amount of power consumed during standby (standby power consumption) is calculated for each execution-order-based thread combination before execution of the first and second threads, and an execution sequence is determined based on the result of the calculation. 
     (1) When the execution sequence is “the second thread→the first thread”, the first thread stands by during execution of the second thread. The standby power consumption of the first thread is given by the following equation.
 
Standby power of first thread=execution period for second thread [ms]×stand-by power per unit time of first thread [mW/ms]
 
     (2) When the execution order is “the first thread→the second thread”, the second thread stands by during execution of the first thread. The standby power consumption of the second thread is given by the following equation.
 
Stand-by power of second thread=execution period for first thread [ms]×stand-by power per unit time of second thread [mW/ms]
 
     The information processing apparatus compares the standby power consumption of the first thread and the standby power consumption of the second thread. If the standby power consumption of the first thread greater than or equal to the standby power consumption of the second thread, the information processing apparatus determines the execution sequence to be “the first thread→the second thread”. If the standby power consumption of the first thread is less than the standby power consumption of the second thread, the information processing apparatus determines the execution sequence to be “the second thread→the first thread”. 
       FIG. 2  is an explanatory diagram of a case where an execution deadline is defined for the first thread.  FIG. 2  depicts an example in which an execution deadline is defined for the first thread while no execution deadline is defined for the second thread. An execution deadline defined for the first thread means that a period from the generation time of the first thread to the execution deadline for the first thread is defined. 
     If a period (d) from the generation time of the first thread to the execution deadline for the first thread is defined, whether the execution deadline for the first thread can be met if the execution sequence is the second thread followed the first thread is determined, that is, whether the following inequality is satisfied is determined.
 
 d −execution period for first thread&gt;execution period for second thread
 
     If “d−execution period for first thread&gt;execution period for second thread” is satisfied, as indicated in  FIG. 2 , the information processing apparatus calculates the standby power consumption of a standby thread for each execution-order-based thread combination and determines the execution sequence, as described with reference to  FIG. 1 . If “d−execution period for first thread≦execution period for second thread” is true, and if execution sequence is “the second thread→the first thread”, the execution deadline for the first thread cannot be met. The information processing apparatus, therefore, determines the execution sequence to be “the first thread→the second thread”. 
     In this embodiment, a multi-core processor system is described as an example of the information processing apparatus. In the multi-core processor system, a multi-core processor is a processor equipped with multiple cores. A single processor equipped with multiple cores and a processor group including parallel single-core processors are both regarded as the multi-core processor since both have multiple cores. For the sake of convenience in description, a processor group of parallel single-core processors will be described in this embodiment. 
       FIG. 3  is a block diagram of hardware of the information processing apparatus. In  FIG. 3 , an information processing apparatus  300  includes a CPU #0, a CPU #1, and a shared memory  302 . The CPU #0, the CPU #1, and the shared memory  302  are interconnected through a bus  301 . 
     The CPU #0 has a cache, a register, and a core. The CPU #1 has a cache, a register, and a core. The CPU #0 executes an OS  310  and supervises overall control over the information processing apparatus  300 . The OS  310  serving as a master OS has a function of determining to which CPU a thread is to be assigned, and executes threads assigned to the CPU #0. The CPU #1 runs an OS  311 , which serves as a slave OS and executes threads assigned to the CPU #1. 
     The shared memory  302  has, for example, a read only memory (ROM), a random access memory (RAM), and a flash ROM. For example, the flash ROM stores a boot program; the ROM stores application software; and the RAM is used as a work area of the CPUs #0 and #1. A program stored in the shared memory  302  is loaded onto a CPU, where the program causes the CPU to execute a coded process. The shared memory  302  stores, for example, a thread table  400  and an assignment management table  500 . 
       FIG. 4  is an explanatory diagram of an example of the thread table  400 . The thread table  400  has a thread identification information field  401 , a priority level field  402 , a deadline field  403 , an execution period field  404 , and a standby power consumption field  405 . The thread identification information field  401  retains identification information of each thread. The priority level field  402  retains information indicating whether the priority level of the thread whose identification information is indicated in the thread identification information field  401  is high or low. In this field, “high priority” is entered for a thread of which the priority level is high while “low priority” is entered for a thread of which the priority level is not high. 
     The deadline field  403  indicates a period from a generation time at which a thread is generated to an execution deadline for the thread (the period being referred to as “deadline”). The execution period field  404  indicates an execution period for the thread whose identification information is indicated in the thread identification information field  401 . The standby power consumption field  405  indicates a standby power consumption value per unit time for the thread whose identification information is indicated in the thread identification information field  401 . 
     In the case of the thread #0, the table indicates that the thread #0 is a high-priority thread, having a deadline of 10 [ms], an execution period of 5 [ms], and standby power consumption per unit time of 100 [mW/ms]. 
       FIG. 5  is an explanatory diagram of an example of the assignment management table  500 . The assignment management table  500  has a CPU identification information field  501 , a LOCK field  502 , an assigned thread identification field  503 , and an execution status field  504 . The CPU identification information field  501  retains identification information of CPUs. 
     The LOCK field  502  retains information indicating whether the CPU whose identification information is indicated in the CPU identification information field  501  is locked. Indicating whether a CPU is locked means indicating whether a high-priority thread is assigned to the CPU. If no high-priority thread is assigned to the CPU, “0” is entered in the LOCK field  502 . If a high-priority thread is assigned to the CPU, “1” is entered in the LOCK field  502 . 
     The assigned thread identification field  503  retains identification information of a thread assigned to the CPU whose identification information is indicated in the CPU identification information field  501 . The execution status field  504  indicates the execution status of each thread whose identification information is indicated in the assigned thread identification field  503 . In this field, either “exe (execution)” or “proh (prohibit)” is entered as an execution status. “exe” indicates that the thread is executable, while “proh” indicates that execution of the thread is prohibited. 
     Each OS refers to the assignment management table  500 , and finds that the threads #1 and #3 are assigned to the CPU #0 and threads #2 and #4 are assigned to the CPU #1. Because threads assigned to each CPU are entered into the assigned thread identification information field in the order of assignment of the threads, each OS can identify the order of assignment of threads by sequentially accessing entries of threads in the assigned thread identification information field in the assignment management table  500 . 
       FIG. 6  is a functional diagram of the information processing apparatus  300 . The information processing apparatus  300  includes a detecting unit  601 , a difference calculating unit  602 , a judging unit  603 , a first calculating unit  604 , a second calculating unit  605 , a comparing unit  606 , and a determining unit  607 . For example, an information processing program stored in the shared memory  302  and having functions of the detecting unit  601  to the determining unit  607  is loaded onto the CPU #0. The CPU #0 then executes a process coded in the program to implement the functions of the detecting unit  601  to the determining unit  607 . 
     The detecting unit  601  detects an unexecuted first thread and an unexecuted second thread. 
     The first calculating unit  604  multiplies the execution period for the second thread detected by the detecting unit  601  and the standby power consumption per unit time of the first thread detected by the detecting unit  601 . The first calculating unit  604  thus calculates the standby power consumption of the first thread in a case of execution of the second thread followed by the first thread. 
     The second calculating unit  605  multiplies the execution period for the first thread and the standby power consumption per unit time of the second thread and thereby, calculates the standby power consumption of the second thread in a case of execution of the first thread followed by the second thread. 
     The comparing unit  606  compares the standby power consumption of the first thread calculated by the first calculating unit  604  and the standby power consumption of the second thread calculated by the second calculating unit  605 . 
     The determining unit  607  determines the order of execution of the first thread and the second thread, based on the result of comparison by the comparing unit  606 . 
     If the comparing unit  606  gives a comparison result indicating that the standby power consumption of the first thread is greater than or equal to the standby power consumption of the second thread, the determining unit  607  determines the order of execution to be the first thread followed by the second thread. 
     If the comparing unit  606  gives a comparison result indicating that the standby power consumption of the first thread is less than the standby power consumption of the second thread, the determining unit  607  determines the order of execution to be the second thread followed by the first thread. 
     If an execution deadline is defined for the first thread detected by the detecting unit  601 , the difference calculating unit  602  calculates a time difference of a period from the generation time to the execution deadline of the first thread and the execution period for the first thread. 
     The judging unit  603  judges whether the time difference calculated by the difference calculating unit  602  is larger than the execution period for the second thread. 
     If the judging unit  603  judges the time difference to be larger than the execution period for the second thread, the first calculating unit  604  multiplies the execution period for the second thread and the standby power consumption per unit time of the first thread to calculate the standby power consumption of the first thread. 
     If the judging unit  603  judges the time difference to be larger than the execution period for the second thread, the second calculating unit  605  multiplies the execution period for the first thread and the standby power consumption per unit time of the second thread to calculate the standby power consumption of the second thread. 
     If the judging unit  603  judges the time difference to be less than or equal to the execution period for the second thread, the determining unit  607  determines the order of execution to be the first thread followed by the second thread. 
     Based on the above description, the embodiment will be explained in detail. The embodiment relates to an example in which when a high-priority thread is generated, and the order of execution of a low-priority thread and the high-priority thread is determined. In the embodiment, a CPU to which only the low-priority threads are assigned executes the threads in the order of assignment thereof. 
     In the embodiment, the order of execution of threads is determined at each CPU to which no high-priority thread is assigned, and a generated high-priority thread (subject thread) is assigned to a CPU that can reduce standby power consumption to the greatest extent. 
     A method of determining the order of execution will first be described. The OS  310  selects an arbitrary CPU (subject CPU) among CPUs to which no high-priority thread is assigned. The OS  310  identifies a thread assigned to the subject CPU. The OS  310  then performs calculations expressed as the following equations.
 
 p total=0
 
 r 0=deadline for subject thread−execution period for subject thread
 
 pst _high (standby power consumption of subject thread)= r 0×standby power consumption per unit time of subject thread [mW/ms]
 
 pst _low (stand-by power of assigned thread)=execution period of subject thread×( p 1+ p 2+ . . .  pn )
 
     In the equations, n denotes the number of assigned threads and 1 to n represent numbers that are appended to the assigned threads in the order of assignment thereof. p1 to pn denote the standby power consumption of the assigned threads. (p1+p2+ . . . pn), therefore, denotes the total of the standby power consumption per unit time of the assigned threads. 
     The OS  310  determines whether the following inequality is satisfied.
 
 r 0&gt;( t 1   t 2  . . .    tn )   pst _high&lt; pst _low  (1)
 
     In the inequality,   denotes logical product and   denotes logical sum, and t1 to tn denote execution periods for the assigned threads. When the above inequality (1) is true (is satisfied), the OS  310  determines an assigned thread that is a low-priority thread to be executed before the subject thread. 
     The OS  310  selects a thread of which the standby power consumption per unit time is the greatest among the assigned threads satisfying “r0&lt;(t1 t2  . . .  tn)”, as a thread to be executed before the subject thread. It is assumed, for example, that a thread (preceding thread) assigned first among the assigned threads is selected as the thread to be executed before the subject thread. 
     The OS  310  then (a) performs calculations expressed as the following equations.
 
 p total= p total+ t 1× p 0  (2)
 
 pst _high= pst _high−t1× p 0  (3)
 
 pst _low= pst _low− t 1× p 0  (4)
 
 r 0 =r 0 −t 1  (5)
 
     The OS  310  then (b) determined whether the following inequality is satisfied.
 
 pst _high&lt; pst _low  (6)
 
     When determining that the above inequality (6) is satisfied, the OS  310  selects a thread of which the standby power consumption per unit time is the greatest among the assigned threads satisfying “r0&lt;(t2  . . .  tn)”, as a thread to be executed after the preceding thread and before the subject thread. 
     The OS  310  repeats the processes (a) and (b) to determine order of execution of threads in the case of assigning the subject thread to the subject CPU. When determining the order of execution in the case of assigning the subject thread to the subject CPU, the OS  310  selects, as the subject CPU, a CPU yet unselected as a subject CPU from among CPUs to which no high-priority thread is assigned. The OS  310  then determines the order of execution of threads in a case of assigning the subject thread to the selected subject CPU. 
     Among the CPUs to which no high-priority thread is assigned, the OS  310  determines a CPU having the greatest ptotal value among ptotal values calculated for individual CPUs to be an assignment destination CPU to which the subject thread is to be assigned. The OS  310  then reports the determined order of execution to the assignment destination CPU, and the assignment destination CPU executes threads assigned thereto, based on the reported order of execution. 
     Detailed description will be made using specific numerical values. 
       FIG. 7  is an explanatory diagram of an example of detection of the generation of the thread #0. (1) When detecting the generation of the thread #0, the OS  310  determines whether the priority level of the thread #0 is high, based on identification information of the thread #0 in the thread table  400 . In this example, the priority level of the thread #0 is determined to be high. The OS  310  then (2) identifies a CPU to which no high-priority thread is assigned among CPUs making up the multi-core processor system, based on the assignment management table  500 . In this example, the CPUs #0 and #1 are identified as such CPUs. The OS  310  selects, as a subject CPU, the CPU #0 among the CPUs #0 and #1. 
     
       
         
           
             
               
                 
                   
                     r 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     0 
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #0 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       deadline 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       for 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       thread 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       #0 
                     
                     - 
                     
                       execution 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       period 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       of 
                     
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       10 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     - 
                     
                       5 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     5 
                     ⁢ 
                     
                         
                     
                     [ 
                     ms 
                     ] 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     pst_high 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #0 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     r 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     0 
                     × 
                     standby 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     power 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     consumption 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     per 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     unit 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     time 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       #0 
                       ⁢ 
                       
                           
                       
                       [ 
                       
                         mW 
                         ⁢ 
                         
                           / 
                         
                         ⁢ 
                         ms 
                       
                       ] 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       5 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     × 
                     
                       100 
                       ⁢ 
                       
                           
                       
                       [ 
                       
                         mW 
                         ⁢ 
                         
                           / 
                         
                         ⁢ 
                         ms 
                       
                       ] 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     500 
                     ⁢ 
                     
                         
                     
                     [ 
                     mW 
                     ] 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     pst_low 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #0 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     execution 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     period 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                     × 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     ( 
                     
                       
                         standby 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         power 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         consumption 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         per 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         unit 
                         ⁢ 
                         
                            
                         
                         ⁢ 
                         time 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         of 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         thread 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #1 
                       
                       + 
                       
                         standby 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         power 
                         ⁢ 
                         
                            
                         
                         ⁢ 
                         consumption 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         per 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         unit 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         time 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         of 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         thread 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #3 
                       
                     
                     ) 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       5 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     × 
                     
                       ( 
                       
                         
                           100 
                           ⁢ 
                           
                               
                           
                           [ 
                           
                             mW 
                             ⁢ 
                             
                               / 
                             
                             ⁢ 
                             ms 
                           
                           ] 
                         
                         + 
                         
                           80 
                           ⁢ 
                           
                               
                           
                           [ 
                           
                             mW 
                             ⁢ 
                             
                               / 
                             
                             ⁢ 
                             ms 
                           
                           ] 
                         
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     900 
                     ⁢ 
                     
                         
                     
                     [ 
                     ms 
                     ] 
                   
                 
               
             
           
         
       
     
     The OS  310  substitutes calculated values from the above equations in the inequality (1) and determines whether the inequality (1) is satisfied.
 
5 [ms] ( r 0(CPU #0))&gt;(3 [ms] (execution period of thread #1) 2 [ms] (execution period of thread #3) 500 [mW]( pst _high (CPU #0))&lt;900 [ms] ( pst _low (CPU #0))
 
     When determining that the inequality (1) is satisfied, the OS  310  identifies a thread of which the standby power consumption per unit time is the greatest among the standby power consumption per unit time of assigned threads satisfying “r0 (CPU #0)&gt;(3 [ms] (execution period of thread #1) 2 [ms] (execution period of thread #3))”. The OS  310  then selects the identified thread as a thread to be executed before the thread #0. The OS  310  outputs the result of the selection to a memory area, such as the shared memory  302 , as execution sequence information. 
     Execution Order Information of CPU #0: Thread #1 
     The OS  310  performs calculations expressed as the equations (2) to (5). 
     
       
         
           
             
               
                 
                   
                     ptotal 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #0 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       ptotal 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         ( 
                         
                           CPU 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           #0 
                         
                         ) 
                       
                     
                     + 
                     
                       execution 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       period 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       of 
                     
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     1 
                     × 
                     standby 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     power 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     consumption 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     per 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     unit 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     time 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     0 
                     + 
                     
                       
                         3 
                         ⁢ 
                         
                             
                         
                         [ 
                         ms 
                         ] 
                       
                       × 
                       
                         100 
                         ⁢ 
                         
                             
                         
                         [ 
                         
                           mW 
                           ⁢ 
                           
                             / 
                           
                           ⁢ 
                           ms 
                         
                         ] 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     300 
                     ⁢ 
                     
                         
                     
                     [ 
                     mW 
                     ] 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       pst_high 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         ( 
                         
                           CPU 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           #0 
                         
                         ) 
                       
                     
                     = 
                       
                     ⁢ 
                     
                       
                         pst_high 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ( 
                           
                             CPU 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             #0 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                           
                       
                       - 
                       
                         execution 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         period 
                       
                     
                   
                   ⁢ 
                   
                       
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #1 
                     × 
                     standby 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     power 
                   
                   ⁢ 
                   
                       
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     consumption 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     per 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     unit 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     time 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       500 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     - 
                     
                       
                         3 
                         ⁢ 
                         
                             
                         
                         [ 
                         ms 
                         ] 
                       
                       × 
                       
                         100 
                         ⁢ 
                         
                             
                         
                         [ 
                         
                           mW 
                           ⁢ 
                           
                             / 
                           
                           ⁢ 
                           ms 
                         
                         ] 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     200 
                     ⁢ 
                     
                         
                     
                     [ 
                     mW 
                     ] 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     pst_low 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #0 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       pst_low 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         ( 
                         
                           CPU 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           #0 
                         
                         ) 
                       
                     
                     ⁢ 
                     
                         
                     
                     - 
                     
                       execution 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       period 
                     
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #1 
                     × 
                     standby 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     power 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     consumption 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     per 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     unit 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     time 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       900 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     - 
                     
                       
                         3 
                         ⁢ 
                         
                             
                         
                         [ 
                         ms 
                         ] 
                       
                       × 
                       
                         100 
                         ⁢ 
                         
                             
                         
                         [ 
                         
                           mW 
                           ⁢ 
                           
                             / 
                           
                           ⁢ 
                           ms 
                         
                         ] 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     600 
                     ⁢ 
                     
                         
                     
                     [ 
                     mW 
                     ] 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     r 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     0 
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #0 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       r 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       0 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         ( 
                         
                           CPU 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           #0 
                         
                         ) 
                       
                     
                     - 
                     
                       execution 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       period 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       of 
                     
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #1 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       5 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     - 
                     
                       3 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     2 
                     ⁢ 
                     
                         
                     
                     [ 
                     ms 
                     ] 
                   
                 
               
             
           
         
       
     
     The OS  310  then determines whether the inequality (6) is satisfied.
 
200 [mW]&lt;600 [mW]
 
     When determining that the inequality (6) is satisfied, the OS  310  selects a thread of which the standby power consumption per unit time is the greatest among the standby power consumption per unit time of assigned threads satisfying “r0 (CPU #0)&lt;(execution period of thread #3)”, as a thread to be executed after the preceding thread and before the subject thread. The OS  310  adds the result of the selection to the above execution sequence information of the CPU #0. 
     Execution Order Information of CPU #0: Thread #1→Thread #3 
     The OS  310  then performs the calculation expressed as equation (2). 
     
       
         
           
             
               
                 
                   
                     ptotal 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #0 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       ptotal 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         ( 
                         
                           CPU 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           #0 
                         
                         ) 
                       
                     
                     + 
                     
                       execution 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       period 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       of 
                     
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #3 
                     × 
                     standby 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     power 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     consumption 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     per 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     unit 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     time 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       300 
                       ⁢ 
                       
                           
                       
                       [ 
                       mW 
                       ] 
                     
                     + 
                     
                       
                         2 
                         ⁢ 
                         
                             
                         
                         [ 
                         ms 
                         ] 
                       
                       × 
                       
                         100 
                         ⁢ 
                         
                             
                         
                         [ 
                         
                           mW 
                           ⁢ 
                           
                             / 
                           
                           ⁢ 
                           ms 
                         
                         ] 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     500 
                     ⁢ 
                     
                         
                     
                     [ 
                     mW 
                     ] 
                   
                 
               
             
           
         
       
     
     Because the threads #1 and #3 are all the threads already assigned to the CPU #0, the thread #0 is added to the execution sequence information of CPU #0. 
     Execution Order Information of CPU #0: Thread #1→Thread #3→Thread #0 
     Subsequently, the OS  310  selects the CPU #1 as a subject CPU, among the CPUs #0 and #1. 
     
       
         
           
             
               
                 
                   
                     r 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     0 
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #0 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       deadline 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       for 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       thread 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       #0 
                     
                     - 
                     
                       execution 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       period 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       of 
                     
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       10 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     - 
                     
                       5 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     5 
                     ⁢ 
                     
                         
                     
                     [ 
                     ms 
                     ] 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     pst_high 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #1 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     r 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     0 
                     × 
                     standby 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     power 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     consumption 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     per 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     unit 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     time 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       #0 
                       ⁢ 
                       
                           
                       
                       [ 
                       
                         mW 
                         ⁢ 
                         
                           / 
                         
                         ⁢ 
                         ms 
                       
                       ] 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       5 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     × 
                     
                       100 
                       ⁢ 
                       
                           
                       
                       [ 
                       
                         mW 
                         ⁢ 
                         
                           / 
                         
                         ⁢ 
                         ms 
                       
                       ] 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     500 
                     ⁢ 
                     
                         
                     
                     [ 
                     mW 
                     ] 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     pst_low 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #1 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     execution 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     period 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                     × 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     ( 
                     
                       
                         standby 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         power 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         consumption 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         per 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         unit 
                         ⁢ 
                         
                            
                         
                         ⁢ 
                         time 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         of 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         thread 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #2 
                       
                       + 
                       
                         standby 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         power 
                         ⁢ 
                         
                            
                         
                         ⁢ 
                         consumption 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         per 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         unit 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         time 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         of 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         thread 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #4 
                       
                     
                     ) 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       5 
                       ⁢ 
                       
                           
                       
                       [ 
                       ms 
                       ] 
                     
                     × 
                     
                       ( 
                       
                         
                           50 
                           ⁢ 
                           
                               
                           
                           [ 
                           
                             mW 
                             ⁢ 
                             
                               / 
                             
                             ⁢ 
                             ms 
                           
                           ] 
                         
                         + 
                         
                           70 
                           ⁢ 
                           
                               
                           
                           [ 
                           
                             mW 
                             ⁢ 
                             
                               / 
                             
                             ⁢ 
                             ms 
                           
                           ] 
                         
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     600 
                     ⁢ 
                     
                         
                     
                     [ 
                     ms 
                     ] 
                   
                 
               
             
           
         
       
     
     The OS  310  substitutes calculated values from the above equations into the inequality (1) and determines whether the inequality (1) is satisfied.
 
5 [ms] ( r 0(CPU #1))&gt;(4 [ms] (execution period of thread #2) 5 [ms] (execution period of thread #4) 500 [mW] ( pst _high (CPU #1))&lt;600 [ms] ( pst _low (CPU #1))
 
     When determining that the inequality (1) is satisfied, the OS  310  identifies a thread of which the standby power consumption per unit time is the greatest among the standby power consumption per unit time of assigned threads satisfying “r0 (CPU #1)&gt;(4 [ms] (execution period of thread #2))”. The OS  310  then selects the identified thread as a thread to be executed before the thread #0. The OS  310  outputs the result of the selection to the memory area, such as the shared memory  302 , as execution sequence information. 
     Execution Order Information of CPU #1: Thread #2 
     The OS  310  then performs the calculation expressed by equation (2). 
     
       
         
           
             
               
                 
                   
                     ptotal 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ( 
                       
                         CPU 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         #1 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       ptotal 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         ( 
                         
                           CPU 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           #1 
                         
                         ) 
                       
                     
                     + 
                     
                       execution 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       period 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       of 
                     
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     thread 
                     ⁢ 
                     
                       
                           
                       
                       ⁢ 
                       
                           
                       
                     
                     ⁢ 
                     2 
                     × 
                     standby 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     power 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     consumption 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     per 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     unit 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     time 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     thread 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     #0 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     0 
                     + 
                     
                       
                         4 
                         ⁢ 
                         
                             
                         
                         [ 
                         ms 
                         ] 
                       
                       × 
                       
                         100 
                         ⁢ 
                         
                             
                         
                         [ 
                         
                           mW 
                           ⁢ 
                           
                             / 
                           
                           ⁢ 
                           ms 
                         
                         ] 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     400 
                     ⁢ 
                     
                         
                     
                     [ 
                     mW 
                     ] 
                   
                 
               
             
           
         
       
     
     Because a thread for which an execution period is less than r0 (CPU #1) is the thread #2 only, the thread #0 is added to the execution sequence information of the CPU #1 and the thread #4 is also added to the information. 
     Execution Order Information of CPU #1: Thread #2→Thread 0→Thread #4 
     The OS  310  then determines one of the CPUs #0 and #1 that has the greater ptotal value to be an assignment destination CPU for the thread #0. ptotal (CPU #0) is calculated to be 500 [mW] while ptotal (CPU #1) is calculated to be 400 [mW]. Hence, the CPU #0 is determined to be the assignment destination CPU for the thread #0. 
       FIG. 8  is an explanatory diagram of an example of updating of the assignment management table  500 . The OS  310  enters “CPU #0” and “thread #0” into the CPU identification information field  501  and the assigned thread identification information field  503  in the assignment management table  500 , respectively. The OS  310  enters “exe” into the execution status field  504  for the thread #1, and for the threads #3 and #0, enters “proh”. The OS  310  then starts executing the thread #1. 
       FIGS. 9, 10, and 11  are flowcharts of an information processing procedure by the information processing apparatus  300 . The master OS  310  executes the procedure. The OS  310  determines whether the generation of a thread has been detected (step S 901 ). If no generation of a thread has been detected (step S 901 : NO), the OS  301  returns to step S 901 . If the generation of a thread has been detected (step S 901 : YES), the OS  301  determines whether the generated thread (subject thread) is a high-priority thread (step S 902 ). 
     If the subject thread is a high-priority thread (step S 902 : YES), the OS  310  identifies a CPU not locked for an assigned high-priority thread (step  903 ). The OS  310  thus determines whether a CPU not locked for an assigned high-priority thread has been identified (step  904 ). 
     If a CPU not locked for an assigned high-priority thread has been identified (step  904 : YES), the OS  310  determines whether an unselected CPU is present among CPUs not locked (step S 905 ). 
     If an unselected CPU is present (step S 905 : YES), the OS  310  selects, as a subject CPU, an arbitrary CPU from among unselected CPUs (step S 906 ). The OS  310  then executes an execution sequence determining process (step S 907 ), correlates and outputs identification information, execution sequence information, and ptotal of the subject CPU (step S 908 ), and returns to step S 905 . 
     If the subject thread is not a high-priority thread (step S 902 : NO), the OS  310  identifies a CPU with the least load (step S 909 ). The OS  310  determines the CPU identified to have the least load to be the assignment destination CPU for the subject thread (step S 910 ), and returns to step S 901 . 
     If no CPU not locked for an assigned high-priority thread is identified (step  904 : NO), the OS  310  determines whether an unselected CPU is present ( FIG. 10 , step S 911 ). If an unselected CPU is present (step S 911 : YES), the OS  310  selects an arbitrary CPU from among unselected CPUs (step S 912 ). 
     The OS  310  extracts threads from execution sequence information of the selected CPU (step S 913 ), and calculates the total execution period for the extracted threads (step S 914 ). The OS  310  determines whether “total execution period for extracted threads&lt;deadline for subject thread (d0)−execution period for subject thread (t0)” is satisfied (step S 915 ). 
     If “total of execution periods for extracted threads&lt;d0−t0” is satisfied (step S 915 : YES), the OS  310  determines the subject CPU to be a CPU that can meet d0 (step S 916 ), and returns to step S 911 . If “total of execution periods for extracted threads&lt;d0−t0” is not satisfied (step S 915 : NO), the OS  310  returns to step S 911 . 
     If no unselected CPU is present (step S 911 : NO), the OS  310  determines whether a CPU that can meet d0 is present (step S 917 ). If a CPU that can meet d0 is present (step S 917 : YES), the OS  310  determines whether an unselected CPU is present among CPUs that can meet d0 (step S 918 ). 
     If an unselected CPU is present among the CPUs that can meet d0 (step S 918 : YES), The OS  310  selects, as a subject CPU, an arbitrary CPU from among unselected CPUs (step S 919 ). The OS  310  then executes the execution sequence determining process (step S 920 ), correlates and outputs identification information, execution sequence information, and ptotal of the subject CPU (step S 921 ), and returns to step S 905 . 
     At step S 918 , if no unselected CPU is present among the CPUs that can meet d0 (step S 918 : NO), the OS  310  identifies a CPU with the greatest ptotal value among the CPUs that can meet d0 (step S 922 ). The OS  310  reports execution sequence information of the identified CPU to the identified CPU (step S 923 ), determines the identified CPU to be the assignment destination CPU for the subject thread (step S 924 ), and returns to step S 901 . 
     If no CPU that can meet d0 is present (step S 917 : NO), the OS  310  identifies a thread for which the execution period is the shortest among high-priority threads assigned to each CPU (step S 925 ). The OS  310  then determines an assignment destination CPU for the identified thread to be the assignment destination CPU for the subject thread (step S 926 ), sends an execution sequence information discarding instruction to the assignment destination CPU for the subject thread (step S 927 ), and returns to step S 901 . 
     At step S 905 , if no unselected CPU is present (step S 905 : NO), the OS  310  identifies a CPU with the greatest ptotal value among the unlocked CPUs (step S 928 ). The OS  310  then reports execution sequence information of the identified CPU to the identified CPU (step S 929 ), determines the assignment destination CPU for the subject thread to be the identified CPU (step S 930 ), and returns to step S 901 . 
       FIGS. 12 and 13  are flowcharts of a detailed procedure of the execution sequence determining process (step S 907 ) in  FIG. 9 . When the execution sequence determining process is the process of step S 907  or step S 920 , the OS  310  executes the process. However, when the execution sequence determining process is a process of step S 1511  ( FIG. 15 ), each OS executes the process. The OS performs a calculation expressed as “r0=deadline for subject thread (d0)−execution period for subject thread (t0)” (step S 1201 ), and performs a calculation expressed as “pst_high=r0×standby power consumption per unit time of subject thread (p0)” (step S 1202 ). 
     The OS then sets ptotal=0 (step S 1203 ), sets m=1 (step S 1204 ), and identifies an assigned CPU as a subject CPU (step  1205 ). The OS identifies a thread for which an execution period is smaller than r0 among identified assigned threads (step S 1206 ). The OS thus determines whether a thread for which an execution period is smaller than r0 has been identified ( FIG. 13 , step S 1207 ). 
     If a thread for which an execution period is smaller than r0 has been identified (step S 1207 : YES), the OS calculates the total standby power consumption of the assigned threads (psum) (step S 1208 ). The OS performs a calculation expressed as “pst_low=psum×t0” (step S 1209 ), and determines whether “pst_high&gt;pst_low” is satisfied (step S 1210 ). 
     If “pst_high&gt;pst_low” is satisfied (step S 1210 : YES), the OS determines whether an unselected thread is present among threads for which execution periods are each smaller than r0 (step S 1211 ). If an unselected thread is present (step S 1211 : YES), the OS selects a thread of which the standby power consumption per unit time is the greatest among unselected threads (step S 1212 ). 
     The OS then correlates identification information and the value of m of the selected thread and adds the identification information and value of m to execution sequence information (step S 1213 ). The OS performs a calculation expressed as “ptotal=ptotal+t0×standby power consumption per unit time of selected thread” (step S 1214 ) and performs a calculation expressed as “pst_low=pst_low−t0×standby power consumption per unit time of selected thread” (step S 1215 ). 
     The OS performs a calculation expressed as “pst_high=pst_high-execution period for selected thread×p0” (step S 1216 ), sets m=m+1 (step S 1217 ), and returns to step S 1211 . 
     At step S 1207 , if no thread for which an execution period is smaller than r0 is identified (step S 1207 : NO), the OS correlates identification information and the value of m of the subject thread, adds the identification information and value of m to execution sequence information (step S 1218 ), and proceeds to step S 908 . 
     At step S 1210 , if “pst_high&gt;pst_low” is not satisfied (step S 1210 : NO), the OS proceeds to step S 1218 . 
     At step S 1211 , if no unselected thread is present (step S 1211 : NO), the OS proceeds to step S 1218 . 
       FIG. 14  is a flowchart of an information processing procedure executed by each OS when a thread is assigned. The OS determines if a report of execution sequence information or an execution sequence information discarding instruction has been received, or if assignment of a thread has been detected (step S 1401 ). If no report of execution sequence information or an execution sequence information discarding instruction has been received, or if an assignment of a thread is not detected (step S 1401 : NO), the OS returns to step S 1401 . 
     If a report of execution sequence information has been received (step S 1401 : REPORT OF EXECUTION ORDER INFORMATION), the OS discards saved execution sequence information and newly saves the received execution sequence information (step S 1402 ). 
     If assignment of a thread has been detected (step S 1401 : ASSIGNMENT OF THREAD), the OS determines whether the detected assigned thread is a high-priority thread (step S 1403 ). If the detected assigned thread is a high-priority thread (step S 1403 : YES), the OS locks a CPU for the assigned high-priority thread (step S 1404 ). 
     The OS then sets the execution status of the head thread in execution sequence information to “exe” (step S 1405 ) and sets the execution statuses of assigned threads other than the head thread in the execution sequence information to “proh” (step S 1406 ). The OS then starts executing the head thread in the execution sequence information (step S 1407 ), and returns to step S 1401 . 
     At step S 1403 , if the detected assigned thread is not a high-priority thread (step S 1403 : NO), the OS determines whether the CPU is locked for an assigned high-priority thread (step S 1408 ). If the CPU is locked for an assigned high-priority thread (step S 1408 : YES), the OS determines whether the detected assigned thread is the head thread in the execution sequence information (step S 1409 ). 
     If the detected assigned thread is not the head thread in the execution sequence information (step S 1409 : NO), the OS sets the execution status of the detected thread to “proh” (step S 1410 ), and returns to step S 1401 . If the detected assigned thread is the head thread in the execution sequence information (step S 1409 : YES), the OS sets the execution status of the detected thread to “exe” (step S 1411 ), and returns to step S 1401 . 
     At step S 1408 , if the CPU is not locked for an assigned high-priority thread (step S 1408 : NO), the OS adds a thread detected at the tail of a run queue to the execution sequence information (step S 1412 ), and returns to step S 1401 . 
     At step S 1401 , if an execution sequence information discarding instruction has been received (step S 1401 : EXECUTION ORDER INFORMATION DISCARDING INSTRUCTION), the OS discards saved execution sequence information (step S 1413 ). The OS then starts executing a thread assigned first among assigned high-priority threads (step S 1414 ), and returns to step S 1401 . 
       FIG. 15  is a flowchart of an information processing procedure executed by each OS when a thread is completed. The OS determines whether the end or switching of a thread has been detected (step S 1501 ). If the end or switching of a thread has not been detected (step S 1501 : NO), the OS returns to step S 1501 . 
     If the end of a thread has been detected (step S 1501 : END OF THREAD), the OS determines whether the thread that has ended is a high-priority thread (step S 1502 ). If the thread is not a high-priority thread (step S 1502 : NO), the OS determines whether a CPU is locked for an assigned high-priority thread (step S 1503 ). 
     If the CPU is locked for an assigned high-priority thread (step S 1503 : YES), the OS progresses to step S 1509 . If the CPU is not locked for an assigned high-priority thread (step S 1503 : NO), the OS progresses to step S 1505 . 
     If the thread that has ended is a high-priority thread (step S 1502 : YES), the OS determines whether a high-priority thread other than the thread that has ended is present among assigned threads (step S 1504 ). If no high-priority thread other than the thread that has ended is present among the assigned threads (step S 1504 : NO), the OS releases the CPU from the locked state for an assigned high-priority thread (S 1505 ). 
     The OS then sets execution statuses of all the assigned threads to “exe” (step S 1506 ), starts executing the thread assigned first among the assigned threads (step S 1507 ), and returns to step S 1501 . 
     At step S 1504 , if a high-priority thread other than the ended thread is present among the assigned threads (step S 1504 : YES), the OS determines that whether an unselected thread is present among execution sequence information (step S 1508 ). If an unselected thread is present among the execution sequence information (step S 1508 : YES), the OS sets the execution status of the head thread of unselected threads in the execution sequence information to “exe” (step S 1509 ). 
     The OS starts executing the head thread (step S 1510 ), and returns to step S 1501 . If no unselected thread is present among the execution sequence information (step S 1508 : NO), the OS executes the execution sequence determining process (step S 1511 ), and returns to step S 1501 . 
     As described above, according to the information processing apparatus, the information processing program, and the information processing method, when the first and second threads are unexecuted, the order of execution of the threads is determined by comparing the standby power consumption of the first thread and that of the second thread. As a result, lower power consumption is achieved without thread switching. 
     If the standby power consumption of the first thread is greater than or equal to the standby power consumption of the second thread, the first thread is executed first and then the second thread is executed. In this manner, by first executing a thread having greater standby power consumption, lower power consumption is achieved. 
     If the standby power consumption of the first thread is less than the standby power consumption of the second thread, the second thread is executed first and then the first thread is executed. In this manner, by executing a thread consuming greater standby power consumption first, lower power consumption is achieved. 
     If an execution deadline is defined for the first thread, whether the first thread can meet the execution deadline if the second thread is executed before execution of the first thread is determined. If the first thread can meet the execution deadline even if the second thread is executed before execution of the first thread, the order of execution is determined based on the standby power consumption of the first thread and the standby power consumption of the second thread. Through this procedure, lower power consumption is achieved even when a thread with an execution deadline is executed. 
     If the first thread cannot meet the execution deadline if the second thread is executed before execution of the first thread, the order of execution is determined to be execution of the first thread followed by the second thread. This prevents a decline in throughput of the first thread. 
     All examples and conditional language provided herein are intended for pedagogical purposes of aiding the reader in understanding the invention and the concepts contributed by the inventor to further the art, and are not to be construed as limitations to such specifically recited examples and conditions, nor does the organization of such examples in the specification relate to a showing of the superiority and inferiority of the invention. Although one or more embodiments of the present invention have been described in detail, it should be understood that the various changes, substitutions, and alterations could be made hereto without departing from the spirit and scope of the invention.