JP5692341B2 - Multiprocessor system, control method, and control program - Google Patents

Description

  The present invention relates to a multiprocessor system, a control method, and a control program.

  Conventionally, when a plurality of threads are assigned to each CPU of a single core processor system or a multi-core processor system, for example, a technique (first conventional technique) that determines an execution order based on a priority defined for each thread is known. (For example, refer to Patent Document 1 below.)

  In addition, when a plurality of threads are assigned, a technique (second conventional technique) is known in which each thread of a plurality of threads is sequentially executed for a predetermined time using a round robin method (for example, Patent Document 2 below). And non-patent document 1 below).

JP-A-63-068934 JP 2000-276360 A

C. L. Liu, 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

  However, the first conventional technique has a problem that power consumption increases when standby power of a thread having a low priority among a plurality of threads is large. Further, in the second prior art, threads are switched at regular intervals, so that the caches in the CPU that temporarily store the execution information of each thread compete.

  For example, while one thread is being executed by the CPU, execution information of the one thread is stored in the cache, but when one thread is switched to another thread, the execution of one thread in the cache is executed. Information is rewritten with execution information of other threads. Next, when the execution of one thread is switched from another thread, the execution information of the other thread in the cache must be rewritten with the execution information of the one thread, so that the execution performance deteriorates and the throughput decreases. There was a problem.

  An object of the present invention is to provide a multiprocessor system, a control method, and a control program capable of reducing power consumption without reducing the throughput in order to solve the above-described problems caused by the prior art.

  According to an aspect of the present invention, an unexecuted first thread and an unexecuted second thread are detected, the detected execution time of the second thread and the detected unit time of the first thread The standby power of the first thread when the first thread is executed next to the second thread is calculated by multiplying by the standby power per hit, and the execution time of the first thread Is multiplied by the standby power per unit time of the second thread to calculate the standby power of the second thread when the second thread is executed next to the first thread. The calculated standby power of the first thread is compared with the calculated standby power of the second thread, and the execution order of the first thread and the second thread is determined based on the comparison result. Multiprocessor system Temu, control method, and control program are provided.

  According to the present multiprocessor system, control method, and control program, there is an effect that low power consumption can be achieved without lowering the throughput.

It is explanatory drawing which shows one Example of this invention. It is explanatory drawing when the execution time limit is defined in the 1st thread | sled. It is a block diagram which shows the hardware of information processing apparatus. It is explanatory drawing which shows an example of the thread table. It is explanatory drawing which shows an example of the allocation management table 500. FIG. 3 is a functional block diagram of an information processing apparatus 300. FIG. It is explanatory drawing which shows the example in which the production | generation of thread | sled # 0 is detected. It is explanatory drawing which shows the example of an update of the allocation management table 500. 6 is a flowchart (part 1) illustrating an information processing procedure by the information processing apparatus 300; 6 is a flowchart (part 2) illustrating an information processing procedure by the information processing apparatus 300; 6 is a flowchart (part 3) illustrating an information processing procedure by the information processing apparatus 300; FIG. 10 is a flowchart (part 1) illustrating a detailed processing procedure of execution order determination processing (step S907) illustrated in FIG. 9; FIG. 10 is a flowchart (part 2) illustrating a detailed processing procedure of the execution order determination process (step S907) illustrated in FIG. 9; It is a flowchart which shows the information processing procedure at the time of the thread | sled allocation by each OS. It is a flowchart which shows the information processing procedure at the time of the thread | end end by each OS.

  Exemplary embodiments of a multiprocessor system, a control method, and a control program according to the present invention will be explained below in detail with reference to the accompanying drawings.

  FIG. 1 is an explanatory view showing an embodiment of the present invention. Here, a description will be given by taking an unexecuted first thread and an unexecuted second thread as examples. In FIG. 1, before execution of the first thread and the second thread, the standby power is calculated for each combination of execution order, and the execution order is determined based on the calculation result.

First, (1) when the execution order is the order of the second thread → the first thread, the first thread is in a standby state during the execution of the second thread. Therefore, the standby power of the first thread is as follows.
Standby power of the first thread = second thread execution time [ms] × standby power per unit time of the first thread [mW / ms]

