JPH1124946A - Device and method for scheduling task - Google Patents

Abstract

PROBLEM TO BE SOLVED: To obtain a task scheduling device which improves the reliability of a system by using round robin scheduling for task groups which access common resources, using pre-empt scheduling for task groups irrelevant to the common resources and performing processing that realizes the pre-empt scheduling among both task groups. SOLUTION: Task groups 300 and 310 which access common resources use round robin scheduling. Task groups 320 and 330 irrelevant to the common resources use pre-empt scheduling. And the pre-empt scheduling is performed among both task groups 300 to 330. Then, even if the tasks 300 and 310 which access the common resources occupy a CPU 140 and continue execution, the tasks 320 and 330 irrelevant to the common resources are preemptible. Because of this, the possessory right of the CPU 140 is obtained and executed, and effects are prevented from being given to an entire system.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] The present invention relates to a task scheduling apparatus and method.

[0002]

2. Description of the Related Art Conventionally, when a shared resource is accessed between multitasks, in a system that requires exclusive control, exclusive control has been realized by the following method.

In the first method, each task acquires a semaphore (access right) to an operating system (OS) immediately before access to a shared resource, and returns the semaphore to the OS when the access to the shared resource ends. This realizes exclusive control.

In the second method, exclusive control is realized by using round-robin scheduling and guaranteeing that task switching is not performed (being non-preemptive) until the CPU right is explicitly released from the invoking task. I do.

[0005]

However, the above-mentioned conventional exclusive control method has the following problems. That is, in the first method, a corresponding semaphore is acquired and returned for each access to the shared resource, so that overhead is required (problem 1).

When a plurality of shared resources are included in a complicated data structure and it is necessary to guarantee the consistency of the entire data structure even when accessing from a plurality of tasks, the extraction of shared resources for semaphore allocation Is difficult (Problem 2).

Further, when it is necessary to guarantee a continuous access order different for each task for a plurality of shared resources, there is a risk of deadlock (problem 3).

On the other hand, in the second system, the above problem is solved by using round robin scheduling. However, pre-embedding (preemption) scheduling by event driven or time slice cannot be performed.
If the task accessing the shared resource occupies the CPU and continues to execute, even a task unrelated to the shared resource is not executed, affecting the entire system (problem 4).

In addition, since preemption (preemption) scheduling by time slice cannot be performed, when there are a plurality of shared resources, the accumulated access time for each of the shared resources cannot be equally allocated, and the number of tasks to be accessed is large. The accumulated access time of the shared resource is longer (problem 5).

Several means have been proposed to solve one or some of these problems. For example, Japanese Patent Laid-Open No. 5-120039 proposes a method of improving problem 1 by providing a table separately for tasks requiring high-speed processing and eliminating the need for resource securing and release processing.

As means for coping with the task priority inversion phenomenon (priority inversion) for one shared resource, which is the simple case of Problem 3, JP-A-5-250188 and JP-A-8-77025 As disclosed in the gazette, a method has been proposed in which the priority of a task is raised only during a shared resource occupation period.

The present invention solves the above problems 1-4, problems 1-3 and problems 5, or problems 1-5, thereby improving the reliability of the system. The purpose is to provide.

[0013]

In order to achieve the above object, a task scheduling apparatus according to a first aspect of the present invention is a task scheduling apparatus for scheduling a multitask program, comprising: a scheduling adjustment mechanism; a preemptive scheduling; And a round-robin scheduling mechanism, wherein round-robin scheduling is used for a task group accessing a shared resource, pre-emption scheduling is used for a task group irrelevant to the shared resource, and pre-emption scheduling is realized between both task groups. Processing is performed.

According to a second aspect of the present invention, in the task scheduling apparatus for scheduling a multitask program, the task scheduling apparatus includes a scheduling adjustment mechanism, a preemption scheduling mechanism, and a round robin scheduling mechanism, and accesses each shared resource. A task group is cut out as a task group, round robin scheduling is independently used in each task group, and processing for realizing preemption scheduling is performed between the task groups.

According to a third aspect of the present invention, in the task scheduling apparatus for scheduling a multitask program, the task scheduling apparatus includes a scheduling adjustment mechanism, a preemption scheduling mechanism, and a round robin scheduling mechanism, and accesses each shared resource. Cut out the task group as a task group, use round robin scheduling independently in each task group, use preemption scheduling for the task group unrelated to the shared resource, and use the pre-emption scheduling between the task groups and between the task group and the shared resource. Is characterized by performing processing for realizing preemption scheduling between unrelated task groups.

According to a fourth aspect of the present invention, in the task scheduling method for scheduling a multitask program, round robin scheduling is used for a task group accessing a shared resource, and preemption is performed for a task group irrelevant to the shared resource. Using scheduling, a process for realizing preemption scheduling is performed between both task groups.

According to a fifth aspect of the present invention, in the task scheduling method for scheduling a multi-task program, a task group to be accessed for each shared resource is cut out as a task group, and round robin is independently performed in each task group. A process for realizing preemption scheduling is performed between the task groups by using scheduling.

According to a sixth aspect of the present invention, in the task scheduling method for scheduling a multi-task program, a task group to be accessed for each shared resource is cut out as a task group, and round robin is independently performed in each task group. Using scheduling, preempt scheduling is used for a task group unrelated to the shared resource, and processing for realizing preempt scheduling is performed between the task groups and between task groups unrelated to the shared resource. Features.

[0019]

DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of a task scheduling apparatus and method according to the present invention will be described.

[First Embodiment] In a first embodiment, a task scheduling apparatus that solves the above-mentioned problems 1 to 4 will be described. FIG. 1 is a block diagram showing a configuration of a system to which the task scheduling device according to the first embodiment is applied. The system to which the task scheduling device is applied is a CPU 140,
ROM 110, RAM 100, timer 150 and I /
It comprises an O interface 130.

In FIG. 1, a ROM 110 stores a RAM 10
All codes in 0 and initialization data are stored. When the CPU 140 is reset, the system starts up, copies all the codes and data stored in the ROM 110 to the RAM 100, and starts the initialization processing 610 of the scheduling adjustment mechanism 600 (see FIG. 2).

In the initialization processing 610, the hardware of the I / O interface 130 and the timer 150 is initialized, thereby enabling the I / O interruption processing 400 and the timer interruption processing 410.

