KR101788279B1 - Measuring system and method of worst-case execution time using test techniques - Google Patents

Abstract

The present invention relates to a system and method for measuring the worst execution time of a real-time program using a cycle table and a test case together, wherein the worst-case execution time measurement system according to one embodiment of the present invention comprises: A cycle table generation unit for generating a cycle table by analyzing a relationship between a code and a corresponding assembly instruction, a program code analysis unit for analyzing a source code of a second real-time application program, A test code generation unit for generating a test case based on a result of analyzing a control flow of the second real-time application program, a second real-time application Run the program and run A program execution unit to store the time, and is of the saved execution time required by the path comprising a worst case execution time extraction for extracting the longest running time.

Description

TECHNICAL FIELD [0001] The present invention relates to a method and a system for measuring a worst execution time using a test method,

The present invention relates to a system and method for measuring the worst execution time of a real-time application program using a cycle table and a test case together.

Weapon Systems Embedded software and software used in nuclear power generation require a high level of reliability because they have a great impact on mission succession and casualties. These mission-critical embedded software are hard real-time software, and dependability is determined according to satisfaction of real-time property. Satisfaction of real-time performance is determined by whether or not a given task can be performed within a given time. That is, it can be confirmed by verifying the schedulability.

In order to verify schedulability, analysis of program execution path is needed. You need to know all the execution paths of the program and measure the execution time for each execution path. If the longest execution time among the actual execution time of the execution path is shorter than the time allocated for execution of the program, the program can guarantee the schedulability. This way of verifying the schedulability is called Worst-case execution time analysis.

Static analysis methods have been used in the past for analyzing the worst execution time. However, it performs analysis of hardware behavior such as pipeline analysis and cache analysis, as well as program behavior analysis such as flow analysis in the program, repetition number analysis of loop statements, data analysis The analysis process is complicated and requires a lot of time and effort.

A problem to be solved by one embodiment of the present invention is to provide a system and a method for measuring a worst execution time of a real-time application program by using an execution path analysis method of a white box test technique.

Embodiments according to the present invention can be used to accomplish other tasks not specifically mentioned other than the above-described tasks.

According to an aspect of the present invention, there is provided an apparatus for real-time application development, comprising: a cycle table generation unit for generating a cycle table by analyzing a relationship between a source code of a first real-time application program and a corresponding assembly instruction, Based on the results of analyzing the control flow of the second real-time application program, a program code analyzing section for analyzing the source code, a program code expanding section for inserting the required cycle calculation code and route grasping probe code into the source code of the second real- A program execution unit for executing a second real-time application program based on the generated test case and storing a time required for each execution path, and a program execution unit for executing a longest execution time A test including a worst execution time extracting section to extract We propose a worst-case execution time measurement system.

Here, the cycle table generation unit may include a sentence classifying unit for classifying a sentence constituting the source code of the first real-time application program, a pattern generating unit for deriving a pattern by analyzing the relationship between the classified sentence and the corresponding assembly instruction, And calculating a required number of cycles of the assembly instruction corresponding to the classified sentence based on the obtained pattern.

Also, the program code analyzing unit may analyze the source code by defining the information about the components of the second real-time application program in a node form and generating an abstract syntax tree.

According to an embodiment of the present invention, there is provided a program execution system including a cycle table generation unit for generating a cycle table by analyzing a relationship between a source code of a first real-time application program and a corresponding assembly instruction through a cycle table generation unit, Analyzing the source code of the second real-time application program through the required cycle calculation code inserting unit, inserting the required cycle calculation code into the source code of the second real-time application program through the required cycle calculation code inserting unit, Generating a test case based on a control flow analysis result of the second real-time application program through a test case generation unit, generating a test case based on the test case generated through the program execution unit, Run real-time applications Storing the required time for each execution path, and extracting the longest execution time among the required execution time for each execution path through the worst execution time extracting unit.

Here, the cycle table generation step includes a step of classifying the sentences constituting the source code of the first real-time application program, a step of analyzing the relationship between the classified sentence and the corresponding assembly instruction and deriving the pattern, And calculating a required number of cycles of the assembly instruction corresponding to the classified sentence.

In addition, the step of analyzing the source code of the second real-time application program may include the steps of defining information on the components of the second real-time application program in the form of nodes, and generating an abstract syntax tree including the defined nodes have.

In addition, the path identification probe code insertion step can identify different paths based on the condition part of the source code of the second real-time application program, and insert the path identification probe code into the identified path.

