JP2017123190A - Task processing device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To efficiently execute and control a task in a multicore system.SOLUTION: A plurality of tasks is executed simultaneously in a plurality of CPUs. A task control circuit is connected to the plurality of CPUs, and when executing a system call instruction, each CPU transmits a system call signal to the task control circuit. Upon receipt of a system call signal from a CPU 0, the task control circuit 200 refers to a processor management register, identifies a RUN-task of the CPU 0, selects a READY-task that is to be executed next, switches process data of the RUN-task and process data of the READY-task, and updates processor management information.SELECTED DRAWING: Figure 48

Description

  The present invention relates to an OS (Operating System) function, and more particularly to an OS compatible with a multiprocessor.

  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.

  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.

  The inventor has developed a task control device that implements a task switch with hardware logic (see Patent Documents 4 and 5). Furthermore, the present inventor has also succeeded in realizing queue management and interrupt processing with hardware logic (see Patent Documents 6 and 7). With these invention groups, the overhead associated with task switching has been greatly reduced.

JP 11-234302 A JP 11-272480 A JP 2001-75820 A Japanese Patent No. 4119945 Japanese Patent No. 4127848 Japanese Patent No. 4088335 JP 2010-049700 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

  However, even though it is a multitasking OS, as long as there is a single CPU, a plurality of tasks are simply executed simultaneously. Hereinafter, a system operating with a single CPU is referred to as an “SP system (Single-Processor System)”, and an RTOS corresponding to the SP system is referred to as “SPRTOS”.

  On the other hand, an approach of executing a plurality of tasks truly simultaneously by a plurality of CPUs is gradually spreading. Hereinafter, a system that operates a plurality of CPUs simultaneously is referred to as an “MP system (Multi-Processors System)”. An RTOS corresponding to the MP system is referred to as “MPRTOS”.

  In the MP system, exclusive control is necessary for a plurality of CPUs to share data safely. Depending on the application, the overhead (execution cost) associated with the exclusive control becomes too large, so that the throughput does not improve as expected, or the throughput rather deteriorates rather than the SP system. The present inventor has thought that if the design concept of the task control circuit described above can be applied to an MP system, the overhead associated with exclusive control can be reduced.

  The present invention has been completed on the basis of the above-mentioned attention by the present inventor, and an object thereof is to provide a technique for performing and controlling tasks more efficiently in the MP system, and in particular, exclusive control. It is to provide a technique for reducing the overhead accompanying the above.

One embodiment of the present invention is a task processing device.
This task processing apparatus is connected to a plurality of processors and centrally manages the execution states of a plurality of tasks executed by the plurality of processors. When the processor executes a system call instruction, it sends a system call signal to the task control circuit.
When the system control signal is received from a certain processor A, the task control circuit refers to the processor management information in which the processor ID of the processor A and the task ID of the task being executed by the processor A are registered. The task T1 being executed is identified, the task T2 to be executed next is autonomously selected from the tasks waiting in the READY state, and the processing data of the task T1 is stored in a predetermined memory from the processing register of the processor A The task switch of the processor A is executed by saving to the area, loading the processing data of the task T2 into the processing register of the processor A, and updating the processor management information.

  According to this embodiment, a task control circuit that is hardware different from a processor such as a CPU that is a task execution entity functions as an MPRTOS. The task processing device does not select a task based on an instruction from a processor or software, but autonomously selects a task by its own hardware logic. Since the task management status is registered in the processor management information, the task control circuit can monitor the status of each processor in real time.

  It should be noted that any combination of the above-described components and a representation of the present invention by a method or system are also effective as an aspect of the present invention.

  According to the present invention, more efficient task execution control is realized in the MP system.

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. It is a circuit diagram of a task processing device in a virtual queue implementation example. It is a partial circuit diagram of the task control circuit in the virtual queue implementation example. 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 time chart of the interruption process by general software OS. It is a circuit diagram of the task processing device in the HW interrupt implementation example. It is a circuit diagram of an interrupt circuit. It is a data structure figure of a memory | storage part. It is a data structure of an interrupt operation instruction. It is a sequence diagram which shows the process of a high-speed interruption process. It is a state transition diagram of the task switching circuit in the HW interrupt implementation example. It is a time chart which shows the process of the high-speed interruption process by the task processing apparatus of the example of HW interruption mounting. It is a hardware block diagram of a general MP system. It is a figure which shows the data structure of memory typically. It is a circuit diagram of a task processing device in an MP implementation example. It is a data structure figure of MP task ID. It is a data structure figure of processor management information. It is a conceptual diagram of the READY queue in the MP implementation example. It is a conceptual diagram of the WAIT queue in the MP implementation example. FIG. 53 is a data structure diagram of a status register corresponding to FIGS. 51 and 52. It is a conceptual diagram which shows the relationship between the virtual queue and task in dispatch. It is a circuit diagram of the task processing device when the function of the processor switching circuit is incorporated in the task switching circuit.

The task processing apparatus 100 according to the present embodiment realizes task scheduling and exclusive control in the MP system by an electronic circuit, and improves its processing efficiency.
First, the task processing apparatus 100 that implements SP system task scheduling using an electronic circuit will be described as a “basic example”. Next, a virtual queue algorithm mounting method will be described as “virtual queue mounting example”, and a hardware-driven interrupt processing mounting method will be described as “HW interrupt mounting example”. After describing the above three examples, the task processing apparatus 100 targeted for the MP system will be described as an “MP implementation example”.
Hereinafter, when referring to “this embodiment”, in principle, the “basic example”, “virtual queue implementation example”, “HW interrupt implementation example”, and “HW interrupt implementation example” are shown.
{Basic example (SP system)}

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. 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 to the processing register 154, respectively. 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 t0, 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. The input timing t1 is almost simultaneously with the detection timing t0. At time t1, the state machine of the CPU 150 is “task in progress” and 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.

Time has passed, and CBUSY = 0 has been changed at time t2. 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 t3). 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 t4). Thus, the task switch from the general task to the special task is executed between the time t2 and the time t3 when the CPU clock stops.
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 t0, the instruction decoder 170 detects a system call and changes SC_DETECT from 0 to 1. At time t0, the state machine of the CPU 150 is “task in progress” 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.

Time has passed, and at time t1, CBUSY = 0. 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 t2 when WT changes from 0 to 1. Since the write signal (WT) is a pulse signal, WT = 0 at time t3 after a predetermined time has elapsed. SC_DETECT latched in the instruction decoder 170 is reset by detecting the fall of WT: 1 → 0 (time t4). At this time, CBUSY changes from 0 to 1. Since CBUSY = 1, HC = 0 and the CPU clock is restarted. The task switch is executed between time t1 and time t4 when the CPU clock stops.
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, “waiting 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 measured for the elapsed READY 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”.