Preemption scheduling mechanism 700
The initialization process 720 (see FIG. 3) and the initialization process 810 (see FIG. 4) of the round robin scheduling mechanism 800 start up a multitask environment based on the initialization data 500.

At this point, the shared resources (variable data, etc.) 2
Tasks that do not access 00 (task 1 (320),
), And only one (task A (300)) of the group of tasks to be accessed (task A (300), task B (310), ...) are registered in the preempt scheduling mechanism 700, Other task groups (task B (310),...) Are registered in the round robin scheduling mechanism 800.

Preemption scheduling mechanism 700
Task group (task 1 (320), task 2
(330)... Of the task A (300)), only one task at the top of the queue in the execution waiting queue 770 is executed by the scheduling process 730 while occupying the CPU 140. You.

Preempt scheduling mechanism 700
When the task A registered in the state transitions to the suspended state 905,
Of the task group (task B (310),...) Registered in the round robin scheduling mechanism 800, the first task (task B) 1 in the round robin queue 840
Only one of them is taken out and additionally registered in the preempt scheduling mechanism 700 (see FIG. 5).

When the suspended state 905 is released, the task A (300) is deleted from the preemption scheduling mechanism 700 and registered in the round robin scheduling mechanism 800 instead of the task B (310).

As described above, a group of tasks (task A (300), task B (310),.
..) Use round-robin scheduling to create a task group (task 1 (32
0), task 2 (330),...) Performs preemption (stealing) scheduling between both task groups by using preemptive scheduling.

Hereinafter, the configuration and operation of the task scheduling device will be described in detail with reference to the drawings. FIG.
FIG. 4 is a diagram showing a configuration of a scheduling adjustment mechanism 600. Processing 6 provided for scheduling adjustment mechanism 600
01 is an initialization process 610, a suspension process 620, a suspension release process 640, and a timer interrupt process 660. Data 602 held by the scheduling adjustment mechanism 600 is a shared resource management table 680.

FIG. 3 is a diagram showing the configuration of the preempt scheduling mechanism 700. The process 701 provided in the preemption scheduling mechanism 700 includes an initialization process 720, a scheduling process 730, an addition process 740 to the tail of the designated execution wait queue, a process 741 for acquisition from the designated execution queue, an addition process 742 to the end of the suspension queue, and a suspension queue. This is an acquisition process 743 from. The data held by the preemption scheduling mechanism 700 is
A task execution block 703 that indicates a task that occupies the same, and a TCB (task control block) 750 that manages a task state and the like for each task.

The preemption scheduling mechanism 700 also has an execution queue 770 and an interruption queue 790 for executing task scheduling. The execution waiting queue 770 has an execution waiting state 9 for each priority.
The TCB 750 of the task 03 is held in a list, and its arrangement order is managed as a queue and a FIFO queue. Processing 7 of preempt scheduling mechanism 700
01 guarantees that among the TCBs 750 linked to these queues, there is only one TCB 750 (task A (777) in FIG. 3) for the task accessing the shared resource. The suspension queue 790 holds the TCBs 750 of the tasks in the suspended state 905 in a list, and manages the arrangement order as a queue and a FIFO queue.

FIG. 4 is a diagram showing the configuration of the round robin scheduling mechanism 800. The processing 801 provided in the round robin scheduling mechanism 800 includes an initialization processing 810, an addition processing 83 after the round robin queue.
This is an acquisition process 831 from 0 and the round robin queue. The round robin scheduling mechanism 80
0 holds a round robin queue 840 for implementing task scheduling. The round robin queue 840 stores the TC of the task in the round robin wait state 904.
B750 is held in a list, and its arrangement order is managed as a queue and a FIFO queue.

FIG. 5 is a diagram showing a state transition of a task.
Tasks are in an initial state 902, an execution waiting state 903, an execution state 901, a suspended state 905, a round robin waiting state 904.
Each state of can be taken. The transition between the states is caused by activation of the scheduling process 730, the suspension process 620, the suspension release process 640, the initialization process 720, the initialization process 810, and the timer interrupt process 660. The task state is a task state 756 in the TCB 750 for each task.
(See FIG. 8).

The initial state 902 is a state at the time of rising immediately after the TCB 750 is secured. Execution state 901
Is a state in which the task is occupying the CPU 140 and is being executed, and only the first task in the queue has the highest priority and can be the first task in the queue. In the task in this state, the TCB 750 is linked to the execution waiting queue 770 (see FIG. 3).

The execution waiting state 903 is a state in which execution is possible, but other tasks occupy the CPU 140 due to the priority order or the like, and thus the task is waiting for the task to become free. In the task in this state, the TCB 750 is linked to the execution waiting queue 770.

The suspended state 905 is a state of waiting for an event from the I / O interrupt processing 400 or the like. During this state, the processing is not executed even if the CPU 140 is idle. In the task in this state, the TCB 750 is linked to the suspend queue 790.

The round robin wait state 904 indicates the shared resource 2
When only the task group accessing the shared resource 200 is in a state capable of transition, and there is already one task accessing the shared resource 200 in the execution waiting state 903 or the execution state 901, it is determined that this task transitions to the suspended state 905. You are waiting. In the task in this state, the TCB 750 is linked to the round robin queue 840.

FIG. 6 shows the structure of the initialization data. Referring to FIG. 7, the initialization data 500 includes the total number of tasks 510 and all task information 520. All task information 520 is stored for each task including the task execution address (PC), priority, and shared resource access flags 521-531. In the shared resource access flags 521 to 531, the value 1 is set for the tasks 521 to 525 that access the shared resource, and the value 0 is set for the tasks 526 to 531 that do not access the shared resource.

FIG. 7 shows a shared resource management table. Referring to the figure, the shared resource management table 680
Are the number of tasks waiting to execute shared resources 682 indicating the number of tasks accessing the shared resources linked to the waiting queue 770, and the number of tasks waiting to be round robin indicating the number of tasks linked to the round robin queue 840. 681 are stored.

FIG. 8 is a diagram showing a configuration of the task control block. Referring to the figure, a TCB (task control block) 750 includes a task ID 752, a task address (PC) 753, a task stack address (SP) 754, a priority 755, a task state 756,
Link pointer 757, shared resource access flag 75
8, and other additional information 759.

