JP2000076081A - Task manager and program recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a task manager and a program recording medium for preventing the malfunction of program or runaway of microprocessor by detecting a specified task is to use stack areas more than previously allocated ones. SOLUTION: Before the activation of a task, a stack area initializing part 231 initializes the stack areas to be used for respective tasks and when the execution of the task is interrupted, data at the final part of the stack area used for this task are read out by a stack boundary monitoring part 2 and compared with the initialized data in the stack area so that the occurrence of overflow of tasks can be detected.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a task manager that performs an operation of sequentially switching the execution of a plurality of programs when performing multitask processing on a microprocessor.

[0002]

2. Description of the Related Art In a microprocessor incorporated in a device used in a home electric appliance, as the functions of the home electric appliance become more sophisticated, a so-called multi-task process for sequentially executing a plurality of processes in a time-sharing manner becomes necessary. Was.

As described above, switching and executing a plurality of program processes on one microprocessor is realized by using a program called a real-time OS which is generally developed and marketed by a microcomputer manufacturer or an OS manufacturer. it can. However, such a real-time OS has a high function and a large program size.
In many cases, it cannot be used due to the limitation of the RAM size. For this reason, conventionally, a device embedded program developer of a home appliance maker has developed a task manager program having a simple structure for performing only the execution switching of a plurality of programs together with a normal program, thereby realizing multitask processing. Was.

FIG. 6 shows an example of the structure of a conventional task manager. In FIG. 6, reference numeral 1 denotes an execution task selection unit that selects one task to be executed from among a plurality of tasks that are execution units of a program; 2, a task execution unit that executes the task selected by the execution task selection unit 1; A task suspending unit that suspends the task being executed, 4 to 5 are tasks A to C, which are execution units of the program, and 7 to 8 are stack areas for temporarily storing data while the tasks A to C are being executed.

[0005] In the conventional task manager configured as shown in FIG.
The task to be executed is determined from C in a predetermined order. For example, when the task to be executed is the task B, the task execution unit 2 is instructed to execute the task B. When the task execution unit 2 is instructed by the execution task selection unit 1 to execute the task B, the task B
Is executed. When a predetermined time has passed since the task B was executed by the task execution unit 2, the task execution interruption unit 3
Instructs the execution task selection unit 1 to determine the next task to execute in order to interrupt the execution of the task B and execute another task.

In this way, the task to be executed by the execution task selecting unit 1 is determined, and the task is executed by the task execution unit 2, and when this task is executed for a predetermined time, another task is executed. For this reason, the task execution interrupting unit 3 interrupts the execution of the task being executed, and a series of operations of causing the execution task selecting unit 1 to determine the next execution task is continued. It is executed sequentially.

[0007]

The task manager of the conventional configuration shown in FIG. 6 only switches the execution of tasks and does not manage the stack area used by each task. It is necessary to design a task program so that it uses only the stack area previously allocated to each task.

Normally, a stack area allocated to each task is used for temporary saving and calculation of data in each task program, and a return address and register data when each task program executes a subroutine call. Used to evacuate.

However, since it is difficult to accurately estimate the size of the stack area required for executing each task during debugging during program design and development, it is necessary to allocate a stack area of an appropriate size to each task in advance. However, the microprocessor area for embedded devices has a limited memory area, and an excessive stack area cannot be allocated.Therefore, a specific task exceeds the stack area allocated in advance and stacks other tasks. In some cases, writing is performed on the area.

[0010] Thus, in the conventional task manager,
If a specific task exceeds the allocated stack area and uses the stack area of another task, other tasks will malfunction, or in the worst case, all tasks will malfunction. Had the problem that the microprocessor would run away.

According to the present invention, in such a conventional task manager, when a specific task exceeds the allocated stack area and the stack area of another task is used, the other task malfunctions. Considering the task of causing a task or, in the worst case, all tasks to malfunction and causing the microprocessor to run away, if a particular task uses more than the pre-allocated stack space, this will be detected. It is another object of the present invention to provide a task manager and a program recording medium for preventing a malfunction of a program and a runaway of a microprocessor.

[0012]

According to a first aspect of the present invention (corresponding to claim 1), there are a plurality of tasks which are execution units of a program processing, and these tasks are processed. A task switching means for sequentially switching the execution of the task, and a stack area monitoring means for detecting that the task has written data to an area other than a pre-allocated stack area. It is a task manager characterized by the following.

[0013] The second invention (corresponding to claim 2) provides:
The stack area monitoring means includes: a stack area initializing means for initializing the stack area before activating the task; and a predetermined range from a boundary of each of the stack areas allocated to each of the tasks. When it is detected that the data is different from the data at the time when the data is initialized by the stack area initializing means, it is determined that the task has written data to an area other than the previously allocated stack area. The task manager according to the first invention, comprising a stack boundary monitoring means.

A third aspect of the present invention (corresponding to claim 3) is:
A stack boundary data storage unit configured to store data in a predetermined range from a boundary of the stack area allocated to the task when the execution of the task is interrupted after executing the task for a predetermined time; and Comparing the past data stored by the stack boundary data storage means with data corresponding to each other within a predetermined range from the boundary line of the stack area at the current time, and when detecting a difference, the task is allocated in advance. The task manager according to the first aspect of the present invention, comprising: a stack boundary monitoring unit that determines that data has been written to an area other than the specified stack area.

