JP5155336B2 - Task processing device - Google Patents

Description

  The present invention relates to an OS (Operating System) function, and more particularly to control of an auxiliary processor (co-processor).

  Advanced functions are being demanded not only for OSs for general-purpose devices such as personal computers but also for OSs for dedicated devices such as mobile phones. In particular, an OS capable of executing a plurality of tasks with a single CPU (Central Processing Unit) (hereinafter, this type of OS is also referred to as a “multitask OS”) is installed in many electronic devices. It has become to.

  The multitask OS divides the processing time of the CPU into unit times (time slices) and assigns time slices to a plurality of tasks in order. Each task can use the CPU only when a time slice is given from the OS. One task is executed in each time slice. Since time slices are very short from the user's point of view, it looks as if multiple tasks are being executed simultaneously. According to such a processing method, when the task A reaches an input standby state and does not require the CPU processing capability for the time being, the processing capability of the CPU can be effectively utilized by giving another task B the execution right. The execution right here is synonymous with the right to use the CPU.

  Switching the task execution right by the multitasking OS is called “task switch”. A task switch occurs when a time slice elapses or when a task executes a predetermined instruction. When the task switch execution timing is reached, the multitask OS saves the context information of the task being executed in a TCB (Task Control Block). The context information is data related to the execution state of a task or data stored in a CPU register at the time of task execution. The TCB is an area secured in the memory for holding task-specific information. After saving the context information of the task being executed to the TCB, the multitask OS selects the next task to which the execution right is assigned, reads the context information from the TCB of the task, and loads it into the CPU register. In this way, each task advances its own processing little by little in units of time slices.

The multitask OS has an advantage that a plurality of tasks can be efficiently executed, but has a disadvantage that an overhead of saving / loading context information is newly generated. Usually, the merit of the multitasking OS more than compensates for the overhead associated with task switching.
JP 11-272480 A JP 2001-75820 A JP 11-234302 A JP 2000-10803 A JP 2000-276362 A Naohisa Mori, Yoshimi Sakamaki, Hiroshi Shigematsu, "Hardware implementation of a read-time operating system for embedded control system", Tokyo Metropolitan Industrial Technology Research Institute research report, Japan, 2005 August 4, 2014 (manuscript acceptance), 8, p. 55-58

  In recent years, a real-time OS (hereinafter referred to as “RTOS (Real-Time Operating System)”) that strictly requires completion of processing within a predetermined time has become widespread mainly in an embedded system. is there. In such an RTOS with strict time requirements, the overhead at the time of task switching may greatly affect the performance of the entire system.

  Also, a part of the task is often delegated to an auxiliary processor other than the CPU. Examples of the auxiliary processor include a direct memory access controller (DMAC), a floating-point processing unit (FPU), and a cryptographic processing unit. Hereinafter, processing executed by the auxiliary processor is referred to as “auxiliary processing”. The auxiliary processor is a dedicated circuit for specific auxiliary processing. For this reason, in general, it is faster to execute the same auxiliary processing with the auxiliary processor than with the CPU. However, when using a plurality of hardware resources such as a CPU and an auxiliary processor, a specific overhead occurs. In order to further improve the performance of the RTOS, it is important to suppress overhead associated with auxiliary processing.

  The present invention has been completed on the basis of the above-mentioned problem recognition by the present inventor, and its object is to provide a technique for performing and controlling tasks more efficiently in multitask processing, and in particular, It is to provide a technique for speeding up auxiliary processing.

One embodiment of the present invention is a task processing device.
This device includes a processing register, an execution control circuit that loads data from the memory to the processing register and executes a task according to the data in the processing register, a state register that holds state data for each task, and a task execution state. A task switching circuit for controlling, a task selection circuit for selecting a task according to a predetermined selection condition, and an auxiliary processing circuit for executing auxiliary processing are provided.
When executing the system call instruction, the execution control circuit notifies the task switching circuit to that effect. The task selection circuit selects a task to be executed from among the tasks in the READY state indicating the state waiting for execution.
The task switching circuit selects the next task to be executed by the output from the task selection circuit when the system call instruction is executed, saves the data in the processing register to a predetermined storage area, and indicates the status of the task being executed Change the data setting, load the data saved in the storage area for the selected task into the processing register, and change the status data from the READY state to the RUN state to switch the task to be executed .
When a task requests execution of auxiliary processing, the task switching circuit instructs the auxiliary processing circuit to execute auxiliary processing.

  The data loaded into the processing register may be an instruction and an operand, an instruction having no operand, or simple data such as a program counter or a stack pointer. According to such a processing method, since the state of the task is managed by the state register, the task switching circuit can execute the task switch based on the output from the task selection circuit. When a task requests execution of auxiliary processing, the task switching circuit may centrally accept the execution request and instruct the auxiliary processing circuit to execute auxiliary processing. In this case, the auxiliary process control can be managed centrally by the task switching circuit.

  It should be noted that any combination of the above-described components, and the present invention expressed by a method, system, recording medium, and computer program are also effective as an aspect of the present invention.

  According to the present invention, more efficient task execution control is realized in multitask processing.

It is a state transition diagram of a task. It is a conceptual diagram of general RTOS. It is a circuit diagram of a general CPU on which software RTOS is executed. It is a conceptual diagram of RTOS in a present Example. It is a circuit diagram of a task processing device in a basic example. FIG. 6 is a circuit diagram of the CPU in FIG. 5. It is a circuit diagram which shows the mechanism in which the execution control circuit 152 stops a CPU clock. It is a time chart which shows the relationship of the various signals at the time of interruption request signal generation. It is a time chart which shows the relationship of the various signals at the time of system call execution. It is a schematic diagram for demonstrating the stop timing of the CPU clock in a pipeline process. It is a circuit diagram which shows the relationship between a state memory | storage part and a task switching circuit. It is a figure which shows the task ready list utilized at the time of RUN-task selection by general RTOS. It is a circuit diagram of an execution selection circuit. It is a figure which shows the wait semaphore list utilized in the semaphore process by general RTOS. It is a circuit diagram of a semaphore selection circuit. It is a state transition diagram of a task switching circuit. FIG. 6 is a circuit diagram of a task processing device that does not include a task control circuit in the task processing device of FIG. 5. FIG. 6 is a circuit diagram of a task processing device that does not include a save circuit among the task processing devices of FIG. 5. FIG. 10 is a circuit diagram of a task processing device in an improved example 1; FIG. 6 is a partial circuit diagram of a task control circuit in Modification Example 1. It is a circuit diagram of a queue control circuit. It is a conceptual diagram which shows the relationship between a virtual queue and a task. FIG. 22 is a data structure diagram of a status register corresponding to FIG. 21. FIG. 22 is a conceptual diagram when tasks (E4) are sequentially placed in the virtual queue of FIG. FIG. 24 is a data structure diagram of a status register corresponding to FIG. 23. FIG. 24 is a conceptual diagram when tasks (E5) are sequentially placed in the virtual queue of FIG. FIG. 26 is a data structure diagram of a status register corresponding to FIG. 25. It is a flowchart which shows the process process of order insertion. It is a partial circuit diagram of a maximum value selection circuit. FIG. 26 is a conceptual diagram when a task (E6) is put back into the virtual queue of FIG. FIG. 30 is a data structure diagram of a status register corresponding to FIG. 29. It is a flowchart which shows the process of reverse insertion. It is a partial circuit diagram of a task selection circuit. It is a conceptual diagram when extracting a task (E3) from the virtual queue of FIG. FIG. 34 is a data structure diagram of a status register corresponding to FIG. 33. It is a flowchart which shows the process process of extraction. It is a 1st conceptual diagram which shows the relationship between the virtual queue and a task in re-execution priority type task scheduling. It is a 2nd conceptual diagram which shows the relationship between the virtual queue and a task in re-execution priority type task scheduling. It is a figure which shows the general circuit structure in the case of performing an auxiliary process by software OS. It is a time chart which shows the control method of a general serial type auxiliary process. It is a time chart which shows the control method of a general parallel type auxiliary process. It is a figure which shows the circuit structure in the case of implement | achieving auxiliary | assistant process control shown to FIGS. 38-40 by the task processing apparatus of a basic example. FIG. 10 is a circuit configuration diagram showing a relationship between a task processing device and an HWF in an improved example 2; It is a circuit diagram which shows the relationship between the state memory | storage part and task switching circuit in the modification 2. It is a time chart which shows the control method of the serial type auxiliary process in the modification 2. It is a time chart which shows the control method of the parallel type auxiliary process in the modification 2.

First, a task processing apparatus 100 that realizes task scheduling of a multitask OS by an electronic circuit will be described as a “basic example”. Next, a hardware implementation of a “double-input queue algorithm (described later)” suitable for the task processing apparatus 100 in the improved example 2 will be described as “improved example 1”. Finally, the task processing apparatus 100 that speeds up the auxiliary processing will be described as “Improvement 2”.
Hereinafter, when referring to "this embodiment", in principle, all of "basic example", "improved example 1", and "improved example 2" are shown.
{Basic example}

The task processing apparatus 100 shown in the present embodiment realizes a task scheduling function of a multitask OS by an electronic circuit. Before explaining the details of the task processing apparatus 100, first, the task state transition will be explained with reference to FIG. Here, description will be made on task state transition in a general multitask OS, but the same applies to task state transition by the task processing apparatus 100. The system call executed in the task processing apparatus 100 will also be outlined. A general multitask OS design concept will be described with reference to FIGS. 2 and 3, and a processing method of the task processing apparatus 100 in the basic example will be described in detail with reference to FIGS. Further, the characteristics of the task processing apparatus 100 will be described as appropriate for processing related to semaphores, mutexes, events, and the like, as compared with general techniques.
[Task state transition]

FIG. 1 is a task state transition diagram.
In multitask processing, each task has a “state”. Each task transits between a plurality of states described later, and is always in one of the states. The trigger for the state transition is “execution of system call” and “detection of interrupt request signal”. A system call is a special instruction among instructions executed by each task. The interrupt request signal is a signal generated when predetermined data is received from a peripheral device, such as a keyboard press, a mouse click, or communication data reception. Of course, the state transition also occurs when the time slice allocated to each task is consumed.

  Tasks are roughly classified into two types: “general tasks” and “special tasks”. A general task is a normal task that is executed in response to a system call. The special task is a task that is executed when an interrupt request signal is detected. This is a so-called interrupt handler. First, after describing each task state, various system call instructions will be described.

(1) STOP state (resting state)
Indicates that the task is in a dormant state. Both general tasks and special tasks can be in the STOP state. Hereinafter, a task in the STOP state is referred to as “STOP-task”.
1-1. General Task When another system executes a system call instructing activation of another task (hereinafter referred to as “activation system call”), the general task in the STOP state transitions to the READY state described later.
1-2. Special tasks Special tasks are usually in the STOP state. When an interrupt request signal is detected by a task switching circuit 210 described later, the special task transits from a STOP state to a RUN state described later. At this time, the task in the RUN state is switched to the READY state instead.

(2) RUN state (execution state)
Indicates that the task is running. That is, the task is assigned a time slice and has acquired the right to use the CPU. Both general and special tasks can be in the RUN state. Hereinafter, a task in the RUN state is referred to as “RUN-task”. Of the plurality of tasks, only one task can be in the RUN state at any one time, and two tasks cannot be in the RUN state at the same time.
2-1. General Task A general task in the RUN state transitions from the RUN state to the READY state or a WAIT state described later when a predetermined system call is executed. A general task in the RUN state also transitions to the READY state when the time slice is consumed. In any case, instead of the general task that was in the RUN state, the general task that is in the READY state transitions to the RUN state. When an interrupt request signal is detected, the RUN-task transitions to the READY state. At this time, the special task in the STOP state transitions to the RUN state.
When the RUN-task executes a system call that terminates itself (hereinafter referred to as “end system call”), the RUN-task transitions to the STOP state.
2-2. Special task The special task that has transitioned from the STOP state to the RUN state by the interrupt request signal returns to the STOP state when its own processing is completed. The states that the special task can take are only the STOP state and the RUN state.

(3) READY state (executable state)
Indicates that the task is ready to run. A task in the READY state can transition to the RUN state at any time if an execution right is given from the OS. Only general tasks can be in the READY state. Hereinafter, a task in the READY state is referred to as “READY-task”.
When a general task in the RUN state transitions to a state other than the RUN state by executing a system call, or when a special task in the RUN state ends its processing and transitions to the STOP state, the READY-task is switched. Transition to the RUN state. The general task changes from the READY state only to the RUN state. When there are a plurality of tasks in the READY state, one of the READY-tasks transitions to the RUN state based on the task priority that is part of the context information. When there are a plurality of READY-tasks having the same task priority, the task having the oldest transition to the READY state transitions to the RUN state.

(4) WAIT state (standby state)
The task is waiting for a predetermined WAIT cancellation condition to be satisfied. When the WAIT cancellation condition is satisfied, the task in the WAIT state transitions to the READY state. Only general tasks can be in the WAIT state. Hereinafter, a task in the WAIT state is referred to as “WAIT-task”. The WAIT cancellation condition will be described in detail later.

In summary, each task can proceed with its own processing using the CPU only when it is in the RUN state. The RTOS switches RUN-tasks as appropriate while managing the states of a plurality of tasks. As a result, a processing mode in which the CPU always executes one of the tasks is realized.
[System Call]

Next, I will add a note about system calls. System calls are roughly classified into three types: “activation system”, “WAIT system”, and “SET system”.
(1) Activation system call A system call related to a transition between the STOP state and the READY state.
1-1. Activation system call This is a system call in which task A, which is a RUN-task, activates another general task B. At this time, the general task B in the STOP state transitions to the READY state.
1-2. End system call The task that executed this system call ends its own processing and transitions from the RUN state to the STOP state. The end system call may be an instruction for one task to end another task.
(2) WAIT system call A system call related to a transition between the RUN state and the WAIT state.
2-1. Wait semaphore system call This system call requests acquisition of a semaphore (described later).
2-2. Wait mutex system call This system call requests acquisition of a mutex (described later).
2-3. Wait event system call A system call that waits for the establishment of an event (described later). In addition to the event ID, a standby flag pattern (described later) and a flag condition (described later) are executed as variables.
In any case, various WAIT cancellation conditions are set by the WAIT system call. If a WAIT cancellation condition is already satisfied when a WAIT system call is executed, the RUN-task that executed the system call transitions to the READY state. On the other hand, when the WAIT cancellation condition is not satisfied, the RUN-task transits to a WAIT state that waits for the WAIT cancellation condition to be satisfied.
(3) SET system call A system call related to a transition between the WAIT state and the READY state. Execution of a SET system call triggers the establishment of a WAIT cancellation condition.
3-1. Release semaphore system call This system call releases a semaphore.
3-2. Release mutex system call This system call releases a mutex.
3-3. Set event system call This system call sets the current flag pattern (described later) of an event.
3-4. Clear flag system call This system call clears the current flag pattern to zero.
In the present embodiment, the above nine types of system calls will be described, but it goes without saying that various system calls can be implemented.
[General RTOS design concept]

FIG. 2 is a conceptual diagram of a general RTOS.
This RTOS is a multitasking OS. A general RTOS is realized as software. A case where the RUN-task is switched from task A to task B will be described as an example. Since task A occupies the CPU, the RTOS interrupts the CPU and picks up the right to use the CPU from task A. After that, the context information of task A is saved in the TCB. The RTOS selects task B as the next RUN-task and loads context information from the task B TCB into the CPU registers. When the loading is completed, the RTOS passes the right to use the CPU to task B. In this way, the RTOS executes task switching from task A to task B by temporarily acquiring the right to use the CPU. The same applies to the execution of special tasks. Also in this case, the task switch is realized by saving the context information of the RUN-task to the TCB and then passing the right to use the CPU to the special task.
Since the RTOS is realized as software, it requires the right to use the CPU in order to execute its own processing. In other words, RTOS and tasks are competing for CPU usage. Hereinafter, the RTOS realized by software in this way is referred to as “software RTOS”.

FIG. 3 is a circuit diagram of a general CPU on which software RTOS is executed.
The CPU 84 includes an execution control circuit 90 that comprehensively controls memory access, instruction execution, and the like, a processing register 92 that stores various data such as task context information, and an arithmetic circuit 94 that executes arithmetic operations. The processing register 92 is a set of a plurality of types of registers, and is roughly divided into a special register 88 and a general-purpose register 86. The special register 88 is a register that holds a program counter, a stack pointer, a flag, and the like. The general-purpose register 86 is a register that holds work data, and includes a total of 16 registers R0 to R15. The special register 88 has two sides for the user and the system, but the general-purpose register 86 has only one side. Hereinafter, the data stored in the processing register 92 is referred to as “processing data”.

  The execution control circuit 90 causes the arithmetic circuit 94 to output processing data of a desired register among the processing registers 92 in response to a control signal (CTRL) for the output selector 98. The arithmetic circuit 94 performs an operation according to processing data, that is, an instruction or a variable. The calculation result is output to the input selector 96. The execution control circuit 90 inputs an operation result to a desired register among the processing registers 92 by a control signal (CTRL) for the input selector 96.

  Further, the execution control circuit 90 reads data from the memory via the CPU data bus, and loads it appropriately into the processing register 92 via the input selector 96. The execution control circuit 90 also records processing data in the memory as appropriate via the CPU data bus. The execution control circuit 90 executes the task while updating the program counter of the special register 88.

When a task switch occurs, the execution control circuit 90 saves the processing data in the TCB, which is an area on the memory. Assume that task A executes a system call and a task switch from task A to task B occurs. Since the RTOS acquires the right to use the CPU when the system call is executed, the CPU 84 temporarily operates according to the RTOS program. The processing process is as follows.
<Save context information of task A>

1. The execution control circuit 90 switches the special register 88 from the user to the system. The system special register 88 is loaded with processing data for RTOS processing.
2. The execution control circuit 90 saves the data in the general-purpose register 86 in a stack (not shown).
3. The execution control circuit 90 loads processing data for RTOS into the general-purpose register 86 from a storage medium (not shown), for example, another register. At this stage, the processing data in the processing register 92 is completely replaced with processing data for RTOS.
4). The RTOS detects the TCB of task A from the memory and writes the processing data saved in the stack to the TCB. Also, the processing data of the user special register 88 is written to the TCB as part of the context information. In this way, the processing data of task A is saved in the TCB. The RTOS records in the TCB of the task A that the state transition of the task A from “RUN” to “READY (or WAIT)”.
<Load context information of task B>

1. The RTOS detects the task B TCB from the memory and writes the TCB context information to the stack and special register 88. The RTOS records in the TCB of the task B that the state transition of the task B from “READY” to “RUN”.
2. The RTOS saves RTOS processing data from the general-purpose register 86 to a recording medium (not shown).
3. The execution control circuit 90 loads the stack context information into the general-purpose register 86. The execution control circuit 90 switches the special register 88 from the system to the user. In this way, the processing data of task B is loaded into the processing register 92.

  The task switch is realized through the above processing steps. Normally, the general-purpose register 86 has a one-sided structure, and therefore a stack is used to switch between task processing data and RTOS processing data. If the general-purpose register 86 is also made two-sided, it is not necessary to save and load through the stack, so that higher-speed task switching is possible.

In this embodiment, a save register 110 is further provided for each task, thereby realizing a faster task switch. The task switch using the save register 110 will be described in detail with reference to FIG. In the case of the CPU 84 and the general software RTOS described in relation to FIG. 3, it can be seen that frequent access to the TCB occurs during task switching. In the above example, description has been made on the premise that the task is switched from the task A to the task B, but actually, it is necessary for the RTOS to execute many instructions in order to select the task B to be executed next. Also at this time, the RTOS frequently accesses the memory. The task processing apparatus 100 according to the present embodiment realizes a faster task switch because a task control circuit 200 described later executes task selection processing exclusively.
[RTOS hardware implementation by the task processing device 100]