The TCB 750 holds data for each task (TCB [0] 751, TCB [1] 760, TCB
[2] 761...), Which is held as data of the preempt scheduling mechanism 700. Task state 75
The possible values of 6 are initial state 902, execution waiting state 903,
An execution state 901, an interruption state 905, and a round robin waiting state 904 are set. These state transitions and the causes thereof are as shown in FIG.

Next, the scheduling adjustment mechanism 600
Will be described. FIG. 9 is a flowchart showing the procedure of the initialization process 610. This initialization processing 610 is C processing as the first processing after CPU reset.
This is executed by the PU 140.

First, hardware interrupts are prohibited.
(Step S611). ROM 110 to RAM 100
Then, the code and the initialization data 500 are copied (step S612). Preemption scheduling mechanism 7
Call the initialization processing 720 of step S00 (step S61).
3). The initialization processing 810 of the round robin scheduling mechanism 800 is called (step S614).

The hardware interrupt is permitted (step S615). Preempt scheduling mechanism 700
The scheduling process 730 is started (step S6).
16), initialization processing 610 of the scheduling adjustment mechanism
To end.

The scheduling process 730 does not return, but starts execution by giving the occupation of the CPU 140 to the task having the highest priority in the execution queue 770 and the head of the queue.

Thereafter, the timing at which task scheduling occurs is as follows: when the interrupt processing 620 or the interrupt release processing 640 is started from the task, the I / O interrupt processing 4
This is a case where the interruption release processing 640 is started from 00, and a case where the timer interrupt processing 660 is started from the timer interrupt 410.

FIG. 10 is a flowchart showing the procedure of the initialization process 720 of the preemption scheduling mechanism 700. This processing is performed by the scheduling adjustment mechanism 600.
Is called only once from the initialization process 610.

First, the TCB 750 of each task is initialized (TCB [0] -TCB) based on the information of the initialization data 500.
[10] (Tasks 1-6, AE) are performed (step S721).

In the process of step S721, an area of all TCBs is secured in the RAM 100 based on the total number of tasks 510 of the initialization data 500 (721a). Based on all task information 520 of the initialization data 500, the values of the task address (PC) 753 / priority 755 / shared resource access flag 758 in the TCB 750 are set (721).
b). A task ID 752 is allocated, a task stack area is secured in the RAM 100, and a stack pointer is set to a task stack address (SP) 754 (72).
1c). Waiting state 90 for task state 756 of all TCBs
It is set to 3 (721d). Other additional information 759
If there is, it is initialized (721e).

Subsequently, the following processing is repeated from TCB [0] to TCB [(total number of tasks 510) -1] (step S722). The TCB (task 1, 2, 3, 4, 5, 6) address of a task that does not access the shared resource whose shared resource access flag 758 of the TCB 750 is 0 is added to the end of the execution wait queue 770 corresponding to the priority 755. I do.

The currently executed task 703 is set as an idle task (step S723). When the I / O interface and the timer are initialized and time slice scheduling of the same priority is required, the timer interrupt processing 660 is registered in the timer interrupt vector (step S72).
4). Then, the process returns to the calling source.

FIG. 11 is a flowchart showing the procedure of the initialization process 810 of the round robin scheduling mechanism 800. This processing is performed by the scheduling adjustment mechanism 60.
Called only once from the initialization process 610 of 0. First, the loop counter Count is initialized (step S811). The number 681 of round-robin waiting tasks is initialized to a value 0 (step S812).

From TCB [0] to TCB [(total number of tasks 5
The following processing is repeated until 10) -1] (step 81)
3). That is, it is determined whether or not the shared resource access flag 758 of TCB [Count] has a value of 1 (task for accessing the shared resource) (step 814). If the value is 1, the loop ends, and the process proceeds to step S816. On the other hand, if the shared resource access flag 758 of TCB [Count] is not the value 1, Count is incremented (step S815).

The TCB [Count] indicating the task that accesses the first found shared resource is added to the end of the execution queue 770 corresponding to the priority 755 (step S816). The loop counter Count is incremented (step S817). The value 1 is set to the number 682 of tasks waiting to be executed shared resource access (step S81)
8).

To add a task group for accessing the remaining shared resources to the round robin queue 840, the TCB
From [Count] to TCB [(total number of tasks 510)-
1)] is repeated (step S81)
9). The value of the shared resource access flag 758 of TCB [Count] is 1 (task for accessing the shared resource).
It is determined whether or not this is the case (step S820). If the value is 1, the task state 756 of the TCB [Count] is set to the round robin wait 904, added to the end of the round robin queue 840 (step S821), and the round robin wait task number 681 is incremented (step S82).
2) The loop counter Count is incremented (step S823). On the other hand, in step S820, TC
If the shared resource access flag 758 of B [Count] is not the value 1, Count is incremented (step S823). In addition, if all of the steps are repeated in step S813 or step S819, the process returns to the calling source.

FIG. 12 is a flowchart showing the procedure of the scheduling process 730 of the preemption scheduling mechanism 700. This process is started from the initialization process 610, the suspension process 620, the suspension release process 640, and the timer interrupt process 660 of the scheduling adjustment mechanism 600.

Task scheduling is realized based on the execution queue 770. First, it is determined whether or not the currently executed task 703 is equal to the first task in the execution queue 770 having the highest priority (step S731). Return if equal. If they are not equal, the CPU 1 sets the TCB 750 (task address 753, task stack address 754) of the currently executed task 703 to perform a task switch.
Save PC (program counter) and SP (stack pointer) in 40 and change task state 756 to execution waiting state 9
03 (step S732).

From the TCB 750 (task address 753, task stack address 754) of the first task in the execution waiting queue 770 having the highest priority, the PC in the CPU 140
(Program counter) and SP (stack pointer) are set, and the task state 756 is changed to the execution state 901 (step S733).

The currently executed task 703 is set as the first task in the execution waiting queue 770 having the highest priority (step S73).
4). Then, the task is started (step S7)
35).

FIG. 13 shows a scheduling adjustment mechanism 600.
Is a flowchart showing the procedure of the interruption process 620 of FIG.
This process is started arbitrarily from a task, and is a process for transitioning a designated task to a suspended state 905.

First, the TCB 750 of the specified suspended task
It is determined whether the shared resource access flag 758 is equal to the value 1 (step S621). If not equal,
Since the task to be interrupted is a task that does not access the shared resource, the TCB 750 of the interrupted task is set to the execution queue 7.
70 (step S622), the interrupt queue 7
90, and the task state 756 is suspended.
5 (step S623), and the scheduling process 7
30 is started (step S623A).

