JP2002318712A - Program execution history analysis method - Google Patents

Abstract

(57) [Summary] [PROBLEMS] Program development by acquiring valid history data during execution of a program, writing the history data into a data storage area, reading the history data from the data storage area after the program execution, and appropriately analyzing the history data. To provide a program execution history analysis method that can improve the efficiency of program execution. In a writing process, program execution history data is sequentially written from the last address of a data storage area to the front, and when there is no free space in the data storage area, the program returns to the last address of the data storage area. Overwrite the old history data. In the reading process, the history data is sequentially read from the data written last to the data storage area to the address area at the rear, in the reverse order of the writing.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program execution history analysis method for writing program execution history data in a data storage area when a software program is executed, and reading and analyzing the history data after the program ends.

[0002]

2. Description of the Related Art Conventionally, a technique of detecting an abnormal operation of a program by storing and analyzing program execution history data such as task generation, transition, and deletion has been used in program development and the like. The conventional program execution history analysis method and the program execution history analysis apparatus are configured such that every time execution transition of a task constituting a program, execution of a function, or the like occurs during execution of a program, the history data is read from a start address of a data storage area. The data is sequentially written to the subsequent address, and when the free space becomes insufficient, the process returns to the first address and overwrites the old data. When reading data after the end of the program, the oldest data remaining in the data storage area was read sequentially.

When graphing the analysis result, the tasks are arranged on the vertical axis for each identification number, the time is taken on the horizontal axis, and the state of task execution transition is indicated by a broken line based on task execution history data. The function execution is marked on the line of the task being executed at the time when the function execution is performed. The task execution history data includes the time at which the task transition occurred and the task identification number of the transition destination. When the history data is arranged in chronological order, the graph can be displayed from the task execution history data that appears first onward, and since the function execution history data before that cannot identify the task being executed, the graph cannot be displayed. The function execution data is composed of the time at which the function was issued, the function name and the value of the argument, and these were output as text data by the analysis tool.

In analyzing the execution history of a task, it is easier to use the task name than the task ID number. For example, in the graph display, the entry on the vertical axis is not displayed by the task ID number but by the task name. I do. There are two types of tasks: static tasks that exist from the beginning of the program, and dynamic tasks that are created and deleted during program execution. For a static task, the correspondence between the identification number and the name can be known from the task definition file, so that the task identification number can be converted to the task name, but for the dynamic task, the conversion from the identification number to the name has been difficult.

If it is not desired to overwrite the history data, a setting can be made to interrupt the execution of the program when there is no more free space in the data storage area. After the interruption, the execution was resumed after manually saving the history data in the data storage area.

[0006] To calculate the stack size used by a task, the function called by the task is further statically analyzed to determine which function is called, and the largest stack size is calculated based on the stack size required by each function. The task using the size was regarded as the stack size required by the task.

[0007]

According to the conventional program execution history analysis method, since the data storage area has a limited capacity, when the free area runs out, the old history data is overwritten with the new history data and disappears. . For this reason,
In particular, when the size of the history data differs depending on its type, that is, when the history data is variable in length, when the history data is read from the data storage area, the oldest history data remaining in the data storage area is deleted. There is a problem that it is difficult to search.

When graphing history data, it is not possible to specify which task has been executed in the function issue history data written before the task execution transition history data.

The function issuance history data can know the function name and the argument value, but cannot specify where in the source code the data was executed.

[0010] In addition, a dynamic task created and deleted during execution of a program is not registered in the task definition file, so that the task name cannot be obtained by referring to the task definition file.

In the case where the history data exceeding the capacity of the data storage area is obtained without being overwritten, in a system in which the timer is running even during the interruption of the program, the history data after the execution is resumed includes the time including the interruption time. Becomes
An accurate value cannot be obtained in the calculation of the task execution time or the like.

In the method of checking the stack size used by the function called by the task when checking the stack size used by the task, if the function includes a recursive call or a call using a pointer to the function, the method must be executed. For example, the stack size cannot be specified because the number of times the recursive call function is called is not known, or which function is called by the function call using the pointer.

