JPH09319597A - Scheduling method for cyclic process - Google Patents

Abstract

PROBLEM TO BE SOLVED: To keep constant the execution interval of respective process groups as much as possible in the case of parallelly executing the plural process groups including a process group to be cyclically executed. SOLUTION: When a group master process 102 of respective process groups 103 requests the allocation of CPU time while designating a start interval cycle and the CPU time required for each cycle, the CPU allocation time of the designated process group 103 is secured so as not to compete with the CPU allocation time of the other process group 103, and a CPU allocation order description table is prepared so as to keep the designated start interval cycle. At the point of the time of activating any one process group 103, a kernel process 101 is activated by changing the execution priority of a process belonging to this process group 103 into the peak priority inside a system and afterwards, the peak priority is kept only for the continuously allocated CPU allocation time.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a process scheduling method, and more particularly to a process scheduling method for periodically activating each process.

[0002]

2. Description of the Related Art Conventionally, as a scheduling method of a process for performing continuous media processing, Conductor / Perfor
mer model (1st International Workshop on Real-Tim
A scheduling method using e Operating Systems and Applications, 1994) has been known. Continuous media processing refers to processing for converting and transferring data obtained by digitizing images and sounds.

In this method, when there is one stream in the system, the processes belonging to the stream are guaranteed to be periodically scheduled. However,
The stream here refers to a process group that directly or indirectly passes the processed continuous media data.
The processes belonging to the same stream are uniquely determined in the order of processing the continuous media processing data. The first process gets an input of continuous media data from an external device (eg a video digitizer). Subsequent processes receive the continuous media data processed by the previous process from the process in the previous order, perform the data processing (such as compression processing) that they should do, and process it in the process after the one in the order. Send continuous media data. The last process outputs continuous media data to an external device (eg network adapter).

The outline of the scheduling method using the Conductor / Performer model is shown below. One cyclically driven Conductor process is prepared for each stream. The order of Performer processes (processes belonging to streams) that the Conductor process should start is registered in advance. The Conductor process starts the Performer process according to the registered order. Therefore, the Conductor process and Performer process both have a message queue for waking up their own process. The other process is activated by sending a message to the message queue held by that process.

The Conductor process is driven at specified intervals. Conductor process is registered P
Performer in the next order according to the order of the erformer process
r Repeatedly issues a call (function call) that sends a message to the message queue owned by the process and waits for a message to arrive at the message queue owned by the Conductor process. That is, the Conductor process starts the Performer process according to the order of the registered Performer processes and the Perfo that has started.
The sleep is repeated until the rmer process finishes executing one cycle. Once the last Performer process has completed execution, the Conductor process sleeps until the next period-driven trigger is triggered by a timer interrupt.

On the other hand, the Performer process is based on Conductor
Wake up by receiving a message from the process,
Perform continuous media processing for one cycle. When one cycle of continuous media processing is completed, the Conductor process issues a call to send a message to the owner's message queue and wait for the arrival of the message in the message queue owned by the own process. The Performer process will sleep until the Conductor process sends a message announcing the start of the next cycle.

[0007] The above scheduling method guarantees that the Performer process is periodically assigned a CPU when there is one stream in the system.

[0008]

[Problems to be Solved by the Invention] Conductor / Performer
The scheduling method according to the model causes the following problems when there are a plurality of streams existing on the system.

(A) Each Conductor process and Perfor
mer process priority does not change over time. Therefore, when Conductor processes with different drive cycles coexist, the execution start interval of Conductor processes fluctuates.
That is, when the Conductor process is awakened, it is possible that another Conductor process with equal or higher priority or another Performer process is running. That is, the CPU time contention occurs between the awakened Conductor process and another Conductor process or another Performer process, and this causes the Conducto process.
r Process execution start interval fluctuates and continues
The execution interval of the Performer process also changes.

(B) Wakeup notification is interprocess communication (IPC)
The function call for message transmission and message reception occurs, and the overhead associated with wakeup notification is large.

These problems make it difficult to realize continuous media processing requiring high throughput such as real-time MPEG compression processing of multimedia data. In these processes, unless the buffer management at the time of continuous media data input is performed without using interrupts, sufficient throughput cannot be obtained due to interrupt overhead. To do this, keep the Performer process execution intervals as constant as possible, even if there are multiple streams in the system, and perform them without interrupt notification.
The process must voluntarily switch input buffers. Similarly, the overhead of IPC used for wake-up notification also lowers the throughput.

Further, a scheduling method according to the Conductor / Performer model has a deadline miss (Conducer
The state where the processing for one cycle could not be completed within the specified time from the driving of the tor process) is notified by the signal to the Conductor process. Signal handlers usually have the same priority as the target process, so
The signal handler process may delay the execution of processes in other streams. That is, the processing delay of one stream may cause the processing delay of another stream.

The present invention (a) keeps the execution interval of the process for performing continuous media processing constant even if a plurality of streams exist in the system, and (b) reduces the overhead associated with the control of the process wake-up and sleep. Make it smaller,
(C) By executing a signal handler that performs processing delay recovery processing, even if processing delay of one stream occurs, processing delay of other streams does not occur.
(D) To provide a periodic process scheduling method for preventing fluctuations in the execution interval of a process that performs continuous media processing when an asynchronous event such as arrival of a network packet occurs.

[0014]

According to the present invention, there are provided a plurality of process groups including at least one process that is periodically executed, and a method for scheduling a periodic process in which these plurality of process groups are executed in parallel, When the activation interval cycle and the required CPU time for each cycle are specified for each process group, ensure that the CPU allocation time of the specified process group does not conflict with the CPU allocation time of other process groups, and it is specified. It is characterized by a periodic process scheduling method that adjusts so as to maintain the activation interval period of each process group.

Further, according to the present invention, when it is time to start one of the process groups, the process is started by changing the execution priority of the process belonging to this process group to the highest priority in the system, and then continuously. It is characterized by a process start-up method that keeps the highest priority for the CPU allocation time that has been allocated.

The present invention also provides for the consecutively assigned C
When the PU allocation time has passed and the required CPU time has been consumed, the execution priority of the started process is changed from the highest priority in the system to the reference priority, and a timeout is notified to this process. Is characterized by.

Further, according to the present invention, when an asynchronous event for receiving information such as arrival of a network packet occurs during execution of a process having the highest priority in the system, the process running at the highest priority is immediately executed. Stop the execution of the process, secure the information reception buffer and prepare to receive the information, then restart the execution of the process that has stopped execution, and process by referring to the information received by the process that is started periodically. It is characterized by an asynchronous event processing method.

[0018]

Embodiments of the present invention will be described below in detail with reference to the drawings.

(1) First Embodiment FIG. 1 shows the flow of process activation and the flow of continuous media data for realizing the scheduling method of the present invention.
Shown in The system has one cycle-driven kernel process
(101) exists. The cycle-driven kernel process (101)
It is a control process that is periodically driven by the timer interrupt handler (104). Periodically driven kernel process (10
1) refers to the CPU allocation order description table (900), selects a process (hereinafter referred to as periodic process) (102) group that processes continuous media data next, and gives priority to the selected periodic process (102) group. By changing the degree, the periodic scheduling of each periodic process (102) is realized.
When there is no periodic process (102) to be scheduled, the other normal processes (109) are scheduled. Details of this operation will be described later.

At least one periodic process (102) that processes the same continuous media data forms a process group (103). The processing order of the periodic processes (102) belonging to the process group (103) is predetermined. The cyclic process (102) with the first processing order is preferentially driven by the priority change by the cyclic driving kernel process (101) and receives the input continuous media data from the external input device (105) through the input buffer (106). Read and process the data. Shared buffer for processed data
The processing order is passed to the next periodic process (102) via (110) and the like. Periodic process (102) in process group (103)
The priority of each process is inherited one after another, and the cyclic process (102) with the last processing order receives the external output device (1) via the output buffer (107).
This is output to 08) and the priority of the own process is lowered to substantially end the processing of one cycle of this process group (103). The system has multiple process groups (10
3) There may be, for example, a process group that processes audio information and a process group that processes image information.

A scheduler (not shown) is called by a function call, and a CPU allocation order description table
Create (900) or perform the process to drive the specified process. The scheduler is a group of program modules operated by the called process to perform processing related to scheduling.

A group master process exists in the process group. The group master process is a process having the first processing order among the processes belonging to the process group. Processes belonging to a process group other than the group master process are called slave processes. Creating a process group (103),
Deletion is performed by the group master process using the following interface.

