JP5979250B2 - Exclusive control inspection device, exclusive control inspection method, exclusive control inspection program - Google Patents

Description

  The present invention relates to an exclusive control inspection device, an exclusive control inspection method, and an exclusive control inspection program.

  To calculate the busy rate and contention rate of the semaphore used in the lock section in the computer program, the lock time from the acquisition of the semaphore specified as the measurement target to the lock release, and from the semaphore lock acquisition wait to the lock acquisition There is known a lock operation measurement method for measuring each of the lock release waiting times in real time (see Patent Document 1).

Japanese Patent Application Laid-Open No. 11-085574

  The lock operation measurement method disclosed in Patent Document 1 is a dynamic inspection method in which the system is operated and the time is measured. Therefore, only the actually executed lock section and lock release waiting process are targeted. . For this reason, a lock section or a branch path that has not been actually executed cannot be measured. Therefore, since the maximum value of the lock time cannot be grasped for each lock section that can be executed, the lock section in which the responsiveness of the system is deteriorated cannot be specified. In other words, the purpose of verifying whether the time required for execution of the lock section used by the computer program (lock time), contention, and time-out conditions are satisfied and whether the requirements imposed on the system are satisfied is sufficiently However, the lock operation measuring method disclosed in Patent Document 1 has a problem that it cannot be achieved.

  The present invention has been made in view of the above problems, and its purpose is to make a user aware of a place where the responsiveness of the system may be deteriorated in a lock section that can be executed in a computer program. An exclusive control inspection device, an exclusive control inspection method, and an exclusive control inspection program are provided.

  An exclusive control checking apparatus according to an aspect of the present invention specifies an execution order and an execution path of statements included in a computer program to be checked, and stores the computer program based on the specified execution order and execution path of the statements. A lock section consisting of a group of statements that execute exclusive control on a shared resource that can be used by a plurality of tasks included is specified. Then, the number of clocks required for execution of the lock section is calculated for each execution path included in the specified lock section. Information such as the specified execution order and execution path, lock interval, and calculated number of clocks is output as a test result.

  The exclusive control inspection apparatus according to one aspect of the present invention extracts a timeout time for waiting for the restriction on access to the shared resource to be released for each lock section, and is different from the task to which the lock section belongs. If another lock section belonging to the specified task is identified as a competing task, and the maximum number of clocks in the lock section is greater than the timeout period of the other lock section, another lock section may be skipped It is preferable to judge that there is.

FIG. 1 is a block diagram showing a hardware configuration of an exclusive control inspection apparatus according to an embodiment of the present invention. FIG. 2 is a block diagram showing a functional configuration of the CPU 11. FIG. 3 is a flowchart showing a flow of information processing executed by the exclusive control inspection apparatus according to the embodiment of the present invention. FIG. 4A, FIG. 4B, and FIG. 4C are diagrams showing an example of a computer program described in C language as the source code D01 read by the source code input unit 21. FIG. 5 is a table (execution order / execution path table T01) showing the execution order and execution paths of statements (codes) when the function “Task1” in FIG. FIG. 6 is a table showing an example of the entry point list D02. FIG. 7 is a table showing an example of the lock start instruction / release instruction list D03. FIG. 8 is a table showing an example of the required clock count list D04. FIG. 9 is a flowchart showing an example of a detailed processing procedure of the information processing F01 shown in steps S03 to S05 of FIG. FIG. 10 is a table (lock section identification table T02) showing the execution result for the function “Task1” in FIG. 4A as an example of the execution result of the flowchart of FIG. FIG. 11 is a table (clock number total management table T03) showing the maximum number of clocks required for execution in the lock section and the number of clocks in each execution path as an example of the execution results of steps S06 and S07 in FIG. is there. FIG. 12 is a table (exclusive control structure management table T04) showing combinations of block sections in a competitive relationship as an example of the execution result of step S08 in FIG. FIG. 13 is a table showing an example of the exclusive control inspection result D05.

  Embodiments of the present invention will be described with reference to the drawings. In the description of the drawings, the same parts are denoted by the same reference numerals and description thereof is omitted.