Therefore, the processing of the hardware RTOS in 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)”, since the sixth bit of the current flag pattern is “0”, 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 semaphore table 212 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 and 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 execution of a task, that is, during operation of the CPU clock, it is possible to immediately interrupt the CPU 150 and execute task switching. Further, during the execution of the task, the task switching circuit 210 can independently execute the timeout value update process 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 the processing data of task B. 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.
{Virtual queue implementation example (SP system)}

  Next, as a virtual queue implementation example, a task processing apparatus 100 that implements a double-throw queue algorithm in hardware 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 virtual queue implementation example, the re-execution priority type task scheduling is realized by the hardware implementation of the double-throw type queue algorithm that is compatible with LIFO while being based on 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 virtual queue implementation example.
The task processing device 100 in the virtual queue implementation example 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 virtual queue implementation example 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. Therefore, the task switching circuit 210 in the virtual queue implementation example 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 virtual queue implementation example.
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 (1). 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 (order 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 values of other tasks may be adjusted 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 of other tasks at the time of ordering, but there is a possibility that the order value of other tasks may be adjusted at the time of reverse ordering.
[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 virtual queue implementation example specifies the 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, a description will be given assuming 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). 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 virtual queue implementation example is realized by hardware logic, it is possible to perform much simpler and faster 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.
{HW interrupt implementation example (SP system)}

  Next, a task processing apparatus 100 that implements interrupt processing by hardware logic will be described as an example of HW interrupt implementation.

FIG. 38 is a time chart of interrupt processing by a general software OS.
When the software OS receives an interrupt request signal from an interrupt controller (not shown), the software OS starts an interrupt handler, that is, a special task in the basic example. Various events such as pressing of the keyboard, reception of a communication packet, completion of DMA transfer, or mere passage of a predetermined time can trigger an interrupt request signal. A special task is a task implemented by software, and executes various interrupt processes corresponding to interrupt factors.

  In the figure, first, an interrupt request signal INTR is detected during execution of a general task. If it is an interrupt request signal that should be dealt with immediately, the general task being executed is interrupted and the execution right is transferred to the OS (S100). The OS saves the context information of the general task in the TCB (S102) and activates the special task (S104).

  The special task analyzes the interrupt factor (S106). Since various writes to the interrupt factor register (not shown) are executed by the interrupt request signal, the interrupt factor can be specified by examining the interrupt factor register. The special task determines the interrupt process to be executed in response to the interrupt factor, and starts the interrupt process. Various system call instructions are executed in the process of interrupt processing. When the system call instruction is executed, the execution right is transferred again to the OS (S108). The OS executes the designated system call (S110). After executing the system call, the execution right is transferred again to the special task (S112). Since the interrupt process is a high-priority process, the execution right is not normally transferred to the general task unless the special task process is completed.

  The special task continues the interrupt process (S114), and when executing the system call instruction again, the execution right is transferred to the OS (S116). As described above, while the special task and the OS alternately acquire the execution right, the last execution right shifts to the special task (S118), and the special task completes the interrupt process (S120). When the interrupt process is completed, the execution right is transferred to the OS (S122), and a task switch from the special task to the general task is executed (S124). Thus, normal processing by the general task is resumed (S126).

The task processing device 100 shown in the basic example and the virtual queue implementation example differs from the software OS in that the function as the RTOS is realized by hardware logic, but the basic flow in interrupt processing is almost the same as that of the software OS. It is the same. However, as described in connection with the basic example, the task switch in S102 and S124 and the execution of system calls such as S110 are significantly faster than the software OS.
In the case of the basic example task processing apparatus 100, the CPU clock (CLK) is stopped in S100, S108, S116, and S122, and the RTOS process is executed. Further, after the CPU clock (CLK) is restarted by S104, S112, S118, and S126, the processing of the special task and the general task is executed. The special task is a task having a particularly high task priority, but is the same as the general task in that it is a context-based task that operates according to the CPU clock (CLK).

  In the HW interrupt implementation example, such interrupt processing, specifically, a part of the function of the special task is realized by hardware logic, thereby further speeding up the interrupt processing.

  The contents of the interrupt process vary, but depending on the interrupt request signal, the process contents are often simple and routine. For example, assume a situation where a general task A starts DMA transfer and waits for completion of DMA transfer. At the start of DMA transfer, the general task A executes a wait event system call and shifts to the WAIT state. When the DMA transfer is completed, a predetermined interrupt request signal is input to the task switching circuit 210 (in the basic example). The special task activated at this time executes a set event system call and sets a flag pattern indicating completion of DMA transfer in the event table 214. When the current flag pattern in the event table 214 changes, the WAIT cancellation condition for the general task A is satisfied, and the general task A shifts to the READY state. As described above, the contents of the interrupt process executed upon completion of the DMA transfer are relatively simple.

  Therefore, the task processing device 100 in the HW interrupt implementation example has a relatively simple interrupt processing content, and an interrupt request signal having a high occurrence frequency is preferably set in advance as a “high-speed interrupt request signal INTR (H)” in advance. Register. The interrupt request signals in the HW interrupt implementation example are roughly classified into two types: a high-speed interrupt request signal INTR (H) and a “normal interrupt request signal INTR (N)”.

FIG. 39 is a circuit diagram of the task processing device 100 in the HW interrupt implementation example.
The task processing apparatus 100 in the HW interrupt implementation example also includes a save circuit 120 and a task control circuit 200 in addition to the CPU 150. An interrupt circuit 450 is further added to the task processing device 100 in the HW interrupt implementation example.

  The high speed interrupt request signal INTR (H) is input to the interrupt circuit 450. The configuration of the interrupt circuit 450 and the processing method of the high-speed interrupt request signal by the interrupt circuit 400 will be described later. As in the basic example, the normal interrupt request signal INTR (N) is directly input to the task switching circuit 210 and is interrupted by a special task. Interrupt processing for a high-speed interrupt request signal (hereinafter referred to as “high-speed interrupt processing”) is faster than interrupt processing for a normal interrupt request signal (hereinafter referred to as “normal interrupt processing”). On the other hand, in the case of normal interrupt processing, there is an advantage that details of processing contents can be flexibly defined as a special task of software. The task processing apparatus 100 in the HW interrupt implementation example uses the high-speed interrupt request signal and the normal interrupt request signal in combination to increase the speed while maintaining versatility as an RTOS.

FIG. 40 is a circuit diagram of the interrupt circuit 450.
The interrupt circuit 450 includes a signal selection circuit 452, an operation circuit 454, and a storage unit 456. The i high-speed interrupt request signals INTR (H) _0 to INTR (H) _i−1 are irregularly input to the signal selection circuit 452. A plurality of high-speed interrupt request signals INTR (H) may be input in a short period of time, or a plurality of high-speed interrupt request signals INTR (H) may be input simultaneously. The signal selection circuit 452 can temporarily store the received high-speed interrupt request signal INTR (H).

  The signal selection circuit 452 selects one high-speed interrupt request signal INTR (H) from the buffered high-speed interrupt request signal INTR (H) based on a predetermined selection rule. The selection rule here may be arbitrarily determined according to the design requirements. For example, a priority is set for each high-speed interrupt request signal INTR (H), and when a plurality of high-speed interrupt request signals INTR (H) are buffered, a high-speed interrupt request with the highest priority among them. The signal INTR (H) may be selected. Alternatively, the fast interrupt request signal INTR (H) having the oldest input timing to the signal selection circuit 452 may be selected or may be selected at random. When the high-speed interrupt request signal INTR (H) _n (n is an integer from 0 to i−1) is selected, the signal selection circuit 452 asserts the corresponding signal QINT_n.

  When QINT_n is asserted, the operation circuit 454 asserts the ISROP signal. By asserting the ISROP signal, the signal selection circuit 452 is informed that high-speed interrupt processing is in progress. When the ISROP signal is asserted, the signal selection circuit 452 does not assert the next QINT until the ISROP signal is negated. When the ISROP signal is negated, the signal selection circuit 452 can select the high-speed interrupt request signal INTR (H) to be processed next.

  When QINT_n is asserted, the operation circuit 454 also asserts ISR_RQ to request the task switching circuit 210 to execute high-speed interrupt processing. When ISR_RQ is asserted, the task switching circuit 210 stops supplying the CPU clock (CLK). Thus, the execution of the general task is stopped.

  The operation circuit 454 sets a predetermined address ADD [n] in DSC_ADD [k−1: 0] according to QINT_n, in other words, according to the selected high-speed interrupt request signal INTR (H) _n. By inputting DSC_ADD [k−1: 0] = ADD [n], the interrupt operation instruction p0 held at the address ADD [n] of the storage unit 456 is transmitted to the task switching circuit 210 as ISR_DT [31: 0]. Is done. The task switching circuit 210 executes high-speed interrupt processing according to the received interrupt operation instruction p0.

  The interrupt operation instruction in this embodiment is normalized to a 32-bit size as will be described later with reference to FIG. 42, and the most significant bit ISR_DT [31] indicates the presence or absence of a subsequent interrupt operation instruction. Note that the interrupt operation instruction may be normalized with an arbitrary size other than 32 bits, such as 64 bits and 128 bits. When the most significant bit ISR_DT [31] = 1, the task switching circuit 210 asserts ISR_NX and requests the operation circuit 454 for the subsequent interrupt operation instruction p1. The operation circuit 454 sets the address ADD [n] +1 obtained by adding one word (32 bits in the present embodiment) to the address ADD [n], to DSC_ADD [k−1: 0]. The interrupt operation instruction p1 held at the address ADD [n] +1 is transmitted to the task switching circuit 210 as ISR_DT [31: 0]. The task switching circuit 210 continues the high-speed interrupt process according to the received interrupt operation instruction p1.

When the most significant bit ISR_DT [31] = 0, the task switching circuit 210 asserts ISR_END and notifies the operation circuit 454 of completion of the high-speed interrupt processing. The operation circuit 454 negates ISROP. When ISROP is negated, the signal selection circuit 452 can select another high-speed interrupt request signal INTR (H) and newly assert QINT.
In the HW interrupt implementation example, the ISR_END signal is input to the operation circuit 454, and the operation circuit 454 negates ISROP to control the signal selection circuit 452. As a modification, the task switching circuit 210 may control the signal selection circuit 452 by transmitting the ISR_END signal directly to the signal selection circuit 452 when the high-speed interrupt processing is completed.

FIG. 41 is a data structure diagram of the storage unit 456.
The storage unit 456 in the HW interrupt implementation example is a memory. Addresses “0x000 to 0x0FF” hold an interrupt operation instruction group corresponding to the high-speed interrupt request signal INTR (H) _0. Similarly, an interrupt operation instruction group corresponding to the high-speed interrupt request signal INTR (H) _1 is held at addresses “0x100 to 0x1FF”. The interrupt operation instruction in the HW interrupt implementation example is a system call instruction. For example, when the signal selection circuit 452 selects the high-speed interrupt request signal INTR (H) _0, the operation circuit 454 sets “0x000”, which is the first address of the high-speed interrupt request signal INTR (H) _0, to DSC_ADD [k−1. : 0]. The corresponding interrupt operation instruction “systemcall_00” is transmitted from the storage unit 456 to the task switching circuit 210. Since the interrupt operation instruction “systemcall_00” includes the subsequent interrupt operation instruction “systemcall_01”, the most significant bit of the interrupt operation instruction “systemcall_00” is set to “1”. After executing the interrupt operation instruction “systemcall_00”, the task switching circuit 210 asserts ISR_NX to request a subsequent interrupt operation instruction.

  The operation circuit 454 newly designates an address “0x001” obtained by adding one word to “0x000” in DSC_ADD [k−1: 0]. From the storage unit 456, a subsequent interrupt operation instruction “systemcall_01” is transmitted to the task switching circuit 210. The most significant bit of “syscall_01” is set to “0”, and the task switching circuit 210 sets “syscall_01” as the last interrupt operation instruction as high-speed interrupt processing for the high-speed interrupt request signal INTR (H) _0. Can be recognized. When the task switching circuit 210 completes execution of the interrupt operation instruction “syscall_01”, the task switching circuit 210 asserts ISR_END to notify the end of the high-speed interrupt processing.

FIG. 42 shows the data structure of an interrupt operation instruction.
As described above, ISR_DT [31] indicates the presence / absence of a subsequent interrupt operation instruction. The type of system call is indicated by ISR_DT [30:24]. ISR_DT [30:24] = 0000001 indicates a “set event system call”. Therefore, the interrupt operation instruction 460a is a set event system call execution instruction. ISR_DT [23: 8] indicates a set flag pattern, and ISR_DT [7: 0] indicates an event ID. When task switching circuit 210 receives interrupt operation instruction 460a, task switching circuit 210 sets event table 214 by the same processing method as in the basic example.

  ISR_DT [30:24] = 0000010 indicates a “release semaphore system call”. Therefore, the interrupt operation instruction 460b is a release semaphore system call execution instruction. ISR_DT [7: 0] indicates the semaphore ID of the released semaphore. ISR_DT [30:24] = 0000011 indicates a “release wait system call”. Therefore, the interrupt operation instruction 460c is a release wait system call execution instruction. ISR_DT [4: 0] indicates the task ID of the task to be released from the WAIT state. ISR_DT [30:24] = 0000100 indicates a “wake-up task system call”. Therefore, the interrupt operation instruction 460d is an execution instruction for the wakeup task system call. ISR_DT [4: 0] indicates the task ID of the task to be released from the WAIT state. ISR_DT [30:24] = 0000101 indicates an “activation system call”. Therefore, the interrupt operation instruction 460e is an execution instruction for an activation system call. ISR_DT [4: 0] indicates the task ID of the task to be activated. Various other system calls may be registered in the storage unit 406 as interrupt operation instructions.

  The storage unit 456 may be provided as a ROM (Read Only Memory) or a readable / writable RAM (Random Access Memory). If the contents of the storage unit 456 can be rewritten by an application, the contents of the high-speed interrupt process can be changed by software.

FIG. 43 is a sequence diagram showing the process of high-speed interrupt processing.
First, the signal selection circuit 452 selects the high-speed interrupt request signal INTR (H) _n to be processed (S130), and asserts QINT_n (S132). The operation circuit 454 asserts ISROP and notifies the signal selection circuit 452 that high-speed interrupt processing is in progress (S134). When ISROP is asserted, the signal selection circuit 452 keeps buffering and does not assert QINT even if it receives a new high-speed interrupt request signal.

  On the other hand, when QINT_n is asserted, the operation circuit 454 asserts ISR_RQ and requests the task switching circuit 210 to start high-speed interrupt processing (S136). At this time, the task switching circuit 210 stops the CPU clock (CLK) and prepares for the start of high-speed interrupt processing. The operation circuit 454 specifies the address ADD [n] corresponding to QINT_n as DSC_ADD, and reads the interrupt operation instruction p0 from the storage unit 456 (S138). The interrupt operation instruction p0 is transmitted to the task switching circuit 210 as ISR_DT [31: 0] (S140).

  The task switching circuit 210 changes the setting contents of the semaphore table 212, the event table 214, and the state storage unit 220 according to the received interrupt operation command p0. More specifically, the task switching circuit 210 executes a processing process equivalent to when a general task issues a release semaphore system call (signaling semaphore system call) or a set event system call (set flag system call). Thus, the setting contents of the semaphore table 212, the event table 214, and the state storage unit 220 are changed. The processing contents of the interrupt operation instruction are the same as the processing contents of the system call instruction shown in the basic example. If “1” is set in the most significant bit of the interrupt operation instruction, the task switching circuit 210 asserts ISR_NX to request the next interrupt operation instruction p1 from the operation circuit 454 (S144). The operation circuit 454 loads the next interrupt operation instruction p1 (S146), and the interrupt operation instruction p1 is transmitted to the task switching circuit 210 (S148).

  When the task switching circuit 210 executes the last interrupt operation instruction px, that is, when executing the interrupt operation instruction px having the most significant bit set to “0”, the task switching circuit 210 asserts ISR_END. (S152). The operation circuit 454 recognizes the completion of the high-speed interrupt process and negates ISROP (S154). Thus, the signal selection circuit 452 can select the next high-speed interrupt request signal.

FIG. 44 is a state transition diagram of the task switching circuit 210 in the HW interrupt implementation example.
In the HW interrupt implementation example, in addition to the state transition diagram shown in FIG. 15, high-speed interrupt processing (A6) is added. The normal interrupt process (A3) is the same as the interrupt process (A3) shown in FIG. In addition, the configuration denoted by the same reference numerals as the basic example indicates the same processing content.

  If a high-speed interrupt request signal INTR (H) is detected during task execution (A2) (S24), ISR_RQ is asserted and high-speed interrupt processing (A6) is executed. When the interrupt circuit 400 transmits an interrupt operation command to the task switching circuit 210 (S26), the task switching circuit 210 executes a corresponding system call process (A4). When the execution of the system call instruction is completed, state transition is made to high-speed interrupt processing (A6) (S28). If there are no more interrupt operation instructions to be processed, the high-speed interrupt process is terminated (S30), and the next general task to be executed is selected (A5).

FIG. 45 is a time chart showing the process of high-speed interrupt processing by the task processing apparatus 100 of the HW interrupt implementation example.
In the figure, first, an interrupt request signal INTR is detected during execution of a general task. If the interrupt request signal is to be dealt with immediately, the general task being executed is interrupted by stopping the CPU clock (CLK), and high-speed interrupt processing by the interrupt circuit 450 and the task switching circuit 210 is started (S160). .

  The interrupt circuit 450 appropriately reads the interrupt operation instruction, and the task switching circuit 210 executes the system call instruction specified as the interrupt operation instruction. When the high-speed interrupt processing realized by a series of system calls is completed in this way (S162), the task switching circuit 210 selects the next RUN-task (S164). After the selection, the CPU clock (CLK) is restarted and normal processing by the general task is restarted (S166).

According to the task processing device 100 shown in the HW interrupt implementation example, high-speed interrupt processing can be realized at the hardware level by the cooperation of the interrupt circuit 450 and the task switching circuit 210. According to the experiments by the present inventors, it has been confirmed that the task processing device 100 in the HW interrupt implementation example further operates at about four times the speed as compared with the task processing device 100 in the basic example. By forming the storage unit 456 as a writable memory, the processing content can be set to some degree of flexibility even in high-speed interrupt processing.
{MP implementation example}

FIG. 46 is a hardware configuration diagram of a general MP system 500.
First, the configuration and problems of a general MP system 500 will be described with reference to FIGS. 46 and 47, and then the task processing device 100 in this MP implementation example will be described.

  In a general MP system 500, a plurality of CPUs 150a to 150c, a memory 502, and an interrupt circuit 506 are connected to each other via a bus 504. The memory 502 stores a software MPRTOS program. The CPU 150 incorporates a cache and a local memory. Each CPU 150 loads and executes the software MPRTOS into the built-in cache or built-in local memory as necessary. 46 and 47, a plurality of task ready lists (see FIG. 11) are prepared for each CPU 150, and a wait list such as a wait semaphore list (see FIG. 13) is prepared for all CPUs 150. . Further, it is assumed that a task is fixedly allocated to one of the CPUs 150. For example, a certain task Tn is executed only by the CPU 150a and is not executed by other CPUs.

FIG. 47 is a diagram schematically showing the data structure of the memory 502. As shown in FIG.
The memory 502 stores a program 508 and data 510. The program 508 includes a program (execution code) 512 of the software RTOS itself and a program (execution code) 514 of the task itself. Both are object codes. The data 510 includes RTOS data 516 under the management of the software RTOS, task data 518 unique to the task, and global data 522 common to all tasks. TCB is a kind of RTOS data 516, and various lists such as a task ready list and a wait list are also a kind of RTOS data 516. Global variables accessed from all tasks are stored as global data 522. Data unique to each task, such as local variables of the task (application), is stored as task data 518.

  The software MPRTOS needs to exclusively control access from the CPU to the memory 502. For example, when the CPU 1 accesses the wait system list, the CPU 2 may also access the same wait system list. The software MPRTOS exclusively controls access to the wait list using a special instruction called an atomic operation instruction.

  Specifically, when the CPU 1 accesses the wait list, first, the software MPRTOS of the CPU 1 prohibits interruption to the CPU 1. Thereby, the task switch being accessed in the CPU 1 is prohibited. Next, the software MPRTOS of the CPU 1 acquires the access right to the wait system list (lock). If the access right cannot be obtained, the CPU 1 waits while interrupts are prohibited. When the access is completed, the access right to the wait list is unlocked, and finally the interrupt inhibition is also released. In this way, the atomic operation instruction has additional execution costs (overhead) such as interrupt prohibition and release, and resource locking and unlocking. When the CPU 1 is executing an atomic operation instruction, the CPU 2 is kept waiting until the access of the CPU 1 is completed. When the access of the CPU 1 is completed, the CPU 2 accesses the wait list by a similar atomic operation instruction. In order to improve the throughput of the MP system 500, it is necessary to reduce overhead associated with atomic operation instructions.

  Exclusive control is also required when accessing a task ready list prepared for each CPU. For example, it is assumed that task T1 is being executed in CPU1, task T2a is being executed in CPU2, and task T2b is in the WAIT state. Here, it is assumed that the WAIT cancellation condition for task T2b is satisfied as a result of task T1 executing a SET system call instruction such as a release semaphore system call.

When executing the release semaphore system call, the CPU 1 is loaded with software MPRTOS. Further, the software MPRTOS of the CPU 1 checks the wait semaphore list that is a shared resource, and changes the task T2b in the WAIT from the WAIT state to the READY state. In order to change the state, the software MPRTOS of the CPU 1 needs to access the task ready list for the CPU 2. If the task priority order of the task T2b released from the WAIT state is higher than the task priority order of the task T2a currently being executed by the CPU2, the task switching is also required in the CPU2. In this case, the software MPRTOS of the CPU 1 interrupts the CPU 2. The software MPRTOS is also loaded into the CPU 2 by the interruption from the CPU 1, and the task switch from the task T2a to the task T2b is executed.
Hereinafter, an event in which a task switch occurs in the same or another CPU by executing a system call or the like in a certain CPU is referred to as “dispatch”. Since a task switch has occurred in CPU 2 due to the execution of a release semaphore system call in CPU 1, the above processing corresponds to dispatch.

  In the above example, at least (A1) MPRTOS (CPU1) accesses the wait semaphore list, (A2) MPRTOS (CPU1) accesses CPU2 task ready list, (A3) MPRTOS (CPU2) performs CPU2 task. Exclusive control with access to the ready list is required. In the case of software MPRTOS, the execution cost of exclusive control tends to increase because a plurality of CPUs may execute a plurality of software MPRTOSs simultaneously.

  According to the task processing apparatus 100 (hardware RTOS) shown in the basic example, the execution cost of the task switch can be greatly reduced as compared with a general software RTOS. In the MP implementation example, the execution cost of exclusive control is further reduced by introducing the following hardware logic.

FIG. 48 is a circuit diagram of the task processing apparatus 100 in the MP implementation example.
The task control circuit 200 in the MP implementation example is connected to a plurality of CPU0, CPU1,. A task switching circuit 530 and a processor management register 524 are added to the task control circuit 200. The CPU and the save circuit 120 are not directly connected but are connected via the processor switching circuit 530.

  A stop request signal (HR0), a write signal (WT0), and saved data are transmitted from the processor switching circuit 530 to the CPU0, and a stop completion signal (HC0) and a system call signal (SC0) are transmitted from the CPU0 to the processor switching circuit 530. And processing data is transmitted. The system call signal (SC0) is asserted when a system call instruction is executed in the CPU 0, as in the basic example. When CPU 0 executes the system call instruction, CPU 0 automatically stops. The CPU clock may be completely stopped (Stop), or the processing may be suspended (Suspend) by invalidating the CPU clock. In any case, the “CPU stop” may be a state where the CPU does not continue the task execution. When the system call signal (SC0) is asserted, the task control circuit 200 asserts a stop request signal (HR0). When the write signal (WT0) is asserted, the save data sent from the save circuit 120 is loaded into the processing register of the CPU0. Further, the processing data of the CPU 0 is always output to the processor switching circuit 530. The same applies to the other CPU1 to CPUm. The signal between the CPU and the processor switching circuit 530 is basically the same as the signal between the CPU and the task switching circuit 210 in the basic example.

  A system call signal (SC), a processor notification signal (SCP), and a stop completion signal (HC) are transmitted from the processor switching circuit 530 to the task switching circuit 210, and a system call is transmitted from the task switching circuit 210 to the processor switching circuit 530. A confirmation signal (SCACK), a processor designation signal (HRP), and a write signal (WT) are transmitted.

  When the CPU 0 asserts the system call signal (SC0), the processor switching circuit 530 asserts the system call signal (SC) and the HR0 signal, and transmits the processor ID, which is the CPU ID, by the processor notification signal (SCP). When the processor switching circuit 530 asserts the system call signal (SC), the task switching circuit 210 asserts the system call confirmation signal (SCACK). In the MP implementation example, the task switching circuit 210 determines that system call processing or the like can be executed after a predetermined time has elapsed since the system call signal (SC) was transmitted. When the system call processing is completed, the SCACK signal is negated and the HR0 signal is also negated. CPU0 is restarted when the HR0 signal is negated. In the basic example, when the system call instruction is executed, the CPU clock is restarted (validated) when the write signal (WT) falls, but in the configuration shown in FIG. 48, the SCACK signal and the HR0 signal are negated. The CPU clock is restarted (validated).

  The task control circuit 200 may stop the CPU0. At this time, the task switching circuit 210 asserts the stop request signal (HR) and transmits the processor ID (0) of the CPU 0 to be stopped by the processor notification signal (HRP). The processor switching circuit 530 asserts the HR0 signal and stops the CPU0. When CPU0 stops, the HC0 signal is asserted, and further, the stop completion signal (HC) is asserted. By asserting the HC signal, the task switching circuit 210 recognizes the stop of the CPU 0 and determines that the task switch or the like can be executed. The HC signal in the MP implementation example is dedicated to the response to the HR signal.

  The processor management register 524 holds processor management information indicating the RUN task in each CPU and its task priority. Details of the processor management information will be described later with reference to FIG.

  In this embodiment as well, a task is fixedly associated with any CPU, a READY queue (described later) is prepared for each CPU, and a WAIT queue (described later) is common to all CPUs.

FIG. 49 is a data structure diagram of the MP task ID.
The task ID in the MP implementation example is called an MP task ID (MEID). The MP task ID in this embodiment is 7 bits, the upper 3 bits are the processor ID (PID), and the lower 4 bits are the task ID (EID) of the task itself. That is, a maximum of 8 CPUs and a maximum of 16 tasks can be mounted. The number of CPUs and tasks that can be mounted are defined by the sizes of PID and EID.

FIG. 50 is a data structure diagram of processor management information.
The processor management register 524 includes processor management information. In the processor management information, a task (RUN-task) executed by each CPU, task priority, and type are registered. According to FIG. 50, in CPU0 with processor ID = 0, task (E4) is being executed, task priority order PR is 0, and type is general task (N). In the CPU 2, a task (E15) which is a special task (S) is being executed. The task switching circuit 210 can access the processor management register 524 to monitor a task being executed in all CPUs in real time. In other words, all RUN-tasks are recognized at the hardware level rather than software. Part or all of the processor management information may be stored in the state storage unit 220 instead of the processor management register 524.

FIG. 51 is a conceptual diagram of the READY queue in the MP implementation example.
A virtual queue corresponding to the READY state (hereinafter referred to as “READY queue”) is prepared for each CPU. The virtual queue (QR0) is a READY queue of CPU0. As shown in FIG. 50, task (E4), task (E9), and task (E2) are being executed in CPU0, CPU1, and CPUm, respectively. The task (E1) is put in the READY queue (QR0: 0) of the CPU0.

FIG. 52 is a conceptual diagram of the WAIT queue in the MP implementation example.
A virtual queue corresponding to the WAIT state (hereinafter referred to as “WAIT queue”) is prepared in common for all CPUs. The virtual queue (QWa) is a WAIT queue for semaphore a, and the virtual queue (QWb) is a WAIT queue for semaphore b. In FIG. 52, the task (E3) is input to the WAIT queue (QWa: 0), and the task (E8) and the task (E7) are respectively stored in the WAIT queue (QWb: 0) and the WAIT queue (QWb: 1). Has been introduced. FIG. 53 is a data structure diagram of the status register corresponding to FIGS. 51 and 52. Since the RUN-task (E2) is not in the virtual queue, “Non” is set. In the MP implementation example, an order value is set for each virtual queue as in the virtual queue implementation example. As a modification, a unique sequence value that is a serial number may be set for all virtual queues. In the example of FIG. 51, the task (E1) is input to the virtual queue (QR0), the task (E0) is input to the virtual queue (QR1), and the task (E5) and the task (E6) are input to the virtual queue (QRm). Yes. If task (E1), task (E5), task (E0), and task (E6) are entered in this order, if the serial number method is used, the respective order values are 3, 2, 1, and 0. Good.

  In the MP implementation example, the MP task ID (MEID) includes a processor ID (PID) in addition to the task ID (EID). Correspondingly, the configuration of the task selection circuit 230 shown in FIG. 32 is partially changed. When the task selection circuit 230 receives an inquiry from the main circuit 400, the task selection circuit 230 specifies an extraction task (for example, the next RUN-task). In the virtual queue implementation example, the first condition for selecting the RUN-task is “READY-task”, but in the MP implementation example, it further has “designated processor ID (PID)”. The condition is added. In this MP implementation example, tasks are fixedly assigned to the CPU. For this reason, when the CPU 1 executes the task switch, only the task including the PID of the CPU 1 is a candidate for the RUN-task. Specifically, if the PID supplied from the state storage unit 220 and the PID specified by the QID supplied from the main circuit 400 do not match, the determination circuit 434 may not assert the EID_XX_EN signal. The same applies to the maximum value selection circuit 406 and the like shown in FIG. 28, and since only PID is added, substantial circuit change hardly occurs.

Next, system call processing and intercept processing of the task processing apparatus 100 corresponding to the MP system 500 will be described.
[Execute system call]

With reference to FIG. 51 and the like, it will be described that the task (E4) of the CPU 0 executes a system call instruction and a task switch from the task (E4) to the task (E1) occurs.
S1. Task (E4) executes the system call instruction, and the SC0 signal is asserted. CPU0 automatically stops.
S2. The processor switching circuit 530 asserts the HR0 signal. However, since the CPU0 has already stopped, the state of the CPU0 does not change by asserting the HR0 signal. The reason for asserting the HR0 signal is to allow the CPU 0 to recognize the negation timing of the HR0 signal later (described later).
S3. The processor switching circuit 530 also asserts the SC signal and designates processor ID = 0 in the SCP signal.
S4. The task switching circuit 210 asserts the SCACK signal. When SCACK is asserted, the processor switching circuit 530 recognizes the start of system call processing and waits until SCACK is negated. The processor switching circuit 530 connects the save circuit 120 and the CPU 0.
S5. The task control circuit 200 executes system call processing by the same process as in the basic example. When a task switch occurs in CPU0, the WT signal is asserted, and the processing data for task (E4) and the saved data for task (E1) are switched. When the system call processing is completed, the task switching circuit 210 negates the SCACK signal. The task switching circuit 210 registers the task (E1) in the processor management register 524 as a new RUN-task of the CPU0.
S6. The processor switching circuit 530 negates the HR0 signal in response to the negation of the SCACK signal. The CPU 0 resumes upon the negation of the HR0 signal, and the task (E1) is executed.
[Intercept processing]

  Proactively interrupting the CPU processing from the task control circuit 200 to generate a task switch is called “intercept”. An intercept is triggered by a timeout, interrupt, system call execution, or the like. For example, when the WAIT-task T3 times out and becomes a RUN-task immediately, the task control circuit 200 detects the timeout, stops the CPU, and executes a task switch.

First, a case where the task (E3) in the WAIT state times out will be described. It is assumed that the task (E3) is a task executed by the CPU 2 (PID = 2).
S1. The task selection circuit 230 detects the timeout of the task (E3).
S2. The task control circuit 200 executes a timeout process by the same process as in the basic example. When the task (E3) does not become a RUN-task, that is, if the task switch is unnecessary, the task (E3) is put into the READY queue of the CPU 2 and the timeout process is completed. If a task switch is necessary, the process proceeds to S3 and subsequent steps.
S3. The task switching circuit 210 asserts the HR signal and designates the CPU 2 by the HRP signal.
S4. The processor switching circuit 530 asserts the HR2 signal and stops the CPU2.
S5. CPU2 asserts the HC2 signal.
S6. The processor switching circuit 530 asserts the HC signal. The processor switching circuit 530 saves the processing data in the saving register 110, loads the saving data into the processing register 154, and performs task switching.
S7. After the task switching of the CPU 2 is completed, the task switching circuit 210 negates the HR signal.
S8. The processor switching circuit 530 negates the HR2 signal. The CPU clock of the CPU 2 is restarted and the task (E3) is executed.

The process in the interrupt process is basically the same as that in the timeout process.
The process in the high-speed interrupt request signal INTR (H) is the same as the process shown in the HW interrupt implementation example. When the normal interrupt request signal INTR (N) is received, it is necessary to activate a special task. That is, normal interrupt processing always involves an intercept (task switch). The task control circuit 200 stops the interrupt destination CPU and executes a task switch to a special task. The CPU that executes the special task may be fixed or selected according to a predetermined rule.

Interception may occur even in high-speed interrupt processing. When a task switch occurs with high-speed interrupt processing, similarly, the task control circuit 200 stops the interrupt destination CPU and executes the task switch. In the HW interrupt implementation example (SP system), the ISR_RQ signal is asserted during high-speed interrupt processing, and the CPU is stopped. However, since it is not necessary to stop the CPU in high-speed interrupt processing without an intercept (task switch), high-speed interrupt processing can be executed without stopping the CPU. According to such a processing method, task execution by the CPU and high-speed interrupt processing by the task control circuit 200 can be executed in parallel, which is more efficient. Specifically, the task switching circuit 210 does not have to assert the HR signal when it is determined that the task switch is unnecessary even when the high-speed interrupt request signal INTR (H) is detected. In application software that frequently generates a high-speed interrupt request signal INTR (H), the merit that high-speed interrupt processing can be executed simultaneously without stopping the CPU is particularly great.
[System call conflict]

  It is assumed that the task (E4) of the CPU 0 executes the system call instruction and immediately after that, the task (E9) of the CPU 1 also executes the system call instruction. Both CPU0 and CPU1 stop. In addition, the SC0 signal and the SC1 signal are transmitted. The processor switching circuit 530 first responds to the SC0 signal, designates CPU0 with the SCP signal, and then asserts the SC signal. The task switching circuit 210 executes the CPU 0 system call process. The processor switching circuit 530 asserts both the HR0 signal and the HR1 signal, but the system call signal (SC1) of the CPU1 is held by the processor switching circuit 530. When the CPU 0 system call processing is completed, the SCACK signal is negated, the HR0 signal is also negated, and the CPU 0 resumes. Next, the processor switching circuit 530, corresponding to the SC1 signal, designates the CPU 1 with the SCP signal and then asserts the SC signal again. The suspended system call process of CPU 1 is executed next to the system call process of CPU 0.

As described above, the plurality of system call instructions are serialized by the processor switching circuit 530. Even when task (E4) and task (E9) transmit system call signals at exactly the same time, processor switching circuit 530 may determine the execution order of system call processing according to an arbitrary rule such as random or round robin. Since the processor switching circuit 530 centrally accepts and serializes system call instructions from a plurality of CPUs, simultaneous access to shared resources such as the semaphore table 212 and the state storage unit 220 cannot logically occur. In the hardware MPRTOS by the task processing device 100, when accessing a shared resource such as the READY queue, interrupt prohibition and cancellation, and resource locking and unlocking are unnecessary.
[System call and intercept conflict]

  Assume that the task (E4) of the CPU 0 executes a system call instruction, and an intercept for another CPU 1 occurs immediately after or simultaneously. In this case, intercept is given priority. The processor switching circuit 530 stops the CPU0 and holds the system call signal (SC0). When the intercept process ends, the processor switching circuit 530 executes the suspended system call process of the CPU 0. If an intercept to another CPU occurs while the CPU 0 system call signal is on hold, the intercept process is given priority.

  On the other hand, when the task (E4) of the CPU 0 executes a system call instruction and an intercept occurs immediately or simultaneously with the same CPU 0, the system call processing is prioritized and the intercept is suspended. First, with the execution of the system call instruction, the CPU 0 stops and the HR signal and the HR0 signal are asserted. When the system call processing is completed and the SCACK signal is negated, the processor switching circuit 530 once negates the HR signal and the HR0 signal. Thereby, CPU0 restarts. Next, in response to the intercept, the HR signal and the HR0 signal are asserted again, and the CPU 0 is stopped again. In this way, intercept processing is executed.

FIG. 54 is a conceptual diagram showing the relationship between virtual queues and tasks in dispatch.
Here, a case where a task switch occurs in CPU 1 as a result of the task (E4) of CPU 0 executing a system call instruction will be described. It is assumed that the task (E8) in the WAIT queue (QWb: 0) is a task to be executed by the CPU1.

S1. It is assumed that the RUN-task (E4) of CPU0 executes a release semaphore system call. As shown in FIG. 50, the task priority PR of the RUN-task (E4) is zero. Since the task priority PR of the READY-task (E1) is also 0, the task (E4) remains a RUN-task even after the system call is executed. That is, no task switch occurs and the processor management register 524 is not updated.
S2. By executing the release semaphore system call, the WAIT-task (E8) in the WAIT queue (QWb: 0) is extracted. At this time, the task switching circuit 210 refers to the processor management register 524 and compares the task priorities of the RUN-task (E9) and the WAIT-task (E8) of the CPU1. Since the task priority of the WAIT-task (E8) is higher than the task priority of the RUN-task (E9), the task switching circuit 210 executes a task switch for the CPU1. Specifically, the CPU 1 is designated, the HR signal is asserted, and the CPU 1 is stopped.
When the task priority of the WAIT-task (E8) is equal to or lower than the task priority of the RUN-task (E9), the task switch (dispatch) is simply performed by putting the WAIT-task (E8) into the CPU 1 READY queue (QR1: 0). ) Is not required.
S3. After the CPU 1 stops, the RUN-task (E9) is put into the READY queue (QR1: 2). The processing data of the READY-task (E9) is saved from the processing register 92 to the save register 110.
S4. The WAIT-task (E8) becomes a new RUN-task. The processor management register 524 is also updated. The processing data of the task (E8) is loaded from the save register 110 to the processing register 92.

  Dispatch occurs when a task of any CPU shifts from a WAIT state to a RUN state by, for example, a SET system call such as a release semaphore system call or a set flag system call. In addition, dispatch occurs when another CPU task is forcibly RUN or STOP by an activation system call or an end system call.