In order to solve these problems, the present invention obtains effective history data and appropriately analyzes the history data to improve the efficiency of program development. It is intended to provide an analysis method.

[0014]

In order to achieve the above object, a first execution history analysis method according to the present invention comprises a writing process of writing program execution history data to a data storage area; In the program execution history analysis method including an analysis process of reading and analyzing the history data from, in the write process, write each history data to an address area ahead of the address area where the previous history data was written, If it is determined that there is no free area corresponding to the data size of the history data to be written, the process returns to the last address of the data storage area and overwrites the history data, and the analysis process performs the last write in the write process. From the stored history data to the rear address of the data storage area. If the history data is read out to the last address of the data storage area and there is still data to be read, the data is jumped to the top address of the data storage area, and the data is read ahead of the last written history data. It is characterized in that history data stored in an address is sequentially read.

According to this method, the history data is sequentially written from the last address of the storage area to the front, and when there is no free area in the data storage area, the data is overwritten by returning to the last address, and when the data is read, the writing order is changed. Conversely, reading is performed sequentially from the last written data to a subsequent address. As a result, it is not necessary to search for the read start position, and the reading of the history data can be started immediately, so that the efficiency of the program execution history analysis processing is improved. In particular, when the history data has a variable length and the history data is overwritten, the search for the read start position, which has been difficult in the past, can be easily performed, and the effect is remarkable.

In the first program execution history analysis method, if it is determined in the writing process that the capacity of the free area is smaller than the data size of the history data to be written, the free area of the history data is It is preferable that a writable portion is written to the free space, and the remaining portion is written to an address area in front of the last address of the data storage area.

Further, a second execution history analysis method according to the present invention includes a writing process of writing program execution history data to a data storage area, and an analysis process of reading and analyzing the history data from the data storage area. In the method for analyzing program execution history including, when the execution transition of a task occurs in the writing process, the data including the time when the execution transition occurred and the task identifier of the execution transition source is defined as the execution history data. It is characterized in that data is written in a data storage area.

According to this method, when a task execution transition occurs during the execution of a program, history data including the time at which the execution transition occurred and the task identifier of the execution transition source is written into the data storage area. For example, when the history data immediately before the occurrence of the task execution transition indicates that the function has been issued, it is possible to specify which task executed the function. As the task identifier, any expression form such as a number, a symbol, or a combination thereof can be used as long as it can identify an individual task.

In the second program execution analysis method, in the writing process, when the analysis target program is stopped, data including a task identifier of a task executed immediately before the stop is stored as execution history data in the data storage area. It is preferable to write. This makes it possible to specify how the task execution has transitioned over the entire period from the start to the stop of the execution of the analysis target program.

A third execution history analysis method according to the present invention includes a writing process of writing program execution history data in a data storage area and an analysis process of reading and analyzing the history data from the data storage area. In the program execution history analysis method, each time a function is executed during execution of the program in the writing process, data including a time at which the function execution occurred, a function name, and a function return address are stored in the history. The data is written to the data storage area, and in the analysis processing, the function return address included in the history data read from the data storage area is obtained from a source code information correspondence table indicating the correspondence between the function return address and the source code information. Acquires source code information corresponding to and displays the acquired source code information. The features.

According to this method, a function return address is written as execution history data, and the function return address is converted into source code information during analysis processing. As the source code information, for example, a source file name and a line number corresponding to the function return address can be used. This makes it possible to specify where in the source code the function was executed.

The source code information correspondence table can be created by a compiler when compiling the program. Further, the function return address can be obtained from the stack written at the time of calling the function.

A fourth execution history analysis method according to the present invention is a program including a writing process of writing history data of program execution to a data storage area, and an analysis process of reading and analyzing the history data from the data storage area. In the execution history analysis method, in the writing process, (a) each time a task is generated, task generation data including a time at which the task is generated, a task identifier, and a task name are used as the history data. Write to the storage area, (b) Every time a task is deleted,
Task deletion data including the time at which the task was deleted, the task identifier, and the task name are written to the data storage area as the history data. (C) The time at which the task transition occurred every time a task transition occurred And task transition data including a task identifier, writing the history data in the data storage area, in the analysis processing, of the history data read from the data storage area, from the task generation data and the task deletion data, A task name correspondence table including a task identifier, a task creation time, a task deletion time, and a task name is created, and among the history data read from the data storage area, a task transition graph is created from the task transition data. On the graph, the task name corresponding to the reference time and task identifier And displaying the task name obtained from.