A fourth aspect of the present invention (corresponding to claim 4) is:
The task switching unit, when the stack area monitoring unit detects that a specific task has written data to an area other than the stack area allocated in advance,
The task manager according to the first aspect of the present invention, wherein execution of the task is stopped.

A fifth aspect of the present invention (corresponding to claim 5) is:
The task switching means writes data to an area other than the previously allocated stack area when the stack area monitoring means detects that the data has been written to an area other than the previously allocated stack area. The task manager according to the first aspect of the present invention, wherein execution of a task and all tasks whose stack areas previously allocated by the task have been rewritten are stopped.

A sixth aspect of the present invention (corresponding to claim 6) is:
The first task switching means stops execution of all tasks when the stack area monitoring means detects that data has been written to an area other than the previously allocated stack area. It is a task manager according to the invention.

A seventh aspect of the present invention (corresponding to claim 7) is:
When the stack area monitoring means detects that data has been written to an area other than the pre-allocated stack area, the task switching means stops execution of all tasks and executes a predetermined task. A task manager according to the first aspect of the present invention.

An eighth aspect of the present invention (corresponding to claim 8) is:
A program recording medium storing a program for realizing all or a part of the functions of each means described in any one of the first to eighth inventions.

[0020]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Embodiments of the present invention will be described below with reference to FIGS.

(Embodiment 1) FIG. 1 shows an embodiment of a task manager according to the present invention.
Reference numerals 0 to 212 denote tasks A to C, which are execution units of the program, 220, a task switching unit as task switching means, 230, a stack area monitoring unit, and 620, a stack area.

The task switching unit 220 includes an execution task selection unit 221 for determining a task to be executed, a task execution unit 222 for starting and resuming execution of the task, and a task execution interruption unit 223 for interrupting the task being executed. It consists of.

The stack area monitoring section 230 initializes a stack area used by each task before the start of execution of each task, and the stack area initialization section 231 and each task move to a different area beyond a predetermined stack area. The stack boundary monitoring unit 232 detects that writing has been performed.

The stack area 620 is composed of stack areas 621 to 623 used for temporarily storing data during execution of the tasks A to C, respectively. Also,
Areas 624 to 626 are stack areas 621 to 626, respectively.
23 is an area included in each area, and is a last storage area of each area in which data is written last in each area.

The task switching section 220 is an example of the task switching section of the present invention, the stack area monitoring section 230 is an example of the stack area monitoring section of the present invention, and the stack area initializing section 231 is the stack switching section of the present invention. This is an example of the area initialization unit, and the stack boundary monitoring unit 232 is an example of the stack boundary monitoring unit of the present invention.

The operation of the task manager configured as described above will be described below with reference to FIGS. 1 and 2.

FIG. 2 is a diagram showing a process flow of the task manager of FIG. In FIG. 2, the portion indicated as task n indicates that it is one of task A, task B, and task C.

The tasks to be executed are tasks A to C.
A description will be given of a case in which the execution switching is performed by repeating task A → task B → task C → task A → task B. Also, the stack areas 621 to 623 used by the tasks are assumed to be used in order from the larger address indicating the data storage location to the smaller address in each area.

First, prior to execution of each task, the stack area initialization unit 231 initializes stack areas 621 to 623 used by each task. This initialization is performed by writing the same data (for example, 0) to all of the stack areas 621 to 623.

When the initialization of the stack areas 621 to 623 by the stack area initialization unit 231 is completed, the execution task selection unit 221 determines a task to start execution in a predetermined order, and starts the task to be started first. The task ID of A is supplied to the task execution unit 222.

The task execution section 222 is an execution task selection section 2
21 according to the task ID supplied from
Is executed from the beginning.

When a predetermined execution allotted time elapses for the task A from the start of the execution of the task A, the task execution suspending unit 223
Of the task A at the time of the interruption, that is, how much the processing of the task A has been performed, and the state of the progress of the processing of the task A are saved. Whether the task is a task is supplied to the stack boundary monitoring unit 232.

When the stack boundary monitoring unit 232 receives the information that the interrupted task is the task A from the task execution interrupting unit 223, the stack area 6 used by the task A
The data written in the last area 624 in the area 21 is read out, and this data is stored in the stack area initialization unit 23.
Check if the data is different from the data when initialized by 1. Last area 6 of task A stack area
24 is the stack area initialization unit 2
If the data is different from the data initialized at step 31, the task ID of this task is registered as a stack overflow task.

When the operation of monitoring the stack area by the stack boundary monitoring unit 232 is completed, the execution task selection unit 221
Determines a task to start execution in accordance with a predetermined order, and supplies the task execution unit 222 with the task ID of the task B to be started second.

Thereafter, as shown in the processing block 10 of FIG. 2, the execution of the task B and the execution of the task C are interrupted and the execution of the task C are interrupted in the same manner as the execution of the task A and the interruption of the execution.