<Function name> create_proc_group (master_pid, slave_pid_array, proc
_array_number, pgroupid) <Argument> master_pid: Process identifier of the group master process slave_pid_array: Array of slave process identifiers that make up the group proc_array_number: Number of slave process identifiers that make up the group pgroupid: The identifier of the created process group is returned. <Return value> SUCCESS: Normal termination or various error codes <Description> The create_proc_group function creates a process group with the process specified by master_pid as the group master. The created process group is mast
In addition to the process specified by er_pid, slave_pid_arra
It consists of the process group specified by y and proc_array_number. The generated process group identifier is returned in pgroupid. Note that master_pid and slave_pid_array
It is assumed that the individual process with the process identifier specified by is already created.

<Function name> destroy_proc_group (pgroupid) <Argument> pgroupid: Process group identifier <Return value> SUCCESS: Normal termination or various error codes <Explanation> The destroy_proc_group function deletes the process group specified by pgroupid.

FIG. 2 shows the data structure of the array data and control block used for managing the process group.

The process group is managed by using the process group control block (202). The process group control block (202) has a master_pid field (20
3), pid_array field (204), nproc field (20
It consists of 5). The master_pid field (203) stores the process identifier of the group master process of the process group. The pid_array field (204) stores a pointer to the process identifier array (206). The process identifier array (206) is an array of process identifiers of slave processes that form a process group. The nproc field (205) stores the number of process identifiers stored in the process identifier array (206). In addition, conversion from the process group identifier to the process group control block (202) is performed by the process group control block pointer array.
Use (201). That is, the pointer to the process group control block (202) is stored in the element of the process group control block pointer array (201) having the process group identifier as an index. If the process group control block (202) corresponding to the process group identifier does not exist, nil is set in the corresponding element of the process group control block pointer array (201).
The pointer is stored.

The processing flow of the create_proc_group function is shown in FIG.

In step 301, one of the elements of the process control block pointer array (201) in which the nil pointer is stored is searched. Its index value pgr
It is the return value of oupid.

In step 302, a memory area used for the process group control block (202) is secured.

In step 303, the process identifier array (206)
Reserve a memory area for use.

In step 304, the identifier of the group master process designated by the argument master_pid of the create_proc_group function is stored in the master_pid field (203) of the process group control block (202) whose memory area was secured in step 302.

At step 305, the array of process identifiers of the slave processes specified by the argument slave_pid_array of the create_proc_group function is copied to the process identifier array (206) which secured the memory area at step 303.

In step 306, the process identifier array (206)
Store a pointer to the pid_array field (204).

In step 307, the number of slave process identifiers forming the process group specified by the argument proc_array_number of the create_proc_group function is stored in the nproc field (203) of the process group control block (202) whose memory area is secured in step 302. Store.

The processing flow of the destroy_proc_group function is shown in FIG.

In step 401, an element of the process group control block pointer array (201) having the argument pgroupid of the destroy_proc_group function as an index is searched, and the process group control block (2
Release the memory area used by 02).

In step 402, the memory area used by the process identifier array (206) pointed to by the pid_array field (204) of the process group control block (202) is released.

In step 403, the nil pointer is assigned to the element corresponding to the process group to be released in the process group control block pointer array (201).

The process group (103) serves as a scheduling unit. At the time of initialization, the group master of the process group (103) uses the alloc_time_slot function to reserve that the CPU is allocated to the process group (103) for the specified time at each specified cycle. When CPU time allocation becomes unnecessary, call the dealloc_time_slot function to release the reservation.

When the alloc_time_slot function is called,
The scheduler determines the CPU allocation order that satisfies the cycle required by each process group and the execution time per cycle, and the CPU allocation order description table (900)
Create This creation algorithm will be described later.

The cyclic kernel process (101) is based on the CPU allocation order description table (900).
The scheduling of (102) is performed. Process group
When the time to allocate the CPU for (103) is reached, the periodical kernel process (101) raises the priority of the group master process of that process group (103)
to ed. The periodic process (102) with priority raised is
Guaranteed to have the highest priority of any user process. It is also guaranteed that the process (102) with a raised priority has a higher priority than the cyclically driven kernel process (101).

The priority of the group master process is raise
When the specified time elapses after d, the timer interrupt handler (104) sets the priority of the periodic process (102) whose priority is raised among the periodic processes (102) belonging to the process group (103) to depressed. (A group master process can inherit the priority to another periodic process (102) belonging to the same process group (103). This will be described later). Priority is depressed
Process (102) is guaranteed to have the lowest priority among the user processes.

As a result, the CP is assigned to the process group (103).
As long as the cyclic process (102) belonging to the process group (103) whose priority is raised is in the runnable state, the time to which U should be allocated is as long as the user process or the cycle-driven kernel process (103) that does not belong to the process group (103) Ten
1) is never scheduled. Also, the time that the CPU should not be allocated is the process group (1
The periodic process (102) belonging to 03) is not scheduled. CPU time that is not allocated to any periodic process (102) is allocated to a normal process (109) or an idle process that executes an endless loop and is always ready to run. Idle process priority depre
C to the periodic process (102) or periodic drive kernel process (101) by setting ssed to the next lowest priority.
It is guaranteed that PUs are not scheduled at times when they should not be allocated.

Alloc_time_slot function, dealloc_time_slo
The external specifications of the t function are as follows.

<Function name> alloc_time_slot (pgroupid, interval, length) <Argument> pgroupid: Process group identifier for which CPU allocation is guaranteed interval: Process startup interval length: Process group execution time per cycle to be secured <Return value> SUCCESS: Normal termination or various error codes <Explanation> The alloc_time_slot function indicates that the process group specified by pgroupid will be allocated the CPU for the period specified by interval at the cycle specified by interval. Request. The interval and length are specified in units of a given time slot. At the cycle specified by interval, the priority of the group master process is
become raised. The group master process is proc_rai
By using the se_handoff function (described later), it is possible to set the priority of other processes belonging to the process group to raised and change the own process to depressed (or reference priority). Group master process priority
When the time specified by length elapses after being raised, the priority of the processes in the process group whose priority is raised is forced to d.
Change to epressed. In addition, a timeout signal is sent to that process.

The value of interval must be a power of two. If any other value is specified, the scheduler processes as if the maximum power-of-two value less than the specified value was specified.

<Function name> dealloc_time_slot (pgroupid) <Argument> pgroupid: Process group identifier for canceling CPU allocation guarantee <Return value> SUCCESS: Normal termination or various error codes <Explanation> The dealloc_time_slot function is specified by pgroupid. Releases the CPU allocation request held by the specified process group.

The scheduler requested to allocate the CPU by the alloc_time_slot function cannot always schedule the process group (103) as requested by all the process groups (103). As shown in FIG. 5, since multiple process groups (501, 502) cannot be scheduled at the same time, the CPU allocation time (503) of any one of the overlapping process groups (501, 502) This is because it is necessary to shift the overlapping time to another time (504).

The scheduler determines the CPU allocation time of each process group (103) according to the following algorithm, and registers the result in the CPU allocation order description table (900) described later. CPUs are assigned in units of timer interrupt generation intervals. The real time is divided into time slot groups at the time when the timer interrupt occurs. The process group (103) to be assigned to each time slot is determined according to the following algorithm.

A flowchart of the algorithm is shown in FIG.

In step 601, the maximum Interval value among the Interval values requested by the process group (103) to be allocated (the process group (103) for which the CPU allocation reservation request has already been issued by the alloc_time_slot function) The time slot table (700) shown in FIG. 7 having the same size as that of is created. The time slot table (700) is a one-dimensional array, and each element of the array stores a process group (103) identifier to be assigned to the corresponding time slot. An identifier indicating that the corresponding time slot has not been assigned is stored as the initial value of each element.

In step 602, the process group (10
Examine the existence of 3). When the time slots have been assigned to all the process groups (103), the process ends normally (step 613).

In step 603, the process group (10
Of the 3), Int requested when the alloc_time_slot function was issued
Select the process group (103) with the smallest erval value.

In step 604, the Inte required by the process group (103) selected in step 603 is requested.
Assign the rval value to I and the Length value to L.

In step 605, unassigned time slots among time slots 0 to I-1 are grouped into adjacent time slots. Hereinafter, the time slot group X _i (i = 1, 2, ... N) grouped in this step will be referred to as a continuous empty time slot.

In step 606, if the total size (number of time slots) of the continuous empty time slot group obtained in step 605 is smaller than L, the time slots satisfying the requirements of all process groups (103) are When it is determined that the allocation is impossible, the process ends abnormally (step 614).

In step 607, the size of L is compared with the one having the largest size among the consecutive empty time slots obtained in step 605.

