JP3459898B2 - Fault information tracer for embedded systems - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION The present invention relates to the development of a program system incorporated in a device to be controlled.
While monitoring the execution status of this embedded system,
The present invention relates to a fault information tracer device of an embedded system for analyzing a fault occurring in a program.

[0002]

2. Description of the Related Art Generally, in the main memory of an electronic computer,
An operating system (hereinafter abbreviated as OS) is installed in the resident area. Also,
A dedicated control program is installed in each of various control devices equipped with a microprocessor and the like. When developing such a control system, it is important to test the algorithm on the system program in the running state. Therefore, conventionally, various debugging devices for programs installed in devices to be controlled have been proposed.

For example, Japanese Patent Laid-Open No. 11-184728 discloses a "debug processing method and a debug processing device" for identifying a runaway portion of a program. In the debug processing device of the first conventional example, a command group related to a debug operation is stored as history information in the order of execution. When a failure occurs in the program, the person who debugs the program resets the program to the initial state by the debugger and executes the command group only in a sufficiently short section before the step in which the failure occurs.

In this way, the execution section of the command group is appropriately selected, the partial program is repeatedly run normally, and the program is advanced to the step immediately before the reset operation described above to identify the number of the failed step. To do.
Then, each command is sequentially executed by the debugger until just before this number. Therefore, the command executed when the failure occurs can be specified, and the state where the program was running normally and immediately before the occurrence of the failure can be reproduced.

In addition to the method of reproducing the debug operation just before such a failure, when a failure occurs while the program is running, there is a method of specifying the corresponding position corresponding to the failure step on the source file. is there. According to the method of the second conventional example, history information regarding the position of the source file can be output. Therefore, the person who debugs the program can directly specify the execution position of the program on the source file, and can trace the failure more easily than the first conventional example.

[0006]

However, the following problems are encountered when trying to find the cause of a failure that occurs when an embedded system is developed using these conventional examples. First, according to the first conventional example, along with the running of the program to be executed, in the method of storing the history information of the command group related to the debug operation, the operation state of the system just before the failure occurs is reproduced,
It is not possible to specify the details of the program that led to the failure.

Further, according to the second conventional example, when a fault occurs during the running of a program, the history information regarding the corresponding position of the source file corresponding to this is output, and the program execution position at the time of the fault is the same. Even if there is, the history information changes every time the source file is revised due to system development. Therefore, there is a problem that a person who debugs is misled by the change in the history information and spends extra time in analyzing the cause of the failure. Therefore, it has been an important technical problem to comprehensively solve these problems.

An object of the present invention is to develop a built-in system, reproduce the execution status of a program at the time of occurrence of a failure based on history information associated with the execution of a system program, and provide a failure for a tester who performs debugging. It is an object of the present invention to provide a failure information tracer device for an embedded system, which notifies information about the history of the occurrence and can smoothly analyze the cause of the failure regardless of the program change due to the progress of debugging.

[0009]

In order to solve the above-mentioned problems, a failure information tracer device for an embedded system according to the present invention includes a test device in which a program to be debugged is installed, and a debug target on the test device. In the fault information tracer device of the embedded system consisting of the device under test in which the cause of the fault is analyzed while monitoring the progress of the program, the execution history collection in which the history information by the program to be debugged is organized in the test device And a trace information analysis program in the device under test, which acquires analysis information from the source file group of the debug target program based on the history information sent from the execution history collection unit when a failure occurs There is.

In the fault information tracer device of this built-in system, when the program to be debugged is run on the test device, the running history is organized into history information by the execution history collection unit. If any trouble occurs during the running of the program, the history information organized at this time is sent from the test device to the device under test and monitored by the trace information analysis program. Then, the corresponding source program is specified from the monitoring result of the history information, and the analysis information of the corresponding portion is acquired from the specific source program and is shown together with the running progress of the program to be debugged.

In the fault information tracer device for an embedded system according to a second aspect of the present invention, the test device has a memory area for outputting history information by the execution history collecting section. According to this, while the program to be debugged is running, the running progress up to the occurrence of a failure is retained in the memory area as history information.

In the fault information tracer device for an embedded system according to claim 3 of the present invention, the test device has a debug monitor for transferring history information to the device under test. According to this, the history information is transferred to the device under test when a failure occurs.

According to a fourth aspect of the present invention, in the fault information tracer device for an embedded system, the device under test has a trace memory dump result file based on history information from the test device. According to this, the source file group is operated while retaining the history information at the time of failure occurrence.

According to a fifth aspect of the present invention, in the fault information tracer device of the embedded system, the device under test has debugger software capable of acquiring history information by the test device. According to this, the history information necessary for the failure analysis is acquired from the test apparatus.

