JPH03225533A - Copy-on-write reverse execution check system - Google Patents

Abstract

PURPOSE:To obtain the copy-on-write reverse execution check system which enables reverse execution by checking altered data, page by page, by using a copy-on-write system. CONSTITUTION:A user selects 21 a check point to obtain an entry from a check point list 22 being outputted currently. The altered data is obtained 23 from an entry result and compared 25 with data in a program 24 to check whether or not the data is requested data. When not, the check point is not a desired check point, so the pointer of a check pointer list 22 is moved, one by one, until the requested check pointer is obtained. Then the user repeats this opera tion until the altered data that the user requests. Namely, a debugger searches a check point list 22. Thus, pages which contain the altered at each constant period are generated to obtain a history of variation of the data in the program.

Description

[Detailed Description of the Invention] [Summary] This invention relates to a copy-on-write reverse execution checkpoint method for efficiently discovering difficult mistakes in programs, and is particularly useful for debugging programming languages run on general-purpose computers such as Reverse. Execution
For this purpose, based on the virtual memory method, it is possible to rewrite each page, that is, reverse execution by checking the changed data for each page using the copy-on-write method. The purpose is to provide a copy-on-write reverse execution checkpointing method that allows for In a virtual memory system that allows page-by-page swapping by saving it to an external storage device, checkpoints are inserted at specific locations in the program, and the contents of appropriate registers are saved at each checkpoint. , further comprising a registration means for copying a memory page according to a copy-on-write method and simultaneously registering the checkpoint in a checkpoint list; and after executing the program, the page and program copied by the registration means are executed for each checkpoint. and a change data registration means for saving changed data generated as a result of the comparing means in the checkpoint list for each checkpoint.

[Industrial application field]

The present invention relates to a debugging system, and more specifically, a copy-on-write reverse execution checkpoint method for efficiently discovering difficult mistakes in programs.In order to provide a new debugging system, it is necessary to Reverse Execution (Reverse Execution)
In addition, methods for selectively searching the execution history, data replacement, or partial program execution are also important.

When building such a new debugging system, there is no point in making major changes to the original operating system or incurring costs. Furthermore, recent systems, especially workstations, are provided with graphical interfaces that facilitate multi-window and menu operation, and debuggers should also be compatible with such interfaces. By setting appropriate breakpoints, the flow of execution can be changed, appropriate areas of the program can be traced, and it is particularly important to be able to perform reverse execution.

[Conventional technology]

Conventionally, such reverse execution has been possible in some prologue systems, but currently it has not been performed at all in systems intended as general-purpose debugging systems.

The conventional debug system is 5INGLE-THREA
A debug system such as D, Reverse
There was no debugging system that could perform execution, that is, reverse execution.

[Problem to be solved by the invention]

The present invention provides debugging of a program language running on a general-purpose computer, especially ReverseExec.
Therefore, based on the virtual memory method, it is possible to rewrite each page, that is, reverse execution by checking the changed data for each page using the copy-on-write method. The purpose of this paper is to provide a copy-on-write reverse execution checkpoint method that enables the following.

[Means to solve the problem]

The present invention divides the storage space into pages of a fixed size, stores only the requested pages in physical memory, and saves the remaining pages to an external storage device, thereby eliminating swapping for each page. It is assumed that a virtual memory system is available.

First, checkpoints are inserted at specific locations in the program, the contents of appropriate registers are saved for each checkpoint, and the memory page is copied using the copy-on-write method, at the same time the checkpoint is registered in the checkpoint list. have a registration means to do so.

Next, it has comparison means for comparing the page copied by the registration means for each checkpoint after the program is executed with the information of the same page after the program is executed.

Furthermore, it has a changed data registration means for saving changed data generated as a result of the comparing means into the aforementioned checkpoint list for each checkpoint.

[For production]

The present invention uses a virtual memory system for each page in the virtual memory system to insert checkpoints, save the execution state of the program at each checkpoint, and compare the before and after execution of the program for each page. By searching the checkpoint list at the same time as saving changed data, it is possible to check historical information on how the data on the program has changed for each page.

〔Example〕

Next, embodiments of the present invention will be described with reference to the drawings.

