JP6218645B2 - Program analysis apparatus, program analysis method, and program - Google Patents

Description

  The present invention relates to calculation of task execution time.

In many embedded systems, there are real-time tasks that need to be completed within a predetermined time (deadline) and non-real-time tasks that are not.
In system development, the worst execution time of a task is calculated and it is confirmed that it does not exceed the deadline so that the execution time of the task does not exceed the deadline.

  As a conventional method of calculating the execution time, (1) a method of statically analyzing the program code to analyze the execution path of the program and estimating the longest execution time from the execution time of each execution path; There is a method of measuring the execution time by dynamically executing it with an actual machine or a simulation.

In the method (1), since all execution paths of the program are calculated, there is no omission of calculation.
However, in order to estimate the exact execution time of a program, not only the number of instructions executed but also the behavior of H / W (Hardware) such as cache hit rate, memory, I / O (Input / Output) access time, etc. There is a need.
In the method (2), it is possible to calculate a more accurate execution time by considering the behavior of H / W, but it is not known whether the execution path having the worst execution time is being executed.

  In Patent Document 1, the program is analyzed and the execution path is output, the execution time of each execution path is calculated in consideration of the H / W behavior, and the limit execution time (worst execution time or best execution time) is calculated. ing.

International Publication WO2013-128519

However, in recent years, embedded memory has become equipped with cache memory, and while memory access performance has improved, the execution time varies depending on the cache miss rate, making it difficult to estimate the worst execution time. ing.
The cache miss rate is influenced not only by the execution of its own task, but also by the execution of other tasks (exactly, the cache miss rate changes depending on the instruction or data arrangement (address) of itself or another executed task) ).
There are also systems in which a plurality of real-time tasks having different execution priorities exist, and a real-time task (A) having a higher priority interrupts execution of the real-time (B) having a lower priority and executes it.
In this case, the instruction or data of the real-time task (A) with high priority is stored in the cache memory while the execution of the real-time task (B) with low priority is interrupted, so that the real-time task (B) with low priority is stored. Instructions or data may be evicted.
When the real-time task (B) tries to refer to an instruction or data evicted from the cache memory after resuming processing, a memory miss occurs because a cache miss occurs.
Therefore, the execution time of the real-time task (B) may increase as compared with the case where the process is not interrupted in the middle.

  In Patent Document 1, since the execution time considering the task execution priority is not calculated as described above, it is considered that the processing is interrupted by a real-time task having a lower priority than another real-time task having a higher priority. However, there is a problem that an accurate task execution time cannot be estimated.

  The main object of the present invention is to solve the above problems, and to calculate the task execution time accurately.

The program analysis apparatus according to the present invention includes:
An execution path extraction unit that analyzes a program composed of a plurality of blocks in which a plurality of tasks are generated and extracts a group of blocks executed in the task as an execution path for each task;
In accordance with the task generation order at the time of executing the program, an array pattern generating unit for arraying execution paths corresponding to each task and generating a plurality of array patterns by changing a combination of execution paths;
An execution time calculation unit that calculates an execution time of an execution path for each execution path when the execution paths included in the array pattern are sequentially executed for each arrangement pattern.

  According to the present invention, the execution time of the execution path when the execution paths included in the array pattern are sequentially executed is calculated for each execution path for each array pattern in which the execution paths are arranged in accordance with the task generation order during program execution. Therefore, the task execution time can be accurately calculated.

1 is a diagram illustrating a configuration example of a worst execution time determination system according to a first embodiment. The figure which shows the process example of the real-time task of execution object S / W which concerns on Embodiment 1. FIG. FIG. 4 is a diagram showing an example of an execution path list according to the first embodiment. FIG. 4 shows an example of a task schedule according to the first embodiment. FIG. 4 shows an example of an arrangement pattern according to the first embodiment. FIG. 4 shows an example of a task schedule according to the first embodiment. The figure which shows the structural example of the worst execution time determination system which concerns on Embodiment 2. FIG. FIG. 10 is a diagram showing an example of an execution path list according to the second embodiment. FIG. 10 is a diagram illustrating a method for determining an array pattern to be simulated according to the second embodiment. The figure which shows the hardware structural example of the worst execution time determination system which concerns on Embodiment 1 and 2. FIG.

