JPH052496A - Multi-task monitor - Google Patents

Abstract

PURPOSE:To easily obtain the stopping time of itself without issuing the request for acquiring the present time with a task by assigning respective kinds of resources (CPU time, main memory, etc.,) of a system with the task as a unit. CONSTITUTION:While a task is in a stopping condition, when the stopping condition is released by other task, a multi-task monitor subtracts the time when the task starts the stopping condition, from the present time (step 301). Thus, the stopping time of the task is obtained. The time value is stored into a memory area pointed out by a WaitTime designated by the task (step 302). Here, when a Task Wait service is the service to inform of the remaining time up to the limit time, the stopping time of the task obtained from a LimitTime is subtracted, and the value is stored in the memory area pointed out by the WaitTime. Thus, the stopping time of the task itself can be obtained as the turn-back value of the service from the multi-monitor.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a multitask monitor, and more particularly to a multitask monitor which makes it possible to easily obtain the time when a task has stopped.

[0002]

2. Description of the Related Art In a multi-task monitor that allows a plurality of tasks to share one processor,
A task may suspend itself until the required event occurs. At this time, it is possible to specify a limit value for the stop time. This is a multitask monitor,
Request a service that stops the task and waits for the occurrence of an event,
By switching execution on the processor to another task. When an event that specifies restarting occurs in a task in the stopped state, the multitask monitor changes the task to the executable state and the task is executed by the processor according to the task execution priority rules implemented in the multitask monitor. When the condition is reached, the execution is switched to the task. Examples of the task execution priority rule include a rule in which a priority is assigned to a task and the task with the higher priority is executed, and a rule in which a processor is assigned to each task for a certain time and then executed in order. Before the task issues a stop request to the multitask monitor, the task asks the multitask monitor to acquire the current time in order to know how long it has been stopped when execution resumes. To do. The multitask monitor obtains the current time by counting the interrupt signals from the hardware in a constant cycle and stores it in the internal area. Then, the task obtains the current time again after resuming the execution, and obtains its own stop time from the difference between these two times. If the task specifies a stop time limit value and it is necessary to obtain the remaining time up to that time limit, the task's stop time obtained by the above method is subtracted from the time limit value. .

[0003]

As described above, in the conventional multitask monitor, in order for a task to obtain its own stop time, a request to obtain the current time is made twice before and after the stop request. It was necessary to issue it to the multitask monitor. In order to meet the two requests for obtaining the current time, an extra processing time is required for the processor, which is an obstacle to further improving the data processing efficiency in the multitask environment. It was

The present invention was devised to solve the above problem, and provides a multi-task monitor having a function of easily acquiring its own stop time without issuing a request for acquisition of the current time by a task. The purpose is to provide.

[0005]

In order to achieve the above object, a multitask monitor of the present invention realizes multitask by allocating at least one task to at least one processor and switching the tasks. In a multi-task monitor, when a task requests a service to suspend itself, the task is suspended and the time is recorded in memory, and the suspended state is released. When it does, it has a function to restart the execution of the task and notify the task of the time value obtained by subtracting the stop state start time recorded in the memory from the execution restart time as the service return value. .

Further, the multitask monitor of the present invention is
When a task sends a service request that specifies a limit value for the stop time and puts itself in the stop state, the task is placed in the stop state, the time is recorded in memory, and the stop state is released. When an error occurs, it is desirable to have a function to restart the execution of the task and notify the task of the remaining time value obtained by subtracting the above time value from the stop time limit value as the service return value. .

[0007]

The multitask monitor allocates various resources (CPU time, main memory, etc.) of the system in units of tasks. It can be easily obtained from the storage area. Therefore, the multitask monitor subtracts the stop state start time from the task execution restart time to obtain the time value, that is, the time when the task has been stopped. When the task execution is restarted before the stop time limit value, the multi-task monitor obtains the remaining stop time by subtracting the time value from the stop time limit value. By notifying the task of the time data such as the task stop time and the remaining time up to the limit value as the service return value when resuming execution, the current time from the previously required task to the multi-task monitor can be displayed. The acquisition request is not required, and the processing can be simplified and speeded up.

[0008]

