JPS6316775B2 - - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION The present invention relates to a method for controlling an information processing device, and more specifically, a method for controlling an information processing device by controlling a plurality of programs on one or more devices.
The present invention relates to a control method for efficient multiple running on the same system having a CPU.

Generally, in an information processing device, a plurality of programs are simultaneously operated in parallel in order to increase the usage efficiency of the processing device. This unit of processing that is performed simultaneously is called a task or process, and will be referred to as a task below.

Figure 1 is a conceptual diagram of conventional task execution control.
indicates a task control table, 2 indicates a task priority, and 3 indicates a group of execution queue terminals. The execution order of tasks is generally controlled as follows in order to keep the turnaround time within a specified time. Priority level 2 is set and maintained in task control table 1 in advance according to the degree of urgency. In addition, queue terminal groups 3 corresponding to priorities are provided. When a task becomes executable due to the completion of a waiting event or the like, the control program checks priority 2 in the task control table 1 and connects the task to the corresponding terminal in the queue terminal group 3 on a first-come, first-served basis. When the processing of one task is terminated or interrupted due to waiting for an event or expiration of a time slice, the control program examines the queue terminal group 3 in order of priority and executes the processing of the task with the higher priority.

When such parallel processing is performed, some shared resources such as files, control tables, and information must be used exclusively between tasks. These will be referred to as serial reusable resources (SRR) below. In other words, if one task occupies an SRR and the processing is transferred to another task, the other task that wants to use the SRR will be declared free when the task that occupies it resumes processing. It cannot be used until it is completed.

Figure 2 is a conceptual diagram of conventional SRR exclusive release control.
4 and 6 indicate tasks, 5 indicates SRR, and 7 indicates SRR release queue terminal. As shown in FIG. 2a, it is assumed that task 4 occupies SRR 5 and is connected to the terminal of the corresponding priority in execution queue terminal group 3. Here, while task 6, which has a higher execution priority than task 4, is being executed, SRR5
When the SRR 5 is already occupied, the task 6 waits for SRR release, is connected to the SRR release waiting terminal 7, and starts executing another task. Eventually, as shown in Figure 2b, when task 4 is executed and SRR5 is declared released, SRR5 is transferred to task 6 waiting at waiting terminal 7.
, and the task 6 is connected to the execution queue terminal group 3. At this time, the terminal is determined by the execution priority of the task.

In this way, conventionally there was no concept of linking and controlling the relationship between SRR occupancy and task execution priority, resulting in the following drawbacks.

(1) When transitioning to the waiting state, the priority of a task is fixed, so tasks with a higher priority than that task often end up in the waiting state due to SRR contention. Therefore, the number of state transitions of the task increases, and the system throughput decreases due to the overhead.

(2) In the case of SRR contention, even a task with a high priority has to wait for the SRR release of a task with a lower priority, so execution is delayed.
The effect of setting a high priority cannot be obtained.

(3) Even in the case of the same priority, as in (1) above, task switching increases more than necessary, resulting in a large overhead.

In order to solve these drawbacks, the present invention assigns priorities to serial reusable resources, and changes the priority of tasks waiting to be executed to the priority of the occupied serial reusable resources. The drawings will be described in detail below.

FIG. 3 is an embodiment of the present invention, and shows a conceptual diagram of control when the priority of SRR is fixedly held in a program. In Figure 3, the task that issued the SRR occupancy request is in the SRR release queue 7.
People are lining up on a first-come, first-served basis waiting for SRR to be released.
The execution queue terminal group 3 is a queue terminal for finding the next task to be executed when the CPU is free, and is made up of a plurality of terminals, which are searched in order of priority. 8 is an execution queue terminal for SRR-occupying tasks, which is a terminal to which a task that is waiting to be executed while occupying SRR should be connected. By setting the execution queue terminal 8 for SRR-occupying tasks to a higher priority than the task group using SRR, the tasks occupying SRR can be executed preferentially.

The program in Figure 4a is the occupied SRR
As part of the procedure to release SRR5, when a certain task is executed and SRR5 is declared released, the corresponding SRR
The release queue 7 is checked, and if there is a task waiting for release, the first task is removed from the queue 7, the task is made to occupy the SRR, and is connected to the execution waiting terminal 8 for SRR-occupying tasks. 10 is an SRR occupied indication in the task control table 1, which is set and controlled by the SRR occupation program and the SRR release program.

Once a CPU is assigned to a task occupying SRR,
When adopting a method of continuous processing until SRR is released, SRR occupancy display 10 is required in a program that switches tasks when a time slice expires, etc.
is checked, and if it is occupied, it can be controlled to postpone task switching.

If forced task switching due to time slice expiration or waiting for an event is allowed while the SRR is occupied, use the queuing program that connects the task shown in Figure 4b to the execution queue terminal group 3 to display the SRR occupied status in the corresponding task control table 1. Check program 10, and if occupancy is displayed, do the same as program 9.
Connect to execution queue 8 for SRR exclusive tasks.

FIG. 5 shows an embodiment in which the SRR priority is held for each SRR. In Figure 5, 9 is
The SRR priority level maintained in the SRR control table 5 defined for each SRR is shown. On the other hand, the task control table 1 is provided with a field 11 that holds the SRR priority separately from the task priority 2. As shown in Figure 6b, a program (task queuing program) that connects a task to a terminal in terminal group 3 waiting for execution checks the priority field 11 of the task control table 1 and queues the terminals with the corresponding priority. Connect to.