[Hardware configuration of exclusive control inspection device]
The exclusive control inspection apparatus according to the embodiment of the present invention can be applied to a process for inspecting exclusive control included in a computer program executed by, for example, an electronic control unit (ECU) mounted on a vehicle.

  In the execution of a computer program, if a conflict occurs due to simultaneous access from multiple tasks to shared resources (including data, files, and databases) that can be used by multiple tasks (including applications), the shared resources are aligned. In order to maintain performance, while one task exclusively uses the shared resource, the other task is prevented from using the shared resource. This is called exclusive control. Specifically, the activation of the other task is locked during a certain period in which one task uses the shared resource. The other task to be locked is started after the one task to be locked releases the semaphore and performs access to the shared resource.

  An exclusive control inspection apparatus according to an embodiment of the present invention is an apparatus that inspects exclusive control executed on shared resources that can be used from a plurality of tasks included in a computer program.

  With reference to FIG. 1, the hardware configuration of the exclusive control inspection apparatus according to the embodiment of the present invention will be described. A general-purpose computer can be used as the hardware configuration of the exclusive control inspection apparatus. For example, the exclusive control inspection device includes a computer program (source code D01) to be inspected and data required for inspection (entry point list D02, lock start instruction / release instruction list D03, and required clock number list D04) from the storage medium. ), A storage device 14 that stores the source code D01 read by the input / output device 12 and analysis intermediate data, and a CPU (central processing unit) that performs various operations and analyzes the source code D01. 11, an input device 13 for a user to input information necessary for analysis, and a display device 15 for displaying a test result (including an exclusive control test result D05) output from the CPU 11. The inspection result can also be written to a storage medium using the input / output device 12. Examples of the storage device 14 include a memory and a hard disk, and data is input and output between the storage device 14 and a CPU (central processing unit) 11.

  The intermediate data stored in the storage device 14 is updated by the CPU 11. Examples of the intermediate data include an execution order / execution path table T01, a lock section specification table T02, a clock number total management table T03, an exclusive control structure management table T04, which will be described later.

  The exclusive control inspection device can also be realized as a client-server model. For example, a general-purpose personal computer (client) is connected to the server via a computer network. Accordingly, a server placed in a remote environment including the CPU 11 shown in FIG. 1 can be connected to the input / output device 12, the input device 13, the storage device 14, or the display device 15 included in the client via a computer network. it can. In this case, the exclusive control inspection device is mainly configured by the CPU 11 (server), and the input / output device 12, the input device 13, the storage device 14, or the display device 15 is not included in the exclusive control inspection device.

  A functional configuration of the CPU 11 will be described with reference to FIG. A computer program (exclusive control inspection program) for causing a computer including the CPU 11 to function as an exclusive control inspection apparatus is installed and executed on the computer including the CPU 11. Thereby, CPU11 functions as each information processing part shown below. Although an example in which the exclusive control inspection device is realized by software is shown here, of course, the exclusive control inspection device may be configured by preparing dedicated hardware for executing the following information processing. Is possible.

  The CPU 11 functions as the source code input unit 21, the order path specifying unit 22, the lock section specifying unit 23, the clock number calculating unit 24, the maximum clock number calculating unit 25, and the inspection result output unit 29.

  The source code input unit 21 reads a computer program (source code D01) to be inspected from the input / output device 12 or the input device 13, and stores it in the storage device 14.

  The order path specifying unit 22 specifies an execution order and an execution path of statements included in the computer program read by the source code input unit 21. Specifically, using the entry point list D02 input from the input / output device 12 or the input device 13, the execution order of statements executed starting from the entry point (program start point) input from the input device 13 And the execution path is specified. The entry point list D02 will be described later with reference to FIG. The entry point list D02 is recorded in the storage device 14 as a file format or a database. The entry point list D02 is read by an instruction from the CPU 11. The execution order and execution path of the statements specified by the order path specifying unit 22 are recorded in the execution order / execution path table T01 (FIG. 5) by the order path specifying unit 22. The execution order / execution path table T01 is recorded in the storage device 14 as a file format or a database.

  The lock section specifying unit 23 specifies a lock section based on the execution order and execution path of the statements specified by the order path specifying unit 22. The “lock section” includes a group of statements that execute exclusive control on a shared resource that can be used by a plurality of tasks included in a computer program. In other words, the lock section is a fixed section in which one task exclusively uses the shared resource. In the lock section, the activation of the other task is locked, and the use of shared resources is prohibited.

  Specifically, the lock section specifying unit 23 specifies a section (lock section) from the lock start instruction to the release instruction according to the statement execution order and execution path information recorded in the execution order / execution path table T01. The lock section specifying unit 23 specifies the statements of the lock start command and the lock release command based on the lock start command / release command list D03 input from the input / output device 12 or the input device 13. The lock start command / release command list D03 will be described later with reference to FIG. The lock start command / release command list D03 is recorded in the storage device 14 as a file format or a database. The lock start command / release command list D03 is read by an instruction from the lock section specifying unit 23 of the CPU 11.

  The clock number calculation unit 24 calculates the number of clocks required for execution of the lock section for each execution path included in the lock section specified by the lock section specifying unit 23. Specifically, the number of clocks required to execute each statement included in the lock section specified by the lock section specifying unit 23 based on the required clock number list D04 input from the input / output device 12 or the input device 13 is calculated. calculate. In the required clock number list D04, the number of clocks necessary for executing the instruction is recorded for each type of instruction described in the statement. The required clock count list D04 will be described later with reference to FIG. The required clock number list D04 is recorded in the storage device 14 as a file format or a database, and is read by an instruction from the clock number calculation unit 24 of the CPU 11.

  The number of clocks required to execute each statement calculated by the clock number calculation unit 24 is recorded by the clock number calculation unit 24 in the lock section identification table T02 (FIG. 10). The lock section specifying table T02 is recorded in the storage device 14 as a file format or a database.

  Then, the clock number calculation unit 24 calculates the total number of clocks required to execute each statement for each execution path, and the total value is clocked together with information on the lock section specified by the lock section specifying unit 23. It records in the number total management table T03 (FIG. 11). The total clock number management table T03 is recorded in the storage device 14 as a file format or a database.

  The maximum clock number calculation unit 25 refers to the clock number total management table T03 and calculates the maximum value of the clock number calculated by the clock number calculation unit 24 for each lock section. Specifically, when two or more execution paths are included in one lock section, that is, when two or more branch processes are performed under a branch condition in one lock section, two or more The largest clock number is extracted in the execution path. When only one execution path is included in one lock section, the number of clocks calculated by the clock number calculation unit 24 is the maximum value of the number of clocks in the lock section. The maximum value of the clock number calculated by the maximum clock number calculation unit 25 is recorded in the clock number total management table T03 by the maximum clock number calculation unit 25.

  The inspection result output unit 29 outputs at least the maximum value of the clock number calculated by the maximum clock number calculation unit 25 to the storage medium inserted in the display device 15 or the input / output device 12 as the exclusive control inspection result D05. The maximum number of clocks output by the inspection result output unit 29 will be described later with reference to FIG.

  The CPU 11 further functions as a timeout time extraction unit 26, a conflict lock section identification unit 27, and a timeout determination unit 28.

  The timeout time extraction unit 26 extracts a timeout time that can wait for the access restriction to the shared resource to be released for each lock section. Specifically, the timeout time is extracted by referring to the argument of the lock start instruction corresponding to the lock section.

  The use of shared resources by one task prohibits the use of shared resources. The other task depends on one task for the timeout period set by the argument of the lock start instruction corresponding to the lock interval of the other task. You can wait for the semaphore to be released. However, if one task does not release the semaphore even after the timeout period has elapsed, the other task is not executed and skips to the next process.

  The contention lock section specifying unit 27 refers to the clock number total management table T03 and specifies, for each lock section, another lock section belonging to another task different from the task to which the lock section belongs. When one task among a plurality of tasks that can exclusively use the same shared resource has acquired a semaphore, the other task cannot acquire the same semaphore. Among two or more lock sections using the same semaphore, lock sections belonging to different tasks compete for acquisition of the semaphore. The contention lock section specifying unit 27 specifies, for each lock section, another lock section that competes for semaphore acquisition. That is, a combination of lock sections in a competitive relationship is specified. The combination of lock sections having the specified conflict relationship is recorded in the exclusive control structure management table T04 (FIG. 12) by the conflict lock section specifying unit 27. The exclusive control structure management table T04 is recorded in the storage device 14 as a file format or a database.

  The timeout determination unit 28 refers to the clock number total management table T03 and the exclusive control structure management table T04, and acquires the maximum value of the number of clocks in the lock section and the timeout time of other lock sections in a competitive relationship. Then, the timeout determination unit 28 determines that there is a possibility that another lock section may be skipped if the maximum value of the number of clocks in the lock section is larger than the timeout time of another lock section. Specifically, the timeout determination unit 28 calculates the maximum value of the number of clocks required for execution of one lock section and the timeout time defined in the other lock section among the two or more lock sections in a competitive relationship. Compare.

  The number of clocks indicates the number of internal clocks used for timing control performed by the microcomputer. By multiplying the number of clocks by the execution time per clock of the microcomputer and the number of clocks, the time required for execution of the lock section is obtained. The timeout time is expressed as the number of internal clocks used for timing control performed by the microcomputer. Therefore, the timeout determination unit 28 compares the maximum value of the number of clocks required for execution of one lock section with the timeout time of another lock section expressed by the number of clocks.

  If the maximum number of clocks required to execute one lock interval is greater than the timeout time of the other lock interval, one lock interval will not release the semaphore even if the timeout interval elapses. If there is a possibility of being skipped, the timeout determination unit 28 can determine.

  The inspection result output unit 29 outputs the determination result by the timeout determination unit 28 as the exclusive control inspection result D05 together with the maximum number of clocks calculated by the maximum clock number calculation unit 25. The exclusive control inspection result D05 will be described later with reference to FIG.

