JP2008269579A - Multitask processor and method therefor - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a stable behavior for parallel programs. <P>SOLUTION: This multitask processing device as one embodiment of the present invention is a multitask processing device for multitask-processing a plurality of tasks divided into two or more of sections in each thereof is provided with a stable set storage part for storing stable set defined with one or more section combinations between respective tasks, a program execution state calculation part for finding a set of the sections for starting execution when executing the task in the next, in every task, and a current section of each other task different from the task hereinbefore, as a program execution state, a distance calculation part for calculating a distance between each of the program execution states and the stable set, and a task execution part for selecting the task to be executed in the next, based on each calculated distance, and for executing the selected task. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a multitask processing apparatus and method therefor, for example, to improvement of technology for supporting program development and execution of an information processing apparatus typified by a computer. More specifically, the present invention relates to a highly reliable and stable performance. This is related to the technology to develop the program.

  In order to develop a computer program, a dedicated program development support device is used to create a program source code and perform test execution, error removal (debugging), and the like. Such a program development support apparatus has dedicated functions such as an editor and a simulator for test execution, and is also called a CASE tool.

  Originally, a computer program controls the operation of the computer in accordance with the situation, so that if the input changes, the operation also changes in accordance with the contents of the program. However, there are programs that show various operations beyond the range of behaviors (assumed range) designed in advance. A program whose behavior at the time of execution is non-deterministic is called a non-deterministic program. On the other hand, a program whose behavior is uniquely determined when an input is determined as described above is called a definitive program.

A typical example of a non-deterministic program is a concurrent program. Since a parallel program cooperates while a plurality of processes operate separately, the overall operation differs depending on which part of each process is executed and at what timing. For concurrent programs, a multitasking system (also referred to as multithreading or multiprocessing) in which multiple tasks move conceptually in parallel on a single CPU, and a parallel multitasking system in which multiple tasks move physically in parallel on multiple CPUs There is. Even if the program itself does not have concurrency, non-determinism occurs in the execution order due to the timing of input from the outside, and there are programs that exhibit de facto non-determinism. For example, a sequence control (ladder, SFC) program for controlling a plant or an IF-THEN rule type program has no concept of a task, but the execution order of the rule changes at the timing of input from the outside. It may be nondeterministic.
JP-A-8-16429 Japanese Patent No. 3675623 Patent No. 3641090 Patent No. 3278588

By the way, the development work for testing and debugging a nondeterministic program typified by a concurrent program is described in documents “CE McDowell, DP Helmhold, Debugging Current Programs, ACM Computing Services, Vol.21, No.4. 1989. "is very difficult compared to definitive program development work. This is because when a conventional test / debug method is applied to a program having nondeterminism, the program has nondeterministic behavior. (1) The number of necessary test cases becomes enormous due to combinations of conditions. In addition, (2) the occurrence of the bug itself is not reproducible. Conventional approaches used to solve this problem can be classified into the following three types.
(1) Program test technology (parallel program debugger, etc.)
(2) Program verification technology (concurrent program verification, etc.)
(3) Program synthesis method (program generation from specification description by logic)
However, these approaches include
(1) A large part depends on the skill of each user (2) There is a problem that it can be applied only to a simple program such as a simplified example.

  Even in a program that has been thoroughly tested in the test process, the test process and execution environment, that is, machine performance, input timing, processing system, etc. are different during actual execution, and problems may occur due to non-deterministic behavior that did not occur in the test. Often occurs. In a system that requires high reliability such as an online system of a bank, such a bug may cause a fatal accident.

  Furthermore, not only functional defects but also unintended non-deterministic low power consumption, memory usage, and the like may exceed the expected range and cause problems as a system.

  In order to solve such problems, the present applicant has proposed hyper sequential programming as a technique for developing a highly reliable concurrent program (Japanese Patent Laid-Open No. 8-16429, Japanese Patent No. 3756623). No. 3641090, No. 3278588, U.S. Pat. No. 6,659,822, U.S. Pat. No. 6,275,980, U.S. Pat. No. 5,565,511, U.S. Pat. No. 6,067,415, U.S. Pat. This technology serializes a concurrent program, performs test execution and debugging on the program, merges only the correct execution log, and regenerates the entire concurrent program from a global state transition system that excludes the behavior that deviates from it. Is.

  However, in this technique, it is necessary to handle a state transition model having a size corresponding to the scale of the program, and it is necessary to serialize the parallel program once and generate it again. For this reason, when the concurrent program is enlarged, the entire processing amount is increased, and it is difficult to efficiently apply it.

  In addition, the present applicant has proposed a programming support apparatus using a scenario. In this technique, the execution order of each part included in a process is represented by a scenario in the form of a state transition diagram. In this scenario, nodes are connected by edges, the nodes represent the state, the edges extending from the node represent the portion of the program that can be executed from the state represented by the node, and multiple edges are output from one node. There are many cases to go. If a user deletes an invalid edge from such a scenario branch, an edge representing an appropriate execution order remains in the scenario. By embedding synchronous instructions for realizing this order in each process, the execution order recognized by the user is realized.

  However, even with this technology, it is necessary to represent the entire concurrent program including multiple processes in the form of a state transition diagram. Therefore, there is a problem that a complicated state transition diagram must be handled in proportion to a complex concurrent program. there were. In addition, there is a problem that the program becomes complicated and difficult to understand because of the synchronization instructions embedded in the program, and the capacity increases. Furthermore, when embedding a synchronous instruction in a program in this way, the synchronous instruction existing in the program from the stage of programming (coding) and the synchronous instruction newly embedded to realize the execution order as described above are mutually In order to avoid this, coding had to be done with great care.

  Further, in the existing hyper sequential programming invention, a scheduler has been proposed that prioritizes the execution of tasks that exhibit behavior included in the execution history (log). Here, the behavior included in the execution history (log) is one specific example of the “stable set” in the present invention in the sense that there is a record of movement in the past. However, with this technique, there is no concept of distance from the stable set, as it is a determination of whether or not it is included in the stable set. In fact, the technology did not work when the stable set was small and in most cases outside the stable set.

  Further, the applicant has proposed an invention of hyper sequential programming suitable for interrupt processing programming. According to this technique, in a program that uses interrupt processing, execution is tested by temporarily specifying candidate locations to be permitted for interrupt. When the user recognizes that the execution result is correct, an interrupt permission instruction is actually added to the candidate location where the correct result is generated and the surrounding area where there is no problem.

  However, this technique is cumbersome in that it is necessary to designate in advance a candidate location for which interruption is permitted. In particular, it was difficult to specify a complicated case where multiple interrupts overlapped.

  The present invention provides a multitask processing apparatus and method capable of realizing stable behavior of concurrent programs.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A stable set storage unit that stores a stable set that defines one or more combinations of sections between the tasks;
For each task, a program execution state calculation unit that obtains, as a program execution state, a set of a section that starts execution when the task is executed next and a current section of another task different from the task;
A distance calculation unit for calculating a distance between each of the program execution states and the stable set;
A task execution unit that selects and executes a task to be executed next based on each calculated distance;
Is provided.

  The multitask processing device has the effect of suppressing the transition of the execution state of the program to a state away from a state that is guaranteed in advance to exhibit a stable behavior, and the effect of suppressing the occurrence of a program defect. is there.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A storage unit for storing section feature values representing the features of the sections included in each task;
For each task, a program execution state calculation unit that obtains, as a program execution state, a set of a section that starts execution when the task is executed next and a current section of another task different from the task;
A task execution unit that selects and executes a task to be executed next based on a section feature value of a section included in each of the program execution states;
Is provided.

  In the multitask processing device, for example, using the characteristic values related to the computer resources used by the session, such as the estimated memory usage and the assumed power usage of each section, the program execution state uses the computer resources more than expected. This has the effect of suppressing transitions and the effect of suppressing the occurrence of program defects.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A stable set storage unit that stores a stable set in which one or more combinations of sections between the tasks and one or more shared resource states are defined;