FIG. 55 is a circuit diagram of the task processing device 100 when the function of the processor switching circuit 530 is incorporated in the task switching circuit 532.
The task switching circuit 532 may incorporate the function of the processor switching circuit 530. The first load selection circuit 526 included in the save circuit 120 is the same as the load selection circuit 112 in FIG. In FIG. 55, a second load selection circuit 528 is newly added.

  The task control circuit 200 shown in FIG. 55 operates when any of the SC0 to SCm signals, INTR signal, or timeout signal is asserted. The task switching circuit 532 transmits a PID signal to the second load selection circuit 528. The CPU to be controlled is specified by the PID signal. The second load selection circuit 528 connects the CPU designated by the PID signal and the save circuit 120. Of the functions of the processor switching circuit 530, the function of connecting any one of the plurality of CPUs to the save circuit 120 is realized by the second load selection circuit 528, and the other functions are realized by the task switching circuit 532.

  In the present MP implementation example, the relationship between the task and the CPU has been described as fixed, but the task ID (EID) and the processor ID (PID) may be handled separately. For example, when executing an activation system call, an arbitrary PID may be set in MEID by specifying a task ID and a processor ID. Also, a migration system call instruction for moving a task from one CPU to another CPU may be introduced. When executing this migration system call instruction, the processor ID of the MEID may be changed by specifying the task ID and the processor ID of the destination CPU. Since the execution states of all tasks are managed by the state storage unit 220 and the processor management register 524, task migration can be realized simply by rewriting data in the state storage unit 220 and the processor management register 524.

  For example, in FIG. 51, when the READY-task (E1) of CPU0 is changed to the READY-task of CPU1, the processor ID of CPU1 is set in the MEID of task (E1) and the virtual queue (QR1: 0) is set. You can put them in order. Thus, since the migration can be realized only by setting the virtual queue, in other words, only rewriting the state storage unit 220, the execution cost of the migration system call instruction is hardly generated.

