JP2002333992A - Execution order inspecting device and its program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide an execution order inspecting device capable of checking whether or not low order programs are called in a valid order by a high order program, and the low order programs are actually executed. SOLUTION: The judgment information of the validity of a call order from a high order program is generated by low order programs. To be more specific the corresponding relation of low order functions to be called to the execution order is prepared as execution order information, and the call judgment processing is executed, and the execution order information is acquired in the low order functions (S200). Then, its own execution order j is acquired (S220), and when it is judged that the call order from a high order function F is valid (S230: YES), its own execution order j is substituted for a variable Yi as the judgment information (S240). Therefore, whether or not the call order from the high order function F is valid can be judged based on whether or not the variable Yi is equal to 'j-1'.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program connection check.

[0002]

2. Description of the Related Art Conventionally, a processing program for realizing a predetermined function such as an engine control is generally described as a set of a plurality of programs as execution units.
For example, in the case of a functional programming language, an execution unit program is prepared as a function.

In the process of developing such a processing program, a unit test of a program as an execution unit is performed, and subsequently, a combination test is performed. In the functional language described above,
A unit test is performed to determine whether a function unit functions normally, and a combined test is performed to determine whether a series of functions function in cooperation.

[0004] By the way, a program of an execution unit is usually described in a hierarchical manner, and a lower program which is a relatively lower layer program is called by an upper program which is a relatively upper layer program. At this time, data may be transferred between the upper program and the lower program. This is known in functional languages as function arguments.

[0005] Therefore, the above connection check generally requires that the lower program is called by the upper program in a proper order, and that normal data transfer between the upper program and the lower program is performed. Will be inspected. Therefore, conventionally, the connection inspection is performed by monitoring these data during execution of the processing program.

[0006]

However, in the inspection method for monitoring data as described above, there are many wastes in the following cases, and as a result, the time required for the inspection is increased. Would.

This is a case where a processing program designed so as not to transfer data between an upper program and a lower program is inspected for the purpose of enhancing the independence of the program of the execution unit. In this case, it is sufficient to confirm only that the upper program calls the lower program in a proper order.

Therefore, in this case, it is most conceivable that the connection check is performed such that the upper program determines whether or not the lower program has been called in a proper order. However, if it is determined in the upper program, control is passed to the lower program, and it is not known whether the lower program was actually executed.

SUMMARY OF THE INVENTION The present invention has been made to solve the above-mentioned problem, and it is intended to check that a lower program is called by a higher program in a proper order and that the lower program is actually executed. It is an object to provide an execution order inspection device.

[0010]

The execution order checking apparatus of the present invention prepares execution order information indicating a proper execution order of a lower program by an upper program. For example, when three lower programs A, B, and C are called in the order of A → B → C by the upper program, the execution order information is “1” for the A lower program and “1” for the B lower program. It is conceivable to provide correspondence information in which a lower program of "3" and a numerical value indicating the execution order correspond to the lower program of "2" and the lower program of C.

Then, the lower program executes a call determination process to determine whether or not the calls from the upper program have been made in a proper order. However, in order to determine whether or not a call is in a legal order in a certain lower-level program, it is necessary to determine not only the order of its own execution but also the order in which another lower-level program has a legal order in the past. You have to know that you are being called.

Therefore, in the above-described call determination processing, when it is determined that calls are made in a proper order, call information that can specify the order of the execution order of the call is set as a processing result. For example, if it is determined that the lower programs of A, B, and C are called in the proper order, the numerical values of "1", "2", and "3" corresponding to the order are respectively used as the call information. .

In the lower-level program, call information which is a processing result of the call determination processing executed in the past,
Based on the execution order information described above, it is determined whether or not the call from the host program is made in a proper order. Specifically, when the execution order information is the above-described correspondence information and the call information is information indicating the call order by a numerical value, for example, the B lower-level program has its own proper call order known from the execution order information of “2”. Therefore, if the call information generated in the closest past is “1”, it is determined that the call from the higher-level program has been made in a proper order. Similarly, since the legitimate call order of the C lower-order program known from the execution order information is “3”, the call information generated in the nearest past is “2”.
If so, it is determined that the calls from the higher-level program have been made in a proper order. In addition, since the legitimate call order of the A lower-order program, which is known from the execution order information, is “1”, if no call information has been generated in the past,
For example, if the call information is the default value,
Judge that the call from the host program was made in a proper order.