For each task, a set of a section that starts executing when the task is executed next and a current section of another task different from the task is obtained as a program execution state, and each program execution state A program execution state calculation unit for identifying a shared resource used in the plurality of tasks and its state;
A distance calculation unit for calculating a distance between each of the program execution states and the state of the shared resource obtained corresponding to each of the program execution states and the stable set;
A task execution unit that selects and executes a task to be executed next based on each calculated distance;
It is provided with.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set that defines one or more sets of sections of the task and one or more shared resource states;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
Identify shared resources used in the plurality of tasks and their states in each of the program execution states;
A program execution state calculation unit that generates a plurality of sets each including a section and the state of the specified shared resource by combining each section included in the program execution state with the state of the specified shared resource;
A distance calculation unit that calculates a distance from the stable set based on the number of sets stored in the stable set storage unit among the plurality of generated sets;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
It is provided with.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set in which one or more sets of the task section and one shared resource state are defined;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
For each section included in the program execution state, a shared resource used in the section and its state are specified,
For each section included in the program execution state, the section is combined with each of the specified shared resource states to generate a plurality of sets each including a section and one specified shared resource. A calculation unit;
A distance calculation unit that calculates a distance from the stable set based on the number of sets stored in the stable set storage unit among the plurality of generated sets;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
It is provided with.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set that defines one or more sets of sections of the task and one or more shared resource states;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
For each section included in the program execution state, a shared resource used in the section and its state are specified,
For each section included in the program execution state, the section is combined with all of the specified shared resource states to generate a plurality of sets each including the section and all of the specified shared resource states. A program execution state calculation unit;
A distance calculation unit that calculates a distance from the stable set based on the number of sets stored in the stable set storage unit among the plurality of generated sets;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
It is provided with.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A stable set storage unit that stores a stable set that defines one or more pairs of sections between each of the tasks and one or more shared resource states;
For each task, a set of a section to be executed when the task is next executed and a current section of another task different from the task is obtained as a program execution state, and for each program execution state A program execution state calculation unit for identifying a state of a shared resource used in the program execution state;
A distance calculation unit for calculating a distance between each of the program execution states and a pair of the state of the shared resource obtained corresponding to each of the program execution states and the stable set;
A task execution unit that selects and executes a task to be executed next based on each calculated distance;
It is provided with.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set that defines one or more sets of individual sections of the task and one or more shared resource states;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
Specifying the state of the shared resource used by the plurality of tasks for each program execution state;
A program execution state calculation unit that generates a plurality of sets each including one section and the specified shared resource state by combining each of the sections included in the program execution state with the specified shared resource state. When,
A distance calculation unit that calculates a distance to the stable set based on the number of matches between the plurality of generated sets and the stable set;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
It is provided with.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set that defines one or more sets of individual sections of the task and one shared resource state;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
For each section included in the program execution state, specify the state of the shared resource used in the section,
For each section included in the program execution state, the section is combined with each of the specified shared resource states to generate a plurality of sets each including one section and one specified shared resource. A program execution state calculation unit;
A distance calculation unit that calculates a distance to the stable set based on the number of matches between the plurality of generated sets and the stable set;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
It is provided with.

A multitask processing device according to one aspect of the present invention includes:
A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set that defines one or more sets of individual sections of the task and one or more shared resource states;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
For each section included in the program execution state, specify the state of the shared resource used in the section,
For each section included in the program execution state, the section is combined with the specified shared resource state to generate a plurality of sets each including one section and the specified shared resource state A state calculation unit;
A distance calculation unit that calculates a distance to the stable set based on the number of matches between the plurality of generated sets and the stable set;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
It is provided with.

The multitask processing method as one aspect of the present invention includes:
A multitask processing method for multitasking a plurality of tasks each divided into two or more sections,
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
Calculating the distance between each program execution state and a stable set defining one or more combinations of sections between the tasks;
Based on each calculated distance, select the next task to perform,
Perform the selected task.

  The multitask processing method has the effect of suppressing the transition of the program execution state to a state away from a state that is guaranteed in advance to exhibit stable behavior, and the effect of suppressing the occurrence of a program defect. is there.

The multitask processing method as one aspect of the present invention includes:
A multitask processing method for multitasking a plurality of tasks each divided into two or more sections,
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
A task to be executed next is selected based on a section characteristic value representing a characteristic of a section included in each program execution state, and the selected task is executed.

  In the multitask processing method described above, for example, using the characteristic values related to the computer resources used by the session such as the estimated memory usage and the assumed power usage of each section, the execution state of the program uses the computer resources more than expected. This has the effect of suppressing transitions and the effect of suppressing the occurrence of program defects.

  According to the present invention, stable behavior in a program having nondeterminism such as a parallel program can be realized.

  Hereinafter, embodiments of the present invention will be described with reference to the drawings.

  FIG. 1 is a block diagram showing a hardware configuration of a computer system used for realizing the present embodiment.

  This computer system includes a processor 11, an I / O interface (bus) 12, a main storage device 13, an input / output device (input device and output device) 14, and an external storage device 15.

  The processor 11 executes software for realizing the functions of this embodiment. The processor 11 is used for multitask processing of a plurality of tasks under the control of an OS (Operating System). The processor 11 is connected to the I / O interface 12 and can access peripheral devices such as the main storage device 13 through the I / O interface 12.

  The main storage device 13 is a memory such as a RAM (Random Access Memory), and is used for each task to exchange information and perform a cooperative operation.

  The input / output device 14 includes a keyboard, a pointing device, and the like, and accepts input of various commands and data by the user. The input / output device 14 includes a CRT display and the like, and performs text display or graphic display. The user can operate the computer interactively using the input / output device 14.

  The external storage device 15 can write and read a program to be executed by the processor 11 and information used in the program by using a magnetic disk device or a magneto-optical disk device.

  Although this embodiment will be described mainly using a multitask computer with a single CPU as an example, a multi-CPU system as shown in FIG. 2, a parallel computer with a shared memory, a parallel computer without a shared memory, or The present embodiment can also be realized using a distributed network computer system. The multi-CPU system in FIG. 2 will be described as follows.

  This computer system has N processors 101-1, 101-2,..., 101-N, and at least one of them executes software for realizing the functions of this embodiment. In addition, each of the processors 101-1, 101-2,..., 101-N is used to execute each task of the parallel program concurrently. Each of these processors 101-1, 101-2,..., 101 -N is connected to an I / O interface 102 and accesses a peripheral device such as a shared memory (main storage device) 103 via the I / O interface 102. can do.

  The shared memory 103 is used by each task executed on each of the processors 101-1, 101-2, ..., 101-N to exchange information and perform a cooperative operation.

  The input device 104 includes a keyboard and a pointing device, and accepts various commands and data input by the user. The output device 105 includes a CRT display and the like, and performs text display or graphic display. The user can interactively operate the computer using the input device 104 and the output device 105.

  The external storage device 106 can write and read programs to be executed by the CPU and information used in the programs using a magnetic disk device, a magneto-optical disk device, or the like.

  Each function of the present embodiment is realized by software as described above, and this software produces the effects of the present embodiment by using a series of hardware resources as described above. Therefore, the configuration and type of each hardware resource may be replaced with another configuration and type that perform the same function.

  FIG. 3 is a functional block diagram of the multitask processing apparatus according to the present embodiment.

  This multitask processing apparatus implements, for example, some functions of the OS, and includes a task execution unit 21, a program execution state calculation unit 22, a stable distance calculation unit 23, and a task priority calculation unit (task selection unit) 24. The storage unit 25 is provided. The program execution state calculation unit 22, the stable distance calculation unit 23, and the task priority calculation unit (task selection unit) 24 are included in, for example, a part of the OS scheduler. The storage unit 25 is included in a part of the main storage device or the external storage device.

  This multitask processing apparatus multitasks a plurality of tasks (parallel programs). The task is executed by the task execution unit 21. A task has a state of being executed, a wait state that can be executed (executable wait state), and an event wait state that is not executable (unexecutable state). FIG. 5 shows a task state transition diagram. When a task occurs, the generated task enters an executable waiting state (stored in the execution waiting task list), and enters a running state when selected and executed as a task to be executed next. When the execution of the task in the execution state is completed, the task disappears. Further, when the task is switched when it is in the execution state, the task enters an executable wait state or transitions to an event wait state. When an event that has been waiting when a task is in an event wait state occurs, the task enters an executable wait state.

Here, each task is divided into a plurality of sections (sections). More specifically, one or more “checkpoint instructions” are inserted in advance in each task, and each task is divided into a plurality of sections by the checkpoint instruction. The part in the task where the checkpoint instruction is inserted is called a “checkpoint”. An example of task 1 and task 2 description in Java (registered trademark) language is shown below.

// Task 1
class Task1 extends Task {
private gui gui;
public Task1 (String tname, Resource r) {
super (tname, r);
System.out.println ("*** Set Up Task1 ***");}
public void run () {
int i = 0, j = 0;
while (i ++ <100) {
System.out.println ("*** Task1 running ***");
arb.check_point (this, 1); ← Checkpoint instruction
j = res.read ();
System.out.println (j);
arb.check_point (this, 2); ← Checkpoint instruction
res.write (j-1);}
System.out.println ("*** End of Task1 ***");
arb.check_point (this, 3); ← Checkpoint instruction
gui.task_panel.set_stop (this);}
public void set_gui (gui g) {
gui = g;}}
// Task 2
class Task2 extends Task {
private gui gui;
public Task2 (String tname, Resource r) {
super (tname, r);
System.out.println ("*** Set Up Task2 ***");}
public void run () {
int i = 0, j = 0;
while (i ++ <100) {
System.out.println ("*** Task2 running ***");
arb.check_point (this, 1); ← Checkpoint instruction
j = res.read ();
System.out.println (j);
arb.check_point (this, 2); ← Checkpoint instruction
res.write (j + 1);}
System.out.println ("*** End of Task2 ***");
arb.check_point (this, 3); ← Checkpoint instruction
gui.task_panel.set_stop (this);}
public void set_gui (gui g) {
gui = g;}}

  In this way, each task is divided into a plurality of sections by the checkpoint instruction. Task 1 and task 2 are each divided into four sections by three checkpoint instructions. If there is a synchronous instruction (wait, notify, etc.) in the program, the synchronous instruction may be included in the checkpoint instruction.

  A task can be expressed as a flow with sections and checkpoints. For example, task 1 can be expressed as a flow with a section (SC) and a checkpoint (CP) as shown in FIG. It is formulated that a virtual checkpoint CP0 exists at the start of the task, and the section from the start of the task to the first checkpoint is SC0. A value that identifies the current section by executing a checkpoint instruction is stored. For example, when arb.check_point (this, 1) is executed, a value (checkpoint name CP1 or section name SC1) indicating that the user is currently in the section SC1 is acquired and stored in the main storage device 13.