Heretofore, the task processing apparatus 100 that can support the MP system 500 has been described.
The task processing apparatus 100 can greatly reduce the execution cost associated with exclusive control as well as task switching. The software MPRTOS in the general example is appropriately loaded into each CPU. In order for the software MPRTOS loaded to the CPU 1 to know the execution state of another CPU 2, the memory 502 must be accessed using an atomic operation instruction. Since the resources of the memory 502 are always used competitively, the execution cost for the adjustment tends to increase. Specifically, the overheads of prohibiting and releasing interrupts and locking and unlocking resources tend to be so large that they cannot be ignored.

  In the MP implementation example, the task control circuit 200 places many shared resources such as a READY queue and a WAIT queue under management. Furthermore, the task control circuit 200 can recognize the execution status of all RUN-tasks in real time and at the hardware level based on the processor management information. As a result, the task control circuit 200 can comprehensively manage the status data of all CPUs and all tasks. Access to resources managed by the task control circuit 200 is serialized by the processor switching circuit 530, so that additional processing for exclusive control such as interrupt prohibition and release, and resource locking and unlocking is not required. The task control circuit 200 autonomously generates various types of intercepts, and the intercepts are serialized in the same manner as system calls.

  Further, not only can tasks be simultaneously executed by a plurality of CPUs, but also high-speed interrupt processing without interception can be executed without stopping the CPU. In other words, since high-speed interrupt processing does not interrupt task execution, it is possible to further increase the speed.