If, for example, the program accesses a memory area that should not be referenced or divides by O in an operation, it will stop abnormally. In this case, for example, in UNIX override systems, it is possible to perform a memory dump called a core image, which allows you to check the state of the program,
For example, it is possible to know the contents of the working register in the CPU or the stack status of static variables. Therefore, it is important for the user to restart the program in the core image state. Moreover, INTER
It is important to start from an intermediate state, that is, an intermediate state. This is based on the concept of reviving a dead program, allowing the program to be revived from various intermediate points, and identifying where the abnormal termination occurred in a partial area. It's about doing it and finding out. Furthermore, in this case, it is important to save the execution state at intermediate points, and for this purpose, it is particularly important to insert checkpoints on the program.

The present invention is based on the concept of inserting checkpoints, and further based on the copy-on-write method, which is a concept of virtual memory, inserts checkpoints for each page, and performs execution between checkpoints in a reverse execution manner. It makes it possible to For example, in the present invention, it is possible to optionally change the checkpoint insertion time interval, and for example, it is possible to insert a checkpoint every 1/100 seconds. In this case, UNIX
The system uses a C language compiler called CC.
At the stage of converting a source program written in a language into an object file, a checkpoint is inserted and the time timing thereof is set to 1/100 seconds. Then, when inspecting the history of variable changes,
The user may, for example, select the main (MA) of the source program.
If you want to check the value of a specific variable within the function I N), you can display the value of the variable at each checkpoint on the display. For example, the value of variable X in the main program includes values for each checkpoint, such as the value at checkpoint #0, the value at checkpoint #1, the value of The execution time at that checkpoint, e.g. the actual execution time of the program, the CPU time used by the user, or the CPU used by the system.
It may be possible to display the time etc. At this time, in order to specifically enable backup and restart, for example, the variable X is set to a value of 1000, so that it can be executed. To this end, it is important to create information at checkpoints, and moreover, it is important to enable reverse execution at checkpoints.

Therefore, the present invention provides a registration function that periodically writes the execution state to a series of files during execution. It would be undesirable if the checkpoint file became very large during this registration, but fortunately this file grows very slowly. In order to efficiently save the intermediate state, in the present invention,
The first step is to introduce an idea similar to the concept of virtual memory into the debugging system.

Virtual memory is a concept in which program memory is divided into units of fixed size, with only a few pages stored in physical memory and most other pages stored in secondary storage. The concept of copy-on-write is to dynamically bring only the pages that are needed to the physical memory, and at the same time bring the pages that are no longer needed to the secondary storage device.

In such a copy-on-write system, a reliable computer system can be constructed by creating checkpoints and providing a function to save intermediate execution states on a page-by-page basis. Furthermore, such a system can be used in sophisticated transient action systems and data-based systems, where data that has changed in periodic time can be analyzed using a simple method such as the one shown below. It is possible to back up. Then, whenever necessary, it becomes possible to return to the previous state of the variable, and it is also possible to recover from an error state where an abnormality has occurred.

That is, when debugging a program, it is important for the user to define the rotation of the program and provide a checkpoint corresponding to the rotation of the program so that the program can be executed in reverse from there.

- FIG. 1 is a flowchart for creating checkpoint information according to the present invention.

First, in order to insert a checkpoint, the program is executed during debugging or at the initial stage of the debugger, and at the inserted checkpoint, all register contents are saved, and all memory pages are saved using the concept of virtual memory. Mark according to the copy-on-write system. Then, the information about the checkpoint is stored in FIFO (First In First 0).
ut) list.

Then, run the program in normal state.

These are step Sl and step S2. Note that when marking all memory pages, if you use a copy-on-write virtual memory system, the pages between checkpoints will be rewritten according to the page-by-page management system even if the memory location in the currently executing process changes. Of course, it is possible to execute it. and,
In step S3, all the copied pages can be identified according to the concept of virtual memory, so the copied memory pages and the original pages are compared. That is, a comparison is made between the page before the program is executed and the page after the program is executed for each page within the checkpoint. According to this comparison, you can see which data has changed, so
This is treated as changed data and saved in the checkpoint list. Therefore, step 31. By repeating S2 and S33, it becomes possible to save changed data for each page within the checkpoint.

