WO2022239148A1 - Equivalence inspection system and equivalence inspection program - Google Patents

Abstract

An effect state variable extraction unit (110) extracts, from each of an unchanged source code and a changed source code, an effect state variable of a target function that is repeatedly called upon. A determination step number calculation unit (120) calculates, as a determination step number, a number of times that the target function is called upon and that satisfies the condition in which: the unchanged target function is repeatedly called upon and the value of the effect state variable returns to an initial value; and the changed target function is repeatedly called upon and the value of the effect state variable returns to the initial value. A determination code generation unit (130) determines equivalence by repeatedly calling upon each of the unchanged target function and the changed target function the same number of times as the determination step number.

Description

Equivalence Checking System and Equivalence Checking Program

The present disclosure relates to differential analysis of software behavior.

In the control software installed in the control device, the control functions are computerized in order to respond to multi-functionality and increased added value. As a result, control software is rapidly increasing in scale and complexity.
In addition, it is expected that variations in control software will increase rapidly in the future due to differences in model derivations and destinations.
In order to maintain and strengthen profitability under these circumstances, it is necessary to work on improving productivity in the development of control software.

As a concrete measure, difference development and derivative development by introducing a software execution environment can be considered. The software execution environment includes communication processing, timer processing, scheduler, operating system (OS), middleware, and the like.
Another possible measure is to apply techniques and tools for ensuring quality and improving development efficiency to software development.

When implementing such measures, identify the scope of impact of changes to two versions of software that are developed daily before or after migration to a new execution environment. There is a need.
For this purpose, it is important to determine whether to modify the two source codes before and after the modification based on the content of the process rather than the appearance of the text.

On the other hand, there is a technology called equivalence checking that uses formal methods to determine where the processing content has been modified.

Equivalence checking is a technique for accurately determining whether or not processing contents have been modified in programming language function units for two source codes before and after modification.
Specifically, if the same output value is always obtained when the same input value is given to two functions that have correspondence before and after the change, it is determined that the processing contents are logically the same (that is, equivalent). Otherwise, it is determined that the processing contents are logically different (that is, unequal).

Also, a function may have multiple state variables, and the values (state values) taken by the state variables are inherited and changed from the previous step to the next step. Here, a step is a one-time process that is executed when a function is called. When a function has a state variable, each time the function receives an input value at each step, the execution part inside the function switches depending on the state value at that time, and the output value and the state value of the next step are determined by the processing content.
Patent Literature 1 discloses a technique for determining whether the processing contents of two functions having such state variables are equivalent.

WO2018/193548

In the equivalence check for functions with multiple state variables, the processing contents are analyzed for all steps from the initial state of each state variable until it returns to the initial state again.
Also, the amount of computer resources required for analysis is determined depending on the number of values taken by the state variables, that is, the number of states. If there is even one state variable with a very large number of states, the number of steps analyzed at one time may become very large, and the amount of computational resources required may become very large. Therefore, when state variables with a small number of states and state variables with a large number of states coexist in the source code, it is difficult to analyze the processing details regarding the number of steps until all state variables return to their initial states.

The purpose of the present disclosure is to enable equivalence checking while reducing the amount of computer resources.

The equivalence checking system of the present disclosure includes:
an influence state variable extraction unit for extracting an influence state variable, which is a state variable that influences an output value of a target function that is repeatedly called, from each of the pre-change source code and the post-change source code;
The target function is repeatedly called in the pre-change source code and the value of the effect state variable is returned to the initial value, and the target function is repeatedly called in the post-change source code and the value of the effect state variable is returned to the initial value. a determination step number calculation unit that calculates the number of times the target function is called that satisfies the condition of returning as a determination step number;
each of the target function of the pre-change source code and the target function of the post-change source code is repeatedly called the same number of times as the determination step number, and the target function of the pre-change source code and the post-change source code are called and an equivalence determination unit that determines whether the target functions are equivalent.

According to the present disclosure, equivalence checking can be performed by focusing on the influence state variables. Therefore, it is possible to perform the equivalence check while suppressing the amount of computer resources.