[Procedure for information processing executed by exclusive control inspection device]
Next, an information processing procedure executed by the exclusive control checking apparatus shown in FIGS. 1 and 2 will be described as an example of the exclusive control checking method according to the embodiment of the present invention with reference to FIGS. .

  First, in step S01, the source code input unit 21 reads the source code D01 to be inspected from, for example, the input / output device 12, and stores it in the storage device 14. The source code D01 may be read into the exclusive control inspection device by the user in advance using the input / output device 12 and stored in the storage device 14. In this case, the process of step S01 is unnecessary. 4 (a), 4 (b), and 4 (c) show an example of a computer program described in C language as the read source code D01. The computer program to be inspected is described across the three files shown in FIGS. 4 (a), 4 (b), and 4 (c). The file name in FIG. 4A is “File1.c”, the file name in FIG. 4B is “File2.c”, and the file name in FIG. 4C is “File3.c”. . In an example of a computer program written in the C language, a serial number starting from 1 described at the left end of each file indicates a “line number” of each file.

  Next, in step S02, the order path specifying unit 22 uses the entry point list D02 to specify the control flow starting from the entry point (program start point), that is, the execution order and execution path of the statements.

  In the computer program shown in FIGS. 4A, 4B, and 4C, four functions are described. The function “Task1” is described in “File1.c” in FIG. The function “Task1” calls two functions “Func1” and “Func2” and ends. The function “Func1” and the function “Func2” are described in “File2.c” in FIG. The function “Task2” is described in “File3.c” in FIG. The function “Task2” ends by calling the function “Func2”. As shown in FIG. 6, the entry points that are the starting points of the program are “Task1” and “Task2”.

  The table in FIG. 5 shows an example of the execution order and execution path of statements (codes) when the function “Task1” in FIG. In the table of FIG. 5, “statement ID” is a serial number starting from “1” attached to a statement in the source code D01. That is, the “statement ID” is a line number corresponding to the execution instruction described in each line of the three files shown in FIGS. 4A, 4B, and 4C constituting the source code D01. It is attached in the order.

  The description of each line is empty (for example, the 10th line in FIG. 4 (a)) or a line (for example, 3 in FIG. , 12, 15, etc.) can be determined not to cause execution time during program execution. Therefore, the order path specifying unit 22 does not attach a “statement ID” to such a line in order to exclude such a line from the target of subsequent processing. Of course, even if a statement ID is assigned to such a line, the subsequent processing is not affected. It is only necessary to assign a statement ID so that all the lines that can be considered to cause execution time at the time of program execution are to be processed. It is not limited to examples.

  The “previous execution statement ID” indicates a statement ID given to a statement executed before the statement. “Next execution statement ID” indicates a statement ID given to a statement executed next to the statement.

  If the statement is a branch instruction, a function call instruction, or a repeat instruction, the statement ID corresponding to the jump destination statement is registered as the next execution statement ID. In general, the number of jump destinations is not limited to one, and there may be a plurality of jump destinations. Therefore, one or a plurality of statement IDs are recorded in the execution order / execution path table T01 by the order path specifying unit 22 as the next execution statement ID. To do. If the statement is neither a branch instruction, a function call instruction, or a repeat instruction, the statement ID corresponding to the statement described at the next line number in the source code D01 is registered as the next execution statement ID. .

  The previous execution statement ID can be registered in the execution order / execution path table T01 after the next execution statement ID is recorded for all the statements included in the source code D01. For example, when the previous execution statement ID is registered for the statement L01 of the source code D01, the statement L02 in which the statement ID corresponding to the statement L01 is recorded as the next execution statement ID is read with reference to the execution order / execution path table T01. . That is, since the statement L01 is executed immediately after the statement L02, it can be understood that the statement executed immediately before the statement L01 is the statement L02. Therefore, the statement ID corresponding to the statement L02 is recorded as the previous execution statement ID for the statement L01. By repeating the same operation for all statements in the source code D01, all previous execution statement IDs can be recorded.

  When a plurality of next execution statement IDs are recorded for the statement L01, the previous execution statement ID can be recorded by repeating the same processing for each recorded next execution statement ID.

  The order path specifying unit 22 detects a conditional branch from the statements included in the source code D01. The conditional branch includes an if-else syntax, a switch-case syntax, a loop statement (for statement, while statement), and a ternary operator “:”. The order path specifying unit 22 determines a statement at which a conditional branch starts as a “branch start point”, and determines a statement at which a conditional branch ends as a “branch end point”. Two or more identified “branch start points” and “branch end points” are identified by adding “branch IDs”. However, the same branch ID is attached to the branch start point and the branch end point corresponding to the branch start point so that the correspondence can be understood.

  Then, the sequential path specifying unit 22 specifies two or more execution paths generated by the conditional branch with respect to a statement between the branch start point and the branch end point. Then, two or more specified execution paths are identified by attaching a “path ID”.

  FIG. 5 illustrates the case where the function “Task1” is an entry point, but the order path specifying unit 22 also executes the execution order and the execution path in the same manner as in FIG. 5 when the function “Task2” is an entry point. Is identified.

  In the example of FIG. 5, the sequential path specifying unit 22 specifies two or more execution paths generated by the conditional branch for the statement at the branch start point, and for the statement at the branch end point. Does not specify the execution path. Whether the execution path is specified for the branch start point and branch end point statements is not limited to the example of this embodiment.

  Furthermore, in the example of FIG. 5, the number of clocks is generated when evaluating a conditional statement, regardless of which of the plurality of execution routes is advanced by a conditional branch. Therefore, there are a plurality of statements representing conditional branches including conditional statements. It is treated as belonging to the execution path. As described above, the order path specifying unit 22 attaches a plurality of path IDs indicating a plurality of corresponding execution paths to a statement determined to be executed by a plurality of execution paths.

  As described above, the order path specifying unit 22 creates an execution order / execution path table T01 of statements (codes) included in the source code D01 as shown in the table of FIG.

  Note that using the previous execution statement ID and the next execution statement ID recorded in the execution order / execution path table T01, it is possible to extract statements executed upstream and downstream of the statement. That is, by referring to the previous execution statement ID, it is possible to refer to the statement executed immediately before, so that a statement executed upstream of a certain statement can be extracted. Further, by referring to the next execution statement ID, it is possible to refer to the statements that are executed one after the other sequentially, so it is possible to extract the statements that are executed downstream.

  Next, information processing F01 shown in steps S03 to S05 is executed. In step S03, the lock section specifying unit 23 specifies a section (lock section) from the lock start command to the release command based on the lock start command / release command list D03 shown in FIG. In step S04, the timeout time extracting unit 26 extracts a timeout time for each of the specified lock sections. In step S05, the clock number calculation unit 24 calculates the number of clocks required to execute each statement included in the lock section based on the required clock number list D04 shown in FIG.

  The table in FIG. 7 shows an example of the lock start instruction / release instruction list D03. “Sem_Lock” is defined as a lock start command, and “Sem_UnLock” is defined as a lock release command. A semaphore ID for identifying a plurality of semaphores used in the source code D01 is specified by a first argument quoted by “Sem_Lock” and “Sem_UnLock”, respectively. The timeout time is specified by the second argument quoted by “Sem_Lock”. For example, “Sem_Lock (ID1,100)” shown in the fourth line of FIG. 4A indicates a start command of a lock section by the semaphore identified by the semaphore ID “ID1”, and the lock starts from the fourth line. This indicates that the time-out time of the section is 100 (number of clocks). “Sem_UnLock (ID1)” shown in the ninth line of FIG. 4A indicates a lock section release command by the semaphore having the semaphore ID “ID1”.

  The table in FIG. 8 shows an example of the required clock count list D04. For each instruction described in the statement, the number of clocks required to execute the instruction is defined.

  Here, steps S03 to S05 can be performed in parallel. With reference to the flowchart of FIG. 9, an example of a detailed processing procedure of the information processing F01 shown in steps S03 to S05 will be described.

  First, in step S101, a section ID for identifying a lock section is initialized. In step S102, a task ID for identifying a task included in the source code D01 is initialized. Proceeding to step S103, the first statement (statement ID = 1) in the function “Task1” specified by the task ID initialized in step S102 is read.

  The lock section specifying unit 23 refers to the lock start instruction / release instruction list D03 in FIG. 7 to determine whether the read statement matches the lock start instruction “Sem_Lock” or the lock release instruction “Sem_UnLock”. If it matches the lock start command “Sem_Lock”, the process proceeds to step S105. If it matches the unlock command “Sem_UnLock”, the process proceeds to step S107. If neither the lock start command “Sem_Lock” nor the lock release command “Sem_UnLock” matches, the process proceeds to step S108.

  In step S105, the section ID is counted up. In step S106, a lock start command (“start”) as a statement type, a section ID, a semaphore ID, and a time-out time are recorded in the lock section specification table T02. This is obtained by referring to the first argument and the second argument of the start instruction, and then proceeds to step S113.

  On the other hand, in step S107, the lock release instruction (“release”) as the statement type, the section ID of the upstream lock start instruction having the same semaphore ID, and the semaphore ID are recorded in the lock section specifying table T02. Thereafter, the process proceeds to step S113.

  In step S107, the semaphore ID is obtained by referring to the first argument of the unlock command. Further, the upstream lock start instruction can be extracted by using the previous execution statement ID in the execution order / execution path table T01. By referring to the previous execution statement ID corresponding to the read statement, it is possible to extract the statement executed immediately before. If the statement is not a lock start instruction, the previous executed statement ID is referenced to extract a statement that is executed one more time before. By repeating the same operation, an upstream lock start command can be finally extracted. Therefore, it is determined whether or not the semaphore ID of the upstream lock start instruction is the same as the semaphore ID of the lock release instruction. If they are the same, the section ID of the upstream lock start instruction is recorded in the lock section identification table T02. Since a plurality of statement IDs corresponding to the statement executed immediately before may be described in the previous execution statement ID, there may be a case where there are a plurality of upstream lock start instructions.

  In step S108, the lock section specifying unit 23 determines whether or not the read statement is within the lock section from the lock start instruction to the lock release instruction. If within the lock section (YES in step S108), the process proceeds to step S109. On the other hand, if it is not within the lock section (NO in step S108), the process proceeds to step S110, and the lock section specifying unit 23 records “outside section” as the statement type in the lock section specifying table T02. Thereafter, the process proceeds to step S113.

  In step S110, the lock section specifying unit 23 records “in section” and the section ID as the statement type in the lock section specifying table T02. In step S111, the clock number calculation unit 24 extracts all instructions described in the read statement. In step S112, the clock number calculation unit 24 calculates the total number of clocks necessary for execution of all the instructions extracted from the read statement based on the required clock number list D04 shown in FIG. As a result, the clock number calculation unit 24 can obtain the number of clocks required to execute the read statement. The clock number calculation unit 24 records the calculated clock number in the lock section identification table T02. Thereafter, the process proceeds to step S113.

  In step S113, it is determined whether or not the read statement is the last statement in the lock section. If it is not the last statement in the lock section (NO in step S113), the next statement is read with reference to the next execution statement ID in the execution order / execution path table T01 (S118), and the process returns to step S104. On the other hand, if the read statement is the last statement in the lock section (YES in step S113), the process proceeds to step S114. If there is a statement that has not been determined yet (YES in S114), the process proceeds to step S115, a statement that has not yet been determined is read, and the process returns to step S104.

  On the other hand, if there is no statement that has not yet been determined (NO in S114), the process proceeds to step S116, and it is determined whether or not the function “Task1” identified by the task ID initialized in step S102 is the last task. To do. If it is not the last task (NO in step S116), the task ID is incremented (step S117), and the process returns to step S103. Then, the above-described procedure is executed for the function “Task2”. On the other hand, if it is the last task (YES in step S116), the flowchart of FIG. 9 ends.

  Whether the read statement is within the lock section from the lock start instruction to the lock release instruction is determined by using the previous execution statement ID and the next execution statement ID in the execution order / execution path table T01. The statements executed upstream and downstream of the server are searched, and whether or not there is a lock start instruction and a lock release instruction is performed. If the semaphore ID and the section ID are the same for the lock start instruction and the lock release instruction obtained by the search, the read statement is included in the lock section specified by the section ID, and the lock section specifying unit 23 can be judged. In general, when the source code D01 includes a conditional branch, the read statement may be in a plurality of lock sections.

  For the search of statements executed upstream and downstream, it is necessary to record all lock start instructions and lock release instructions included in the task in the lock section specifying table T02. This process is expressed in a simplified manner.

  The table in FIG. 10 shows the execution result for the function “Task1” in FIG. 4A as an example of the execution result of the flowchart in FIG. 9, and the lock for the function “Task1” in FIG. The section identification table T02 is represented. A group of statements with statement ID = 2-7 is specified as a lock section identified by section ID = 1. In the statement ID = 2 that matches the lock start command “Sem_Lock” in the lock section of the section ID = 1, semaphore ID = 1 and timeout time = 100 are recorded. “Intra-section (section ID = 1)” is recorded in each group of statements executed with statement ID = 2-7, and each group of statements with statement ID = 3-6 is recorded. A list of instructions included in the statement and the number of clocks required to execute the statement are recorded. A semaphore ID = 1 is recorded for a statement with a statement ID = 7 that matches the unlock command “Sem_UnLock” in the lock section (section ID = 1). In the lock section (section ID = 1), there is a branch process that branches into two execution paths identified by the path IDs (1, 1) (1, 2) in one lock section. Yes.

  Similarly, a group of statements executed in the order of statement ID = 9, 10, 15, 16, 14 is specified as a lock section identified by section ID = 2. Further, a group of statements executed in the order of statement ID = 12, 13, 17, 18, and 14 is specified as a lock section identified by section ID = 3. The semaphore (semaphore ID = ID2) used in the lock section (section ID = 2) and the lock section (section ID = 3) is common. On the other hand, the semaphore (semaphore ID = ID2) used in the lock section (section ID = 2) and the lock section (section ID = 3) is the same as the semaphore (semaphore ID = ID1) used in the lock section (section ID = 1). Is different. In the lock section (section ID = 2) and the lock section (section ID = 3), the statement with statement ID = 8 is set as the branch start point (branch ID = 2), and the statement with statement ID = 14 is set at the branch end point ( Branch ID = 2) exists in two execution paths identified by path IDs (2, 1) (2, 2), respectively.

  As described above, the lock section specifying unit 23 and the clock number calculating unit 24 execute the statements (codes) included in the source code D01 as shown in the table of FIG. 10 based on the execution order / execution path table T01. A lock section identification table T02 is created. In the lock section specifying table T02, the statement type, section ID, semaphore ID, and timeout time specified by the lock section specifying unit 23 are recorded. Then, the instruction in the statement extracted by the clock number calculation unit 24, the type of the instruction, and the clock number are recorded.

  Returning to FIG. 3, in step S <b> 06, the clock number calculation unit 24 calculates the number of clocks required to execute the lock section for each execution path included in the lock section specified by the lock section specifying unit 23. Specifically, the number of clocks required to execute each statement calculated in step S112 in FIG. 9 is read from the lock section specifying table T02 recorded in the storage device 14, and all statements included in each lock section are read. Add the number of clocks for. As a result, the number of clocks required to execute the lock section can be calculated for each execution path. At this time, if there are two or more execution paths (path ID (1, 1) (1, 2)) in the lock section (lock ID = 1), the clock required for execution of the lock section for each of the execution paths. Calculate the number. The calculated number of clocks required for execution of the lock section is recorded in the total clock number management table T03 shown in FIG.

  In the total clock number management table T03 in FIG. 11, “total number of clocks of statements in the section” is the lock section (lock ID = 1 to 4) included in the function “Task1” and the function “Task2”. Indicates the number of clocks required for execution. Regarding the lock section (lock ID = 1), since there are two execution paths (path ID (1,1) (1,2)) in the lock section, the number of clocks required to execute the lock section for each execution path Indicates. For example, as shown in FIG. 10, the execution path identified by the path ID (1, 1) includes a group of statements with statement ID = 3 and 4. The number of clocks required to execute the statement with statement ID = 3 is “1”, and the number of clocks required to execute the statement with statement ID = 4 is “3”. Therefore, as shown in FIG. 11, for the execution path identified by the path ID (1, 1), the number of clocks required to execute the lock section (lock ID = 1) is “1 + 3” = “4”.

  In step S07, the maximum clock number calculation unit 25 refers to “total number of clocks of statements in the section” in the total clock number management table T03, and for each lock section, the maximum number of clocks calculated in step S06. Calculate the value. As shown in FIG. 11, the lock section (lock ID = 1) is identified by the clock number (= 4) of the execution path identified by the path ID (1, 1) and the path ID (1, 2). And the larger clock number (= 4) is selected. When only one execution path is included in one lock section, the number of clocks calculated in step S06 is directly used as the maximum number of clocks in the lock section.

  As shown in FIG. 11, the exclusive control inspection apparatus according to the embodiment can visualize the structure related to exclusive control included in the source code D01 to be inspected. In other words, the entry point, the section ID, the semaphore ID, the route ID, and the statement ID included in the route can be specified as the structure related to the exclusive control included in the source code D01. Then, the maximum number of clocks required to execute the lock section can be obtained for each lock section that can be executed in the source code D01 to be inspected by a static analysis method. Therefore, it is possible to specify a portion where the responsiveness of the system may be deteriorated without omission in the lock section that can be executed in the computer program.

  Returning to FIG. 3, in step S08, the contention lock section specifying unit 27 refers to the clock number total management table T03, and for each lock section, another lock belonging to another task different from the task to which the lock section belongs. Identify the section. Further, in the embodiment, a plurality of types of semaphores (semaphore ID = ID1 and ID2) are used in the source code D01. Different semaphores do not create a competitive relationship for semaphore acquisition. For this reason, in the lock section using the same semaphore, a combination of lock sections belonging to different tasks is specified. FIG. 12 shows the exclusive control structure management table T04. In the exclusive control structure management table T04, combinations of block sections having a competitive relationship are recorded. In step S08, the exclusive lock structure management table T04 is read or updated by the contention lock section specifying unit 27.

  The lock section (lock ID = 1) belongs to the function “Task1” and uses a semaphore (semaphore ID = ID1). The lock section (lock ID = 2) and the lock section (lock ID = 3) belong to the function “Task1” and use a semaphore (semaphore ID = ID2). On the other hand, the lock section (lock ID = 4) belongs to the function “Task2” and uses a semaphore (semaphore ID = ID2).

  Therefore, the lock section (lock ID = 2), the lock section (lock ID = 3), and the lock section (lock ID = 4) are exclusive using the same semaphore (semaphore ID = ID2) for the same shared resource. Execute control. Here, since the lock section (lock ID = 2) and the lock section (lock ID = 4) belong to different tasks “Task1” and “Task2”, they have a competitive relationship with respect to acquisition of the semaphore with semaphore ID = ID2. Similarly, the lock section (lock ID = 3) and the lock section (lock ID = 4) are in a competitive relationship regarding the acquisition of the semaphore with semaphore ID = ID2. On the other hand, the lock section (lock ID = 2) and the lock section (lock ID = 3) use the semaphore with the same semaphore ID = ID2, but belong to the same task “Task1”, and therefore acquire the semaphore with the semaphore ID = ID2. There will be no competition.

  The lock section (lock ID = 1) does not compete with other lock sections (lock ID = 2), lock section (lock ID = 3), and lock section (lock ID = 4) because the semaphores used are different.

  As described above, the contention lock section specifying unit 27 specifies, for each lock section, whether or not it competes with other lock sections by using the task to which the lock section belongs and the information of the semaphore to be used. After execution of step S08, the exclusive control structure management table T04 is in a state in which information related to the combination of block sections in a competitive relationship specified by the conflict lock section specifying unit 27 is stored.

  Next, the process proceeds to step S09, and the timeout determination unit 28 determines whether or not the maximum value of the number of clocks in the lock section is larger than the timeout time of another competing lock section. Specifically, the time-out determining unit 28 uses the time-out time of each lock section recorded in the lock-section specifying table T02 and the information on the combination of the block sections in the competitive relationship recorded in the exclusive control structure management table T04. refer. Then, among the combinations of the lock sections having the competitive relationship specified in step S08, the maximum value of the number of clocks required for execution of one lock section is compared with the timeout time of the other lock section. As described above, the timeout time is expressed as the number of internal clocks used for timing control performed by the microcomputer, and can be compared with the maximum number of clocks.

  When the maximum number of clocks required for execution of one lock section is larger than the timeout time of the other lock section (YES in step S09), the timeout determination unit 28 may skip the other lock section. It is determined that there is (step S10).