Since the task control circuit 200 implements state management such as the READY queue and the WAIT queue with hardware logic, the execution cost itself of the system call processing and intercept processing is lower than that of the software RTOS. The same applies to dispatch. As a result of reducing the execution cost associated with task switching and exclusive control, power consumption is also suppressed as compared to multiprocessor control by software RTOS.
In this embodiment, the CPU has been described as a control target. However, the present invention can also be applied to other processors such as a DSP (Digital Signal Processor).

In the present embodiment, the task control circuit 200 loads and saves processing data using a WT signal, an HRP signal, or the like. In the basic example (SP system), the task control circuit 200 loads and saves processing data by asserting a WT signal, a TS signal, and the like. In the MP implementation example, the task switching circuit 210 asserts the WT signal and designates the target CPU by the HRP signal, so that the processor switching circuit 530 loads and saves processing data.
However, “saving and loading processing data by the task control circuit 200” is not limited to the case where the task control circuit 200 directly operates the processing data. For example, the task control circuit 200 may write a task switch instruction command to an external register or the like, and the monitoring software executed on the CPU 150 may detect the writing of this register and load and save processing data. In such a configuration, it is necessary to execute software for task switch execution in the CPU 150, so that it is not a complete hardware RTOS. Even so, the execution cost is much lower than that of a general software RTOS.

  In the above, this invention was demonstrated based on the Example. 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. .