Embodiment 1 FIG.
In this embodiment, in a system in which real-time tasks with different priorities exist, a task with a lower priority calculates the worst execution time considering the influence of a task with a higher priority more accurately, and exceeds the deadline. A configuration for more accurately determining whether will be described.

FIG. 1 shows a configuration example of a worst execution time determination system 1000 according to the present embodiment.
In FIG. 1, an execution target S / W storage unit 10 stores an execution target S / W (Software) for determining whether or not a real-time task exceeds a deadline.
In the execution target S / W, there are two or more real-time tasks, and a priority is set for each task.

The execution path analysis unit 20 analyzes the execution target S / W and calculates the execution path of each real-time task from the execution target S / W.
The execution target S / W is a program composed of a plurality of blocks, the execution path is an execution path for each task in the execution target S / W, and is a sequence in which blocks executed in the task are connected in the execution order. is there.
The execution path analysis unit 20 corresponds to an example of an execution path extraction unit.

The execution path list storage unit 30 stores an execution path list.
The execution path list is information representing a list of execution paths for each task calculated by the execution path analysis unit 20 and conditions for executing each path.

The task schedule storage unit 60 stores a task schedule.
The task schedule is task execution schedule information of the target system.
In the task schedule, the generation order of tasks is described, and a deadline (upper limit time) that is an upper limit execution time is described for each task.
The task schedule corresponds to an example of upper limit time information.
The task schedule storage unit 60 corresponds to an example of an upper limit time information storage unit.

The execution path combination determination unit 40 determines a combination of execution paths to be simulated from the execution path list and the task schedule.
More specifically, the execution path combination determination unit 40 arranges execution paths corresponding to each task according to the task generation order indicated in the task schedule, and changes the combination of execution paths to generate a plurality of arrangement patterns. Generate.
The execution path combination determination unit 40 corresponds to an example of an array pattern generation unit.

The execution time calculation unit 100 calculates, for each execution path, the execution time of the execution path when the execution paths included in the array pattern are sequentially executed for each array pattern that is a combination of execution paths.
The execution time calculation unit 100 includes a simulation unit 50, a variable operation unit 70, and a cache invalidation unit 80.

The simulation unit 50 is a simulator that executes a simulation of the program of the execution target S / W.
The simulation unit 50 simulates the execution environment of the execution target S / W and calculates the execution time of the execution target S / W.
The simulation unit 50 also includes a cache simulator that simulates the operation of the cache memory.

  The variable operation unit 70 operates variable values during simulation in order to perform a simulation according to the execution paths combined by the execution path combination determination unit 40 in the simulation unit 50.

  The cache invalidation unit 80 invalidates data in the cache simulator provided in the simulation unit 50 at an arbitrary timing during the execution of the simulation unit 50.

  The worst execution time determination unit 90 determines whether or not the real-time task exceeds the deadline as a result of executing the execution target S / W by the simulation unit 50.

Each functional block may be implemented as one or a plurality of programs, or a plurality of functional blocks may be implemented as one program.
The execution target S / W may exist as an execution file of one or a plurality of programs, or may be a program expanded on a memory.
The execution path list and the task schedule may exist as files, or may be data arranged only on the memory.

  Next, the operation will be described.

First, the execution path analysis unit 20 calculates a list of execution paths for each task of the execution target S / W.
An execution path calculation example will be described with reference to the flowchart of FIG.

FIG. 2 is a flowchart showing processing of a certain real-time task.
Each block in FIG. 2 represents one or more instructions, and block 2 and block 4 represent branch instructions. In this example, the establishment conditions are X <0 and Y = 1.
At this time, the following three types of task execution paths are conceivable, and the conditions for executing each execution path are those described in ().
・ Block 1 → Block 2 (X <0)
Block 1 → Block 2 → Block 3 → Block 4 → Block 5 (X> = 0 and Y ≠ 1)
-Block 1-> Block 2-> Block 3-> Block 4-> Block 6-> Block 5 (X> = 0 and Y = 1)
Therefore, the execution path list obtained from the task shown in FIG. 2 is as shown in FIG.
In FIG. 3, the branch condition is shown as a range of values such that X <0. However, any value that satisfies the condition such as X = −1 may be described as the condition.
The above procedure is performed for all real-time tasks, and the execution path of each real-time task is calculated.