The execution state s of the program can be expressed by a set of checkpoints of each task passed immediately before as in the following example.
s = (cp11, cp21, cp32, cp43)
cpij: Name of the latest checkpoint that task i passed immediately before or s = (sc11, sc21, sc32, sc43)
scij: The latest section name that task i was executing immediately before

  All combinations of checkpoints between tasks (all combinations of sections between tasks) are referred to as “entire program state set S”. The execution state s of the program is one element of the entire program state set S (sεS). The program execution state s is calculated by the program execution state calculation unit 22.

  A set of checkpoint sets for each task for which a stable program state is obtained is referred to as a “stable set A”. The stable set A is a subset (S⊃A) of the entire program state set. A stable set A is given in advance. The stable set A is stored in the storage unit 25. A specific example of the stable set A will be described later.

  An index indicating how far the program execution state s (sεS) is from the stable set A is referred to as “stable distance Δ (s, A)”. The stable distance is calculated by the stable distance calculator 23. For the calculation of the stable distance, a program execution state s, a stable set A, and a distance function (distance calculation formula) Δ given in advance are used. The distance function Δ is stored in the storage unit 25. For example, when switching tasks, the stable distance calculation unit 23 extracts a set of tasks Te タ ス ク T (a set of all tasks) that can be executed at the present time. For each task included in the task set Te, The program execution state when the task is executed is acquired using the program execution state calculation unit 22. A set of program execution states acquired from each task is S′⊂S. The stable distance calculation unit 23 calculates a stable distance for each program execution state in the set S ′ using the stable set and the distance function stored in the storage unit 25. The stable distance represents a distance from a stable set of program execution states, and is defined, for example, such that the smaller the stable distance, the higher the stability. If the program execution state is included in the stable set, the distance is zero. If all program execution states belong to the stable set, this is equivalent to performing normal multitask processing. A specific example of calculating the stable distance will be described later.

  The task to be executed next by the task execution unit 21 is obtained by a task priority calculation unit (task selection unit) 24. The task priority calculation unit 24 selects a task to be executed next from the task set Te based on the stable distance obtained from each task in the task set Te. Specifically, a task that realizes a program execution state that minimizes the stable distance is selected. That is, a high priority (stable task priority) is given to a task that realizes a program execution state in which the stable distance becomes smaller. The processing of the task priority calculation unit 24 will be described with reference to FIG.

The task priority calculation unit 24 determines the next task to be executed based on the stable task priority based on the stable distance, the priority of the task specified by the programmer, and the order of the tasks arriving in the execution waiting task list. select. That is, the task priority calculation unit 24
(1) Priority specified for each task by the programmer in the program (specified task priority or second priority)
(2) Priority of each task based on stable distance (stable task priority or first priority)
(3) Order of tasks arriving on the task list waiting to be executed (priority in arrival order task)
Based on the three types of priorities, a task to be executed next is selected.

  Here, consider an execution order policy in which the priority order of (1) to (3) is (1)> (2)> (3). In this policy, as shown in FIG. 6, the tasks are stored in the waiting task list in the order of arrival, and then the tasks in the waiting task list are sorted according to the priority based on the stable distance (those with a high stable task priority). Are placed on the top side, and tasks with the same priority are placed on the top side as they arrive first), and finally sorted with the priority specified by the programmer (tasks with the same task priority specified by the programmer) In the middle, the higher the stability priority, the more it is placed on the top side). Then, the first task in the waiting task list is selected as a task to be executed next. As a result, task execution based on the above policy can be realized. There are cases other than the above in the execution order policy. For example, when more importance is attached to stability, the priority based on the stable distance may be given priority over the task priority specified by the programmer. In this case, (2)> (1)> (3).

  A specific example of the execution procedure of the multitask processing apparatus shown in FIG. Here, a multitask system on one CPU will be described. However, a multitask system on a plurality of CPUs can be expanded in the same manner as in a normal scheduler. Here, when task switching is performed only at checkpoints (including synchronous instructions) (non-preemptive multitasking) and when task switching is possible at any timing (preemptive multitasking: preemptive) Multitasking) The former has the advantage that the scheduler overhead is smaller, but has the disadvantage that it cannot handle urgent interrupt tasks.

  FIG. 7 is a flowchart illustrating an execution procedure of a scheduler (including a program execution state calculation unit 22, a stable distance calculation unit 23, and a task priority calculation unit (task selection unit) 24) in non-preemptive multitasking.

  First, the execution state of the program is extracted. Specifically, a checkpoint set s indicating the current execution section of each task is extracted (S11). Each task is considered to be in the section immediately before passing the checkpoint.

  Next, a set of tasks Te⊂T that can be executed at the present time is extracted from the set T of all tasks (S12).

  Next, for each task in the task set Te, the program execution state when the task is executed next is calculated, and the set of program execution states obtained from each Te task is S ′ ( S13).

  Next, a stable distance is calculated for each program execution state in the set S 'from a predetermined stable set and a distance function (S14). When calculating the distance, when the number of tasks in the task set Te is smaller than the number of sections of each element in the stable set (for example, when a section of a task waiting for an event is included in the element), the task set The stable distance may be calculated using only the task section in Te (for example, the section of the task waiting for an event may be ignored).

  Next, the stable task priority is calculated for each task in the task set Te based on the stable distance calculated from each program execution state (S15).

  Next, a task to be executed next is selected using (1) designated task priority, (2) stable task priority, and (3) arrival order task priority (S16). For example, if the priority order is (1)> (2)> (3), the tasks in the execution waiting task list (execution waiting queue) are sorted in the order of (3) → (2) → (1). To do. As a result of the sorting, the top of the execution waiting task list becomes a task to be executed next.

  Next, the selected task is executed until the next checkpoint is reached (until the next checkpoint instruction is executed) (S17). Thereafter, the process returns to step S11.

  A specific example of the procedure described above will be described by taking three tasks shown in FIG. 8 as an example.

  First, the execution state of the program is extracted. Specifically, a section set s = (t11, t20, t32) indicating the current execution section of each task T1 to T3 is extracted (S11). Each task T1 to T3 is considered to exist in the section immediately before passing the checkpoint.

  A set Te of tasks that can be executed at the present time is extracted (S12). Here, Te = {T1, T2, T3}.

  For each task in Te, the program execution state when the task is executed next is calculated, and the set of program execution states calculated for each task is set as S '(S13). Here, S ′ = {s1, s2, s3}, s1 = (t12, t20, t32), s2 = (t11, t21, t32), s = (t11, t20, t33).

  A stable distance is calculated for each program execution state of S ′ = {s1, s2, s3} from a previously given stable set and distance function (S14).

  Based on the stable distance of each task of Te = {T1, T2, T3}, the stable task priority of the task is calculated (S15). Here, it is assumed that T1> T2> T3.

  A task to be executed next is selected using (1) designated task priority, (2) stable task priority, and (3) arrival order task priority (S16). For example, when the priority order is (1)> (2)> (3), the tasks in the execution waiting task list (execution waiting queue) are sorted in the order of (3) → (2) → (1). As a result, the first task in the waiting task list becomes the next task to be executed. Here, it is assumed that the designated task priority is the same for each of the tasks T1, T2, and T3, and the task T1 is selected.

  The selected task T1 is executed until the next checkpoint cp13 is reached (S17). Thereafter, the process returns to step S11. At this time, the new program execution state is s1 = (t12, t20, t32).

  FIG. 9 is a flowchart for explaining the execution procedure of the scheduler in the preemptive multitasking. Here, task switching is performed at an arbitrary position in a section at an arbitrary timing based on various reasons. For example, (1) When a high-priority interrupt task occurs triggered by a signal from the outside world, etc. (2) When the task being executed enters an event wait state other than a checkpoint by the scheduler (3) When another high-priority task can be executed by the synchronization instruction (notify instruction) of the task being executed, (4) The task waiting in the timer can be executed over time There are cases. Task switching timing is specified by the scheduler. Normally, when an event such as an interrupt process occurs on the scheduler side, a flag is set, and when the flag is set, execution of the task is temporarily suspended and control returns to the scheduler. Hereinafter, the execution procedure will be described.

  First, the execution state of the program is extracted. Specifically, a checkpoint set s passed immediately before each task is extracted (S21).

  Next, a set Te of tasks that can be executed at the present time is extracted from the set T of all tasks (S22).

  Next, for each task in Te, the program execution state when the task is executed next is calculated, and a set of program execution states calculated for each task is set as S '(S23). If it is not stopped just before the checkpoint (stopped in the middle of a section), the program execution state when the task is executed does not change.

  Since steps S24 to S26 are the same as steps S14 to S16, the description thereof is omitted.

  In step S27, the task selected in step S16 is executed until a task switching instruction is received from the scheduler or until the next checkpoint is reached. Thereafter, the process returns to step S21.

  Hereinafter, specific examples of the stable set A and the stable distance will be described.

[1] Stabilization against functional failures 1
The simplest definition of a stable set is one in which the total number of tasks in a critical section (section that accesses computer resources) is 1 or less. The critical section can be automatically extracted by analyzing the program, but may be specified by the user.

Definition of stable set:
A = {s = (t1, t2, t3, t4) | sum of tasks belonging to critical section among t1, t2, t3, t4 ≦ 1}

Definition of stable distance:
Δ (s, A) = 0 if s∈A
Δ (s, A) = 1 if not s∈A

  That is, the stable set is a set of sections (a set of program execution states) in which the total number of tasks in the critical section is 1. If the program execution state to be evaluated is in the stable set, the stable distance is 0 (first value), and if not, the stable distance is 1 (second value).

  Here, the stable set can be calculated in advance and stored in the storage device (13 or 15), but it can also be calculated each time whether or not the program execution state belongs to the stable set.

  As described above, the priority of tasks whose total number of tasks entering the critical section is 1 or higher is high, and a plurality of tasks can be prevented from entering the critical section at the same time.