[0014] After executing all the lower programs to be called, the upper program executes a judging process for judging whether or not the lower programs have been called in a correct order based on the processing result in the call judging process. In the above example, if the call information generated in the closest past is "3", it is determined that all the lower programs to be called have been called in the correct order.

That is, according to the present invention, the lower program itself determines the validity of the call sequence from the upper program, and finally, based on the determination result, the call sequence of the lower program to be called by the upper program. Is determined. This makes it possible to check that the lower program is called by the upper program in a proper order and that the lower program is actually being executed.

The above-described call information can directly specify the order of the call in the execution order.
Alternatively, any information that can be specified indirectly using the execution order information may be used. The former may be a numerical value that directly indicates the execution order as described above. On the other hand, the latter
For example, the information may be information that can specify a called lower-level program. This is because, by using the execution order information, it is possible to indirectly specify the order of the call of the lower-order program in the execution order. Further, the execution order information is not limited to the information indicating the correspondence between the lower-order program and the execution order (numerical value). For example, lower program names may be arranged in the order of execution.

It is conceivable that the above-mentioned call information is substituted into one global variable commonly used between the upper program and the lower program (claim 2). Needless to say, if a global variable is used, call information can be shared by a plurality of programs. However, if it is assigned to one global variable, it is advantageous in that the storage area can be reduced.

On the premise of this configuration, in the call determination processing, when it is determined that the calls from the upper-level program are not made in a proper order, it is conceivable not to update the processing result assigned to the global variable. (Claim 3). Thus, even when one global variable is used, it is possible to know which lower-level program has been called in a proper order.

In the call determination process, when it is determined that the calls from the higher-level program are not made in a proper order, information indicating that fact may be output (claim 4). For example, if an error in the execution order is notified, it is convenient to know the occurrence of the error at an early stage before a series of inspection processing ends.

Incidentally, the lower-level program to be called by the upper-level program is generally specified in units of a predetermined event. Therefore, assuming this, the execution order information is prepared for each event, an event specifying process for specifying an event to be inspected is executed in an upper program, and an event specifying process is performed in a call determining process in a lower program. It is conceivable to make a determination based on the execution order information prepared corresponding to the event specified in the processing (claim 5). This makes it possible to easily perform a connection test to be executed in response to a plurality of events, and further reduce the time required for the connection test. For example, a connection test for a plurality of events can be automatically performed. And in this case,
In the determination process, it is desirable to output the result of the determination for each event (claim 6).

Each of the above-described processes is executed in a lower-level program or a higher-level program. However, considering that the processes are inserted and used only at the time of inspection, they are prepared in a macro description, and It is convenient to execute the program by linking to (claim 7).

In the above description, the execution order checking apparatus has been described. However, the present invention can also be realized as an invention of a program described by a macro or the like as described above.

[0023]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is an explanatory diagram schematically showing the program configuration of the embodiment. In this example,
It is assumed that the processing program is described in a functional programming language, and among a plurality of programs as execution units, a relatively upper-layer program is called an upper function, and a relatively lower-layer program is called a lower function. FIG. 1 shows a certain upper function F and lower function groups f1, f2,... Called from this higher function. In the following description, when the lower functions are not particularly distinguished, they are simply referred to as “lower functions f”.

The upper function F and the lower function groups f1, f
It is assumed that a function corresponding to a specific event such as an initialization event or a periodic event is realized by some of the lower-order functions f among 2,. By the way, the hierarchical relationship between the functions shown here indicates a part of the entire processing program for realizing the predetermined function.
It is also conceivable that the upper function F becomes a lower function of the function of the higher hierarchy.