FIG. 4 is a conceptual diagram of the RTOS in this embodiment.
Unlike a general software RTOS, the RTOS in the present embodiment is mainly realized as hardware separate from the CPU. Hereinafter, RTOS realized by hardware is referred to as “hardware RTOS”. The RTOS of this embodiment is mainly hardware that is separate from the CPU, and therefore requires substantially no right to use the CPU to execute its own processing. In other words, RTOS and tasks have little competition for CPU usage. In the case of the general software RTOS shown in FIG. 2, the CPU is not only a task execution circuit but also an RTOS execution circuit. On the other hand, in the case of the hardware RTOS in this embodiment, the CPU is clarified as a task execution circuit, and the task scheduling function can be realized centering on a save circuit 120 and a task control circuit 200 described later.

FIG. 5 is a circuit diagram of the task processing apparatus 100 in the basic example.
The task processing device 100 includes a save circuit 120 and a task control circuit 200 in addition to the CPU 150. The CPU 150 is a task execution subject, and the save circuit 120 and the task control circuit 200 are circuits that play the role of the RTOS shown in FIG. The task scheduling process is led by the task control circuit 200.

  The CPU 150 includes an execution control circuit 152, a processing register 154, and an arithmetic circuit 160. The CPU 150 may be a general CPU described with reference to FIG. However, the CPU 150 in the present embodiment is slightly different from the CPU 84 shown in FIG. A specific circuit configuration will be described in detail with reference to FIG.

  The task control circuit 200 includes a task switching circuit 210, a semaphore table 212, an event table 214, a task selection circuit 230, and a state storage unit 220. The semaphore table 212 and the event table 214 will be described in detail with reference to FIG. The state storage unit 220 is a unit associated with each task. Hereinafter, the state storage unit 220 corresponding to the task A is expressed as “state storage unit 220_A”. Each state storage unit 220 holds task state data. The state data is information indicating task attributes such as task priority and state among context information. Specific data contents will be described later with reference to FIG. From each state storage unit 220, all state data of all tasks is constantly output to the task selection circuit 230. The task selection circuit 230 is a circuit that performs various task selection such as selection of a RUN-task based on the state data of each task. The task selection circuit 230 will also be described in detail with reference to FIG. When task switching circuit 210 detects a system call signal (SC) received from execution control circuit 152 or an interrupt request signal (INTR) from an external device, task switching circuit 210 executes a task switch.

  The execution control circuit 152 transmits a system call signal (SC) to the task switching circuit 210 when the system call is executed. When the task switching circuit 210 detects an interrupt request signal (INTR), the task switching circuit 210 asserts a stop request signal (HR) to the execution control circuit 152. The execution control circuit 152 asserts a stop completion signal (HC) to the task switching circuit 210 when the operation of the CPU 150 is stopped. With these three types of signals, the CPU 150 and the task control circuit 200 are linked to each other.

  The save circuit 120 includes a load selection circuit 112 and a plurality of save registers 110. The save register 110 is also a unit associated with each task, and is a register for saving the processing data of the processing register 154. Therefore, the save register 110 has a data capacity equal to or greater than that of the processing register 154. Hereinafter, the save register 110 corresponding to the task A is expressed as “save register 110_A”. When instructed by the task switching circuit 210, the load selection circuit 112 loads data in any of the save registers 110 (hereinafter, data held by the save register 110 is referred to as “saved data”) into the processing register 154. To do.

  Each save register 110 always outputs each save data to the load selection circuit 112. When the task switching circuit 210 inputs a task selection signal (TS) designating a task ID to the load selection circuit 112, the load selection circuit 112 outputs the saved data of the save register 110 corresponding to the designated task to the processing register 154. . Further, when the task switching circuit 210 inputs a write signal (WT) to the processing register 154, the saved data is actually loaded into the processing register 154.

On the other hand, all the processing data in the processing register 154 is always output to the all save register 110. When the task switching circuit 210 asserts a write signal (WT) to a desired save register 110, the processing data is saved in the save register 110. Here, the number of bits that can be transmitted at one time by the bus connecting the processing register 154 and each save register 110 is set so that the processing data can be transferred in parallel. Therefore, the task switching circuit 210 can write the processing data to the save register 110 at a stretch by only transmitting the write signal to the save register 110 once. The number of bits of the bus connecting the save register 110 and the load selection circuit 112, and the load selection circuit 112 and the CPU 150 are set in the same manner.
Hereinafter, a task switch execution method for each of the system call and the interrupt request signal will be described.
[1] System call execution

  When the execution control circuit 152 of the CPU 150 executes the system call, the execution control circuit 152 stops the clock of the CPU 150 (hereinafter referred to as “CPU clock (CLK)”). A specific stopping method will be described later in detail with reference to FIG. The execution control circuit 152 transmits a system call signal (SC) indicating the execution of the system call to the task switching circuit 210 of the task control circuit 200. When CLK is completely stopped, the execution control circuit 152 asserts a stop completion signal (HC) to the task switching circuit 210.

Nine signal lines are connected between the CPU 150 and the task switching circuit 210 for system call signal transmission. Nine signal lines correspond to the nine types of system calls described above. The execution control circuit 152 transmits a digital pulse through one of the system call signal lines according to the type of the system call that has been executed. The task switching circuit 210 can immediately detect the type of the system call that has been executed according to which of the nine system call signal lines the digital pulse is detected from. The task switching circuit 210 selects necessary data from the output data of the task selection circuit 230 according to the type of the system call, and executes the process instructed by the system call. This process is executed on condition that HC is asserted. The relationship between the task switching circuit 210 and the task selection circuit 230 will be described in detail with reference to FIG. The system call parameters and return values are written to a predetermined general-purpose register 158 in the processing register 154. The task switching circuit 210 can read parameters and write return values to the general-purpose register 158. Here, it is assumed that task A, which is a RUN-task, executes a wait semaphore system call. Therefore, first, it is necessary to save the processing data of task A.
<Save context information of task A>

  The execution control circuit 152 inputs an SC signal indicating a wait semaphore system call to the task switching circuit 210. The execution control circuit 152 stops CLK and asserts HC when the stop is completed. The task switching circuit 210 outputs a semaphore ID of a semaphore to be waited for to a semaphore selection circuit 234, which will be described later, among various selection circuits built in the task selection circuit 230, and then selects a task B to be executed next. select. The task switching circuit 210 writes predetermined data to the state storage unit 220_A. For example, the state of task A is changed from “RUN” to “READY” or “WAIT”. More specifically, the task switching circuit 210 outputs “WAIT” as data indicating the task state among the state data to the entire state storage unit 220 and then inputs a write signal (WT_A) only to the state storage unit 220_A. To do. In this way, the state of task A is changed.

Next, the task switching circuit 210 outputs a write signal (WT) to the save register 110_A. Since the processing data of the processing register 154 is always output to each save register 110, it is saved in the save register 110_A of the task A by this write signal (WT).
<Load context information of task B>

The task switching circuit 210 outputs a task selection signal (TS_B) designating the task B to the load selection circuit 112 when the change of the state data of the task A and the saving of the processing data are completed. As a result, the save data of the save register 110_B is output to the processing register 154. When the task switching circuit 210 outputs a write signal (WT) to the processing register 154, the saved data of task B is loaded into the processing register 154. Further, the task switching circuit 210 writes predetermined data in the state storage unit 220 of task B. For example, the state of task B is changed from “READY” to “RUN”. When the above processing is completed, the execution control circuit 152 restarts the CPU clock. The CPU 150 starts executing the task B by the resumed CPU clock. Further details of the processing method will be described later with reference to FIG.
[2] Generation of interrupt request signal

  The task switching circuit 210 detects an interrupt request signal (INTR) from a peripheral device. More specifically, the interrupt request signal (INTR) is transmitted to the task switching circuit 210 from an interrupt controller (not shown). A parameter indicating the level of the interrupt request signal (INTR) is recorded in a register built in the interrupt controller. The task switching circuit 210 asserts a stop request signal (HR) to the execution control circuit 152, and the execution control circuit 152 stops the CPU clock. As in the case of system call execution, the task switching circuit 210 saves the processing data of the RUN-task in the save register 110. Next, the task switching circuit 210 starts a special task. There is one type of special task that is activated regardless of the parameters of the interrupt request signal. The special task reads the INTR parameter from the built-in register of the interrupt controller and executes a process according to the parameter. The processing executed by the special task may be execution of a set event system call or a set semaphore system call, or activation of a general task. Depending on the parameters, the special task may end without executing any special processing. What processing is executed according to the parameters of INTR depends on the implementation of the special task. When the execution of the special task is completed, the next RUN-task is selected from the READY-tasks.

  The task switching circuit 210 causes the CPU 150 to load the processing data of the save register 110 corresponding to the special task. The time required for switching from the general task to the special task can be estimated in advance by the operation clock of the task control circuit 200. When the operation clock of the task switching circuit 210 elapses after the HR is asserted to the execution control circuit 152, the task switching circuit 210 negates HR to cancel the stop of the CPU clock. The execution control circuit 152 restarts the CPU clock when HR is negated. At this time, the task switching circuit 210 completes the task switch from the general task to the special task. Details of the processing method will be described later with reference to FIG.

In either case,
(A) Saving / loading of processing data (B) The core processing of task switching such as task state transition and RUN-task selection is realized by hardware. Regarding (A) and (B), the need to access the TCB on the memory is eliminated, which contributes to the speedup of the task switch. In realizing the task processing apparatus 100, the CPU 150 need only have a function of stopping and restarting the CPU clock. Note that the realization of all of these functions by hardware does not limit the scope of the present invention. For example, those skilled in the art will understand that the main functions of (A) or (B) may be realized by hardware, and some functions of RTOS may be realized by software in order to assist the hardware functions. It is a place.

FIG. 6 is a circuit diagram of the CPU 150 of FIG.
Unlike the CPU 84 in FIG. 3, the processing register 154 includes only one surface for both the special register 156 and the general-purpose register 158. In the processing register 154, an input bus from the load selection circuit 112, an output bus to the save register 110, and a signal line for a write signal (WT) from the task switching circuit 210 are added. The execution control circuit 152 inputs data of a desired register in the processing register 92 to the arithmetic circuit 160 by a control signal (CTRL) for the output selector 164. The calculation result is input to the input selector 162. The execution control circuit 152 inputs a calculation result to a desired register among the processing registers 154 by a control signal (CTRL) to the input selector 162. The execution control circuit 152 executes the task while updating the program counter of the special register 156.

  The processing data is saved in the save register 110 instead of the TCB on the memory. The processing data is always output from the processing register 154 to each save register 110. The task switching circuit 210 controls which save data is actually saved in which save register 110 as described above.

  The save data is loaded into the processing register 154 from the save register 110 instead of the TCB on the memory. The task switching circuit 210 controls which save register 110 processing data is actually loaded at which timing as described above.

  The bus connecting the processing register 154 and the load selection circuit 112, and the processing register 154 and the save register 110 is a bus having the number of bits that can transfer the processing data in parallel at one time. Therefore, reading and writing can be performed at once by the write signal (WT) from the task switching circuit 210. The general software RTOS needs to temporarily occupy the processing register 154 at the time of task switching. On the other hand, the hardware RTOS in this embodiment does not need to load special processing data for task switch processing into the processing register 154. When switching from task A to task B, the task B processing data is simply loaded after saving the task A processing data, so two processing registers 154 are prepared for the system and the user, or stacks are prepared. There is no need to perform data exchange processing via

FIG. 7 is a circuit diagram showing a mechanism by which the execution control circuit 152 stops the CPU clock.
The inputs of the second AND gate 174 are the original clock (CLK0) and the output of the first AND gate 172, and the latter is negative logic. The output of the first AND gate 172 is a stop completion signal (HC). Since the stop completion signal (HC) is normally 0, the second AND gate 174 outputs the input original clock (CLK0) as it is as the CPU clock (CLK). The CPU 150 operates in response to the CPU clock output from the second AND gate 174. When the output of the first AND gate 172 is “1”, in other words, when the stop completion signal (HC) = 1, the output of the second AND gate 174 is fixed to zero and the CPU clock (CLK) stops.

  The inputs of the first AND gate 172 are the output of the OR gate 176 and the CPU busy signal (CBUSY), the latter being negative logic. CBUSY is a signal output from a known state machine that generates an internal cycle of the CPU 150, and is a signal that is “1” when the CPU 150 is in a stoppable state. For example, when the arithmetic circuit 94 completes the last instruction of a single instruction being executed or a plurality of locked instructions, the CPU can be stopped, or the supply of the CPU clock has already been stopped. "0" when

The inputs of the OR gate 176 are an output (SC_DETECT) of the instruction decoder 170 and a stop request signal (HR) from the task switching circuit 210. The instruction decoder 170 includes a latch circuit that holds SC_DETECT. The instruction decoder 170 receives the data (FD) fetched from the CPU 150, and outputs SC_DETECT = 1 when the FD is a system call instruction. Even if the FD subsequently changes due to the built-in latch circuit, the instruction decoder 170 continues to output SC_DETECT = 1. The instruction decoder 170 also receives a write signal (WT) for the processing register 154 of the task switching circuit 210. When WT changes from 0 to 1, loading of the saved data into the processing register 154 is executed as described above. This WT is a pulse signal that returns from 1 to 0 after a predetermined time. When WT changes from 1 to 0, the latch circuit of instruction decoder 170 is reset and instruction decoder 170 negates SC_DETECT. The relationship between SC_DETECT and the write signal (WT) will be described in detail with reference to FIG. The instruction decoder 170 in this embodiment is a device provided exclusively for the execution control circuit 152 in order to determine whether or not the execution target instruction is a system call. As a modification, the instruction decoder 170 may be shared with a CPU decoder in charge of the decoding stage of the CPU 150. In this case, the instruction decoder 170 can be realized by adding a function of outputting SC_DETECT = 1 to the CPU decoder when the decoded data is a system call instruction.
When the interrupt request signal (INTR) is generated, the task switching circuit 210 asserts a stop request signal (HR) to the execution control circuit 152. That is, the output of the OR gate 176 becomes “1” when a system call is executed or a stop request signal (HR) is asserted.

  In summary, when a system call is executed or an interrupt request signal is generated and the CPU busy signal becomes “0”, the output of the first AND gate 172 becomes “1”, and the second AND 174 outputs the CPU clock. No output.

FIG. 8A is a time chart showing the relationship between various signals when an interrupt request signal is generated.
In the figure, first, at time t ₀ , the task switching circuit 210 detects an external interrupt request signal (INTR). The task switching circuit 210 asserts a stop request signal (HR) to the execution control circuit 152 in order to execute a special task. Input timing _{t 1} is almost simultaneous with the detection timing _{t 0.} At time _{t 1,} the state machine of the CPU150 is "in the task execution" is a CBUSY = 1. Since HR = 1, the OR gate 176 outputs “1”, but since CBUSY = 1, the CPU 150 does not stop. Therefore, even if HR = 1 is input, the CPU clock (CLK) is output in synchronization with the original clock (CLK0) for a while.

As time elapses, it changes CBUSY = 0 at time _{t 2.} Since HR = 1 already, the first AND gate 172 outputs HC = 1, and the CPU clock output from the second AND gate 174 is fixed to 0. On the other hand, the task switching circuit 210 starts task switching from a general task to a special task when HC is asserted. As will be described in detail later, the time required for the task switch is several times as the operation clock of the task control circuit 200. The task control circuit 200 negates the stop request signal (HR) on condition that the operation clock of the task control circuit 200 has changed a predetermined number of times after HC is asserted (time t ₃ ). Since HR = 0, the execution control circuit 152 restarts the CPU clock (CLK). When the CPU 150 resumes the processing, the CPU 150 changes CBUSY from 0 to 1 (time t ₄ ). Thus, the period from time t ₂ the CPU clock is stopped at time t _3, so that the task switch to a special task is performed from the general task.
As another processing method, HR may be negated on the condition that the task control circuit 200 has completed the task switch instead of being conditional on the operation clock of the task control circuit 200 changing a predetermined number of times. Good. Then, the execution control circuit 152 may negate HC on the condition that HR is negated. When HC = 0, the execution control circuit 152 restarts the CPU clock (CLK). In this way, the execution of the task may be resumed.

FIG. 8B is a time chart showing the relationship between various signals when a system call is executed.
In the figure, first, at time t ₀ , the instruction decoder 170 detects a system call and changes SC_DETECT from 0 to 1. At time t ₀ , the state machine of the CPU 150 is “task executing” and CBUSY = 1. Since SC_DETECT = 1, the OR gate 176 outputs “1”, but the CPU 150 does not stop because CBUSY = 1. Therefore, even if SC_DETECT = 1 is output, the CPU clock (CLK) is output in synchronization with the original clock (CLK0) for a while.

As time elapses, it changes CBUSY = 0 at time _{t 1.} Since SC_DETECT = 1 and CBUSY = 1, HC is negated and the CPU clock is stopped. When HC = 0 is input, task switching circuit 210 starts task switch processing and outputs a write signal (WT) to CPU 150. The saved data is loaded into the processing register 154 at time t ₂ when WT changes from 0 to 1. Write signal (WT), since the pulse signal, the WT = 0 to time _{t 3} after a predetermined time. SC_DETECT latched in the instruction decoder 170 is reset by detecting the falling edge of WT: 1 → 0 (time t ₄ ). At this time, CBUSY changes from 0 to 1. Since CBUSY = 1, HC = 0 and the CPU clock is restarted. Between time t ₁ at which the CPU clock is stopped at time t _4, so that the task switch is performed.
As another processing method, the execution control circuit 152 is configured on the condition that the task control circuit 200 completes the task switch and negates the HR instead of being conditional on the detection of the falling edge of WT: 1 → 0. HC may be negated. SC_DETECT is reset on condition that HC = 0. The execution control circuit 152 restarts the CPU clock (CLK), and CBUSY changes from 0 to 1.

  In any case, the CPU 150 does not need to recognize that the RUN-task switching has been performed while the CPU clock is stopped. Since the task switching circuit 210 performs task switching while the CPU clock is stopped and the CPU 150 is frozen, the processing of the CPU 150 and the processing of the task control circuit 200 are sequentially separated.

FIG. 9 is a schematic diagram for explaining the stop timing of the CPU clock in the pipeline processing.
The CPU 150 executes a task by executing a plurality of instructions while sequentially reading them from the memory to the processing register 154. The instruction which is the execution unit of this task is decomposed into the following four phases.
1. F (fetch): fetch an instruction from the memory.
2. D (decode): interprets an instruction.
3. E (execution): execute an instruction.
4). WB (write back): The execution result is written in the memory.

  When a certain task sequentially executes instruction 1 to instruction 5, F from instruction 2 may be executed after execution from F of instruction 1 to WB. However, for more efficient execution, execution of instruction 2 is often initiated during execution of instruction 1. Such a processing method is called pipeline processing. For example, when the instruction 1 reaches the phase D, the F phase of the instruction 2 is started. When the instruction 1 reaches the phase E, the D phase of the instruction 2 and the F phase of the instruction 3 are executed. Thus, by increasing the number of instructions executed per unit time, the execution time for each task can be reduced.

  Furthermore, each phase may be subdivided into two phases. For example, the F phase is separated into two phases F1: F2. When instruction 1 reaches the phase of F2, the phase of F1 of instruction 2 is started. When the instruction 1 reaches the phase D1, the F2 phase of the instruction 2 and the F1 phase of the instruction 3 are executed. By subdividing the phases, the calculation resources of the CPU 150 can be used more efficiently. In FIG. 9, the CPU clock stop timing when a system call occurs in the pipeline processing in which each phase is divided into two phases will be described.

  In the figure, instruction 1 starts processing at the timing of CPU clock “0”. Decoding of the instruction 1 is completed at the timing of the CPU clock “4”. Assume that instruction 1 is a system call. The instruction decoder 170 changes SC_DETECT from 0 to 1. Next, the condition for SC_DETECT to return from 1 to 0 is that the write signal (WT) from the task switching circuit 210 to the processing register 154 changes from 1 to 0. Even when SC_DETECT = 1, since instructions 2 to 5 are already being executed or have been started, CBUSY = 1 remains. Therefore, the second AND gate 174 continues to output the CPU clock. However, when SC_DETECT = 1, the execution control circuit 152 temporarily stops the update of the program counter so that a new instruction is not fetched. Therefore, the instruction 6 and later are not fetched from the memory.