According to one embodiment of the present invention, the worst execution time can be measured through a simple process compared to the conventional static analysis method. In addition, it is possible to perform the verification of the schedulability in the course of performing the white box test.

1 shows a configuration of a worst-case execution time measurement system using a test technique according to an embodiment of the present invention.
Figure 2 is an example of an assembly instruction corresponding to a short data type product (*) operation.
Figure 3 is an example of an assembly instruction corresponding to an int data type product (*) operation.
4 is an example of a pattern corresponding to the product operator derived through the pattern generator of FIG.
5 is an example of a cycle table generated by the required cycle calculating unit of FIG.
FIG. 6 shows a method of measuring the worst execution time using the test technique using FIG.
7 is a program source code example including the required cycle calculation code.
8 is an example of a probe code inserted into the program source code.
9 is a program source code example including the probe code corresponding to Fig.
10 is an example of a graph representation corresponding to the program source code of FIG.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings, which will be readily apparent to those skilled in the art to which the present invention pertains. The present invention may be embodied in many different forms and is not limited to the embodiments described herein. In order to clearly illustrate the present invention, parts not related to the description are omitted, and the same reference numerals are used for the same or similar components throughout the specification. In the case of publicly known technologies, detailed description thereof will be omitted.

In this specification, when a part is referred to as "including " an element, it is to be understood that it may include other elements as well, without departing from the other elements unless specifically stated otherwise. Also, the terms "part," " module, "and the like, which are described in the specification, refer to a unit for processing at least one function or operation, and may be implemented by hardware or software or a combination of hardware and software.

In this specification, it is assumed that a program is converted into an assembly instruction and executed, and each assembly instruction has a unique cycle number. Here, the cycle is also referred to as a clock, which means the time required to execute each step (Fetch, Decode, Execute, etc.) of executing instructions in the processor.

1 shows a configuration of a worst-case execution time measurement system using a test technique according to an embodiment of the present invention.

The worst execution time measurement system of FIG. 1 includes a cycle table generation unit 100, a program code analysis unit 200, a program code extension unit 300, a test case generation unit 400, a program execution unit 500, And an execution time extracting unit 600.

The cycle table generation unit 100 generates a cycle table by analyzing the relationship between the unit sentence of the source code of the first program and the corresponding assembly instruction and outputs the cycle table to the sentence classifying unit 110, ), And a required cycle calculation unit 130. At this time, the cycle table corresponding to the assembly instruction is dependent on a specific processor (Intel, Motorola, etc.). Here, the first program may be a plurality of programs.

The sentence classifying section 110 classifies sentences constituting the source code of the first program. The sentence classifying unit 110 according to the embodiment of the present invention classifies the sentence of the C language into an expression, a conditional statement, a loop statement, a function, and a function call unit. An expression is a statement written on the basis of an operator provided by the C language, and the conditional statement includes an if statement and a switch statement. The loop contains a for statement, a while statement, and a do while statement. Functions and function calls are statements that declare a function or call a declared function. These elements are described through operators and keywords provided by C language and are used as a criterion for classifying C language sentences. For example, all expressions provided by C language (assignment operator, unary operator, binary operator, ternary operator, casting operator, etc.) are used to create an expression and use it as input. In the case of an if statement, four types of expressions such as if, if-else, and if-else if-else can be created using two keywords, if and else. In addition, data type keywords do not have any relationship with assembly instructions alone, but they affect assembly instructions that are generated when combined with an operator. For example, multiplication of short type and multiplication of int type have the same operators but different type of MPY instruction and MPYI instruction type, respectively.

The pattern generation unit 120 generates a pattern by analyzing a relation between a sentence constituting the source code of the first program and the corresponding assembly command. The pattern generating unit 120 according to the embodiment of the present invention may be configured such that the sentence constituting the source code of the first program is converted into an assembly instruction according to a rule preset by the compiler, The pattern is derived.

FIG. 2 is an example of an assembly instruction corresponding to a short data type product (*) operation, FIG. 3 is an example of an assembly instruction corresponding to an int data type product (*) operation, As shown in Fig.

Assembly instructions 13 through 15 in FIG. 2 are instructions for preparing values for two operands, numbers 16 and 17 are instructions for multiplication operations, assembly instructions 13 through 15 in FIG. 3 are for two operands And 16 and 17 are instructions corresponding to multiplication operations. 2 and Fig. 3, the pattern shown in Fig. 4 can be derived.