If the value of the shared resource access flag 758 in the TCB 750 of the specified suspended task is equal to the value 1, the task to be suspended is a task to access the shared resource, and the TCB of the suspended task is taken out from the execution waiting queue 770 ( In step S624), a value 0 is set to the number of tasks waiting to be executed shared resource access (682) (step S62).
5), the TCB extracted in step S624 is added to the end of the suspension queue 790, and the task state 756 is changed to the suspension state 905 (step S626).

It is determined whether or not the number of round robin waiting tasks 681 is equal to the value 0 (step S627). If the value is equal to 0, the task in the round robin waiting state 904 does not exist, and the scheduling process 730 is started (step S632).

If the value is not equal to 0, the task accessing the specified shared resource has transitioned from the execution wait state 903 to the suspended state 905, and the round robin wait state 9 is newly added.
In the group of tasks accessing the shared resource No. 04, one task is shifted to the execution waiting state 903. First, the TCB 750 of the first task in the round robin queue 840 is taken out (step S628), the number of round robin waiting tasks 681 is decremented (step S629), and the TCB taken out in the step 628 is assigned a corresponding priority 755.
Is added to the end of the execution wait queue 770, and the task state 75
6 is set to the execution waiting state 903 (step S630).

The number of shared resource access tasks waiting to be executed (68
The value 1 is set in 2) (step 631). The scheduling process 730 is started (Step 632).

FIG. 14 shows a scheduling adjustment mechanism 600.
9 is a flowchart showing the procedure of the interruption release processing 640 of FIG. This process is arbitrarily started from a task or I / O interrupt process. This is a process of transitioning the designated task from the suspended state 905 to the execution waiting state 903 or the round robin waiting state 904.

First, it is determined whether or not the shared resource access flag 758 in the TCB 750 of the task for which the specified suspended state is to be released is equal to the value 1 (step S641).
If they are not equal, the task to be released from the suspended state is a task that does not access the shared resource.
The CB 750 is taken out of the suspension queue 790 (step S642), and the execution waiting queue 7 of the corresponding priority 755 is taken.
70 is added to the end, and the task state 756 is in the execution waiting state 9
03 (step S643), and activates the scheduling process 730 (step S643A).

The T of the task to be released from the specified suspended state
If the shared resource access flag 758 in the CB 750 is equal to the value 1, the task to be interrupted is a task to access the shared resource, so the TCB 750 of the interrupted task is taken out from the interrupt queue 790 (step S644).

It is determined whether or not the number 681 of round-robin waiting tasks is equal to the value 0 (step S645). If the value is not equal to 0, the task in the round robin waiting state 904 already exists, and thus the T extracted in step S644
The CB is added to the end of the round robin queue 840, the task state 756 is set to the round robin waiting state 904 (step S647), the round robin waiting task number 681 is incremented (step S648), and the process returns.

If the value is equal to 0 in step S645, there is no task in the round-robin waiting state 904, so that
It is determined whether or not the number of tasks waiting for execution of shared resource access (682) is equal to the value 0 (step S646). If the value is not equal to 0, one of the tasks that already access the shared resource is in the waiting state 903, so the TCB extracted in step S644 is added to the end of the round robin queue 840, and the task state 756 is changed. The state is set to the round robin waiting state 904 (step S647), the round robin waiting task number 681 is incremented (step S648), and the process returns.

If the value is equal to 0 in step S646, the execution waiting state 90 of the task group accessing the shared resource
Since the task No. 3 does not exist, the TCB extracted in step S644 is added to the tail of the execution waiting queue 770 of the corresponding priority 755, and the task state 756 is changed to the execution waiting state 903 (step S649). The value 1 is set to the number of tasks waiting to be executed shared resource access (682) (step S650). The scheduling process 730 is started (step S651).

FIG. 15 shows a scheduling adjustment mechanism 600.
6 is a flowchart showing a procedure of a timer interrupt process 660 of FIG. This process is started from the timer interrupt process 410 when a timer interrupt occurs. This is a process for performing time slice (time division) scheduling of the tasks linked in the execution waiting queue 770 having the highest priority. If you do not want to execute the time slice, you do not need to start.

First, the highest priority execution wait queue 770
The task is taken out of the queue (step S661) and added to the end of the execution waiting queue 770 having the same priority (step S662). The scheduling process 730 is started (step S663).

[Second Embodiment] In the second embodiment,
A task scheduling device that solves the above problems 1 to 5 will be described. FIG. 16 is a diagram illustrating a configuration of a system to which the task scheduling device according to the second embodiment is applied. In the second embodiment, different from the first embodiment, there are a plurality of shared resources.
Task A (300) and task B (310) access shared resource 1 (200), and shared resource 2 (210).
Is accessed by task X (340) and task Y (350).

FIGS. 17 to 24 show only parts having processing and data structures different from those of the first embodiment in the second embodiment. 2, 3, 5, 9, 12,
FIG. 15 shows the same processing and data structure as in the first embodiment. In the following description, FIGS. 16 to 24, FIG.
The components shown in FIGS. 3, 5, 9, 12, and 15 are used, and the same reference numerals are used for the same components as those in the first embodiment.

The ROM 110 shown in FIG.
All codes and initialization data indicated by 00 are stored. When the CPU 140 is reset, the system copies all of them to the RAM 100 when the system starts up, and initializes the scheduling adjustment mechanism 600 in the initialization processing 6.
Start 10

In the initialization processing 610, the hardware of the I / O interface 130 and the timer 150 is initialized, thereby enabling the I / O interruption processing 400 and the timer interruption processing 410, and initializing the preempt scheduling mechanism 700. In a process 720, an initialization process 810 of the round robin scheduling mechanism 800 starts up a multitask environment based on the initialization data 500.

At this point, the task group (task 1 (320), task 2 (330),
..) And a group of tasks accessing the shared resource 1 (200) (task A (300), task B (310),.
..) And a group of tasks (task X) accessing the shared resource 2 (210)
(340), only one of tasks Y (350),...) (Task X (340)) is registered in the preemptive scheduling mechanism 700, and the other tasks (task B (310),. Y (350), ...
..) Are registered in the round robin scheduling mechanism 800 by creating a round robin group for each shared resource.