Although the instruction 1 is completely executed at the timing of the CPU clock “8”, since the instructions 2 to 5 are being executed, the CPU busy signal remains “1”. When the timing of the CPU clock “12” is reached, execution of the instruction 5 is completed. At this time, the CPU busy signal becomes “0”. After that, the supply of the CPU clock is stopped according to the process related to FIG. The task switching circuit 210 saves the processing data at the stage where the instructions up to the instruction 5 are completed in the save register 110. According to such a stopping method, the task can be switched without wasting the execution result of the instruction after the system call is executed. When the task switch is completed, the CPU busy signal is set to “1” again, and the processing of the instruction decoder 170 is resumed. Thus, the CPU clock is supplied again.
As another processing method, the CPU busy signal may be set to “0” and the supply of the CPU clock may be stopped when the execution of the system call instruction is completed. In this case, another instruction that has been executed simultaneously with the system call instruction is stopped during execution. The intermediate processing result of the interrupted instruction is recorded in the processing register 154 and then saved in the save register 110. The next time this task becomes a RUN-task, the continuation of the suspended instruction is executed. For example, when an instruction is interrupted at the stage where the fetch is completed, the instruction and operand read from the memory are saved in the save register 110. When the task is resumed, the data in the save register 110 is loaded into the processing register 154, and the subsequent processing is executed from the decode stage.

FIG. 10 is a circuit diagram showing the relationship between the state storage unit 220 and the task switching circuit 210.
The state storage unit 220 includes a state register 250 and a timer 252. The state storage unit 220 holds task state data. The timer 252 is a timer that starts when the task transitions to the READY state or the WAIT state. The time that has elapsed since the task transitioned to the READY state is referred to as “READY elapsed time”, and the time that has elapsed since the task transitioned to the WAIT state is referred to as “WAIT elapsed time”. The timer 252 always outputs the value as a TIM signal. When a task is switched to a READY state or a WAIT state at the time of task switching, the task switching circuit 210 drives the timer 252 of the task to start time measurement.

The state storage unit 220 is a set of registers shown below.
(A) Task ID register 254: Holds a task ID. An ID signal indicating a task ID is constantly output from the task ID register 254 to the task selection circuit 230. Hereinafter, the ID signal output from the task ID register 254 of the task A to the task selection circuit 230 is referred to as “ID_A signal”. The same applies to other signals output from the state storage unit 220.
(B) Task priority order register 256: Holds task priority order. The task priority order register 256 always outputs a PR signal indicating the task priority order. “0” is the highest priority, and a larger value indicates a lower task priority.
(C) Task status register 258: indicates a task status. Any one of STOP, READY, RUN, WAIT, and IDLE is always output as the ST signal. Note that IDLE is a state before the task is initialized.
(D) Task activation address register 260: indicates the TCB address of the task in the memory. The output is an AD signal.
(E) Wait reason register 262: When the task is in the WAIT state, it indicates the reason for waiting as part of the WAIT cancellation condition. The reason for waiting is one of “waiting for semaphore”, “waiting for event”, and “waiting for mutex”. The output is a WR signal.
(F) Semaphore ID register 264: Holds the semaphore ID of the semaphore to be waited (hereinafter simply referred to as “waiting semaphore”) when the task is in the WAIT state because of waiting for the semaphore. The output is a SID signal.
(G) Mutex ID register 265: Holds the mutex ID of the mutex to be waited (hereinafter simply referred to as “waiting mutex”) when the task is in the WAIT state because of waiting for the mutex. The output is a MID signal.
(H) Event ID register 266: Holds an event ID of an event to be waited (hereinafter simply referred to as “waiting event”) when the task is in the WAIT state because of waiting for an event. The output is an EID signal.
(I) Wait flag register 268: Holds a wait flag pattern when the task is in the WAIT state because of waiting for an event. The output is the FL signal.
(J) Flag condition register 270: Holds a flag condition when the task is in the WAIT state because of waiting for an event. The output is an FLC signal. The standby flag pattern and flag conditions will be described later.
(K) Flag initialization register 272: Holds data indicating the presence or absence of a standby flag pattern. The output is the FLI signal.
(L) Timeout counter 274: In a WAIT system call, a timeout value is specified as a variable. The timeout counter 274 holds a timeout value. The task switching circuit 210 periodically decrements the timeout value of each timeout counter 274. The output is a TO signal. Instead of the task switching circuit 210 decrementing the timeout value, the timeout counter 274 itself may autonomously decrement its own timeout value periodically.

The task selection circuit 230 selects a task based on various signals output from each state storage unit 220. The task selection circuit 230 includes the following circuits.
(A) Execution selection circuit 232: When the task is switched, the next RUN-task is selected. The execution selection circuit 232 always selects one of the tasks as a RUN-task based on the state data constantly output from the state storage unit 220. There are four types of input signals of the execution selection circuit 232: ID, ST, PR, and TIM. The output is the task ID of the next RUN-task. A detailed circuit configuration will be described in detail with reference to FIG.
(B) Semaphore selection circuit 234: Selects a task to transition from the WAIT state to the READY state by executing a release semaphore system call. A semaphore ID of a semaphore released by a release semaphore system call (hereinafter simply “release semaphore”) is input from the task switching circuit 210. There are six types of input signals from the state storage unit 220: ID, ST, WR, PR, SID, and TIM. The output signal is a task ID of a task that makes a transition from the WAIT state to the READY state. If there is no corresponding task, a predetermined value such as -1 is output. A more specific circuit configuration will be described in detail with reference to FIG.
(C) Event selection circuit 236: Selects a task that transitions from the WAIT state to the READY state by executing the set event system call. An event ID of an event (hereinafter simply referred to as “setting event”) set by the set event system call is input from the task switching circuit 210. There are six types of input signals from the state storage unit 220: ID, ST, WR, EID, FL, and FLC. The output signal outputs the task ID of the task that transitions from the WAIT state to the READY state, and the FL and FLC of the task.
(D) Timeout detection circuit 238: Among the tasks in the WAIT state, a task for which the timeout value of the timeout counter 274 has become zero is detected. The timeout detection circuit 238 is driven every time the timeout value is updated. There are three types of input signals to the timeout detection circuit 238: ID, ST, and TO. The output signal is the task ID of the corresponding task. If there is no corresponding task, a predetermined value such as -1 is output.
(E) Mutex circuit 240: Selects a task that transitions from the WAIT state to the READY state by executing the release mutex system call. The mutex ID of the mutex released by the release mutex system call (hereinafter simply referred to as “release mutex”) is input from the task switching circuit 210. There are six types of input signals from the state storage unit 220: ID, ST, WR, PR, SID, and TIM. The output signal is a task ID of a task that makes a transition from the WAIT state to the READY state. If there is no corresponding task, a predetermined value such as -1 is output.
(F) Search circuit 242: When a task ID is input from the task switching circuit 210, all state data of the task is output.

In the following, regarding the task switch, RUN-task selection, semaphore, event, mutex, and timeout will be described in comparison with a general technique, particularly focusing on the processing of the task selection circuit 230.
[RUN-task selection]
[1] Selection of RUN-task by general software RTOS

FIG. 11 is a diagram showing a task ready list used when selecting a RUN-task by a general RTOS.
The task ready list is formed on a memory and is a list in which TCBs of each READY-task are linked by pointers. The priority level pointer 280 is provided for each task priority level and points to the head address of the TCB of the task having the corresponding task priority level. In the case of the task ready list shown in the figure, the task priority “0” priority pointer 280 addresses the task A TCB, and the task priority “1” priority pointer 280 addresses the task B TCB. ing. The TCB of task A further addresses the TCB of task D. The general software RTOS selects the next RUN-task while scanning the task ready list. At this time, RTOS
A. RUN--Transitions the task from RUN to READY.
B. The next RUN-task is selected, and the task state of the task is changed from READY to RUN.
A two-stage process is performed. Each processing by the software RTOS is disassembled as follows.
<RUN-task state transition>

Here, RUN-task is described as task J.
A1. The RTOS holds the task ID of the RUN-task in the memory. Based on this task ID, the TCB address of task J is acquired.
A2. Access TCB and obtain task priority of task J. It is assumed that the task priority is “0”.
A3. A priority order pointer 280 corresponding to the task priority order of task J is acquired from the task ready list shown in FIG.
A4. The TCB indicated by the acquired priority order pointer 280 is detected. Here, the TCB of task A is detected.
A5. Traces the pointer of the task A TCB and detects the last TCB. In the figure, task F is the last.
A6: The task F TCB pointer is set to address the task J TCB. In this way, the TCB of task J is added to the task ready list.
A7. “READY” is set in the TCB of task J. Further, the processing data is copied to the register storage area of the TCB.
<READY-task state transition>

B1. The RTOS detects which TCB the priority level pointer 280 of the task priority level “0” indicates. If there is no TCB, it is detected whether the priority order pointer 280 of the task priority “1” indicates any TCB. One task is specified while lowering the task priority until a TCB is found. In the case of the figure, task A is specified.
B2. Remove task A from the task ready list. Specifically, the priority order pointer 280 of the task order “0” is rewritten so as to address the TCB of the task D instead of the task A. Also, NULL is set so that the pointer of task A does not address task D. Thus, the TCB for task A is removed from the task ready list.
B3. “RUN” is set in the TCB of task A. Further, the processing data saved in the TCB register storage area of task A is loaded into the processing register.

A general software RTOS performs task switching by such a task ready list. That is, the policy for RTOS to select a RUN-task from a plurality of READY-tasks is as follows.
1. READY-task (first condition).
2. READY-task having the highest task priority (second condition).
3. When there are a plurality of tasks having the highest task priority, the task in the READY state is the oldest task (third condition).
These three conditions are collectively referred to as “RUN task selection conditions”. The execution selection circuit 232 of the task processing apparatus 100 implements such a task scheduling function of RTOS by hardware.
[2] RUN-task selection by hardware RTOS in basic example

FIG. 12 is a circuit diagram of the execution selection circuit 232.
Here, a description will be given assuming that a RUN-task is selected from eight tasks of task 0 to task 7. The execution selection circuit 232 includes four first comparison circuits 290 (290a to 290d), two second comparison circuits 292 (292a and 292b), and one third comparison circuit 294. Further, eight determination circuits 296 (296a to 296h) are also included.
The determination circuit 296 receives the ST signal indicating the task state, and outputs a CID signal indicating “1” if READY and “0” if not READY. The determination circuit 296 performs determination based on the first condition among the RUN task selection conditions. The first comparison circuit 290 receives the IDs of the two tasks, PR, TIM, and the CID signal from the determination circuit 296 as inputs.

Description will be made by paying attention to the first comparison circuit 290a. The first comparison circuit 290a compares the task 0 and the task 1, and selects a more suitable task based on the RUN task selection condition described above.
First determination: First, the CID signals output from the determination circuit 296a and the determination circuit 296b are compared. If either one is “1”, in other words, if only one of the tasks is in the READY state, the first comparison circuit 290a outputs the ID, PR, and TIM of the task. If both are “0”, that is, if no task is in the READY state, the first comparison circuit 290a outputs ID = PR = TIM = NULL. This indicates that no task has been selected. If both are “1”, that is, if any task is in the READY state, the next second determination is executed.
Second determination: The PR signal of task 0 and the PR signal of task 1 are compared, and a task having a higher task priority is selected. For example, if the task priority of task 0 is “1” and the task priority of task 1 is “2”, the ID, PR, and TIM of task 0 are output. According to the second determination, a task having a higher task priority is selected as a RUN-task candidate. If the task priorities of task 0 and task 1 are the same, the next third determination is executed.
Third determination: The task 0 TIM signal is compared with the task 1 TIM signal, and the task having the longer READY elapsed time is selected. If the READY elapsed time is the same, task 0 is selected. Since the determination can be made simply by comparing the magnitudes of the elapsed times, TCB order management like a task ready list becomes unnecessary.

  In this way, task 0 and task 1, task 2 and task 3, task 4 and task 5, task 6 and task 7 are respectively compared according to the RUN task selection condition. The second comparison circuit 292 further narrows down RUN-task candidates based on the outputs from the two first comparison circuits 290. The second comparison circuit 292a executes task selection based on the outputs of the first comparison circuit 290a and the first comparison circuit 290b. For this reason, the second comparison circuit 292a outputs the ID, PR, and TIM of the task that best meets the RUN task selection condition among the tasks 0 to 3. The same applies to the third comparison circuit 294, and the third comparison circuit 294 outputs the task ID of one of the tasks 0 to 7.

According to such a processing method, the RUN task selection condition can be realized by hardware. The general software RTOS selects the RUN-task while accessing the task ready list. However, the execution selection circuit 232 in this embodiment selects the RUN-task based on the state data constantly output from the state storage unit 220. Selected. The processing of the execution selection circuit 232 is summarized as follows.
<RUN-task state transition>

Here, RUN-task is described as task J.
A1. The task switching circuit 210 sets “READY” in the task status register 258 of task J.
A2. The task switching circuit 210 sets the timer 252 of the task J and starts measuring the READY elapsed time.
Thus, task J makes a state transition from RUN to READY. The processing data is saved in the save register 110 of the task J as described above. Since the bus connecting the processing register 154 and the save register 110 can transmit processing data in parallel, the processing of A1 and A2 can be executed in one clock time.
<READY-task state transition>

B1. The task switching circuit 210 specifies a RUN-task from the task ID output by the execution selection circuit 232 when the state transition of the task J is completed. “RUN” is set in the task status register 258 of this task.
Thus, the specified task makes a state transition from READY to RUN. The processing data of the identified task is loaded from the save register 110 to the processing register 154. Since the bus connecting the save register 110 and the processing register 154 is also the number of bits that can transmit the processing data in parallel, the processing of B1 can be executed in one clock time.

The software RTOS consumes a large amount of CPU clock time due to access to a task ready list or the like at the time of task switching. On the other hand, the task control circuit 200 in this embodiment can complete the task switch in a short time. Since the state storage unit 220 always outputs the state data to the execution selection circuit 232, the execution selection circuit 232 always outputs the task ID of any task. RUN-task selection processing is not started after the task switch occurs, but the selection of the RUN-task by the output of the execution selection circuit 232 when the task switch occurs also contributes to the speedup of the task switch. doing. Here, although it has been described that there are eight tasks, it is possible to deal with more tasks by increasing the number of stages of the comparison circuit.
[Semaphore processing]

FIG. 13 is a diagram showing a wait semaphore list used in semaphore processing by a general RTOS.
Before describing the wait semaphore list, a brief description of semaphores will be given. In the semaphore table 212, a semaphore ID and a semaphore counter are recorded in association with each other. The semaphore counter is set to a finite number as an initial value. For example, it is assumed that semaphore ID = 4 and semaphore counter = 3 are set. When any task executes a wait semaphore system call with the semaphore with semaphore ID = 4 as a waiting semaphore, the task switching circuit 210 decrements the semaphore counter of the waiting semaphore. The semaphore counter is decremented each time an acquisition request is made by a wait semaphore event call. A task that has executed a wait semaphore system call with a semaphore whose semaphore counter is 0 as a standby semaphore makes a transition to the WAIT state.

On the other hand, when any task executes a release semaphore system call with the semaphore with semaphore ID = 4 as a release semaphore, the task switching circuit 210 increments the semaphore counter in the semaphore table 212. Summary,
When semaphore counter> 0: The task that executed the wait semaphore system call transits from RUN to READY. At this time, the semaphore counter is decremented.
When semaphore counter = 0: The task that executed the wait semaphore system call transits from RUN to WAIT. The semaphore counter is not decremented.
In order for the task that executed the wait semaphore system call to transition from the WAIT state to the READY state, another task needs to execute the release semaphore system call.
[1] Semaphore processing by general software RTOS

A general software RTOS manages a TCB of a task in a WAIT state because of waiting for a semaphore (hereinafter, particularly referred to as “semaphore waiting task”) using a wait semaphore list. The wait semaphore list is a list having the same shape as the task ready list of FIG. 11, and is formed on the memory. The TCB of each semaphore waiting task is linked by a pointer. The priority order pointer 280 indicates the head address of the TCB of the semaphore waiting task having the corresponding task priority order.
When a general software RTOS executes a release semaphore system call, it scans this wait semaphore list and selects a semaphore waiting task to be changed from the WAIT state to the READY state. The RTOS processing at the time of executing the wait semaphore system call and the release semaphore system call is as follows.
<Execution of wait semaphore system call>

Here, RUN-task is described as task J.
A1. The RTOS holds the task ID of the RUN-task in the memory. Based on this task ID, the TCB address of task J is acquired.
A2. The semaphore counter of the waiting semaphore specified in the wait semaphore system call is detected. Hereinafter, the process branches according to the value of the semaphore counter.
(When semaphore counter> 0)
A3. The RTOS decrements the semaphore counter of the standby semaphore.
A4. “READY” is set in the TCB of task J. In this case, the TCB of task J is added to the task ready list.
(When semaphore counter = 0)
A3. Access TCB and obtain task priority of task J. It is assumed that the task priority is “0”.
A4. A priority pointer corresponding to the task priority of task J is acquired from the wait semaphore list.
A5. The TCB indicated by the acquired priority order pointer is detected. Here, the TCB of task A is detected.
A6. Traces the pointer of the task A TCB and detects the last TCB. In the figure, task F is the last.
A7: The task F TCB pointer is set to address the task J TCB. Thus, the TCB of task J is added to the wait semaphore list.
A8. “WAIT” is set in the TCB of task J. A semaphore ID of the standby semaphore is also set.
<Execution of release semaphore system call>

B1. The RTOS searches for a semaphore waiting task with the release semaphore as a waiting semaphore while following the tasks with the task priority “0” in order. If not, the task with the task priority “1” is set as a search target. Processing branches depending on whether or not a semaphore waiting task whose release semaphore is a waiting semaphore is detected.
(When detected)
B2. A description will be given assuming that the detected task is task E. “READY” is set in the TCB of task E. Also, the semaphore ID of the standby semaphore is cleared.
B3. The task E TCB is removed from the wait semaphore list.
B4. The state of the task that has released the semaphore is changed from RUN to READY. The TCB for this task is added to the task ready list.
(When not detected)
B2. Increment the semaphore counter.
B3. The state of the task that has released the semaphore is changed from RUN to READY. The TCB for this task is added to the task ready list.

A general software RTOS performs semaphore-related processing by managing such a wait semaphore list. When releasing a semaphore, the policy for RTOS to select a READY-task from a plurality of WAIT-tasks is as follows.
1. WAIT-task (first condition).
2. Of the WAIT-tasks, the task must be a release semaphore as a standby semaphore (second condition)
3. When there are a plurality of such tasks, the task has the highest task priority (third condition).
4). When there are a plurality of tasks having the highest task priority, the task that has entered the WAIT state is the oldest task (fourth condition).
These four conditions are collectively referred to as “semaphore standby release conditions”. The semaphore selection circuit 234 of the task processing device 100 realizes such a task scheduling function of RTOS by hardware.
[2] Semaphore processing by hardware RTOS in basic example