Referring back to FIG. 1, the required cycle calculating unit 130 calculates the required cycle number of the assembly instruction word based on the pattern generation result of the pattern generating unit 120, and generates the cycle table.

The cycle required for the actual instruction to enter the execution state is 1, and all instructions have a delay slot according to the characteristics. This means the cycle required to complete the actual operation after the assembly instruction is executed. Therefore, the required cycle of the actual instruction is the cycle required to enter the execution state plus the delay slot. The compiler inserts a NOP instruction after a delay slot to guarantee a delay slot of each instruction.

The required cycle calculating unit 130 according to the embodiment of the present invention applies the pattern for performing the product operation after preparing the two values of the operands of FIG. 4 to the assembly instruction of FIG. 2 and FIG. 3, . For example, in FIG. 2, the multiply operation of the short data type corresponds to MPY.M2, B5, B4 and B4 instructions (one cycle) and one NOP instruction (one cycle) . It corresponds to .M2, B5, B4, B4 instruction (1 cycle) and 8 NOP instructions (8 cycles). For this reason, the multiplication of short data types can be computed in 2 cycles, and the multiplication of int data types can be computed in 9 cycles. In addition, the cycle table shown in FIG. 5 can be generated by storing the calculated required cycles for each calculated instruction word.

5 is an example of a cycle table generated by the required cycle calculating unit of FIG.

5, the required cycles according to the correspondence between the data type and the operation instruction can be confirmed.

Referring back to FIG. 1, the program code analyzing unit 200 analyzes a source code of a real-time application program (hereinafter referred to as a 'second program') which is a schedulability test target. The program code analyzing unit 200 according to the embodiment of the present invention includes a parser module and defines a class for a node for each component of the second program and stores data type information (context information) of the operator and the operand And generates an abstract syntax tree (AST) based on the generated node.

The program code extension unit 300 extends the source code of the second program for the worst case execution time analysis and includes a required cycle calculation code inserting unit 310 and a probe code inserting unit 320.

The required cycle calculation code inserting unit 310 inserts a code for obtaining a sum of required cycles corresponding to the source code of the second program.

The probe code inserting unit 320 inserts a probe code for identifying a path that takes the worst execution time to the source code of the second program. The probe code inserting unit 320 according to the embodiment of the present invention inserts one or more probe codes into a linearly independent execution path constituting the second program.

The test case generation unit 400 recognizes the linear independent execution path based on the result of grasping the control flow of the second program and generates a test case including input data necessary for executing the path. In this case, the test case satisfies the path coverage used in the white-box test (how to test how the output value according to the input value is calculated by examining the source code and the internal structure one by one) Run the path at least once.

The program execution unit 500 executes the second program based on the test case generated through the test case generation unit 400, and stores the execution path and the required time.