The activation of all of the tasks A to C is completed, and the last activated task C is executed by the task execution suspending unit 223.
When the execution is interrupted and the operation of monitoring the stack area by the stack boundary monitoring unit 232 ends, the execution task selection unit 221 sets the processing branch 20 in FIG.
Check whether all tasks have been started, and since all tasks have been started, select the task whose execution is to be resumed from each task whose execution has been interrupted, and then execute it. .

The execution task selection unit 221 first assigns the task ID of the task A, which is the task whose execution is to be resumed first, to the task execution unit 22 in a predetermined order.
Feed to 2.

The task execution section 222 is an execution task selection section 2
21 according to the task ID supplied from
Is executed from the part where the execution was interrupted. That is, the state of the task A at the time of the execution interruption stored by the task execution interruption unit 223 is restored, and the processing of the task A is executed from the part where the execution was interrupted.

In the same manner as when the execution of the task A is suspended after the start of the task A, when a predetermined execution allotted time for the task A elapses after the execution of the task A is resumed, the task execution suspending unit 223 again suspends the processing execution of task A, saves the state of task A at the time of the suspension, and stack boundary monitoring unit 232 performs a monitoring operation of the stack area.

Thereafter, as shown in the processing block 30 in FIG. 2, the execution task selection unit 221 determines the execution task, and the task execution unit 222 returns the state of the task to be resumed, and resumes the execution of this task. The task execution suspending unit 223 suspends the task being executed, and saves the state of the task at the time of the suspension.
Performs a monitoring operation of the stack area of the task whose execution has been interrupted. Thus, the execution of the tasks is sequentially switched by repeating the task A → the task B → the task C → the task A → the task B.

As described above, when the execution of each task is performed while the execution of the tasks is sequentially switched by the task manager, a specific task, for example, the task B is stored in the stack area 62 of the predetermined task B.
The operation in the case where data is written in another area beyond 2 will be described.

The task B is used as a temporary storage area for data, with respect to the stack area 622 of the task B allocated in advance, from a portion having a large address to a portion having a small address (from bottom to top in the stack region 622 in FIG. 1). The data is written toward () direction. However, when a large amount of data is written, finally, the data is written to the last area 625 in the area of the stack area 622 of the task B, and further the data writing is continued. Then, data is written to the first area of the stack area 621 of the task A.

Task B is the stack area 621 of task A.
When the data is written to the first area of the task A, the task A resumes execution. When the data temporarily stored in this part is read, the data is rewritten by the task B. It cannot be obtained, and performs wrong processing. In the worst case, task A performs abnormal processing.

In such a case, the processing branch 11 and the processing block 12 in FIG.
As shown in the processing block 32, the stack boundary monitoring unit 232 reads the data of the last area 625 in the area of the stack area 622 of the task B, and this data is the data when the stack area initialization unit 231 initializes the data. Detects that they are different, and registers the task ID of task B as a stack overflow task.

When the task B is registered as a stack overflow task, the execution task selection unit 221
Stops execution of all tasks, prevents the tasks from performing abnormal processing, and outputs a signal indicating that a stack overflow has occurred.

FIG. 3 shows a specific configuration when the task manager of the present invention shown in FIG. 1 is realized by a program operating on a general microprocessor.
Note that each component of the task manager in FIG. 1 is indicated by the same number in FIGS. 1 and 3.

In FIG. 3, 100 is a program counter, 200 is an instruction ROM, 250 is an instruction selection circuit, 30
0 is an instruction decoding circuit, 400 is an ALU, 500 is a register, 600 is a RAM, 630 is an address decoder, 64
0 is a stack pointer, 700 is a timer, 800 is an interrupt processing control circuit, 900 is a data bus, 950 is a local bus, and 1000 is an address bus.

The program counter 100 outputs the execution address data of the program to be executed and updates the execution address data. The output execution address data is supplied to the instruction selection circuit 250.

The instruction ROM 200 stores a plurality of programs each composed of an instruction code data group. Instruction R
The OM 200 includes tasks A to C (210 to 21 in FIG. 3).
2), and a task switching unit 220 which is a program for switching the execution of the tasks A and B at regular intervals.
A stack area monitoring unit 230, which is a program for monitoring a stack area used by tasks A to C, is stored.

When the execution address data is supplied from the program counter 100 to the instruction selection circuit 250, the instruction selection circuit 250 selects an instruction code corresponding to the supplied execution address data from the instruction code data stored in the instruction ROM 200. Data is selected, and the selected instruction code data is supplied to the instruction decoding circuit 300.

The instruction decoding circuit 300 includes an instruction selection circuit 250
And decodes the instruction code data supplied from the microprocessor and supplies a control signal corresponding to the instruction to each section of the microprocessor.

The register 500 includes a general-purpose register 510 for temporarily storing digital data when performing arithmetic and logical operations on digital data, and a PSW 520 in which flags indicating the operation results and the operating state of the processor are collected.

The RAM 600 is a random access memory for reading and writing digital data via the data bus 900 or the local bus 950. The RAM 600 includes a data storage area 610 and a stack area 620, and is selected by the address decoder 630 or the stack pointer 640. Writing or reading of digital data is performed on the area thus set.