FIG. 2 is a flowchart for performing reverse execution based on checkpoint information.

As shown in FIG. 2, in accordance with the user's request for checkpoints to be backed up (S4), an entry is first acquired from the checkpoint list (S5).
). Pull out data from this entry content S6)
, if this is the desired checkpoint (
S7), and if not, return to the operation of extracting the entry from the next checkpoint. By repeating this routine,
The requested data at the desired checkpoint can be retrieved. This is the principle of reverse execution.

FIG. 3 is a block diagram of a system for generating checkpoint information.

In the figure, 1 is a program, and 2 is a debugger, which includes a part 3 for saving registers, a part 4 for setting all memory pages by copy-on-write, and a part 5 for putting checkpoints in a checklist. Then, as shown in Fig. 3, the register contents are saved at each checkpoint, all memory pages are marked according to the copy-on-write method, and the checkpoint is placed in the checkpoint list, and then the program is executed.
Thereafter, each page copied at each checkpoint is compared with the original page after execution. For this reason, it is necessary to perform a process of merging 6 the program and saving data that has changed depending on the result at each checkpoint.

Also, save the data at checkpoint position 8 to checkpoint restore, find the memory page copied for each checkpoint, compare it with the memory page, that is, the page after executing the program, and check the changes that have been made. The system at the bottom of 11 degrees that saves data in the checkpoint list is the operating system, which is a virtual storage system that manages each page, and O3 for performing swaps for each page.

FIG. 4 is a block diagram of a checking method based on checkpoint information.

In the figure, all parts exist within the debug system. First, the user selects 21 a checkpoint.

And the currently output checkpoint list 2
By acquiring the entry from 2 and extracting changed data 23 from the entry result, the data is compared 25 with the data on the program 24 to check whether it is the requested data. If the checked data is not the requested data, it is not the desired checkpoint, so move the pointer in the checkpoint list one by one until you reach the requested checkpoint, until you find the changed data requested by the user. It will be repeated.

That is, the debugger will search the checkpoint list.

In this way, according to the present invention, it is possible to generate a page that includes data that changes at regular intervals. Therefore, according to the present invention, it is possible to keep a history of changes in data on a program.

〔Effect of the invention〕

According to the present invention, it is possible to perform complete and high-speed debugging after an error in a program is observed.
Moreover, it allows for reverse execution of the program, allowing backup from a point before the error occurred. This makes it possible to immediately find out what was the cause of the error.

[Brief explanation of drawings]

FIG. 1 is a flowchart for generating checkpoint information, FIG. 2 is a flowchart for reverse execution based on checkpoint information, and FIG. 3 is a block diagram for generating checkpoint information. FIG. 4 is a block diagram of reverse execution using checkpoint information. 1...Program, 2...Debugger.

Claims (1)

[Claims] 1) Divide the storage space into pages of fixed size,
Only the requested pages are placed in physical memory,
In a virtual memory system that enables page-by-page swapping by saving the remaining pages to an external storage device, checkpoints are inserted at specific locations in the program, and the contents of appropriate registers are inserted at each checkpoint. a registration means for saving a memory page according to a copy-on-write method and registering the checkpoint in a checkpoint list at the same time; and a page and program copied by the registration means for each checkpoint after executing the program. The present invention is characterized by comprising: a comparison means for comparing information on the same page after the above has been executed; and a change data registration means for saving changed data resulting from the comparison means into the checkpoint list for each checkpoint. Copy-on-write reverse checkpoint method. 2) data reading means for acquiring an entry from the checkpoint list and reading data in the entry for a checkpoint requested in accordance with a request from a user; and the readout data is data of a desired checkpoint. checking means for checking whether there is a checkpoint, and if the checkpoint is not the checkpoint requested by the user, repeatedly performing an operation of obtaining an entry in the checkpoint list and further reading data from the entry. However, if the checkpoint is a desired checkpoint in the checking means, it has a judgment means that judges that the read data is data at the specified checkpoint, and it is possible to perform reverse execution based on the checkpoint information. Copy-on-write reverse execution checkpoint method.