FIG. 14 is a circuit diagram of the semaphore selection circuit 234.
Here, description will be made on the premise of eight tasks of task 0 to task 7. The semaphore selection circuit 234 includes four first comparison circuits 300 (300a to 300d), two second comparison circuits 302 (302a and 302b), and one third comparison circuit 304. Also, eight determination circuits 306 (306a to 306h) are included.
The determination circuit 306 is a circuit that receives the ST, WR, and SID signals from the state storage unit 220 and the signal indicating the semaphore ID from the task switching circuit 210 as inputs. The semaphore ID input here is the semaphore ID of the released semaphore. The determination circuit 306 outputs a CID signal indicating “1” if the task is a semaphore waiting task having the released semaphore as a standby semaphore, and “0” otherwise. The determination circuit 306 is a circuit that outputs a determination result regarding the first condition and the second condition among the semaphore standby cancellation conditions. The first comparison circuit 300 receives the IDs of the two tasks, PR, TIM, and the CID signal from the determination circuit 306 as inputs.

The first comparison circuit 300 is a circuit that performs determination on the third condition and the fourth condition among the semaphore standby cancellation conditions. The same applies to the second comparison circuit 302 and the third comparison circuit 304. As is apparent, the second condition and the third condition of the RUN task selection condition are the same as the third condition and the fourth condition of the semaphore standby cancellation condition. Each comparison circuit of the execution selection circuit 232 is a circuit that compares task state data (PR, TIM). On the other hand, each comparison circuit of the semaphore selection circuit 234 is also a circuit that compares task status data (PR, TIM). Therefore, the first comparison circuit 290 of the execution selection circuit 232 and the first comparison circuit 300 of the semaphore selection circuit 234 are circuits that incorporate the same logic and can be shared. Each task is subjected to the determination process of the first comparison circuit 300 after the determination circuit 306 determines the first condition and the second condition. After that, one of the task IDs is output from the third comparison circuit 304 by a determination process equivalent to the execution selection circuit 232. Processing when a wait semaphore system call and a release semaphore system call are executed is as follows.
<Execution of wait semaphore system call>

Here, RUN-task is described as task J.
A1. The task switching circuit 210 detects the semaphore counter of the semaphore specified in the wait semaphore system call from the semaphore table 212. Hereinafter, the process branches according to the value of the semaphore counter.
(When semaphore counter> 0)
A2. The task switching circuit 210 decrements the semaphore counter of the semaphore table 212.
A3. “READY” is set in the task status register 258 of the task J. At this time, the task switching circuit 210 sets the RUN-task timer 252 and starts measuring the READY elapsed time.
(When semaphore counter = 0)
A2. The task switching circuit 210 sets “WAIT” in the task status register 258 of the task J, “waits for semaphore” in the waiting reason register 262, sets the semaphore ID of the waiting semaphore in the semaphore ID register 264, sets the timer 252 and waits for WAIT Start measuring time.
In this way, the task that executed the wait semaphore system call makes a state transition from RUN to READY or WAIT.
<Execution of release semaphore system call>

B1. The task switching circuit 210 inputs the semaphore ID of the released semaphore to each determination circuit 306. Each determination circuit 306 determines the success or failure of the first condition and the second condition of the semaphore standby cancellation conditions for this semaphore ID. Accordingly, each first comparison circuit 300 selects a task based on the third condition and the fourth condition.
(When any determination circuit 306 outputs “1” and the third comparison circuit 304 outputs any task ID)
B2. “READY” is set in the task status register 258 of the detected task, the waiting reason register 262 and the semaphore ID register 264 are cleared, and the timer 252 is made to measure the READY elapsed time.
B3. The task status register 258 of the task that executed the system call is set to “READY”, and measurement of the READY elapsed time is started.
(None of the determination circuits 306 outputs “1”, and the third comparison circuit 304 does not output any task ID)
B2. The task switching circuit 210 increments the semaphore counter of the semaphore table 212.
B3. The state of the task that executed the system call is changed from RUN to READY.

Since the state storage unit 220 always outputs the state data to the semaphore selection circuit 234, when the task switching circuit 210 inputs the semaphore ID to the determination circuit 306, the semaphore selection circuit 234 can immediately execute the selection process.
[Mutex processing]

Mutexes, like semaphores, are also used for synchronization between tasks. Mutexes and semaphores differ in the following respects.
1. The semaphore counter can set an integer of 1 or more. In contrast, a mutex is a special semaphore with a semaphore counter of 1 or 0. When the semaphore counter is 2 or more, two or more tasks can acquire the same semaphore. However, in the case of a mutex, there can always be only one task that can acquire a mutex.
2. A task that can release a semaphore by a release semaphore system call is not limited to a task that has acquired a semaphore by a wait semaphore system call. On the other hand, the task that can release the mutex by the release mutex system call is only the task that has acquired the mutex by the wait mutex system call.

The policy for selecting a READY-task from a plurality of WAIT-tasks when releasing a mutex is as follows.
1. WAIT-task (first condition).
2. Among WAIT-tasks, the task must have a release mutex as a waiting mutex (second condition)
3. When there are a plurality of such tasks, the task has the highest task priority (third condition).
4). When there are a plurality of tasks having the highest task priority, the task that has entered the WAIT state is the oldest task (fourth condition).
These four conditions are collectively referred to as “mutex standby release conditions”.

Accordingly, the processing of the hardware RTOS of the basic example when executing the wait mutex system call and the release mutex system call is as follows. The semaphore table 212 holds a mutex ID and occupation state data indicating whether or not the mutex is occupied by any task. The occupation state data is “0” when not occupied, and becomes the task ID of the task occupying the mutex when occupied.
<Execution of wait mutex system call>

Here, RUN-task is described as task J.
A1. The task switching circuit 210 detects whether the mutex designated in the wait mutex system call is occupied. Hereinafter, the process branches depending on the occupation state of the mutex.
(When the mutex is not occupied)
A2. The task switching circuit 210 records the task ID of the task that executed the system call as the mutex occupation data.
A3. “READY” is set in the task status register 258 of the task J. At this time, the task switching circuit 210 sets the RUN-task timer 252 and starts measuring the READY elapsed time.
(When mutex is occupied)
A2. The task switching circuit 210 sets “WAIT” in the task status register 258 of task J, “waiting for mutex” in the waiting reason register 262, sets the mutex ID of the waiting mutex in the mutex ID register 265, sets the timer 252, and waits for WAIT. Start measuring time.
<Execution of release mutex system call>

B1. The task switching circuit 210 inputs the release semaphore ID to the mutex circuit 240 on the condition that the task that executed the system call occupies the release mutex. The mutex circuit 240 also includes a comparison circuit that is connected in multiple stages as in FIG. 14 and a determination circuit that determines whether the first condition and the second condition of the mutex standby cancellation conditions are successful. This determination circuit outputs “1” only when both the first condition and the second condition of the mutex standby conditions are satisfied for this mutex. When a task that does not occupy the release mutex executes a release mutex system call, the task state is changed from RUN to READY.
(When any judgment circuit outputs "1" and any task ID is output from the mutex circuit 240)
B2. “READY” is set in the task status register 258 of the detected task, the waiting reason register 262 and the mutex ID register 265 are cleared, and the timer 252 is made to measure the READY elapsed time.
B3. The task status register 258 of the task that executed the system call is set to “READY”, and measurement of the READY elapsed time is started.
(None of the determination circuits outputs “1” and the mutex circuit 240 does not output any task ID)
B2. In the semaphore table 212, the task switching circuit 210 sets the mutex to an unoccupied state.
B3. The state of the task that executed the system call is changed from RUN to READY.
[Event processing]

The event management in the basic example will be briefly described. In the event table 214, an event ID is recorded in association with a flag pattern (hereinafter referred to as “current flag pattern”). The flag pattern is an 8-bit bit pattern.
The set event system call is a system call for setting and changing the current flag pattern, and uses an event ID and a flag pattern (hereinafter referred to as “set flag pattern”) as parameters. When the set event system call is executed, the current flag pattern is changed to a logical sum with the set flag pattern for the corresponding event. For example, when the current flag pattern is “00001100” and the set flag pattern is “00000101”, the current flag pattern is “00001011”. Hereinafter, each flag pattern is referred to as 0th bit, 1st bit,..., 7th bit from the left.

The wait event system call is a system call for waiting for the current flag pattern of the standby event to satisfy a predetermined condition, and uses an event ID, a flag pattern (hereinafter referred to as “standby flag pattern”), and a flag condition as parameters. . When the wait event system call is executed, it is determined whether a flag condition is satisfied between the current flag pattern and the standby flag pattern. The flag condition is logical sum (OR) or logical product (AND). When the flag condition is AND (AND), the WAIT cancellation condition is that all the corresponding bits of the current flag pattern are “1” for all the bits that are “1” in the standby flag pattern. When the flag condition is logical sum (OR), the WAIT cancellation condition is that the corresponding bit of the current flag pattern is “1” for any bit that is “1” in the standby flag pattern. For example, in the case of the current flag pattern “00001011”, the standby flag pattern “00000011”, and the flag condition “logical sum (OR)”, the seventh bit of the current flag pattern among the sixth bit and the seventh bit of the standby flag pattern is In this case, the WAIT cancellation condition by the wait event system call is satisfied. On the other hand, when the flag condition is “logical product (AND)”, the sixth bit of the current flag pattern is “0”, so the WAIT cancellation condition is not satisfied.
[1] Event processing by general software RTOS

A general RTOS process at the time of executing the wait event system call and the set event system call is as follows. In general RTOS, an event table is held in a memory for event management. In this event table, not only the event ID and current flag pattern, but also the task ID, standby flag pattern, and flag condition of a task that is normally in the WAIT state with the event as a standby event (hereinafter referred to as “event waiting task”). Are associated and held.
<Execution of wait event system call>

A1. The RTOS reads the current flag pattern of the event specified by the system call from the event table.
A2. The current flag pattern and the standby flag pattern are compared according to the flag condition to determine whether the WAIT cancellation condition is successful.
(When WAIT cancellation condition is satisfied)
A3. The task state of the task that executed the system call is changed from RUN to READY.
(When WAIT cancellation condition is not satisfied)
A3. The task ID of the task that executed the system call is recorded in the event table.
A4. Record the wait flag pattern in the event table.
A5. Record the flag condition in the event table.
A6. The task state of the task that executed the system call is changed from RUN to WAIT.
<Execution of set event system call>

B1. The RTOS reads the current flag pattern, task ID, standby flag pattern, and flag condition from the event table for the set event specified by the system call.
B2. The logical sum of the current flag pattern and the set flag pattern is recorded as a new current flag pattern.
(When there is no event-waiting task for the set event, or even if it exists, the WAIT cancellation condition is not satisfied from the wait flag pattern and flag condition)
B3. The task state of the task that executed the system call is changed from RUN to READY.
(When there is an event waiting task for the set event and the WAIT cancellation condition is met)
B3. The task state of the task waiting for the event is changed from WAIT to READY.
B4. The standby task ID, standby flag pattern, and flag condition in the event table are cleared.
B5. The task state of the task that executed the system call is changed from RUN to READY. In addition, a RUN-task is selected.

When a set event system call is executed, a policy for selecting a READY-task from a plurality of WAIT-tasks is as follows.
1. WAIT-task (first condition).
2. Of the WAIT-tasks, the task must be a set event as a standby event (second condition).
3. The task must satisfy the WAIT cancellation condition by comparing the standby flag pattern, current flag pattern, and flag conditions (third condition)
These three conditions are collectively referred to as “event standby release conditions”.
[2] Event processing by hardware RTOS of basic example

Processing when the task processing apparatus 100 executes the wait event system call and the set event system call is as follows. In the event table 214 built in the task processing apparatus 100, an event ID and a current flag pattern are associated with each other. Information such as a standby task ID and a standby flag pattern is stored in the state storage unit 220.
<Execution of wait event system call>

A1. The task switching circuit 210 reads the current flag pattern from the event table 214.
A2. The task switching circuit 210 compares the current flag pattern with the standby flag pattern according to the flag condition, and determines whether the WAIT cancellation condition is met.
(When WAIT cancellation condition is satisfied)
A3. “READY” is set in the task status register 258 of the task that executed the system call.
(When WAIT cancellation condition is not satisfied)
A3. The task switching circuit 210 “WAIT” in the task status register 258 of the task that executed the system call, “waiting for event” in the wait reason register 262, event ID of the standby event in the event ID register 266, and standby flag in the standby flag register 268. Flag conditions are set in the pattern and flag condition register 270, respectively.
<Execution of set event system call>

B1. The task switching circuit 210 reads the current flag pattern from the event table 214 and inputs the event ID of the set event designated by the system call to the event selection circuit 236.
B2. The task switching circuit 210 logically adds the set flag pattern to the current flag pattern of the event table 214.
B3. The event selection circuit 236 selects a task that satisfies the event standby condition for the input event ID. At this time, a plurality of tasks may be selected regardless of the task priority order and the WAIT elapsed time.
(When there is a task that satisfies the event waiting cancellation condition)
B4. “READY” is set in the task status register 258 of the event waiting task, and the event ID register 266, the standby flag register 268, and the flag condition register 270 are cleared.
B5. The task state of the task that executed the system call is changed from RUN to READY.
(When there is no task that satisfies the event wait cancellation condition)
B4. The task state of the task that executed the system call is changed from RUN to READY.
[Timeout processing]

A task that has transitioned to the WAIT state transitions to the READY state when the WAIT cancellation condition is satisfied. However, if the establishment of the WAIT cancellation condition is hindered due to some external factor or a bug in the application program, the task cannot escape from the WAIT state. Therefore, normally, a timeout value is set when the task is shifted to the WAIT state. The timeout value is decremented periodically, and when it becomes zero, the task transitions from the WAIT state to the READY state even if the WAIT cancellation condition is not satisfied. That is, the task is prevented from stopping in the WAIT state for a time longer than the timeout value.
[1] Time-out processing by general software RTOS

In the case of a general RTOS by software, a timeout value is set in the TCB of a task in a WAIT state, and this timeout value is periodically decremented. The RTOS periodically interrupts the processing of the CPU, checks all TCBs, and detects a WAIT-task whose timeout value has reached zero. When such a task is detected, the RTOS changes the task state of the task from WAIT to READY.
[2] Time-out process by hardware RTOS of basic example

  On the other hand, in the basic example, the task switching circuit 210 periodically decrements the timeout value of each timeout counter 274. The timeout value is set as a parameter when the WAIT system call is executed, and the task switching circuit 210 sets the timeout value in the timeout counter 274 of the task that executed the system call.

  Since the CPU 150 is not involved in the timeout value decrement process, the task switching circuit 210 can update the timeout value independently of the task execution process. For this reason, the task control circuit 200 autonomously updates the timeout value while the CPU 150 is executing a task. Since the status data is always input to the timeout detection circuit 238, the timeout detection circuit 238 can detect a task whose timeout count value has become zero at almost the same timing as when the timeout count value is updated. The timeout detection circuit 238 outputs the task ID of such a task. When the task switching circuit 210 receives the task ID from the timeout detection circuit 238, the task switching circuit 210 recognizes that a timeout has occurred, and asserts HC to stop supplying the CPU clock. The task control circuit 200 causes the WAIT-task in which a timeout has occurred to transition to the READY state, and causes the RUN-task to transition to the READY state. The task switching circuit 210 selects a task to be executed next from among the READY-tasks. In addition, the task switching circuit 210 restarts the timer 252 of the task that has timed out, and measures the READY elapsed time.

According to such a processing method, when a timeout occurs during the execution of a task, that is, during the operation of the CPU clock, it is possible to immediately interrupt the CPU 150 and execute the task switch. Further, during the execution of the task, the task switching circuit 210 can execute the timeout value update process independently without borrowing the processing capability of the CPU 150.
[Task switching circuit 210 as a finite state machine]

FIG. 15 is a state transition diagram of the task switching circuit 210.
In the initialization process (A1), all tasks are in the IDLE state. When the initialization process is completed (S10), one of the tasks becomes a RUN-task and enters the task execution state (A2). When an interrupt request signal is detected (S12), the special task becomes a RUN-task, and interrupt processing (A3) is executed. When the interrupt process ends (S14), the task switching circuit 210 selects a RUN-task from the general tasks, and transitions to A2.

When a system call is executed during task execution (A2) (S16), system call processing is executed (A4). If task switching, that is, RUN-task switching does not occur (S18), the process returns to A2. On the other hand, when a task switch occurs due to the system call process (A4) (S20), the task switching circuit 210 selects a RUN-task based on the output of the execution selection circuit 232 (A5). When the task switch is completed (S22), the processing state shifts to A2.
In relation to the basic example, a case where only one of the save circuit 120 and the task control circuit 200 which are main elements of the task processing device 100 is mounted will be additionally described.
[A task processing apparatus 100 of a type that does not include the task control circuit 200]

FIG. 16 is a circuit diagram of the task processing apparatus 100 that does not include the task control circuit 200 in the task processing apparatus 100 of FIG.
Instead of mounting the task control circuit 200, a register switching control circuit 322 and a processing data holding unit 320 are added. Since the task control circuit 200 is not installed, the task scheduling function is realized by software RTOS. Therefore, it becomes necessary for the RTOS to temporarily acquire the right to use the CPU 150 at the time of task switching. The processing data holding unit 320 normally holds processing data for RTOS. When the RTOS acquires the right to use the CPU 150, the processing data holding unit 320 replaces the processing data for RTOS in the processing data holding unit 320 with the processing data for tasks in the special register 156. In the following, the processing process will be described on the assumption that task switching is performed from task A to task B.

A1. When the task A executes a system call, the system call variable and the system call ID are recorded in a part of the general-purpose register 158.
A2. The register switching control circuit 322 moves the processing data of task A to the processing data holding unit 320 and loads the RTOS processing data of the processing data holding unit 320 into the processing register 154. At this stage, the RTOS acquires the right to use the CPU 150.
A3. The register switching control circuit 322 inputs a write signal to the save register 110 a and saves the task A process data in the process data holding unit 320 to the save register 110.
A4. The RTOS executes processing corresponding to the system call based on the system call variable and ID recorded in the general-purpose register 158. Also, the task status data of the task A TCB is set to “READY”, and the task A TCB is added to the task ready list.

B1. Next, the RTOS selects a RUN-task, in this case, task B, according to the RUN task selection condition described above.
B2. The RTOS instructs the register switching control circuit 322 to input a task selection signal designating task B to the load selection circuit 112. The processing data is moved from the save register 110b to the processing data holding unit 320.
B3. The register switching control circuit 322 switches the task B processing data in the processing data holding unit 320 and the RTOS processing data in the processing register 154. As a result, the task B acquires the right to use the CPU 150.

According to such a processing method, the circuit size of the task processing device 100 as a whole can be made compact compared to the task processing device 100 of FIG. Although the RTOS is realized as software, loading and saving of processing data can be controlled by hardware by a signal from the register switching control circuit 322. If the bus connecting the processing register 154, the processing data holding unit 320, the load selection circuit 112, and the save register 110 is set to the number of bits that can be transferred in parallel, the processing data can be saved to the TCB or processed from the TCB. Task switching can be performed faster than loading of
[A task processing device 100 of a type that does not include the save circuit 120]