The priority field 11 is set to the value of task priority 2 when the SRR is not occupied, and when the SRR is occupied, the value of task priority 2 is set to the priority field 11.
is controlled so that the maximum priority is set.
This is the SRR exclusive program shown in Figure 6a,
This is achieved by comparing the priority 9 held in the control table 5 of the SRR to be occupied with the value of the priority field 11 in the task control table 1, and setting the higher priority in the priority field 11. can. In addition, the SRR release processing program checks the priorities 9 of the remaining SRRs occupied by the task, and selects the one with the highest priority as priority field 1.
Set to 1. At this time, if there is no other occupied SRR, task priority 2 held in task control table 1 is set in priority field 11.

As shown in Figure 7, the method to obtain the highest priority of the SRRs occupied by the relevant task is to chain the control table 5 of the SRRs occupied by the task control table 1 with the occupation program of Figure 6a. Then, as shown in Figure 8, how to check the priorities of chained SRRs in the release program, register the occupied tasks in the SRR control table 5 with the occupied program, and then use the release program to control all the SRRs. There is a method to examine the table. Of these, the method shown in Figure 7
The occupying program displays the occupied information in task control table 1.
In the process of chaining SRR control tables, by chaining them in order of priority, the task control table 1 is always pointed to.
Since the SRR control table can be controlled to maintain the highest priority, it is also possible to eliminate the need to check the priority of the release processing program.

Next, in the example shown in FIG. 5, the SRR priority setting methods include two methods: the entity defining the SRR also defines the priority, and an SRR occupancy procedure.
There is a method of setting based on the priority of the occupation requesting task. In the latter method, the initial value of the priority is set low, and when a request for SRR occupancy is made, the priority of the requested task is compared with the priority of SRR, and if SRR is higher, it is left as is.
If the priority of the task is higher, set the SRR to a value higher than the priority of the task (for example, a value larger by 1).
Reset as the priority.

As a result of the above priority control, the task occupying the SRR can be processed with priority over other tasks, and by defining the priority of the SRR according to the degree of urgency, It is also possible to control the execution order when there is a mixture of tasks that require a turnaround time guarantee and those that do not.

FIG. 9 is a simplified version of the embodiment shown in FIG. In this embodiment, SRR is classified into several types of classes, and a priority is set in advance for each class. In the execution queue terminal group 3, execution queue terminals 8 for SRR exclusive tasks are prepared in accordance with the priority of each class. On the other hand, task control table 1 has an item (occupancy multiplicity) 12 representing the number of occupied SRRs for each class.
will be established. Further, in order to know which class each SRR belongs to, a code representing the class type is set in the SRR control table 5. The SRR exclusive program adds 1 to the exclusive multiplicity 12 corresponding to the relevant class in the control table of the exclusive requesting task. Further, the SRR occupation cancellation program subtracts 1 from the occupation multiplicity 12.

Fig. 10 is a task queuing program corresponding to Fig. 9, which checks the corresponding task occupancy multiplicity, and if all of them are zero, connects the task to the terminal with the task's original priority; otherwise, the occupancy multiplicity is Connect the task to the terminal with the highest priority among non-zero classes. In this example,
The advantage is that the task priority change procedure when occupying and releasing SRR is simple and requires little overhead.

As explained above, according to the present invention,
When connected to the execution queue while occupying an SRR, the execution priority is given according to the priority given to the SRR, so the priority is higher than the highest priority among tasks that share the SRR. By giving priority to the SRR, there are the following advantages.

(1) Tasks occupying SRR can be processed preferentially, and the time occupied by SRR can be shortened.
This reduces the chance that other tasks will encounter SRR contention, and reduces the chance of overload caused by task switching.
Heads can be reduced.

(2) If a task with a lower priority is connected to the execution queue while occupying an SRR, the same SRR
It is possible to avoid the priority inversion phenomenon in which high-priority tasks that use SRR are delayed in execution compared to other low-priority tasks due to waiting for SRR release, and throughput can be improved.

(3) When a task becomes executable, its priority is compared with the priority of the task currently being executed, and if the former is higher, the task is forcibly switched (so-called preemption control). ), task switching is often performed while occupying SRR, so (1)
The improvement effect of (2) is even greater.

[Brief explanation of the drawing]

Figure 1 is a conceptual diagram of conventional task execution control;
The figure is a conceptual diagram of conventional SRR occupation release control, Figure 3 is a conceptual diagram of an embodiment of the present invention, Figure 4 is a flow diagram of a program used in the embodiment of Figure 3, and Figure 5 is a conceptual diagram of a conventional SRR occupation release control.
The figure is a conceptual diagram of another embodiment of the present invention, and FIG.
A flow diagram of the program used in the embodiment of the figure,
Figures 7 and 8 show the SRR occupied by tasks.
FIG. 9 is a conceptual diagram of yet another embodiment of the present invention, and FIG. 10 is a flow diagram of a program used in the embodiment of FIG. 1...Task control table, 2...Task priority, 3
...Execution queue terminal group, 4, 6...Task, 5...Serial reusable resource (SRR), 7...SRR release queue terminal, 8
...Execution queue terminal for SRR occupancy, 9...
...SRR priority, 10...SRR occupancy display, 11...
...Priority field, 12... Occupancy multiplicity.

Claims (1)

[Claims] 1 A CPU allocation priority is set for a processing unit for running multiple programs in parallel, and according to this priority, the execution order of processing units waiting for allocation is controlled, and processing units other than In an information processing device that is equipped with a means for defining resources to be used in common and serially with the processing units of If the resource is occupied, the priority of the resource is used to control the execution order of the processing unit, and if the resource is not occupied, the CPU allocation priority of the processing unit is used to control the execution order. A method for controlling an information processing device.