If L is smaller, then in step 608, of the consecutive free time slots having a size equal to or larger than the size of L, the one with the smallest size is selected.

In step 609, the first L time slots of the continuous empty time slots selected in step 608 are set to the process group selected in step 603.
Assign to (103). In addition to the timeslots assigned here, the timeslots after the I, 2I, 3I ... timeslots are also assigned to the process group (10
Assign to 3). This completes the time slot assignment for the process group (103) selected in step 603 and jumps to step 602.

In step 607, if L is larger than the largest contiguous empty timeslot size obtained in step 605, in step 610 the largest contiguous empty timeslot is selected.

In step 611, all the time slots belonging to the continuous empty time slots selected in step 610 are selected as process groups (103) selected in step 603.
Assign to. In addition to the timeslots assigned here, the timeslots after I, 2I, 3I ... timeslots are also the process groups selected in step 603.
Assign to (103).

In Step 612, from L to Step 610
The value obtained by subtracting the size of the continuous empty time slot selected in is set as a new L value, and the process jumps to step 605.

An example of creating the time slot table (700) will be described with reference to FIGS. 7 and 8.

There are three process groups (103) to which time slots are assigned. Figure 8 shows the Interval value (801) and Length value (802) required by each process group (103).
Shown in

First, the time slot table (700) having a size of 32 which is the maximum value of the Interval value (801) requested by the three process groups (103) is created.
Each element of the time slot table (700) is initialized to an identifier indicating unallocated.

The time slot assigned to the process group A having the smallest Interval value (801) is determined. Continuous empty time slots are generated from the time slot group of time slots 0 to 7. In this case, time slots 0-7
One continuous empty time slot of size 8 is generated.

Lengt requested by process group A
Since the h value (802) 2 is smaller than the size 8 of the continuous empty time slot generated earlier, the first two time slots of this continuous empty time slot, that is, time slots 0 and 1 are assigned to the process group A. In addition to this, the Interval value (8
The time slot after the integer multiple of 01) 8 is also assigned to the process group A. That is, time slots 0, 1
In addition, 8, 9, 16, 17, 24, and 25 are process groups A
Assigned to. According to this, the corresponding element of the time slot table (700) is updated. This completes the time slot allocation for process group A.

Next, the time slot to be assigned to the process group B having the second smallest Interval value (801) is determined. A continuous empty time slot is generated from the time slots 0 to 15. In this case, two consecutive empty time slots of size 6 each including time slots 2 to 7 and time slots 10 to 15 are generated.

Lengt requested by process group B
The h value (802) 3 is smaller than this size 6. A consecutive empty time slot having the smallest size is selected from consecutive empty time slots having a size of 3 or more. Here, a continuous time slot consisting of time slots 2 to 7 is selected. The first 3 time slots of the continuous empty time slots are assigned to the process group B. That is, the time slots 2 to 4 are assigned to the process group B. Similarly, the time slots 18 to 20 are also assigned to the process group B. According to this, the corresponding element of the time slot table (700) is updated. This completes the time slot allocation for process group B.

Finally, the time slot assigned to the process group C is determined. From time slots 0-31,
Create consecutive empty slots. In this case, the following consecutive empty time slots are generated. -Size 3 consecutive empty time slots consisting of time slots 5-7-Size 6 consecutive empty time slots consisting of time slots 10-15-Size 3 consecutive empty time slots consisting of time slots 21-23-Time slot 26- Consecutive free time slot of size 6 consisting of 31 Length value (802) 7 requested by process group C
Is larger than the maximum size 6 of the consecutive empty time slots. Therefore, first, one continuous empty time slot having the maximum size 6 is selected. Here is time slot 10
Suppose a continuous empty time slot consisting of ~ 15 is selected. All time slots belonging to this continuous time slot, that is, time slots 10 to 15 are assigned to the process group C. According to this, the corresponding element of the time slot table (700) is updated.

Lengt requested by process group C
The remaining 1 time slot is assigned by subtracting the size 6 of the previously selected continuous empty time slot from the h value (802) 7. Again, consecutive empty slots are generated. In this case, the following continuous empty time slots are generated.・ Size 3 continuous empty time slots consisting of time slots 5 to 7 ・ Size 3 continuous empty time slot consisting of time slots 21 to 23 ・ Size 6 continuous empty time slot consisting of time slots 26 to 31 1 or more sizes Of the continuous free time slots that we have,
Select the one with the smallest size. In this case, consecutive empty time slots consisting of time slots 5 to 7 are selected. The first one time slot of the continuous empty time slots, that is, the time slot 5 is assigned to the process group C. According to this, the time slot table
Update the corresponding element in (700). This completes the time slot allocation for process group C.

By the above processing, the process group assigned to each time slot is determined as shown in FIG. From now on, the scheduler is the CPU shown in FIG.
An allocation order description table (900) is generated. This CPU
The allocation sequence description table (900) shows the order of the process group (915) to which the CPU should be allocated and its allocation time.
This table describes (916) (number of time slots). Further, the scheduled end flag (917) indicates whether or not the allocation for one cycle of the process group (915) will be completed when the CPU allocation for the row is completed. For example, the scheduled end flag (917) of 903 is OFF or FALSE because the allocation for one cycle is not completed even if the time slot 5 is allocated to the process group C, but 90
The end scheduled flag (917) of 6 is ON or TRUE because allocation of one cycle is completed if time slots 10 to 15 are allocated. Time slot table (7
The conversion algorithm from 00) to the CPU allocation order description table (900) is self-explanatory, and is therefore omitted. Index (9
14) is a pointer indicating a row (entry) of the CPU allocation order description table (900) to which the CPU is allocated next.
The time slot in which the process group (915) specifies OTHERS is the time slot assigned to the normal process (109). OTHERS (907) indicates that the free time slot is assigned to the normal process (109) when the execution of the periodic process in the process group C ends before the 6 time slots assigned to the process group C have elapsed. Shows.

Whenever the alloc_time_slot function is issued, the scheduler creates a new table and an existing table as shown in FIG.
Recreate the CPU allocation order description table (900) based on the request from the alloc_time_slot function.

CPU generated according to the above algorithm
According to the allocation order description table (900), the periodic drive kernel process (101) schedules the process group (103). Periodically driven kernel process (101)
Rai the priority of the periodic process (102) that belongs to the process group (103) that requested periodic CPU allocation.
Achieve this scheduling by changing to sed or depressed or the base priority.

A periodic process whose priority has been raised by the periodic driving kernel process (101) changes its own priority to depressed and sets the priority of other periodic processes belonging to the same process group to rai.
Enables handoff scheduling within a process group by changing to sed.

To change the priority, proc_raise, proc_raise
_cancel, proc_raise_handoff, proc_depress, proc_de
Use the press_cancel function. The external specifications of these functions are shown below.

<Function name> proc_raise (pid, time, flags) <argument> pid: process identifier time: time to keep priority in raised flags: flag to specify priority after the specified time has elapsed. The following flags can be specified. RIORITY_NORMAL Change the process priority to the standard priority. PRIORITY_DEPRESSED Change the process priority to depressed. Also, the following flag specifies whether to send a signal to the process specified by pid when the specified time has elapsed. SEND_SIGNAL Send a timeout signal to the process specified by pid when the specified time has elapsed. <Return value> SUCCESS: Normal termination or various error codes <Description> The proc_raise function sets the priority of the process specified by pid to raised for the time (number of time slots) specified by time. time is the time assigned to the process group to which the process belongs (916)
Or specify INFINITY. A process with a raised priority is guaranteed to have a higher priority than any other user process.

Raise the priority of multiple processes simultaneously
You can't. If this function is called when there is already a process whose priority is raised,
This function returns with an error.

When INFINITY is set for time, the proc_raise_cancel function for the process
The priority of the process is kept raised until the proc_raise_handoff function is issued. INFINITY is specified, for example, when the timer interrupt handler (104) starts the cyclically driven kernel process (101). INFINITY is not normally specified when invoking the periodic process (102).

If a value other than INFINITY is specified for time, the proc_raise_cancel function or proc_r will be executed for the process even if the time specified by time has elapsed.
If the aise_handoff function is not issued, the process priority is forcibly changed according to the flags specified in flags. If PRIORITY_NORMAL is specified in flags, the process priority is changed from raised to the standard priority. PRIORITY_DE on flags
If PRESSED is specified, the priority of the process changes from raised to depressed. Furthermore flags
If SEND_SIGNAL is specified in, a timeout signal is sent to that process. The process that receives the time-out signal is started according to the set priority, and the process in the case of time-out can be performed.