In this embodiment, the upper function F to the lower function f
Are called in the correct order to check whether the lower-order function f is actually executed. Therefore, in the upper function F,
In the process, an event specifying process is called prior to a series of calls of the lower-level function f corresponding to the event (S1). When a series of calls of the corresponding lower-level function f is completed, a determination process is called (S3). On the other hand, the lower-level function f calls a call determination process in the process (S2). Note that the processing steps are simply indicated by a symbol S. The same applies to the following.

The event identification processing, the determination processing, and the call determination processing are prepared by being described in a macro.
At the time of inspection, a predetermined instruction is given to compile and link to link to the upper function F or the lower function f. When the inspection is not performed, the above-mentioned S1, S
A dummy function is linked to the call destinations of S2 and S3.

In the call decision processing in the lower function f, the call decision processing from the upper function F is performed based on the execution order information 30 prepared in advance and the call information which is the processing result of the call decision processing executed most recently in the past. Determine if the calls were made in the proper order.

The execution order information 30 includes, for each event, lower functions f1, f2,.
.., N. fM and its valid execution order 1, 2,..., N. The execution order information 30 can be prepared at the time of designing the upper-level function F, and can be prepared as a header file. Therefore, the lower-order function f is obtained at the time of compiling and linking as described above.
The execution order information 30 is included.

The program 10 that implements the above-described macro-described event identification processing, determination processing, and call determination processing corresponds to a “program”. The inspection device 20 that executes the upper function F and the lower function f linked with the program 10 corresponds to an “execution order inspection device”. Therefore, the inspection device 20 uses the CP
It has a configuration as a so-called computer system including a U, a ROM, a RAM, an input / output device, and the like. The configuration of such a computer system is well known to those skilled in the art and will not be described.

Next, the characteristic operation of the inspection apparatus 20, that is, the functions exhibited by the program 10 will be described with reference to flowcharts. First, when the processing of the upper function F is executed, the event specifying processing is executed prior to the call of the lower function f (S1).

FIG. 2 is a flowchart showing the event specifying process. First, in S100, an event is specified. That is, the upper function F performs an operation corresponding to a plurality of events, and the lower function f to be called changes depending on the event. Therefore, here, the event i is specified by substituting the number i corresponding to the event to be inspected into the variable X. The number i may be input by the operator prior to the inspection, or may be automatically set.

At S110, a global variable Yi corresponding to the event number i is set. A storage area for outputting the inspection result for each event is secured in advance,
Here, the storage area is set as a variable Yi. Then, after the processing of S110 ends, the present event specifying processing ends.

After executing such an event specifying process, the upper function F becomes the lower function f to be actually called.
Call. Then, the lower function f executes a call determination process (S2) to determine the validity of the call order from the upper function F. FIG. 3 is a flowchart showing the call determination process.

First, in step S200, the execution order information 30 prepared corresponding to the event of the number i is acquired with reference to the variable X. In subsequent S210, the variable Yi is set to “0”.
x7F ”or more is determined. Here "0x"
Indicates hexadecimal notation. In the present embodiment, when it is finally determined by the upper function F that the calling order of the lower function f is correct, “0x80” is substituted for the variable Yi. On the other hand, when it is determined that the calling order is incorrect. , “0x7F” is substituted for the variable Yi. Therefore, this determination processing is for determining whether or not “normal / abnormality determination” has already been performed. Where Yi ≧ 0x7
When it is determined to be F (S210: YES), that is, when the normality / abnormality determination has already been made, the present call determination processing is terminated without executing the subsequent processing. On the other hand, if Yi <0x7F (S210: NO), S
Move to 220.

In step S220, the own execution order j is obtained. Then, in the next S230, the variable Yi is set to “j−1”.
Judge whether it is equal to or not. Here, if Yi = j−1 (S230: YES), the own execution order j is substituted for Yi in S240, and then the present call determination processing ends. On the other hand, if Yi ≠ j−1 (S230: N
O), the process of S240 is not performed, and the call determination process ends.