In this method, information on task generation, deletion, and transition is written as history data in a data storage area, and in an analysis process, a task name correspondence table is created based on the information, and a task transition graph is created. On output,
The reference time is determined, and the task name is obtained from the task name correspondence table using the reference time and the task identifier as keys. This makes it possible to graphically display the names of tasks that are dynamically created and deleted, thereby facilitating program analysis.

A fifth execution history analysis method according to the present invention includes a writing process of writing program execution history data to a data storage area, and an analysis process of reading and analyzing the history data from the data storage area. In the program execution history analysis method, (a) in the write processing, interrupted data including data of the time at which the program execution was interrupted is recorded as the history data in the data storage area, and (b) program execution is resumed. The resume data including the data at the time when the program was executed is recorded as the history data in the data storage area, and in the analysis process, the interruption time of the program execution is obtained based on the suspend data and the resume data. The interruption time is subtracted from the time of the history data at a later time.

According to this method, when the program execution is interrupted for some reason, the interruption time and the restart time are recorded in the data storage area as history data, and the time of each history data after the program execution is resumed at the time of analysis processing. By subtracting the interruption time from, the execution history can be analyzed as if there was no interruption.

Thus, for example, in the writing process,
When it is determined that there is not enough free space for writing history data in the data storage area, a program is executed to save all history data stored in the data storage area to a save area such as another data storage area. Can be interrupted. In this case, after the saving of the history data is completed, the data storage area is initialized if necessary, and the execution of the program and the writing of the history data are resumed. The history data is read, the history data after the program execution is resumed from the data storage area, and the interruption time is subtracted from the time of each history data after the execution is resumed as described above, as if there was no interruption. , The execution history can be analyzed.

A sixth execution history analysis method according to the present invention is a program including a writing process of writing history data of program execution to a data storage area, and an analysis process of reading and analyzing the history data from the data storage area. In the execution history analysis method, every time a task transition occurs in the writing process, data including a task identifier of a transition source task or a transition destination task and a stack size used by the task is stored in the history data. And writing a maximum stack size for each task identifier from all the history data read from the data storage area in the analysis processing.

According to this method, the stack size used by each task is stored as history data in the data storage area, and the maximum value of the stack size of each task is calculated at the time of analysis processing, so that each task uses the stack size. It is possible to optimize the setting of the stack size.

[0030]

(Embodiment 1) FIGS. 1 and 2
An embodiment of the present invention will be described with reference to FIG.

FIG. 1 is a flowchart showing a processing procedure of the program execution history analysis method according to the present embodiment. In this program execution history analysis method, a process 100 for writing history data to a data storage area is performed during execution of a program, and a process 150 for reading history data from the data storage area is performed after the program is completed. The reading process 150 is performed as a part of the history data analysis process.

In the writing process 100, history data is written in order from the last address of the data storage area to the front according to the following procedure.

That is, in the write processing 100, first, the last address of the data storage area is stored in the pointer A (step 101). Next, the size of the history data to be written is compared with the remaining capacity of the data storage area (step 102), and if there is sufficient remaining capacity in the data storage area to write the history data (the result of step 102 is Y ), The address pointed by the pointer A is set ahead by the size of the history data to be written (step 1).
05). Thereafter, the history data is written from the address indicated by the pointer A (step 106).

On the other hand, if there is not enough free space in the data storage area to write the history data (the result of step 102 is N), the address value of the pointer A is substituted for the pointer B (step 103). After substituting the last address of the data storage area into A (step 104),
Perform steps 105 and 106. That is, when there is not enough free space in the data storage area, the position of the last written history data is recorded in the pointer B,
Older history data is overwritten forward from the last address of the data storage area.

Steps 102 to 106 are repeated until the program execution ends, that is, until there is no more history data to be written (the result of step 107 is Y).

Here, a procedure for writing the history data a to g in the data storage area will be described with reference to FIG. It is assumed that the position of the pointer A before writing the history data a is A ′ in FIG. In this case, the history data a is the history data A from the position of A ′.
The data is written in the data storage area as shown in FIG. Thereafter, similarly, history data b and c are sequentially written toward the front of the data storage area as shown in FIG. Then, when trying to write the history data d,
Since the free space of the data storage area is smaller than the data size of the history data d, the process returns to the last address of the data storage area, and the history data d is overwritten on the old data. Subsequently, the history data e, f, and g are written in the order of the front of the data storage area, and when the data g is written, the writing process 100 is completed. As can be seen from FIG. 2, the pointer A at the end of the write processing 100 points to the head address of the last written history data (history data g in FIG. 2).

Next, the reading process 150 shown in FIG. 1 which is performed after the execution of the program is described. In the reading process 150, the writing process 10
Conversely to 0, the history data is sequentially read from the front to the rear of the data storage area.

In the reading process 150, first, the address value of the pointer A is assigned to the pointer C (step 15).
1). That is, in the case of FIG. 2, the head address of the history data g written last in the write processing 100 is substituted into the pointer C as the read start position.

Next, before reading the history data, the address of the pointer A is compared with the last address of the data storage area (step 152).
When the result of 52 is N), the history data is read from the position indicated by the pointer A (step 154). On the other hand, if the address pointed by the pointer A is equal to the last address of the data storage area (the result of step 152 is Y), the value of the pointer B is assigned to the pointer A (step 153), and then step 154 is executed.

After reading the history data in step 154, the position pointed to by the pointer A is shifted backward by the data size of the read history data (step 155).
Next, the address of the pointer C is compared with the address of the pointer A (step 156). If they are equal (the result of step 156 is Y), the processing is terminated. Perform data read processing.

As described above, in the case of FIG. 2, reading is performed in the order of the history data g, f, e, and d. When reading the next history data c, referring to the address indicated by the pointer B, The read position is known. Further, the history data b and a are read. Part of the data overwritten by the history data a written last remains, but is not read because it is overwritten by the history data g and is invalid. That is, the reading process ends when the history data a is read.

As described above, according to the procedure shown in FIG.
For example, as shown in FIG. 2, a, b, c, d, e, f,
The history data written to the data storage area in the order of g is written in the reverse order of writing, that is, g, f, e,
Reading is performed in the order of d, c, b, and a.

Thus, even when the history data is overwritten in the data storage area, it is sufficient to read from the data indicated by the pointer A at the time of reading, and it is not necessary to search for the history data to be read first. In this embodiment, when the free space of the data storage area becomes insufficient,
Nothing is written in the free space at the beginning of the data storage area, and the data is overwritten from the last address.However, the history data is divided and data that can be written to the capacity of the free space at the beginning is written, and the remaining data May be written from the last address.

(Embodiment 2) Hereinafter, another embodiment of the present invention will be described. FIG. 3 is an explanatory diagram illustrating the contents of the history data according to the present embodiment. FIG. 4 is a graphical representation of a program execution history obtained as a result of analyzing the history data shown in FIG.

In the present embodiment, when a task execution transition occurs, data including the time at which the execution transition occurred and the task identification number of the execution transition source is written to the data storage area as execution history data. When the program is stopped, the data including the task identification number of the task executed immediately before the stop is written to the data storage area as execution history data. In addition, function execution history data, etc.
Written to the data storage area.

In FIG. 3, the history data at time t1 is the history data of the function execution. The history data at times t2 to t5 are all history data of task execution transition, and indicate that execution has transitioned from task 1, task 3, task 2, task 1 to another task, respectively. The last line indicates the execution task at the end of the data, that is, at the end of writing the history data of the program. In the case of FIG. 3, task 3 corresponds to this task.

In the analysis processing, these pieces of history data are read and a graph as shown in FIG. 4 is displayed. In the conventional method, it was not possible to know which task executed the function executed at the time t1, and it was not possible to display a graph. However, according to the present embodiment, the function execution occurred at the time t1 as shown in FIG. The fact that the function execution has been executed in task 1 can be displayed graphically.

(Embodiment 3) Still another embodiment according to the present invention will be described below.

FIG. 5 shows an example of displaying detailed information of function execution data on a graph display screen of history data in the analysis processing. Detailed information on function data includes function name, time,
In addition to the arguments, the return position of the function is included. The return position of the function is indicated by the source code file name and line number.
In other words, it can be known from this information that the function was issued by the function call described in which file of which file.

FIG. 6 shows a procedure for acquiring detailed information of function execution data. First, function execution data is written (step 400). At this time, as shown in the function execution data 450, other data such as a time, a function name, a function return address, and an argument value are written to the data storage area 440. Since the return address of the function is written on the stack when the function is called, it can be obtained by reading the contents. Step 400 includes:
During the execution of the program, it is repeated each time the function is executed.

After the program ends, the function execution data is read from the data storage area 440 in step 410, the source code information correspondence table 460 is searched in step 420 using the return address as a key, and the source code file name and the line number are searched. Source code information. The source code information correspondence table 460 is generally created by a compiler as debug information when compiling a program.

At step 430, the function name, time, argument value, etc. read at step 410 and the return position of the function obtained at step 420 are displayed. By looking at the return position of the function, the program analyst can specify where in the source code the function was issued.

(Embodiment 4) Still another embodiment of the present invention will be described below.

FIG. 7 shows a relationship between a procedure for acquiring a task name and a task name correspondence table. FIG. 8 is an explanatory diagram showing how task names are displayed on the graph display screen.

In FIG. 7, reference numeral 500 denotes task generation history data, and 510 denotes task deletion history data, each of which includes a time, a task identification number, and a task name. 5
20 is an example of a task name correspondence table. Task name correspondence table 5
20 is created from the task generation history data 500 and the task deletion history data 510.

In the present embodiment, as shown in FIG. 8, in the graph display, time is taken on the horizontal axis, and tasks are entered for each task identification number on the vertical axis. In the graph display,
Instead of displaying the task identification numbers, the respective task names at the left end time of the graph display area are displayed.

First, after acquiring the reference time in step 530 shown in FIG. 7, the task identification number is acquired in step 540, and the task name correspondence table 520 is searched in step 550 using the task identification number and the reference time as keys. And get the task name. At step 560, the task name obtained at step 550 is displayed. And step 54
0, steps 550 and 560 are performed for all tasks.

In FIG. 8, a graph 580 shows all the history data in a graph. A graph 581 shows the area A of the graph 580, a graph 582 shows the area B, and a graph 583 shows the area C. is there.

In the graph 581, the reference time t1 is
Since TASK # A is before the value at time t100 when it is deleted, the task names of identification numbers 1 and 2 are displayed as “TASK # A” and “TASK # C” from the task name correspondence table 520, respectively. In the graph 582, at the reference time t2, from the task name correspondence table 520, since the task with the identification number 1 does not exist, “NON # EXISTENC” indicating that the task name does not exist.
The task with the identification number 2 is displayed as “TASK # C.” In the graph 583, after the task TASK # B with the identification number 1 is generated from the task name correspondence table 520 at the reference time t3. Therefore, it is displayed as “TASK # B.” The task with the identification number 2 is displayed as “TASK # C.”

In this way, the task name can be uniquely obtained from the reference time and the task identification number, so that a graph with the task name can be displayed in an arbitrary area. The task can be easily identified as compared with the case of identifying the task.

(Embodiment 5) Still another embodiment according to the present invention will be described below.

In the present embodiment, if there is no free space in the data storage area during the writing of the history data of the program execution, the program is stopped, the history data in the data storage area is saved, and Initialize the data storage area and restart the program. The timer is running while the program is stopped.

FIG. 9A is a graph showing a task transition including a program stop section. In FIG. 9, the execution is interrupted at time t3 during the execution of the task 2 and resumed at time t4. Between the time t3 and the time t4, the program is stopped and not the task 2 execution section.
However, in the history data, it becomes as if it were an execution section of task 2, and an error occurs when the execution time of task 2 is measured.