<Function name> proc_raise_cancel (pid, flags) <Argument> pid: Process identifier flags: Flags that specify the priority after the change. The following can be specified. PRIORITY_NORMAL Change process priority to base priority. PRIORITY_DEPRESSED Change the process priority to depressed. <Return value> SUCCESS: Normal termination or various error codes <Explanation> The proc_raise_cancel function flags the priority of the process set to raised by the proc_raise function.
Change accordingly. When PRIORITY_NORMAL is specified in flags, the changed priority becomes the standard priority according to the scheduling attribute. PRIORIT in flags
If Y_DEPRESSED is specified, the changed priority will be depressed.

<Function name> proc_raise_handoff (pid, flags) <Argument> pid: Process identifier flags: Flags that specify the priority after handoff. The following can be specified. PRIORITY_NORMAL Change process priority to base priority. PRIORITY_DEPRESSED Change the process priority to depressed. <Return value> SUCCESS: Normal termination or various error codes <Explanation> The proc_raise_handoff function raises the priority of the process specified by pid and changes the priority of its own process according to flags. The process specified by pid must belong to the same process group as the calling process. Otherwise, it returns with an error. If PRIORITY_NORMAL is specified in flags, the priority of the calling process after handoff becomes the standard priority. PRIORITY_DEPRESSED in flags
If is specified, the priority of the calling process after handoff is depressed.

The priority of the calling process must be raised. If a process whose priority is not raised calls this function, an error will be returned.

When the upper limit time for which the priority of the calling process is kept raised is specified (when a time argument other than INFINITY is specified in the time argument of the proc_raise function), the priority of the handoff destination process is raised.
The time that is kept at this time is the time that the priority of the process of the handoff source that remains at the time of the call is kept at raised. If no time limit is specified for the calling process to keep its priority raised, there is no time limit to keep the priority of the handoff process raised.

<Function name> proc_depress (pid, time, flags) <Argument> pid: Process identifier time: Time to keep priority priority depressed: Flag to specify priority after the specified time has elapsed. The following flags can be specified. PRIORITY_NORMAL Change process priority to base priority. PRIORITY_RAISED Change process priority to raised. <Return value> SUCCESS: Normal termination or various error codes <Description> The proc_depress function sets the priority of the process specified by pid to depressed for the time (number of time slots) specified by time. Priority is depresse
A process that is d is guaranteed to have a lower priority than any other user process. The proc_depress function is issued mainly for the purpose of causing the periodical kernel process (101) to lower the priority of its own process and activate the normal process (109).

When INFINITY is set for time, the priority of the process is kept depressed until the proc_depress_cancel function or the proc_raise_handoff function is issued to the process.

When a value other than INFINITY is specified for time, if the proc_depress_cancel function is not issued to the process even if the time specified by time has elapsed, the flag specified by flags is set. The process priority is forced to change accordingly. in flags
If PRIORITY_NORMAL is specified, the process priority is changed from depressed to the standard priority. flags
If PRIORITY_RAISED is specified in, the process priority changes from depressed to raised.

<Function name> proc_depress_cancel (pid, flags) <Argument> pid: Process identifier flags: Flag designating the changed priority. The following can be specified. PRIORITY_NORMAL Change process priority to base priority. PRIORITY_RAISED Change process priority to raised. <Return value> SUCCESS: Normal termination or various error codes <Explanation> proc_depress_cancel function calls proc_depress
Change the priority of processes set to depressed by the function according to flags. PRIORITY_NORMA in flags
If L is specified, the priority of the changed process will be the reference priority. If PRIORITY_RAISED is specified in flags, the priority of the changed process will be raised.

FIG. 10 shows the data structure of the array data and control block necessary for realizing the above-mentioned function group.

Process management is performed by the process control block (100
2) is performed. The process control block (1002) of the process in the ready (ready) state is assigned to the bidirectional queue (hereinafter referred to as the bidirectional ready queue) that has the elements of the ready queue header array (1001) in the queue header for each priority. Connected. Ready queue header array (1001) is
It is an array of queue headers (pointers pointing to process control blocks) of bidirectional ready queues for each priority, with the priority index. However, the smaller the value of the priority, the higher the priority. The highest priority value is represented by raised and the lowest priority value is represented by depressed.

The process control block (1002) holds the next_proc field (1003) and the prev_proc field (1004) in order to connect to the bidirectional ready queue for each priority. A pointer to the process control block (1002) behind the bidirectional queue and a pointer to the previous process control block (1002) are stored respectively. However, prev_ of the first process control block (1002) of the bidirectional ready queue
The proc field (1004) contains the ready queue header array.
The pointer to the element of (1001) is stored. It also includes a nexus to the tail process control block (1002) of the bidirectional ready queue.
A nil pointer is stored in the t_proc field (1003).

The process control block (1002) also includes a counter field (1005) and flags field (100
6), context field (1007), base_pri field
(1010) exists. The counter field (1005) holds the remaining time (the number of time slots) that the process can maintain the priority of raised or depressed. flags
The field (1006) stores a flag indicating the priority of the process to be changed after the time in which the priority of raised or depressed can be maintained. The context field (1007) is a save area for the execution context of the process. The base_pri field (1010) stores the reference priority of the process when the process is created.

Process identifier to process control block
Conversion to (1002) is a process control block pointer array
Use (1009). That is, the pointer to the process control block (1002) is stored in the element of the process control block pointer array (1009) having the process identifier as an index. If the process control block (1002) corresponding to the process identifier does not exist, ni is set in the corresponding element of the process control block pointer array (1009).
l Stores the pointer.

The ctxproc (1008) also stores a pointer to the process control block (1002) of the currently executing process.

The processing flow of the proc_raise function is shown in FIG.

In step 1101, the scheduler obtains the element of the process control block pointer array (1009) having the argument pid of the proc_raise function as an index, and sets the process control block (1002) pointed to by the element to the bidirectional ready queue. Dequeue from.

At step 1102, ready queue header array
Find the element whose index is raised in (1001), and add the process control block (100
Enqueue 2).

At step 1103, the argument of the proc_raise function
The value specified by time is stored in the counter field (1005) of the process control block (1002) obtained in step 1102.

At step 1104, arguments of the proc_raise function
The value specified by flags is stored in the flags field (1006) of the process control block (1002) obtained in step 1102.

At step 1105, the current execution context (values of various registers) is set to the context field (10) of the process control block (1002) pointed to by ctxproc (1008).
Move to 07).

At step 1106, a pointer to the process control block (1002) of the process having the highest priority in the system is stored in ctxproc (1008). The process control block of the process with the highest priority in the system can be retrieved using the following procedure. First, the ready queue header array (100
Among the bidirectional ready queues stored in 1), the bidirectional ready queue with a queue length of 1 or more and the smallest index value is obtained. The process control block (1
002) becomes the desired process control block (1002). Here, the process specified by the argument pid of the proc_raise function and connected to the ready queue header array (1001) with the value raised in step 1102 is the process with the highest priority.

In step 1107, the execution context saved in the context field (1007) of the process control block obtained in step 1106 is restored. Step 11
The process of 07 causes the process to be switched, and the process whose execution context has been recovered is dispatched.
Note that between step 1104 and step 1105, the contents of ctxproc (1008) and the process control block pointer of the process with the highest priority in the system are compared, and if both are the same, the processing of steps 1105 to 1107 can be skipped. .

Proc_raise_cancel, proc_raise_handoff,
The proc_depress and proc_depress_cancel functions also have the same ready queue operation as in steps 1101 to 1102, and
Update various fields of the process control block (1002) similar to steps 1103 to 1104 (if necessary), and
This can be realized by saving the execution context similar to step 1105 and recovering the execution context of the process having the highest priority in the system similar to steps 1106 to 1107. The process flow is the same as the proc_raise function, so it is omitted.

When the proc_raise function and the proc_depress function are issued, it is necessary to check whether or not the time designated by the argument time has elapsed since the function was issued. This check uses the counter field (1005) of the process control block to timer interrupt handler (104).
Done within Also timer interrupt handler (104)
Also performs the driving process of the periodical driving kernel process (101). FIG. 12 shows a processing flow of the timer interrupt handler (104) which performs these operations. A timer interrupt is generated for each preset time slot, control is passed to the timer interrupt handler (104), and the processing shown in FIG. 12 is executed.

At step 1201, the element having raised in the ready queue header array (1001) as an index is obtained,
Process control block stored in that element (1002)
Assign a pointer to to the variable PCB.

In step 1202, it is checked whether the PCB value updated in step 1201 is a nil pointer. If it is a nil pointer, go to step 1207 and nil
If it is not a pointer, jump to step 1203.