[2] Stabilization against functional failures 2
In this example, the total number of tasks in the critical section (section in which computer resources are accessed) is defined as the stable distance.

Definition of stable distance for program execution state s = (t1, t2, t3, t4):
Δ (s) = sum of tasks belonging to critical section among t1, t2, t3, and t4 (number of tasks)

  That is, if each section is expressed as a section feature value indicating whether it belongs to a critical section (for example, 1 for a section belonging to a critical section or 0 for a section not belonging to it), Δ (s) is a section feature in the program execution state. This corresponds to the number of sections having a value of 1.

  Here, it can be considered that there is no stable set (or an empty set), and the stable distance is calculated only from the feature amount. That is, even if there is no stable set, the function can be realized only by the stable distance calculation formula.

  As described above, task scheduling that minimizes the number of tasks entering the critical section can be performed.

[3] Stabilization against functional failures 3
In this example, the simplest stable set is defined as the sum of the number of tasks in the critical section (section accessing computer resources) being 1 or less and the sum of the number of tasks in the critical section as the stable distance. Define.

Definition of stable set:
A = {s = (t1, t2, t3, t4) | sum of tasks belonging to critical section among t1, t2, t3, t4 ≦ 1}

Definition of stable distance:
Δ (s, A) = 0 if s∈A
Δ (s, A) = sum of tasks belonging to critical section if not s∈A

  As described above, the highest priority is given to tasks whose total number of tasks entering the critical section is 0 or 1 (priorities of 0 and 1 are equal), and the number of tasks even when two or more tasks enter the critical section at the same time. It is possible to perform task scheduling that minimizes.

[4] Stabilization against functional failures using test results 1
In this example, a combination of sections that have been tested (a combination of sections that have been tested in the test stage before shipment) is defined as a stable set.

Definition of stable set:
A = {s = (t1, t2, t3, t4) | t1, t2, t3, t4 have been tested}

Definition of stable distance:
Δ (s, A) = 0 if s∈A
Δ (s, A) = 1 if not s∈A

  Here, the stable set can be calculated in advance and stored in the storage device (13 or 15). However, if the number of states is large, the memory usage may increase. A set of states (section combinations) belonging to a stable set can be efficiently expressed by a binary decision diagram (BDD). It is known that it is easy to calculate whether a given program execution state is included (s∈A) for a stable set expressed compactly in a binary decision graph (reference: Randal E. Bryant) , Symbolic Boolean manipulation with ordered binary-decision diagrams, ACM Computing Surveys, Vol.24, No.3, pp.293-318,1992.)

  As described above, task scheduling that gives priority to the tested combination can be performed.

[5] Stabilization against functional failures using test results (2)
In this example as well, as in [4], the combination of tested sections is defined as a stable set, but the definition of the stable distance is different.

Definition of stable set:
A = {s = (t1, t2, t3, t4) | t1, t2, t3, t4 have been tested}

Definition of stable distance:
Δ (s, A) = min {δ (s, s ′) | s′∈A}

  Here, δ (s, s ′) is the number of tasks that do not match between s and s ′. s is the program execution state to be evaluated, and s' is an element of the stable set. A calculation example of δ (s, s ′) is shown in FIG. For example, when s = (t11, t22, t31, t41) and one element s1 of stable set A is (t12, t22, t31, t41), there is one task that does not match between s and s1. , Δ (s, s1) = 1. Similarly, δ (s, s ′) is obtained for the other elements s2 to s7 in the stable set A, and the minimum value of the obtained seven δ (s, s ′) is the stable distance.

  As described above, task scheduling that gives priority to the tested combination can be performed.

  Hereinafter, this example will be described in more detail with reference to FIG.

  It is assumed that there are three tasks T1 to T3, and each task is in an executable wait state. That is, task set T = {T1, T2, T3}. Also, the priority (designated task priority) specified by the programmer for all three tasks is the same. Assume that there is one element of the stable set, and A = {s ′}, s ′ = (CP11, CP22, CP32). The current program execution state is s = (CP11, CP22, CP30).

  During execution of section SC11 of task T1, there is a Wait instruction, and task T1 transitions to an event waiting state, and task selection unit (scheduler) 24 executes next from tasks T2 and T3 in an executable waiting state. You have to select a task to do.

  When the task T2 is executed next, the program execution state is s = (CP11, CP21, CP30), and the stable distance from the stable set is 2 (T2 and T3 do not match).

  On the other hand, when the task T3 is executed next, the program execution state is s = (CP11, CP22, CP31), and the stable distance from the stable set is 1 (T3 does not match).

  Therefore, the scheduler selects task T3 and puts task T3 into an execution state. The task execution unit 24 executes the selected task.

  In the above example, the minimum value of the number of unmatched tasks is set as the stable distance and the task that can obtain the minimum stable distance is selected. However, the maximum value of the number of matching tasks is set as the stable distance and the maximum stable distance is obtained. May be selected.

[6] Stabilization against functional failures using test results (3)
In this example, the sum of the reciprocal of the number of tests in each section at the test stage before shipment is defined as the stable distance. (The reciprocal is used so that the stable distance decreases as the number of section tests increases. To make). It is assumed that the reciprocal of the number of tests in each section is stored in advance in a table.

Definition of stable distance for program execution state s = (t1, t2, t3, t4):
Δ (s) = sum of reciprocal number of test times of each section of t1, t2, t3, t4

  That is, by expressing the reciprocal of the number of tests in each section as a section feature value, Δ (s) is an indicator of whether or not the combination of sections is relatively well tested.

  Here, it can be considered that there is no stable set (or an empty set), and the stable distance is calculated only from the feature amount. That is, even if there is no stable set, the function can be realized only by the stable distance calculation formula.

  As described above, it is possible to preferentially select a task that realizes a program execution state in which a combination of sections is firmly tested, and to perform scheduling so as to avoid simultaneously executing sections having insufficient tests.

[7] Stabilization against performance failure In this example, the simplest definition of a stable set is a set of sections (program execution) in which power consumption or memory usage is below a certain level (α: assumed allowable amount). A set of states) is a stable set.

Here, regarding power consumption, scheduling on a plurality of CPUs is targeted. As for low power consumption task scheduling, there is a research of the University of Tokyo “Research on low power consumption task scheduling of multiprocessor” available from the following URL, but it is an ad hoc method and lacks versatility. It was.
http://www.iu-tokyo.ac.jp/edu/course/ipc/master/2005/RCAST/watanabe_r.pdf

(1) In the case of the amount of used memory, 1 (assuming a multitask system on a single CPU)
Definition of stable set:
A = {s = (t1, t2, t3, t4) | sum of estimated memory usages of t1, t2, t3, and t4 ≦ α, α is a memory usage causing no problem in the system}

Definition of stable distance:
Δ (s, A) = 0 if s∈A
Δ (s, A) = 1 if not s∈A

(2) Memory usage 2 (assuming a multitasking system on a single CPU)
Definition of stable set:
A = {s = (t1, t2, t3, t4) | total sum of estimated memory usages of t1, t2, t3, t4 ≦ α, α is a memory usage with no problem in the system}

Definition of stable distance:
Δ (s, A) = 0 if s∈A
Δ (s, A) = sum of estimated memory usage of t1, t2, t3, t4 if s∈A

  As for the estimated memory usage (section feature value), it is assumed that the maximum estimated memory usage (or estimated average memory usage) is calculated in advance for each section and stored in a table format. An example of the table is shown in FIG. For the estimated memory usage, the section is independently executed in advance to calculate the memory usage, and this is used as the estimated memory usage. Alternatively, the program is analyzed to estimate the estimated memory usage theoretically.

  As described above, the situation where the memory usage exceeds the allowable amount can be suppressed.

(3) Memory usage 3 (assuming a multitask system on a single CPU)
In this example, the total amount of memory used for each task is defined as a stable distance.

Definition of stable distance for program execution state s = (t1, t2, t3, t4):
Δ (s) = sum of estimated memory usage of t1, t2, t3, t4

  The difference from “(2) In the case of consumed memory (2)” is that the task priority is the same if the memory usage is within α in (2), whereas it is within α in (3). But tasks with low memory usage are given priority.

  As described above, it is possible to perform task scheduling that minimizes the total amount of memory usage.

(4) Case 1 of power consumption (assuming multitask system on multiple CPUs)
In a multitask system on a plurality of CPUs (two or more execution units) such as a multicore system on one chip, each task includes a plurality of tasks being executed and tasks waiting for execution as shown in FIG. It can be classified into tasks waiting for execution in the list (execution queue). At this time, the target of task switching is one CPU, and the task switching of other CPUs being executed is not performed. In FIG. 13, in order to select a task of the CPU 3, the task is selected based on the following stable set and stable distance. Note that the CPU task being executed is also included in the calculation of the total estimated power consumption.

Definition of stable set:
A = {s = (t1, t2, t3, t4) | total sum of estimated power consumption amounts of tasks executed by each CPU in t1, t2, t3, t4 ≦ α}