Next, the operation of the execution path combination determination unit 40 will be described.
The execution path combination determination unit 40 determines an execution path combination (array pattern) for executing a simulation of the execution path list calculated by the execution path analysis unit 20 based on the task schedule.
The task schedule is information indicating a task execution schedule, and stores the execution cycle, deadline, and execution priority of each task of the real-time task.

FIG. 4 shows an example of the task execution schedule of the system in which the execution target S / W of the present embodiment operates.
Task A and task B are both real-time tasks, and the deadline is until the start of the next task execution.
Both task A and task B are executed at the timing of a predetermined execution cycle (task A is T1, T3, T6, task B is T1, T6).
In the example of FIG. 4, the execution cycle of task A is half of the execution cycle of task B, and the execution priority of task A is higher.
Therefore, when the execution start timing of task A is reached during the execution of task B, the processor suspends the execution of task B and performs the processing of task A (the timing from T3 to T4 is applicable).
Thereafter, when the processing of task A is completed, the processing of task B is resumed (timing T4).

In the combination of execution paths, tasks are scheduled for a period that is the least common multiple of the execution cycle of all real-time tasks.
In this example, since the execution cycle of task A and task B is 1: 2, task combination is performed when task A is executed twice and task B is executed once.

If the execution path analysis unit 20 assumes that there are three execution paths A1, A2, and A3 and two execution paths B1 and B2 from the calculated execution path list, the combination of execution paths is as follows. There are 18 ways shown in FIG.
That is, the execution paths corresponding to each task are arranged in accordance with the generation order of task A and task B in FIG. 4, and the combinations of the execution paths are changed to generate 18 arrangement patterns.
And the simulation part 50 performs a simulation about the combination of each execution path of these 18 kinds of arrangement patterns, and calculates execution time.

Next, the operation for calculating the execution time in the simulation unit 50 will be described.
The simulation unit 50 executes the 18 execution path combinations shown in FIG. 5 one by one and calculates the execution time.
The simulation unit 50 is a simulator for executing the execution target S / W. The simulation unit 50 simulates the hardware configuration of the system (target system) on which the execution target S / W operates (particularly, contention for cache memory entries), and the target It is assumed that the execution target S / W is executed in consideration of an instruction execution time based on the hardware specifications of the system and an execution time considering a miss penalty due to a cache miss.
Such a simulator has already been considered by Reference 1 and the like.
As shown in FIG. 4, the simulation unit 50 executes the tasks A and B based on the respective execution periods (timing) and priorities based on the hardware timer by the target system provided in the simulation unit 50. There are methods that can be implemented by an interrupt, an execution target S / W, or an OS (Operating System) included in the execution target S / W, which can be easily implemented when the simulation unit 50 builds a simulation environment. .
Reference 1: JP 2013-222392 A

In order to execute the combination of execution paths designated by the simulation unit 50, the variable operation unit 70 starts the execution of each task (in the case of task scheduling as shown in FIG. 4, timings T1, T2, and T3). The variable value in the simulator is changed so that the execution condition for each pass is satisfied.
For example, the execution paths A1 to A3 of task A are shown in No. No. 1 in FIG. 3 is executed, the variable operation unit 70 sets X = -1 at the timing T1 in FIG. 4, and X = 0 and Y = 1 at the timing T3. Set.
In addition, when the execution condition of the execution path of task B uses the same variable as the execution condition of the execution path of task A (for example, when the condition under which task B executes B1 is X = 2), task B resumes. At the timing (T4 timing in the case of FIG. 4), the value of the variable is set again.

The cache invalidation unit 80 invalidates all entries in the cache memory (a model for simulating the operation) existing in the simulation unit 50 when the simulation unit 50 starts execution, and there is no data in the cache. Not in a state.
Thereby, since the instruction and data of task A do not exist in the cache memory at the start of simulation, the worst execution time in the execution path can be calculated.