1 is a configuration diagram of an equivalence checking system 100 according to Embodiment 1. FIG. FIG. 2 is a functional configuration diagram of the equivalence checking system 100 according to the first embodiment; FIG. 4 is a diagram showing terms for functions in Embodiment 1. FIG. 4 shows an example of pre-change source code 201 according to the first embodiment; FIG. FIG. 2 shows an example of a post-change source code 202 according to the first embodiment; FIG. 4 is a flowchart of an equivalence checking method according to the first embodiment; 4 is a flowchart of the influence state variable extraction process (S110) according to the first embodiment; 4 is a diagram showing an affected portion 203 according to the first embodiment; FIG. FIG. 2 shows an affected portion 204 according to the first embodiment; FIG. 4 is a flowchart of determination step number calculation processing (S120) according to the first embodiment; 4 is a flowchart for calculating the number of return steps according to Embodiment 1; 4 is a diagram showing calculation code 221 according to Embodiment 1. FIG. 4 is a diagram showing calculation code 222 according to Embodiment 1. FIG. FIG. 4 shows analysis results 223 according to Embodiment 1; FIG. 4 shows analysis result 224 according to Embodiment 1; FIG. 4 shows a calculation code 225 according to Embodiment 1; FIG. FIG. 10 shows analysis results 226 according to Embodiment 1; FIG. FIG. 5 is a diagram showing how the value of the influence state variable returns to the initial value according to the first embodiment; FIG. 4 is a flow chart of determination code generation processing (S130) according to the first embodiment; FIG. 4 shows an example of pre-change source code 231 according to the first embodiment; FIG. FIG. 4 shows an example of a post-change source code 232 according to the first embodiment; FIG. 4 shows an example of a determination header 233 according to the first embodiment; FIG. 4 shows an example of a decision wrapper 234 according to the first embodiment; FIG. 4 is a flowchart of an equivalence determination process (S140) according to the first embodiment; FIG. 4 shows an example of an analysis result 241 according to the first embodiment; FIG. FIG. 4 shows an example of an analysis result 242 according to Embodiment 1; FIG. 2 is a hardware configuration diagram of the equivalence checking system 100 according to the first embodiment; FIG.

In the embodiments and drawings, the same or corresponding elements are denoted by the same reference numerals. Descriptions of elements having the same reference numerals as those described will be omitted or simplified as appropriate. Arrows in the figure mainly indicate the flow of data or the flow of processing.

Embodiment 1.
The equivalence checking system 100 will be described with reference to FIGS. 1 to 27. FIG.
The equivalence checking system 100 is used as a difference analysis system for software operations before and after change.

*** Configuration description ***
The configuration of the equivalence checking system 100 will be described based on FIG.
The equivalence checking system 100 is a computer comprising hardware such as a processor 101 , a memory 102 , an auxiliary storage device 103 , a communication device 104 and an input/output interface 105 . These pieces of hardware are connected to each other via signal lines.

The processor 101 is an IC that performs arithmetic processing and controls other hardware. For example, processor 101 is a CPU.
IC is an abbreviation for Integrated Circuit.
CPU is an abbreviation for Central Processing Unit.

Memory 102 is a volatile or non-volatile storage device. Memory 102 is also referred to as main storage or main memory. For example, memory 102 is RAM. The data stored in the memory 102 is saved in the auxiliary storage device 103 as required.
RAM is an abbreviation for Random Access Memory.

Auxiliary storage device 103 is a non-volatile storage device. For example, the auxiliary storage device 103 is ROM, HDD or flash memory. Data stored in the auxiliary storage device 103 is loaded into the memory 102 as required.
ROM is an abbreviation for Read Only Memory.
HDD is an abbreviation for Hard Disk Drive.

Communication device 104 is a receiver and transmitter. For example, communication device 104 is a communication chip or NIC. Communication of equivalence checking system 100 is performed using communication device 104 .
NIC is an abbreviation for Network Interface Card.

The input/output interface 105 is a port to which an input device and an output device are connected. For example, the input/output interface 105 is a USB terminal, the input device is a keyboard and mouse, and the output device is a display. Input/output of the equivalence checking system 100 is performed using the input/output interface 105 .
USB is an abbreviation for Universal Serial Bus.

The equivalence checking system 100 includes elements such as an influence state variable extraction unit 110 , a determination step number calculation unit 120 , a determination code generation unit 130 and an equivalence determination unit 140 . These elements are implemented in software.

The auxiliary storage device 103 stores an equivalence checking program for causing the computer to function as an influence state variable extraction unit 110 , a determination step count calculation unit 120 , a determination code generation unit 130 and an equivalence determination unit 140 . The equivalence checking program is loaded into memory 102 and executed by processor 101 .
The auxiliary storage device 103 further stores an OS. At least part of the OS is loaded into memory 102 and executed by processor 101 .
The processor 101 executes the equivalence checking program while executing the OS.
OS is an abbreviation for Operating System.

The input/output data of the equivalence checking program are stored in the storage unit 190 .
Memory 102 functions as storage unit 190 . However, a storage device such as the auxiliary storage device 103 , a register within the processor 101 and a cache memory within the processor 101 may function as the storage unit 190 instead of or together with the memory 102 .

The equivalence checking system 100 may include multiple processors that substitute for the processor 101 .

The equivalence checking program can be recorded (stored) in a computer-readable manner on a non-volatile recording medium such as an optical disc or flash memory.

FIG. 2 shows the functional configuration of the equivalence checking system 100. As shown in FIG.
In FIG. 2, arrows indicate main data flows.
The contents of each data will be described later.

***Description of operation***
The operating procedure of the equivalence checking system 100 corresponds to the equivalence checking method. Also, the operation procedure of the equivalence checking system 100 corresponds to the processing procedure of the equivalence checking program.
The equivalence checking method will be described below.