Claims (9)

A task control circuit for managing execution states of a plurality of tasks executed by a plurality of processors;
When the processor executes a system call instruction, it sends a system call signal to the task control circuit,
When the task control circuit receives the first system call signal from the first processor, the task control circuit refers to the processor management information in which the processor ID of the processor and the task ID of the task being executed by the processor are registered. The first task being executed in the first processor is specified, the second task to be executed next is autonomously selected, and the processing data of the first task is processed by the first processor. The task switch of the first processor is saved from the register to a predetermined storage area, the processing data of the second task is loaded into the processing register of the first processor, and the processor management information is updated. And
The task control circuit does not change the execution right of the first task even when an interrupt event for the first processor occurs during the execution of the first task. In some cases, the task processing apparatus executes processing corresponding to the interrupt event while continuing execution of the first task. A task control circuit for managing execution states of a plurality of tasks executed by a plurality of processors;
When the processor executes a system call instruction, it sends a system call signal to the task control circuit,
When the task control circuit receives the first system call signal from the first processor, the task control circuit refers to the processor management information in which the processor ID of the processor and the task ID of the task being executed by the processor are registered. The first task being executed in the first processor is specified, the second task to be executed next is autonomously selected, and the processing data of the first task is processed by the first processor. The task switch of the first processor is saved from the register to a predetermined storage area, the processing data of the second task is loaded into the processing register of the first processor, and the processor management information is updated. And
The task control circuit suspends the second system call signal when the second processor transmits a second system call signal before the task switch in the first processor is completed, and the first processor Executing a task switch of the second processor following the task switch of:
The task control circuit does not change the execution right of the first task even when an interrupt event for the first processor occurs during the execution of the first task. In some cases, the task processing apparatus executes processing corresponding to the interrupt event while continuing execution of the first task.   When the task control circuit changes the execution state of the third task scheduled to be executed by the first processor from the WAIT (wait) state to the READY (ready) state due to the interrupt event, the task control circuit The task processing device according to claim 1, wherein the execution of the task is continued. A task control circuit for managing execution states of a plurality of tasks executed by a plurality of processors;
A state register that holds the task and the processor ID of the processor that is the execution subject of the task in association with each other,
When the processor executes a system call instruction, it sends a system call signal to the task control circuit,
When the task control circuit receives the first system call signal from the first processor, the task control circuit refers to the processor management information in which the processor ID of the processor and the task ID of the task being executed by the processor are registered. The first task being executed in the first processor is specified, and the second task to be executed next is selected from the tasks for which the first processor is the execution subject with reference to the status register. Autonomously selecting, saving the processing data of the first task from a processing register of the first processor to a predetermined storage area, and transferring the processing data of the second task to the processing register of the first processor And executing the task switch of the first processor by updating the processor management information. Task processing device that. The task control circuit includes a comparison circuit connected in multiple stages,
The comparison circuit in the first stage compares the state data of two or more tasks according to a predetermined selection condition, checks the processor ID to which the task is associated, and sets the state data of any task to the comparison circuit in the second stage Output,
An n-th (n is a natural number greater than or equal to 2) stage comparison circuit compares state data output from a plurality of comparison circuits located in the (n−1) -th stage according to the predetermined selection condition, and By outputting task status data,
The task processing apparatus according to claim 4, wherein the task specified by the last-stage comparison circuit is selected as an execution target. A task control circuit for managing execution states of a plurality of tasks executed by a plurality of processors;
When the processor executes a system call instruction, it sends a system call signal to the task control circuit,
When the task control circuit receives the first system call signal from the first processor, the task control circuit refers to the processor management information in which the processor ID of the processor and the task ID of the task being executed by the processor are registered. The first task being executed in the first processor is specified, the second task to be executed next is autonomously selected, and the processing data of the first task is processed by the first processor. The task switch of the first processor is saved from the register to a predetermined storage area, the processing data of the second task is loaded into the processing register of the first processor, and the processor management information is updated. And
The task control circuit suspends the second system call signal when the second processor transmits a second system call signal before the task switch in the first processor is completed, and the first processor A task processing apparatus for executing a task switch of the second processor subsequent to the task switch.   The task control circuit executes a task switch after stopping the first processor when the first system call signal is received, and the second processor executes the task switch before the task switch in the first processor is completed. When the second system call signal is transmitted, the second system call signal is held, and when the task switching of the first processor is completed, the first processor is restarted and the task of the second processor 7. The task processing apparatus according to claim 2, wherein a switch is executed.   The task control circuit identifies a task waiting in the READY state by referring to the state data output from a plurality of state registers, and when saving the processing data of the first task, The status data in the status register is changed from the RUN status to another status, and when the processing data of the second task is loaded, status data indicating the RUN status is set in the status register of the second task. A task processing device according to claim 1. A task control circuit for managing execution states of a plurality of tasks executed in the processor;
When the processor executes a system call instruction, it sends a system call signal to the task control circuit,
When the task control circuit receives the system call signal from the processor, the task control circuit changes the state data corresponding to the task being executed from the RUN state to another state, and the task to be executed next is changed. Autonomous selection, processing data of the task being executed is saved from the processing register of the processor to a predetermined storage area, processing data of the selected task is loaded into the processing register of the processor and the task is run Executing a task switch of the processor by changing to a state; and
The task control circuit responds to the interrupt event while continuing execution of the task even when an interrupt event occurs during the execution of the task and the task execution right does not change. A task processing device that executes processing.

Images