That is, when it is determined that the calling order from the upper-level function F is valid (S230: YES), its own execution order j is substituted for Yi (S240), and the process ends. For example, when the calling order of the lower-order function f is the second, and the lower-order function F is called in a proper order (S230: YES), “2” is substituted for the variable Yi. Therefore, for example, in the call determination process in the lower-order function f having the third call order, after acquiring its own execution order j (= 3) in S220, Yi becomes “j−1”.
If (= 2) (S230: YES), it is determined that the calls were made in a proper order. On the other hand, after acquiring its own execution order j (= 3), if Yi is not “j−1” (≠ 2), it is determined that the call order is not valid and S240 is performed.
Do not execute the process. Therefore, in S240, the variable Y
The numerical value assigned to i corresponds to “call information”.

When such a call determination process is executed in all the lower functions f to be called, if the calling order by the upper function F is valid, the execution order of the lower function f that was called last j should be substituted for Yi. Therefore, in the upper-level function F, a determination process is performed (S
3) Determine the validity of the call order.

FIG. 4 is a flowchart showing the determination process. First, in the first S300, the variable Yi is set to “0x
7F ”or more. This determination is similar to S210 in FIG. 3 described above, and determines whether or not “normality / abnormality determination” has already been performed. Here, when it is determined that Yi ≧ 0x7F (S
300: YES), that is, in the case where the normal / abnormal judgment has been made, the present judgment processing ends without executing the subsequent processing. On the other hand, if Yi <0x7F (S30
0: NO), and proceeds to S310.

In S310, it is determined whether or not the variable Yi is equal to the number N. This number N is the execution order j of the lower function fM called last. Here, if Yi = N (S310: YES), normality is determined in S320, “0x80” is substituted for the variable Yi, and this determination processing ends. On the other hand, if Yi ≠ N (S310: NO),
In S330, an abnormality is determined, “0x7F” is substituted for the variable Yi, and the present determination processing ends.

As described above, according to the present embodiment, by executing the call determination processing by the lower function f, each of the lower functions f to be called determines the validity of its own call order ( S220 to S240 in FIG. 3). Finally, based on the result of the determination, the upper-level function F executes a determination process to determine the validity of the calling order of the lower-level function f to be called (S310 to S33 in FIG. 4).
0). As a result, the lower-order function f is called by the upper-order function F in a proper order, and the lower-order function f is actually called.
Is running.

When each lower-level function f determines that the call order from the upper-level function F is valid (S230: YES in FIG. 3), the lower-order function f sets its own execution order j as call information to one global function. Assigned to the variable Yi (S24
0). By preparing one global variable Yi in this way, even if the number of lower-level functions f called from the upper-level function F increases or decreases, the storage area required for the inspection does not increase or decrease, and as a result, the storage area is reduced. No pressure on the area. Further, the result of the final determination process by the upper-level function F is also assigned to the global variable Yi (S32 in FIG. 4).
0, S330), the storage area required for the inspection is reduced.

Further, it is determined whether or not a normal / abnormal determination has already been made (S210 in FIG. 3, S30 in FIG. 4).
0) When the normal / abnormal state is determined, the variable Yi is not updated. This is convenient when the value of the variable Yi is monitored without changing the value of the variable Yi even if the inspection process is repeatedly performed.

The execution order information 30 is prepared for each event realized by the upper function F and the lower function f. Then, in the upper function F, an event is specified by an event specifying process (S100 in FIG. 2), and in the call determining process of the lower function f, the execution order information 30 is acquired according to the event specified here (FIG. 3). S200). As a result, an inspection to be executed in response to a plurality of events can be easily performed, and the time required for the inspection can be further reduced. For example, if the number i corresponding to the event substituted in S100 is automatically incremented, inspection for a plurality of events can be performed automatically. At this time, since the global variable Yi is prepared corresponding to the event number i (S110), the result of the determination can be output for each event.

Further, the program 10 of the embodiment is
It is described by a macro and linked to the upper function F or the lower function f at the time of inspection and executed. Therefore, it is only necessary to describe the processes S1, S2, and S3 for calling the program 10 in the upper function F and the lower function f themselves, which is convenient for the operator.