Preemption scheduling mechanism 700
Task group (task 1 (320), task 2
(330)..., Task A (300), task X (34)
Of the tasks 0)), only one task at the top of the queue in the execution queue 770 by the scheduling process 730 occupies the CPU 140 and is executed.

Preempt scheduling mechanism 700
When the task A registered in the task group A transitions to the suspended state 905, the task group (task B (842), task C (843)...) Registered in the round robin group [1] 841 of the round robin scheduling mechanism 800 Of these, only one task (task B842) at the head of the queue of the round robin group [1] 841 is taken out and additionally registered in the preemption scheduling mechanism 700. The task A (300) is released when the suspended state 905 is released. Preempt scheduling mechanism 70
0, and is registered in the round robin group [1] 841 of the round robin scheduling mechanism 800 instead of the task B (842).

Similarly, when the task X registered in the preemption scheduling mechanism 700 transitions to the suspended state 905, the task group registered in the round robin group [2] 846 (task Y (847), Task Z (848) ...)
Among them, only one task (task Y847) at the head of the queue of the round robin group (2) 846 is extracted and additionally registered in the preemption scheduling mechanism 700. The task X (340) is deleted from the preemption scheduling mechanism 700 at the timing when the suspended state 905 is released, and is registered in the round robin group [2] 846 of the round robin scheduling mechanism 800 instead of the task Y (847).

As described above, the task group (task A (300), task B (3) accessing the shared resource 1 (200)
10),...) Use round-robin scheduling in the round-robin group [1] 841 to execute a task group (task X (340), task Y (350),...) Accessing the shared resource 2 (210). Use round-robin scheduling in a round-robin group [2] 846, and use a task group (task 1 (320), task 2 (330),.
..) Uses preemptive scheduling, and preemptive scheduling is performed between these three task groups.

Hereinafter, the configuration and operation of the task scheduling apparatus according to the second embodiment will be described in detail with reference to the drawings, but different points from the first embodiment will be described in detail.

FIG. 17 is a diagram showing the configuration of the round robin scheduling mechanism 800. The processing 801 provided in the round robin scheduling mechanism 800 includes an initialization processing 810, an addition processing 832 to the tail of the designated round robin queue, and an acquisition processing 8 from the designated round robin queue.
33. Further, a round robin queue 840 is held to implement task scheduling.

The round robin queue 840 holds the TCBs 750 of the tasks in the round robin waiting state 904 in a list for each shared resource, and arranges the arrangement order for each round robin group (round robin group [1] 841, round robin group [2]). ] 846, the queue is managed as a queue in the round robin group [3] 851) as a FIFO queue.

FIG. 18 shows the structure of the initialization data. The initialization data 500 includes a total number of tasks 510, a total number of shared resource groups 511, and all task information 540. The all task information 540 is stored for each task including the task execution address (PC), priority, and shared resource access group (541-551). A group number is assigned to the shared resource access group (541-551) for each shared resource.
C (541-543) has the value 1, task XZ (544)
-546) has the value 2, task IK (547-549)
Has a value of 3, and the task 1-2 not to access (550-55)
The value 0 is set in 1).

FIG. 19 shows a shared resource management table. The shared resource management table 680 accesses the shared resources linked to the execution waiting queue 770 in the form of grouping by shared resources (group [1] 691, group [2] 694, group [3] 697). Number of tasks waiting to execute shared resources 69 representing the number of tasks to be executed
2, 695, 698 and the number of tasks waiting for round robin 69 representing the number of tasks linked to the round robin queue 840 for each round robin group (shared resource)
3,696,699.

FIG. 20 is a diagram showing the configuration of the task control block. The TCB (task control block) 750 includes a task ID 752, a task address (P
C) 753, task stack address (SP) 754,
Priority 755, task status 756, link pointer 7
57, a shared resource access group 765, and other additional information 759.

The TCB 750 holds data for each task, and includes TCB [0] 751, TCB [1] 760, TCB
[2] It is held as data of 761 and the preemption scheduling mechanism 700.

The possible values of the task state 756 are an initial state 902, an execution wait state 903, an execution state 901, an interruption state 905, and a round robin wait state 904. The state transition and the cause of occurrence are as shown in FIG.

FIG. 21 is a flowchart showing the procedure of the initialization process 720 of the preemption scheduling mechanism 700. This processing is performed by the scheduling adjustment mechanism 600.
Is called only once from the initialization process 610.

First, the TCB 750 of each task is initialized (TCB [0] -TCB) based on the information of the initialization data 500.
[10] (Task 1-3, AC, XZ, IJ))
Is performed (step S721A). This step S721
In the process A, the total number of tasks 510
All TCB areas are secured in the RAM 100 based on
1a). Based on all task information 520 of the initialization data 500, the values of the task address (PC) 753 / priority 755 / shared resource access group 765 in the TCB 750 are set (721b).

A task ID 752 is allocated, a task stack area is secured in the RAM 100, and a stack pointer is set to a task stack address (SP) 754 (721c). The task state 756 of all TCBs is set to the execution waiting state 903 (721d). If there is other additional information 759, it is initialized (721e).

From TCB [0] to TCB [total number of tasks (5
The following processing is repeated until 10) -1] (Step S7)
22A). TCB750 Shared Resource Access Group 7
T of a task that does not access a shared resource whose value 65 is 0
The CB (task 1, 2, 3) address is added to the tail of the execution wait queue 770 corresponding to the priority 755.

The currently executed task 703 is set as an idle task (step S723). When the I / O interface and the timer are initialized and time slice scheduling of the same priority is required, the timer interrupt processing 660 is registered in the timer interrupt vector (step S72).
4). Thereafter, the process returns to the caller.

FIG. 22 is a flowchart showing the procedure of the initialization process 810 of the round robin scheduling mechanism 800. This processing is performed by the scheduling adjustment mechanism 60.
Called only once from the initialization process 610 of 0. First, all the subsequent processing is performed with the loop counter Count2 = 1.
It is determined whether or not the process has been repeated up to Count2 = the total number of shared resource groups 511 (step S810A). If the process has been repeated, the process returns as it is. If the process has not been repeated, the loop counter Count is initialized to 0 (step S811). Number of round robin waiting tasks (693, 696, or 69) in group [Count2]
9) is initialized to a value 0 (step S812).