The address decoder 630 is connected to the address bus 1
RAM 6 according to the address data supplied from
00 data area 610 is selected.

The stack pointer 640 is composed of a pointer register for selecting one storage area in the stack area 620 of the RAM 600, and an adder / subtractor for incrementing or decrementing the stack pointer data stored in this pointer register.
The stack pointer data is incremented or decremented by the control signal supplied from the controller.

The ALU 400 uses the general-purpose register 510 as a temporary data storage location, or makes a condition judgment based on the data of the PSW 520, thereby allowing the RAM 60
An arithmetic unit that performs arithmetic and logical operations on digital data stored in 0.

Time data is set in the timer 700 via the data bus 900, and when a time corresponding to the set time data elapses, a timer overflow signal is supplied to the interrupt processing control circuit 800. Interrupt processing control circuit 8
When the timer 700 receives a timer overflow signal from the timer 700, the program counter 100 and the ALU 40
0, an interrupt processing start signal is supplied to the register 500, the RAM 600, and the stack pointer 640, and the normal processing is forcibly interrupted to start the interrupt processing.

The operation when the task manager of the present invention shown in FIG. 1 is realized by a general microprocessor having the above components will be described below.

When the microprocessor of FIG. 3 is reset and starts operating, first, the program processing of the stack area monitoring unit 230 is executed, and the processing of the program corresponding to the stack area initialization unit 231 of FIG. 1 is performed.

That is, the program counter 100 includes a stack area initialization unit 231 stored in the instruction ROM 200 as a group of instruction code data of the microprocessor.
The start address data of the program corresponding to the stack area initialization unit 231 is repeatedly output and incremented and updated by setting the start address data of the program corresponding to the initial data to the end address data. Are sequentially supplied to the instruction selection circuit 250.

The instruction selecting circuit 250 reads from the instruction ROM 200 the instruction code of the program corresponding to the address data sequentially supplied from the program counter 100 and sequentially supplies the instruction code to the instruction decoding circuit 300.
Numeral 0 sequentially decodes the supplied instruction code and sequentially supplies a control signal corresponding to the instruction code, that is, a command signal corresponding to the operation of the stack area initialization unit 231 to each unit of the microprocessor.

In the program corresponding to the stack area initialization unit 231, the local bus 9 is transmitted from the ALU 400.
The stack area initialization data is supplied to the stack area 620 via 50, and the instruction code is described so that the initialization data is sequentially written to all the areas of the stack area 620.

Thus, the stack area initialization unit 2
When the processing of the program corresponding to S31 is executed and the initialization of the stack area 620 is completed, the task switching unit 2
The program processing corresponding to 20 is executed.

The execution of the program processing corresponding to the task switching section 220 is executed in exactly the same way as the processing of the program corresponding to the stack area initialization section 231. That is, the program counter 100 sequentially outputs the program addresses from the start address to the end address of the program corresponding to the task switching unit 220 to the instruction selection circuit 250, and the instruction selection circuit 250 supplies instruction code data corresponding to the supplied program address. From the instruction ROM 200, the instruction decoding circuit 300 decodes the instruction, and sequentially supplies a control signal to each section of the microprocessor.

In the program processing corresponding to the task switching unit 220, first, the processing corresponding to the execution task selection unit 221 is performed, and the task ID of the task A to be activated first is stored in the activation task ID storage area of the data storage area 610. I do.

Next, a program process corresponding to the task execution unit 222 is performed. In the program processing corresponding to the task execution unit 222, the task to be activated is determined to be the task A by reading the ID of the activated task stored in the activated task ID storage area of the data storage area 610.
As a result, it is known that the task to be activated first is the task A. Therefore, in the program processing corresponding to the task execution unit 222, the time data corresponding to the execution time of the task A is continuously transmitted via the data bus 900 to the timer 700.
, The pointer data indicating the stack area of the task A is set in the stack pointer 640, the start address of the program of the task A is set in the program counter 100, and the execution ends.

As described above, the program processing corresponding to the task execution unit 222 sets the start address of the task A program which is the task to be started first in the program counter 100, so that the program processing of the task A is started. Is done.

Thereafter, the program processing of the task A is sequentially executed in the same manner as when the program corresponding to the task switching section 220 is executed.

Further, since the stack pointer data indicating the stack area allocated to the task A is set in the stack pointer 640 by the program processing corresponding to the task execution section 222, reading and writing to the stack area during the execution of the task A program is performed. The data to be performed is performed on the stack area 621 of the task A in FIG.

The timer 700 supplies a timer overflow signal to the interrupt processing control circuit 800 when the execution time of the task A set by the program processing corresponding to the task execution section 222 has elapsed. Interrupt processing control circuit 80
0 indicates that when the timer overflow signal is supplied, the interrupt generation signal is transmitted to the program counter 100, the ALU 400, the register 500, the RAM 600, and the stack pointer 640.
To interrupt the processing of the task A being executed by the microprocessor and start the interrupt processing.