Based on FIG. 3, terminology for functions will be explained.
A single process that is executed when a function is called is called a "step".
The number of times the function is called is called the "step number". In other words, the number of steps corresponds to the number of times the function is executed. In FIG. 3, the number of steps is N.
A variable that serves as an input to a function is called an "input variable". Specifically, the input variables are the arguments or global variables required for processing the function.
The value of the input variable is called "input value". Each of in_1 to in_N represents the value of the input variable in at each step.
A variable that is the output of a function is called an “output variable”. Specifically, an output variable is a return value or global variable that represents the result of processing a function.
The value of the output variable is called "output value". Each of out_1 to out_N represents the value of the output variable out at each step.
A variable representing the state of the software is called a "state variable".
The values of state variables are called "state values". Each of st_1 to st_N represents the value of the state variable state at the end of each step.

State values are carried over from the previous step to the next step. For example, the state value st_1 at the end of the first step is used in the second step, and the state value st_2 at the end of the second step is used in the third step.
On the other hand, input and output values are not carried over from the previous step to the next step.

FIG. 4 shows an example of pre-change source code 201 . The pre-change source code 201 is the original source code. In FIG. 3, pre-change source code 201 is written in C language.
FIG. 5 shows an example of the post-change source code 202 . Modified source code 202 is modified source code. In FIG. 4, the post-change source code 202 is written in C language.
Different portions between the pre-change source code 201 and the post-change source code 202, that is, changed portions are underlined.

Each of pre-change source code 201 and post-change source code 202 includes a main function, a func1 function, and a func2 function.
The func1 function and the func2 function are functions to be checked for equivalence. A function to be checked for equivalence is called a "target function".

The target function is included in the pre-change source code 201 and the post-change source code 202, has a state variable, and is repeatedly called and executed.
The func1 and func2 functions are repeatedly executed while a specific condition is satisfied in the main function.

The pre-change source code 201 in FIG. 4 will be described.
The target function switches the part to be executed inside the function according to the state value each time an input value is received at each step. Then, the state value of the next step is determined by the execution result of the target function.
The func1 function has two state variables (state, counter). These state values then change each time the func1 function is executed.
In the initial state, the value of each of the state variable state and the state variable counter is 0.
When the func1 function is executed when the value of the state variable state is 0, the values of the state variable state and the state variable counter are changed to 1, respectively.
When the func1 function is executed when the value of the state variable state is 1, the values of the state variable state and the state variable counter are changed to 2, respectively.
When the func1 function is executed when the value of the state variable state is 2, the value of the state variable state changes to 0 and the value of the state variable counter changes to 3.
The state variable counter is a variable for recording statistical information about the number of times the func1 function is called. Each time the func1 function is called, 1 is added to the value of the state variable counter.

The func2 function has a state variable num. And this state value changes each time the func2 function is executed.
In the initial state, the value of the state variable num is 1.
Each time the func2 function is executed, 1 is added to the value of the state variable num. However, if the func1 function is executed when the value of the state variable num is 1000000000, the value of the state variable num returns to 1.

The target function determines the output value according to the content of the processing corresponding to the state value.
The func1 function determines an output value according to the content of processing corresponding to the value of the state variable state.
When the value of the state variable state is 0, the output value is represented by in+1 with respect to the input value in of the func1 function.
When the value of the state variable state is 1, the output value is represented by in+2 for the input value in of the func1 function.
When the value of the state variable state is 2, the output value is represented by in+3 with respect to the input value in of the func1 function.

The func2 function determines an output value according to the contents of processing corresponding to the value of the state variable num.
When the value of the state variable num is 1000000000, the output value is represented by in+1 for the input value in of the func2 function.
If the value of the state variable num is not 1000000000, the output value is expressed as in+num for the input value in of the func2 function.

The post-change source code 202 in FIG. 5 will be described.
In the post-change source code 202 , the output values of the func1 function and the func2 function are changed with respect to the pre-change source code 201 .
In the func1 function, when the value of the state variable state is 2, the output value is expressed as in+5 with respect to the input value in of the func1 function.
In the func2 function, when the value of the state variable num is 1000000000, the output value is expressed as in+2 for the input value in of the func2 function.

The equivalence checking method will be described based on FIG.
Steps S110 to S140 are executed for each target function.

In step S110, the influence state variable extraction unit 110 extracts influence state variables for the target function from the pre-change source code 201 and the post-change source code 202, respectively.
The effect state variables extracted from the pre-change source code 201 are referred to as pre-change effect state variables 211 .
The effect state variables extracted from the post-change source code 202 are referred to as post-change effect state variables 212 .
Influencing state variables are state variables that affect the output value of the target function.

The procedure of the influence state variable extraction process (S110) will be described based on FIG.
Steps S111 to S114 are executed by analyzing the pre-change source code 201 .
Steps S115 to S118 are executed by analyzing the modified source code 202 .