From TCB [0] to TCB [total number of tasks (5
The following processing is repeated until 10) -1] (Step S8)
13). It is determined whether the value of the shared resource access group 765 of TCB [Count] is not 0 (task for accessing the shared resource) (step S814). If the value is 0, the loop ends and the process moves to step S816. If the value of the shared resource access group 765 of TCB [Count] is not 0, Count is incremented (step S815).

The TCB [Count] indicating the task that accesses the shared resource found first is added to the end of the execution wait queue 770 corresponding to the priority 755 (step S816). The loop counter Count is incremented (step S817). Group [Count
2] waiting shared resource access task number (692, 69
5 or 698) is set to the value 1 (step S8).
18).

To add a task group for accessing the remaining shared resources to the round robin queue 840, the TCB
From [Count] to TCB [(total number of tasks 510)-
1] is repeated (step S819).
TCB [Count] shared resource access group 76
It is determined whether 5 is not the value 0 (task for accessing the shared resource) (step S820).

If the value is not 0, the task state 756 of the TCB [Count] is set to the round robin wait 904 and added to the end of the round robin queue (841, 846 or 851) of the round robin group [Count2] (step S821). Number of round-robin waiting tasks in group [Count2] (693, 696 or 6
99) is incremented (step S822), and the loop counter Count is incremented (step S823). If the value of the shared resource access group 765 of TCB [Count] is 0, Count is incremented (step S823). Then, step S8
When the processing is repeated up to Count2 = the total number of shared resource groups 511 at 10A, the process returns to the caller.

FIG. 23 shows the scheduling adjustment mechanism 600.
Is a flowchart showing the procedure of the interruption process 620 of FIG.
This process is arbitrarily started from a task. This is a process of transitioning the designated task to the suspended state 905. First, it is determined whether or not the value of the shared resource access group 765 in the TCB 750 of the specified suspended task is not equal to 0 (step S621). If the value is equal to 0, the task to be interrupted is a task that does not access the shared resource. Therefore, the TCB 750 of the interrupted task is removed from the execution queue 770 (step S622), and added to the end of the interrupt queue 790,
The task state 756 is changed to the suspended state 905 (step S6
23), start the scheduling process 730 (step 623A).

If the shared resource access flag 758 in the TCB 750 of the specified suspended task is not equal to the value 0,
Since the task to be interrupted is a task that accesses a shared resource, the TCB of the interrupted task is taken out of the queue for execution 770 (step S624), and the number of shared resource access tasks waiting for execution of the group [shared resource group 765] (6
92, 695 or 698) to 0 (step S625), and the TCB extracted in step S624.
Is added to the end of the suspend queue 790, and the task state 756 is added.
To the suspended state 905 (step S626).

The number of round-robin waiting tasks (693, 696 or 69) in the group [shared resource group 765]
It is determined whether or not (9) is equal to the value 0 (step S62).
7). If the value is equal to 0, in particular, the round robin wait state 9
Since the task 04 does not exist, the scheduling process 730 is started (step S632). On the other hand, if the value is not equal to 0 in step S627, the task that accesses the specified shared resource has transitioned from the execution wait state 903 to the suspended state 905, and the task group that newly accesses the shared resource in the round robin wait state 904 One of the tasks is shifted to the execution waiting state 903. First, the TCB of the first task (842, 847 or 852) of the round robin queue (841, 846 or 851) of the round robin group [shared resource group 765].
750 is extracted (step S628), the number of round-robin waiting tasks (693, 696 or 699) of the group [shared resource group 765] is decremented (step S629), and the TCB extracted in step S628 is executed with the corresponding priority 755. Wait queue 770
And the task state 756 is placed in the execution waiting state 903.
(Step S630).

The value 1 is set to the number of tasks (692, 695 or 698) waiting for execution of the shared resource of the group [shared resource group 765] (step S631).
Activate the scheduling process 730 (step S6)
32).

FIG. 24 shows a scheduling adjustment mechanism 600.
9 is a flowchart showing the procedure of the interruption release processing 640 of FIG. This process is arbitrarily started from a task or I / O interrupt process. This is a process of transitioning the designated task from the suspended state 905 to the execution waiting state 903 or the round robin waiting state 904.

First, it is determined whether or not the value of the shared resource group 765 in the TCB 750 of the task to be released from the specified suspended state is not equal to 0 (step S641). If the value is equal to 0, the task whose suspension state should be released is a task that does not access the shared resource,
The CB 750 is taken out of the suspension queue 790 (step S642), and the execution waiting queue 7 of the corresponding priority 755 is taken.
70 is added to the end, and the task state 756 is in the execution waiting state 9
03 (step S643), and activates the scheduling process 730 (step S643A).

[0107] The T of the task for which the specified suspended state is to be released
Shared resource access group 765 in CB 750 has value 0
If not, the task to be interrupted is the task that accesses the shared resource, so the interrupted task TCB 750
From the suspend queue 790 (step S64)
4). It is determined whether or not the number of round robin waiting tasks (693, 696, or 699) of the group [shared resource group 765] is equal to the value 0 (step S645).
If the value is not equal to 0, a task in the round robin waiting state 904 already exists, and the TCB extracted in step S644 is stored in the round robin group [Count2].
Round robin queue (841, 846 or 85
1) The task state 756 is added to the tail, the task state 756 is set to the round robin waiting state 904 (step S647), and the number of round robin waiting tasks (693, 696 or 699) of the group [shared resource group 765] is incremented (step S648). To return.

If the value is equal to 0 in step S645, there is no task in the round-robin waiting state 904, so that
It is determined whether or not the number of tasks (692, 695 or 698) waiting for execution of the shared resource of the group [shared resource group 765] is equal to the value 0 (step S646).

If the value is not equal to 0, one of the tasks in the shared resource group 765 is already in the execution waiting state 903, and the TC extracted in step S644
B is added to the end of the round robin queue (841, 846 or 851) of the round robin group [Count2], the task state 756 is set to the round robin waiting state 904 (step S647), and the round robin of the group [shared resource group 765] is set. Number of waiting tasks (69
3, 696 or 699) (step S648), and the process returns.

If it is determined in step S646 that the value is equal to 0, of the tasks in the shared resource group 765, the execution waiting state 9
Since the task 03 does not exist, the TCB extracted in step S644 is added to the tail of the execution waiting queue 770 of the corresponding priority 755, and the task state 756 is changed to the execution waiting state 903 (step S649). The value 1 is set to the number of tasks (692, 695 or 698) waiting for execution of the shared resource of the group [shared resource group 765] (step S650). Scheduling process 730
Is started (step S651).