At step 1203, the counter field (1005) of the process control block (1002) pointed to by the PCB is set to 1
Only decrement. However, the counter field (1
If INFINITY is stored in (005), do nothing.

At step 1204, it is checked whether or not the value of the counter field (1005) of the process control block (1002) pointed to by PCB is 0. If the value of the counter field (1005) is 0, the process jumps to step 1205, and if it is not 0, the process jumps to step 1206.

In step 1205, the ready queue operation is performed according to the flags field (1006) of the process control block (1002) pointed to by the PCB. That is, the following operation is performed. First, the process control block (1
002) is dequeued from the bidirectional ready queue. next,
If PRIORITY_NORMAL is stored in the flags field (1006), b in the ready queue header array (1001)
Find the element whose index is the value stored in the ase_pri field (1010), and enqueue the process control block (1002) pointed to by PCB at the end of the bidirectional ready queue with that element as the queue header. Also, flags
When PRIORITY_DEPRESSED is stored in the field (1006), depre in the ready queue header array (1001)
Find the element with ssed as the index and enqueue the process control block (1002) pointed to by PCB at the end of the bidirectional ready queue with that element as the queue header.

At step 1206, the value of PCB is set to the next_proc of the process control block (1002) pointed to by PCB.
Update to the value of field (1003). Then step 1202
Jump to.

In step 1207, the element having depressed in the ready queue header array (1001) as an index is obtained, and the pointer to the control block (1002) stored in that element is assigned to the variable PCB.

In step 1208, it is checked whether or not the PCB value updated in step 1207 is a nil pointer. If it is a nil pointer, go to step 1213, nil
If it is not a pointer, jump to step 1209.

At step 1209, the counter field (1005) of the process control block (1002) pointed to by the PCB is set to 1
Only decrement. However, the counter field (1
If INFINITY is stored in (005), do nothing.

At step 1210, it is checked whether or not the value of the counter field (1005) of the process control block (1002) pointed to by PCB is 0. If the value of the counter field (1005) is 0, the process jumps to step 1211. If it is not 0, the process jumps to step 1212.

In step 1211, the ready queue operation is performed according to the flags field (1006) of the process control block (1002) pointed to by the PCB. That is, the following operation is performed. First, the process control block pointed to by the PCB
Dequeue (1002) from the bidirectional ready queue. Next, if PRIORITY_NORMAL is stored in the flags field (1006), the ready queue header array (1001)
Find the element whose index is the value stored in the base_pri field (1010) of the, and enqueue the process control block (1002) pointed to by the PCB at the end of the bidirectional ready queue with that element as the queue header. Also,
If PRIORITY_RAISED is stored in the flags field (1006), r in the ready queue header array (1001)
Find the element whose index is aised, and enqueue the process control block (1002) pointed to by the PCB at the end of the bidirectional ready queue with that element as the queue header.

At step 1212, the value of PCB is set to the next_proc of the process control block (1002) pointed to by PCB.
Update to the value of field (1003). Then step 12
Jump to 08.

In steps 1213 to 1216,
The driving process of the periodic driving kernel process (101) is performed. The cycle-driven kernel process (101) is driven when the following events occur.

(A) When the CPU time to be allocated to the process group (915) elapses The cycle-driven kernel process (101) follows the CPU allocation order description table (900) to describe the time described in the table.
(916) is sequentially given to each process group (915). When the time (916) given to the process group (915) has elapsed, the priority belonging to that process group (915) is ra.
Since the PCB counter of the ised process becomes 0,
Steps 1204 and 1205 change the priority of the process to a lower priority according to PCB-> flags, and as a result, the cycle-driven kernel process (101) having the next highest priority after raised is driven. The cycle-driven kernel process (101) changes the process group (915) to which the CPU should be allocated. If there is no process group (915) to allocate the CPU next, the cycle-driven kernel process (101) changes its priority to depressed, thereby allocating the CPU time to the normal process (109). .

(B) When the minimum Interval of the process group (915) requesting the CPU allocation (for example, 8 time slots in the example of FIG. 8 and abbreviated as the minimum Interval thereafter) has passed. As described above, the period-driven kernel process (10
1) is the process group (91
If 5) does not exist, the priority of the own process is depressed.
Change to However, every time the minimum Interval elapses, it becomes necessary to allocate CPU time to the process group (915) requesting to drive at the minimum Interval. Therefore, drive the period-driven kernel process (101) with the minimum Interval period, and
Performs CPU time allocation processing.

The driving interval of the cyclically driven kernel process (101) with the minimum Interval is managed by a variable called kproc_timer. This variable is initialized to the minimum Interval by the scheduler when creating the CPU allocation order description table (900) by the alloc_time_slot function.

In step 1213, kproc_timer is decremented by 1.

In step 1214, it is checked whether the value of kproc_timer updated in step 1213 is 0. If it is 0, it indicates that it is the driving trigger of the cyclically driven kernel process (101) in (b) above. After the re-initialization of kproc_timer, the process jumps to step 1215 for the process of driving the cyclically driven kernel process (101).

When kproc_timer is other than 0, the execution context save / recovery processing shown in steps 1105 to 1107 is executed. When the CPU time that should be allocated to the process group (915) has elapsed (in the case of (a) above), the cycle-driven kernel process (101) becomes the process holding the highest priority in the system, and steps 1105 to 1107 are executed. Execution drives the Periodically Driven Kernel Process (101).

In step 1215, the Index (914) of the CPU allocation order description table (900) is set to the process group (915).
Go to the entry that stores OTHERS in the field. For example, in FIG. 9, when Index (914) points to the entry of 906, this step is updated to point to the entry of Index (914) to 907. By this step, the cyclically driven kernel process (101) driven in step 1216
However, the CPU time allocation process to the process group (915) can be started from the entry next to the entry having OTHERS stored in the field of the process group (915). Index (914) is already in process group (9
If it points to an entry in which OTHERS is stored in the field of 15), do nothing.

At step 1216, proc_depress_cancel (ke
rn_proc, PRIORITY_NORMAL) function is called. kern_proc
Represents the process identifier of the cycle-driven kernel process (101). By executing this function, if the priority of the cyclically driven kernel process (101) is depressed, it is changed from depressed to the reference priority (the next highest priority to raised). If the priority of the cycle-driven kernel process (101) is the reference priority, execution of this function does not change the priority. At this point, it is guaranteed that no process has priority raised (each process group (91
In 5), the CPU allocation order description table (900) is set so that CPU time is not allocated without waiting for the drive trigger of the cyclically driven kernel process (101). The driving kernel process (101) can be realized.

PCB-> counter of the periodic process (102)
The PCB of the periodic process (102) must always be attached to the ready queue in order to be correctly decremented every time slot interval. Therefore the cyclic process
(102) PCBs are not allowed to be removed from the ready queue. When the cyclic process (102) waits, it needs to wait by means such as dynamic jump within the allocated CPU time.

FIG. 13 shows a flowchart of the operation of the cyclically driven kernel process (101).

The cycle-driven kernel process (101) is a CPU
It is driven by a timer interrupt handler (104) at every time (916) or at least every Interval allotted to the process group (103) requesting the allocation. That is, the process that was executing the timer interrupt handler (104) at that time activates the cyclically-driven kernel process (101). The cycle-driven kernel process (101) operates at the standard priority.

In step 1301, the Index (914) of the CPU allocation order description table (900) is incremented by one entry in the table. The Index (914) of the CPU allocation order description table (900) points to an entry indicating a process group (915) to which a CPU should be allocated next by the cycle-driven kernel process (101).

In step 1302, the CPU allocation order description table (900) pointed to by Index (914) is searched for an entry.

In Step 1303, Step 1302
Check whether the field of process group (915) of the entry obtained in is OTHERS.

If the process group (915) is OTHERS, in step 1304 proc_depress (MYSEL
F, INFINITY, PRIORITY_NORMAL). This will make the Periodic Driven Kernel process (101) proc_depres
The priority is depressed until the s_cancel function is issued.
become. The timer interrupt handler (104) issues the proc_depress_cancel function at every minimum Interval of the process group (103) requesting periodic CPU allocation. Until then, a normal process (109) that does not perform continuous media processing (process that has not requested periodic scheduling by the alloc_time_slot function) is scheduled.

If the process group (915) is not OTHERS, it is checked in step 1305 whether the process group (915) to which the CPU is to be allocated next has completed the execution of one cycle. This is determined using the flag of the done field (1401) of the execution state description table (1400) as shown in FIG. This is alloc
This field describes whether or not the execution for one cycle is completed for each process group (103) requesting cyclic scheduling using the _time_slot function.
The periodic process (102) belonging to the process group (103) requesting the periodic scheduling issues the proc_raise_cancel function to its own process when the execution for one period is completed (described later). Done of the process group (103) to which the periodic process (102) that called this function belongs
The flag is set in the processing routine of this function.

When the process group (915) of the entry obtained in step 1302 has completed the execution for one cycle, the end scheduled flag (917) of the entry is searched in step 1306.

If the end schedule flag (917) is FALSE,
Return to step 1301.

If the end schedule flag (917) is TRUE,
In step 1308, the execution status description table (1400)
Clear the corresponding flag in the done field (1401). It also initializes the active pid field (1402). This initialization method will be described immediately below. After this, step 1301
Return to

If it is determined in step 1305 that the execution for one cycle has not been completed, in step 1309 the scheduled end flag (917) of the entry obtained in step 1302 is checked.

If the end schedule flag (917) is TRUE,
In step 1307 proc_raise (pid, TIME, PRIORITY_DEP
RESS | SEND_SIGNAL) is issued. The process identifier stored in the active pid field (1402) of the execution state description table (1400) is used for pid. The value of the entry's time field (916) is used for TIME.
Active pid field of execution status description table (1400)
(1402) indicates which periodic process (102) belonging to the process group (103) is currently executing continuous media processing. Immediately following this step, the periodic process (102) specified by pid is scheduled for the time specified by TIME.

At step 1308, the corresponding entry is initialized. In step 1308, the entry in the active pid field (1402) corresponding to the process group (915) selected in step 1302 has the process group (9
It is initialized to the process identifier of the group master in 15). Also, when the proc_raise_handoff function is issued,
In the processing routine, the corresponding entry in the active pid field (1402) is updated to the process identifier of the handoff destination. When the proc_raise_cancel function is issued, if the termination schedule flag (917) is TRUE, the corresponding entry of the active pid field (1402) is initialized in the processing routine.

At step 1309, the end schedule flag (917) is set.
If it is determined to be FALSE, in step 1310, proc_raise (pid, TIME, PRIORITY_DEPRESS) is issued and the process ends. Steps for setting pid and TIME
Same as for 1307. Again, immediately after this step, the periodic process (102) specified by pid is scheduled for the time specified by TIME.

The operation of the group of periodic processes (102) belonging to the process group (103) requesting periodic scheduling is shown in FIGS.

FIG. 15 is a diagram showing the starting order of the periodic processes (102) belonging to the process group (103).

The processing order of the periodic processes (102) belonging to the process group (103) is predetermined. Group master process (1501) of process group (103)
Starts up after the priority is raised by the proc_raise function of the periodical kernel process (101). Each process (102) belonging to the process group (103) has a proc_raise
Using the _handoff function, the next periodic process (102)
Inherit the priority to. After inheritance, the priority of the local process (102) becomes depressed. The last cycle process (10
In 2), the execution of one cycle is completed using the proc_raise_cancel function.

FIG. 16 shows the group master process (1501).
Is a program showing the operation of.

At line 1601, a process group (103) having its own process as a group master process (1501) is created. Thereafter, this process group (103) becomes a scheduling unit.

On line 1602, the process group (103) created on line 1601 has the le specified at the interval specified by interval.
Requests to allocate the CPU time specified by ngth. After issuing this function, as shown in FIG. 15, from the periodical driving kernel process (101) to the group master process
The proc_raise function will be issued for (1501).

Lines 1603 to 1606 are a loop for performing continuous media processing. After performing one cycle of continuous media processing, proc_raise_hando at line 1605
Process (102) belonging to the process group (103) created in the 1601st line that should call the ff function and perform the next processing
Make the priority of raised. Own process priority is depr
Become essed.

When the execution loop of continuous media processing is executed a specified number of times, the CPU issued at line 1607 and the CPU issued at line 1602
Cancel the time allocation request.

Further, in the 1608th line, the process group (103) generated in the 1601st line is deleted.

FIG. 17 is a program showing the operation of the slave process (102).

Lines 1702 to 1704 are a loop for performing continuous media processing.

After performing continuous media processing for one cycle, call the proc_raise_handoff function at line 1703,
The priority of the periodic process (102) belonging to the process group (103) created in the 1601st line to be processed next is rai
set to sed. The priority of our process is depressed. However, the last sequential cyclic process (102) is 1704
On the second line, issue the proc_raise_cancel function to change the priority of the own process to depressed. When the execution loop of continuous media processing is executed a specified number of times, the program ends.

When the execution for one cycle is not completed within the CPU allocation time for one cycle, the process (102) registered in the active pid field (1402) of the execution status description table (1400). A timeout signal is sent to. And d in the execution status description table (1400)
IN_SIGNAL_TRANSACT in the flag in the one field (1401)
A flag indicating ION is set.

Process group for which this flag is set
Regarding (103), the execution end judgment of the process group (915) in step 1305 is always judged to be TRUE.
Also, the done field (1401) in step 1308 is not cleared. That is, the signal handler is scheduled and executed in the same manner as the normal process (109) with the reference priority of the cyclic process (102). This can ensure that the processing delay of one stream does not affect the processing of other streams.

According to the first embodiment, since a single periodic driving kernel process (101) performs periodic scheduling of all process groups (103) based on the CPU allocation order description table (900), a plurality of There is no delay in the execution of the periodic process (102) due to the CPU time contention between the process groups (103). In addition, after changing the execution priority of the periodic process (102), the periodic process (102) is started depending on process dispatch, so the wake-up notification is issued compared to the case where the periodic process is started via interprocess communication. Less overhead involved. In addition, the signal handler processing of the process that has run out of the specified CPU time and has timed out is executed with the standard priority of the process, so the signal handler processing does not cause the execution delay of other process groups.

(2) Second Embodiment In the first embodiment, from the process executing the timer interrupt handler (104) at every time (916) or the minimum Interval assigned to the process group (103), the cyclic drive kernel is executed. Process switch to process (101),
At this time, the process switch overhead intervenes. In the second embodiment, the cycle-driven kernel process (10
A timer interrupt handler (104) is provided by executing a timer interrupt handler (104) and a scheduler in the same process by providing a module (hereinafter referred to as a scheduler) for controlling process scheduling instead of 1).
To reduce the process switch overhead from to the Periodically Driven Kernel Process (101). FIG. 18 shows the configuration of a system that implements the present invention using a scheduler.

The system has one scheduler (1801)
Exists. The scheduler changes the priority of a periodic process, determines the process to be scheduled next, and dispatches the process. The scheduler is periodically called by the timer interrupt handler (104). When the periodic process (102) that performs continuous media processing inherits the priority to the next periodic process (102), the periodic process (1
When 02) completes execution for one cycle and changes the priority of its own process, the scheduler is called in the processing routine of each function. Details of these scheduler calling methods will be described later.

Similar to the first embodiment, the periodic process (102) for processing the same continuous media processing data forms the process group (103). Process Group (103)
To create or delete, create_proc _group, destroy
This is done using the _proc_group function. Process group (1
The cyclic process (102) at the head of the processing order in 03) reads continuous media data from the external input device (105) via the input buffer (106) and processes the data. The processed data is passed through the shared buffer (110) to the next periodic process (102) in the processing order. The cyclic process (102) with the last processing order is connected to the external output device (1) via the output buffer (107).
Output to 08).

The process group (103) serves as a scheduling unit. When the group master process of the process group (103) is initialized,
Use the oc_time_slot function to reserve CPU allocation for the process group (103) every specified period for the specified time. When CPU time allocation becomes unnecessary, the dealloc_time_slot function is called to cancel the reservation.

When the alloc_time_slot function is called,
The scheduler determines the CPU allocation order that satisfies the cycle required by each process group and the execution time per cycle, and the CPU allocation order description table (900)
Create This creation algorithm is as described in the first embodiment.

The scheduler (1801) schedules each periodic process (102) based on the CPU allocation order description table (900). When the time to allocate CPU for the process group (103) has been reached, the scheduler (1801) sets the priority of the group master process of that process group (103) to raised (proc_
call the raise function). When the specified time has passed since the priority of the group master process was raised, the scheduler (1801) called from the timer interrupt handler (104) determines that the priority of the periodic processes (102) belonging to the process group (103) is higher. a periodic process that is raised
Set the priority of (102) to depressed. How to call the scheduler from this timer interrupt handler (104),
Details of the operation of the scheduler will be described later. As a result, the time that CPU should be allocated to the process group (103) is as long as the periodic process (102) belonging to the process group (103) with the priority raised is in the executable state.
User processes that do not belong to the process group (103) are not scheduled. Further, during the time when the CPU should not be allocated, the periodic process (102) belonging to the process group (103) is not scheduled. CPU time that is not allocated to any process group (103) is allocated to the normal process (109) or idle process.

As mentioned above, the scheduler (1801)
Can be called from the timer interrupt handler (104) or the periodic process (102) requesting the priority change of its own process or another process. The format of the command list used to call the scheduler is shown in FIG.

The timer interrupt handler (104) and the cyclic process (102) that call the scheduler (1801) specify the pointer (1901) to the head entry of the command list shown in FIG. 19 as an argument of the calling function. The command list is a list of operation instructions of the scheduler. Each entry in the command list is next
_command field (1902), flag field (1903),
It consists of a pid field (1904). The next_command field (1902) stores a pointer to the next entry. The value of the next_command field of the last entry in the list is nil. HANDOF in the flag field
F, CANCEL, INTERVAL and TIMER can be specified. Also, the pid field is meaningful only when the flag field is HANDOFF.

Each time the timer interrupt handler (104) is driven, it passes to the scheduler (1801) a command list consisting of entries in which TIMER is stored in flag. Also,
Process group requesting CPU allocation (103)
In addition to the above entries, flag every minimum Interval of
The entry that stores INTERVAL in is also passed to the scheduler. Therefore, the timer interrupt handler (104) is
It is necessary to judge the minimum Interval by c_timer.

When the periodic process (102) inherits the priority to the next periodic process (102) in the processing order, HAND is set in flags.
OFF is passed to the scheduler as a command list consisting of entries in which the identifier of the periodic process (102) whose processing order is next is stored in pid.

Further, the cyclic process (102) is the last in the processing order.
Completes one cycle of execution and dep
When changing to ressed, pass the command list consisting of the entries in which CANCEL is stored in flags to the scheduler.

Finally, the operation flow of the scheduler that receives and drives the command list will be described with reference to FIG.

In step 2001, the scheduler
Search the flag field of the first entry in the passed command list. If the flag field is HANDOFF, jump to step 2002, and if the flag field is CANCEL, jump to step 2003. flag field is IN
If it is TERVAL, after executing step 1215, step 2006
Jump to. If the flag field is TIMER, perform steps 1201-1212, then step 1204 PCB-
> If the counter has been determined to be 0, that is, the process has passed the CPU time (916) allocated to the process group (915) and the flag field pointed to by the next_command field is not INTERVAL, go to step 2015. To jump. If this condition is not met, jump to step 2012.

In step 2015, the process group to which the CPU time has been allocated immediately before the scheduler is started (Index (91) in the CPU allocation order description table (900)
Search the end scheduled flag (917) of the entry pointed to in 4). If the termination flag (917) is ON, the timeout signal transmission processing described in the first embodiment is performed,
Jump to step 2006. Expected end flag (917)
If OFF, jump directly to step 2006.

In step 2002, the periodic process (1202) from which the priority is inherited and the periodic process from which the priority is inherited
The priority of (1202), the counter field (1005) and the flag field (1006) in the process control block (1002) are updated. This updating method is the same as the flowchart shown in FIG. Then jump to step 2012.

In step 2003, the process group to which the CPU time was allocated immediately before the scheduler was activated (Index (914) in the CPU allocation order description table (900)
Search for the end scheduled flag (917) of the entry pointed to by. If the end scheduled flag (917) is ON, step 2005
If it is OFF, jump to step 2004.

At step 2004, the done field (1401) of the corresponding entry of the execution state description table (1400) is set and the process jumps to step 2006.

Step 2005 performs the same operation as step 1308, and jumps to step 2006.

At step 2006, the same operation as that at steps 1301 to 1302 is performed, and the process jumps to step 2007.

In step 2007, it is checked whether or not the field of the process group (915) of the entry obtained in step 2006 is OTHERS. If it is OTHERS, go to step 2012. If not, go to step 20.
Jump to 08.

In step 2008, the end scheduled flag (917) of the entry pointed to by Index (914) incremented in step 2006, and the done field (1401) of the execution state description table (1400) corresponding to that entry
Search for. If both bits are set together, it goes to step 2009. If only the done field is set, it goes to step 2006. If only the end schedule flag is set, it goes to step 2010. If both bits are cleared, it goes to step 2011.
Jump to.

Step 2009 performs the same operation as step 1308, and jumps to step 2006.

Step 2010 is the periodic process (102) which is the group master process (1501) of the process group (103) registered in the entry pointed to by Index (914).
To change the priority to raised for the time specified in the entry's time (916) field, and to send a signal after that time, the process priority,
Also, the counter field (1005) and the flag field (1006) of the corresponding process control block (1002) are updated. This updating method is the same as the flowchart shown in FIG. Then jump to step 2012.

In step 2011, the periodic process (102) which is the group master (1501) of the process group (103) registered in the entry pointed to by Index (914) is designated by the time field (916) of the entry. The priority of the process, the counter field (1) of the corresponding process control block (1002) so that the priority is raised to raised for a specified time and no signal is sent after that time.
005) and the flag field (1006) are updated. This updating method is the same as the flowchart shown in FIG. Then jump to step 2012.

In step 2012, steps 2001 to 2011
Search the next_command field of the entry processed in. If the value is not nil, the process returns to step 2001. n
If it is il, steps 1105 to 1107 are executed and the process ends.

(3) Third Embodiment When an asynchronous event such as arrival of a network packet occurs frequently while the system is operating according to the periodic process scheduling method of the first or second embodiment, the periodic process ( The execution of 102) is hindered, and the fluctuation of the driving cycle interval of the periodic process (102) becomes large. In other words, asynchronous event processing such as network packet reception processing requires a certain level of response performance.
If priority is given to asynchronous event processing and the priority of the process performing the processing is set higher than that of the periodic process (102), the execution time of the periodic process (102) may be delayed. In the third embodiment, in order to solve this problem, a network
An interrupt handler for receiving packets is layered. The timer interrupt handler (104), the cycle driven kernel process (101), the scheduler (1801) and the process group (10) of the first or second embodiment.
There is no change in 3), and the third embodiment is implemented in a form that reinforces the first embodiment or the second embodiment. The configuration of this interrupt handler and its operating method will be described below by taking an interrupt handler for receiving a network packet as an asynchronous interrupt handler as an example.

FIG. 21 shows the configuration of the system centering on this interrupt handler and the configuration of the interrupt handler. Illustration of the timer interrupt handler (104), the cycle-driven kernel process (101), the scheduler (1801), etc. is omitted.

In this system, the CPU (2
101) and an Ether board (2102). Ether board (21
02), when receiving a packet, C
It has a function of notifying the PU (2101) and driving a routine (interrupt handler) for performing packet reception processing on the CPU (2101). In addition to the first level interrupt handler (2103) driven by packet reception, a second level interrupt handler (2104) and an application program (2105) are provided on the CPU (2101). The second level interrupt handler (2104) is, as one of the periodic processes (102), periodically driven by the periodic driving kernel process (101) or the scheduler (1801) according to the scheduling method described above. Application Program (210
5) is a business program that processes the received packet, and runs by the periodic process (102) or the normal process (109).

FIG. 22 shows an operation flow of the first level interrupt handler (2103).

As described above, the first level interrupt handler (2103) is driven by the packet arrival notification of the Ether board (2102). First, in step 2201, the received packet is enqueued in the packet queue (2106). In step 2202, one reception buffer is secured from the empty buffer group (2108). Step 2203, Step
A command requesting packet reception for the reception buffer secured in 2202 is issued to the Ether board (2102).
That is, the first level interrupt handler (2103) only secures the reception buffer and prepares to receive the packet, and does not perform any processing that refers to the information in the reception buffer. The Ether board (2102) cannot receive the packet that arrives between the notification of arrival of the packet and the execution of step 2203. Because the first
This is because the interrupt handler (2103) has not specified the address of the reception buffer in which the reception packet should be stored. Therefore, even if a packet arrives in the meantime, the Ether board (2102) fails to receive the packet and the packet is lost, but the time is minimized.

The second level interrupt handler (2104) is cyclically driven at the specified cycle. Then, the packet connected to the packet queue (2106) enqueued by the first level interrupt handler (2103) is dequeued, and the protocol processing is performed by referring to the dequeued packet. Then, as a result of the protocol processing, if the received data to be passed to the application program (2105) is obtained, the received data is enqueued in the received data queue (2107). Therefore, the second level interrupt handler (2104)
Is scheduled as only one of the periodic processes (102) belonging to a certain process group (103).

The application program (2105) is
Dequeuing the reception data enqueued in the reception data queue (2107) and releasing the reception buffer storing the reception data are performed.

When a packet arrives during the execution of the cyclic process (102), the execution of the cyclic process (102) is stopped and the execution of the first interrupt handler (2103) is started. By executing the first interrupt handler (2103) with the highest priority, the occurrence of packet loss due to the packet reception failure of the Ether board (2102) is prevented. That is, by applying the third embodiment to the first embodiment or the second embodiment, the first level interrupt handler (210
3) and the second level interrupt handler (2104) are processed by one packet reception interrupt handler, the probability of packet loss is reduced and the periodic process (1
The execution delay of 02) is reduced, and the advantages of both are compatible.

Since the second level interrupt handler (2104) is scheduled as the periodic process (102),
Until the time when the CPU (2101) is assigned to the own process, even if the packet is queued in the packet queue (2106), the execution is not started. Therefore, the execution of the periodic process (102) is resumed immediately after the execution of the first interrupt handler (2103) is completed. By layering the interrupt handlers in this way, the execution stop time of the periodic process (102) accompanying the arrival of a packet can be
It is possible to limit the execution time of the level interrupt handler (2103).

A second level interrupt handler (2104)
Is guaranteed to be cycled. Therefore, the second-level interrupt handler (2104) is driven once at least once during the time corresponding to the driving cycle after the packet arrives. That is, the upper limit of the time required from the arrival of a packet to the enqueuing of the reception data queue (2107) is also the second
It becomes the driving cycle of the level interrupt handler (2104), and the response performance of the network packet reception processing can be guaranteed.

[0191]

The scheduling method of the present invention provides a CPU time allocation algorithm that simultaneously satisfies a plurality of periodic CPU allocation requests. It is guaranteed that the fluctuation of the execution start interval of continuous media processing for one cycle using this algorithm will be shorter than the driving interval of the cyclically driven kernel process. In addition, a process with a short request cycle, that is, a process in which the absolute value of the fluctuation of the execution start interval must be kept small, is assigned CPU time immediately after the driving of the cycle-driven kernel process. Therefore, it becomes possible to suppress the variation in the execution start interval to be smaller as the process has a shorter cycle.

When the arrival rate of continuous media data is constant, input buffer management such as input buffer switching may be performed periodically. Therefore, if periodic process scheduling can be assured, a process that performs continuous media processing may spontaneously switch input buffers, and notification of arrival of input continuous media data is not required. It can be expected to improve the performance of continuous media processing by reducing the interrupt overhead.

Further, in the scheduling method of the present invention, wake-up and sleep of each process for performing continuous media processing are realized by changing the priority. The overhead required to wake up and sleep can be reduced compared to the conventional method using IPC. From this point as well, improvement in performance of continuous media processing can be expected.

Furthermore, according to the scheduling method of the present invention, when a deadline miss occurs in one process group and a signal is delivered to the target process, the priority of the signal handler is lower than that of the process which performs continuous media processing. Guaranteed to be a priority. Therefore, it can be guaranteed that the processing delay of one stream does not affect the processing of other streams.

Further, in the CPU allocation algorithm of the present invention, the time allocated to each process group is set as continuous as possible. Therefore, the number of process switches can be minimized. It is expected that the performance of continuous media processing will be improved by reducing the overhead required for process switching.

Further, in the CPU allocation algorithm of the present invention, the execution time ratio between process groups is always kept constant. Therefore, synchronization between streams can be realized without using a synchronization mechanism such as rendezvous.

Further, according to the present invention, it is possible to prevent the variation of the execution interval of the process for performing continuous media processing when an asynchronous event occurs.

[Brief description of drawings]

FIG. 1 is a diagram showing a process activation and a data flow in a scheduling method of the present invention.

FIG. 2 is a diagram showing a structure of data for managing a process group.

FIG. 3 is a flowchart of a create_proc_group function.

FIG. 4 is a flowchart of a destroy_proc_group function.

FIG. 5 is a diagram showing a method for eliminating the overlap of CPU times assigned to process groups.

FIG. 6 is a flowchart for creating a time slot table.

FIG. 7 is a diagram showing a result of an example of creating a time slot table.

FIG. 8 is a diagram showing input data for an example of creating a time slot table.

FIG. 9 is a diagram showing a configuration of a CPU allocation order description table.

FIG. 10 is a diagram showing a structure of data for managing a process.

FIG. 11 is a flowchart of the proc_raise function.

FIG. 12 is a flowchart of a timer interrupt handler.

FIG. 13 is a flow chart of a period driven kernel process.

FIG. 14 is a diagram showing a configuration of an execution state description table.

FIG. 15 is a diagram showing a flow of activation of a continuous media processing process.

FIG. 16 is a diagram showing a program of a group master process.

FIG. 17 is a diagram showing a program of a slave process.

FIG. 18 is a diagram showing process activation and data flow in the scheduling method of the present invention.

FIG. 19 is a diagram showing the structure of a command list.

FIG. 20 is a flowchart of a scheduler.

FIG. 21 is a diagram showing a configuration of a network packet reception system.

FIG. 22 is a flowchart of a first level interrupt handler.

[Explanation of symbols]

101: Cyclic drive kernel process, 102: Cyclic process, 103: Process group, 700: Time slot table, 900: CPU allocation order description table, 1400: Execution state description table, 1801: Scheduler,

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Masaaki Iwasaki 1099, Ozenji, Aso-ku, Kawasaki-shi, Kanagawa Ltd. System Development Laboratory, Hitachi, Ltd.

Claims (9)

[Claims] 1. A periodic process scheduling method for a computer system in which there are a plurality of process groups including at least one process that is periodically executed, and in which a plurality of process groups are executed in parallel, an activation interval for each process group. When a cycle and the required CPU time for each cycle are specified, ensure that the CPU allocation time of the specified process group does not conflict with the CPU allocation time of other process groups, and start each specified process group. A periodic process scheduling method characterized by adjusting so as to maintain an interval period. 2. The cyclic process scheduling method according to claim 1, wherein a step of creating a table for registering a sequence of process groups to which CPU time is allocated in units of time slots, and a process group having a short activation interval period are sequentially processed. Select a process group to allocate slots, extract continuous empty slots that are time slots that are continuously open in the range of the startup interval cycle of the selected process group, and set a size equal to or greater than the required CPU time. If there is a group of consecutive empty slots that have the required CPU time, a step of allocating consecutive empty time slots of the required CPU time from the beginning of the consecutive empty slots having a size equal to or larger than the required CPU time to the selected process group, More than If there is no continuous empty slot group with a size, all time slots of the continuous empty slot with the largest size are assigned to the selected process group, and the remaining time obtained by subtracting the assigned time slot from the required CPU time And a step of assigning the process group to the process group by this step. 3. A method of activating a process scheduled according to the periodic process scheduling method according to claim 1, wherein a process belonging to said process group is reached when the time to activate one of said process groups is reached. A process starting method characterized by starting by changing the execution priority to the highest priority in the system, and then maintaining the highest priority for the continuously allocated CPU allocation time. 4. The process starting method according to claim 3, wherein when the CPU allocation time that is continuously allocated has elapsed, the execution priority of the process is changed to the lowest priority in the system. Process startup method. 5. The process starting method according to claim 3, wherein the priority is inherited from the first process belonging to the same process group to the second process before the consecutively allocated CPU allocation time elapses. Start by changing the execution priority of the first process from the highest priority in the system to the lowest priority and the execution priority of the second process to the highest priority. A method for starting a process characterized by. 6. The process starting method according to claim 3, wherein when the continuously allocated CPU allocation time has elapsed and the required CPU time has been consumed, the execution priority of the started process is the highest in the system. A method for starting a process, characterized in that the priority is changed to a reference priority and a timeout is notified to the process. 7. The process activation method according to claim 3, wherein when a CPU allocation time that is continuously allocated has elapsed, a single control process that activates the process group is activated, and the control process Consecutive CP
A process starting method characterized by starting a process belonging to a process group to which U-allocated time is allocated. 8. The process start-up method according to claim 3, wherein a process from detecting a time point at which one of the process groups is started to starting a process belonging to the process group is executed by a single process. A process starting method characterized by the above. 9. The process starting method according to claim 3, wherein during execution of a process having the highest priority in the system, when an asynchronous event for receiving information such as arrival of a network packet occurs, the highest priority is immediately given. Each time the process that is running is stopped, the reception buffer for the information is secured and preparations for receiving the information are made, and then the process that has stopped the execution is restarted, and the process that is started periodically is received. An asynchronous event processing method characterized by processing by referring to information.