The worst-case execution time extraction unit 600 extracts the longest execution time based on the execution result of the program execution unit 500. [ Here, the extracted longest execution time is the worst execution time of the second program.

FIG. 6 shows a method of measuring the worst execution time using the test technique using FIG.

First, the cycle table generating unit 100 analyzes a relationship between a sentence constituting the first program and an assembly instruction, and generates a cycle table based on the analysis result (S100).

In step S100 according to the embodiment of the present invention, the type of the sentence of the first program source code is classified and a pattern based on the relation with the assembly instruction corresponding to the sentence is generated. Thereafter, the required number of cycles of the assembly instruction is calculated based on the generated pattern to generate the cycle table. In this regard, since the detailed description is given in the cycle table generation unit 100 of FIG. 1, redundant description is omitted.

Thereafter, the program code analyzing unit 200 parses the second program using a parsing module and analyzes the source code (S200).

The step S200 according to an embodiment of the present invention is a step of grasping a sentence constituting a second program using an abstract syntax tree. In order to grasp the context information of a sentence, Classes are defined and represented as nodes in an abstract syntax tree. Here, the context information includes data type information of the operator and the operand. As shown in the cycle table of FIG. 5, in the case of the multiplication (*) operator, the short data type multiplication operator takes 2 cycles, whereas the int type data multiplication operator takes 9 cycles. Therefore, in order to accurately grasp the execution time, do. In this case, since the data type of the operator is determined by the data type of the operand, the data type of the operand must first be determined and then the data type of the operator must be determined. For example, if both operands are of type short, the multiplication operator is also applied to the short type operator, but if one operand is a short type and the other is an int type, the multiplication operator is applied to the int type operator.

Thereafter, the required cycle calculation code is inserted into the source code of the second program through the required cycle calculation code inserting unit 310, and the probe code is inserted into the source code of the second program through the probe code inserting unit 320 ( S300).

The step S300 according to the embodiment of the present invention inserts a required cycle calculation code into the source code to obtain the sum of the required cycles of each sentence for measuring the execution time of the second program. The required cycle calculation code calculates a required cycle sum of each sentence based on the abstract syntax tree (AST) generated through the program code analysis unit (200). Here, each node of the abstract syntax tree (AST) includes the information about the data type for the worst execution time prediction and the original source code. Therefore, when each node is visited in order to output the related information, It is possible to output a sentence of the second program which can grasp the second program.

7 is a program source code example including the required cycle calculation code.

7 shows that the required cycle calculation codes 720, 730, 740 and 750 are inserted into the source code 710 of the second program.

In FIG. 7, Total_Cycles + = int_LOAD + int_MV + int_GT; of the first code 720 means adding the number of cycles int_LOAD, int_MV, and int_GT to the required number of cycles calculated before the corresponding code. In order to compute the expression k> 10, the operation (int_LOAD) to read the variable k value from the memory and store it in the register, the operation (int_MV) to store the constant 10 in the register, and the operation (int_GT) .

In FIG. 7, Total_Cycles + = int_LOAD + int_MV + int_GT; of the first code 720 is included in the third code 740. This is because when the actual program is executed, This is to reflect the time required to execute the condition statement even if the control flows. The NOP of the first code 720 is an operation that is performed when control is immediately passed to the next area of the comparison statement after the comparison operation. On the other hand, the BRANCH operation of the else region is an operation that reflects a situation where control is shifted to the else region after the comparison operation is completed. Accordingly, it can be confirmed that there is a BRANCH operation in the second code 730, which is the end of the then area, but no BRANCH operation, in the fourth code 750, which is the end of the else area.

Referring back to FIG. 6, step S300 according to the embodiment of the present invention inserts the probe code into the source code in order to grasp the execution path of the program.

In step S300 according to the embodiment of the present invention, the position of the probe is determined in the process of parsing the program code, and the probe is inserted in the extended C code output process. Specifically, it is predicated on the program logic that control flows to different execution paths in the program. Therefore, different paths are determined based on the condition part and the probe is inserted in the part. There is a true path and a false path in the if statement. In the loop statement such as the while statement, the for statement, and the while statement, there exists a path for entering the loop statement and a path for not entering the loop statement. And each of these paths constitutes a linear independent path. In the iterative sentence, the path of each iteration can be regarded as an independent path. However, since it is difficult to predict the number of paths when considering all the individual paths in this case, only the case of entering the loop and the case of not entering are treated as independent paths. The program is implemented as an element of sequence, selection, and iteration, and only the branch structure and the iteration structure including the condition part create a new path.

8 is an example of a probe code inserted into the program source code.

8, a probe code is inserted for each path of the if statement 810 of the branch structure and the while statement 820 of the repetition structure.

9 is a program source code example including the probe code corresponding to Fig.

9 shows the source code of the second program in which the probe code of FIG. 8 is inserted, wherein the first probe code 910 is inserted into the then region of the first conditional and the third probe code 930 is inserted into the second And then inserted into the then area of the conditional part. If the second program execution is started, initialize all probe values to 0, and increase the probe value every time the second program is executed to enter the then or else region, thereby confirming the path of the program. For example, if the value of the first probe code 910 is 1 and the value of the fourth probe code 940 is 1, it can be confirmed that the then region of the first branch and the else region of the second branch are performed .

Referring again to FIG. 6, a test case is created through the test case generation unit 400 (S400). In step S400, a test case satisfying the path coverage used in the white-box test is generated.

Thereafter, the second program is executed through the program executing unit 500 using the test case generated in step S400 (S500). In step S500, the path where the second program is executed and the time required for executing the path are recorded in the log. For example, when executing the true path (then region) in FIG. 7, the maximum execution time is int_LOAD + int_MV + int_GT + NOP + int_STORE + int_LOAD + int_LOAD + int_ADD + BRANCH. 5 + 2 + 1 + 1 + 3 + 5 + 5 + 1 + 6 = 29 cycles are obtained by converting the number of cycles into the number of cycles based on the cycle table of FIG.

Thereafter, the worst execution time extracting unit 600 extracts the worst execution time of the program based on the execution result of step S500 (S600).

10 is an example of a graph representation corresponding to the program source code of FIG.

FIG. 10 is a representation of each sentence of the original source code 710 of FIG. 7 as a node, and has two execution paths. The first execution path 1010 is a node-> b node-> d node-> f node-> g node and the second execution path 1020 is a node-> c node-> e node-> g node to be. The sum of the weights of the nodes included in the first execution path 1010 is 29 cycles and the sum of the weights of the nodes included in the second execution path 1020 is 28 cycles so that the first execution path 1010 is connected to the second execution path 1020). ≪ / RTI > As a result, the longest execution time of the program can be determined to be 29 cycles. At this time, assuming that one cycle is 10 ns, the longest execution time is 29 * 10 = 290 ns.