The cache invalidation unit 80 invalidates all entries in the cache memory not only at the start of simulation but also at a timing at which a non-real-time task may operate.
For example, as shown in FIG. 6, when task B completes processing at timing T12 before T13, which is the second execution start timing of task A, the cache invalidation unit 80 starts execution timing of the second task A. Even at T13, all entries in the cache memory existing in the simulation unit 50 are invalidated.
This is because a non-real-time task may operate between T12 and T13, and which cache data of task A is evicted (or not evicted at all) by execution of the non-real-time task is executed. This is to calculate the worst execution time in which all cache data is evicted because it varies depending on the non-real-time task program (the simulation unit 50 does not simulate the non-real-time task from T12 to T13). ).
As a result, it is possible to calculate the worst execution time in consideration of the fact that the non-real-time task operates between T12 and T13 and the data of the real-time task A is evicted.

  As described above, the cache invalidation unit 80 invalidates all entries in the cache memory at the start of simulation execution or between executions of a real-time task, that is, at a timing at which a non-real-time task may be executed.

The simulation unit 50 calculates the execution completion time of each task when the combination is executed.
For example, in the case of FIG. 4, the execution completion time of task A (first time) is T2, the execution completion time of task B is T5, and the time completion time of task A (second time) is T4.

The worst execution time determination unit 90 confirms whether the execution time of each real-time task by a combination of task execution paths does not exceed the deadline from the execution completion time and task schedule output by the simulation unit 50.
Specifically, in the case of FIG. 4, the task A (first time) execution completion time does not exceed the second task A execution completion time T3, task B, task A (second time). ) Execution completion time does not exceed T6 which is the execution start time of the next task B and task A. If the execution completion time of any task exceeds the deadline, the execution target S It is determined that / W exceeds the deadline.

  When the worst execution time determination unit 90 determines that the execution path combination determination unit 40 does not exceed the deadline for all execution path combinations calculated, the execution target S / W sets the deadline on the target system. It can be said that it does not exceed.

  The above is the operation of the first embodiment.

<Effect of Embodiment 1>
As described above, in the present embodiment, after the execution path analysis unit 20 analyzes all the execution paths of the execution target S / W, the simulation is performed according to the task execution schedule described in the task schedule. Calculate the execution time.
For this reason, the execution time of task B with a low priority is calculated in consideration of the influence of processing interruption by task A with a high priority, so whether task B with a low priority misses a deadline. Can be determined more accurately.

<Modification of Embodiment 1>
In this embodiment, all execution path combinations are simulated and it is determined that the execution time of each execution path combination does not exceed the deadline. However, the worst execution time determination unit 90 exceeds the deadline. If it is determined that the execution target S / W has already exceeded the deadline, it may be terminated without executing the simulation of the combination of subsequent execution paths.
Thereby, the determination time can be shortened.

In this embodiment, the order of combinations of execution paths executed by the simulation unit 50 is not described. However, the execution path analysis unit 20 executes a combination of long execution paths. Also good.
In this case, since the simulation is executed from a path that is highly likely to exceed the deadline, it may be determined that the deadline is exceeded early.
At this time, as described above, if it is determined that the deadline is exceeded, the determination time can be further shortened if the simulation is terminated without performing the subsequent simulation.

Long execution paths here include those with a large number of instructions, those with a large number of memory and I / O accesses (or those with a long access time), both the number of instructions and the memory and I / O access times. Can be considered.
In addition to these, the execution time when each execution path alone is executed using the simulation unit 50 may be calculated, and a long execution path may be a long execution path (described in the second embodiment).

Embodiment 2. FIG.
In the first embodiment described above, a total combination according to the task execution schedule described in the task schedule is performed for the execution paths for each task calculated by the execution path analysis unit 20.
However, there are generally many execution paths (several tens to several hundreds or more) for each task, and the total number of combinations when the paths are combined in accordance with the task execution scheduling is enormous. It is not realistic to calculate time.
Therefore, an embodiment in which the number of determining execution path combinations is reduced will be described.