FIG. 17 is a circuit diagram of the task processing apparatus 100 in which the save circuit 120 is not mounted in the task processing apparatus 100 of FIG.
Instead of mounting the save circuit 120, an interrupt interface circuit 324 is added. Since the save circuit 120 is not installed, the processing data is saved in the TCB of the memory. Processing data saving / loading is realized by a software-based RTOS. Therefore, it becomes necessary for the RTOS to temporarily acquire the right to use the CPU 150 at the time of task switching. In the following, the processing process will be described on the assumption that task switching is performed from task A to task B.

  When a task switch occurs due to the execution of a system call, first, the software RTOS saves the processing data of task A in the TCB of task A. Then, the processing data for RTOS is loaded into the processing register 154. The processing method at this time is equivalent to the content described in relation to FIG.

  The software RTOS writes the system call parameters in the interrupt interface circuit 324. The execution control circuit 152 stops the CPU clock of the CPU 150. The interrupt interface circuit 324 causes the task control circuit 200 to execute a task switch. The task switching circuit 210 first sets the task status register 258 of the task A to READY, and selects the task B that is the next RUN-task based on the output from the task selection circuit 230. The task switching circuit 210 instructs the interrupt interface circuit 324 to load task B processing data. Here, the interrupt interface circuit 324 causes the execution control circuit 152 to restart the CPU clock. The interrupt interface circuit 324 notifies the software RTOS that the task B has been selected. The software RTOS accesses the TCB of task B and loads the processing data of task B into the processing register 154.

  Even with such a processing method, the circuit size of the task processing device 100 as a whole can be made compact compared to the task processing device 100 of FIG. Some of the functions of the RTOS are realized as software, but the task selection process can be realized by the task control circuit 200.

  Compared to the software RTOS described with reference to FIGS. 2 and 3, the task processing device 100 of FIGS. 16 and 17 can implement some of the functions of the RTOS as hardware. As described with reference to FIG. 16, the existence of the save circuit 120 eliminates the need to access the TCB for saving / loading the processing data. Therefore, the register switching control circuit 322 can execute processing data save / load processing. As described with reference to FIG. 17, the presence of the task control circuit 200 allows the software RTOS to delegate the task selection function to the task control circuit 200.

As described with reference to FIG. 5, in the case of the task processing device 100 including the save circuit 120 and the task control circuit 200, the RTOS task scheduling function can be completely implemented in hardware. Since there is no need to access the memory TCB at the time of task switching, the task switching process is further accelerated. According to the experiments by the present inventors, it has been confirmed that the task processing apparatus 100 in the basic example operates at a speed about 100 times that of the general software RTOS described with reference to FIG.
{Improved Example 1}

  In creating a computer program, “Queue” is a standard and frequently used algorithm. For this reason, speeding up the queue processing tends to contribute to an improvement in the processing speed of the computer program. However, even in the case of a FIFO (First-In First-Out) queue, there are cases where it is desired to operate in a LIFO (Last-In Last-Out) manner. Alternatively, there is a case where it is desired to operate in a FIFO manner based on the LIFO. In the improvement example 1, a task processing apparatus 100 that implements a hardware of a special queue algorithm (hereinafter referred to as “double-throw queue algorithm”) that can also handle LIFO will be described.

  The task processing apparatus 100 of the basic example has a task scheduling function based on timer management. The basic example task scheduling is an algorithm that “assigns an execution right preferentially to a task having a long waiting time as long as the task priorities are the same”. Hereinafter, such task scheduling is referred to as “fair type task scheduling”.

  In FIG. 11 as well, the task ready list management method has been described based on the concept of fair task scheduling. When task J, which is a RUN-task, returns to the READY state, it is linked after the last task F. Since task A becomes a RUN-task next to task J, the TCB of each task is displayed in the order of task D,..., Task F, task J in the priority pointer 280 with task priority “0”. Will be linked. The task J is not given the execution right until at least the execution of the task F is completed. The processing method in fair task scheduling is similar to the FIFO, ie, queue algorithm. Since the algorithm is familiar to time management, fair task scheduling can be implemented in hardware by timer management.

On the other hand, in the software OS, task scheduling of “assigning an execution right preferentially to a task once a RUN-task as long as the task priority is the same” is often adopted. Hereinafter, such task scheduling is referred to as “re-execution priority type task scheduling”. In the re-execution priority type task scheduling, when the task J, which is a RUN-task, returns to the READY state, it is inserted at the head instead of the tail. Since task A becomes a RUN-task next to task J, the TCB of each task is displayed in the order of task J, task D,... Will be linked. When the task A is completed, the task J is reassigned the execution right before the task D and the task F. Once the execution right is given, the re-execution priority type task scheduling is effective when there are types of tasks that should be executed together as much as possible. It can be said that the re-execution priority type task scheduling includes a LIFO, that is, a stack-like algorithm. In the improved example 1, the re-execution priority type task scheduling is realized by the hardware implementation of the double-throw type queue algorithm that can support the LIFO while being based on the FIFO.
Note that not only the re-execution priority type task scheduling but also the double-input type queue algorithm is useful in general application programs. For this reason, the hardware implementation of the double-throw queue algorithm is effective in improving the processing speed of various computer programs.

FIG. 18 is a circuit diagram of the task processing device 100 in the first modification.
The task processing device 100 according to the improved example 1 also includes a save circuit 120 and a task control circuit 200 in addition to the CPU 150. However, the task switching circuit 210 in the first modification includes a main circuit 400, a writing circuit 402, a queue control circuit 404, and a maximum value selection circuit 406. The main circuit 400 is a circuit having substantially the same function as the task switching circuit 210 in the basic example. For this reason, the task switching circuit 210 in the improved example 1 has a configuration in which a writing circuit 402, a queue control circuit 404, and a maximum value selection circuit 406 are added to the main circuit 400 as the task switching circuit 210 in the basic example. All state data of all tasks is constantly output from each state storage unit 220 not only to the task selection circuit 230 but also to the maximum value selection circuit 406 and the queue control circuit 404.

FIG. 19 is a partial circuit diagram of the task control circuit 200 in the first modification.
The basic configuration of the task control circuit 200 is almost the same as the circuit configuration shown in FIG. The status register 250 associated with each task includes a task ID register 410, a task priority register 412, a queue order register 414, and a queue identification register 416. The status register 250 may include other registers, but here, a description will be given focusing on a register group related to the double-throw queue algorithm.
(A) Task ID register 410: Holds a task ID. This is equivalent to the task ID register 254 shown in the basic example. The task ID register 410 constantly outputs an EID_S signal indicating the task ID.
(B) Task priority order register 412: Holds task priority order (PR). This is the same as the task priority order register 256 shown in the basic example. Always output as a PR_S signal.
(C) Queue order register 414: Holds an “order value (ODR)” indicating the order of entry into a virtual queue to be described later. The larger the order value, the deeper the virtual queue is, which will be described later in detail. The order value is always output as an ODR_S signal.
(D) Queue identification register 416: Holds a “queue ID (QID)” for identifying a virtual queue. Always output as the QID_S signal.
The task priority order register 412, the queue order register 414, and the queue identification register 416 function as queue registers for managing virtual queues in particular.

  A virtual queue is a queue associated with a task state. For example, the virtual queue with QID = 0 (hereinafter referred to as “virtual queue (0)”) is associated with the READY state, the virtual queue (1) is associated with the semaphore wait state, and the virtual queue (2) is associated with the mutex wait state. May be. Alternatively, the virtual queue (1) may be associated with the semaphore waiting state for semaphore ID = 0, and the virtual queue (2) may be associated with the semaphore waiting state for semaphore ID = 1. The association between the QID and the task state may be arbitrarily set by software.

  When the task A is in the READY state, the QID of the virtual queue associated with the READY state is set in the queue identification register 416_A. The task selection circuit 230 and the queue control circuit 404 can determine the task state of each task by referring to each queue identification register 416. Therefore, the queue identification register 416 can function in the same way as the task status register 258, the waiting reason register 262, the semaphore ID register 264, the mutex ID register 265, the event ID register 266, etc. in the basic example.

It is important that the virtual queue does not physically exist but is a conceptual queue assumed by the setting contents of the queue order register 414 and the queue identification register 416. For example, in each queue identification register 416 and queue order register 414,
Task A: QID = 0, ODR = 0
Task B: QID = 0, ODR = 1
Task C: QID = 0, ODR = 2
Task D: QID = 1, ODR = 0
Is set in the virtual queue (0) in the order of tasks C, B, and A, and only the task D is input in the virtual queue (1). The number and size of virtual queues can be flexibly changed according to the numerical range of QID and ODR.

  The task selection circuit 230 selects a task whose state is to be changed based on the state data output from the state register 250. The main circuit 400 inputs the CND signal to the task selection circuit 230. CND is a signal indicating a task selection condition, and includes QID_C indicating a queue ID and PR_C indicating a task priority. For example, when it is desired to extract a task from the virtual queue (0), the main circuit 400 sets QID_C = 0 in CND. The task selection circuit 230 outputs a task ID of a task to be extracted in the designated virtual queue (0) (hereinafter simply referred to as “extraction task”) to EID_A1, and asserts EID_A1_EN. In addition, the task priority order and the order value of the extracted task are output to PR_A1 and ODR_A1. As described above, the main circuit 400 can know the extraction task of the virtual queue (Qn) by inquiring of the task selection circuit 230 by designating QID_C = Qn. The task selection circuit 230 functions as an extraction candidate circuit that selects an extraction task. More details will be described later with reference to FIG.

  The maximum value selection circuit 406 receives a CND signal from the main circuit 400. When QID_C = Qn is specified by CND, the maximum value selection circuit 406 outputs the maximum order value in the virtual queue (Qn) to ODR_A2, and asserts EID_A2_EN. More details will be described later with reference to FIG.

  The queue control circuit 404 controls the state transition of each task by setting the state data in each state register 250. The CMD and EID_C are input from the main circuit 400 to the queue control circuit 404. In addition, CND (QID_C, PR_C), ODR_A1, ODR_A2, ODR_A2_EN, and status data of each status register 250 are input.

  CMD indicates a command for operating the virtual queue. The queue ID of the virtual queue subject to CMD, the task ID of the task, and the task priority are designated by QID_C, EID_C, and PR_C, respectively. The command is one of three types of ENQ_TL, ENQ_TP, and DEQ.

  When the sequential input command ENQ_TL is input, the task specified by the EID_C signal is input from the tail of the virtual queue. Hereinafter, input from the tail of the queue is referred to as “ordered input”. When the extraction command DEQ is input, a task is taken out from the head of the virtual queue. The queue control as a FIFO is executed by ENQ_TL and DEQ. When the reverse input command ENQ_TP is input, the task specified by the EID_C signal is input from the head of the virtual queue. Hereinafter, the input from the head of such a queue is referred to as “reverse input”. Reverse injection is a special input method in that it is not input as a FIFO.

When CMD is input from the main circuit 400, the write circuit 402 asserts WT, and writing of each data output from the queue control circuit 404 to the status register 250 is executed. The queue control circuit 404, the write circuit 402, the task selection circuit 230, the maximum value selection circuit 406, and the like function as a virtual queue processing circuit for controlling the virtual queue.
The circuit configuration of the queue control circuit 404 will be described in detail with reference to FIG.

FIG. 20 is a circuit diagram of the queue control circuit 404.
The queue control circuit 404 is an aggregate of a plurality of register value generation circuits 420. Each register value generation circuit 420 is the same circuit. The register value generation circuit 420 is associated with each task. It can be said that each status register 250 is associated with each other. The register value generation circuit 420_En is associated with a task with task ID = En (hereinafter referred to as “task (En)”). The task ID of the corresponding task is fixedly input to the register value generation circuit 420 as an ELM_ID signal.

ODR_S, QID_S, and PR_S are status data output from the status register 250, and indicate an order value, a queue ID, and a task priority, respectively. The register value generation circuit 420_En associated with the task (En) receives the order value, queue ID, and task priority of the task (En) as ODR_S_En, QID_S_En, and PR_S_En, respectively. CMD and EID_C are input from the main circuit 400. ODR_A2_EN and ODR_A2 are input from the maximum value selection circuit 406. ODR_A2 indicating the maximum order value becomes a valid input when ODR_A2_EN is asserted. ODR_A1 is input from the task selection circuit 230. ODR_A1 indicates the task ID of the extraction task. QID_C and PR_C are CND signals input from the main circuit 400, and indicate QID and PR as task selection conditions, respectively.
The register value generation circuit 420_En outputs the task (En) order value, queue ID, and task priority as QID_N_En, ODR_N_En, and PR_N_En, respectively, and is written in the state register 250_En when the write circuit 402 asserts WT. .
When the write circuit 402 asserts WT, QID_N_En, ODR_N_En, and PR_N_En of all the register value generation circuits 420 are written to all the status registers 250. The register value generation circuit 420 for the task affected by the CMD writes new data designated by an algorithm described later to the status register 250. On the other hand, the register value generation circuit 420 for the task not affected by the CMD also re-outputs the same data as the data written in the status register 250 and executes the writing.
Note that the WT of the register value generation circuit 420 may be directly input to the queue control circuit 404 instead of each status register 250. In this case, only the register value generation circuit 420 for a task whose state should be changed by CMD among the register value generation circuits 420 built in the queue control circuit 404 may write new data into the state register 250.
Specific processing contents of the register value generation circuit 420 will be described later.

FIG. 21 is a conceptual diagram showing the relationship between virtual queues and tasks.
Here, two virtual queues of a virtual queue (Q0) and a virtual queue (Q1) are assumed. In the virtual queue (Q0), a priority queue (hereinafter referred to as “priority queue (Q0: 0)”) into which tasks with task priority PR = 0 are input and a task with task priority PR = 1 are input. This is a set of two priority queues of priority queues (Q0: 1). The same applies to the virtual queue (Q1), and substantially four priority queues are assumed. For example, the virtual queue (Q0) may be associated with the READY state, and the virtual queue (Q1) may be associated with the WAIT state.

  Each virtual cue is a cue having an input port on the left and an extraction port on the right as viewed in FIG. Tasks are entered from the left side in the forward entry, and tasks are entered from the right side in the reverse entry. Tasks are always extracted from the right side.

  In the figure, four tasks with task ID = E0, E1, E2, E3 are put in the virtual queue. The task (E0), the task (E2), and the task (E3) are put in the virtual queue (Q0). Among these, the task (E0) and the task (E3) are tasks with the task priority order PR = 0, and are therefore placed in the priority queue (Q0: 0). Since the task (E2) is a task with PR = 1, it is put into the priority queue (Q0: 1). The order values ODR of the task (E3), the task (E2), and the task (E0) input to the virtual queue (Q0) are 2, 1, 0. The task (E1) having the task priority order PR = 0 is put in the virtual queue (Q1). The ODR is “0”.

FIG. 22 is a data structure diagram of the status register 250 corresponding to FIG.
The input status of each task to the virtual queue shown in FIG. 21 is expressed by the setting of the status register 250. In the state shown in FIG. 21, among tasks (E0) to (E7), tasks (E0) to (E3) are put in the virtual queue. Therefore, “Non” indicating non-input is set in the queue identification register 416 of other tasks. “Q0” is set in the queue identification register 416 of the task (E0), the task (E3), and the task (E2) input to the virtual queue (Q0). Further, “Q1” is set in the queue identification register 416 of the task (E1) to be put into the virtual queue (Q1). According to the setting contents of the queue identification register 416, which task is put in which virtual queue is expressed.

  In the queue order registers 414 of the three tasks (E0), task (E3), and task (E2) put in the virtual queue (Q0), 0, 2, and 1 are set as ODR, respectively. Since only the task (E1) is put in the virtual queue (Q1), the minimum order value is set to “0”. The position of each task in the virtual queue is expressed by the setting contents of the queue order register 414.

The task priority order PR of task (E0), task (E1), and task (E3) is “0”. Therefore, “0” is set in the task priority order register 412 of these tasks. Since the task priority order PR of the task (E2) is “1”, “1” is set in the task priority order register 412_E2. According to the setting of the task priority order register 412, which priority queue is assigned to each task is expressed.
Based on the above settings, the processing contents in the forward input, reverse input, and extraction will be described in detail.
[Sequential input]

FIG. 23 is a conceptual diagram when tasks (E4) are sequentially entered into the virtual queue of FIG.
Here, description will be made assuming that the task (E4) with the task priority order PR = 0 is sequentially placed in the virtual queue (Q1). The main circuit 400 sets EID_C = E4, QID_C = Q1, and PR_C = 0 as CMD = ENQ_TL (sequential input command). When register value generation circuit 420_E4 built in queue control circuit 404 detects EID_C = ELM_ID = E4, it outputs QID_N_E4 = QID_C = Q1, ODR_N_E4 = 0, and PR_N_E4 = PR_C = 0. QID_N_E4 is the QID of the virtual queue to which the task (E4) is input, ODR_N_E4 is the order value at the time of input, and PR_N_E4 is the task priority of the task (E4). ODR_N for tasks that are sequentially entered is always set to “0”. This is an order value indicating the latest input to the queue.

  Not only the register value generation circuit 420_E4 but also the register value generation circuit 420_En in which QID_S_En = QID_C = Q1 reacts. The register value generation circuit 420_En outputs ODR_N_En = ODR_S_En + 1. Here, the register value generation circuit 420_E1 detects QID_S_E1 = QID_C = Q1, and outputs ODR_N_E1 = 0 + 1 = 1. ODR_N_E1 is an order value after the task (E1) is input. The order value of the task that has already been submitted to the virtual queue (Q1) that is the destination of the task (E4) is affected. Through such a process, the state data of the task (E4) and the task (E1) which are elements of the virtual queue (Q1) are adjusted.

FIG. 24 is a data structure diagram of the status register 250 corresponding to FIG.
In FIG. 22, the underlined portion is a portion changed from the setting contents of the status register 250 shown in FIG. As the task (E4) enters the virtual queue (Q1) in order, “Q1” is set in the queue identification register 416_E4 by QID_N_E4. The ODR of task (E4) is “0”, and PR is “0”. As the tasks (E4) are sequentially input, the ODR of the task (E1) that has already been input to the virtual queue (Q1) is incremented from “0” to “1”. The state of the virtual queue (Q1) shown in FIG. 23 is expressed by the setting contents of the state register 250 after the change.

FIG. 25 is a conceptual diagram when the tasks (E5) are sequentially entered into the virtual queue of FIG.
Here, a description will be given assuming that the task (E5) with the task priority order PR = 1 is sequentially entered into the virtual queue (Q0). The main circuit 400 sets EID_C = E5, QID_C = Q0, and PR_C = 1 as CMD = ENQ_TL (order input command). The register value generation circuit 420_E5 outputs QID_N_E5 = QID_C = Q0, ODR_N_E5 = 0, and PR_N_E5 = PR_C = 1.

  Not only the register value generating circuit 420_E5 but also the register value generating circuit 420_En that satisfies QID_C = QID_S_En = Q0 outputs ODR_N_En = ODR_S_En + 1 when detecting QID_C = QID_S_En. In this example, the register value generation circuit 420 corresponding to the task (E0), the task (E2), and the task (E3) corresponds. Thus, the state data of the task (E5), the task (E0), the task (E2), and the task (E3) that are elements of the virtual queue (Q0) are adjusted.

FIG. 26 is a data structure diagram of the status register 250 corresponding to FIG.
In FIG. 24, the underlined portion is a portion changed from the setting contents of the status register 250 shown in FIG. First, “Q0” is newly set in the queue identification register 416_E5 by the sequential entry of the task (E5) into the virtual queue (Q0). The ODR of task (E5) is “0”, and PR is “1”. ODRs of the task (E0), task (E1), and task (E3) that were originally submitted to the virtual queue (Q0) are incremented by the sequential entry of the task (E5).