When the interrupt generation signal is supplied, the program counter 100 outputs to the data bus 900 the program address data stored in the program counter 100 at that time, that is, the execution program address of the task A which is the program being executed. The program address output to the data bus is supplied to the stack area 620 via the ALU 400. The stack pointer 640 decrements the stack pointer data when the interrupt generation signal is supplied, and the RAM 600 stores the program address data supplied from the ALU 400 via the local bus 950 in a stack area corresponding to the stack pointer data.

When the interrupt generation signal is supplied, register 500 outputs the data stored in PSW 520 at that time to data bus 900, and the data of PSW 520 output to this data bus is transmitted through ALU 400. The data is supplied to the stack area 620. Stack pointer 6
When the storage of the previously transmitted program address data is completed, the stack pointer data is further decremented, and the RAM 600 stores the data of the PSW 520 supplied from the ALU 400 via the local bus 950 in the stack area corresponding to the stack pointer data. To be stored.

The program counter 100 transfers the program address data of the task A being executed to the data bus 1.
00, the data at the next execution program address is changed to the address data storing the program corresponding to the task execution suspending unit 223 in FIG. 1 to be executed as the interrupt processing program, and this address data is selected by the instruction selection. By supplying the program to the circuit 250, the program corresponding to the execution suspending unit 223 is thereafter executed.

The program corresponding to the task execution suspending unit 223 first starts the activation task ID in the data storage area 610.
By reading the ID of the activation task stored in the storage area, it is determined that the task whose execution has been suspended is the task A.

Next, the program address data and the PSW 520 data at the time of the interruption of the execution of the task A, which are stored in the stack area 621 of the task A, are stored in the area managed by the task manager in the data storage area 610. Further, the data of the stack pointer at the time when the execution of the task A is interrupted is calculated, and similarly, the data storage area 610 is calculated.
It is stored in the area managed by the task manager in. In this way, the program corresponding to the task execution suspending unit 223 stores the data of the program counter 100, the PSW 520, and the stack pointer 640 when the task A is suspended in the area managed by the task manager in the data storage area 610. Then, when the execution of the task A is resumed next, the execution can be resumed from where it was interrupted.

When the program corresponding to the task execution suspending unit 223 finishes saving the data necessary for resuming the execution of the task A, the stack pointer 640 points to start the processing of the program corresponding to the stack boundary monitoring unit 232. The initial data of the PSW 520 for executing the program corresponding to the stack boundary monitoring unit 232 is stored in the stack area, the data of the stack pointer 640 is incremented, and the stack area indicated by the data of the incremented stack pointer 640 is stored. Of the stack boundary monitoring unit 232 is stored.

The program corresponding to the task execution suspending unit 223 stores the initial data of the PSW 520 when the program corresponding to the stack boundary monitoring unit 232 is executed and the start address data of the program corresponding to the stack boundary monitoring unit 232 in the stack area 620. When stored, the data of the stack pointer 640 is decremented, and an interrupt processing end command is executed to end the processing.

When the program corresponding to the task execution suspending unit 223 executes the interrupt processing end instruction, the instruction decoding circuit 3
00 to program counter 100, ALU 400, register 500, RAM 600, stack pointer 640
Is supplied with a control signal for terminating the interrupt processing, and the following series of operations are performed to terminate the interrupt processing.

When the control signal for terminating the interrupt processing is supplied,
The RAM 600 stores the data stored in the stack area pointed to by the stack pointer 640, that is, the PSW5 for executing the program corresponding to the stack boundary monitoring unit 232.
20 is output to the data bus 900, and the PSW
520 fetches and stores the PSW initial data supplied via the ALU 400 and the local bus 950.

When the PSW 520 finishes storing the PSW initial data, the stack pointer 640 increments the stack pointer data, and the stack boundary monitor 232
The RAM 600 points to the stack area where the start address data of the program corresponding to the stack boundary monitoring unit 232 stored in the stack area indicated by the stack pointer 640 is stored on the data bus 900. Supply.

The program counter 100 takes in the start address data of the program corresponding to the stack boundary monitor 232 supplied via the data bus, and outputs it to the instruction selection circuit 250.

In this way, the program corresponding to the task execution suspending unit 223 started and executed as the interrupt processing ends, and the execution of the program corresponding to the stack boundary monitoring unit 232 starts.

The program corresponding to the stack boundary monitoring unit 232 reads the ID of the activation task stored in the activation task ID storage area of the data storage area 610 in the same manner as the program corresponding to the task execution suspension unit 223. It is determined that the task whose execution has been suspended is the task A. Next, the data written in the last area 624 of the stack area 621 used by the task A, which is the task whose execution has been interrupted, is read out to the general-purpose register 510 via the data bus 900, and this data and the stack are read by the ALU 400. A comparison is made with the initialization data in the area 620 to check whether the two data are different. Then, the final area 6 in the stack area of task A
24 is different from the initialization data of the stack area 620, the data storage area 6
The task ID of this task, ie, task A, is stored in the stack overflow task ID storage area of No. 10.

The program corresponding to the stack boundary monitoring unit 232 executes the program corresponding to the execution task selection unit 221 when it has finished determining whether or not the task whose execution has been interrupted has caused a stack overflow.