[Third Embodiment] In the third embodiment,
A task scheduling device that solves the above-described problems 1 to 4 will be described. This corresponds to the case of FIG. 16 excluding the tasks (task 1 (320) and task 2 (330)) that do not access the shared resources in the second embodiment. Therefore, if the task information (550 and 551) relating to task 1 and task 2 is deleted from the initialization data 500 in FIG. 18, the other operations can be realized by the same processing as in the second embodiment.

The storage location of the startup code and initialization data 500 may be replaced with a recording medium such as a floppy disk or hard disk instead of the ROM 110.

The shared resources include not only variable data but also a hard disk, CD-ROM drive, RS
Application to communication ports such as -232C and PIO makes it possible to easily share resources from a plurality of tasks while maximizing the reliability and performance of the system.

Further, as a shared resource, it is easy to correspond to a "class" of an object-oriented language.
The reliability and performance of a system described in an object-oriented language can be maximized and implemented as a multitask system.

[0115]

According to the task scheduling apparatus of the first aspect of the present invention, the above-mentioned problems 1 to 4
Can be solved.

That is, the scheduling coordinating mechanism registers one of all tasks irrelevant to the shared resource and the task accessing the shared resource in the preemption scheduling mechanism, and all the tasks accessing the remaining shared resources are round-robin. A task that accesses the shared resources registered in order in the round-robin scheduling mechanism when the task that accesses the shared resources by scheduling by the preemption scheduling mechanism relinquishes the execution right (transition to the suspended state). In this case, the task that has transitioned to the suspended state can be registered at the end of the ordering of the round-robin scheduling mechanism when the cause of suspension is released. Therefore, even if the task accessing the shared resource occupies the CPU and continues to execute the task, the task unrelated to the shared resource can be preempted (preempted), and therefore has a higher priority than the task accessing the shared resource. Even if the priority is high or the priority is the same, a task switch occurs due to the time slice, the CPU is executed with the exclusive right of the CPU, and it is possible to prevent the whole system from being affected.
Can be solved.

In the task group accessing the shared resource, the round robin scheduling is used to
Exclusion control by the semaphore is not required, overhead at that time can be eliminated, and the aforementioned problem 1 can be solved.

Further, even for a complicated data structure, the entire data structure is regarded as one shared resource, and the relationship between the shared resource and the task can be defined in a one-to-many relationship. Problem 2 mentioned above
Can be solved.

Also, when continuous data access is required, they can be handled as one shared resource, the danger of deadlock can be eliminated, and problem 3 described above can be solved.

The same effect can be obtained in the task scheduling method according to the fourth aspect.

According to the task scheduling apparatus of the second aspect, the above problems 1 to 3 and 5 can be solved.

That is, a task group to be accessed for each shared resource is divided and managed by the scheduling adjustment mechanism as a task group, and one task from each task group is registered in the preemption scheduling mechanism, and the remaining shared resources are accessed. All the tasks are registered in order in the round robin scheduling mechanism for each task group, and when a task belonging to a certain task group (applicable task group) relinquishes its execution right (transition to a suspended state) by scheduling by the preemption scheduling mechanism, a round is performed. Replaces the tasks registered in the Robin Scheduling Order with the order of each task group with the first in the order in the corresponding task group. Of round-robin scheduling mechanism, it is possible to register at the end of the ordering in the corresponding task group. Therefore, when there are a plurality of shared resources, the accumulated access time for each of the shared resources can be evenly allocated by preemption (preemption) scheduling by time slice, and the above-mentioned problem 5 can be solved.

Further, by using round-robin scheduling in a task group accessing a shared resource, semaphore exclusion control is not required, overhead at that time can be eliminated, and Problem 1 described above can be solved.

Further, even for a complicated data structure, the entire data structure is used as one shared resource, and the relationship between the shared resource and the task can be defined in a one-to-many relationship. Problem 2 mentioned above
Can be solved.

Also, when continuous data access is required, they can be handled as one shared resource, the risk of deadlock can be eliminated, and problem 3 described above can be solved.

The same effect can be obtained in the task scheduling method according to the fifth aspect.

According to the task scheduling device of the third aspect, the above problems 1 to 5 can be solved.

That is, the task group to be accessed for each shared resource is divided and managed by the scheduling adjustment mechanism as a task group, and one task from each task group is registered in the preemption scheduling mechanism, and the remaining shared resources are accessed. All the tasks are registered in order in the round robin scheduling mechanism for each task group, and when a task belonging to a certain task group (applicable task group) relinquishes its execution right (transition to a suspended state) by scheduling by the preemption scheduling mechanism, a round is performed. Replaces the tasks registered in the Robin Scheduling Order with the order of each task group with the first in the order in the corresponding task group. Of round-robin scheduling mechanism, it is possible to register at the end of the ordering in the corresponding task group. Therefore, when there are a plurality of shared resources, the accumulated access time for each of the shared resources can be evenly allocated by preemption (preemption) scheduling by time slice, and the above-mentioned problem 5 can be solved.

Further, even if the task accessing the shared resource occupies the CPU and keeps executing, the task unrelated to the shared resource can be preempted (preempted). Even if the priority is high or the same priority is given, a task switch occurs due to time slicing, the CPU is executed with the exclusive right of the CPU, so that the entire system can be prevented from being affected, and the problem 4 described above can be solved.

Furthermore, in the task group accessing the shared resource, the use of round-robin scheduling eliminates the need for semaphore exclusive control and eliminates the overhead in that case, and can solve the above-described problem 1.

Further, even for a complicated data structure, the entire data structure is used as one shared resource, and the relationship between the shared resource and the task is defined as one.
By making it possible to define the relationship in a many-to-many relationship, it is not necessary to cut out a fine shared resource, and the problem 2 described above can be solved.

Further, even when continuous data access is required, they can be handled as one shared resource.
The risk of deadlock can be eliminated, and the aforementioned problem 3 can be solved.

The same effect can be obtained in the task scheduling method according to the sixth aspect.

As described above, even if the task accessing the shared resource occupies the CPU and continues to execute the task, the task unrelated to the shared resource can be preempted (preempted), so the shared resource is accessed. A task switch occurs due to a time slice having a higher priority than a task or the same priority, and is executed with CPU exclusive right, so that it does not affect the entire system,
It is possible to increase the reliability of the system.