In step S<b>111 , the influence state variable extraction unit 110 extracts input variables from the target function of the pre-change source code 201 .
Specifically, when the target function reads a value from a variable, the influence state variable extraction unit 110 extracts the variable as an input variable.
For example, the influence state variable extraction unit 110 extracts the argument of the target function as an input variable. Also, the influence state variable extraction unit 110 extracts the global variable on the right side of the assignment operator “=” as an input variable.

Furthermore, the influence state variable extraction unit 110 extracts output variables from the target function of the pre-change source code 201 .
Specifically, when the target function writes a value to a variable, the influence state variable extraction unit 110 extracts the variable as an output variable.
For example, the influence state variable extraction unit 110 extracts the return value of the target function as an output variable. Also, the influence state variable extraction unit 110 extracts the global variable on the left side of the assignment operator “=” as an output variable.

In step S<b>112 , the influence state variable extraction unit 110 extracts, from the pre-change source code 201 , the influence portion of the target function on the output variables.
The influencing part is the part that affects the value of the output variable of the target function.
For example, the effect state variable extraction unit 110 extracts the effect part from the pre-change source code 201 using program slicing.

In step S<b>113 , the affected state variable extracting unit 110 extracts a non-function scope variable from the affected portion of the pre-change source code 201 .
An out-of-function scope variable is a variable that has an out-of-function scope of the target function and can be referenced from outside the target function. For example, global variables are out-of-function scope variables.

In step S<b>114 , the influence state variable extraction unit 110 excludes the input variables of the target function and the output variables of the target function from the non-function scope variables of the pre-change source code 201 .
The remaining out-of-function scope variables become pre-change impact state variables 211 .

In step S<b>115 , the influence state variable extraction unit 110 extracts input variables and output variables from the target function of the post-change source code 202 .
The extraction method is the same as the method in step S111.

In step S<b>116 , the influence state variable extraction unit 110 extracts from the post-change source code 202 the influence portion of the target function on the output variables.
The extraction method is the same as the method in step S112.

In step S<b>117 , the affected state variable extracting unit 110 extracts a non-function scope variable from the affected portion of the post-change source code 202 .
The extraction method is the same as the method in step S113.

In step S<b>118 , the influence state variable extraction unit 110 excludes the input variables of the target function and the output variables of the target function from the non-function scope variables of the post-change source code 202 .
The remaining out-of-function scope variables become post-change impact state variables 212 .

The influence state variable extraction processing (S110) will be described using the pre-change source code 201 in FIG. 4 and the post-change source code 202 in FIG. 5 as examples.
First, the effect state variable extraction unit 110 extracts the argument in as an input variable from the func1 function of each of the pre-change source code 201 and the post-change source code 202, and uses the return value specified in the return statement as an output variable. Extract.
In addition, the effect state variable extraction unit 110 extracts the argument in as an input variable from the func2 function of each of the pre-change source code 201 and the post-change source code 202, and uses the return value specified in the return statement as an output variable. Extract.
Next, the influence state variable extraction unit 110 extracts portions (influence portions) that affect the values of the output variables of the func1 and func2 functions from the pre-change source code 201 and the post-change source code 202, respectively.
The affected portion 203 is shown in FIG. The affected portion 203 is the affected portion extracted from the pre-change source code 201 in FIG.
Affected portion 204 is shown in FIG. Affected portion 204 is the affected portion extracted from modified source code 202 of FIG.
Then, the effect state variable extraction unit 110 extracts the effect state variable state for the func1 function and the effect state variable num for the func2 function from the respective effect portions of the pre-change source code 201 and the post-change source code 202. .

By the influence state variable extraction processing (S110), when a state variable with a very large number of states (the number of values taken by the state variable) does not affect the calculation of the output value, the number of determination steps 220, which will be described later, is reduced to the necessary minimum. can be reduced to

Returning to FIG. 6, the description continues from step S120.
In step S<b>120 , the determination step number calculation unit 120 calculates the determination step number 220 based on the influence state variables for the target function of the pre-change source code 201 and the post-change source code 202 .
The number of determination steps 220 determines whether the target function of the pre-change source code 201 and the target function of the post-change source code 202 are equivalent. is the number of times that is called and executed.

Specifically, the determination step number 220 is the number of calls (number of executions) of the target function when both the condition (1) and the condition (2) are satisfied.
Condition (1) is that the target function is repeatedly called in the pre-change source code 201 and the value of the affected state variable returns to the initial value.
Condition (2) is a condition that the target function is repeatedly called in the post-change source code 202 and the value of the affected state variable returns to the initial value.

Based on FIG. 10, the procedure of the determination step count calculation process (S120) will be described.
In step S<b>121 , the determination step number calculation unit 120 calculates the number of return steps of the target function of the pre-change source code 201 by analyzing the pre-change source code 201 .
The number of return steps is the number of calls (number of executions) of the target function when the target function is repeatedly called and the value of the affected state variable returns to the initial value.
A method for calculating the number of return steps will be described later.

In step S122, the determination step number calculation unit 120 calculates the number of return steps of the target function of the post-change source code 202 by analyzing the post-change source code 202.