Next, (2) when the execution order is the order of the first thread → the second thread, the second thread is in a standby state during the execution of the first thread. Therefore, the standby power of the second thread is as follows.
Standby power of the second thread = first thread execution time [ms] × second thread standby power per unit time [mW / ms]

  Then, the information processing apparatus compares the standby power of the first thread with the standby power of the second thread. If the standby power of the first thread is equal to or higher than the standby power of the second thread, the information processing apparatus determines the execution order from the first thread to the second thread. If the standby power of the first thread is less than the standby power of the second thread, the information processing apparatus determines the execution order from the second thread to the first thread.

  FIG. 2 is an explanatory diagram when an execution time limit is defined for the first thread. FIG. 2 illustrates an example in which an execution time limit is defined for the first thread and an execution time limit is not defined for the second thread. Here, the execution time limit defined for the first thread indicates that the time from the generation time of the first thread to the execution time limit of the first thread is defined.

When the time (d) from the generation time of the first thread to the execution deadline of the first thread is defined, the first thread is set when the execution order is the first thread next to the second thread. It is determined whether or not the execution deadline of the thread can be observed. That is, it is determined whether or not the following is true.
D-execution time of the first thread> execution time of the second thread

  If d-first thread execution time> second thread execution time as shown in FIG. 2, as described above with reference to FIG. 1, the information processing apparatus waits for each combination of execution order. And the execution order is determined. On the other hand, if d-execution time of the first thread ≤ execution time of the second thread, if the execution order is the second thread-> first thread, the execution deadline of the first thread cannot be observed, The information processing apparatus determines the execution order from the first thread to the second thread.

  In the present embodiment, a multi-core processor system will be described as an example of the information processing apparatus. Here, in the multi-core processor system, the multi-core processor is a processor in which a plurality of cores are mounted. If a plurality of cores are mounted, a single processor having a plurality of cores may be used, or a processor group in which single core processors are arranged in parallel may be used. In the present embodiment, in order to simplify the explanation, a processor group in which single-core processors are arranged in parallel will be described as an example.

(Information processing equipment hardware)
FIG. 3 is a block diagram illustrating hardware of the information processing apparatus. In FIG. 3, the information processing apparatus 300 includes a CPU # 0, a CPU # 1, and a shared memory 302. CPU # 0, CPU # 1, and shared memory 302 are connected to each other via 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. CPU # 0 executes OS 310 and controls the entire information processing apparatus. The OS 310 is a master OS, has a function of controlling which CPU the thread is assigned to, and executes the thread assigned to the CPU # 0. CPU # 1 executes the OS 311. The OS 311 is a slave OS and executes a thread assigned to the CPU # 1.

  Specifically, the shared memory 302 includes, for example, a ROM (Read Only Memory), a RAM (Random Access Memory), a flash ROM, and the like. For example, a flash ROM stores a boot program, a ROM stores application software, and a RAM is used as a work area for CPU # 0 to CPU # 1. The program stored in the shared memory 302 is loaded on each CPU, thereby causing each CPU to execute a coded process. The shared memory 302 stores, for example, a thread table 400 and an allocation management table 500.

  FIG. 4 is an explanatory diagram showing an example of the thread table 400. The thread table 400 includes a thread identification information item 401, a priority item 402, a deadline item, an execution time item 404, and a standby power item 405. The thread identification information item 401 holds identification information of each thread. The priority item 402 holds information indicating whether the priority of each thread whose identification information is held in the thread identification information item 401 is high. When the priority is high, the high priority is held, and when the priority is not high, the low priority is held.

  The deadline item 403 holds the time from the generation time when the thread is generated to the execution deadline of the thread (herein referred to as “deadline”). The execution time item 404 holds the execution time of each thread whose identification information is held in the thread identification information item 401. In the standby power item 405, a value of standby power per unit time of each thread whose identification information is stored in the thread identification information item 401 is stored.

  Taking thread # 0 as an example, thread # 0 is a high-priority thread and the deadline is 10 [ms]. The execution time of the thread # 0 is 5 [ms], and the standby power per unit time is 100 [mW / ms].

  FIG. 5 is an explanatory diagram showing an example of the allocation management table 500. The allocation management table 500 includes a CPU identification information item 501, a LOCK item 502, an allocated thread identification information item 503, and an execution state item 504. The CPU identification information item 501 holds CPU identification information.

  The LOCK item 502 holds information indicating whether or not the CPU in which the identification information is held in the CPU identification information item 501 is LOCKed. Whether or not LOCK is set indicates whether or not a high priority thread is assigned to the CPU. If no high-priority thread is assigned to the CPU, 0 is registered in the LOCK item 502, and if a high-priority thread is assigned to the CPU, 1 is registered in the LOCK item 502. .

  In the assigned thread identification information item 503, the identification information of the thread assigned to the CPU whose identification information is held in the CPU identification information item 501 is registered. The execution state item 504 registers the execution state of the thread whose identification information is registered in the identification information item 503 of the assigned thread. Either exe (execution) or proh (prohibit) is registered as the execution state. exe indicates that the thread is in an executable state, and proh indicates that the thread is in an execution prohibited state.

  Here, each OS specifies that thread # 1 and thread # 3 are assigned to CPU # 0 and thread # 2 and thread # 4 are assigned to CPU # 1 by assignment management table 500 it can. In addition, since the identification information of the allocated threads of each CPU is registered in the order of allocation, each OS specifies the allocation order by sequentially accessing the identification information of the allocated threads in the allocation management table 500. Can do.