If the maximum number of clocks required to execute one lock interval is smaller than or equal to the timeout time of the other lock interval (NO in step S09), the timeout determination unit 28 skips the other lock interval. It is determined that there is no possibility (step S12).

  The timeout determination unit 28 executes the determination in step S09 for all combinations of block sections specified in step S09.

  In step S11, the inspection result output unit 29 outputs the determination result by the timeout determination unit 28 as the exclusive control inspection result D05 together with the maximum number of clocks calculated by the maximum clock number calculation unit 25. FIG. 13 is a table showing an example of the exclusive control inspection result D05. For example, the maximum value (= 6) of the number of clocks in one lock section (lock ID = 3) is longer than the timeout time (= 5) of the competing other lock section (lock ID = 4). That is, while one lock section (lock ID = 3) locks the semaphore with semaphore ID = ID2, the other lock section (lock ID = 4) does not acquire the semaphore with semaphore ID = ID2. The timeout period may elapse while waiting for semaphore release. Therefore, the timeout determination unit 28 determines that there is a possibility that the lock section (lock ID = 4) may be skipped during the execution of the function “Task1”. Similarly, the maximum value (= 11) of the number of clocks in one lock section (lock ID = 4) is longer than the timeout time (= 10) of the competing other lock section (lock ID = 2). Therefore, the timeout determination unit 28 determines that there is a possibility that the lock section (lock ID = 2) may be skipped during the execution of the function “Task2”.

  On the other hand, the maximum value (= 5) of the number of clocks in one lock section (lock ID = 2) is not longer than the timeout time (= 5) of the competing other lock section (lock ID = 4). . Similarly, the maximum value (= 11) of the number of clocks in one lock section (lock ID = 4) is not longer than the timeout time (= 15) of the competing other lock section (lock ID = 3). Therefore, with respect to the combination of these lock sections, it can be determined that there is no possibility that the timeout time elapses while waiting for the semaphore to be released. FIG. 13 shows a lock section (lock ID = 1) using a semaphore with semaphore ID = ID1, but another lock section using a semaphore with semaphore ID = ID1 in the source code D01. Because there is no competition, there is no competition.