FIG. 7 shows a configuration example of the worst execution time determination system 1000 according to the present embodiment.
Components that perform the same configuration and operation as those in FIG.

In the second embodiment, part of information stored in the execution path list stored in the execution path list storage unit 31 is added, and the operation content of the execution path combination determination unit 41 is different.
Hereinafter, the execution path list according to the present embodiment is referred to as an execution path list 310.
In FIG. 7, there are two execution time calculation units 100 for explanation of the flow, but the same one is assumed.

  A difference between the second embodiment and the first embodiment will be described.

In the execution mode 2, first, the execution path analysis unit 20 calculates a list of execution paths in the same manner as in the first embodiment, and then the execution time calculation unit 100 calculates the execution time when each execution path is executed alone. calculate.
At this time, each cache invalidation unit 80 in the execution time calculation unit 100 executes the cache memory in the simulation unit 50 in an invalid state, and always obtains data from the main memory ahead of the cache memory. Calculate the execution time of the execution path.
As a result, the worst execution time can be calculated (in fact, since the cache memory is enabled, it is not as bad as this time).

  The execution path list 310 stores the execution time of each path calculated by the execution time calculation unit 100 in addition to the cache execution path and the execution condition for executing the execution path as shown in FIG.

As in the first embodiment, the execution path combination determination unit 41 performs execution path combinations based on the execution paths and task schedules stored in the execution path list 310.
Then, from the combinations, combinations of execution paths that may exceed the deadline are extracted, and the simulation unit 50 calculates the execution time.

A method for extracting a combination of execution paths that may exceed the deadline will be described with reference to the example of FIG.
In the example, the real-time tasks of task A and task B are executed with the same execution schedule as in FIG.
The execution cycle of task A is 50 ms, and the execution cycle of task B is 100 ms.
Task A has three types of execution paths A1, A2 and A3, and task B has two types of execution paths B1 and B2. The individual execution times of A1, A2, and A3 are 5 ms, 20 ms, 60 ms, and B1. , B2 is 30 ms and 70 ms.
At this time, there are 18 combinations of execution paths according to the execution schedules of task A and task B in FIG.
Here, the execution path combination determination unit 41 calculates the total execution time of each single unit for the 18 combinations, and the execution time is a scheduling period (here, 100 ms) in which the execution path combinations of the tasks are performed. The simulation unit 50 calculates the execution time for those that exceed.
In FIG. Nine combinations of 6, 9, 11, 12, 14, 15, 16, 17, 18 are applicable.

The simulation unit 50 also calculates an execution time for a task whose execution time exceeds a deadline (execution cycle).
In FIG. Ten types of 3, 6, 9, 12, 13 to 18 are applicable.

  Among these, 11 combinations excluding duplication are combinations of execution paths for which the simulation unit 50 measures the execution time.

  The above is description of the operation | movement which reduces the number of execution path combinations by the execution path combination determination part 41. FIG.

<Effect of Embodiment 2>
As described above, in the present embodiment, the execution path combination determination unit 41 determines whether or not the deadline is exceeded by performing simulation only for combinations of execution paths that may exceed the deadline. Time to do can be reduced.

<Modification of Embodiment 2>
In this embodiment, the number of combinations is reduced based on the execution time of each execution path when there is no cache memory. However, when the effect of reducing the processing time by the cache memory is large, the execution time is much longer than the actual time. There is a possibility of executing almost all combinations.
Therefore, the cache memory may be enabled (a usable state), and the number of combinations may be reduced based on the execution time when the simulation is executed from a state where there is nothing in the cache memory at the start of execution.
However, in this case, in order to take into account the delay due to the increase in the number of cache misses due to being expelled from the cache when a high priority task is interrupted halfway, the time calculated by adding the margin time to the actual execution time Is the execution time of each execution path.
The margin time may be uniform for each execution path, or may be set according to cache usage characteristics such as the number of cache hits and cache usage.

  As a modification of the present embodiment, similar to the first embodiment, if the worst execution time determination unit 90 determines that the deadline is exceeded, the simulation may be terminated without executing a simulation of the combination of subsequent execution paths. As a result, the determination time can be shortened as in the first embodiment.

Also, the order of combinations of execution paths executed by the simulation unit 50 may be executed from the combination of the execution times calculated by the execution path combination determination unit 41 having the largest total.
In this case, since the simulation is executed from a path that is highly likely to exceed the deadline, it may be determined that the deadline is exceeded early.
At this time, if it is determined that the deadline is exceeded, the determination time can be further shortened by ending without executing the subsequent simulation.

Finally, a hardware configuration example of the worst execution time determination system 1000 shown in the first and second embodiments will be described with reference to FIG.
The worst execution time determination system 1000 is a computer, and each element of the worst execution time determination system 1000 can be realized by a program.
As a hardware configuration of the worst execution time determination system 1000, an arithmetic device 901, an external storage device 902, a main storage device 903, a communication device 904, and an input / output device 905 are connected to a bus.

The arithmetic device 901 is a CPU (Central Processing Unit) that executes a program.
The external storage device 902 is, for example, a ROM (Read Only Memory), a flash memory, or a hard disk device.
The main storage device 903 is a RAM (Random Access Memory).
The communication device 904 is, for example, a NIC (Network Interface Card).
The input / output device 905 is, for example, a mouse, a keyboard, a display device, or the like.

The program is normally stored in the external storage device 902, and is loaded into the main storage device 903 and sequentially read into the arithmetic device 901 and executed.
The program is a program that realizes a function described as “˜unit” (excluding “˜storage unit”, the same applies hereinafter) shown in FIG.
Further, an operating system (OS) is also stored in the external storage device 902. At least a part of the OS is loaded into the main storage device 903. ”Is executed.
In the description of the first and second embodiments, “determination of”, “determination of”, “extraction of”, “calculation of”, “detection of”, “setting of”, “ Information, data, signal values, and variable values indicating the results of the processing described as “Registration of”, “Selection of”, “Generation of”, and the like are stored in the main storage device 903 as files.

  The configuration of FIG. 10 is merely an example of the hardware configuration of the worst execution time determination system 1000, and the hardware configuration of the worst execution time determination system 1000 is not limited to the configuration illustrated in FIG. It may be a configuration.

  Further, the program analysis method according to the present invention can be realized by the procedure shown in the first and second embodiments.

  10 execution target S / W storage unit, 20 execution path analysis unit, 30 execution path list storage unit, 31 execution path list storage unit, 40 execution path combination determination unit, 41 execution path combination determination unit, 50 simulation unit, 60 task schedule Storage unit, 70 variable operation unit, 80 cache invalidation unit, 90 worst execution time determination unit, 100 execution time calculation unit, 1000 worst execution time determination system.

Claims (14)

An execution path extraction unit that analyzes a program composed of a plurality of blocks in which a plurality of tasks are generated and extracts a group of blocks executed in the task as an execution path for each task;
In accordance with the task generation order at the time of executing the program, an array pattern generating unit for arraying execution paths corresponding to each task and generating a plurality of array patterns by changing a combination of execution paths;
A program analysis apparatus comprising: an execution time calculation unit that calculates an execution time of an execution path for each execution path when execution paths included in the array pattern are sequentially executed for each arrangement pattern. The execution time calculation unit
2. The program analysis apparatus according to claim 1, wherein an execution time when execution paths included in the array pattern are sequentially executed in a program execution environment in which a cache memory is mounted is calculated for each execution path. The program analysis device further includes:
For each task, an upper limit time information storage unit that stores upper limit time information described as an upper limit execution time as an upper limit time;
The determination unit according to claim 1, further comprising: a determination unit that determines whether the execution time of each execution path calculated by the execution time calculation unit exceeds an upper limit time of a task of each execution path. Program analysis device. The determination unit
The execution time of each execution path calculated by the execution time calculation unit before the execution time calculation unit finishes calculating the execution time of the execution path for all the array patterns is the upper limit time of the task of each execution path. Determine whether or not
The execution time calculation unit
4. The subsequent execution time calculation is canceled when the determination unit determines that the execution time of any execution path exceeds the upper limit time in any array pattern. The program analysis device described in 1. The execution time calculation unit
The execution time of the execution path when the execution paths included in the array pattern are sequentially executed in order from the array pattern having the largest number of blocks is included for each execution path. The program analysis device described in 1. The program analysis device further includes:
Each task has an upper limit time information storage unit that stores upper limit time information described as an upper limit execution time as an upper limit time,
The execution time calculation unit
Calculate the execution time of each execution path when executed alone,
For each array pattern, determine whether the execution time of each execution path included in the array pattern exceeds the upper limit time of each execution path task,
For each array pattern, determine whether the total value of the total execution time of each execution path included in the array pattern exceeds the total value of the total upper limit time of tasks of each execution path,
Select at least one of an array pattern in which the execution time of a single execution path exceeds the upper limit and an array pattern in which the total execution time exceeds the total upper limit,
The program analysis apparatus according to claim 1, wherein the execution time of execution paths when execution paths included in the selected array pattern are sequentially executed is calculated for each execution path. The execution time calculation unit
The program analysis apparatus according to claim 6, wherein an execution time when each execution path is executed alone in a program execution environment in which no cache memory is mounted is calculated. The execution time calculation unit
In a program execution environment in which a cache memory is mounted, the execution time is calculated when each execution path is executed alone with no data in the cache memory at the start of execution of each execution path. The program analysis apparatus according to claim 6. The execution time calculation unit
Execution of execution paths when the execution paths included in the array pattern are executed in order from the array pattern with the largest total value of the total execution time of the individual execution paths included in the array pattern among the selected array patterns The program analysis apparatus according to claim 6, wherein the time is calculated for each execution path. The execution path extraction unit
Analyzing a program composed of multiple blocks that generate multiple real-time tasks, and for each real-time task, extract a group of blocks to be executed in the real-time task as an execution path in the order of execution,
The array pattern generation unit includes:
According to the generation order of the real-time task at the time of program execution, the execution path corresponding to each real-time task is arranged, and a plurality of arrangement patterns are generated by changing the combination of the execution paths,
The execution time calculation unit
The program analysis apparatus according to claim 1, wherein an execution time of an execution path when execution paths included in the array pattern are sequentially executed is calculated for each execution pattern. The execution time calculation unit
In the program execution environment where the cache memory is implemented, the execution path when the execution path is executed in a state where no data exists in the cache memory at the start of execution of the execution path in a specific execution order for each array pattern The program analysis apparatus according to claim 10, wherein the execution time is calculated for each execution path. The program analysis device further includes:
For each task, an upper limit time information storage unit that stores upper limit time information described as an upper limit execution time as an upper limit time;
The execution time of each execution path calculated by the execution time calculation unit before the execution time calculation unit finishes calculating the execution time of the execution path for all the array patterns is the upper limit time of the task of each execution path. And a determination unit for determining whether or not
The execution time calculation unit
The subsequent execution time calculation is canceled when the determination unit determines that the execution time of any execution path exceeds the upper limit time in any array pattern. The program analysis device described in 1. An execution path extraction step in which a computer analyzes a program composed of a plurality of blocks in which a plurality of tasks are generated, and extracts a group of blocks executed in the task as an execution path for each task;
The computer arranges execution paths corresponding to each task according to the generation order of the tasks at the time of executing the program, and generates a plurality of array patterns by changing the combination of the execution paths; and
An execution time calculating step for calculating, for each execution path, an execution time of an execution path when the execution path included in the array pattern is sequentially executed for each array pattern. . Analyzing a program composed of a plurality of blocks in which a plurality of tasks are generated, and for each task, an execution path extraction process for extracting a block group executed in the task as an execution path in the execution order;
Arranging execution paths corresponding to each task according to the generation order of the tasks at the time of program execution, and an array pattern generation process for generating a plurality of array patterns by changing the combination of execution paths;
A program that causes a computer to execute an execution time calculation process that calculates an execution time of an execution path for each execution path when execution paths included in the array pattern are sequentially executed for each arrangement pattern.

Images