Definition of stable distance:
Δ (s, A) = 0 if s∈A
Δ (s, A) = 1 if not s∈A

  Here, it is assumed that the estimated power consumption (section feature value) is calculated in advance as the estimated maximum consumption (or estimated average consumption) for each section and stored in a table format. An example of the table is shown in FIG. For the estimated power consumption, the section is executed alone in advance, the power consumption is calculated, and this is used as the estimated power consumption. Alternatively, the program is analyzed to estimate the power consumption theoretically.

  As described above, the situation where the power consumption exceeds the allowable amount can be suppressed.

(5) Case 2 of power consumption (assuming multitask system on multiple CPUs)
In this example, the total estimated power consumption used in each task is defined as a stable distance.

Definition of stable distance for program execution state s = (t1, t2, t3, t4):
Δ (s) = sum of estimated power consumption of t1, t2, t3, t4

  As described above, it is possible to perform task scheduling that minimizes power consumption.

[8] Stabilization using feature values set when creating a program (1)
In many cases, the failure of the concurrent program is caused by a combination of non-main processes rather than the main process that has been thoroughly studied at the time of creation. In this example, a stable distance is defined using a main processing feature amount that distinguishes main processing from non-main processing (exception processing or the like). Specifically, the feature quantity of the section that is the main process is 0, and the feature quantity of the section that is the non-main process is 1. It is assumed that the feature amount is set by the creator at the time of creating the program and stored in a table format at the time of execution.

Definition of stable distance for program execution state s = (t1, t2, t3, t4):
Δ (s) = sum of main processing feature values of t1, t2, t3, and t4

  Here, it can be considered that there is no stable set (or an empty set), and the stable distance is calculated only from the feature amount. That is, even if there is no stable set, the function can be realized only by the stable distance calculation formula.

  As described above, task scheduling can be performed so that non-main processing is not executed at the same time.

[9] Stabilization using feature values set when creating the program (2)
A failure of a concurrent program often occurs with a combination of processes between closely intertwined tasks. In this example, the stable distance is defined with the closeness between the sections of the task set at the time of creating the program as the feature amount (section closeness feature amount). Specifically, it is assumed that the degree of closeness between all sections is set by the creator at the time of creating a program and stored in a table format at the time of execution. In reality, it is not necessary to set all the combinations, and a closeness feature amount of 0 or more may be set only when the creator is uneasy about stability, and the closeness feature amount may be set to 0 otherwise. In addition, the closeness feature amount can be automatically calculated from the degree of sharing of variables by a program analysis method. As a specific calculation method, Myers' module strength / jointness (GJMyers, Composite / Structured Design, Van Nostrand Reinhold, 1978.) can also be used.

Definition of stable distance for program execution state s = (t1, t2, t3, t4):
Δ (s) = total sum of closeness feature quantities of combinations of sections of t1, t2, t3, and t4

  As described above, task scheduling can be performed so that non-main processing is not executed at the same time.

  FIG. 14 shows a device (monitoring target device) 28 having a multitask processing device, and a remote monitoring device 30 connected to the monitoring target device 28 via a network. The remote monitoring device 30 monitors the program execution state of the monitoring target device 28, creates a stable set based on this monitoring, sends the created stable set to the monitoring target device 28, and uses it in the monitoring target device 28. Update the set. As a result, the functional and performance stability of the device can be improved in accordance with the usage status of the device after shipment. Previously, it took time to report bugs, identify bugs, and correct programs. During that time, there were problems with many devices. By removing the various program execution states from the stable set and adding execution states that have been confirmed to be stable in actual performance to the stable set, it is possible to prevent a failure from occurring in another device.

  Hereinafter, a procedure of processing performed by the monitoring target device 28 and the remote monitoring device 30 will be described. This procedure is mainly composed of the following steps 1 to 3.

Step 1: The monitoring unit 31 in the remote monitoring device 30 monitors the execution state of the program of the monitoring target device 28.

Step 2: The stable set creation unit 32 in the remote monitoring device 30 creates a revised version of the stable set based on the monitoring result.

Step 3: The stable set transmission unit 33 in the remote monitoring device 30 sends the prepared stable set revised version to the monitoring target device 28, and replaces (updates) the stable set.

  In the following, the details of each step are as follows: [1] Stabilization against functional failure No. 1, [2] Stabilization against functional failure No. 2, [4] Stabilization against functional failure using test results 1. [5] Stabilization for functional failure using test results No. 2 will be described.

  Step 1: The monitoring unit 31 in the remote monitoring device 30 monitors the program execution state of the monitoring target device 28.

  Specifically, in the program execution when the stable distance is greater than 0, the remote monitoring device 30 monitors whether a failure has occurred based on the notification from the notification unit 26 in the monitoring target device 28. Each time the task is executed when the stable distance is greater than 0, the notification unit 26 notifies the program execution state at that time and whether or not a failure has occurred. If no failure has occurred, the monitoring unit 31 extracts the notified program execution state as a stable set addition candidate s and stores it in the stable set addition candidate set SC (SC ← SC∪ {s}). On the other hand, if a failure occurs despite the stable distance being 0, it is stored in the stable set deletion candidate set NSC (NSC ← NSC∪ {s}). Here, the failure can be detected from detection of system down or hang-up, and can be automatically determined from an operation history of a reset button or the like. Alternatively, it can also be detected from a feedback operation from the user (such as pressing a failure notification button). Once registered in the stable set addition candidate collection SC, if a defect in the stable set addition candidate s is detected in the subsequent program execution, the candidate s is deleted from the SC. In the case of FIG. 11, if s2 = (CP11, CP22, CP31) of stable distance 1 is executed and no problem occurs, s2 = (CP11, CP22, CP31) is extracted and added to the set SC. Here, it is assumed that there is no addition to the stable set deletion candidate set NSC.

  Step 2: Create a revised version of the stable set based on the monitoring results.

  Specifically, a set SC of stable set addition candidates accumulated in a specified period is added to the original stable set A to create a revised version A ′ of the stable set (A ′ ← A ← SC). In the case of FIG. 11, A ′ = {s2}. Here, for simplicity of explanation, the original stable set A is assumed to be an empty set. When there is a stable set deletion candidate set NSC, a thing (A ′ ← A−NSC) obtained by deleting the NSC from the stable set is set as a revised version A ′.

  Step 3: The created stable set revision is sent to the monitoring target device 30, and the update unit 27 in the monitoring target device 30 replaces the stable set.

  Specifically, the stable set A of the monitoring target device 30 is replaced with a stable set revised version A ′.

  In the case of FIG. 11, A is replaced with A '= {s2}. After the replacement, s2 = (CP11, CP22.CP31) has a stable distance of zero.

  In the above example, the stable set is updated. However, the stable distance can be updated instead of the stable set.

  In the above example, there is one monitoring target device. FIG. 15 shows an example in which a plurality of monitoring target devices are monitored by one remote monitoring device and a stable set for updating is created.

  Step 1: The monitoring unit 31 in the remote monitoring device 30 monitors the program execution state of each monitored device 28, and in the same manner as described above, for each monitored device 28, stable set addition candidate sets SC1, SC2, SC3, and The stable set deletion candidate sets NSC1, NSC2, and NSC3 are calculated.

  Step 2: Create a revised version of the stable set based on the monitoring results.

  Specifically, the common set of stable set addition candidate sets SC1, SC2, SC3 calculated for each monitored device 28 is defined as a stable set addition candidate set SC, and the union of stable set deletion candidate sets NSC1, NSC2, NSC3 Is a stable set deletion candidate set NSC. A stable set revision (A ′ = (A∪SC) −NSC) is calculated from SC and NSC. As another calculation method, there is a method in which when there are the same addition / deletion candidates from N or more remote monitoring apparatuses, they are designated as SC or NSC.

  Step 3: The created stable set revision is sent to each monitoring target device 28, and the updating unit 27 in the monitoring target device 30 replaces the stable set.

  In the examples so far, the stable set has been defined with the program execution state as an element, but a section execution sequence or a set of an executable task set and a selected task may be a stable set. This will be described below in [10] and [11].

[10] Stabilization using a tested section execution sequence In this example, a tested section execution sequence is defined as a stable set. For example, when a section ti1 executed in the immediately preceding program execution state s1 and a section ti2 executed in the next program execution state s2, the section execution sequence that has been tested is accumulated at the time of testing and stored in a table format at the time of execution. Suppose that In this example, the length of the section execution sequence is 2, but two or more sequences may be stored.

Definition of stable set:
A = {t11t12, t21t22, t31t32, t41t42}, t11t12, t21t22, t31t32, and t41t42 are tested section execution sequences.

Definition of stable distance:
Δ (s2, A) = 0 if ti1tj2∈A, ti1 is the section executed at s1, ti2 is the section executed at s2, Δ (s2, A) = 1 if ti1tj2∈A, ti1 is executed at s1 Section, ti2 is the section executed in s2

  As described above, it is possible to perform task scheduling that gives priority to a section execution sequence that has been tested.

  FIG. 16 shows the execution procedure of the scheduler when the tested section execution sequence is a stable set. First, the program execution state s1 is extracted (S31), then the currently executable task set Te is extracted (S32), and the program execution state s2 is calculated for each task in the task set Te (S33). Based on the above definition, a stable distance is calculated from s1 and each program execution state s2 (S34). Based on the stable distance calculated from each program execution state s2, a stable task priority is calculated for each task in the task set Te (S35). Task scheduling is performed based on stable task priority.

[11] Stabilization using a tested executable task set and a selected set of tasks In this example, an executable task set (a set of tasks waiting for execution) and a selected set of tasks are set as a stable set. Define as For example, when a task set SS that can be executed in the previous program execution state s1 and a section sc that is executed in the next program execution state s2, (SS, sc) is a set of the executable task set and the selected task. To do. Assume that a set of the testable executable task set and the selected task is accumulated at the time of testing and stored in a table format at the time of execution.