[Effects of the embodiment]
In a computer program, when multiple tasks or applications access the same resource (resource), in order to avoid data corruption due to access contention, a measure to temporarily prohibit access from other tasks by exclusive control such as semaphores Take. In other words, the activation of the other task is locked in a certain interval in which one task uses the resource. The locked task is started after the locking task releases the semaphore and executes access to the resource. Here, if the section for locking resource access from other tasks (lock section) is set incorrectly, there is a problem that the locked task occupies an unreasonable time resource and slows down the operation of the other tasks. As a result, the response time of the task is extended, leading to a problem that the system operation becomes dull.

  In order to avoid such problems and keep the responsiveness of the system within an allowable range, a timeout period for waiting for semaphore release, that is, waiting for unlocking is set. If the semaphore is not released even if the timeout time is exceeded, the access process to the resource is skipped and the process after that is executed.

  However, if the lock section becomes longer than expected due to diversion or expansion of the legacy code, there is a problem that the average processing time of the lock section becomes longer than the set timeout time, and timeouts occur frequently. In addition, large-scale software has a problem that lock conflicts cannot be grasped and an inappropriate timeout time is set.

  Therefore, the exclusive control checking apparatus according to the embodiment specifies the execution order and execution path of the statements included in the source code D01 (computer program) to be checked by the order path specifying unit 22, and executes the specified statement. Based on the order and the execution path, the lock section specifying unit 23 specifies a lock section including a group of statements that execute exclusive control on a shared resource that can be used by a plurality of tasks included in the computer program. Then, for each execution path included in the specified lock section, the clock number calculation unit 24 calculates the number of clocks required for execution of the lock section. Thereby, the maximum value of lock time can be calculated | required about each of the lock area which performs exclusive control. Since the inspection result output unit 29 outputs information such as the specified execution order and execution path, the lock interval, and the calculated number of clocks as the inspection result, the system response for the lock interval that can be executed in the computer program. It is possible to make the user aware of a place where there is a possibility that the sex will deteriorate. Thereby, the time-out time can be optimized and the responsiveness of the system can be improved. Further, by analyzing the computer program by a static method, lock sections and lock release waiting processes that are not actually executed can be examined, so that verification oversight can be suppressed.

  In addition, the exclusive control inspection device extracts a timeout period set in the lock section in which the access restriction to the shared resource can be waited for for each lock section by the timeout period extraction unit 26, and the lock section Based on the information on the semaphore acquired by the task and the information of the task to which the lock section belongs, the contention lock section specifying unit 27 specifies another lock section that forms a competitive relationship for each lock section. Then, the timeout determination unit 28 skips the other lock section when the maximum number of clocks in one lock section forming the competition relationship is larger than the timeout time of the other lock section forming the competition relationship. It is determined that there is a possibility, and the determination result is output by the inspection result output unit 29. As a result, for example, it is possible to make the user aware of a place where an inappropriate timeout time is set due to a mistake in porting legacy code or a mistake in combining source code that has been distributed and developed. Therefore, it is possible to optimize the timeout time and suppress frequent occurrence of timeout.

  As another modification, for example, for the combination of lock sections that are in a conflicting relationship determined to be likely to be skipped in steps S09 and S10 in FIG. The ratio of the timeout time of the other lock section to the maximum value of the number of clocks may be calculated as the verification priority and output as the exclusive control test result D05. The higher this ratio (verification priority), that is, the closer to 100%, the higher the verification priority regarding exclusive control. When information specifying a combination of a plurality of lock sections is output as a portion that may be skipped, the priority as a verification target can be communicated to the user, so that the efficiency of verification work by the user is improved. be able to. By checking the combination of lock sections whose verification priority is less than 100% but very close to 100%, an inappropriate timeout period is set due to a legacy code porting error or a distributed source code combining error. Can be found efficiently.

  As mentioned above, although embodiment of this invention was described, these embodiment is only the illustration described in order to make an understanding of this invention easy, and this invention is not limited to the said embodiment. The technical scope of the present invention is not limited to the specific technical matters disclosed in the above embodiment, but includes various modifications, changes, alternative techniques, and the like that can be easily derived therefrom. From this disclosure, various alternative embodiments, examples and operational techniques will be apparent to those skilled in the art.

  This application claims priority based on Japanese Patent Application No. 2013-008356 filed on Jan. 21, 2013, the entire contents of which are incorporated herein by reference.

  According to the present invention, the computer program is analyzed by a static method, and the maximum value of the lock time can be obtained for each lock section in which exclusive control is executed. Therefore, it is possible to make the user aware of a place where the responsiveness of the system may be deteriorated in the lock section that can be executed in the computer program.