A fault information tracer device for an embedded system according to claim 6 of the present invention is a debug target in a test device.
The program is configured to have a process of starting the execution history collection unit. According to this, along with the execution of the program
History information is acquired. A failure information tracer device for an embedded system according to claim 7 of the present invention is provided in a device under test.
The source file is the execution history of the program to be debugged.
It is configured to have a comment on the weft. By this
If so, information about how the program was executed is available in the source file.
Obtained from Ill's comment.

[0016]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An example of an embodiment suitable for the present invention will be described below with reference to the accompanying drawings. 1 and 2 are views for explaining a failure information tracer device of an embedded system according to an embodiment of the present invention. FIG. 1 shows a configuration example of this embodiment, and FIG. 2 shows a failure analysis thereof. A flow chart of an example of processing is shown.

Referring to FIG. 1, a fault information tracer device 100 of an embedded system according to the present configuration example includes a test device 1 for incorporating and executing a program (hereinafter simply referred to as a program) 11 to be debugged, and the test device. The source file group 23 of the program 11 above is stored, and the device under test 2 detects the failure status of the program 11 while monitoring the execution progress of the program 11.

From this test device 1 to the device under test 2,
The execution status of the program 11 is communicated via the mutual communication function. Further, the device under test 2 is provided with a display as a device for displaying the detected failure status. As a result, in the device under test 2, the source file group 23 is appropriately managed as the tester debugs the program 11, and the cause of failure is analyzed from the running progress of the program 11.

The test apparatus 1 stores an execution-format program 11 implemented in a simulation environment, an execution history collection unit 12 that organizes history information as the program 11 runs, and history information obtained by the execution history collection unit 12. The trace memory 13 which is a memory area for storing the trace memory 13 while communicating with the device under test 2
A debug monitor 14 for dumping the stored contents of the above into the device under test 2 is provided.

The trace memory 13 has a memory area with a sufficient storage capacity for storing organized history information. Therefore, it is desirable to estimate the amount of history information necessary for analyzing the cause of failure in advance. Also, if cyclic memory addresses are assigned, efficient overwriting becomes possible by addressing the execution history collecting unit 12.

The device under test 2 includes debugger software 21 for introducing history information into the device under test 2 via the debug monitor 14, a trace memory dump result file 22 in which history information by the debugger software 21 is stored, and a test. A trace information analysis program 24 is provided which outputs a relevant part from the source file group 23 while referring to the source file group 23 and the trace memory dump result file 22 of the program 11 executed on the device 1.

Next, an example of a failure analysis process according to this embodiment will be described with reference to a flowchart. As a premise,
When executing the program 11 on the test apparatus 1,
One or more locations (breakpoints) where the execution status of the program 11 is easy to confirm are specified. Then, while starting the execution history collecting unit 12 at each location ,
Specify the data you want to collect as history information . At the same time, in correspondence with the activation of each execution history collection unit 12 ,
Describe the appropriate comments for the analysis process when a failure is detected at the matching points.

Specifically, for example, when the source file group 23 is organized by using C language as a system description language, such processing can be described as in the following example , and the analysis is performed. Appropriate comment on processing
Each can be described in the immediately preceding line. Further, preferably, this processing may be described in a plurality of important points suitable for debugging. / * Comment * / Dump (file ID, LINE, collected data ...);

In this case, the "comment" is a description about the collected history information and other execution history, for example, information indicating the travel route of the program 11 is described. Further, “Dump” is a dump function that activates the execution history collection unit 12, and “File ID” is the source file group 2
3 is an identification number for designating a specific file.
"LINE" is a symbol name defined by the ANSI standard, and is converted into a specific line number by the preprocessor during compilation. The “collected data” is data stored in the trace memory 13 as history information.

Generally, the C language is known for its high portability of programs in the operating system UNIX (registered trademark) of small computers. However, when the failure analysis of the program 11 is performed by the above-described conventional example, the tester needs to be aware of a specific line number of the source file group 23. On the other hand, in this embodiment, the "file ID"
This automatically selects a specific source file and converts "LINE" into a specific line number, so it is not necessary for the tester to be aware of these.

After the above preparations are made, the program 11 is run on the test apparatus 1 in which the simulation environment is set. Referring also to FIG. 2, the running with the (Step A1) of the program 11, the program described above
A process corresponding to the dump function is executed at a location where the execution status can be easily confirmed . Then, the execution history collecting unit 12 is called, the history information regarding the execution state at that time is output and saved in the trace memory 13 (step A).
2).

At this time, the execution history collecting unit 12 specifies a specific "file" for designating the source file group 23.
"ID" and a specific line number in the source file are output to the trace memory 13. Further, at that time, arbitrary data to be referred to is also output together. This in a predetermined memory area of the trace memory 13, the latest history information is overwritten, or a plurality of history information is organized.