In step S<b>123 , the determination step number calculation unit 120 calculates the least common multiple of the return step number of the target function of the pre-change source code 201 and the return step number of the target function of the post-change source code 202 .
The calculated lowest common multiple is the determination step number 220 .

The determination step number 220 can be calculated by the determination step number calculation process (S120). By using the number of determination steps 220, even if there are state variables with an extremely large number of states, it is possible to determine equivalence until both the target functions before and after the change return to the initial state.

A procedure for calculating the number of return steps will be described with reference to FIG.
In step s121, the judgment step number calculation unit 120 determines the upper limit number of steps based on the amount of computer resources that can be used for analysis of the calculation code, which will be described later.
The upper limit number of steps is the upper limit of the number of times the target function is executed without releasing computer resources.

In step s122, the determination step count calculator 120 generates a calculation code.
The calculation code is source code for calculating the number of return steps, and is also called a calculation wrapper.
Specifically, a calculation code for the first time and a calculation code for the second and subsequent times are generated.

FIG. 12 shows calculation code 221 . The calculation code 221 is an example of the first calculation code for the func1 function.
FIG. 13 shows an example of calculation code 222 . Calculation code 222 is an example of the first calculation code for the func2 function.
Code (0) to code (3) are described in each of the calculation code 221 and the calculation code 222 . The upper limit number of steps X is 1,000.
Code (0) is the code for saving the initial values of the effect state variables. The initial value of the impact state variable is the value of the impact state variable when the subject function is first called.
Code (1) is a code for calling the target function the same number of times as the upper limit number of steps. In this case, 1000 steps of processing for reading the target function are described.
Code (2) is a code for determining whether the post-condition is satisfied for the same number of times as the upper limit number of steps. The condition that the value of the influence state variable is equal to the initial value is the postcondition. In this case, 1000 steps of post-condition determination processing are described.
Code (3) is for recording the value of the influence state variable at the end of the upper limit number of steps. The value of the influence state variable at the end of the upper limit number of steps is referred to as the final step state value.

Returning to FIG. 11, the description continues from step s123.
In step s123, the number-of-judgments-steps calculation unit 120 secures computer resources for the analysis of the calculation code for the first time.

In step s124, the determination step count calculator 120 analyzes the calculation code and executes the calculation code.
For example, the determination step count calculator 120 analyzes the calculation code using bounded model checking.
In step s124 for the first time, the calculation code for the first time is used.
In step s124 for the second and subsequent times, the calculation code for the second and subsequent times is used.

In step s125, the judgment step number calculation unit 120 judges whether the value of the influence state variable has returned to the initial value in any step up to the upper limit number of steps, based on the analysis result of the calculation code.
If the value of the influence state variable returns to the initial value at any step up to the upper limit number of steps, the process proceeds to step s128.
If the value of the influence state variable has not returned to the initial value in any step up to the upper limit number of steps, the process proceeds to step s126.

The analysis result 223 is shown in FIG. The analysis result 223 is the analysis result of the first calculation code 221 for the func1 function.
FAILURE means that the value of the impact state variable is different from the initial value.
SUCCESS means that the value of the impact state variable is equal to the initial value.
Analysis result 223 indicates that the value of the influence state variable of the func1 function returns to the initial value in the third step.
In this case, after step s125, the process proceeds to step s129.

The analysis result 224 is shown in FIG. The analysis result 224 is the analysis result of the first calculation code 222 for the func2 function.
Analysis result 224 indicates that the value of the influence state variable of the func2 function does not return to the initial value by the 1000th step.
In this case, after step s125, the process proceeds to step s126.

Returning to FIG. 11, the description continues from step s126.
In step s126, the number-of-judgments-steps calculator 120 temporarily releases the computer resources reserved for the analysis of the first calculation code (or the second and subsequent calculation codes).
Note that the state value of the final step is recorded in a storage area other than the computer resource to be released.

In step s127, the number-of-judgments-steps calculation unit 120 secures computer resources again for analysis of calculation codes for the second and subsequent times.
After step s127, the process proceeds to step s124.

In step s124 for the second and subsequent times, the calculation code for the second and subsequent times is used.
A code for taking over the state value of the final step is added to the second and subsequent calculation codes.

Calculation code 225 is shown in FIG. Calculation code 225 is an example of calculation code for the second and subsequent times for the func2 function.
Code (0) is changed and code (4) is added to the calculation code 222 of FIG.
Code (0) saves the initial value of the effect state variable "1" without using the effect state variable "num".
Code (4) is a code for taking over the state value of the final step. The state value of the final step is set to the influence state variable num. state_last_step represents the state value of the last step.

Returning to FIG. 11, step s128 will be described.
In step s128, the judgment step number calculation unit 120 judges the number of steps when the value of the influence state variable returns to the initial value for the first time as the number of return steps. Thereby, the number of return steps is obtained.

When the analysis result 223 of FIG. 14 is obtained, the determination step number calculation unit 120 determines that the number of return steps of the func1 function is 3.