Therefore, the time t3 at which the execution was interrupted and the time t4 at which the execution was resumed are left as interruption history data and resumption history data, respectively. Then, in the analysis of the history data, the program interruption time (t4-t
3) is calculated, and the interruption time is subtracted from all the history data times after the restart history data. When the result is graphed, as shown in FIG. 9B, a graph in which the interruption section of the program is deleted is obtained. The execution history data generated at time t5 and time t6 is the time t4 of the restart history data.
Since the time is later, t
5 ′ and t6 ′.

This eliminates the need for the user to manually evacuate the data, and allows the analysis result to be presented as if there were no interruption time. Many historical data can be handled.

(Embodiment 6) Still another embodiment according to the present invention will be described below.

In this embodiment, the stack size at the time is recorded together with the execution transition history data of the task, and the maximum value of the stack size of each task is extracted at the time of analysis, so that the stack used by each task is extracted. Optimize size settings.

FIG. 10A shows an example of the task transition graph. FIG. 10B shows the configuration of task transition history data from which a task transition graph is created. The task transition history data includes a task transition time, a task transition source task identification number (task ID), and a stack size used by the task.

FIG. 10C shows an example in which the maximum stack size is extracted for each task. In the example of FIG. 10C, for the task with the task ID of 1, data exists at times t1 and t4, and the used stack sizes at the respective times are 100 and 250, so the maximum stack size is 2
It becomes 50. In the case of the task with the task ID of 2 and the task with the task ID of 3, there is only one data in this example, and the values of the used stack sizes 80 and 230 are extracted as the maximum values as they are.

As described above, by adding the used stack size of the task to the task transition history data, it can be used for measuring the stack size used by the task, and the definition of the stack size used by the task can be optimized. Will be possible. In the present embodiment, an example has been described in which the task history data includes the task transition source and its stack size. However, the same effect can be obtained when the task history data includes the task transition destination and its stack size.

[0071]

As described above, according to the present invention, there is provided a program execution history analysis method capable of improving the efficiency of program development by acquiring effective history data and appropriately performing the analysis process. Can be provided.

[Brief description of the drawings]

FIG. 1 is a flowchart showing a procedure of a program execution history analysis method according to a first embodiment of the present invention;

FIG. 2 is an explanatory diagram showing a state of history data written to a data storage area in the first embodiment.

FIG. 3 is an explanatory diagram showing an example of history data used in a program execution history analysis method according to a second embodiment of the present invention;

4 is a graph showing a program execution history obtained as a result of analyzing the history data shown in FIG. 3;

FIG. 5 is a graph of a program execution history displayed together with detailed information of function execution data by the program execution history analysis method according to the third embodiment of the present invention;

FIG. 6 is a flowchart showing a procedure for acquiring detailed information of function execution data.

FIG. 7 is an explanatory diagram showing a relationship between a procedure for acquiring a task name and a task name correspondence table by the program execution history analysis method according to the fourth embodiment of the present invention;

FIG. 8 is an explanatory diagram showing a display example of an acquired task name on a graph display screen.

FIG. 9A is a graph showing an example of a task transition including a program suspension section, and FIG. 9B is a graph showing a program interruption section obtained by the program execution history analysis method according to the fifth embodiment of the present invention. Deleted graph

10A is a graph showing an example of a task transition, FIG. 10B is an explanatory diagram showing an example of the configuration of task transition history data from which a task transition graph is created, and FIG. Explanatory diagram showing an example of extracting the maximum stack size from history data

[Explanation of symbols]

 440 Data storage area 450 Function execution data 460 Source code information correspondence table 500 Task generation history data 510 Task deletion history data 520 Example of task name correspondence table 580 Graph display of all history data 581 Graph display of area A 582 Graph display of area B 583 Graph display of area C

Claims (11)