Thereafter, similarly, the execution task selecting unit 2
21, the program corresponding to the task execution unit 222 is executed, the program processing of the tasks B and C is started, and the program corresponding to the task execution suspension unit 223 is changed to the task B during execution of the programs of the tasks B and C. , C is interrupted, and then the operation of executing the program corresponding to the stack boundary monitoring unit 232 is repeated.

If any task causes a stack overflow during this repetitive operation, the program corresponding to the execution task selecting section 221 stores the stack overflow task ID in the data storage area 610 before executing the task. By reading the area, it is detected that a stack overflow has occurred, and execution of all tasks is stopped.

When it is detected that a stack overflow has occurred, execution of all tasks is stopped, and processing to be executed when a stack overflow occurs (eg, initialization of a system controlled by a microprocessor, etc.) is started. By writing a program corresponding to the execution task selection unit 221 such that the device controlled by the microprocessor does not perform an abnormal operation.

As described above, the stack area initialization unit 231 initializes the stack area used by each task before the task is activated, and when the execution of the task is interrupted, the stack boundary monitoring unit 232 executes The data of the last part of the stack area to be used is read, and the overflow of the stack is detected by comparing the data with the initialization data of the stack area.

As a result, a stack overflow can be detected before a task other than this task is executed after a stack overflow occurs due to a specific task. Runaway can be prevented.

(Embodiment 2) FIG. 4 shows an embodiment of a task manager according to the present invention.
Reference numerals 0 to 212 denote tasks A to C, which are execution units of the program, 220, a task switching unit as task switching means, 230, a stack area monitoring unit, and 620, a stack area.

The task manager of the present invention shown in FIG. 4 differs from the task manager of FIG. 1 in the components of the stack area monitoring unit 230, and the task is interrupted in the stack area monitoring unit 230 of FIG. A boundary data holding unit 233 for holding the data of the start area and the last area of the stack area allocated to each task, and the boundary between the data of the start area and the last area of the stack area of each task when the task is interrupted. It is composed of a stack boundary monitoring unit 234 that compares the data with the data held by the data holding unit 233.

The stack area 620 contains tasks A to C
Are each composed of stack areas 621 to 623 used for temporarily storing data during execution.
Area 627 is the stack area 6 assigned to task A
The first area 21 and the area 624 are the last area in the stack area 621 allocated to the task A. Similarly, an area 628 and an area 625 are a head area and an end area of the stack area 622 allocated to the task B, respectively, and an area 629 and an area 626 are a head area and an end area of the stack area 623 allocated to the task C, respectively. is there.

The task switching section 220 is an example of the task switching section of the present invention, the stack area monitoring section 230 is an example of the stack area monitoring section of the present invention, and the boundary data holding section 233 is the boundary data of the present invention. It is an example of storage means,
The stack boundary monitoring unit 234 is an example of the stack boundary monitoring unit of the present invention.

The operation of the task manager configured as described above will be described below with reference to FIGS. 4 and 5.

FIG. 5 is a diagram showing a processing flow of the task manager of FIG. In FIG. 5, the part having the task n indicates that the task is one of the task A, the task B, and the task C. The tasks to be executed are tasks A to C
Task A → task B → task C
A case where execution switching is performed by repetition of → task A → task B... Will be described. Also, the stack areas 621 to 623 used by the tasks are assumed to be used in order from the larger address indicating the data storage location to the smaller address in each area.

The execution task selection unit 221 determines a task to start execution in a predetermined order, and supplies the task execution unit 222 with the task ID of the task A to be started first.

The task execution section 222 is an execution task selection section 2
21 according to the task ID supplied from
Is executed from the beginning.

When a predetermined execution allotted time elapses for the task A after the execution of the task A is started, the task A
Of the task A at the time of the interruption, that is, how much the processing of the task A has been performed, and the state of the progress of the processing of the task A are saved. Whether the task is a task is supplied to the boundary data holding unit 233.

Upon receiving information from the task execution suspending unit 223 that the suspended task is the task A, the boundary data holding unit 233 stores the data stored in the head area 627 and the last area 624 in the stack area 621 of the task A. Is stored as the boundary data of task A.

When the operation of storing the stack area boundary data of the task A by the boundary data holding unit 233 is completed, the execution task selection unit 221 determines a task to be executed according to a predetermined order, and starts the task second. The task ID of the task B is supplied to the task execution unit 222.

Thereafter, as indicated by the processing block 40 in FIG. 5, the execution of the task B and the execution of the task C are interrupted and the execution of the task C is interrupted in the same manner as the execution of the task A and the interruption of the execution.

The activation of all of the tasks A to C is completed, and the task C that has been activated last becomes the task execution suspending unit 223.
When the execution is interrupted and the operation of storing the stack area boundary data of the task C by the boundary data holding unit 233 ends, the execution task selection unit 221 determines whether all the tasks have been started as shown in the processing branch 50 of FIG. Check that all tasks have been started,
Thereafter, the task whose execution is to be resumed is sequentially selected and executed from among the tasks whose execution has been interrupted.