The analysis result 226 is shown in FIG. The analysis result 226 is the analysis result when the calculation code for the func2 function is analyzed 1000000 times.
When the analysis result 226 of FIG. 17 is obtained, the determination step count calculator 120 determines that the return step count of the func2 function is 1000000000 (=X×1000000). The upper limit number of steps X is 1,000.

FIG. 18 shows how the calculation code is parsed ten times and the values of the impact state variables return to their initial values.
The upper limit number of steps X is determined based on the amount of computer resources that can be used for one analysis of the computational code.
The subject function is called X times each time the computational code is parsed.
Each time the computational code is parsed, the computer resource is once released and reallocated.
Each time the computational code is parsed, it inherits the state value of the last step.

Returning to FIG. 6, the description continues from step S130.
In step S<b>130 , the determination code generation section 130 generates the determination code 230 based on the number of determination steps 220 .
The determination code 230 repeatedly calls the target function of the pre-change source code 201 and the target function of the post-change source code 202 the same number of times as the number of determination steps 220, and determines the target function of the pre-change source code 201 and the post-change source code. 202 is a source code for determining whether the target functions of 202 are equivalent.

Based on FIG. 19, the procedure of determination code generation processing (S130) will be described.
In step S<b>131 , the determination code generation unit 130 edits the pre-change source code 201 and the post-change source code 202 in order to eliminate name conflicts between the pre-change source code 201 and the post-change source code 202 .
As a result, pre-change source code 231 and post-change source code 232 are generated.
The pre-change source code 231 is the edited pre-change source code 201 .
The modified source code 232 is the edited modified source code 202 .
Specifically, determination code generation unit 130 attaches different prefixes or suffixes to function names and global variable names between pre-change source code 201 and post-change source code 202 .

FIG. 20 shows an example of pre-change source code 231 .
FIG. 21 shows an example of the post-change source code 232 .
In the pre-change source code 231, the function names "main", "func1" and "func2" and the global variable names "state" and "counter" are each given the suffix "_1".
In the post-change source code 232, the function names "main", "func1" and "func2" and the global variable names "state" and "counter" are each given the suffix "_2".
As a result, function names and global variable names are distinguished between the pre-change source code 231 and the post-change source code 232, and conflicts in names are eliminated.

Returning to FIG. 19, the description continues from step S132.
In step S<b>132 , the determination code generator 130 generates the determination header 233 .
The determination header 233 is a header describing a declaration necessary for determining whether the target function of the pre-change source code 231 and the target function of the post-change source code 232 are equivalent.
Specifically, the determination code generation unit 130 describes the prototype declaration of the target function of the pre-change source code 231 and the prototype declaration of the target function of the post-change source code 232 in the determination header 233 . In addition, the determination code generation unit 130 writes, in the determination header 233, the extern declaration of the global variables of the pre-change source code 231 and the extern declaration of the global variables of the post-change source code 232, etc., as necessary.

FIG. 22 shows an example of the determination header 233. As shown in FIG.
The determination header 233 describes the declarations of the target functions “func1_1” and “func2_1” of the pre-change source code 231 and the declarations of the target functions “func1_2” and “func2_2” of the post-change source code 232 .

Returning to FIG. 19, step S133 will be described.
In step S<b>133 , the judgment code generation unit 130 generates the judgment wrapper 234 .
The determination wrapper 234 is a wrapper that describes processing necessary to determine whether the target function of the pre-change source code 231 and the target function of the post-change source code 232 are equivalent.
Specifically, the determination code generation unit 130 writes code (A) to code (C) in the determination wrapper 234 .
Code (A) is a code for specifying preconditions. The precondition is that the input value of the target function of the pre-change source code 231 and the input value of the target function of the post-change source code 232 are the same in all the steps corresponding to 220 determination steps.
Code (B) is a code for repeatedly calling each of the target function of the pre-change source code 231 and the target function of the post-change source code 232 as many times as the determination step number 220 .
Code (C) is a code for determining whether the postcondition is satisfied. The post-condition is that the output value of the target function of the pre-change source code 231 and the output value of the target function of the post-change source code 232 are equal in all steps corresponding to 220 determination steps.

FIG. 23 shows an example decision wrapper 234 for the func1 function.
The determination step number STEP is three.
In code (A), preconditions for three steps are specified.
In code (B), the func1 function (func1_1, func1_2) is called three times.
In code (C), three steps of postconditions are determined.

A set of pre-change source code 231 , post-change source code 232 , decision header 233 and decision wrapper 234 is decision code 230 .

The determination code 230 can be generated by the determination code generation process (S130). By using the determination code 230, even when there are state variables with a very large number of states, it is possible to correctly determine whether the processing contents of the target function before and after the change are equivalent.

Returning to FIG. 6, step S140 will be described.
In step S140, the equivalence determination unit 140 uses the determination code 230 to determine whether the target function of the pre-change source code 201 and the target function of the post-change source code 202 are equivalent.