When the same program is executed based on a plurality of processors, the worst execution time of a program operating in different processors is measured using a cycle table dependent on the same processor And select an optimal processor for driving the program based on the worst-case execution time measurement result.

According to the embodiment of the present invention, it is possible to simplify the worst execution time measurement method compared to the worst execution time measurement method based on the conventional static method by checking the possibility of scheduling by measuring the worst execution time of the real- have. In addition, the schedulability can be verified at the same time as performing the white box test.

While the present invention has been particularly shown and described with reference to exemplary embodiments, it is to be understood that the invention is not limited to the disclosed exemplary embodiments, but, on the contrary, It belongs to the scope.

100: Cycle table generating unit
110: sentence classification section
120: pattern generator
130: Required cycle calculating unit
200: Program code analysis section
300: program code extension unit
310: Required cycle calculation code insertion section
320: probe code inserting portion
400: test case generation unit
500: Program execution unit
600: worst execution time extraction unit

Claims (7)

A computer-readable recording medium having stored thereon a program for implementing a worst-case execution time measurement method using a worst-case execution time measurement system using a test technique,
Classifying a type of a sentence in a source code of a first real-time application program including a plurality of programs converted into assembly instructions and executing the program, deriving a pattern by analyzing a relationship between the classified sentence and the corresponding assembly instruction, A function of generating a cycle table by calculating a required number of cycles of the assembly instruction corresponding to the classified sentence based on the pattern,
Analyzing source code of a second real-time application program that is an object of a schedulability test independent of the first real-time application program,
A function of inserting the required cycle calculation code and the route identification probe code into the source code of the second real-time application program,
A function of generating a test case based on a result of analyzing a control flow of the second real-time application program,
A function of executing the second real-time application program based on the generated test case, calculating and storing the time required for each execution path of the second real-time application program based on the generated cycle table, and
A function of extracting the longest execution time among the required times for each of the stored execution paths
And a method of measuring a worst-case execution time using a test technique. delete The method of claim 1,
The function of analyzing the source code of the second real-
A computer readable storage medium storing a program implementing a worst-case execution time measurement method using a test technique for defining information on a component of the second real-time application program in a node form and generating an abstract syntax tree to analyze the source code; Recording medium. A first real-time application program that includes a plurality of programs converted into assembly instructions through a cycle table generation unit, classifies the types of sentences in the source code, analyzes the relationship between the classified sentences and the corresponding assembly instructions, Calculating a required number of cycles of the assembly instruction corresponding to the classified sentence based on the derived pattern to generate a cycle table,
Analyzing a source code of a second real-time application program that is an object of a schedulability test independent of the first real-time application program through a program code analyzing unit;
Inserting a required cycle calculation code into the source code of the second real-time application program through a required cycle calculation code inserting unit,
Inserting a path capture probe code into the source code of the second real-time application program through a probe code insertion unit,
Generating a test case based on a result of analysis of the control flow of the second real-time application program through a test case generating unit,
Executing the second real-time application program based on the generated test case through a program execution unit, calculating and storing the time required for each execution path of the second real-time application program based on the generated cycle table, and
Extracting the longest execution time among the required execution times of the stored execution paths through the worst execution time extracting step
A method for measuring a worst case execution time using a test method including a test method. delete 5. The method of claim 4,
Wherein the step of analyzing the source code of the second real-
Defining information on a component of the second real-time application program in the form of a node, and generating an abstract syntax tree including the defined node. 5. The method of claim 4,
In the path grasping probe code inserting step,
Determining a different path based on a condition part of the source code of the second real-time application program and inserting the path identification probe code into the identified path.

Images