DESCRIPTION OF SYMBOLS 21 Source code input part 22 Order path | route identification part 23 Lock area specification part 24 Clock number calculation part 25 Maximum clock number calculation part 26 Timeout time extraction part 27 Contention lock area specification part 28 Timeout judgment part 29 Test result output part D01 Source code ( Computer program)
D02 Entry Point List D03 Lock Start Instruction / Release Instruction List D04 Required Clock List D05 Exclusive Control Check Result T01 Execution Order / Execution Path Table T02 Lock Section Specific Table T03 Clock Count Total Management Table T04 Exclusive Control Structure Management Table

Claims (4)

An exclusive control inspection device for inspecting exclusive control included in a computer program,
An order path specifying unit for specifying an execution order and an execution path of statements included in the computer program to be inspected;
A lock composed of a group of statements that execute exclusive control on a shared resource that can be used by a plurality of tasks included in the computer program, based on the execution order and execution path of the statements specified by the order path specifying unit. A lock section identifying unit for identifying a section;
A clock number calculating unit for calculating the number of clocks required for execution of the lock section for each of execution paths included in the lock section specified by the lock section specifying unit;
A maximum clock number calculating unit that calculates a maximum value of the clock number calculated by the clock number calculating unit for each of the lock sections;
An inspection result output unit that outputs a maximum value of the clock number calculated by the maximum clock number calculation unit;
An exclusive control inspection device comprising: The exclusive control inspection device according to claim 1,
For each of the lock sections, a time-out time extracting unit that extracts a time-out time that can wait for the access restriction to the shared resource to be released;
For each of the lock sections, a contention lock section specifying unit that specifies another lock section belonging to another task different from the task to which the lock section belongs,
A time-out determination unit that determines that the other lock section may be skipped when the maximum value of the number of clocks in the lock section is larger than a timeout time of the other lock section;
The exclusive control inspection apparatus, wherein the inspection result output unit outputs a determination result by the timeout determination unit. An exclusive control inspection method for inspecting exclusive control included in a computer program,
Specify the execution order and execution path of the statements included in the computer program to be examined,
Based on the execution order and execution path of the statements, specify a lock section consisting of a group of statements that execute exclusive control on a shared resource that can be used by a plurality of tasks included in the computer program,
For each execution path included in the lock section, calculate the number of clocks required to execute the lock section,
For each of the lock intervals, calculate the maximum number of clocks,
An exclusive control inspection method, wherein the maximum value of the number of clocks is output. An exclusive control inspection program for inspecting exclusive control included in a computer program,
On the computer,
A function for specifying an execution order and an execution path of statements included in the computer program to be inspected;
A function for specifying a lock section consisting of a group of statements that execute exclusive control on a shared resource that can be used by a plurality of tasks included in the computer program, based on an execution order and an execution path of the statements;
A function for calculating the number of clocks required for execution of the lock section for each of the execution paths included in the lock section;
A function of calculating the maximum number of clocks for each of the lock sections;
A function of outputting the maximum number of clocks;
The exclusive control inspection program characterized by realizing.

Images