FIG. 27 is a flowchart showing the ordering process.
The main circuit 400 sets the input conditions for the tasks to be sequentially input (hereinafter referred to as “sequential input task”) (S10). Specifically, EID_C, QID_C, and PR_C are set as CMD = ENQ_TL. Of the queue control circuit 404, the register value generation circuit 420 corresponding to the sequential entry task sets PR_C, 0, and QID_C in the task priority order register 412, the queue order register 414, and the queue identification register 416 of the sequential entry task, respectively. (S12).

If another task has already been submitted to the virtual queue (QID_C) (Y in S14), the ODR is incremented for each task that has already been submitted (S16). In the case of the example shown in FIG. 25, the ODR is incremented for the task (E0), the task (E2), and the task (E3). The processes of S12, S14, and S16 are executed substantially in parallel in time.
[Reverse input]

FIG. 28 is a partial circuit diagram of the maximum value selection circuit 406.
The maximum value selection circuit 406 is a circuit driven by the main circuit 400 for reverse input processing. When QID_C = Qn is input as the CND signal, the maximum value selection circuit 406 outputs the maximum order value in the virtual queue (Qn) to ODR_A2, and asserts ODR_A2_EN. Similar to the execution selection circuit 232 and the semaphore selection circuit 234 shown in the basic example, the maximum value selection circuit 406 includes a plurality of comparison circuits. The maximum value selection circuit 406 includes four first comparison circuits 422 (422a, 422b, etc.), two second comparison circuits 424 (424a, etc.), and one third comparison circuit (not shown). In addition, eight determination circuits 426 (426a, 426b, 426c, 426d, etc.) are included.

Description will be made by paying attention to the first comparison circuit 422a. The first comparison circuit 422a compares the task 0 and the task 1, and if both are put in the virtual queue (Qn), the task having the larger order value is selected. The task IDs and order values of task 0 and task 1 are input to the first comparison circuit 422a as EID_S and ODR_S.
First determination: The determination circuit 426a asserts EID_11A_EN if the task 0 has been put into the virtual queue (Qn). The determination circuit 426b asserts EID_11B_EN if the task 1 has been put into the virtual queue (Qn). The first comparison circuit 422a first refers to the EID_11_EN signal output from each of the determination circuit 426a and the determination circuit 426b. If either one is “1”, only one of the tasks is put in the virtual queue (Qn). At this time, the first comparison circuit 422a outputs the task ID (EID_S) and the order value (ODR_S) of the task that is put in the virtual queue (Qn) as EID_21A and ODR_21A, respectively, and asserts EID_21A_EN.
When both the determination circuit 426a and the determination circuit 426b output “0”, neither task is put in the virtual queue (Qn). At this time, EID_21A_EN is negated, and thereafter neither task 0 nor task 1 is taken into consideration in the second comparison circuit 424a.
When both the determination circuit 426a and the determination circuit 426b output “1”, both tasks have been put into the virtual queue (Qn). At this time, the next second determination is executed.

  Second determination: ODR_S_0 of task 0 and ODR_S_1 of task 1 are compared, and the task with the larger order value is selected. The first comparison circuit 422a outputs the task ID (EID_S) and the order value (ODR_S) of the task having the larger order value as EID_21A and ODR_21A, respectively, and asserts EID_21A_EN.

The processing contents of the other first comparison circuits 422 are the same, and task 0 and task 1, task 2 and task 3, task 4 and task 5, and task 6 and task 7 are compared. The second comparison circuit 424 selects a task having a larger order value based on outputs from the two first comparison circuits 422. Description will be made by paying attention to the second comparison circuit 424a. The second comparison circuit 424a compares the output signal of the first comparison circuit 422a and the output signal of the first comparison circuit 422b, and selects the task having the larger order value. EID_21, ODR_21, and EID_EN are input to the second comparison circuit 424a from the first comparison circuit 422a and the first comparison circuit 422b, respectively. The second comparison circuit 424 selects a task having the largest order value in the virtual queue (Qn) among the tasks 0 to 3. The same applies to the other second comparison circuit 424. Finally, the maximum order value in the virtual queue (Qn) is output as the ODR_A2 signal. ODR_A2_EN is asserted when any task is selected, and ODR_A2_EN is negated when no task exists in the virtual queue (Qn).
Note that a PR invalid signal for invalidating the priority determination may be input to the first comparison circuit 422, the second comparison circuit 424, and the third comparison circuit. When the PR invalid signal is asserted, each comparison circuit selects a task by excluding priority from the determination conditions. The same applies to each comparison circuit shown in FIG.

FIG. 29 is a conceptual diagram when the task (E6) is put back into the virtual queue of FIG.
Here, description will be made assuming that the task (E6) with the task priority order PR = 1 is reversely input to the virtual queue (Q0). First, the main circuit 400 inputs the input destination QID = Q0 to the maximum value selection circuit 406 by the QID_C signal. The maximum value selection circuit 406 outputs the maximum order value of the virtual queue (Q0) to the queue control circuit 404 as ODR_A2, and asserts ODR_A2_EN. According to FIG. 25, since the maximum order value of the virtual queue (Q0) is “3” of the task (E3), ODR_A2 = 3.

  Next, the main circuit 400 sets EID_C = E6, QID_C = Q0, and PR_C = 1 as CMD = ENQ_TP (reverse input command). At this time, when the register value generation circuit 420_E6 built in the queue control circuit 404 detects EID_C = ELM_ID = E6, it outputs QID_N_E6 = QID_C = Q0, ODR_N_E6 = ODR_A2 + 1 = 3 + 1 = 4, and PR_N_E6 = PR_C = 1.

  When CMD = ENQ_TP (reverse input command), only the register value generation circuit 420 associated with the task specified by EID_C operates. For this reason, only the status data of the task (E6) to be reversely input is changed.

FIG. 30 is a data structure diagram of the status register 250 corresponding to FIG.
In FIG. 26, an underlined portion is a portion changed from the setting contents of the status register 250 shown in FIG. First, “Q0” is newly set in the queue identification register 416_E6 due to reverse input of the task (E6) to the virtual queue (Q0). The ODR of the task (E6) is “4”, and PR is “1”. The state data of other tasks are not affected by the reverse input of the task (E6).

FIG. 31 is a flowchart showing the reverse charging process.
First, the main circuit 400 inputs QID = Qn of the virtual queue to be reversely input into the maximum value selection circuit 406 (S20). The main circuit 400 outputs the maximum order value of the virtual queue (Qn) to the queue control circuit 404 (S22). The main circuit 400 sets the input condition for the task to be reverse input (hereinafter referred to as “reverse input task”) (S24). Specifically, EID_C, QID_C, and PR_C are set as CMD = ENQ_TP (reverse input command). Among the queue control circuits 404, the register value generation circuit 420 corresponding to the reverse input task includes the PR_C, the maximum order value + 1, and the QID_C in the task priority register 412, the queue order register 414, and the queue identification register 416 of the reverse input task, respectively. Is set (S26). However, when the maximum order value = 0 and ODR_A2_EN is negated, that is, when a task has not been submitted to the virtual queue (Qn), the queue order register 414 is given an order value “0” indicating the first submission. Set.

As described above, there is a possibility that the order value may be adjusted for other tasks at the time of sequential input, but such adjustment is not necessary at the time of reverse input. When a virtual queue is viewed on the premise of FIFO, a larger order value is set for a task input in the past. In other words, tasks placed deeper in the virtual queue have a higher order value. On the contrary, it may be set so that the order value becomes smaller as the task is inserted deeper in the virtual queue. In this case, it is not necessary to adjust the order value for other tasks at the time of sequential input, but there is a possibility that the adjustment of the order value for other tasks may occur at the time of reverse input.
[Extract]

FIG. 32 is a partial circuit diagram of the task selection circuit 230.
The basic configuration of the task selection circuit 230 is as described with reference to FIG. 12 as a basic example. When receiving a query from the main circuit 400, the task selection circuit 230 in the first improvement example specifies an extraction task. Here, a circuit configuration related to a mechanism for specifying this extraction task will be described. When QID_C = Qn is input as the CND signal, the task selection circuit 230 selects an extraction task from the priority queue having the highest task priority in the virtual queue (Qn), and extracts the task ID, task priority, and order of the extraction task The values are output to EID_A1, PR_A1, and ODR_A1, respectively, and EID_A1_EN is asserted. Similar to the execution selection circuit 232 and the semaphore selection circuit 234 shown in the basic example, the task selection circuit 230 includes a plurality of stages of comparison circuits. The task selection circuit 230 includes four first comparison circuits 430 (430a, 430b, etc.), two second comparison circuits 432 (432, etc.), and one third comparison circuit (not shown). Also, eight determination circuits 434 (434a, 434b, 434c, 434d, etc.) are included.

Description will be made by paying attention to the first comparison circuit 430a. The first comparison circuit 422a compares the task 0 and the task 1, and if both are put in the virtual queue (Qn), the task having the higher task priority is selected. If the task priorities are the same, the task with the larger order value is selected. The task IDs, task priorities, and order values of task 0 and task 1 are input to the first comparison circuit 430a as EID_S, PR_S, and ODR_S.
First determination: The determination circuit 434a asserts EID_11A_EN if the task 0 has been put into the virtual queue (Qn). The determination circuit 434b asserts EID_11B_EN if the task 1 has been put into the virtual queue (Qn). The first comparison circuit 430a first refers to the EID_11_EN signal output from each of the determination circuit 434a and the determination circuit 434b. If either one is “1”, only one of the tasks is put in the virtual queue (Qn). At this time, the first comparison circuit 430a sets the task ID (EID_S), task priority (PR_S), and order value (ODR_S) of the task put in the virtual queue (Qn) as EID_21A, PR_11A, and ODR_21A, respectively. Output and assert EID_21A_EN.
When both the determination circuit 434a and the determination circuit 434b output “0”, neither task is put in the virtual queue (Qn). At this time, EID_21A_EN is negated, and thereafter neither task 0 nor task 1 is taken into consideration in the second comparison circuit 432a.
When both the determination circuit 434a and the determination circuit 434b output “1”, both tasks have been put into the virtual queue (Qn). At this time, the next second determination is executed.

  Second determination: PR_S_0 of task 0 and PR_S_1 of task 1 are compared, and the task with the higher task priority, in other words, the task with the smaller PR_S is selected. The first comparison circuit 430a outputs the task ID (EID_S), task priority (PR_S), and order value (ODR_S) of the task with the higher task priority as EID_21A, PR_21A, and ODR_21A, and asserts EID_21A_EN. If the task priorities of the two tasks are the same, the next third determination is executed.

  Third determination: ODR_S_0 of task 0 and ODR_S_1 of task 1 are compared, and the task with the larger order value is selected. The first comparison circuit 430a outputs the task ID (EID_S), task priority (PR_S), and order value (ODR_S) of the task with the larger order value as EID_21A, PR_21A, and ODR_21A, respectively, and asserts EID_21A_EN.

  The processing contents of the other first comparison circuits 430 are the same, and task 0 and task 1, task 2 and task 3, task 4 and task 5, and task 6 and task 7 are compared. The second comparison circuit 432 further narrows down extraction task candidates based on the outputs from the two first comparison circuits 430. Finally, an extraction task is selected from the priority queue having the highest task priority in the virtual queue (Qn). EID_A1_EN is asserted when any task is selected, and EID_A1_EN is negated when no task exists in the virtual queue (Qn).

FIG. 33 is a conceptual diagram when the task (E3) is extracted from the virtual queue of FIG.
Here, it is assumed that one task is extracted from the virtual queue (Q0). The main circuit 400 inputs QID_C = Q0 to the task selection circuit 230. According to FIG. 29, in the priority queue (Q0: 0) corresponding to the highest task priority among the virtual queues (Q0), the task (E0) having the order value “1” and the task (E3) having the order value “3” are included. ) Has been entered. The task selection circuit 230 selects a task (E3) having a larger order value as an extraction task. The task selection circuit 230 asserts EID_A1_EN as EID_A1 = E3, PR_A1 = 0, and ODR_A1 = 3.

  Next, the main circuit 400 sets EID_C = EID_A1 = E3 and QID_C = Q0 as CMD = DEQ (extraction command). The register value generation circuit 420_E3 outputs QID_N_E3 = Non, ODR_N_E3 = 0 (reset), and PR_N_E3 = 0 (reset). Thus, the relationship between the task (E3) and the virtual queue (Q0) is canceled in the status register 250.

  Not only the register value generating circuit 420_E3 but also the register value generating circuit 420_En that satisfies QID_S_En = QID_C = Q0 determines whether or not ODR_S_En> ODR_A1 when detecting QID_C = QID_S_En. Here, ODR_A1 is an order value before extraction of the extraction task (E3). If ODR_S_En> ODR_A1, that is, the register value generation circuit 420_En of the task (En) whose order value is larger than the order value of the extracted task outputs ODR_N_En = ODR_S_En-1. In the example shown in FIG. 29, the register value generation circuit 420_E6 for the task (E6) corresponds. The register value generation circuit 420_E6 outputs ODR_N_E6 = ODR_S_E6-1 = 4-1 = 3. Thus, the state data of the task (E6) that is an element of the virtual queue (Q0) is adjusted.

FIG. 34 is a data structure diagram of the status register 250 corresponding to FIG.
In the figure, the underlined portion is a portion changed from the setting contents of the status register 250 shown in FIG. First, by extracting the task (E3) from the virtual queue (Q0), “Non” is newly set in the queue identification register 416_E3. In addition, “0” is set as a reset value in each of the queue order register 414 and the task priority register 412. Of the task (E0), task (E2), task (E5), and task (E6) originally placed in the virtual queue (Q0) by the extraction of the task (E3), the order value is higher than that of the extraction task (E3). The ODR of the task (E6) having a large value is decremented.

FIG. 35 is a flowchart showing the extraction process.
First, the main circuit 400 inputs QID = Qn of the virtual queue to be extracted into the task selection circuit 230 (S30). The task selection circuit 230 selects an extraction task from the virtual queue (Qn) (S32). When the main circuit 400 inputs the task ID = En of the extraction task to the queue control circuit 404, the queue control circuit 404 clears QID = Qn from the status data of the extraction task (En) (S34). At this time, PR and ODR are reset to “0”, but they are not necessarily reset.

When other tasks are also put in the virtual queue (Qn) (Y in S36) and there is a task satisfying ODR_S_En> ODR_A1 (Y in S38), the order value of the corresponding task is decremented (S40). Note that the processing shown in S30 to S40 need not be executed serially, and may be executed in parallel in time.
In terms of implementation, tasks can be taken out from the middle of the virtual queue. For example, in FIG. 33, it is assumed that the task (E2) needs to be taken out from the middle of the virtual queue (Q0). The task (E2) is assumed to be an operable task on condition that a certain flag A is set to ON. When the flag A is turned off, the task (E2) needs to be taken out from the middle of the virtual queue (Q0). Alternatively, it is necessary to take out the task (E2) from the middle of the virtual queue (Q0) even when the waiting time set in advance for the task (E2) times out. In this case, the QID of the task (E2) is cleared, and the task (E2) is decremented by the ODR of the task having an order value larger than the order value “2” of the task (E2), thereby making the task (E2) a virtual queue (Q0). It can be taken out even from the middle. In the case of FIG. 33, the ODR of the task (E6) is “2”. Since the virtual queue is formed in such a way that it is not physically restricted by hardware, it is possible to perform input / extraction processing even from the middle of the queue.

  According to the virtual queue control described above, a special queue that realizes LIFO-like operation can be realized by hardware logic while being based on FIFO. If the double-throw queue algorithm is implemented by software, it is usually implemented by a linked list. However, as long as the processing is performed by software, overhead associated with memory access and address management must be generated. On the other hand, since the virtual queue control shown in the improvement example 1 is realized by hardware logic, it is possible to perform remarkably simple and high-speed control. In particular, in RTOS where time requirements are strict, it is significant to implement the double-throw queue algorithm in hardware. Next, an aspect in which the re-execution priority type task scheduling is realized by the above-described virtual queue control method will be described.

FIG. 36 is a first conceptual diagram showing the relationship between virtual queues and tasks in re-execution priority task scheduling.
Here, two virtual queues are assumed, a virtual queue (Q0) corresponding to the READY state and a virtual queue (Q1) corresponding to the WAIT semaphore state. The virtual queue (Q0) inputs a priority queue (hereinafter referred to as “priority queue (Q0: 0)”) for inputting a task having a task priority order PR = 0 and a task having a task priority order PR = 1. It is an aggregate of two priority queues for priority queues (Q0: 1) for The same applies to the virtual queue (Q1), and substantially four priority queues are assumed.

  In this figure, the task (E1) with PR = 1 is in the RUN state, and the task (E0) and task (E2) with PR = 1 are also waiting in the READY state in the priority queue (Q0: 1). Yes. Further, the task (E3) with PR = 0 is waiting in the WAIT semaphore state in the priority queue (Q1: 0). Here, it is assumed that the task (E1) is a task to be executed intensively and preferentially once it is executed.

  First, it is assumed that the task (E1) in the RUN state executes a release semaphore system call and returns to the READY state (S1). Since the task (E1) is a task that is to be re-executed at the earliest possible stage, it is “reversely input” to the priority queue (Q0: 1). On the other hand, it is assumed that the WAIT cancellation condition for the task (E3) is satisfied by the release semaphore system call. The task (E3) is extracted from the priority queue (Q1: 0) and sequentially entered into the priority queue (Q0: 0) (S2). Next, the task selection circuit 230 selects a new RUN-task. The task selection circuit 230 selects the task (E3) having the highest task priority among the tasks in the READY state as the extraction task. Thus, the task (E3) just shifted from the WAIT state to the READY state is extracted from the priority queue (Q0: 0) and becomes a new RUN-task. According to such task scheduling, a task having a high task priority can acquire an execution right at a relatively early stage if the WAIT cancellation condition is satisfied.

FIG. 37 is a second conceptual diagram showing the relationship between virtual queues and tasks in re-execution priority task scheduling.
When the task (E3) executes the wait semaphore system call, the task (E3) is sequentially placed in the priority queue (Q1: 0) (S4). Next, the task selection circuit 230 selects a new RUN-task. The task selection circuit 230 selects the task having the highest task priority among the tasks in the READY state. Here, the task priority of the task (E0), the task (E2), and the task (E1) is the same. . In this case, the task (E1) is extracted from the priority queue (Q0: 1) (S5). Task (E1) becomes a new RUN-task. According to such a processing method, it is possible not only to set the task priority order PR = 0, but to cope with the specification of the task (E1) that is to be executed continuously as much as possible once it is executed.

In the re-execution priority type task scheduling, the task execution order can be controlled by properly using the forward input and reverse input according to the execution status and the type of task. For this reason, more precise task scheduling can be realized while maintaining the feature of high-speed processing performance of the task processing apparatus 100 shown in the basic example.
{Improved Example 2}

Next, as an improved example 2, the speeding up of the auxiliary process in the task processing apparatus 100 will be described. In the task processing apparatus 100 according to the improved example 2, an HWF (Hardware Function Module) executes auxiliary processing. The HWF here is a so-called auxiliary processor and functions as an auxiliary processing circuit. The auxiliary processing is executed as a part of the task, and there are various contents of processing such as floating point calculation, DMA transfer, encryption / decryption processing, and 3D image coordinate calculation.
First, a general auxiliary processing control method by the software OS will be described. Then, the control method of the auxiliary process by the task processing apparatus 100 of the improvement example 2 is demonstrated.