The execution task selection section 221 supplies the task execution section 222 with the task ID of the task A, which is the task whose execution is to be resumed first, in a predetermined order.

The task execution section 222 is an execution task selection section 2
21 according to the task ID supplied from
Is executed from the part where the execution was interrupted. That is, the state of the task A at the time of the execution interruption stored by the task execution interruption unit 223 is restored, and the processing of the task A is executed from the part where the execution was interrupted.

After the execution of the task A is resumed, when the predetermined execution allotted time has elapsed for the task A, the task A
Of the task A at the time of the interruption, that is, how much the processing of the task A has been performed, and the state of the progress of the processing of the task A are saved. Whether the task is a task is supplied to the stack boundary data holding unit 233 and the boundary monitoring unit 234.

Upon receiving information from the task execution suspending unit 223 that the suspended task is the task A, the boundary data holding unit 233 reads out only the data stored in the head area 627 in the stack area 621 of the task A. Is replaced with the data of the past head area of the task A which is already stored as the boundary data of the task A.

When the stack boundary monitoring unit 234 receives the information that the interrupted task is the task A from the task execution interrupting unit 223, the stack boundary monitoring unit 234 reads the data stored in the last area 624 of the stack area 621 of the task A, and Is different from the data of the past final area stored as the stack boundary data of the task A by the boundary data holding unit 233.

Thereafter, as shown by the processing block 60 in FIG. 5, the execution task selection unit 221 determines the execution task, and the task execution unit 222 returns the state of the task to be resumed, and resumes the execution of this task. The task execution suspending unit 223 suspends the task being executed and saves the state of the task at the time of suspension, and the boundary data holding unit 233 reads the head area of the stack area of the interrupted task to read the boundary data. Is updated, and the stack boundary monitoring unit 234 continues the operation of monitoring the stack area of the task whose execution has been interrupted. Thereby, task A
The execution of the tasks is sequentially switched by repetition of → task B → task C → task A → task B.

As described above, when the execution of each task is performed while the execution of the tasks is sequentially switched by the task manager, a specific task, for example, task B writes data in the areas 625 and 627. Will be described.

The task B serves as a temporary data storage area with respect to the stack area 622 of the task B allocated in advance, from a part having a large address to a part having a small address in the area (from the head area 628 to the last area 625).
, Data is written to the last area 625 in the area of the stack area 622 of the task B when a lot of data is written, and when the data is further written, the task B is written. The data is written to the head area 627 of the stack area 621 of A.

When the task B writes data to the head area 627 of the task A stack area, the task A resumes execution. If the task B attempts to read the data temporarily stored in this area, the task B Is rewritten, correct data cannot be obtained, and wrong processing is executed. In the worst case, task A performs abnormal processing.

Although task B has not written data in the head area 627 of the stack area of task A,
When data is written to the last area 625 of the stack area of the task B, the operation of the task A is not affected. However, if the task B further writes data to the stack area from this state, the stack area of the task A This is dangerous because the data is written in the head area 627 of.

In such a case, as shown by the processing branch 61 and the processing block 62 in FIG. 5, the stack boundary monitoring unit 234 reads out the data stored in the area 627, and this data is stored in the boundary data holding unit 233. Is compared with the stack top area data at the time of the interruption of the execution of the task A, which is stored as the stack boundary data of the task A. If the two are different, the data of the stack area 621 of the task A is rewritten by the execution of the task B. Therefore, the task IDs of task A and task B are registered as execution suspension tasks.

If the two are not different, the data stored in the area 625 is further read out, and this data is suspended by the boundary data holding unit 233 as the task B stack boundary data. When the two data are different from each other, the task ID of task B is registered as a task using all the allocated stack areas.

When the task A and the task B are registered as the execution suspension tasks, the execution task selection unit 221 executes the tasks other than the tasks registered as the execution suspension tasks when selecting the task to be executed. The task A and the task B are not executed thereafter.

As described above, when the execution of a task is interrupted, the stack boundary monitoring unit 234 outputs the data of the last area of the stack allocated to the interrupted task and the data of another task adjacent to this final data. The data in the top area of the stack is read, and the boundary data holding unit 233 reads 1
Compared with the data of the last area of the stack of this task and the data of the top area of the stack of the adjacent task saved when the task was interrupted the last time, the occurrence of stack overflow or the stack Detects the risk of overflow.

As a result, a stack overflow can be detected before a task other than this task is executed after a stack overflow has occurred by a specific task, and the state immediately before the stack overflow occurs can be detected. Therefore, it is possible to prevent abnormal processing of a task due to a stack overflow and runaway of a program.

In the above description, a case has been described in which three tasks are sequentially switched and executed. However, any number of two or more tasks can be realized in the same manner, and the obtained effects are equivalent.

In the above description, the stack area used by each task is sequentially used from the largest address indicating the data storage location to the smaller address indicating the data storage location. In both cases, the stack overflow can be detected in the same manner when the addresses indicating the data storage locations are sequentially used from the smaller address to the larger address, and the same effect can be obtained.