EXAMPLE An example of the present invention will be described below with reference to FIGS. Here, it is assumed that the present multitask monitor receives a signal of a constant cycle from the hardware (clock included in the processor, etc.), counts it, and manages the current time. Further, it is assumed that the multi-task monitor provides a service for suspending the task for a fixed time specified by the task. This service is described in the programming language C discussed in ANSI X3J11 as follows.

Void TaskWait (Time limitTime, Time * wa
itTime); where TaskWait is the function name that provides the above services. Time is a type that indicates the time to be implemented by the multitask monitor of this example, where the period of the signal from the hardware is 1. For example, if the signal period from the hardware is 1 ms, 1 second will be 1000. This does not require the period of the signal from the hardware to be 1, but may be 1, for example, the time for receiving the signal from the hardware 10 times. limitTime is the limit value of the stop time represented by type Time, and waitTime is the address of the memory area in which the task stop time is stored by the multitask monitor when the task resumes execution.

The multitask monitor is a service TaskWait
Is requested, the procedure shown in Fig. 1 (A) is taken. First, a memory area is acquired to record a task request (step 100). An example of the acquired memory area is shown in FIG. Then, the specified limitTime and the current time are recorded in the area of 400,401 (step 101). In this memory area,
Other information needed to implement the TaskWait service may also be stored. When the multi-task monitor receives a signal of a constant cycle from the hardware, it takes the procedure shown in FIG. 1 (B). First, the content of the memory area 401 storing limitTime is decremented by 1 (step 200), and it is checked whether or not it has become 0 (step 201). If it is not 0, the process ends. If it becomes 0, the wait specified by the task
Limi as the task stop time value in the memory area pointed to by Time
The tTime is stored (step 202), and the task is made ready (step 203). According to the implemented task execution priority, the multi-task monitor switches execution to the task at the time when the task becomes a condition to be executed by the processor and also sets the stop time value (limitTime) to the return value of the service. Notify as

Now, let us consider the processing in the case where the suspended state is canceled by another task while the task is in the suspended state. In this case, the multitask monitor takes the procedure shown in FIG. The multitask monitor retrieves the current time (step 300), and the time when the task started the stopped state from the current time (written in the memory area 401).
(Step 301). This gives the task downtime. The waitTime at which this time value was specified by the task
It is stored in the memory area pointed to by (step 302). here,
If the TaskWait service is a service that notifies the remaining time up to the time limit, the process from limitTime to step 302
The task stop time calculated in step 1 is subtracted and the value is stored in the memory area pointed to by waitTime. The multitask monitor will then waitTime when restarting the task execution.
The task is notified of the time data stored in the memory area indicated by as the return value of the service.

Thus, the conventional task is 2 before and after the stop request.
The request to obtain the current time, which was issued to the Matil task monitor over time, is completely unnecessary.

[0013]

In summary, according to the present invention, when the task is released from the request to be in the stopped state, the own stop time can be obtained as the return value of the service from the multitask monitor. It became unnecessary to obtain the current time from the multitask monitor, which was a simple process.
The speed can be increased.

[Brief description of drawings]

FIG. 1 is a flowchart showing an operation example of a multitask monitor according to the present invention.

FIG. 2 is a diagram showing a configuration example of a memory area required for the multitask monitor according to the present invention to realize a task stop service.

Claims (2)

[Claims] 1. A multi-task monitor for allocating at least one or more tasks to at least one or more processors and switching the tasks to realize a multi-task, which is a service request for suspending itself from the tasks. When there is an event, the task is stopped and the time is recorded in the memory. When an event that cancels the stopped state occurs, execution of the task is restarted and the execution restart time is stored in the memory. A multi-task monitor having a function of notifying the task of a time value obtained by subtracting the recorded stop state start time as a service return value. 2. In the multitask monitor according to claim 1, when a task requests a service to specify a limit value of a stop time and put itself in a stop state, the task is stopped and the time is set. Is recorded in the memory, and when an event that cancels the stopped state occurs, execution of the task is resumed and the remaining time value obtained by subtracting the above time value from the limit value of the stop time is returned to the service. A multi-task monitor characterized by having a function of notifying the task as.