Based on FIG. 24, the procedure of the equivalence determination process (S140) will be described.
In step S<b>141 , the equivalence determination unit 140 analyzes the determination code 230 and executes the process of the determination wrapper 234 .
For example, the equivalence determination unit 140 analyzes the determination code 230 using bounded model checking.

In step S<b>142 , the equivalence determination unit 140 determines whether the target function of the pre-change source code 201 and the target function of the post-change source code 202 are equivalent based on the analysis result of the determination code 230 .
The analysis result of the judgment code 230 corresponds to the processing result of the judgment wrapper 234 .

In step S<b>143 , the equivalence determination unit 140 outputs the determination result 240 .
The determination result 240 indicates whether the target function of the pre-change source code 201 and the target function of the post-change source code 202 are equivalent. The determination result 240 also indicates a step (inequality step) at which the target function of the pre-change source code 201 and the target function of the post-change source code 202 become unequal.

FIG. 25 shows an example of the analysis result 241. As shown in FIG. The analysis result 241 is the analysis result of the determination code 230 for the func1 function.
The number of decision steps 220 is three. SUCCESS means that the output values are equal before and after the change. FAILURE means that the output value is different before and after the change.
The output values of the func1 function before and after the change are the same in the first step and the second step, but the output values of the func1 function are different before and after the change in the third step.
Therefore, the func1 function before and after the change is unequal, and the inequality step is the third step.

FIG. 26 shows an example of the analysis result 242. As shown in FIG. The analysis result 242 is the analysis result of the determination code 230 for the func2 function.
The determination step number 220 is 1000000000.
At the 1000000000th step, the output value of the func2 function differs before and after the change.
Therefore, the func2 function before and after the change is unequal, and the unequal step is the 1000000000th step.

Through the equivalence determination process (S140), it is possible to correctly determine whether the processing contents of the target function before and after the change are equivalent even when there are state variables with an extremely large number of states.
Also, the user can determine whether or not the target function after the change needs to be modified and the content of the modification by referring to the determination result 240 .

*** Effect of Embodiment 1 ***
According to Embodiment 1, it is possible to analyze the processing content by excluding state variables that do not affect the calculation of the output value of the target function and focusing on only the state variables that affect the calculation. In addition, by dividing the analysis for equivalence checking into multiple times and repeating the release and re-allocation of computer resources between the divided analyses, the target function before and after the change that has an extremely large number of state variables are equivalent.

*** Supplement to Embodiment 1 ***
The hardware configuration of the equivalence checking system 100 will be described based on FIG.
Equivalence checking system 100 comprises processing circuitry 109 .
The processing circuit 109 is hardware that realizes the influence state variable extraction unit 110 , the determination step number calculation unit 120 , the determination code generation unit 130 , and the equivalence determination unit 140 .
The processing circuit 109 may be dedicated hardware, or may be the processor 101 that executes a program stored in the memory 102 .

If processing circuitry 109 is dedicated hardware, processing circuitry 109 may be, for example, a single circuit, multiple circuits, a programmed processor, a parallel programmed processor, an ASIC, an FPGA, or a combination thereof.
ASIC is an abbreviation for Application Specific Integrated Circuit.
FPGA is an abbreviation for Field Programmable Gate Array.

The equivalence checking system 100 may include a plurality of processing circuits that substitute for the processing circuit 109.

In the processing circuit 109, some functions may be implemented by dedicated hardware, and the remaining functions may be implemented by software or firmware.

In this way, the functions of the equivalence checking system 100 can be implemented in hardware, software, firmware, or a combination thereof.

Embodiment 1 is an example of a preferred form and is not intended to limit the technical scope of the present disclosure. Embodiment 1 may be partially implemented, or may be implemented in combination with other modes. The procedures described using flowcharts and the like may be changed as appropriate.

Equivalence checking system 100 may be implemented with two or more devices.
A “unit” that is an element of the equivalence checking system 100 may be read as “processing”, “process”, “circuit” or “circuitry”.

100 equivalence check system, 101 processor, 102 memory, 103 auxiliary storage device, 104 communication device, 105 input/output interface, 109 processing circuit, 110 influence state variable extraction unit, 120 determination step number calculation unit, 130 determination code generation unit, 140 equivalence determination unit, 190 storage unit, 201 source code before change, 202 source code after change, 203 affected part, 204 affected part, 211 affected state variables before change, 212 affected state variables after change, 220 number of judgment steps, 221 calculation Code, 222 Calculated code, 223 Analysis result, 224 Analysis result, 225 Calculated code, 226 Analysis result, 230 Judgment code, 231 Before change source code, 232 After change source code, 233 Judgment header, 234 Judgment wrapper, 240 Judgment result, 241 Analysis result, 242 Analysis result.

Claims (10)