When there are a plurality of shared resources, the accumulated access time for each of the shared resources can be evenly allocated by preemption (preemption) scheduling by time slice, and a stable throughput can be obtained even if the number of tasks changes. Can be constructed.

Furthermore, the use of round-robin scheduling in the task group accessing the shared resource eliminates the need for semaphore exclusion control, eliminates overhead in that case, and improves system performance. .

In addition, even for a complicated data structure, the entire data structure is used as one shared resource, and the relationship between the shared resource and the task is defined as one.
By making it possible to define the relationship in a many-to-many relationship, it is not necessary to cut out the shared resources in detail, so that the system can be easily designed and the productivity can be improved.

Further, even when continuous data accesses are required, they can be handled as one shared resource, so that the danger of deadlock can be eliminated and the reliability of the system can be improved. .

The shared resources include not only variable data but also a hard disk, CD-ROM drive, RS
Application to communication ports such as -232C and PIO makes it possible to easily share resources from a plurality of tasks while maximizing the reliability and performance of the system.

Further, as a shared resource, it is easy to correspond to a “class” of an object-oriented language.
The reliability and performance of a system described in an object-oriented language can be maximized and implemented as a multitask system.

Further, there is no need to newly develop dedicated hardware, and it is possible to easily incorporate the hardware into a real-time OS having a fixed-priority preemption schedule function. Reliability and performance can be improved.

[Brief description of the drawings]

FIG. 1 is a block diagram illustrating a configuration of a system to which a task scheduling device according to a first embodiment is applied.

FIG. 2 is a diagram showing a configuration of a scheduling adjustment mechanism 600.

FIG. 3 is a diagram showing a configuration of a preemption scheduling mechanism 700.

FIG. 4 is a diagram showing a configuration of a round robin scheduling mechanism 800.

FIG. 5 is a diagram showing a state transition of a task.

FIG. 6 is a diagram showing a configuration of initialization data.

FIG. 7 is a diagram showing a shared resource management table.

FIG. 8 is a diagram showing a configuration of a task control block.

FIG. 9 is a flowchart illustrating a procedure of an initialization process 610.

FIG. 10 is a flowchart showing a procedure of an initialization process 720 of the preemption scheduling mechanism 700.

FIG. 11 is a round-robin scheduling mechanism 800
9 is a flowchart showing a procedure of an initialization process 810 of FIG.

FIG. 12 is a flowchart showing a procedure of a scheduling process 730 of the preempt scheduling mechanism 700.

FIG. 13 is a flowchart showing a procedure of an interruption process 620 of the scheduling adjustment mechanism 600.

FIG. 14 is a flowchart illustrating a procedure of an interruption release process 640 of the scheduling adjustment mechanism 600.

FIG. 15 is a flowchart showing a procedure of a timer interrupt process 660 of the scheduling adjustment mechanism 600.

FIG. 16 is a diagram illustrating a configuration of a system to which the task scheduling device according to the second embodiment is applied.

FIG. 17 is a round robin scheduling mechanism 800.
FIG. 3 is a diagram showing the configuration of FIG.

FIG. 18 is a diagram showing a configuration of initialization data.

FIG. 19 illustrates a shared resource management table.

FIG. 20 is a diagram showing a configuration of a task control block.

FIG. 21 is a flowchart showing a procedure of an initialization process 720 of the preemption scheduling mechanism 700.

FIG. 22 shows a round robin scheduling mechanism 800
9 is a flowchart showing a procedure of an initialization process 810 of FIG.

FIG. 23 is a flowchart showing a procedure of an interruption process 620 of the scheduling adjustment mechanism 600.

FIG. 24 is a flowchart showing a procedure of an interruption release process 640 of the scheduling adjustment mechanism 600.

[Explanation of symbols]

 Reference Signs List 100 RAM 110 ROM 140 CPU 200 Shared resources 300, 310, 320, 330 Task 600 Scheduling mechanism 700 Preempt scheduling mechanism 800 Round robin scheduling mechanism

 ────────────────────────────────────────────────── ─── Continuing on the front page (72) Inventor Masataka Bessho 3-30-2 Shimomaruko, Ota-ku, Tokyo Inside Canon Inc.

Claims (6)

[Claims] 1. A task scheduling apparatus for scheduling a multitask program, comprising: a scheduling adjustment mechanism, a preemption scheduling mechanism, and a round-robin scheduling mechanism, wherein a group of tasks accessing a shared resource uses round-robin scheduling. A task scheduling device, wherein preempt scheduling is used for a task group irrelevant to a shared resource, and processing for realizing preempt scheduling is performed between both task groups. 2. A task scheduling apparatus for scheduling a multitask program, comprising: a scheduling adjustment mechanism, a preemption scheduling mechanism, and a round-robin scheduling mechanism, wherein a task group to be accessed for each shared resource is cut out as a task group. A task scheduling apparatus, wherein round robin scheduling is used independently within a task group, and processing for realizing preemption scheduling is performed between the task groups. 3. A task scheduling apparatus for scheduling a multitask program, comprising: a scheduling adjustment mechanism, a preemption scheduling mechanism, and a round-robin scheduling mechanism, wherein a task group to be accessed for each shared resource is cut out as a task group. Round robin scheduling is used independently within a task group, preemption scheduling is used for a task group unrelated to the shared resource, and preemption is performed between the task groups and between task groups unrelated to the shared resource. A task scheduling device for performing a process for realizing scheduling. 4. A task scheduling method for scheduling a multi-task program, wherein a round robin scheduling is used for a task group accessing a shared resource, a preempt scheduling is used for a task group irrelevant to the shared resource, and between the two task groups. In the task scheduling method, a process for realizing preemption scheduling is performed. 5. A task scheduling method for scheduling a multi-task program, wherein a task group to be accessed for each shared resource is cut out as a task group, and round robin scheduling is used independently in each task group. In the task scheduling method, a process for realizing preemption scheduling is performed. 6. A task scheduling method for scheduling a multitask program, wherein a task group to be accessed for each shared resource is cut out as a task group, and round robin scheduling is used independently in each task group, and is independent of the shared resource. A task scheduling method, characterized in that preempt scheduling is used for a task group, and processing for realizing preempt scheduling is performed between the task groups and between task groups irrelevant to the shared resource.