Definition of stable set:
A = {(SS, sc) | SS and sc have been tested}.

Definition of stable distance:
A set of executable task sets SS of Δ (s2, A) = 0 if s1 and section sc selected by s2 is included in A.
A set of executable task set SS of if (s2, A) = 1 if s1 and section sc selected by s2 is not included in A.

  As described above, it is possible to perform task scheduling that preferentially selects a task that matches the tested task selection pattern.

  FIG. 17 shows an execution procedure of the scheduler when a set of tested executable task sets and selected tasks is a stable set. First, the program execution state s1 is extracted (S41), then the currently executable task set Te is extracted (S42), and the program execution state s2 is calculated for each task in the task set Te (S43), The task set Te is determined as the set SS of executable tasks in s1, and the section to be executed in each program execution state s2 is determined as sc (S44). A stable distance is calculated using the program execution state SS and each sc, and a stable task priority is calculated for each task in the task set Te (S45). Task scheduling is performed based on stable task priority.

  Hereinafter, stabilization considering shared resources (for example, variables shared between tasks, structured data, or objects) will be described in [12] to [15].

[12] Stabilization using task state (section) and shared resources (1)
Stable combination of multiple task states and multiple shared resource states s = (ts, rs), where multiple task states (sections) have been tested against multiple shared resource states Define as a set. Normally, the combination s = (ts, rs) of all task states and all shared resources is a stable set, but tasks and shared resources that do not need to be considered from the viewpoint of reliability are excluded. Also good.

Definition of stable set:
A = {(ts, rs) | (ts, rs) tested}
Here, ts = (t1, t2, t3,...), Rs = (r1, r2, r3,...). ts is a set of task states (sections) (ti is the state of task i), and rs is a set of shared resource states related to ts (ri is the state of shared resource i). ts corresponds to the program execution state.

Definition of stable distance:
Δ (s, A) = 0 if s∈A,
Δ (s, A) = 1 if s∈A is not shown. In the example of the stable distance, whether the state (s1i, s2j, s3k, r1l, r2m) has been tested in the example of task and shared resource shown in FIG. It is determined whether or not (belongs to stable set A).

  Details of the task selection process using the stable set defined in this example are the same as those in the flowchart of FIG. 7 or FIG.

  However, in step S13 or S23, in addition to the program execution state, the state of the shared resource used in this program execution state is obtained. In step S14 or S24, the distance between the obtained set of program execution state and shared resource state and the stable set is calculated according to the above definition.

[13] Stabilization using task state and shared resources (2)
A combination of a plurality of task states and a plurality of shared resource states such that each task state (section) has been tested for a plurality of shared resource states is a stable set s = (ts, rs ). Normally, the combination s = (ts, rs) of all task states and all shared resources is a stable set, but tasks and shared resources that do not need to be considered from the viewpoint of reliability are excluded. Also good.

Definition of stable set:
A = {(ts, rs) | (ti, rs) tested for each ti of ts}
Here, ts = (t1, t2, t3,...), Rs = (r1, r2, r3,...). ti∈ {t1, t2, t3...} represents a task state, and rs represents a set of shared resource states. That is, while the embodiment [12] defines a stable set depending on whether or not a set of tasks and a set of shared resources has been tested, in this embodiment, a set of task states and a set of shared resources. A stable set is defined by whether or not it has been tested.

Definition of stable distance:
Δ (s, A) = 0 if s∈A,
Δ (s, A) = (number of tasks) − (number of tasks for which (ti, rs) has been tested) if s∈A is not shown. In the example shown in FIG. 18, in the example shown in FIG. , s2j, s3k, r1l, r2m) to obtain (s1i, r1l, r2m) (s2j, r1l, r2m) (s3k, r1l, r2m), and determine whether each has been tested. If only one has been tested, the stable distance is the number of tasks 3-1 = 2. However, as preparation, (ts, rs) that have been tested are acquired in advance from the execution log at the time of testing, and this is decomposed into a plurality of (ti, res) and stored in the list L. The stable set is a logical concept, and in an actual algorithm, if the stable distance is zero, it is included in the stable set.

  Details of the task selection process using the stable set defined in this example are the same as those in the flowchart of FIG. 7 or FIG.

  However, in step S13 or S23, in addition to the program execution state, the states of a plurality of shared resources are obtained.

  In step S14 or S24, a plurality of sets are generated by combining individual sections (task states) included in the obtained program execution state with the obtained shared resource state. Then, the number of pairs that are not included in the list L among the plurality of generated pairs (may be the number of matches between the plurality of generated sets and the list L) is calculated as a stable distance.

  In step S15 or S25, it is assumed that a high stable task priority is given in the priority order that (ti, rs) of the selected task has been tested and that the stable distance is small.

[14] Stabilization using task state and shared resources (3)
For each task state, a combination of a plurality of task states and a plurality of shared resource states is defined as a stable set such that the state of each shared resource related to each task has been tested. Here, that a task is related to a shared resource means that the task uses (refers to, updates, etc.) the shared resource.

Definition of stable set:
A = {(ts, rs) | (ti, rik) tested for each resource rik∈ {r1, r2, r3, ...} related to each ti and task i of ts}
Here, ts = (t1, t2, t3,...), Rs = (r1, r2, r3,...). ti∈ {t1, t2, t3 ...} is the state of task i, {ri1, ri2, ri3, ...} is a set of shared resource states related to state ti, rik∈ {ri1, ri2, ri3, ...} Indicates the state of each shared resource related to the state ti.

Definition of stable distance:
Δ (s, A) = (number of tasks and associated shared resources)-(number of tasks for which (ti, rik) has been tested)
In the example shown in FIG. 18, the state (s1i, s2j, s3k, r1l, r2m) is decomposed to obtain (s1i, r1l) (s2j, r1l) (s2j, r2m) (s3k, Acquire four sets of r2m) and determine whether each has been tested. If only one has been tested, the stable distance is the number of pairs 4-1 = 3. However, as preparation, (ts, rs) that have already been tested are acquired from the execution log at the time of testing, and this is decomposed into a plurality of (ti, rik) and stored in the list L. The stable set is a logical concept, and in an actual algorithm, if the stable distance is zero, it is included in the stable set.

  Details of the task selection process using the stable set defined in this example are the same as those in the flowchart of FIG. 7 or FIG.

  However, in step S13 or S23, in addition to the program execution state, the state of the shared resource related to the state of each task is obtained.

  In step S14 or S24, a plurality of sets are generated by combining individual sections (task states) included in the obtained program execution state with corresponding individual shared resource states. Then, the number of sets that are not included in the list L (may be the number of matches between the plurality of generated sets and the list L) among the plurality of generated sets is obtained as the stable distance.

  In step S15 or S25, for the selected task i, the priority order that the pair (ti, rki) of the task i state ti and the state of the shared resource related to the task i has been tested and that the stable distance is small Therefore, a high stable task priority is given.

[15] Stabilization using task state and shared resources (4)
For each task state, a combination of a plurality of task states and a plurality of shared resource states such that the states of the plurality of shared resources related to each have been tested is a stable set s = (ts, rs ).

Definition of stable set:
A = {(ts, rs) | (ti, rsi) has been tested for the state rsi⊂rs of the set of shared resources related to each ti and task i of ts}
Here, ts = (t1, t2, t3,...), Rs = (r1, r2, r3,...), Rsi = (ri1, ri2, ri3,...). ti∈ {t1, t2, t3 ...} is the task state, rsi⊂rs is the set of shared resource states related to the state ti (ie, rsi is a subset of rs), rik (= ri1, ri2, ri3 , ...) indicates the state of each shared resource included in rsi.

Definition of stable distance:
Δ (s, A) = (number of tasks)-((ti, rsi) is the number of tested tasks)
An example of calculating the stable distance is as follows. In the example shown in FIG. 18, the state (s1i, s2j, s3k, r11, r2m) is decomposed (s1i, r11) (s2j, r1l, r2m) (s3k, r2m) Are obtained, and it is determined whether each has been tested. If only one has been tested, the stable distance is the number of pairs 4-1 = 3. However, as preparation, (ts, rs) that have been tested are acquired in advance from the execution log at the time of testing, and this is divided into a plurality of (ti, rsi) and stored in the list L. The stable set is a logical concept, and in an actual algorithm, if the stable distance is zero, it is included in the stable set.

  Details of the task selection process using the stable set defined in this example are the same as those in the flowchart of FIG. 7 or FIG.

  However, in step S13 or S23, in addition to the program execution state, the state of the shared resource related to each task is obtained.

  In step S14 or S24, a plurality of sets are generated by combining each section (task state) included in the obtained program execution state with one or more corresponding shared resource states. Then, the number of sets that are not included in the list L (may be the number of matches between the plurality of generated sets and the list L) among the plurality of generated sets is obtained as the stable distance.

  In step S15 or S25, it is assumed that a high stable task priority is given in the priority order that (ti, rsi) of the selected task has been tested and that the stable distance is small.