The predetermined range from the boundary of the stack area according to the present invention is, as in the above-mentioned embodiment, the last part of the stack area used by each task by the stack boundary monitor, that is, the boundary of the stack area. The overflow of the stack is detected by reading out part of the data, but this is not a limitation. By increasing the size of the data area to be read for overflow detection, overflow detection can be performed more reliably. In other words, it is only necessary to set the range so that the stack overflow can be reliably detected.

In the second embodiment, reference numeral 40 in FIG.
When starting the first task as in the first embodiment,
Does not detect stack overflow like this, but it hardly causes a problem in practice. In other words, the reason why the stack overflow occurs is that the task is frequently started many times and data is accumulated in the stack area in many cases. However, when the first task is started after the stack area is initialized in advance, a stack overflow is detected as in the first embodiment, and the stack is started as in the second embodiment after the second task is started. It is also possible to detect overflow.

Further, the present invention is also a program recording medium characterized by storing a program for realizing all or a part of each means for realizing the function.

[0123]

As is apparent from the above description, the present invention detects a stack overflow after a specific task causes a stack overflow and before execution of a task other than this task is performed. Therefore, it is possible to provide a task manager and a program recording medium that prevent abnormal processing of a task or runaway of a program due to stack overflow.

Further, according to the present invention, a stack overflow can be detected before a task other than this task is executed after a specific task causes a stack overflow, and furthermore, a stack overflow occurs. Since the immediately preceding state can also be detected, it is possible to provide a task manager and a program recording medium which prevent abnormal processing of a task or runaway of a program immediately before a stack overflow occurs.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a task manager according to a first embodiment of the present invention.

FIG. 2 is a diagram showing an operation flow of a task manager according to the first embodiment of the present invention.

FIG. 3 is a block diagram showing a configuration when the task manager according to the first embodiment of the present invention is realized by a general microprocessor;

FIG. 4 is a block diagram showing a configuration of a task manager according to a second embodiment of the present invention.

FIG. 5 is a diagram showing a flow of operation of a task manager according to the second embodiment of the present invention.

FIG. 6 is a block diagram showing a configuration of a conventional task manager.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Execution task selection part 2 Task execution part 3 Task execution suspension part 4-6 Tasks A-C 7-9 Stack area 100 Program counter 200 Instruction ROM 210-212 Tasks A-C 220 Task switching part 221 Execution task selection part 222 Task Execution unit 223 Task execution suspension unit 230 Stack area monitoring unit 231 Stack area initialization unit 232 Stack boundary monitoring unit 250 Instruction selection circuit 300 Instruction decoding circuit 400 ALU 500 Register 510 General-purpose register 520 PSW 600 RAM 610 Data storage area 620 Stack area 630 Address decoder 640 stack pointer 700 timer 800 interrupt processing control circuit 900 data bus 950 local bus 1000 address bus

 ──────────────────────────────────────────────────続 き Continued on the front page (72) Mitsuya Nakahara 1006 Kazuma Kadoma, Kadoma, Osaka Prefecture Matsushita Electric Industrial Co., Ltd. F-term (reference) 5B098 GA04 GA08 GC08 JJ01 JJ08

Claims (8)

[Claims] 1. A task manager for processing a plurality of tasks, which is a unit of execution of a program processing, wherein: a task switching unit for sequentially switching the execution of the tasks; and a stack area to which the tasks are allocated in advance. A stack area monitoring means for detecting that data has been written to the area. 2. The stack area monitoring means according to claim 1, wherein said stack area monitoring means initializes said stack area before activating said task, and a boundary line of each of said stack areas assigned to each of said tasks. When detecting that the data in a predetermined range is different from the data at the time when the data is initialized by the stack area initializing means, the task writes data to an area other than the previously allocated stack area. 2. The task manager according to claim 1, further comprising stack boundary monitoring means for judging that the task has occurred. 3. The stack area monitoring means stores data in a predetermined range from a boundary of the stack area allocated to the task when execution of the task is interrupted after execution of the task for a predetermined time. Boundary data storage means, comparing the past data stored by the stack boundary data storage means and corresponding data in a predetermined range from the boundary line of the current stack area,
2. The task according to claim 1, further comprising stack boundary monitoring means for judging that the task has written data to an area other than a pre-allocated stack area when the task is different. manager. 4. The task switching means, when the stack area monitoring means detects that a specific task has written data to an area other than the pre-allocated stack area, suspends execution of the task. The task manager according to claim 1, wherein: 5. When the stack area monitoring means detects that data has been written to an area other than the pre-allocated stack area, the task switching means stores the data in the area other than the pre-allocated stack area. 2. The task manager according to claim 1, wherein execution of the task in which the writing has been performed and all tasks in which the stack area allocated in advance by the task has been rewritten is stopped. 6. The task switching means, when the stack area monitoring means detects that data has been written to an area other than the previously allocated stack area,
The task manager according to claim 1, wherein execution of all tasks is stopped. 7. The task switching means, when the stack area monitoring means detects that data has been written to an area other than a pre-allocated stack area, suspends execution of all tasks and designates a task designated in advance. The task manager according to claim 1, wherein the task manager executes the performed task. 8. A program recording medium storing a program for realizing all or a part of the functions of each means according to claim 1. Description: