JPH11175369A - Program development supporting device, program development supporting method and medium recording program development supporting program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program development supporting device, a program development supporting method and a medium recording a program development supporting program capable of securing the reliability of a program by displaying the signals of an alarm or the like to a user in the case that an action other than a scenario is executed. SOLUTION: This device is provided with a scenario preparation means 2 for preparing the scenario for successively expressing the action from a parallel program 1, a testing and debugging means 6 for confirming the correctness of the respective scenarios in scenario information 3 which is the set of the scenarios, the execution means 8 of the parallel program 1, a comparison means 10 for comparing the execution information 9 of the program with the scenario information 3 at the time of executing the parallel program 1 and a compared result display means 11 for displaying the alarm to the user in the case that the execution information 9 of the program performs the action not in the scenario.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an apparatus and a method for supporting the development of a software program for an information processing apparatus, and more particularly, to a program development support apparatus and a program development which enable creation and execution of a highly reliable program. The present invention relates to a support method and a medium recording a program development support program.

[0002]

2. Description of the Related Art In recent years, with the advance of semiconductor integrated circuit technology, a complicated processor and a large capacity memory can be realized at a small size and at a low price, and a parallel processing system or a distributed processing system including a large number of processors has been constructed. Hardware has been put to practical use. For such hardware, a dedicated program such as a parallel program or a distributed processing program (hereinafter referred to as a “parallel program”) must be used.

[0003] The parallel program is a program in which a plurality of processes operate concurrently in parallel. One type is a program in which a plurality of programs run physically in parallel on a parallel computer having a plurality of CPUs. Is mentioned. In addition, even when physically operating sequentially on a single CPU, a program in which a plurality of processes operate logically in parallel, such as a multitask system,
It is a concurrent program. A system having such physical or logical concurrency is called a concurrent system, and a concurrent program generally runs in the concurrent system. How to develop such a concurrent program efficiently is an important issue as in the case of examining an excellent algorithm.

In program development, a process called test / debug greatly affects development efficiency. The test / debugging is to find and correct a bug in a program, and can be performed relatively easily in the development of a normal sequential program. However, in the development of a concurrent program, it is necessary to consider a problem based on a characteristic of the concurrent program called "nondeterminism". In other words, each process that makes up the concurrent program
Depending on the timing of the interaction between each process,
They can behave in a variety of ways that are not encountered in a regular sequential program, and are commonly referred to as "non-deterministic"
Call. Concurrent programs include the possibility that, due to this "non-determinism", the whole program may not operate correctly.

Here, a program having "non-determinism" can be defined as a program whose behavior at the time of execution of the program is non-deterministic. On the other hand, a program whose behavior is uniquely determined when an input is determined is called a definitive program. The above parallel program is a typical example of a program with "non-determinism" .However, even if the program itself has no concurrency, "non-determinism" may occur in the execution order due to the timing of external input etc. is there.
For example, in an IF-THEN rule-type program, the execution order of rules may change at the timing of input from the outside. In addition, there is “non-determinism” in behavior caused by causes such as when the semantics of the programming language is ambiguous and the behavior differs depending on the processing system, or when the behavior differs depending on the instability of the processing system.

[0006] Such "nondeterminism" can be classified into "good nondeterminism", "harmless nondeterminism", and "bad nondeterminism". Of these, “good non-determinism” is the non-determinism that the program designer wants to realize, and the existence of this “good non-determinism” makes it possible to respond to external non-deterministic inputs And the process is flexible, reusable and scalable.

[0007] "Harmless non-determinism" refers to non-determinism in which the selection of a non-deterministic option does not adversely affect the final result, although it may affect execution efficiency. It is.

[0008] On the other hand, "bad nondeterminism" is nondeterminism that a designer does not expect or expect, and often causes malfunction of a program. In other words, since the general form of thinking of human beings is sequential in nature, it is difficult to predict all situations that can actually occur between a plurality of processes of a concurrent program. For this reason, many cases that were not expected at the time of design occur in the execution of the actual concurrent program.

Performing test / debugging on a program having "non-determinism" typified by the above-mentioned concurrent programs causes problems such as combinatorial explosion of test cases and lack of reproducibility of bugs. This is a very difficult task. To deal with this, for example, Japanese Patent Application Laid-Open No.
No. 16429 has been proposed. this is,
By serializing a concurrent program once, test / debug is performed with the same ease as for a conventional sequential program, and thereafter, parallelism is restored.

[0010] A program serialized while maintaining information on the parallel structure of the original parallel program is called a "super-sequential program". FIG. 18 shows an example of a program development support device for creating such a “super-sequential program” and performing test / debugging on the “super-sequential program”. That is, this program development support device includes the serialization unit 22, the test / debugging unit 26, the good non-deterministic introduction unit 27, and the parallelization unit 24.

In such a program development support apparatus, the parallel program 1 is converted into a hyper-sequential program 23 by the serialization means 22, and the super-sequential program 23 is subjected to test debugging by the test debugging means 26. For the ultra-sequential program 23 confirmed to operate normally by test / debug,
Good non-determinism introduction means 27 introduces information about partially good non-determinism. Such a super-sequential program in which good nondeterminism is partially introduced is called a "partial super-sequential program". Here, a specific example of “introduction of good nondeterminism” is “preparing a plurality of correct sequential programs”.

[0012] Test / debug is further performed on the partial hyper-sequential program. However, since the part where information regarding good non-determinism is introduced, non-deterministic behavior is performed, so that test / debug is performed on all of the behavior. Done.

As described above, the test / debugging and the introduction of the information regarding the good non-determinism are repeated, and the information regarding the good non-determinism is gradually added. Then, the parallelizing means 24 extracts a harmless nondeterministic part from the partially hypersequential program into which good nondeterminism has been introduced, and restores the parallel program 25 by parallelizing the entire partial hypersequential program. .

[0014] As shown in FIG. 19, a device without good non-determinism introducing means 27 can also be configured. In this case, a parallel program 25 is generated by the parallelization device 24 based on a set of a plurality of super-sequential programs 23 determined to be correct by the test debug by the test debug means 26.

[0015]

By the way, the above technique is based on "a partial super-sequential program in which good nondeterminism is introduced" or "a set of a plurality of sequential programs determined to be correct by test debugging". This is to generate the desired concurrent program. However, inserting all the information obtained in these processes as the source code of the reconstructed concurrent program has the following problems.

(1) Since the source code becomes long, a storage medium for storing the program is additionally required. This is a great limitation in systems with large memory constraints, such as embedded microcomputer systems.

(2) The overhead during execution increases.

(3) The inserted code may cause an undesirable behavior such as deadlock.

The present invention has been proposed to solve the above-mentioned problems of the prior art, and an object of the present invention is to provide a warning when a behavior other than the scenario information is executed during execution of a program. It is an object of the present invention to provide a program development support device, a program development support method, and a medium on which a program development support program is recorded, which can ensure the reliability of a program by displaying a signal such as this to a user.

Another object of the present invention is to provide a program development support apparatus, a program development support method, and a program development control method capable of achieving high reliability of a program by controlling a behavior other than scenario information during execution of the program. An object of the present invention is to provide a medium recording a program development support program.

[0021]

According to an aspect of the present invention, there is provided a program development support apparatus for supporting program development, wherein scenario information is created from a given program. Creating means; executing means for executing the program; comparing means for comparing execution information of the program executed by the executing means with the scenario information; and display means for displaying a result of the comparison by the comparing means. It is characterized by the following. According to a fourteenth aspect of the present invention, there is provided a program development support method for supporting program development, wherein scenario information is created from a given program. Executing the program, comparing execution information of the program with the scenario information, and displaying a result of the comparison. According to the first and fourteenth aspects of the present invention, the comparing means compares the scenario information with the execution information of the program, and displays the result of the comparison. In this case, the user can clearly recognize this and take a countermeasure such as suppressing the execution.

According to a second aspect of the present invention, there is provided a program development support device for supporting program development, wherein scenario creation means for creating scenario information from a given program; execution means for executing the program; Comparing means for comparing execution information of the program executed by the means with the scenario information, wherein the executing means controls the execution of the program based on a comparison result by the comparing means. I do. According to a fifteenth aspect of the present invention, the invention of the second aspect is grasped from the viewpoint of a method. In a program development support method for supporting program development, scenario information is created from a given program. Executing the program, comparing the execution information of the program with the scenario information, and controlling the execution of the program based on the comparison result. According to the second and fifteenth aspects of the present invention, the comparing means compares the scenario information with the execution state of the program.
Since the execution of the program is controlled based on the comparison result, the behavior other than the correct scenario is suppressed without waiting for the user's confirmation.

According to a third aspect of the present invention, there is provided the program development support apparatus according to the second aspect, further comprising display means for displaying a comparison result by the comparing means.
According to the third aspect of the present invention, the comparing means compares the scenario information with the execution information of the program.
Since the comparison result is displayed, when a behavior other than the correct scenario is executed, the user can clearly recognize this and take a countermeasure such as suppressing the execution.

According to a fourth aspect of the present invention, there is provided the program development support apparatus according to any one of the first to third aspects,
It is characterized by having registration means for adding a new scenario to the scenario information. In the invention according to claim 4 described above, behaviors other than the correct scenario are distinguished into those having a problem and those having no problem by the judgment of the user, and those having no problem are registered as new scenarios. Since the execution of the problematic behavior can be suppressed, a highly reliable program can be created more accurately.

According to a fifth aspect of the present invention, there is provided the program development support apparatus according to any one of the first to fourth aspects,
State abstraction means for abstracting the execution state of the program, and scenario graph generation means for expressing the scenario information in a finite state transition graph based on an abstraction function obtained by the state abstraction means. Features. According to the fifth aspect of the present invention, the scenario information can be represented by a scenario graph, which is a finite state transition graph, based on the abstraction function. Creating expensive programs becomes easier.

According to a sixth aspect of the present invention, in the program development support apparatus of the fifth aspect, the abstraction function is a hash function. In the invention according to claim 6 described above, since a hash function capable of expressing a large amount of information by one integer value is used for state abstraction, efficient abstraction can be performed.

According to a seventh aspect of the present invention, in the program development support apparatus of the fifth or sixth aspect, there is provided designating means for designating a subset of elements constituting a state of the program, and the state abstraction is provided. The means targets only the elements of the subset specified by the specifying means. According to the seventh aspect of the present invention, elements other than the subset specified by the user by the specifying means are not subject to state abstraction and are ignored, so that an appropriate program can be promptly selected by the user. Can be generated.

According to an eighth aspect of the present invention, in the program development support apparatus according to the first or second aspect, the scenario information is set with a priority of execution. According to the above-described invention, it is easy to create a program based on the next best scenario in accordance with the priority even when there is no desirable behavior that can be executed corresponding to the scenario with a high priority. Become.

According to a ninth aspect of the present invention, in the program development support device according to the first or second aspect, when there is no behavior that matches the scenario information in the execution information of the program, the execution means executes the program. And a safe state storage means for forcibly changing the state of the device to the safe state. According to the ninth aspect of the invention, when there is no behavior that matches the scenario,
Since the state of the program is forcibly changed to the safe state, it is possible to realize a program suitable for a control system for equipment having a high risk.

According to a tenth aspect of the present invention, in the program development support device according to the first or second aspect, the execution means includes an execution task switching unit for selecting a scenario by switching an execution task; An interrupt processing unit that performs an interrupt process based on information for controlling execution is provided. According to the tenth aspect of the present invention, it is not necessary to perform table comparison and task switching for each instruction execution of the program, and the table comparison and program execution can be performed as parallel as possible. Does not increase the overhead.

According to an eleventh aspect of the present invention, in the program development supporting apparatus for supporting the development of a concurrent program, a serializing means for converting a given parallel program into a hyper-sequential program which can be sequentially executed; A runtime comparison information generating unit that generates runtime comparison information from the execution program, an execution unit that executes the parallel program, and a comparison between the execution information of the parallel program executed by the execution unit and the runtime comparison information. It is characterized by having comparison means and display means for displaying a result of comparison by the comparison means. According to the above-described invention, the comparing means compares the execution-time comparison information with the execution information of the concurrent program, and displays a result of the comparison. When a behavior other than the above is executed, it is possible to clearly recognize the behavior and take a countermeasure such as controlling the execution.

According to a twelfth aspect of the present invention, in the program development supporting apparatus for supporting the development of a parallel program, a serializing means for converting a given parallel program into a hyper-sequential program which can be sequentially executed; A runtime comparison information generating unit that generates runtime comparison information from the execution program, an execution unit that executes the parallel program, and a comparison between the execution information of the parallel program executed by the execution unit and the runtime comparison information. A comparison unit and the execution unit control execution of the concurrent program based on a comparison result by the comparison unit. In the invention according to the twelfth aspect, the comparing means compares the scenario information with the execution state of the concurrent program, and controls the execution of the concurrent program based on the comparison result. ,
The execution is suppressed without waiting for the confirmation of the user.

According to a thirteenth aspect of the present invention, in the program development support device according to the eleventh or twelfth aspect, there is provided an introduction means for introducing good non-determinism into the hyper-sequential program, and the runtime comparison information generating means is provided. Is characterized in that the runtime comparison information is generated from a hyper-sequential program into which good nondeterminism is introduced. Claim 1 as described above
According to the invention described in 3, the runtime comparison information is created based on the sequential program in which good nondeterminism is introduced, so that a more reliable program can be created and executed.

[0034]

Embodiments of the present invention will be described below with reference to the drawings. Each function of the embodiment is realized by predetermined software controlling a computer and peripheral devices. In this specification, the invention and the embodiment correspond to each function and each process. The description is made assuming a virtual circuit block such as “-means”. Therefore, each hardware element and each software element do not correspond one-to-one to each block.

[1. Configuration of Computer System] First, a computer system for realizing the present embodiment using a multi-CPU will be described with reference to the conceptual diagram of FIG. That is, N processors 101-1 and 101-10 capable of simultaneously executing a concurrent program
, 101-3,..., 101-N are I /
It is provided so as to be able to access the shared memory 103 and peripheral devices via the O interface 102. The peripheral device includes an input device 104, an output device 105, and an external storage device 106.

The input device 104 includes a keyboard, a pointing device, and the like that allow the user to input various commands and data. The output device 105 includes a CRT display or the like that can display a source program, information on a debugging situation, or the like in text or graphic form and present it to the user. The external storage device 106 is composed of a magnetic disk, a magneto-optical disk, or the like on which a source program and information on a debugging situation can be written or read.

[2. Embodiment] (1) First Embodiment (Configuration) This embodiment corresponds to the invention described in claim 1 and claim 14, and as shown in FIG. It has a scenario creating means 2 for creating a “scenario”. Here, the “scenario” sequentially represents the behavior of the concurrent program 1, and an execution log when the concurrent program is sequentially executed is a typical example of the “scenario”. Then, a set of “scenarios” constitutes “scenario information 3”. One form of “super-sequential program 23” in the related art shown in FIG.
This is “scenario information 3”.

In this embodiment, the test / debugging means 6 for checking the correctness of the scenario information 3 and correcting the original concurrent program if there is a bug, the concurrent program executing means 8, the execution state of the program And a comparison result display means 11 for displaying a comparison result in the comparison means 10.

(Operation) In the present embodiment having the above-described configuration, first, a scenario is created by the scenario creating means 2 based on the concurrent program 1 and accumulated as scenario information 3. The correctness of each scenario in the scenario information 3 is confirmed by the test / debugging means 6, and if there is a bug, the original concurrent program 1 is corrected.

When the execution means 8 executes the concurrent program 1, the comparing means 10 compares the execution information 9 of the program obtained by the execution means 8 with the scenario information 3. If the behavior is not described above, the comparison result display means 11 warns the user.

(Effects) According to the present embodiment as described above, if a behavior other than the scenario confirmed to operate correctly in advance is executed, a warning is displayed to the user, so that the user can execute the program in the program. The behavior to be suppressed can be clearly determined, and a highly reliable program can be easily created.

Further, it is not necessary to insert all information obtained in the process of serializing a parallel program, introducing good concurrency, and restoring a parallel program as the source code of a reconstructed parallel program as in the prior art. Since this does not exist, it leads to saving of memory, shortening of overhead, and prevention of occurrence of deadlock and the like.

(2) Second Embodiment (Structure) This embodiment corresponds to the invention described in claims 2 and 15, and as shown in FIG.
Although the configuration is almost the same as that of the first embodiment, the comparison result display means 11 is not provided. Then, based on a comparison result between the execution information 9 of the program obtained by the execution means 8 and the scenario information 3, the comparing means 10 determines whether the concurrent program 1 does not operate in a behavior not included in the scenario information 3. It is configured to generate execution control information 21 for controlling execution and control execution of the execution means 8.

(Operation) In the present embodiment having the above-described configuration, first, a scenario is created by the scenario creating means 2 based on the concurrent program 1 and accumulated as scenario information 3. The correctness of each scenario in the scenario information 3 is confirmed by the test / debugging means 6, and if there is a bug, the original concurrent program 1 is corrected.

When the concurrent program 1 is executed by the executing means 8, the comparing means 10 compares the program execution information 9 with the scenario information 3, and if the execution of the concurrent program 1 does not behave in the scenario. If there is, the execution control information 21 is generated by the comparing means 10. Further, based on the execution control information 21, the execution of the concurrent program 1 by the execution means 8 is controlled so as not to move in a behavior not included in the scenario.

(Effect) According to the present embodiment as described above, the execution of the behavior other than the scenario confirmed to operate correctly beforehand is automatically suppressed without waiting for the user's confirmation. Therefore, a highly reliable program can be easily created.

Further, as in the first embodiment, it is possible to save memory by reducing the length of the source code, reduce overhead, and prevent occurrence of deadlock.

(3) Third Embodiment (Structure) This embodiment corresponds to the first and fourth aspects of the present invention, and is a further improvement of the first embodiment. It is. That is, as shown in FIG. 4, in the present embodiment, in addition to the configuration requirements of FIG. Instruction means 13 for instructing a result of determination as to whether or not there is
A scenario registration unit 12 for registering a scenario in the scenario information 3 according to a user's instruction is provided.

(Operation) In the present embodiment having the above configuration, first, a scenario is created by the scenario creating means 2 based on the concurrent program 1, and is accumulated as scenario information 3. The correctness of each scenario in the scenario information 3 is confirmed by the test / debugging means 6, and if there is a bug, the original concurrent program 1 is corrected.

Then, when the execution means 8 executes the concurrent program 1, the comparing means 10 compares the execution information 9 of the program with the scenario information 3, and if the execution of the concurrent program 1 does not behave in the scenario. If yes, the comparison result display means 11 warns the user.
When the user determines that the behavior not in the warned scenario is not actually a problem, the instruction unit 13
The scenario registering unit 12 is instructed to register the behavior not included in the warned scenario as the correct scenario in the scenario information 3. As a result, the behavior determined by the user as having no problem is also registered in the scenario information 3 as a correct scenario.

(Effect) According to the present embodiment as described above, the same effect as that of the first embodiment can be obtained, and the behavior that has not been stored as the scenario information 3 (in other words, correctness) Is not confirmed), but based on the user's judgment that there is no actual problem,
It can be added to the scenario information. As a result, a new scenario can be registered without executing test / debugging, thereby making it easier to create a program.

(4) Fourth Embodiment The present embodiment corresponds to the second to fourth aspects of the present invention. Are combined. That is, in the present embodiment, when a behavior that is not included in the scenario information 3 occurs at the time of execution, the behavior is not forcibly suppressed, but the user is asked whether the behavior is satisfactory by the comparison result display unit 11. Inquire whether or not. Then, when the user instructs the behavior judged to be no problem by the instruction means 13, the scenario registration means 12 registers the correct scenario in the scenario information.

When the behavior is judged by the user to have a problem, execution of the behavior by the execution means 8 is suppressed. In this case, the execution ends and the parallel program 1
You can also test / debug.

According to the present embodiment as described above, behaviors other than the scenario confirmed to operate correctly in advance are distinguished into those having a problem and those having no problem by the judgment of the user, and Those that do not exist are registered as new scenarios, and execution of problematic behaviors can be suppressed, so that a more reliable program can be created more accurately.

(5) Fifth Embodiment (Structure) This embodiment relates to claims 1 to 3, and claims 5 to 7.
It corresponds to the described invention, and as shown in FIG.
A program creating means (not shown) for creating the concurrent program 1, an executing means 8 for executing the concurrent program 1,
Scenario creating means 30 for creating a scenario of the concurrent program 1, test / debugging means 6 for confirming the correctness of the scenario, and a state abstraction function 37 from the concurrent program 1.
, A scenario graph 33 from a set of scenarios 31 and a state abstraction function 37.
And a scenario graph generating means 32 for generating

Further, in the present embodiment, the execution control table creating means 34 for creating the execution control table 35 from the scenario graph 33 is compared with the execution information 9 of the program and the execution control table 35. It has a table comparison means 38 for generating execution control information 21 for controlling the execution of the concurrent program 1 based on the result, and a comparison result display means 11 for displaying a comparison result in the table comparison means 38.

(Operation) The operation of the present embodiment having the above configuration will be described below with reference to the flowchart of FIG.

Creation of Concurrent Program First, the concurrent program 1 is created by the program creation means.
Is created (step 601). Here, an example of the structure of the concurrent program 1 is shown in FIG. In this concurrent program, P1 and P2 are processes (similarly for tasks or threads) that run in parallel on a single CPU.
1 and P2 are accessing the shared memory M. The parallel program P = P1 | P2 is described as a source code, for example, as shown in FIG. Where P1 | P
2 means that P1 | P2 is executed logically in parallel. The parallel program 1 can be expressed as an equivalent state transition system as shown in FIG.

Setting of execution state abstraction function Next, the state abstraction function 37 is obtained by the state abstraction function setting means 36 (step 602). This is because the execution state of the concurrent program 1 needs to be abstracted in order to make the scenario a scenario graph 33 that is represented by a finite state graph. Without it, it cannot be represented by a finite state graph.

For example, f _abs is set as a function that abstracts the execution state of the concurrent program P. Where f
_abs is an abstract function that employs only a set of the program counters P1 and P2 as states and ignores the values of the variables x, y, M, and sum.

[0061]

(1) (<P1 state>, <P2 state>) = f _abs
([<P1 state>, <P2 state>, <variable value>,
…]) In addition, various other abstraction functions, such as ignoring a state other than the state specified by the user, can be considered. For example, there are a method using a hash function and a method using a hash function partially. Here, the hash function is a technique for expressing a large amount of information by one integer value, and is a well-known technique described in the document "Aeho, Hopcroft, Ullman: Data Structure and Algorithm (Boufukan)". is there.
If this hash function is used, the state of the program [<P
1 state, <P2 state>, <variable value>,.
It can be represented by two integers, which enables efficient abstraction.

Further, there is provided designation means for allowing a user to designate a subset of elements constituting the state of the program, and the state abstraction function setting means 36 targets only the elements of the subset designated by the designation means. It is also possible to adopt a configuration in which the state abstraction function 37 is set. With such a configuration, a state other than the state designated by the user is ignored, so that an appropriate program can be quickly generated by the user's selection.

Creation of Scenario and Execution of Test Subsequently, several scenarios of the concurrent program 1 are created by the scenario creation means 30 (step 603), and correctness is confirmed by the test / debugging means 6 (step 60).
4). If there is an error in the scenario, the original concurrent program 1 is modified (steps 605 and 606), and a scenario is generated and tested again to obtain a set 31 of scenarios confirmed to be correct (step 607).

Generation of Scenario Graph Next, the scenario graph 33 is generated by the scenario graph generation means 32 from the set of scenarios 31 using the execution state abstraction function 37 (step 608). For example,
The execution state of the concurrent program 1 is converted to the execution state abstraction function 37.
Assuming that the node abstracted by the above is a node and the transition of the execution state is an edge, a scenario graph 33 as shown in FIG. 10 can be created. In this example, scenario graph 3
3 represents a scenario that was confirmed to be correct in steps 604 and 605.

Creation of Runtime Control Table From the scenario graph 33 created as described above, the runtime control table creating means 34 creates the runtime control table 35 (step 609). The execution control table 35 re-expresses the information of the scenario graph 33 in a table format that can be easily referred to when the program is executed.

For example, for the sake of simplicity, it is assumed that a run-time control table 35 corresponding to the scenario graph 33 shown in FIG. 10 on a one-to-one basis has been created (see FIGS. 11 and 12). Here, FIG. 11 is a table showing the next executable transition (execution instruction) in each execution state, and t / s indicates that the execution state transits to s when the transition t is executed. means. Also, c: t
Means that transition t is executable when condition c is satisfied.

FIG. 12 is a table showing task (process) switching in each execution state.
When the process is switched to and the one-unit process is executed, the execution state transits to s. Also,-/ s is
When one-unit processing is executed without switching the process, the execution state transits to s. When a normal real-time OS is used, the runtime control table in FIG. 12 is used.

If the parallelization technique based on program analysis separately proposed by the present applicant is used, it is possible to create the runtime control table 35 with less restrictions.

Execution of Concurrent Program and Warning Display Next, the concurrent program 1 is executed by the execution means 8 (step 610).
At 8, the execution information 9 is compared with the execution control table 35 (step 611), and the execution control table 35 is compared.
Only the behaviors allowed in the scenario are selected from the executable behaviors based on (step 612). Then, the execution control information 21 is generated so that only the selected behavior is executed, whereby the execution of the behavior not permitted in the scenario is suppressed (step 613). On the other hand, if the behavior permitted in the scenario does not exist, a warning is issued to the user by the comparison result display means 11 (step 6).
14).

Here, for example, the execution cycle of the unit instruction when the execution control table 35 shown in FIG. 12 is used will be described with reference to the flowchart of FIG.
That is, from the runtime control table 35, the current state S
1 is obtained (step 1).
300, 1301). Then, C: P / S2 satisfying the condition C in S1 is obtained from the control information I (S1) (step 1302). If there is C: P / S2 that satisfies C (step 1303), the process proceeds to step 1305.
If there is nothing that satisfies C, a warning indicating "behavior not in the scenario" is displayed (step 130).
4). After the warning is displayed, one of the following processes is performed.

Α: Stop the program safely. Β: Backtrack to a certain safe state (for example, initial state) and resume execution. Γ: Continue execution. Further, C: P of P / S2 is specified. If it is (Step 1305), the process is switched to P and the P unit instruction is executed (Step 1306). If the P of C: P / S2 is not specified (C:-/ P), the unit instruction is executed without performing the process switching (step 130).
7). As described above, the unit instruction is executed, and step 1 is executed.
Return to 300.

(Effect) According to the present embodiment as described above, by using the state abstraction function 37, the concurrent program 1 is expressed as the scenario graph 33, and the execution is described in a table format that can be easily referred to. Since the execution of the concurrent program 1 can be controlled by using the time control table 35, it becomes easier to create a highly reliable program that executes only the behavior permitted in the scenario.

(6) Sixth Embodiment (Structure) This embodiment corresponds to the first to fifth aspects of the present invention. In this embodiment, the same scenario registration means 12 as that of the first embodiment is added.

(Operation) In the present embodiment having the above configuration, if a warning is displayed and the execution is continued in step 1304 of the fifth embodiment, there is no problem in the execution. If not, the execution is added as a new scenario to the runtime control table 35 by the scenario registration means 12. And after that,
Even in a similar case, the execution is advanced based on the execution control table 35 without displaying a warning.

(Effects) According to the present embodiment as described above, even if the scenario is insufficient at the initial stage and there are many warnings, the number of scenarios increases in the process of actually using the software. Warnings will be reduced. Therefore, for example, in a plant or the like where safety is considered important, it is necessary for the operator to wait for an emergency in case of warning, but the number of warnings decreases as the system is used, You only have to wait. As described above, according to the present embodiment, it is easier to create a highly reliable program.

(7) Seventh Embodiment This embodiment corresponds to the eighth aspect of the present invention. In the fifth embodiment, the behavior corresponding to each scenario is executed. And set a high priority to a desirable scenario that can be executed, and set the execution priority to the lowest for behaviors that are not registered in the scenario information but are executable. .

In this embodiment, when there is no executable behavior corresponding to a high priority scenario in the run-time control table 22 in steps 611 and 612 in the fifth embodiment described above. , An executable behavior corresponding to a scenario having a lower priority is executed. On the other hand, if there is no behavior that matches the scenario, the executable behavior with the lowest priority is executed.

As described above, according to the present embodiment, even if there is no desirable scenario that can be executed,
According to the priority, it is possible to create a program based on a suboptimal scenario.

(8) Eighth Embodiment This embodiment corresponds to the ninth aspect of the present invention, and corresponds to step 61 in the fifth embodiment.
1 and 612, a safe state storage device for forcibly setting the state of the program in the execution means 8 to a safe state when there is no behavior matching the scenario in the run-time control table 22 is introduced. For example, an emergency stop state used in a control system of a nuclear power plant is one of the safe states. According to the present embodiment, since the system automatically enters the safe state without the user making a determination based on the warning, it is possible to create a program suitable for a control system of a high-risk facility. Can be.

(9) Ninth Embodiment (Structure) This embodiment is an embodiment corresponding to the tenth aspect of the present invention. As shown in FIG. It has a switching unit 81 and an interrupt processing unit 82. Also, the execution control information 21
Is composed of an interrupt flag 71 and task information 72. In the present embodiment, more specifically, as shown in FIG.
Hardware such as SC and execution means 8 in real time O
S can be realized.

(Operation) In the present embodiment having the above configuration, normal program execution is realized by selecting a scenario by the program execution task switching unit 81 in the OS. Then, only when it is necessary to switch the task in order to control the execution of the program, the interrupt processing unit 82 copes.

More specifically, as shown in FIG. 15, the state of the program is read directly from the memory / register in a hardware manner, and the necessity of task switching suitable for the scenario is determined by the AISC-based table comparing means. 38 to determine instantaneously. As a result of the determination, when task switching is required, the interrupt flag 71 is set in hardware. Then, the CPU interrupts the normal processing of the OS and executes the specified interrupt processing program. In this interrupt processing program, the current task is suspended by the suspend instruction of the OS, and the task to be activated is determined by the OS.
Activate with resume command. As soon as this interrupt processing is completed, the control is returned to the normal OS processing.

(Effect) According to the present embodiment as described above, there is no need to perform table comparison and task switching for each instruction execution of the program, and the table comparison and program execution are performed as parallel as possible. The execution overhead does not increase. In particular, the overhead at the time of execution can be significantly reduced by the table comparison and interrupt processing by the ASIC as described above.

(10) Tenth Embodiment (Structure) This embodiment is an embodiment corresponding to the eleventh aspect of the present invention. In each of the above embodiments, scenario information as a sequential execution history has been targeted.
This embodiment is directed to a super-sequential program capable of generating scenario information. That is, in the present embodiment, as shown in FIG.
It comprises a debugging unit 26, a runtime comparison information generation unit 41, an execution unit 8, a comparison unit 10, and a comparison result display unit 11.

(Operation) In the present embodiment having the above-described configuration, the parallel program 1 is converted into a super-sequential program 23 by the serialization means 22.
Is subjected to test debugging by the test debugging means 26. As described above, the ultra-sequential program 2 confirmed to operate normally by test / debugging
3, the runtime comparison information generating means 41 generates runtime comparison information 42.

Then, when the concurrent program 1 is executed by the execution means 8, the comparing means 10 compares the execution information 9 of the program with the comparison information 42 at the time of execution. If the behavior is not described above, the comparison result display means 11 warns the user.

(Effects) According to the present embodiment as described above, the same effects as those of the first embodiment can be obtained, and in general, a program (scenario information) for generating the scenario information rather than the scenario information itself. Here, the super-sequential program 23) has a smaller storage capacity because it is targeted.
The memory can be effectively used, and quick processing can be performed.

(11) Eleventh Embodiment (Structure) This embodiment corresponds to the invention described in claim 12, and is substantially the same as the tenth embodiment as shown in FIG. The comparison result display means 11
Do not have. Then, the comparing means 1 operates so that the concurrent program 1 does not operate in the behavior not included in the runtime comparison information 42.
0 generates the execution control information 21 for controlling the execution of the concurrent program 1 based on the comparison result between the execution information 9 of the program and the comparison information 42 at the time of execution, and controls the execution of the execution means 8. Have been.

(Operation) In the present embodiment having the above-described configuration, the parallel program 1 is converted into a super-sequential program 23 by the serializing means 22.
Is subjected to test debugging by the test debugging means 26. As described above, the ultra-sequential program 2 confirmed to operate normally by test / debugging
3, the runtime comparison information generating means 41 generates runtime comparison information 42.

When the execution means 8 executes the concurrent program 1, the comparing means 10 compares the execution information 9 of the program with the comparison information 42 at the time of execution. If the behavior does not exist, the comparing means 10 executes the execution control information 21.
Is generated. Then, based on the execution control information 21, the execution of the concurrent program 1 by the execution means 8 is controlled so as not to move in a behavior not included in the execution time comparison information 42.

(Effects) According to the present embodiment as described above, the same effects as those of the second embodiment can be obtained, and the effective use of the memory,
Rapid processing becomes possible.

(12) Twelfth Embodiment (Structure) This embodiment corresponds to the invention described in claim 13, and further improves the tenth embodiment or the eleventh embodiment. It was done. That is, the difference is that a good non-deterministic introduction means for introducing good non-determinism into the super-sequential program 23 is provided.

(Operation) In the present embodiment as described above,
The parallel program 1 is converted into a super-sequential program 23 by the serialization means 22, and the super-sequential program 23 is tested and debugged by the test debugging means 26. Good nondeterminism introduction means 27 partially introduces information about good nondeterminism into the ultra-sequential program 23 that has been confirmed to operate normally by test / debug.

Test and debug are further performed on the partially super-sequential program into which good nondeterminism has been partially introduced as described above. However, since the part related to good nondeterminism behaves nondeterministically, Test and debug for all behavior. In this manner, the test / debug and the introduction of the information about the good non-determinism are repeated, and the information about the good non-determinism is gradually added.

Further, from the partial hyper-sequential program into which good non-determinism has been introduced, the runtime comparison information generating means 41
Thus, the runtime comparison information 42 is generated. Then, when the execution program 8 executes the concurrent program 1, the comparison program 10 compares the execution information 9 of the program with the execution comparison data 42.

Here, in an embodiment obtained by improving the tenth embodiment, if the execution of the concurrent program 1 is not in the execution-time comparison information 42, the comparison result display means 11 uses the user. Warn the. Further, in an embodiment in which the eleventh embodiment is improved, if the execution of the concurrent program 1 is not behaving in the runtime comparison information 42, the execution control information 21 is generated by the comparing means 10. . Then, based on the execution control information 21,
The execution of the concurrent program 1 in the execution means 8 is controlled so as not to move in a behavior not included in the execution time comparison information 42.

(Effect) According to the present embodiment as described above, the same effects as those of the tenth and eleventh embodiments can be obtained, and the partial super-sequential Since the run-time comparison information 42 is created based on the program, it is possible to create a more reliable program.
Execution is possible.

(13) Other Embodiments The above embodiments are directed to concurrent programs which are generally difficult to develop, but are nondeterministic due to external input or nondeterminism due to processing system problems. The present invention is also applicable to a sequential program having

The size and the configuration of the computer for realizing the present invention and the number and the form of the CPU are free. For example, various configurations such as a computer network and distributed processing can be used freely. That is, the present invention provides a multi-C
The present invention is not limited to the configuration example using the PU, and may be a parallel computer having a shared memory, a parallel computer having no shared memory, a distributed network computer system, or a multitask system using a single CPU. In the case of a multitask system using a single CPU, a plurality of processes can exist in one CPU.

Further, as the invention of the sixteenth and seventeenth aspects, it is possible to configure a medium in which software for realizing the above embodiment is recorded.

[0101]

As described above, according to the present invention,
A program development support device, a program development support method, and a program development support program that can ensure the reliability of a program by displaying a signal such as a warning to a user when a behavior other than a scenario is executed during program execution. Can be provided.

Further, according to the present invention, a program development support apparatus, a program development support method, and a program capable of achieving high reliability of a program by controlling behavior other than a scenario during execution of the program are controlled. A medium on which the development support program is recorded can be provided.

[Brief description of the drawings]

FIG. 1 is a configuration diagram illustrating an example of a computer system that implements the present invention.

FIG. 2 is a block diagram showing a first embodiment of the present invention.

FIG. 3 is a block diagram showing a second embodiment of the present invention.

FIG. 4 is a block diagram showing a third embodiment of the present invention.

FIG. 5 is a block diagram showing a fifth embodiment of the present invention.

FIG. 6 is a flowchart showing a processing procedure in the embodiment of FIG.

FIG. 7 is a structural diagram showing an example of a concurrent program.

FIG. 8 is an explanatory diagram showing an example of the parallel program of FIG. 6 expressed in source code.

FIG. 9 is an explanatory diagram showing an example of the parallel program of FIG. 6 expressed by a state transition system.

FIG. 10 is an explanatory diagram showing an example of a scenario graph in the embodiment of FIG.

FIG. 11 is an explanatory diagram showing an example of a run-time control table representing executable transitions in the embodiment of FIG. 5;

FIG. 12 is an explanatory diagram showing an example of a run-time control table representing task switching in an execution state in the embodiment of FIG. 5;

FIG. 13 is a flowchart showing a procedure of executing a concurrent program and displaying a warning in the embodiment of FIG. 5;

FIG. 14 is a block diagram showing a ninth embodiment of the present invention.

FIG. 15 is a block diagram showing an example in which the embodiment of FIG. 14 is implemented in hardware.

FIG. 16 is a block diagram showing a tenth embodiment of the present invention.

FIG. 17 is a block diagram showing an eleventh embodiment of the present invention.

FIG. 18 is a block diagram illustrating an example of a parallel program creation support device.

FIG. 19 is a block diagram showing another example of the parallel program creation support device.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 ... Concurrent program 2, 30 ... Scenario creation means 3 ... Scenario information 6, 26 ... Test / debugging means 8 ... Execution means 9 ... Program execution information 10 ... Comparison means 11 ... Comparison result display means 12 ... Scenario registration means 13 ... User instruction 20 ... Execution suppression means 21 ... Execution suppression information 22 ... Serialization means 23 ... Super-sequential program 24 ... Parallelization means 25 ... Parallel program 27 ... Good concurrency introduction means 31 ... Scenario set 32 ... Scenario graph generation means 33 ... Scenario graph 34 ... Run-time control table creation means 35 ... Run-time control table 36 ... State abstraction function setting means 37 ... State abstraction function 38 ... Table comparison means 41 ... Run-time comparison information extraction means 42 ... Run-time control information 71: interrupt flag 72: task information 81: program execution task switching 82 ... interruption processing unit 101-1 to 101-N ... processor 102 ... I / O interface 103 ... shared memory 104 ... output device 105 ... input device 106 ... external storage device 601 and later steps of the 1300 or later ... Procedure

Claims (17)

[Claims] 1. A program development support device for supporting development of a program, comprising: scenario creation means for creating scenario information from a given program; execution means for executing the program; and program executed by the execution means. A program development support device, comprising: comparison means for comparing the execution information with the scenario information; and display means for displaying a comparison result by the comparison means. 2. A program development support device for supporting program development, wherein: a scenario creation unit that creates scenario information from a given program; an execution unit that executes the program; and a program executed by the execution unit. And a comparison means for comparing the execution information of the program with the scenario information, wherein the execution means controls the execution of the program based on a comparison result by the comparison means. 3. The program development support device according to claim 2, further comprising display means for displaying a result of comparison by said comparison means. 4. The apparatus according to claim 1, further comprising a registration unit for adding a new scenario to said scenario information.
The program development support device according to any one of the preceding claims. 5. State abstraction means for abstracting the execution state of the program, and scenario graph generation means for representing the scenario information as a finite state transition graph based on an abstraction function obtained by the state abstraction means The program development support device according to any one of claims 1 to 4, further comprising: 6. The program development support device according to claim 5, wherein the abstraction function is a hash function. 7. A program according to claim 7, further comprising a designation unit for designating a subset of elements constituting a state of the program, wherein the state abstraction unit targets only the elements of the subset designated by the designation unit. The program development support device according to claim 5 or 6, wherein 8. The scenario information according to claim 1, wherein an execution priority is set in the scenario information.
The described program development support device. 9. A program according to claim 7, wherein said execution information includes a safe state storage means for forcibly changing the state of the program to a safe state when there is no behavior matching the scenario information. The program development support device according to claim 1 or 2. 10. An execution task switching unit for selecting a scenario by switching execution tasks, wherein the execution means includes:
3. The program development support device according to claim 1, further comprising an interrupt processing unit that performs an interrupt process based on information for controlling execution of the program. 11. A program development support device for supporting the development of a concurrent program, comprising: a serializing means for converting a given concurrent program into a super-sequential program that can be sequentially executed; Runtime comparison information generating means for generating; execution means for executing the concurrent program; execution information of the concurrent program executed by the execution means; and comparison means for comparing the runtime comparison information; And a display means for displaying a result of comparison by the means. 12. A program development support apparatus for supporting the development of a concurrent program, comprising: a serializing means for converting a given concurrent program into a hyper-sequential program that can be sequentially executed; Runtime comparison information generating means for generating; execution means for executing the concurrent program; execution information of the concurrent program executed by the execution means; and comparison means for comparing the runtime comparison information; Means for controlling execution of the concurrent program based on a result of comparison by the comparing means. 13. An ultra-sequential program having an introduction unit for introducing good non-determinism into the super-sequential program, wherein the run-time comparison information generation unit generates the run-time comparison information from the hyper-sequential program into which good non-determinism is introduced. 13. The program development support apparatus according to claim 11, wherein 14. A program development support method for supporting program development, comprising: creating scenario information from a given program; executing the program; comparing execution information of the program with the scenario information; A program development support method characterized by displaying a result. 15. A program development support method for supporting program development, comprising: creating scenario information from a given program; executing the program; comparing execution information of the program with the scenario information; A program development support method, wherein the execution of the program is controlled based on a result. 16. A medium on which a program development support program for supporting program development is recorded, the program comprising: a scenario creation process for creating scenario information from a given program; an execution process for executing the program; A medium recording a program development support program, comprising: a comparison process for comparing execution information of a program with the scenario information; and a display process for displaying a result of the comparison. 17. A medium recording a program development support program for supporting program development, wherein the program is a scenario creation process for creating scenario information from a given program; an execution process for executing the program; A medium recording a program development support program, comprising: a comparison process for comparing execution information of a program with the scenario information; and an execution control process for controlling execution of the program based on the comparison result.