(Functional block diagram of information processing apparatus 300)
FIG. 6 is a functional block diagram of the information processing apparatus 300. The information processing apparatus 300 includes a detection unit 601, a difference calculation unit 602, a determination unit 603, a first calculation unit 604, a second calculation unit 605, a comparison unit 606, and a determination unit 607. doing. Specifically, for example, the CPU # 0 loads an information processing program stored in the shared memory 302 and having the functions of the detection unit 601 to the determination unit 607. And the function of the detection part 601-the determination part 607 is implement | achieved by performing the process coded by this information processing program which CPU # 0 loaded.

  The detection unit 601 detects an unexecuted first thread and an unexecuted second thread.

  The first calculation unit 604 multiplies the execution time of the second thread detected by the detection unit 601 and the standby power per unit time of the first thread detected by the detection unit 601. Thereby, the first calculation unit 604 calculates standby power of the first thread when the first thread is executed next to the second thread.

  When the second thread is executed next to the first thread, the second calculation unit 605 multiplies the execution time of the first thread by the standby power per unit time of the second thread. The standby power of the second thread is calculated.

  The comparison unit 606 compares the standby power of the first thread calculated by the first calculation unit 604 with the standby power of the second thread calculated by the second calculation unit 605.

  The comparison unit 607 determines the execution order of the first thread and the second thread based on the comparison result compared by the comparison unit 606.

  In addition, when the comparison unit 606 compares the standby power of the first thread to be equal to or higher than the standby power of the second thread, the determination unit 607 sets the execution order to the second thread next to the first thread. To do.

  Further, when the comparison unit 606 compares the standby power of the first thread with less than the standby power of the second thread, the determination unit 607 changes the execution order to the first thread next to the second thread. To do.

  When the execution time limit is defined for the first thread detected by the detection unit 601, the difference calculation unit 602 includes the time from the generation time of the first thread to the execution time limit, the execution time of the first thread, The difference time is calculated.

  The determination unit 603 determines whether or not the difference time calculated by the difference calculation unit 602 is greater than the execution time of the second thread.

  When the determination unit 603 determines that the difference time is greater than the execution time of the second thread, the first calculation unit 604 determines the execution time of the second thread and the standby power per unit time of the first thread. The standby power of the first thread is calculated by multiplying.

  When the determination unit 603 determines that the difference time is greater than the execution time of the second thread, the second calculation unit 605 determines the execution time of the first thread and the standby power per unit time of the second thread. The standby power of the second thread is calculated by multiplying.

  When the determination unit 603 determines that the difference time is equal to or less than the execution time of the second thread, the determination unit 607 sets the execution order to the second thread next to the first thread.

  This will be described in detail based on the above. In the present embodiment, an example of determining the execution order of a low priority thread and a high priority thread when a high priority thread is generated will be described. In this embodiment, CPUs to which only low-priority threads are assigned are executed in the assigned order.

  In this embodiment, the execution order is determined for each CPU to which a high priority is not assigned, and a high priority thread (target thread) generated is assigned to a CPU that can reduce the standby power most.

  Here, the execution order determination method is shown. First, the OS 310 selects an arbitrary CPU (target CPU) among CPUs to which no high priority thread is assigned. Then, the OS 310 identifies assigned threads assigned to the target CPU. Next, the OS 310 calculates the following formulas, respectively.

・ Ptotal = 0
R0 = target thread deadline-target thread execution time pst_high (target thread standby power) = r0 × target thread standby power per unit time [mW / ms]
Pst_low (standby power of allocated thread) = execution time of target thread × (p1 + p2 +... Pn)

  n is the number of assigned threads. Numbers 1 to n are assigned to the assigned threads in the order of assignment. p1 to pn are standby powers of assigned threads. Therefore, (p1 + p2 +... Pn) is a total value of standby power per unit time of the assigned thread.

Next, the OS 310 determines whether or not to comply with the following formula.
R0> (t1∨t2∨ ... ∨tn) ∧pst_high <pst_low (1)

  ∧ is a logical product, and ∨ is a logical sum. t1 to tn are execution times of assigned threads. When the above expression (1) is True (observance), the OS 310 determines an assigned thread that is a low priority thread to be executed before the target thread.

  Then, the OS 310 selects a thread having the largest standby power per unit time as a thread to be executed before the target thread among the assigned threads satisfying r0> (t1∨t2∨... ∨tn). . Here, for example, it is assumed that the first assigned thread among the assigned threads is selected as a thread (previous thread) to be executed before the target thread.

Then, the OS 310 calculates (a) the following formula.
Ptotal = ptotal + t1 × p0 (2)
Pst_high = pst_high−t1 × p0 Formula (3)
Pst_low = pst_low−t1 × p0 (4)
R0 = r0-t1 Formula (5)

Then, the OS 310 determines whether or not (b) the following formula is observed.
Pst_high <pst_low (6)

  When the OS 310 determines that (b) the above equation (6) is observed, the thread having the largest standby power per unit time among the assigned threads satisfying r0> (t2∨... ∨tn). Is selected as a thread to be executed after the preceding thread and before the target thread.

  Then, the OS 310 repeats the processes (a) to (b), thereby determining the execution order when assigned to the target CPU. When the execution order when the target thread is assigned to the target CPU is determined, the OS 310 selects an unselected CPU as the target CPU among the CPUs to which no high priority thread is assigned. Then, the OS 310 determines the execution order when the target thread is assigned to the selected target CPU.

  Of the CPUs to which no high-priority thread is assigned, the CPU having the largest ptotal calculated for each CPU is determined as the assignment destination CPU of the target thread. Then, the determined execution order is notified to the assignment destination CPU, and the thread assigned to the assignment destination CPU is executed based on the notified execution order.

  Next, it will be described in detail using specific numerical values.

  FIG. 7 is an explanatory diagram illustrating an example in which the generation of thread # 0 is detected. First, when the OS 310 detects (1) the generation of the thread # 0, it determines whether or not the priority of the thread # 0 is high using the thread table 400 based on the identification information of the thread # 0. Here, it is determined that the priority of thread # 0 is high. Next, the OS 310 identifies (2) a CPU to which a high priority thread is not allocated among the multi-core processors based on the allocation management table 500. Here, CPU # 0 and CPU # 1 are specified. First, the OS 310 selects CPU # 0 as the target CPU from among CPU # 0 and CPU # 1.

R0 (CPU # 0) = dead line of thread # 0−execution time of thread # 0
= 10 [ms] -5 [ms]
= 5 [ms]
Pst_high (CPU # 0) = r0 × standby power per unit time of thread # 0 [mW / ms]
= 5 [ms] x 100 [mW / ms]
= 500 [mW]
Pst_low (CPU # 0) = execution time of thread # 0 × (standby power per unit time of thread # 1 + standby power per unit time of thread # 3)
= 5 [ms] × (100 [mW / ms] +80 [mW / ms])
= 900 [ms]

Next, the OS 310 assigns each calculated value to the above equation (1) and determines whether or not the above equation (1) is observed.
5 [ms] (r0 (CPU # 0))> (3 [ms] (execution time of thread # 1) ∨2 [ms] (execution time of thread # 3)) ∧500 [mW] (pst_high (CPU # 0)) <900 [ms] (pst_low (CPU # 0))

When the OS 310 determines that the above equation (1) is observed, r0 (CPU # 0)> (3 [ms] (execution time of thread # 1) ∨2 [ms] (execution time of thread # 3)) Among the assigned threads, the thread having the maximum standby power per unit time is specified. Then, the OS 310 selects the identified thread as a thread to be executed before the thread # 0. The selection result is output to the storage area such as the shared memory 302 as execution order information.
CPU # 0 execution order information: thread # 1

Then, the OS 310 calculates the above formulas (2) to (6).
Ptotal (CPU # 0) = total (CPU # 0) + execution time of thread # 1 × standby power per unit time of thread # 0
= 0 + 3 [ms] × 100 [mW / ms]
= 300 [mW]
Pst_high (CPU # 0) = pst_high (CPU # 0) −execution time of thread # 1 × standby power per unit time of thread # 0
= 500 [mW] -3 [ms] × 100 [mW / ms]
= 200 [mW]
Pst_low (CPU # 0) = pst_low (CPU # 0) −execution time of thread # 1 × standby power per unit time of thread # 0
= 900 [ms] -3 [ms] × 100 [mW / ms]
= 600 [mW]
R0 (CPU # 0) = r0 (CPU # 0) -Thread # 1 execution time
= 5 [ms] -3 [ms]
= 2 [ms]

Then, the OS 310 determines whether to comply with the above formula (6).
・ 200 [mW] <600 [mW]

Then, the OS 310 determines that the above equation (6) is observed, and among the assigned threads satisfying r0 (CPU # 0)> (execution time of thread # 3), the thread having the largest standby power per unit time Is selected as a thread to be executed after the preceding thread and before the target thread. Then, the selection result is added to the execution order information of CPU # 0 described above.
CPU # 0 execution order information: thread # 1 → thread # 3

Then, the OS 310 calculates the above equation (2).
Ptotal (CPU # 0) = total (CPU # 0) + execution time of thread # 3 × standby power per unit time of thread # 0
= 300 [mW] + 2 [ms] x 100 [mW / ms]
= 500 [mW]

Here, since the threads assigned to the CPU # 0 are only the thread # 1 and the thread # 3, the thread # 0 is added to the execution order information of the CPU # 0.
CPU # 0 execution order information: thread # 1 → thread # 3 → thread # 0

  Next, the OS 310 selects CPU # 1 as the target CPU from among CPU # 0 and CPU # 1.

R0 (CPU # 1) = deadline of thread # 0−execution time of thread # 0
= 10 [ms] -5 [ms]
= 5 [ms]
Pst_high (CPU # 1) = r0 × standby power per unit time of thread # 0 [mW / ms]
= 5 [ms] x 100 [mW / ms]
= 500 [mW]
Pst_low (CPU # 1) = execution time of thread # 0 × (standby power per unit time of thread # 2 + standby power per unit time of thread # 4)
= 5 [ms] × (50 [mW / ms] +70 [mW / ms])
= 600 [ms]

Next, the OS 310 assigns each calculated value to the above equation (1) and determines whether or not the above equation (1) is observed.
5 [ms] (r0 (CPU # 1))> (4 [ms] (execution time of thread # 2) ∨5 [ms] (execution time of thread # 4)) ∧500 [mW] (pst_high (CPU # 1)) <600 [ms] (pst_low (CPU # 1))

Then, when the OS 310 determines that the above equation (1) is observed, the assigned thread per unit time among the allocated threads satisfying r0 (CPU # 1)> (4 [ms] (execution time of thread # 2)). Identify the thread with the highest standby power. Then, the OS 310 selects the identified thread as a thread to be executed before the thread # 0. The selection result is output to the storage area such as the shared memory 302 as execution order information.
CPU # 1 execution order information: thread # 2

Then, the OS 310 calculates the above equation (2).
Ptotal (CPU # 1) = total (CPU # 1) + execution time of thread # 2 × standby power per unit time of thread # 0
= 0 + 4 [ms] × 100 [mW / ms]
= 400 [mW]

Here, since the thread less than r0 (CPU # 1) is only thread # 2, thread # 0 is registered in the execution order information of CPU # 1, and thread # 4 is further registered.
CPU # 1 execution order information: thread # 2 → thread # 0 → thread # 4

  Next, the OS 310 determines a CPU having a large total of CPU # 0 and CPU # 1 as an assignment destination CPU of the thread # 0. Here, since ptotal (CPU # 0) is 500 [mW] and ptotal (CPU # 1) is 400 [mW], CPU # 0 is determined as the allocation CPU of thread # 0.

  FIG. 8 is an explanatory diagram showing an example of updating the allocation management table 500. The OS 310 registers the identification information of the CPU in the allocation management table 500 in the CPU # 0 and the identification information of the thread # 0 in the allocated thread identification information item 503. The OS 310 sets exe in the execution state item 504 of the thread # 1, sets proh in the execution state item 504 of the thread # 3, and sets proh in the execution state item 504 of the thread # 0. Then, the OS 310 starts executing the thread # 1.

(Information processing procedure)
9 to 11 are flowcharts illustrating an information processing procedure performed by the information processing apparatus 300. The execution subject is the OS 310 which is the master OS. First, the OS 310 determines whether or not the generation of a thread has been detected (step S901). When the OS 310 determines that the generation of a thread is not detected (step S901: No), the process returns to step S901. When the OS 310 determines that the generation of a thread has been detected (step S901: Yes), it determines whether the generated thread (target thread) is a high priority thread (step S902).

  When the OS 310 determines that the target thread is a high priority thread (step S902: Yes), it identifies a CPU that is not locked with respect to the allocation of the high priority thread (step S903). Then, the OS 310 determines whether or not the CPU that is not locked with respect to the assignment of the high priority thread has been identified (step S904).

  When the OS 310 determines that a CPU that is not locked with respect to the assignment of the high priority thread has been identified (step S904: Yes), it is determined whether there is an unselected CPU among the CPUs that are not locked. (Step S905).

  If the OS 310 determines that there is an unselected CPU (step S905: Yes), an arbitrary CPU is selected from the unselected CPUs as the target CPU (step S906). Then, the OS 310 executes execution order determination processing (step S907), outputs the target CPU identification information, execution order information, and ptotal in association with each other (step S908), and returns to step S905.

  When the OS 310 determines that the target thread is not a high priority thread (step S902: No), the CPU with the minimum load is specified (step S909). Then, the OS 310 sets the CPU to which the target thread is assigned as the specified minimum load CPU (step S910), and the process returns to step S901.

  When the OS 310 determines that the CPU that is not locked with respect to the assignment of the high priority thread cannot be identified (step S904: No), it determines whether there is an unselected CPU (step S911). If the OS 310 determines that there is an unselected CPU (step S911: Yes), an arbitrary CPU is selected from the unselected CPUs (step S912).

  The OS 310 extracts threads registered in the execution order information of the selected CPU (step S913), and calculates the total execution time of the extracted threads (step S914). The OS 310 determines whether or not the total value of the extracted thread execution times <the target thread deadline (d0) −the target thread execution time (t0) (step S915).

  When the OS 310 determines that the total execution time of the extracted threads <d0−t0 (step S915: Yes), the target CPU is determined as a CPU that can comply with d0 (step S916), and the process proceeds to step S911. Return. On the other hand, when it is determined that the total execution time of the extracted threads is not less than d0−t0 (step S915: No), the process returns to step S911.

  When the OS 310 determines that there is no unselected CPU (step S911: No), it determines whether there is a CPU that can comply with d0 (step S917). When the OS 310 determines that there is a CPU that can comply with d0 (step S917: Yes), it determines whether there is an unselected CPU among CPUs that can comply with d0 (step S918).

  When the OS 310 determines that there is an unselected CPU among CPUs that can comply with d0 (step S918: Yes), an arbitrary CPU is selected from the unselected CPUs as a target CPU (step S919). Then, the OS 310 executes execution order determination processing (step S920), outputs the target CPU identification information, execution order information, and ptotal in association with each other (step S921), and returns to step S905.

  In step S918, when the OS 310 determines that there is no unselected CPU among the CPUs that can comply with d0 (step S918: No), the CPU with the largest ptotal value among the CPUs that can comply with d0. Specify (step S922). Then, the OS 310 notifies the identified CPU of the execution order information of the identified CPU (step S923), sets the assignment destination CPU of the target thread to the identified CPU (step S924), and returns to step S901.

  When the OS 310 determines that there is no CPU that can comply with d0 (step S917: No), it identifies the thread with the shortest execution time among the high priority threads assigned to each CPU (step S925). Next, the OS 310 sets the specified thread allocation destination CPU as the target thread allocation destination CPU (step S926), and notifies the target thread allocation destination CPU of the execution order information discard instruction (step S927). Return to S901.

  In step S905, when the OS 310 determines that there is no unselected CPU (step S905: No), the CPU having the largest ptotal value among the unlocked CPUs is identified (step S928). Then, the OS 310 notifies the identified CPU of the execution order information of the identified CPU (step S929), sets the assignment destination CPU of the target thread to the identified CPU (step S930), and returns to step S901.

  12 and 13 are flowcharts showing the detailed processing procedure of the execution order determination processing (step S907) shown in FIG. When the execution order determination process is step S907 or step S920, the execution subject is the OS 310, but when the execution order determination process is the process of step S1511 (FIG. 15), the execution subject is each OS. First, the OS calculates r0 = dead line of target thread (d0) −target thread execution time (t0) (step S1201), and pst_high = r0 × standby power per unit time of target thread (p0). (Step S1202).

  Next, the OS sets ptotal = 0 (step S1203), m = 1 (step S1204), and identifies the CPU assigned to the target CPU (step S1205). The OS specifies a thread whose execution time is shorter than r0 among the specified assigned threads (step S1206). Then, it is determined whether or not the OS has identified a thread whose execution time is shorter than r0 (step S1207).

  When the OS determines that a thread having an execution time shorter than r0 has been identified (step S1207: YES), the total value (psum) of standby power of the allocated threads is calculated (step S1208). The OS calculates pst_low = psum × t0 (step S1209), and determines whether pst_high> pst_low is satisfied (step S1210).

  When the OS determines that pst_high> pst_low (step S1210: Yes), it is determined whether there is an unselected thread among threads whose execution time is shorter than r0 (step S1211). When the OS determines that there is an unselected thread (step S1211: Yes), the unselected thread having the largest standby power per unit time is selected (step S1212).

  Then, the OS associates the identification information of the selected thread and the value of m, and outputs them in the execution order information (step S1213). The OS calculates ptotal = ptotal + t0 × standby power per unit time of the selected thread (step S1214), and pst_low = pst_low−t0 × standby power per unit time of the selected thread (step S1215).

  The OS calculates pst_high = pst_high−the execution time of the selected thread × p0 (step S1216), sets m = m + 1 (step S1217), and returns to step S1211.

  In step S1207, when the OS determines that a thread having an execution time shorter than r0 could not be identified (step S1207: No), the identification information of the target thread is associated with the value of m and output to the execution order information ( Step S1218) and the process proceeds to Step S908.

  In step S1210, if the OS determines that pst_high> pst_low is not satisfied (step S1210: No), the process proceeds to step S1218.

  In step S1211, when the OS determines that there is no unselected thread (step S1211: No), the process proceeds to step S1218.

  FIG. 14 is a flowchart illustrating an information processing procedure when a thread is assigned by each OS. First, the OS receives a notification of execution order information, receives an instruction to discard execution order information, or determines whether or not a thread assignment has been detected (step S1401). When the OS receives the notification of the execution order information, receives the instruction to discard the execution order information, and determines that the thread assignment is not detected (step S1401: No), the process returns to step S1401.

  If the OS determines that the notification of execution order information has been received (step S1401: notification of execution order information), the stored execution order information is discarded and the received execution order information is stored (step S1402).

  When the OS determines that a thread assignment has been detected (step S1401: thread assignment), it determines whether the thread that has detected the assignment is a high priority thread (step S1403). When the OS determines that the thread that has detected the assignment is a high priority thread (step S1403: Yes), it locks the assignment of the high priority thread (step S1404).

  Then, the OS sets the execution state of the first thread in the execution order information to exe (step S1405), and sets the execution state of the allocated thread excluding the first thread in the execution order information to proh (step S1406). Next, the OS starts execution of the first thread in the execution order information (step S1407), and returns to step S1401.

  In step S1403, when the OS determines that the thread that detected the assignment is not a high priority thread (step S1403: No), the OS determines whether or not a lock relating to the assignment of the high priority thread is applied (step S1408). . When the OS determines that the lock relating to the assignment of the high priority thread is applied (step S1408: Yes), it is determined whether the thread that detected the assignment is the first thread in the execution order information (step S1409). ).

  If the OS determines that the thread whose allocation is detected is not the first thread in the execution order information (step S1409: No), the execution state of the detected thread is set to proh (step S1410), and the process returns to step S1401. . When the OS determines that the thread that detected the allocation instruction is the first thread in the execution order information (step S1409: Yes), the execution state of the detected thread is set to exe (step S1411), and the process returns to step S1401. .

  In step S1408, when the OS determines that the lock relating to the assignment of the high priority thread is not applied (step S1408: No), the thread detected at the end of the run queue is registered (step S1412), and the process returns to step S1401. .

  If the OS determines in step S1401 that the execution order information discard instruction has been received (step S1401: execution order information discard instruction notification), the stored execution order information is discarded (step S1413). Then, the OS starts executing the thread assigned first among the assigned high priority threads (step S1414), and returns to step S1401.

  FIG. 15 is a flowchart showing an information processing procedure at the time of thread termination by each OS. First, it is determined whether or not the OS detects the end of a thread or the switching of a thread (step S1501). If the OS determines that the end of the thread or the switching of the thread is not detected (step S1501: No), the process returns to step S1501.

  If the OS determines that the end of the thread has been detected (step S1501: end of thread), it determines whether the ended thread is a high priority thread (step S1502). When the OS determines that the terminated thread is not a high priority thread (step S1502: No), it determines whether or not a lock relating to the assignment of the high priority thread is applied (step S1503).

  When the OS determines that the lock related to the assignment of the high priority thread is applied (step S1503: Yes), the process proceeds to step S1509. When the OS determines that the lock relating to the assignment of the high priority thread is not applied (step S1503: No), the process proceeds to step S1505.

  When the OS determines that the terminated thread is a high-priority thread (step S1502: Yes), it determines whether there is a high-priority thread other than the terminated thread among the allocated threads. (Step S1504). When the OS determines that there is no high priority thread other than the terminated threads among the assigned threads (step S1504: No), the lock relating to the assignment of the high priority thread is released (step S1505). ).

  Then, the OS sets the execution state of all the allocated threads to exe (step S1506), and starts the execution of the thread with the highest allocation among the allocated threads (step S1507), and step S1501. Return to.

  In step S1504, when the OS determines that there is a high-priority thread among the allocated threads except for the terminated thread (step S1504: Yes), there is an unexecuted thread in the execution order information. Whether or not (step S1508). When the OS determines that there is an unexecuted thread in the execution order information (step S1508: Yes), the execution state of the first thread among the unexecuted threads in the execution order information is set to exe (step S1509). ).

  The OS starts execution of the first thread (step S1510) and returns to step S1501. When the OS determines that there is no unexecuted thread in the execution order information (step S1508: No), the execution order determination process is executed (step S1511), and the process returns to step S1501.

  As described above, according to the multiprocessor system, the control method, and the control program, when the first thread and the second thread are not executed, the execution order is determined by comparing the standby power of each thread. As a result, low power consumption can be achieved without switching threads.

  Further, when the standby power of the first thread is equal to or higher than the standby power of the second thread, the second thread is executed next to the first thread. Thereby, a thread with large standby power can be executed first, and power consumption can be reduced.

  When the standby power of the first thread is less than the standby power of the second thread, the first thread is executed next to the second thread. Thereby, a thread with large standby power can be executed first, and power consumption can be reduced.

  If an execution time limit is defined for the first thread, it is determined whether or not the first thread can comply with the execution time limit even if the second thread is executed before the first thread. When it is determined that the first thread can comply with the execution deadline even if the second thread is executed before the first thread, the standby power of the first thread and the standby power of the second thread are determined. The execution order is determined based on the above. As a result, power consumption can be reduced even when a thread with an execution deadline is executed.

  In addition, if it is determined that if the second thread is executed before the first thread, the first thread cannot comply with the execution deadline, the execution order is set to the second thread next to the first thread. Thus, it is possible to prevent the throughput of the first thread from decreasing.

300 Information processing apparatus 601 Detection unit 602 Difference calculation unit 603 Determination unit 604 First calculation unit 605 Second calculation unit 606 Comparison unit 607 Determination unit

Claims (3)

Multiple cores running multiple threads,
A storage unit for storing execution time information indicating a time required for execution of each of the plurality of threads and standby power information indicating power generated during standby before execution;
A multiprocessor system having any one of the plurality of cores,
The execution order of the first thread and the second thread is changed based on the execution time information and the standby power information in response to execution requests of the first thread and the second thread among the plurality of threads. A multiprocessor system that calculates standby power for each of the execution orders and assigns the first thread and the second thread to any of the plurality of cores in an execution order based on the calculated standby power. A multiprocessor having a plurality of cores that execute a plurality of threads, and a storage unit that stores execution time information indicating the time required to execute each of the plurality of threads and standby power information indicating power generated during standby before execution A method for controlling a system, wherein the multiprocessor system comprises:
The execution order of the first thread and the second thread is changed based on the execution time information and the standby power information in response to execution requests of the first thread and the second thread among the plurality of threads. Processing for calculating standby power for each execution order;
A control method for a multiprocessor system, which executes a process of assigning the first thread and the second thread to any one of the plurality of cores in an execution order determined based on the calculated standby power. A multiprocessor having a plurality of cores that execute a plurality of threads, and a storage unit that stores execution time information indicating the time required to execute each of the plurality of threads and standby power information indicating power generated during standby before execution A system control program, comprising:
The execution order of the first thread and the second thread is changed based on the execution time information and the standby power information in response to execution requests of the first thread and the second thread among the plurality of threads. Processing for calculating standby power for each execution order;
A control program for a multiprocessor system that executes a process of assigning the first thread and the second thread to any one of the plurality of cores in an execution order determined based on the calculated standby power.

Images