In this way, the execution history collection unit 12 is activated at each information collection location , and the debug monitor 14 determines whether or not a failure has occurred at each execution step as the program 11 runs ( Step A3).
As a result, when the occurrence of a failure can be confirmed, the running state of the test apparatus 1 is initialized to restore the failure state. If no trouble has occurred, the process returns to step A1 to continue the normal running of the program 11.

Further, when a failure occurs in the program 11, the fact is reported to the debug monitor 14 of the test apparatus 1. The debug monitor 14 transfers the history information stored in the trace memory 13 to the device under test 2 while communicating with the debugger software 21 of the device under test 2. And
This history information is introduced into the device under test 2 by the debugger software 21, and the trace memory dump result file 22
(Step A4).

In the device under test 2, the trace memory dump result file 22 is stored in the trace information analysis program 2
Let 4 get it. Then, in the history information, "File I
The file group 23 is accessed by "D", a specific source file is selected and referred to, and the relevant part of this source file is specified by the line number of the history information. As a result, the history information collected by the execution history collecting unit 12 is stored in the source file at the specified line number (immediately before).
The comment is output to the display 3 together with the comment (step A5).

Therefore, from the comment displayed on the display 3, the tester who debugs the program 11 can immediately understand the execution process leading to the failure while recognizing the running route of the program 11 up to that time. Further, since the relevant part of the program 11 and the running state under the simulation environment can be confirmed from the collected data and the like, it is possible to proceed with the failure analysis while also confirming the execution state of the program 11.

[0032]

As described above in detail, according to the fault information tracer device of the embedded system of the present invention, comments such as the execution history of the program are shown to the tester along with the running state of the program when the fault occurs. Be done. Therefore, only the information required by the program developer can be displayed on the display or the like in the format intended by the developer, and the history of the failure can be easily grasped.

The source file in the development process is used as it is as an input file of the trace information analysis program. Therefore, even if the source file is revised due to debugging or addition of functions, the output format of the history information does not change and the tester does not search for the relevant part when a failure occurs.

[Brief description of drawings]

FIG. 1 is a diagram for explaining a failure information tracer device of an embedded system according to an embodiment of the present invention, and shows a configuration example of this embodiment.

FIG. 2 is a flowchart illustrating an example of failure analysis according to a configuration example of the embodiment illustrated in FIG.

[Explanation of symbols]

1 test equipment 2 Device under test 3 display 11 programs (debugging target programs) 12 Execution history collection section 13 Trace memory 14 Debug monitor 21 Debugger software 22 Trace memory dump result file 23 Source File 24 Trace information analysis program 100 Fault information tracer device for embedded system

─────────────────────────────────────────────────── ─── Continuation of the front page (56) Reference JP-A-4-352245 (JP, A) JP-A-3-54643 (JP, A) JP-A-10-228395 (JP, A) JP-A-2- 294849 (JP, A) JP 63-64138 (JP, A) JP 63-143638 (JP, A) JP 7-311692 (JP, A) JP 1-295344 (JP, A) JP-A-5-224984 (JP, A) JP-A-3-225535 (JP, A) JP-A-11-184728 (JP, A) Actually developed JP-A-106942 (JP, U) (58) Fields investigated (Int.Cl. ⁷ , DB name) G06F 11/28-11/34

Claims (7)

(57) [Claims] 1. An embedded system comprising a test device in which a program to be debugged is incorporated, and a device under test in which failure factors are analyzed while monitoring the progress of the program to be debugged on the test device. In the fault information tracer device, the test device has an execution history collecting unit in which history information by a program to be debugged is organized, and the device under test has history information sent from the execution history collecting unit. A fault information tracer device for an embedded system, which has a trace information analysis program for acquiring analysis information when a fault occurs from a source file of a debug target program based on the above. 2. The fault information tracer device for an embedded system according to claim 1, wherein the test device has a memory area for output of history information by an execution history collection unit. 3. The fault information tracer device for an embedded system according to claim 1, wherein the test device has a debug monitor for transferring history information to the device under test. 4. The fault information tracer device for an embedded system according to claim 1, wherein the device under test has a trace memory dump result file based on history information from the test device. 5. The fault information tracer device for an embedded system according to claim 1, wherein the device under test has debugger software for acquiring history information from the test device. . 6. A debug target program in the test apparatus.
The fault information tracer device for an embedded system according to any one of claims 1 to 5, wherein the system has a process of activating an execution history collection unit. 7. The source file in the device under test is a comment regarding the execution history of the program to be debugged.
It has any of Claims 1-6 characterized by the above-mentioned.
Fault information tracer device for the embedded system described in.