FIG. 38 is a diagram showing a general circuit configuration when the auxiliary process is executed by the software OS.
The CPU 84 is connected to a memory (not shown) and the HWF 500 via the CPU bus 512. Further, an interrupt controller 502 is connected to the CPU 84. The interrupt controller 502 receives various interrupt signals from the HWF 500 or the like, and transmits an interrupt signal (INTR) to the CPU 84. When the CPU 84 receives the interrupt signal (INTR), the CPU 84 appropriately executes a process corresponding to the interrupt signal (INTR) by a special task.
As shown in FIG. 2, the software OS is executed by the CPU 84, and general tasks and special tasks are executed in the upper hierarchy.

  Auxiliary processing is roughly divided into two types: “serial auxiliary processing” and “parallel auxiliary processing”. In the case of serial auxiliary processing, no other task can be executed during the execution. In the case of parallel auxiliary processing, other tasks can be executed in parallel even during the execution.

FIG. 39 is a time chart showing a control method of a general serial type auxiliary process.
First, the task A issues an “interrupt prohibition instruction” as a system call for occupying the HWF 500 (S100). Here, it is assumed that the target HWF 500 is an FPU (floating point arithmetic unit). When the “interrupt disable instruction” is issued, the task switch is suppressed until an “interrupt cancel instruction” described later is issued. Hereinafter, the period from when the interrupt prohibition is set by the interrupt prohibition instruction until the interrupt prohibition is canceled by the interrupt cancel instruction is referred to as an “interrupt prohibition period”. Even if an interrupt signal (INTR) is input during the interrupt inhibition period, the special task is not activated. During the interrupt prohibition period, the task A monopolizes the right to use the CPU 84. Therefore, tasks other than the task A do not access the HWF 500, that is, the FPU.
After the software OS sets the interrupt prohibition, the process returns to task A (S102). The task A instructs the HWF 500 to execute auxiliary processing (S104). In order to suppress the overhead associated with the auxiliary process control, the task A directly writes the parameter to the built-in register of the HWF 500 and instructs the execution of the auxiliary process without using the software OS. The HWF 500 executes auxiliary processing instructed by the task A.

  Task A waits for the completion of auxiliary processing while periodically checking the internal register of HWF 500. When the completion of the auxiliary process is detected (S106), task A issues an interrupt release command (S108). When the software OS receives the interrupt release command, the software OS cancels the interrupt inhibition (S110). Thus, the interrupt prohibition period ends. The software OS executes a task switch and selects a task to be executed next, for example, task B (S112). Thereafter, an execution right is assigned to task B. The task B can also use the HWF 500 by the same method.

  If the HWF 500 is executing an auxiliary process at the request of the task A and another task, for example, a special task rewrites the internal register of the HWF 500, the task A cannot receive the correct processing result. . For this reason, it is necessary to strictly control the exclusive right of the HWF 500. However, each task can access the HWF 500 without going through the software OS. For example, in S104, the task A directly accesses the HWF 500 without going through the software OS. Therefore, the task is issued with an “interrupt disable instruction” and an “interrupt cancel instruction” so that the software OS can correctly manage the occupation right of the HWF 500. The software OS prevents the task switch from occurring during the auxiliary process in advance by an interrupt prohibition instruction. In this way, while the task A is using the HWF 500, another task acquires the right to use the CPU 84 and takes measures so as not to interfere with the HWF 500. In the case of FIG. 39, the interrupt prohibition period is from the timing of S102 to the timing of S110.

  In the case of the serial type auxiliary processing, other tasks cannot be substantially executed during the interrupt prohibition period. In other words, in the serial type auxiliary process, another task cannot acquire the right to use the CPU 84 during the auxiliary process. For this reason, auxiliary processing that can be completed in a relatively short time, such as floating point arithmetic, is suitable as serial auxiliary processing.

FIG. 40 is a time chart showing a control method of a general parallel type auxiliary process.
First, the task A issues a WAIT system call such as a wait semaphore system call or a wait mutex system call using the right to use the HWF 500 as a waiting condition (S120). Here, a description will be given of the wait mutex system call. This wait mutex system call is issued as an instruction for requesting occupation of the HWF 500. Further, it is assumed that the target HWF 500 is a DMAC (DMA controller). When the software OS receives the wait mutex system call, the mutex prohibits the access to the HWF 500 by the task other than the task A, that is, the access to the DMAC (S122). Thus, the HWF 500 is temporarily occupied by the task A. The software OS selects a task to be executed next. Here, the description is continued on the assumption that the task A is selected again. The task A instructs the HWF 500 to execute auxiliary processing (S124). Here again, it is assumed that the task A directly instructs the HWF 500 to execute the auxiliary process without using the software OS. The HWF 500 executes the instructed auxiliary process.

  Task A issues a WAIT system call such as a wait event system call with the completion of auxiliary processing as a standby condition (S126). Task A transitions to the WAIT state. The software OS executes a task switch and selects the next RUN-task, for example, task B (S128). Task B is executed in parallel with the auxiliary process. However, since the HWF 500 is occupied by the task A, the task B cannot use the HWF 500.

  When the auxiliary process is completed, the HWF 500 transmits an interrupt signal (INTR) (S130). When detecting the interrupt signal (INTR), the software OS activates a special task as an interrupt handler (S132). The special task first notifies the event of completion of the auxiliary process by a SET system call such as a set event system call (S134). Thus, the wait condition for the wait event system call issued by task A is satisfied. Again, the execution right is transferred from the software OS to the special task (S136). After executing the remaining processing, the special task transitions to the STOP state (S138). The software OS acquires the execution right again, terminates the special task, and then executes a task switch (S140). Here, it is assumed that task A is selected again.

  Since the auxiliary processing requested by task A has already been completed, task A reads the processing result from the built-in register of HWF 500 (S142). Alternatively, the task A may read the processing result written by the HWF 500 in a predetermined area of the memory. Task A issues a release mutex system call (S144). When the software OS receives the release mutex system call, the software OS releases the exclusive right by the task A of the HWF 500 (S146). The software OS executes a task switch and selects a task to be executed next, for example, task C (S148). Thereafter, an execution right is assigned to task C. Since the occupation right of the HWF 500 is released, the task C can use the HWF 500 in the same manner.

  The parallel type is the same as the serial type in that general tasks directly access the HWF 500. In the parallel type auxiliary processing, other tasks are prevented from using the HWF 500 during the auxiliary processing, but other tasks can acquire the right to use the CPU 84 itself. In this way, while the task A is using the HWF 500, other tasks are prevented from interfering with the HWF 500.

  During the execution of the parallel auxiliary processing, other tasks can be executed in parallel as shown in S128. However, the overhead is larger than the serial auxiliary processing due to the system call of S126 and S134, the activation of the special task, and the like. For this reason, auxiliary processing that takes a relatively long time such as DMA transfer is suitable as parallel auxiliary processing.

  In the case of the serial auxiliary process shown in FIG. 39, the task needs to issue system calls twice in total. Further, even after the auxiliary process is started, it is necessary to periodically check the HWF 500 to detect whether or not the auxiliary process is completed. A “deviation” is likely to occur between the timing at which the auxiliary process is actually completed and the timing at which the task detects the completion of the auxiliary process, resulting in a reduction in processing efficiency.

  In the case of the parallel auxiliary process shown in FIG. 40, task A needs to issue system calls four times in total. Furthermore, when the auxiliary process is completed, a special task must be activated to notify task A of the completion of the auxiliary process.

  Generally, about 500 to 1000 CPU clocks are consumed per system call. The auxiliary process is a process with high execution frequency, and it is an important design point how to suppress such overhead for an RTOS with severe time requirements.

FIG. 41 is a diagram showing a circuit configuration when the auxiliary processing control shown in FIGS. 38 to 40 is realized by the task processing apparatus 100 of the basic example.
As described in connection with the basic example, the task processing device 100 mainly includes the CPU 150, the save circuit 120, and the task control circuit 200. In the case of the general circuit configuration shown in FIG. 38, the CPU 84 executes both the software OS and the task. On the other hand, in the task processing apparatus 100, the CPU 150 executes the task, and the function as the OS is realized by the save circuit 120 and the task control circuit 200. As described in relation to the basic example, the processing efficiency as a whole is remarkably improved by externalizing the function of the OS from the CPU 150. Also in FIG. 41, the CPU 150 is connected to the HWF 500 via the CPU bus 512.

In the case of the hardware OS by the task processing apparatus 100, the system call execution, in particular, the task switch is significantly faster than the software OS. The task processing apparatus 100 requires only about 12 CPU clocks in order to execute a system call once. For this reason, even if the auxiliary processing control shown in FIGS. 39 and 40 is executed by the task processing device 100 with the circuit configuration of FIG.
In the improved example 2, the auxiliary processing is further speeded up by reviewing the relationship between the task processing apparatus 100 and the HWF 500, in particular, the CPU 150 and the HWF 500.

FIG. 42 is a circuit configuration diagram showing the relationship between the task processing device 100 and the HWF 500 in the second improved example.
In the figure, a plurality of HWFs 500 (HWF500_0,..., HWF500_k: k is an arbitrary natural number) are connected to the task control circuit 200 instead of the CPU 150. Each HWF 500 is a dedicated circuit designed for different auxiliary processing. For example, the HWF 500_0 may be an FPU and the HWF 500_1 may be a DMAC. Each HWF 500 is uniquely identified by an HWFID ranging from 0 to k.

  The task executed by the CPU 150 causes each HWF 500 to execute auxiliary processing via the task control circuit 200. The task cannot directly access the internal register of the HWF 500. In the improved example 2, the task control circuit 200 manages each HWF 500 in an integrated manner.

FIG. 43 is a circuit diagram showing the relationship between the state storage unit 220 and the task switching circuit 210 in the second modification.
An HWF standby selection circuit 510 is added to the task selection circuit 230 of the improved example 2. A plurality of HWFs 500 are newly connected to the task switching circuit 210.

The basic configuration of the task control circuit 200 is almost the same as the circuit configuration of the basic example shown in FIG. The status register 250 associated with each task includes a HWFID register 504, a queue order register 506, and a queue identification register 508 in addition to the task ID register 254, the task priority order register 256, and the like.
(A) HWFID register 504: When a certain task instructs execution of auxiliary processing, the HWFID of the HWF 500 that is the execution subject of the auxiliary processing is set. HWFID is always output as an HID_S signal. In the improved example 2, the HWFID is written in the HWFID register 504 only during the parallel type auxiliary processing.
(B) Queue order register 506: Holds an “order value (ODR)” indicating the order in which tasks are submitted to the virtual queue. The larger the order value, the deeper the virtual queue is inserted. The order value is always output as an ODR_S signal. The order value ODR of the improvement example 2 has the same concept as the “order value ODR” described in the improvement example 1.
(C) Queue identification register 508: Holds a “queue ID (QID)” for identifying a virtual queue. Always output as the QID_S signal. The queue ID has the same concept as the “queue ID (QID)” described in the first modification.

  The virtual queue is a virtual queue that is associated with the task state, similar to the virtual queue shown in the first improvement example. As described above, the correspondence between the queue ID and the task state need not be fixed as hardware implementation. The task selection circuit 230 can determine the task state of each task by referring to each queue identification register 508.

  The task selection circuit 230 selects a task whose state is to be changed based on the state data output from the state register 250. When task switching circuit 210 inputs HWFID to HWF standby selection circuit 510, HWF standby selection circuit 510 outputs the task ID of the task whose HWFID is set in HWFID register 504. In other words, “task waiting for completion of processing by designated HWF 500” is notified to the task switching circuit 210. If the designated HWF 500 is not being processed, that is, if no task is requested to be processed, the HWF standby selection circuit 510 outputs a predetermined value such as “−1”.

Each HWF 500 is directly connected to the task switching circuit 210. Each HWF 500 is connected to the task switching circuit 210 by the following six types of signal lines. In the following, it is assumed that i is an arbitrary number from 0 to k.
a. HFi_REQ: The task switching circuit 210 asserts HFi_REQ when instructing the HWF 500_i to execute auxiliary processing.
b. HFi_ARG [m-1: 0]: Transmit auxiliary processing parameters. The size of HFi_ARG [m-1: 0] varies depending on the contents of the auxiliary processing, and the number of parameters also varies. When HFi_REQ is asserted, HFi_ARG [m-1: 0] is written to the internal register of the HWF 500_i.
c. HFi_RQACK: When HFi_REQ is asserted and HFi_ARG [m-1: 0] is written, the HWF 500_i starts auxiliary processing. At the start of the auxiliary process, the HWF 500 — i asserts HFi_RQACK. From HFi_RQACK, the task switching circuit 210 recognizes that the auxiliary processing has started.
d. HFi_CMPLT: When the auxiliary process is completed, the HWF 500_i writes the result of the auxiliary process to the built-in register and then asserts HFi_CMPLT. By HFi_CMPLT, the task switching circuit 210 recognizes the completion of the auxiliary processing.
e. HFi_RSLT [m-1: 0]: A return value indicating the result of the auxiliary process. The size of HFi_RSLT [m-1: 0] varies depending on the contents of the auxiliary processing, and the number of return values also varies. The return value written in the internal register of the HWF 500 — i is transmitted. When HFi_CMPLT is asserted, the task switching circuit 210 acquires the return value of HFi_RSLT [m-1: 0].
f. HFi_CMPACK: When the task switching circuit 210 acquires the return value, it asserts HFi_CMPACK. From HFi_CMPACK, the HWF 500 — i recognizes that the return value has been acquired normally.

FIG. 44 is a time chart showing a control method of serial auxiliary processing in the improved example 2.
In addition to the nine system calls described in the basic example, a “HWF call” is added to the task processing apparatus 100 of the improved example 2. The “HWF call” is a system call for a task to instruct execution of auxiliary processing.

  First, the task A issues an HWF call with the type of target auxiliary processing as a parameter (S100). For example, the type of auxiliary processing is specified by a floating point arithmetic instruction, a DMA transfer instruction, an encryption processing instruction, or the like. The task switching circuit 210 selects the target HWF 500 according to the auxiliary process specified as the parameter, and identifies the corresponding HWFID. Note that an HWF call may be issued with the HWFID itself as a parameter. Here, a description will be given assuming that HWFID = i is specified. An argument of auxiliary processing may be specified as a parameter of the HWF call. Such parameters are written into a predetermined general-purpose register 158 in the CPU 150. The task switching circuit 210 reads these parameters from the general-purpose register 158 when receiving the HWF call.

  The task switching circuit 210 instructs the HWF 500_i to execute auxiliary processing (S102). The task switching circuit 210 stops the CPU 150 by the HC signal. Therefore, task A is stopped in the RUN state.

  In S102, the task A does not access the HWF 500 as shown in FIG. 39, but the task switching circuit 210 instructs the HWF 500 to execute auxiliary processing. Specifically, HFi_REQ is asserted after setting an argument in HFi_ARG [m-1: 0]. The HWF 500 — i starts auxiliary processing and asserts HFi_RQACK. Since the CPU 150 is already stopped, the task A is not executed during the auxiliary process. Of course, other tasks including special tasks are not executed.

  When the auxiliary processing is completed, the HWF 500 — i outputs a return value to HFi_RSLT [m−1: 0] and asserts HFi_CMPLT. The task switching circuit 210 receives the return value and asserts HFi_CMPACK (S104). The task switching circuit 210 records the return value in the processing register 92. The task switching circuit 210 negates the stop request signal (HR) and resumes the execution of the task A (S106).

  In the case of the serial type auxiliary process of the improved example 2, only one system call is required. Moreover, since the CPU 150 is stopped during the execution of the auxiliary process, power consumption is also suppressed. Further, since the task A that requested the auxiliary process does not need to inquire the completion timing of the auxiliary process to the HWF 500, there is almost no difference between the timing at which the auxiliary process is completed and the timing at which the task processing apparatus 100 detects the completion of the auxiliary process. do not do.

  In the improved example 2, the task cannot directly access the HWF 500, and the task switching circuit 210 accesses the HWF 500 to the last. For this reason, processing for causing the OS to control the interrupt prohibition period by the interrupt prohibition instruction or the interrupt release instruction is unnecessary. After receiving the HFW call, the task processing device 100 only controls the stop / restart of the CPU clock by the stop request signal (HR). Since the task processing apparatus 100 writes the result of the auxiliary process as a return value in the processing register 92, the task A that has requested the auxiliary process has already acquired the result of the auxiliary process when the execution is resumed. Since task A does not need to inquire the result of auxiliary processing to HWF 500 or task control circuit 200, not only the processing efficiency is improved, but also the program code of task A can be simplified.

FIG. 45 is a time chart showing a control method of parallel auxiliary processing in the improved example 2.
Here again, it is assumed that the target HWF 500 is an FPU (floating point arithmetic unit). Further, the HWFID of the HWF 500 corresponding to the FPU is “i”. First, the task A issues a wait mutex system call using the FPU usage right as a waiting condition (S120). The exclusive right of each HWF is managed by the mutex and semaphore. Exclusive control of HWF by mutex or the like is not essential. For example, if the HWF is used only for a specific task, exclusive control is unnecessary.
If the HWF 500 — i is not set as occupied by the mutex, the task processing apparatus 100 prohibits the task other than the task A from accessing the HWF 500 — i by the mutex (S 122).

  Thus, the HWF 500 — i is temporarily occupied by the task A. Next, task A issues an HWF call (S124). Task A makes a state transition from RUN to WAIT. The condition for releasing the WAIT is that the auxiliary process of the HWF 500 — i is completed. When task switching circuit 210 receives the HWF call, task switching circuit 210 sets HWFID = i in HWFID register 504 of task A.

  In the improved example 2, the task switching circuit 210 itself instructs the HWF 500 to start the auxiliary process without returning the execution right to the task A as shown in FIG. 40 (S126). The HWF 500 — i starts auxiliary processing. The task switching circuit 210 selects the next RUN-task, for example, task B (S128). Task B is executed in parallel with auxiliary processing. However, the task B cannot use the HWF 500 — i. This is because the task A secures the occupation right of the HWF 500 — i by the mutex.

  When the auxiliary processing is completed, the HWF 500 — i outputs a return value to HFi_RSLT [m−1: 0] and asserts HFi_CMPLT. The task switching circuit 210 receives the return value and asserts HFi_CMPACK (S130). Task B makes a state transition from RUN to READY. Specifically, the task processing device 100 asserts the stop request signal (HR) to request the stop of the CPU clock, waits for the stop completion signal (HC) to be asserted, and receives the processing data of the task B. Save to the save register. Task B is put back into the virtual queue associated with the READY state. The task switching circuit 210 inputs HWFID = i to the HWF standby selection circuit 510, and acquires the task ID of the task A that has requested the HWF 500_i to perform auxiliary processing. Then, a return value indicating the result of the auxiliary process is recorded in the save register corresponding to the task A, and the task A is set to the READY state. Here again, as shown in the first improvement, the task A may be put back into the virtual queue corresponding to READY. The task switching circuit 210 selects a task to be executed next, for example, task A (S132). Thereafter, an execution right is assigned to task A. When the auxiliary process is completed, the task A that has requested the auxiliary process may be selected. According to such a task switch rule, it is possible to improve the throughput of a task for which auxiliary processing is requested. The task A releases the exclusive right of the HWF 500 — i by the release mutex system call (S134). The task processing device 100 executes the task switch again, and selects the task to be executed next, for example, the task B that has been executed from S128 to S130 (S136). Thereafter, an execution right is assigned to task B. Since the occupation right of the HWF 500 is released, the task B can use the HWF 500 — i in the same manner.

  In the parallel auxiliary processing shown in relation to FIG. 40, a total of four system calls have been issued. On the other hand, the number of system calls of the parallel type auxiliary processing in the improved example 2 is “wait mutex system call”, “release mutex system call”, and “HWF call”. For this reason, according to the improvement example 2, the overhead accompanying a system call can be suppressed by one time. Also, there is no need to execute special tasks. By writing the return value in the save register, the task A does not need to inquire the result of the auxiliary processing to the HWF 500 or the task control circuit 200.