1. an influence state variable extraction unit for extracting an influence state variable, which is a state variable that influences an output value of a target function that is repeatedly called, from each of the pre-change source code and the post-change source code;
   The target function is repeatedly called in the pre-change source code and the value of the effect state variable is returned to the initial value, and the target function is repeatedly called in the post-change source code and the value of the effect state variable is returned to the initial value. a determination step number calculation unit that calculates the number of times the target function is called that satisfies the condition of returning as a determination step number;
   each of the target function of the pre-change source code and the target function of the post-change source code is repeatedly called the same number of times as the determination step number, and the target function of the pre-change source code and the post-change source code are called an equivalence determination unit that determines whether the target function is equivalent;
   An equivalence checking system comprising:
2. The impact state variable extraction unit
   extracting input variables and output variables from the target functions of the pre-change source code and the post-change source code;
   extracting, from each of the pre-change source code and the post-change source code, an influencing portion that affects the value of the output variable of the target function;
   extracting a variable having an out-of-function scope of the target function as an out-of-function scope variable from the affected portions of the pre-change source code and the post-change source code;
   excluding the input variable of the target function and the output variable of the target function from the outside-function scope variables of the pre-change source code and the post-change source code;
   2. The equivalence checking system according to claim 1, wherein the remaining outer-function scopes of the pre-modification source code and the post-modification source code are the effect state variables.
3. The determination step number calculation unit
   For each of the pre-change source code and the post-change source code, the number of times the target function is called when the target function is repeatedly called and the value of the affected state variable returns to the initial value is defined as the number of return steps. calculate,
   3. The least common multiple of the number of return steps of the target function of the pre-change source code and the number of return steps of the target function of the post-change source code is calculated as the determination step number. Equivalence checking system.
4. The determination step number calculation unit generates a calculation code for calculating the number of return steps, analyzes the calculation code, executes processing of the calculation code, and performs the return step based on the analysis result of the calculation code. 4. The equivalence checking system of claim 3, wherein the number of steps is determined.
5. The calculation code determines a first code for calling the target function the same number of times as the upper limit number of steps, and a post-condition that the value of the influence state variable is equal to the initial value the same number of times as the upper limit number of steps. 5. The equivalence checking system of claim 4, comprising a second code for doing.
6. The determination step count calculation unit generates a calculation code for the first calculation and a calculation code for the second and subsequent calculations as the calculation codes,
   The first calculation code includes the first code, the second code, and the third code for recording the value of the influencing state variable at the end of the upper limit number of steps as the state value of the final step. , including
   The calculation code for the second and subsequent times includes a fourth code for setting the state value of the final step to the influencing state variable, the first code, the second code, and the third code; including
   If the number of return steps cannot be obtained by analyzing the calculation code for the first time, the determination step number calculation unit releases computer resources secured for the analysis of the calculation code for the first time. 6. The equivalence checking system according to claim 5, wherein the computer resource is secured for the second analysis of the calculation code, and the number of return steps is obtained by analyzing the calculation code after the second time.
7. The equivalence checking system includes:
   a determination code generation unit configured to generate a determination code for repeatedly calling each of the target function of the pre-change source code and the target function of the post-change source code the same number of times as the number of determination steps;
   The equivalence determination unit analyzes the determination code, executes processing of the determination code, and determines whether the target function of the pre-change source code and the target function of the post-change source code are equivalent. 7. The equivalence checking system according to any one of claims 1 to 6, wherein determination is made based on analysis results.
8. The determination code generation unit includes the edited pre-change source code and the edited post-change source code in which name conflicts are eliminated, the target function of the edited pre-change source code, and the edited change. determination headers describing respective declarations of the target function of the post-change source code, and the target function of the edited pre-change source code and the target function of the edited post-change source code; 8. The equivalence checking system according to claim 7, wherein a decision wrapper for repeatedly calling the same number of times as the number of decision steps is generated as the decision code.
9. In the determination wrapper, the input value of the target function of the edited pre-change source code and the input value of the target function of the edited post-change source code are set in all the steps equal to the number of determination steps. Repeating code A for specifying a precondition of equality, and the target function of the edited pre-change source code and the target function of the edited post-change source code the same number of times as the number of determination steps. A code B to be called, an output value of the target function of the edited pre-change source code in all steps equal to the number of determination steps, and an output of the target function of the edited post-change source code. 9. The equivalence checking system of claim 8, comprising code C for determining a postcondition that the values are equal.
10. an influence state variable extraction process for extracting an influence state variable, which is a state variable that influences the output value of a target function that is repeatedly called, from each of the pre-modification source code and the post-modification source code;
    The target function is repeatedly called in the pre-change source code and the value of the effect state variable is returned to the initial value, and the target function is repeatedly called in the post-change source code and the value of the effect state variable is returned to the initial value. a determination step number calculation process for calculating the number of times the target function is called that satisfies the condition of returning as a determination step number;
    each of the target function of the pre-change source code and the target function of the post-change source code is repeatedly called the same number of times as the determination step number, and the target function of the pre-change source code and the post-change source code are called an equivalence determination process for determining whether the target function is equivalent;
    Equivalence checking program for executing on a computer.

Images