[16] Stabilization using observationally invariant [12] to [15] explained the stabilization using the task state and shared resources, but the tested shared resources are aggregated. Often, the number of aggregations increases explosively and is often not realistic. Therefore, in this example, the characteristics of the tested task state and shared resource state are acquired as observation invariant conditions in a macro manner, and stabilization is achieved based on the acquired observation invariant conditions.

  Here, the observation invariant (likely invariant) is the invariant extracted from the log (program execution state history) when a program (including multiple tasks) is executed for a test case prepared in advance. (Conditions that are always satisfied in the execution log). For example, there are conditions that hold for variables, conditions that hold between variables, and the former example includes X = 1, 0 <X <100, X! = Null for variable X. In addition, Daikon (http: //people.csail.mit.edu.mernst/pubs/daikon-tool-scp2007.pdf), Agitor developed by M. Ernst's research group at Massachusetts Institute of Technology Agitator (http://www.agitar.com/) can be used.

  In this example, the state (section) of each task and the state of the shared resource (for example, variable or object) related to each state satisfy the observation invariant condition, and the multiple shared states The combination with the resource state is defined as a stable set.

Definition of stable set:
A = {(ts, rs) | (ti, rsi) satisfies the observation invariance condition for each ti of ts}
Here, ts = (t1, t2, t3,...), Rs = (r1, r2, r3,...), Rsi = (ri1, ri2, ri3,...). ti∈ {t1, t2, t3 ...} is the task state, rsi⊂rs is the set of shared resource states related to the state ti (ie, rsi is a subset of rs), rik (= ri1, ri2, ri3 , ...) indicates the state of each shared resource included in rsi.

Definition of stable distance:
Δ (s, A) = (number of tasks)-((ti, rsi) is the number of tasks that satisfy the observation invariant)
In actual calculation, as preparation, the observation invariant condition of the shared variable at each ti is calculated from the execution log and stored in the list L. Then, based on the list L, it is determined whether (ti, rsi) satisfies the observation invariant condition. The stable set is a logical concept, and in an actual algorithm, if the stable distance is zero, it is included in the stable set.

  Details of the task selection process using the stable set defined in this example are the same as those in the flowchart of FIG. 7 or FIG.

  However, in step S13 or S23, the state of the shared resource related to the state of each task is obtained in addition to the program execution state.

  In step S14 or S24, a plurality of sets are generated by combining each section included in the obtained program execution state with the corresponding shared resource state. Then, the number obtained by subtracting the number of the generated plurality of sets satisfying the observation invariant from the number of tasks is obtained as the stable distance.

  In step S15 or S25, it is assumed that a high stable task priority is given in the priority order that (ti, rsi) of the selected task satisfies the observation invariant condition and the stable distance is small.

  Hereinafter, three specific examples of task selection processing based on the observation invariant conditions will be described.

  (Example 1) An example in which there are two tasks and a shared resource is a variable will be described with reference to FIG.

The two tasks in FIG. 19 are Task1 and Task2, and the shared resource is two shared variables X and Y. Two observation invariants (likely invariant) are acquired using linv as follows.
linv (cp12, {X, Y}) = {Y! = null}: In the section following cp12, Y is not null for shared resources X and Y
linv (cp22, {X, Y}) = {X! = null}: In the section following cp22, X is not null for shared resources X and Y

  In the above case, Task1 and Task2 are controlled not to proceed to the next section until both proceed to cp12 and cp12. This avoids bugs caused by operations on null variables.

In FIG. 19, the observation invariant condition is
linv (cp12, {X, Y}) = {Y = 1}: In the section following cp12, Y is 1 for shared resources X and Y
linv (cp22, {X, Y}) = {X! = null}: In the section following cp22, for shared resources X and Y, X is not null.

  In this case, Task1 and Task2 are controlled not to proceed to the next section until both proceed to cp12 and cp12. Also, here, if a rule that prioritizes a task that satisfies strict conditions (many restrictions) is used, when both tasks are located at cp12 and cp22, the task 1 is controlled to be processed first. That is, the condition of {Y = 1} is more restrictive than X! = Null.

  (Example 2) An example in which there are two tasks and the shared resource is an object will be described with reference to FIG.

  The two tasks in FIG. 20 are Task1 and Task2, and the shared resources are two objects signal1 and signal2. It is assumed that the observation invariant (likely invariant) is obtained as follows using linv.

  linv (cp13, {signal1, signal2}) = {signal1.status == green, signal2.status == red}: In the section following cp13, for shared resources signal1 and signal2, the status of signal1 is green and signal2 status is red.

  linv (cp23, {signal1, signal2}) = {signal1.status == red, signal2.status == green}: In the section following cp23, for shared resources signal1 and signal2, the status of signal1 is red and signal2 status is green.

  By trying to stabilize timing based on the above constraints, it is possible to avoid a bug in which Task1 and Task2 move the functions do1 () and do2 () while signal1 and signal2 are in the green state at the same time. In other words, there is an implicit specification that prohibits simultaneously running do1 () and do2 (), and when it is satisfied with the execution log at the time of testing, by performing task selection based on the above observation invariant condition, This specification can be realized.

  (Example 3) An example in which there are three tasks and the shared resource is an object will be described with reference to FIG.

  The three tasks in FIG. 21 are Taski (i = 1, 2, 3), and the shared resource is three objects signali (i = 1, 2, 3). It is assumed that the observation invariant (likely invariant) is obtained as follows using linv.

  linv (cp13, {signal1, signal2}) = {signal1.status == green, signal2.status == red}: In the section following cp13, for shared resources signal1 and signal2, the status of signal1 is green and signal2 status is red.

  linv (cp23, {signal2, signal3}) = {signal2.status == green, signal3.status == red}: In the section following cp23, for shared resource signal2, signal3, status of signal2 is green and signa3 status is red.

  linv (cp33, {signal3, signal1}) = {signal3.status == green, signal1.status == red}: In the section following cp33, for shared resources signal3 and signal1, the status of signal3 is green and signa11 status is red.

  By trying to stabilize timing based on the above constraints, it is possible to avoid bugs that cause do1 () and do2 (), do2 () and do3 (), and do3 () and do1 () to move simultaneously. In other words, there is an implicit specification that prohibits the simultaneous movement of do1 () and do2 (), do2 () and do3 (), do3 () and do1 (), which were satisfied with the execution log at the time of testing In this case, this specification can be realized by performing task selection based on the observation invariant condition.

  Next, the update process of the stable set when the stable set based on the observation invariant condition is used in the system described above with reference to FIG. 14 will be described.

  The monitoring unit 31 in the remote monitoring device 30 monitors the program execution state of the monitoring target device 28. The storage unit 25 of the monitoring target device 20 stores a stable set at the time of shipment (a stable set based on observation invariant conditions). It is also possible to store an execution log that determines the observation invariant conditions.

  The stable set creation unit 32 in the remote monitoring device 30 collects, as trace information (execution log), program execution states that are sequentially monitored by the monitoring unit 31 when the observation invariant condition is satisfied and no failure occurs. Then, the program stable set creation unit 32 updates the observation invariant condition from the existing observation invariant condition and the newly accumulated execution log, and derives a new stable set. Here, an existing execution log can also be used.

  The stable set transmission unit 33 sends the updated stable set to the monitoring target device 30, and the updating unit 27 in the monitoring target device 30 replaces the stable set.

  When a failure occurs in the monitoring target device 28, the cause of the failure may be specified using the deviation history of the stable set (the program execution state when the departure from the stable set) and the trace information.

  As described above, according to the embodiment of the present invention, it is possible to provide a technology for supporting development and execution of a program having high reliability (functional stability) and high quality stability, and even a large-scale program can be functional. In addition, since a program with high performance stability can be efficiently developed, productivity in program development is improved.

The block diagram which shows the hardware constitutions of the computer system used in order to implement | achieve this embodiment. The figure which shows a multi-CPU system. The functional block diagram of the multitask processing apparatus concerning this embodiment. A diagram representing a task as a flow of sections and checkpoints. Task state transition diagram. The figure explaining the process of a task priority calculation part. The flowchart explaining the execution procedure of the scheduler in non-preemptive multitasking. The figure which shows the example of three tasks for demonstrating the specific example of the procedure of FIG. The flowchart explaining the execution procedure of the scheduler in preemptive multitasking. The figure which shows the example of calculation of stable distance. The figure explaining the specific example of Example [5]. The figure which shows the example of the memory usage and power consumption for every section. The figure which shows the example of the task selection in the case of the multitask system on multiple CPU. The figure which shows the remote monitoring apparatus connected with the multitask processing apparatus via the network. The figure which shows the remote monitoring apparatus connected with the some multitask processing apparatus via the network. The flowchart explaining the other example of an execution procedure of a scheduler. 12 is a flowchart for explaining another example of the execution procedure of the scheduler. The figure explaining the 1st-the 4th using the state of a task, and a shared resource. The figure explaining the example 1 of stabilization using an observation invariant condition. The figure explaining the example 2 of stabilization using an observation invariant condition. The figure explaining the example 3 of stabilization using an observation invariant condition.

Explanation of symbols

21: Task execution unit 22: Program execution state calculation unit (section calculation unit)
23: Stable distance calculation unit 24: Task priority calculation unit (task selection unit)
25: storage unit 26: notification unit 27: update unit 28: monitoring target device 30: remote monitoring device 31: monitoring unit 32: stable set creation unit 33: stable set transmission unit

Claims (25)

A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A stable set storage unit that stores a stable set that defines one or more combinations of sections between the tasks;
For each task, a program execution state calculation unit that obtains, as a program execution state, a set of a section that starts execution when the task is executed next and a current section of another task different from the task;
A distance calculation unit for calculating a distance between each of the program execution states and the stable set;
A task execution unit that selects and executes a task to be executed next based on each calculated distance;
A multitask processing device. The distance calculation unit calculates a first value as the distance when the same combination of sections as the program execution state is included in the stable set, and calculates a second value as the distance when the combination is not included. ,
The task execution unit preferentially selects the task to be executed next from among the tasks having the first value;
The multitask processing device according to claim 1.   The combination of sections included in the stable set storage unit is a combination of sections in which the total number of tasks accessing a predetermined computer resource is equal to or less than a first threshold, or the total memory usage by each task is a second threshold. The multitask processing apparatus according to claim 1, wherein the multitask processing apparatus is a combination of the following sections.   The distance calculation unit calculates the number of mismatches of sections between the program execution state and the combination of sections included in the stable set storage unit, and the minimum value of the calculated number of mismatches The multitask processing apparatus according to claim 1, wherein the distance is obtained as the distance.   The distance calculation unit calculates the number of matching sections between the program execution state and each combination of sections included in the stable set storage unit, and calculates the maximum value among the calculated number of matchings. The multitask processing apparatus according to claim 1, wherein the multitask processing apparatus is obtained as the distance. A memory usage information holding unit for holding information in which each section is associated with a memory usage amount;
The combination of the sections included in the stable set storage unit is a combination of sections in which the total memory usage by each task is equal to or less than a second threshold value,
The distance calculation unit calculates a first value as the distance when the same combination of sections as the program execution state is included in the stable set, and when not included, the total of memory usage corresponding to each section As the distance,
The multitask processing device according to claim 1. A power consumption information holding unit that holds information in which each section is associated with a power consumption amount;
The task execution unit has two or more execution units that individually execute tasks,
The combination of the sections is a combination of sections in which the total power consumption by the tasks executed by the execution units is equal to or less than a third threshold value.
The program execution state calculation unit includes, for each task other than the task being executed, a current section of the task that is being executed, a section that is to be executed when a free execution unit is next executed, Is calculated as the program execution state,
The distance calculation unit calculates, for each program execution state, a first value as the distance when the same combination of sections as the program execution state is included in the stable set, and a second value when the combination is not included Calculating the value as the distance,
The multitask processing device according to claim 1. A power consumption information holding unit that holds information in which each section is associated with a power consumption amount;
The task execution unit has two or more execution units that individually execute tasks,
The combination of the sections is a combination of sections in which the total power consumption by the tasks executed by the execution units is equal to or less than a third threshold value.
The program execution state calculation unit includes, for each task other than the task being executed, a current section of the task that is being executed, a section that is to be executed when a free execution unit is next executed, Is calculated as the program execution state,
The distance calculation unit calculates, for each program execution state, the first value as the distance when the same combination of sections as the program execution state is included in the stable set, and when not included, the program execution Calculating the total power consumption corresponding to each section included in the state as the distance;
The multitask processing device according to claim 1. The task execution unit
Determining a first priority of each task based on a distance calculated from the program execution state and the stable set;
If there is one task with the highest first priority, select the task as the task to be executed next,
When there are two or more tasks having the highest first priority, the task having the highest second priority, which is a priority specified in advance, is selected from the tasks having the highest first priority.
When the selected task is one, select the task as the task to be executed next,
If there are two or more selected tasks, the task that is in the waiting state for execution first among the selected tasks is selected as the task to be executed next.
The multitask processing device according to claim 1. The task execution unit selects a task having the highest second priority based on a second priority that is a priority specified in advance.
If there is one task selected, select this task as the next task to be executed,
If there are two or more selected tasks, a first priority is determined for each of the two or more selected tasks based on the distance calculated for the two or more selected tasks;
When there is one task having the highest first priority, the task is selected as the task to be executed next,
When there are two or more tasks having the highest first priority, the task having the highest waiting state among the tasks having the highest first priority is selected as the task to be executed next. To
The multitask processing device according to claim 1. A remote monitoring device that inspects whether or not a predetermined failure has occurred due to the execution of the task by the task execution unit, and that indicates a program execution state corresponding to the task and information indicating whether or not a failure has occurred in advance. A notification unit to notify
An update unit that receives data representing a stable set updated from the remote monitoring device, and updates the stable set in the stable set storage unit with the received data;
The multitask processing device according to claim 1, further comprising: A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A stable set storage unit for storing a stable set in which one or more section series including N (N is an integer of 2 or more) sections are defined;
For each task, a section calculation unit for obtaining a section to be executed when the task is executed next,
A distance calculation unit that calculates the distance between the section series consisting of each N-1 times executed immediately before and the section obtained by the section calculation unit, and the stable set for each task;
A task execution unit that selects and executes a task to be executed next based on each calculated distance;
A multitask processing device. A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A stable set storage unit that stores a stable set in which one or more tasks and one or more sets of sections are defined;
For each task in an executable state among the plurality of tasks, a section calculation unit for obtaining a section to be executed when the task is executed next,
A distance calculation unit for calculating a distance between a plurality of sets obtained by combining the task set in the executable state with a section obtained for each task in the executable state, and the stable set;
A task execution unit that selects and executes a task to be executed next from among the tasks in the executable state based on each calculated distance;
A multitask processing device. A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A storage unit for storing a section feature value representing a feature of a section included in each of the tasks;
For each task, a program execution state calculation unit that obtains, as a program execution state, a set of a section that starts execution when the task is executed next and a current section of another task different from the task;
A task execution unit that selects and executes a task to be executed next based on a section feature value of a section included in each of the program execution states;
A multitask processing device. The section feature value indicates whether the task accesses a predetermined computer resource in the section corresponding to the section feature value;
The task execution unit calculates the number of tasks for accessing the predetermined computer resource for each program execution state, and selects a task corresponding to the program execution state with the smallest number of tasks.
The multitask processing apparatus according to claim 14, wherein: The section feature value indicates a memory usage consumed in the section corresponding to the section feature value;
The task execution unit calculates the total memory usage of each section for each program execution state, and selects a task corresponding to the program execution state that minimizes the total memory usage.
The multitask processing apparatus according to claim 14, wherein: The task execution unit includes two or more execution units that individually execute tasks,
The section feature value indicates a power consumption consumed in the section corresponding to the section feature value,
The program execution state calculation unit includes, for each task other than the task being executed, a current section of the task that is being executed, a section that is to be executed when a free execution unit is next executed, Is calculated as the program execution state,
The task execution unit calculates the total power consumption of sections included in each program execution state, and selects a task corresponding to the program execution state that minimizes the total power consumption.
The multitask processing device according to claim 18. A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
A stable set storage unit that stores a stable set that defines one or more pairs of sections between each of the tasks and one or more shared resource states;
For each task, a set of a section to be executed when the task is next executed and a current section of another task different from the task is obtained as a program execution state, and for each program execution state A program execution state calculation unit for identifying a state of a shared resource used in the program execution state;
A distance calculation unit for calculating a distance between each of the program execution states and a pair of the state of the shared resource obtained corresponding to each of the program execution states and the stable set;
A task execution unit that selects and executes a task to be executed next based on each calculated distance;
A multitask processing apparatus comprising: A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set that defines one or more sets of individual sections of the task and one or more shared resource states;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
Specifying the state of the shared resource used by the plurality of tasks for each program execution state;
A program execution state calculation unit that generates a plurality of sets each including one section and the specified shared resource state by combining each of the sections included in the program execution state with the specified shared resource state. When,
A distance calculation unit that calculates a distance to the stable set based on the number of matches between the plurality of generated sets and the stable set;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
A multitask processing apparatus comprising: A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set that defines one or more sets of individual sections of the task and one shared resource state;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
For each section included in the program execution state, specify the state of the shared resource used in the section,
For each section included in the program execution state, the section is combined with each of the specified shared resource states to generate a plurality of sets each including one section and one specified shared resource. A program execution state calculation unit;
A distance calculation unit that calculates a distance to the stable set based on the number of matches between the plurality of generated sets and the stable set;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
A multitask processing apparatus comprising: A multitask processing device for multitasking a plurality of tasks each divided into two or more sections,
For each task, a stable set storage unit that stores a stable set that defines one or more sets of individual sections of the task and one or more shared resource states;
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
For each section included in the program execution state, specify the state of the shared resource used in the section,
For each section included in the program execution state, the section is combined with the specified shared resource state to generate a plurality of sets each including one section and the specified shared resource state A state calculation unit;
A distance calculation unit that calculates a distance to the stable set based on the number of matches between the plurality of generated sets and the stable set;
A task execution unit that selects and executes a task to be executed next based on the distance calculated for each task;
A multitask processing apparatus comprising:   The multitask processing apparatus according to any one of claims 18 to 21, wherein the stable set stored in the stable set storage unit is a set of a set of a tested section and a shared resource.   The stable set stored in the stable set storage unit satisfies an observation invariant condition regarding a section and a shared resource, which is observed by executing the plurality of tasks on a test case. The multitask processing device according to claim 21. A multitask processing method for multitasking a plurality of tasks each divided into two or more sections,
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
Calculating the distance between each program execution state and a stable set that defines one or more combinations of sections between tasks;
Based on each calculated distance, select and execute the next task to execute,
A multitask processing method characterized by the above. A multitask processing method for multitasking a plurality of tasks each divided into two or more sections,
For each task, a set of a section that starts execution when the task is executed next and a current section of another task different from the task is obtained as a program execution state,
Selecting and executing a task to be executed next based on a section feature value representing a feature of a section included in each of the program execution states;
A multitask processing method characterized by the above.

Images