Conventionally, various methods have been attempted to execute software such as an OS at high speed. Such attempts are often directed to increase in scale and complexity such as increase in the number of CPU clocks, increase in memory capacity and register capacity, parallel processing by a plurality of CPUs, and further, network distributed processing.
On the other hand, in the case of the task processing device 100 shown in the present embodiment, the processing efficiency is dramatically improved by adding the save circuit 120 and the task control circuit 200 to the existing CPU 150. In the case of the software OS, in order to realize processing such as a task switch that is originally desired to be executed, incidental processing such as management of TCB and task ready list must be executed. On the other hand, the task processing apparatus 100 is freed from such software-specific overhead because the task switch, task state management, and interrupt processing are realized by hardware logic. For this reason, it is an ideal system that realizes high speed while suppressing increase in power consumption and cost.

  Furthermore, according to the auxiliary process control shown in the improved example 2, the overhead associated with the auxiliary process can be greatly suppressed. Conventionally, in order to execute auxiliary processing such as DMA transfer at high speed, a program for directly operating a built-in register of the HWF 500 is often provided without using a software OS. However, if a problem occurs in such a program, the behavior of the entire system becomes unstable.

  The task processing apparatus 100 of the improved example 2 has a configuration in which a task cannot physically operate the HWF 500 directly. Even if the task requests the task processing device 100 for auxiliary processing due to the high-speed processing performance of the task processing device 100 itself, a reduction in the number of system calls, etc., high-speed auxiliary processing can be realized. According to the task processing apparatus 100 of the improved example 2, it is possible to achieve both safety and speedup in the auxiliary process control.

  The present invention has been described based on the embodiments. The embodiments are exemplifications, and it will be understood by those skilled in the art that various modifications can be made to combinations of the respective constituent elements and processing processes, and such modifications are within the scope of the present invention. .

  It should also be understood by those skilled in the art that the functions to be fulfilled by the constituent elements recited in the claims are realized by the individual functional blocks shown in the present embodiment or their linkage.

Various determination circuits have been described with reference to FIGS. 12, 14, 28, and 32. These determination circuits select a task to be compared and selected by a comparison circuit group.
For example, the execution selection circuit 232 in FIG. 12 is a circuit for selecting a RUN-task, but a RUN-task can be a READY-task. Therefore, the determination circuit 296 in FIG. 12 outputs the CID signal “1” on condition that the task is a READY-task. The comparison circuit group of the execution selection circuit 232 selects the next RUN-task based on the task priority order PR and the READY elapsed time TIM only for the task having the CID signal “1”, that is, the task in the READY state. To do.

  The semaphore selection circuit 234 in FIG. 14 is a circuit for selecting a task whose semaphore wait should be released when releasing the semaphore. The task whose semaphore wait is released is a task in the WAIT state with the released semaphore as a standby semaphore. Therefore, the determination circuit 306 in FIG. 14 outputs the CID signal “1” on condition that the WAIT-task has the release semaphore as a standby semaphore. The comparison circuit group of the semaphore selection circuit 234 is based on the task priority order PR and the WAIT elapsed time TIM only for the task for which the CID signal is “1”, that is, “WAIT-task with the released semaphore as a standby semaphore”. Select a task to be released from waiting for a semaphore.

  If the logic of the determination circuit is changed, the execution selection circuit 232 and the semaphore selection circuit 234 can share the comparison circuit group. The same applies to mutexes and events. The same applies to the maximum value selection circuit 406 in FIG. 28 and the task selection circuit 230 in FIG. In this way, by adding / changing the logic of the determination circuit, various selection logics can be implemented in the form of sharing the comparison circuit group. Here are two examples.

1. Rotate system call This system call is a system call for changing the task group of the virtual queue associated with the READY state, that is, the READY-task order value (ODR). For example, as shown in FIG. 29, in the virtual queue (Q0) associated with the READY state, the task (E6), the task (E3), the task (E2), the task (E0), and the task (E5) are in this order. Assume that one task is submitted. Here, it is assumed that the RUN-task issues a rotate system call with the task priority PR = 1 specified.
Then, the task (E6) at the head of the priority queue (Q0: 1) associated with PR = 1 is once taken out and sequentially inserted behind the task (E5). That is, the order value (ODR) of the task (E6) is “0”, and the order values of other tasks are adjusted accordingly.
The rotate system call is a system call for changing the order of the first task to the last for the priority queue (Q0: 1) associated with the task priority PR = 1 specified by the parameter. According to the rotate system call, the order value (ODR) of the task put in the virtual queue (Q0) can be controlled from the outside.

  The determination circuit for realizing the rotate system call may output “1” on condition that “the task is in the READY state and has the designated task priority PR”. After that, the task having the largest order value (ODR) may be selected as a rotation target from among the corresponding tasks for which the output signal of the determination circuit is “1” by the comparison circuit group.

2. Function expansion for virtual queue associated with WAIT state Normally, when a semaphore is released, the priority queue (Qn: Pn) having the highest task priority PR in the virtual queue (Qn) associated with semaphore waiting The task from which this semaphore is to be acquired is selected. However, regardless of the task priority order PR, a special semaphore (hereinafter referred to as “special semaphore”) to be acquired by a task having the largest order value (ODR) may be set.

  In order to implement a special semaphore, a determination circuit that outputs “1” when a “task is in a WAIT state and a release semaphore is a standby semaphore” may be prepared. The determination circuit 434 in FIG. 32 is a circuit that receives QID_S and CND and outputs an EID_EN signal. This is changed, and a determination circuit is assumed that receives task priority PR_S in addition to QID_S and CND, and outputs EID_EN and PR_A. This determination circuit outputs a predetermined value x to PR_A when the special semaphore is released, and outputs PR_S as it is as PR_A when the normal semaphore is released. For this reason, the comparison circuit group recognizes that the task priority order PR of each task is the predetermined value x when the special semaphore is released. As a result, the comparison circuit group selects the task having the smallest order value (ODR) from the corresponding tasks for which the output signal of the determination circuit is “1” regardless of the task priority order PR of each task. Become.

  Various aspects of the invention grasped from the above embodiments and modifications will be exemplified below in the form including those already described in the claims. In connection with the improved example 1, the following invention is recognized.

C1. A queue control circuit that controls input and extraction of a plurality of elements identified by an element ID for a plurality of types of virtual queues identified by a queue ID;
A register provided corresponding to each element, and includes a plurality of queue registers that associate and hold a queue ID of a virtual queue to be input and an order value indicating the input order,
The queue control circuit includes:
When a sequential input command for specifying an element ID and a queue ID is input, the input to the end of the virtual queue corresponding to the specified queue ID is performed for the corresponding queue register of the specified element ID. Set the end order value indicating the and the specified queue ID,
When a reverse submission command specifying an element ID and a queue ID is input, the input to the corresponding queue register of the specified element ID is input to the head of the virtual queue corresponding to the specified queue ID Set the head order value indicating the above and the specified queue ID,
When an extraction command for specifying a queue ID is input, the queue ID is cleared from the queue register holding the specified queue ID and the head order value, and the corresponding element is set as an extraction target. A virtual queue processing circuit that manages the plurality of types of virtual queues based on information.

  C2. The queue control circuit adjusts an order value of another queue register that holds a queue ID specified by a command when either the forward input command or the reverse input command is input. The virtual queue processing circuit according to 1.

C3. An extraction candidate circuit for outputting an element ID corresponding to the designated queue ID and head order value with reference to the queue ID and order value output in parallel from the plurality of queue registers when the queue ID is designated Further comprising
The virtual queue processing circuit according to C3, wherein the queue control circuit clears the queue ID from the corresponding queue register of the element ID output from the extraction candidate circuit.

C4. A virtual queue is further defined as a set of multiple priority queues depending on the priority of extraction,
The queue register also holds a priority for identifying a priority queue,
The queue control circuit includes:
When a sequential input command specifying a priority in addition to an element ID and a queue ID is input, the specified priority is also set for the corresponding queue register of the specified element ID,
When a reverse input command specifying a priority in addition to an element ID and a queue ID is input, the specified priority is also set for the corresponding queue register of the specified element ID,
When an extraction command that specifies a queue ID is input, the queue is held from the queue register that holds the specified queue ID, has the highest priority among them, and has the order value closest to the head. The virtual queue processing circuit according to C1, wherein ID is cleared.

  C5. The virtual queue according to C4, wherein the queue control circuit adjusts an order value of another queue register holding the designated queue ID when the extraction command designating the queue ID is input. Processing circuit.

C6. When a queue ID is designated, based on the queue ID, order value and priority output in parallel from the plurality of queue registers, the designated queue ID is held, and the highest priority is set among them. And an extraction candidate circuit that outputs an element ID corresponding to a queue register that holds an order value closest to the top of the order values,
The virtual queue processing circuit according to C5, wherein the queue control circuit clears the queue ID from the corresponding queue register of the element ID output from the extraction candidate circuit.

C7. A processing register that temporarily holds data for task execution;
An execution control circuit for loading instructions and operands from memory into the processing register and executing a task in accordance with the instructions and operands of the processing register;
A register for holding state data for task scheduling, a plurality of state registers respectively associated with a plurality of tasks,
A task switching circuit that manages the task execution state by controlling the input and extraction of a plurality of tasks identified by a task ID for a plurality of types of virtual queues associated with the task execution state;
A task selection circuit for selecting a task according to a predetermined selection condition, with status data output in parallel from the plurality of status registers as an input; and
The status register holds, as a part of the status data, the queue ID of the virtual queue associated with the execution state of the corresponding task and the order value indicating the order of entry into the virtual queue in association with each other,
When the first task being executed executes a predetermined system call instruction, the execution control circuit transmits a predetermined system call signal to the task switching circuit,
The task selection circuit specifies a status register that holds a queue ID of a ready queue that is a virtual queue corresponding to a READY (ready) state and a head order value indicating a head position of the ready queue, and stores the status register in the specified status register. Select the corresponding second task as the next execution target,
When the task switching circuit receives the system call signal, the task switching circuit clears the queue ID from the state register of the second task, and is different from the RUN state with respect to the state register of the first task. The queue ID and order value of a virtual queue associated with another execution state are set, and the data in the processing register is saved in a predetermined storage area, and the data saved in the storage area for the second task Is loaded into the processing register.

  C8. When the task switching circuit shifts the first task to the READY state as the other execution state, the task switching circuit sets a queue ID and a head order value of the ready queue in the state register of the first task. The task control device according to C7, characterized by:

C9. The task selection circuit, when a wait queue is set as a virtual queue associated with a WAIT state that is a waiting state for establishing a WAIT (wait) release condition, when the WAIT release condition is satisfied, Select the task corresponding to the status register that holds the ID and head sequence value,
The task switching circuit according to C7, wherein the task switching circuit sets, for the status register of the selected task, a queue ID of a ready queue and a tail order value indicating insertion at the tail of the ready queue. Control device.

C10. The status register holds task priority as part of the status data,
When there are a plurality of tasks for which the queue ID of the ready queue is set at the time of task switching, the task selection circuit sets the highest task priority among them and sets the order value closest to the top of them. The task processing device according to C7, wherein the task being selected is selected as an execution target.

  According to the present invention, more efficient task execution control is realized in multitask processing.

Claims (13)

A processing register that temporarily holds data for task execution;
An execution control circuit for loading instructions and operands from memory into the processing register and executing a task in accordance with the instructions and operands of the processing register;
A status register that holds status data indicating the task execution status;
A task switching circuit for controlling the task execution state;
A task selection circuit for selecting a task according to a predetermined selection condition based on the state data;
An auxiliary processing circuit that is connected to the task switching circuit via a signal line and executes predetermined auxiliary processing as a part of the task,
The execution control circuit, when executing a predetermined system call instruction, transmits a predetermined system call signal to the task switching circuit,
The task selection circuit selects a task to be executed next from a task in a READY state indicating a state waiting for execution,
The task switching circuit selects a task to be executed next by an output from the task selection circuit when the system call signal is received, saves the data in the processing register to a predetermined storage area, and executes the task The status data for the current task is changed from the RUN status indicating that the task is being executed to another status, and the data saved in the storage area for the selected task is loaded into the processing register and the task By changing the state data for the from the READY state to the RUN state, the task to be executed is switched,
In the execution control circuit, when a task being executed executes an auxiliary process instruction as a system call instruction for causing the predetermined auxiliary process to be executed,
The task processing device, wherein the task switching circuit instructs the auxiliary processing circuit to execute the auxiliary processing by transmitting a predetermined signal to the signal line . A processing register that temporarily holds data for task execution;
An execution control circuit for loading instructions and operands from memory into the processing register and executing a task in accordance with the instructions and operands of the processing register;
A status register that holds status data indicating the task execution status;
A task switching circuit for controlling the task execution state;
A task selection circuit for selecting a task according to a predetermined selection condition based on the state data;
An auxiliary processing circuit that executes predetermined auxiliary processing as part of a task,
The execution control circuit, when executing a predetermined system call instruction, transmits a predetermined system call signal to the task switching circuit,
The task selection circuit selects a task to be executed next from a task in a READY state indicating a state waiting for execution,
The task switching circuit selects a task to be executed next by an output from the task selection circuit when the system call signal is received, saves the data in the processing register to a predetermined storage area, and executes the task The status data for the current task is changed from the RUN status indicating that the task is being executed to another status, and the data saved in the storage area for the selected task is loaded into the processing register and the task By changing the state data for the from the READY state to the RUN state, the task to be executed is switched,
In the execution control circuit, when a task being executed executes an auxiliary process instruction as a system call instruction for causing the predetermined auxiliary process to be executed,
The task switching circuit instructs the auxiliary processing circuit to execute the auxiliary processing;
The task executing the auxiliary processing instruction occupies the auxiliary processing circuit until an auxiliary completion signal indicating completion of the auxiliary processing is received from the auxiliary processing circuit by the task switching circuit. . A processing register that temporarily holds data for task execution;
An execution control circuit for loading instructions and operands from memory into the processing register and executing a task in accordance with the instructions and operands of the processing register;
A status register that holds status data indicating the task execution status;
A task switching circuit for controlling the task execution state;
A task selection circuit for selecting a task according to a predetermined selection condition based on the state data;
An auxiliary processing circuit that executes predetermined auxiliary processing as part of a task,
The execution control circuit, when executing a predetermined system call instruction, transmits a predetermined system call signal to the task switching circuit,
The task selection circuit selects a task to be executed next from a task in a READY state indicating a state waiting for execution,
The task switching circuit selects a task to be executed next by an output from the task selection circuit when the system call signal is received, saves the data in the processing register to a predetermined storage area, and executes the task The status data for the current task is changed from the RUN status indicating that the task is being executed to another status, and the data saved in the storage area for the selected task is loaded into the processing register and the task By changing the state data for the from the READY state to the RUN state, the task to be executed is switched,
In the execution control circuit, when the first task being executed executes an auxiliary processing instruction as a system call instruction for causing the predetermined auxiliary processing to be executed,
The task switching circuit instructs the auxiliary processing circuit to execute the auxiliary processing, sets an occupation right for the auxiliary processing circuit of the first task that has executed the auxiliary processing instruction, and the first task and Sets a different second task to the RUN state, and releases the occupation right of the first task on condition that an auxiliary completion signal indicating completion of the auxiliary processing is received from the auxiliary processing circuit. A featured task processing device. The task switching circuit sets an occupation right for the auxiliary processing circuit of the first task that has executed the auxiliary processing instruction when instructing execution of the auxiliary processing, and is different from the first task. It was set to RUN state, claim 1, wherein the condition that the auxiliary completion signal indicating completion of the auxiliary processing from the auxiliary processing circuit is received, and cancels the exclusive rights of the first task Or the task processing apparatus of 2. In the execution control circuit, the first task executes an occupation request instruction as a system call instruction for requesting the occupation of the auxiliary processing circuit,
The task switching circuit sets an occupation right for the auxiliary processing circuit of the first task on the condition that no occupation right by another task is set for the auxiliary processing circuit,
5. The task processing according to claim 3 , wherein in the execution control circuit, the first task executes the auxiliary processing instruction on the condition that acquisition of the occupation right of the auxiliary processing circuit is successful. apparatus. The task switching circuit records predetermined data in the status register of the first task that has executed the auxiliary processing instruction, thereby indicating that the first task is waiting for completion of processing of the auxiliary processing circuit. Set,
The task selection circuit notifies the task switching circuit of a task in which the predetermined data is recorded in the status register,
The task switching circuit sets the first task notified from the task selection circuit to the RUN state again when an auxiliary completion signal indicating completion of the auxiliary processing is received from the auxiliary processing circuit. The task processing device according to claim 1 . A plurality of auxiliary processing circuits are provided corresponding to each of a plurality of types of auxiliary processing,
In the execution control circuit, when the task being executed executes the auxiliary processing instruction with the type of auxiliary processing as a parameter,
The task switching circuit selects an auxiliary processing circuit corresponding to an auxiliary process specified as a parameter from a plurality of auxiliary processing circuits, and instructs the selected auxiliary processing circuit to execute the auxiliary process. The task processing device according to claim 1 . When selecting the auxiliary processing circuit, the task switching circuit records an auxiliary processing ID for uniquely identifying the selected auxiliary processing circuit in a status register of a task that has executed the auxiliary processing instruction. The task that executed the processing instruction is set to wait for the completion of the processing of the selected auxiliary processing circuit, and when the auxiliary completion signal indicating the completion of the auxiliary processing is received from the selected auxiliary processing circuit, the selection is performed. Notifies the task selection circuit of the auxiliary processing ID of the auxiliary processing circuit,
The task selection circuit selects a task in which the notified auxiliary process ID is recorded,
8. The task processing device according to claim 7, wherein the task switching circuit sets the selected task to the RUN state again when the auxiliary completion signal is received. A register for saving data of the processing register, further comprising a plurality of save registers respectively associated with a plurality of tasks;
When the task switching circuit receives the predetermined system call signal, the task switching circuit saves the data in the processing register in the save register associated with the task being executed, and is associated with the next task to be executed. The task processing apparatus according to claim 1 , wherein data in the save register is loaded into the processing register. The task switching circuit, when receiving an auxiliary completion signal indicating completion of the auxiliary processing from the auxiliary processing circuit, acquires a return value indicating the result of the auxiliary processing from the auxiliary processing circuit and executes the auxiliary processing instruction The task processing apparatus according to claim 9, wherein the return value is written to a task saving register to notify the result of the auxiliary processing to a task that has executed the auxiliary processing instruction. The task switching circuit, upon receiving an auxiliary completion signal indicating completion of the auxiliary processing from the auxiliary processing circuit, the claim 1, characterized in that to set the auxiliary processing instruction again RUN state and the task execution the 4. The task processing device according to any one of 3 . The task switching circuit selects the task to be executed next on the condition that an auxiliary completion signal indicating completion of the auxiliary processing is received from the auxiliary processing circuit, and sets the task to the RUN state. 4. The task processing apparatus according to claim 1 , wherein a task is prevented from being executed in the execution control circuit during execution of processing. The task switching circuit transmits a stop request signal to the execution control circuit when the auxiliary processing instruction is executed,
The execution control circuit, upon receiving the stop request signal, temporarily stops the execution process of the task that executed the auxiliary processing instruction by stopping the supply of an execution clock for advancing the execution process of the task,
The task switching circuit transmits a stop release signal to the execution control circuit when the auxiliary completion signal is received,
The execution control circuit, by which the releasing and receiving a stop release signal supply stop of the execution clock, according to claim 12, characterized in that to resume the execution process of the task that has executed the auxiliary processing instruction task processing apparatus.

Images