[Claims] 1. A program execution history analysis method comprising: a writing process of writing program execution history data to a data storage area; and an analysis process of reading and analyzing the history data from the data storage area. If each history data is written to an address area ahead of the address area where the previous history data was written, and it is determined that there is no free area corresponding to the data size of the history data to be written, Return to the last address and overwrite the history data. In the analysis process, sequentially read the stored history data from the last written history data in the write process toward the rear address of the data storage area. The history data is read up to the last address of the data storage area. If there is data to be read, the program jumps to a start address of the data storage area, and sequentially reads history data stored at an address ahead of the last written history data. Method. 2. When the capacity of the free area is determined to be smaller than the data size of the history data to be written in the writing process, a portion of the history data that can be written to the free area is written to the free area; 2. The program execution history analysis method according to claim 1, wherein the remaining portion is written to an address area ahead of the last address of said data storage area. 3. A program execution history analysis method, comprising: a write process of writing program execution history data to a data storage area; and an analysis process of reading and analyzing the history data from the data storage area. Writing a data including a time at which the execution transition occurs and a task identifier of the execution transition source to the data storage area as the execution history data when the execution transition of the task occurs. Method. 4. The writing process according to claim 3, wherein, when the analysis target program is stopped, data including a task identifier of a task executed immediately before the stop is written to the data storage area as the execution history data. Analysis method of program execution. 5. A program execution history analysis method comprising: a write process of writing program execution history data to a data storage area; and an analysis process of reading and analyzing the history data from the data storage area. Each time a function is executed during execution of the program, data including a time at which the function is executed, a function name, and a function return address are written to the data storage area as the history data, and the analysis processing is performed. Source code information corresponding to the function return address included in the history data read from the data storage area from the source code information correspondence table indicating the correspondence between the function return address and the source code information. A program execution history analysis method characterized by displaying code information. 6. The program execution history analysis method according to claim 5, wherein the source code information correspondence table is created by a compiler when compiling the program. 7. The program execution history analysis method according to claim 5, wherein the function return address is obtained from a stack written at the time of calling the function. 8. A program execution history analysis method comprising: a write process of writing program execution history data to a data storage area; and an analysis process of reading and analyzing the history data from the data storage area. (A) Every time a task is generated, task generation data including the time at which the task was generated, a task identifier, and a task name are written to the data storage area as the history data, and (b) the task is deleted. Every time the task is deleted, the task deletion data including the time at which the task was deleted, the task identifier, and the task name
Writing to the data storage area as the history data,
(C) Every time a task transition occurs, task transition data including the time at which the task transition occurred and a task identifier are written as the history data to the data storage area. Among the read history data, a task identifier, a task creation time,
A task name correspondence table including a task deletion time and a task name is created, and among the history data read from the data storage area, a task transition graph is created from the task transition data, and a reference time is set on the transition graph. And displaying a task name acquired from the task name correspondence table based on the task identifier and the task identifier. 9. A program execution history analysis method comprising: a write process of writing program execution history data to a data storage area; and an analysis process of reading and analyzing the history data from the data storage area. (A) recording the interruption data including the data of the time when the program execution was suspended in the data storage area as the history data, and (b) resuming the data including the data of the time when the program execution was resumed. Recorded in the data storage area as history data, in the analysis process, based on the interruption data and the resumption data, determine the interruption time of the program execution, from the time of the history data that takes time after the resumption data,
A program execution history analysis method, wherein the interruption time is subtracted. 10. In the writing process, when it is determined that there is not enough free space in the data storage area, the program execution is interrupted, and after the program execution is interrupted, all the history data stored in the data storage area are interrupted. In the save area, resume the program execution after saving the history data, read the history data before the interruption of the program execution from the save area in the analysis processing, and resume the program execution from the data storage area. The program execution history analysis method according to claim 9, wherein the subsequent history data is read. 11. A program execution history analysis method, comprising: a write process of writing program execution history data to a data storage area; and an analysis process of reading and analyzing the history data from the data storage area. , Every time a task transition occurs,
Data including a task identifier of a transition source task or a transition destination task and a stack size used by the task is written as the history data to the data storage area, and is read from the data storage area in the analysis processing. A program execution history analysis method, wherein a maximum stack size value for each task identifier is calculated from all the history data.