As described above, the present invention is not limited to such an embodiment, and can be implemented in various forms without departing from the gist of the present invention. For example, in the above embodiment, the result of the determination processing by the higher-order function F is substituted for the variable Yi (S320, S330 in FIG. 4), but the result of the determination processing may be substituted for another variable Z. In this way, the execution order j of the final lower-order function f called in the proper order is substituted for the variable Yi (S240 in FIG. 3). (S230: NO) Since the execution order j is not substituted, it is possible to know, based on the variable Yi, which lower function f has been called in a proper order after the determination processing by the upper function F. When preparing the variable Z, it is desirable to prepare it in correspondence with each event.

Also, for example, the above-described configuration performs the inspection / determination substantially only once by determining whether the normal / abnormal state is determined. However, even if it is determined to be normal at first, there is a possibility that an abnormality is determined (a defect is found) during repeated execution.
Therefore, it is possible to adopt a configuration in which the inspection / judgment processing is repeatedly performed until an abnormality is detected.

For example, in the above embodiment, an error in the execution order can be finally found based on the result of the judgment processing by the upper function F. However, in the call judgment processing of the lower function f, an error in the execution order is notified. Is also good. Specifically, such a notification process may be executed after a negative determination is made in S230. This is convenient because the operator can recognize the occurrence of an error at an early stage before the end of a series of inspection processes.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram schematically showing a program configuration of an embodiment.

FIG. 2 is a flowchart showing an event specifying process by a higher-order function.

FIG. 3 is a flowchart showing a call determination process by a lower function.

FIG. 4 is a flowchart illustrating a determination process by a higher-order function.

[Explanation of symbols]

 10 program 20 inspection device 30 execution order information

Claims (8)

[Claims] When a processing program for realizing a predetermined function is described as a set of a plurality of programs serving as execution units, a higher-level program that is a relatively higher-level program uses a relatively lower-level program. An execution order checking device for checking whether or not a lower program that is a program is called and executed in a proper order, wherein execution order information indicating a proper execution order of the lower program by the higher program is prepared. In the lower program, it is determined whether or not the call from the upper program has been made in a valid order, and if it is determined that the call has been made in a valid order, the order of the call in the execution order Or call information that can be specified indirectly using the execution order information as the processing result. A Lumpur determination process,
The execution order information and a call determination process for making the determination based on the call information that is a processing result of the call determination process performed by another lower-level program are executed. After executing all of the lower-order programs, a judgment process for judging whether or not the lower-order programs have been called in a correct order is executed based on the processing result in the call judgment process. apparatus. 2. The execution order checking device according to claim 1, wherein the call information is substituted into one global variable commonly used between the upper program and the lower program. Execution order inspection device. 3. The execution order checking device according to claim 2, wherein in the call determination processing, when it is determined that the calls from the upper-level program are not made in a proper order, the processing substituted into the global variable. An execution order inspection apparatus characterized in that a result is not updated. 4. The execution order checking device according to claim 1, wherein in the call determining process, when it is determined that the calls from the upper-level program are not made in a proper order, the fact is notified. An execution order checking device for outputting information indicating the execution order. 5. The execution order checking device according to claim 1, wherein said lower order program to be called by said upper order program is specified in a predetermined event unit. Information is prepared for each event, and an event specifying process for specifying an event to be inspected is executed in the upper program, and in the call determining process in the lower program, the event specified in the event specifying process is performed. An execution order inspection device, wherein the determination is made based on the execution order information prepared in correspondence with (1). 6. The execution order inspection apparatus according to claim 5, wherein, in the determination processing, a result of the determination is output for each event. 7. The execution order checking device according to claim 1, wherein each of the processes executed by the upper-level program and the lower-level program is prepared as a macro description, and is linked to the processing program. An execution order inspection apparatus characterized by being executed after being executed. 8. A program for realizing each of the processes executed by the execution order checking device according to claim 1.