JP2004287869A - Program execution monitoring device and method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a method for inserting monitoring codes into a program, easily applicable with a low load and available even during the operation of a system. <P>SOLUTION: The monitoring codes are embedded in execution codes of functions to be monitored when a program is read. At this time it is possible to monitor function execution without applying loads to executions of functions except the monitored functions by executing the insertion through a stub function. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a method for efficiently monitoring program execution when a computer executes a program.
[0002]
[Prior art]
For monitoring the execution of a program executed by a computer, for example, a method of embedding a log output code in a program source and compiling the program to obtain an execution log is very common. (Patent Document 1 etc.).
[0003]
Most of the existing debuggers realize their functions by inserting debugging code into a program. For example, by embedding an instruction for generating a software interrupt in a program, an interrupt is generated when the code is executed, and it is possible to easily detect the execution of the program (for example, Patent Document 2) There are also profiling tools that measure how much time is spent in which parts of a program to detect bottlenecks, and these are often used in the program optimization process. . In these, when a program is read, a monitoring code is inserted into the program, and the execution state of the program is monitored by executing the monitoring code.
[0004]
[Patent Document 1]
JP-A-6-314221 [Patent Document 2]
JP-A-11-184727
[Problems to be solved by the invention]
The method of embedding the log output code requires a program source and this compilation environment for implementation, and it is not feasible if any of them is missing. The debugger has been developed with the intention of using it at the time of program development. It is difficult to use the debugger with a small load at the time of execution, and it cannot be used in the interpreter program execution environment.
[0006]
In addition, profiling tools require complex processing to insert monitoring code without affecting the operation of the program as much as possible (for example, stack operations are required to monitor arguments). Etc.) The present invention proposes a method of inserting a monitoring code into a program that can be easily used with a low load that can be used even during operation of the system.
[0007]
[Means for Solving the Invention]
In order to solve the above problem, when executing a program on a computer including a program storage unit that stores a program including a plurality of functions and a program execution unit that reads and executes the program from the storage unit, It is determined whether the read function of the program is a function to be monitored, and a monitoring code is inserted into the program so that monitoring processing is performed on the function to be monitored.
[0008]
At this time, the monitoring code is inserted at the beginning of the function to be monitored and immediately before the instruction for returning from the function. When the execution part of the program executes the function in which the monitoring code is inserted, the monitoring code is executed and the status of the function execution can be understood.
[0009]
Also, an address for calling the function to be monitored or the name of the function is changed, and a monitoring function including an instruction for calling the function whose name has been changed and a monitoring function including the above-described monitoring code are generated. The monitoring function may be inserted.
[0010]
In this case, if the monitoring code arbitrarily created by the user is compiled by the compiler once and transformed into a monitoring function, any code created by the user can be used as the monitoring code. A high degree of execution monitoring can be realized. Furthermore, in order to support the development of this monitoring function, the source of the monitoring code is generated based on the program to be monitored, presented to the user, modified if necessary, and compiled, making it even easier to use. Can be
[0011]
BEST MODE FOR CARRYING OUT THE INVENTION
Hereinafter, embodiments of the present invention will be described with reference to the drawings. Note that the present invention is not limited to the embodiments.
[0012]
FIG. 1 shows the overall configuration of one embodiment of the present invention. According to the present invention, the monitoring code insertion unit 11 and the monitoring code insertion control file 30 are installed in a general program execution device in which the program execution unit 10 operating on the computer reads and executes the program file 50 stored in the program storage unit 20. , A monitoring program 60, and a monitoring code generation unit 70.
[0013]
The program execution unit 10 is mainly executed by a CPU, which may be an interpreter execution system or a normal execution system that executes a machine language. The program storage unit 20 is any device that can record programs, such as a disk device, a memory card, and a magnetic tape. The monitoring code insertion control file 30 stores information for determining whether a function in a program to be executed is a function to be monitored. It may be composed of a simple file, but may be another program or another program that operates on the same computer.
[0014]
The monitoring code generation unit 70 includes a program file analysis unit 71, a monitoring code arrangement unit 72, a monitoring code suppression unit 73, a compiler 75, and an editor 74. The monitoring code generator 73 refers to the monitoring code template 80.
[0015]
The program execution device includes, in addition to the program execution unit 10 and the program storage unit 20, a work memory 12 for temporarily storing programs and data read from the program storage unit and the like executed by the program execution unit 10, and instructs execution of the program. An input device 13 for the operator to input to the device; a display 14 for visually outputting the execution progress and execution results of the program; a communication control unit 15 for controlling communication with other devices via a communication path; When data such as a program and a monitoring code insertion control file are stored in a storage medium such as a CD-ROM and traded, a medium reading device 1 for reading the contents of the storage medium and installing the contents in the program storage unit 20.
6 are connected by an internal bus bridge 17. The bus bridge 17 in the figure also serves as an interface controller for a work memory, an input device, a display, and the like.
[0016]
FIG. 2 shows the configuration of the program file 50. The program file 50 has an arbitrary number of functions 510. The function is composed of one or a plurality of execution codes 520. As the execution code 520, a machine language can be considered in a normal program execution system, and an intermediate code (also called a byte code) can be considered in an interpreter execution system. The program file 50 has a function table 530. The function table 530 has information on the function, such as which part of the program file the function has and what attributes it has. In FIG. 2, the function table 530 is configured to be stored in the program file 50. However, the function table 530 may be provided as another file such as a MAP file output by a general compiler.
[0017]
FIG. 3 shows an example of the structure of the function table. The function table 530 includes an index 531, a function name 532, a start address 533, an end address 534, and an attribute 535. Information on functions in the program file is stored.
[0018]
FIG. 4 is a flowchart showing a process in which the program execution unit 10 of the present invention inserts a monitoring code while reading the program file 50. First, the program execution unit 10 reads one function from the program file 50 and transfers the processing to the monitoring code insertion unit 11 (step 1000). The monitoring code insertion unit 11 determines whether or not the function is a monitoring target based on the information in the monitoring code insertion control file 30 (step 1010). If the function is a monitoring target, the monitoring code insertion unit 11 inserts the monitoring code into the function (step 1020). ), The address information of the execution code after the insertion portion by the length of the inserted code, and
The function table 530 is changed (Step 1030), and Steps 1020 and 1030 are repeated until all the monitoring codes for the target to be monitored are inserted, and then the function is transferred to the program execution unit 10 (Step 1040). This is performed for all functions (step 1050). The program execution unit 10 executes the function passed from the monitoring code insertion unit 11 in step 1040 in parallel.
[0019]
FIG. 5 is a diagram showing a configuration of a function in which a monitoring code is inserted by the monitoring code insertion method shown in FIG. The upper part of the figure is executed first, and the lower instructions are executed in order. In this method, the monitor code 530 is first embedded in the head of the function, and then the monitor code 531 is placed immediately before the function end code of the execution code, that is, the code 521 that returns to the place where the function was called by executing this code. Insert
[0020]
Since the program execution unit 10 sequentially executes the program file in which the monitoring code is inserted by the monitoring code insertion unit 11 as described above, the monitoring code is executed immediately after the execution is shifted to the function and immediately before the end. It is possible to monitor the execution time, execution count, arguments passed at the time of calling, and the like.
[0021]
The monitoring code itself may be a module implemented by a plurality of execution codes, a function call code that calls another monitoring code library, or a software interrupt in the case of machine language execution. May be generated. Examples of the operation of the monitoring code include control of external hardware, output of a log, change of a value of a variable, and the like. Further, the monitoring code may be inserted only at the time of executing the function or just before the end of the function execution.
[0022]
Next, another example of the monitoring code insertion method will be described with reference to FIG. In this method, first, a function to be monitored (for example, function A in this case) (610) is changed so that it looks like another function in program execution (615). For example, if the execution method calls a function by an address, the function table may be referred to (620) to move the function to another available address. In the case of an execution method that calls an function by designating an index to the function table (620), which is often adopted in the interpreter language, a new entry is added to the function table (620), and another name is given. Other information can be realized by copying the original information. Next, a stub function (611) called when called as the conventional function A is inserted. In this stap function (611), a code (613) for calling the function A, which has been renamed, is described. As a result, the call of the function A (610) calls the “renamed function A” (620) once via the stub function (611). At this time, if the monitoring code (612) exists before the call code (613) of the function A whose name has been changed of the stub function (611), the monitoring code (612) is prior to the function A (615). The content is executed, and similarly the subsequent monitoring code (614) will be called after the execution of the renamed function A (615). In this monitoring code, it becomes possible to monitor and change the value of the argument that should be passed to the function A, and to monitor and change the return value from the function A.
[0023]
FIG. 7 is a flowchart of the monitoring code insertion processing of the method shown in FIG. The only difference from the process described with reference to FIG. 4 is the step 1015, so only that portion will be described. This flow describes a case where the function execution method of the program execution unit 10 executes a function using the index 531 of the function table 530. In order to make the read function an alias function, a new entry is created in the function table (step 2000). Next, the function read in step 1000 of FIG. 4 is registered in the newly created entry so as to be seen as another function in the program (step 2010). Next, a stub function for monitoring is inserted (step 2020), a code for calling the function to be monitored operated in step 2010 is inserted from the stub function (step 2030), and a monitoring code is also inserted (step 2040). ). Finally, the function table is changed so that the stub function inserted in step 2020 functions as a monitoring target.
[0024]
By performing such processing, it becomes possible to monitor the execution of the function to be monitored via the stub function inserted in step 2020.
[0025]
In steps 2020 to 2040 in FIG. 7, a stub function was generated programmatically. In this case, in order for the user to finely control the behavior of the monitoring code, it is necessary to implement a function corresponding to the monitoring code insertion unit 11. On the other hand, if the code described by the user is used for the stub function to be monitored, it is only necessary to transform and insert it. Arbitrary monitoring code insertion can be easily realized.
[0026]
This procedure will be described with reference to the flow of FIG. The only difference from the processing shown in FIG. 7 is the step 2015, so only that part will be described. First, the calling convention of the function to be monitored is obtained (step 3000). The calling convention is a convention required when calling a function, such as what arguments and return values the function has. Next, a source code of the stub function is generated based on the obtained calling convention (step 3010). This may be output to a file or a window may be generated and output on a GUI. The user modifies this source as needed (step 3020) and compiles the source (step 3030). The compile timing may be performed by the monitoring code insertion unit 11 detecting a change by the user or by the user. When the compilation is completed, a stub function is created from the compiled code, compiled, extracted, and inserted as a stub function (step 3040). Check whether the contents of the last inserted stub function $ do not contradict the program execution, and correct if necessary (step 3050)
In the above-described procedure, the source compilation of the stub (step 3010) and the compilation of the source (step 3030) are described as being performed at the time of insertion. However, this processing is performed in advance by the user before executing the program, and which monitoring code A method of increasing the speed by obtaining information on whether or not to insert from the monitoring code insertion control unit 30 and performing only the processing of steps 3040 and 3050 at the time of insertion may be considered. Alternatively, it is also possible to implement only the part for performing the processing from steps 3000 to 3030 as another program.
[0027]
Further, in the above-described embodiment, when performing various types of monitoring operations on one function to be monitored, a plurality of processes are already described for one stub function. Next, a method of inserting a plurality of monitoring codes into one monitoring target function will be described.
[0028]
FIG. 9 shows an outline of this method. FIG. 6 shows a method of inserting a monitoring code. This is a method of using one stub function and mounting a monitoring code therein. On the other hand, FIG. 9 shows a method of inserting a plurality of stub functions B and C as a plurality of stub functions (FIG. 9 shows an example in which two functions are inserted). In this state, when the stub function C (700) renamed to A is called, first the monitoring code Z (612) is executed, and the stub function B is called (704). Further, the stub function B (701) calls the renamed function A (705), and executes the monitoring code Y (703) after the termination. By nesting stub functions in such a configuration, a plurality of monitoring codes can be executed by one call.
[0029]
FIG. 10 shows an example of a table for inputting which stub function is to be inserted into the function A to the monitoring code insertion control unit 30. In this figure, the function to be monitored (801) and the function to be inserted (802) are on one line, and it is possible to insert a plurality of functions for the same monitored function. The figure shows an example in which a stub function B and a stub function C are inserted into a function A. By implementing so that the described order of the rows reflects the order of insertion and the order of calling, the accuracy of monitoring can be improved. For example, it is necessary to measure the execution time of a function as soon as possible immediately before a monitoring target. By reflecting such a user's intention, it is possible to improve monitoring accuracy.
[0030]
In the insertion processing, the stub renamed once to the function name of the monitoring target is regarded as the monitoring target in the next processing, so that the flowcharts of FIGS. 4 and 8 can be applied as it is.
[0031]
In the embodiment, the method of generating and compiling the source has been described. However, as an easier method, the source may be converted into an executable form by using an assembler language. In addition, a system is also conceivable in which a user inputs a machine language or a byte code of an interpreter, and performs monitoring with this code.
[0032]
Next, a method of automatically generating a monitoring code from a program to be monitored will be described. In the embodiments described so far, the description has been made on the assumption that the user creates the monitoring code and the monitoring code insertion control file.However, it is possible to improve the operability of the present invention itself by automating this to some extent. Become. The monitoring code generation unit 70 of FIG. 1 provides this function.
[0033]
FIG. 11 shows a basic operation flow. First, the program analysis unit 71 analyzes the program file 50 to obtain program information, extract functions, and obtain function information (step 4010). Next, the obtained program information and the monitoring code template 80 applicable to the function are presented to the user (step 4020). The user specifies a function and a monitoring code template 80 to be used (step 4030). At this time, if it is specified that editing is to be performed later (step 4040), the monitoring code, that is, the source program of the monitoring function is output to the editor 74 once (step 4050). Then, it is compiled by the compiler 75 (step 4060). If editing is not required, compilation is performed directly from step 4030. The monitoring code placement unit 72 places the compiled monitoring code and the monitoring code insertion control file 30 generated by the monitoring code generation unit 73 at appropriate positions. The program to be read in step 4010 is not limited to a file, but may be read from a network or a memory.
[0034]
FIG. 12 shows the configuration of the monitoring code template 80. The monitoring code template 80 includes a monitoring code output unit 81, an operation setting unit 82, a conformity inspection unit 83, and a detailed information output unit 84. The monitoring code output unit 81 generates a monitoring code program source. For example, if a monitoring code template provides a function for measuring the execution time of function execution, a program for measuring the execution time is output in a format that can be used as a monitoring code. If the source does not need to be edited, the monitoring code may be output directly.
[0035]
The operation setting unit 82 is for externally performing optional designation such as changing the content of the monitoring code output from the monitoring code output unit 81. This is not an essential component if the monitoring code output unit 81 can directly receive the setting of the option. The conformity check unit 83 determines whether the code output by the monitoring code template can be used for the function to be monitored. The detailed information output unit 84 outputs a description of the monitoring code template and the like.
[0036]
The monitoring code template is implemented, for example, as a program module, and in that case, the function is easy to use if implemented as a function. Alternatively, a monitoring code template may be used as data registered in a database, and the database may be analyzed to output a monitoring code.
[0037]
FIG. 13 shows an example of a screen for presenting the contents of the program in step 4020 and the applicable monitoring code template to the user. The module name display area 901 displays a module name, a class name, and the like in the program. The function name display area 902 displays the function names in the module. The calling method display area 903 displays the type of the argument at the time of calling the function. The return value display area 904 displays the type of the return value of the function. A monitoring code usable for the function is output to an application monitoring code designation area 905. For example, in the case of this figure, the acquisition of the log, the insertion of the monitoring code of the 9051 and the execution time measurement 9052 are specified for the function name method1. In addition, since the function method2 takes a character string as an argument of a call, the use of the monitoring code of the argument character number check 9053 can be selected in addition to the case of method1. A GUI 9054 for setting how many characters are to be checked is displayed as an option designation.
[0038]
FIG. 14 shows a flow for displaying the GUI shown in FIG. First, the program file analysis unit 71 extracts a program module from the program file 50 (Step 5010), and further obtains a function 510 from the program module (Step 5020). The monitoring code template 80 is obtained (Step 5030), and it is determined whether the monitoring code template can be applied to the obtained function (Step 5040). If applicable, further detailed information is obtained (step 5050) and added to the information presented to the user (step 5060). This process is performed on all templates (step 5070), these processes are performed on all functions (step 5080), and these processes are performed on all program modules (step 5090). 13 can be presented to the user. In this example, all program modules, functions, and monitoring code templates were searched.However, the search time can be shortened by specifying the search target in advance by using a regular expression and narrowing down the search target. It is also possible to restrict the presentation of information without the information.
[0039]
The monitoring code generation unit 73 also generates a monitoring code insertion file, which can be generated from information on which monitoring code template is applied to which function of which module by the user. It is.
[0040]
【The invention's effect】
According to the present invention, it is possible to monitor the execution of a specific or all functions in a program without performing the source code of the program to be monitored or compiling. When the monitoring code is inserted only into a specific function (needing monitoring) using the present invention, monitoring can be performed without imposing a load on execution of other functions. When the method of inserting a stub function is adopted, an arbitrary monitoring code described by a user can be inserted, and execution monitoring with a high degree of freedom can be performed.
[0041]
Further, by using the monitoring code template, detailed monitoring of function execution is possible without the user writing a monitoring code.
[Brief description of the drawings]
FIG. 1 is a block diagram showing an overall configuration according to an embodiment of the present invention.
FIG. 2 is a diagram showing a configuration of a program file.
FIG. 3 is a diagram showing a configuration of a function table.
FIG. 4 is a flowchart showing a procedure for inserting a monitoring code.
FIG. 5 is a diagram showing a configuration of a function into which a monitoring code is inserted.
FIG. 6 is a view for explaining another example of insertion of a monitoring code.
FIG. 7 is a flowchart showing a procedure of introducing a monitoring code by a stub function insertion method.
FIG. 8 is a flowchart showing the procedure of another example using the stub function insertion method.
FIG. 9 is a diagram showing a configuration when a plurality of stub functions are used.
FIG. 10 is a diagram showing an insertion order designation method when a plurality of stub functions are used.
FIG. 11 is a flowchart showing a procedure for generating a monitoring code from a monitoring code template.
FIG. 12 is a diagram showing a configuration of a monitoring code template.
FIG. 13 is a view showing an example of a screen when a monitoring code template is used.
FIG. 14 is a flowchart showing a procedure for acquiring contents to be presented to a user when using a monitoring code template.
[Explanation of symbols]
Reference Signs List 10: program execution unit, 11: monitoring code insertion unit, 20: program storage unit, 30: monitoring code insertion control unit, 60: monitoring code, 50: program file, 70: monitoring code generation unit, 510: function, 520: Execution code, 530: Function table.

Claims (14)

Program storage means for storing a program including a plurality of functions;
Means for determining whether the function of the program read from the storage unit is a function to be monitored,
Monitoring code insertion means for inserting a monitoring code into a program so that a monitoring process is performed on a function to be monitored;
A program execution monitoring device comprising: a function in which a monitoring code is inserted; and a program execution unit that executes the function and a monitoring process for the function. 2. The program execution monitoring apparatus according to claim 1, wherein the monitoring code insertion unit inserts a monitoring code immediately before a function to be monitored and immediately before an instruction for returning from the function. 2. The monitoring code insertion unit according to claim 1, wherein the monitoring code insertion unit changes an address or a function name for calling a function to be monitored, and generates a monitoring function including the monitoring code and an instruction for calling the function whose name has been changed. A program execution monitoring device for inserting the monitoring function into a program. 4. The monitoring code insertion means according to claim 3, wherein the monitoring code insertion means generates a template source of a function to be generated for monitoring, and extracts a monitoring function from a program code obtained by compiling after allowing a user to modify the function. And a program execution monitoring device using the function as a monitoring function. 2. The program execution monitoring device according to claim 1, wherein the monitoring code is a monitoring module including a plurality of execution codes and a function call code that calls another monitoring code library. A program execution monitoring method in a computer, comprising: a program storage unit that stores a program including a plurality of functions; and a program execution unit that reads and executes the program from the storage unit.
Determining whether the function of the program read from the storage unit is a function to be monitored, and inserting a monitoring code into the program so as to perform monitoring processing on the function to be monitored; Execution monitoring method. 7. The program execution monitoring method according to claim 6, wherein in the step of inserting the monitoring code, the monitoring code is inserted at the beginning of the function to be monitored and immediately before an instruction for returning from the function. 7. The monitoring function according to claim 6, wherein the step of inserting the monitoring code includes changing an address or a function name for calling a function to be monitored, and including the monitoring code and an instruction for calling the function whose name has been changed. And a method for monitoring the execution of the program, the method including inserting the monitoring function into the program. 9. The monitoring function according to claim 8, wherein the step of inserting the monitoring code includes generating a template source of a function to be generated for monitoring, allowing a user to modify the program, and then compiling the program code. A program execution monitoring device characterized in that the program execution monitoring device extracts the program and uses it as a monitoring function. 7. The program execution monitoring method according to claim 6, wherein the monitoring code is a monitoring module including a plurality of execution codes, and a function call code that calls another monitoring code library. 9. The method according to claim 8, wherein, in the step of inserting the monitoring code, a plurality of monitoring codes are executed by nesting a plurality of monitoring functions so as to call them in order. Program execution monitoring method. 12. The program execution monitoring method according to claim 11, wherein the order in which the monitoring functions are nested can be specified. 10. The program execution monitoring method according to claim 9, wherein an appropriate monitoring function is generated by referring to a template of the monitoring function and a monitoring target program prepared in advance as a template of the monitoring function. 14. The program according to claim 13, wherein a template of the monitoring function and a source of the monitoring function generated from the program to be monitored are presented to the user, and if necessary, this is corrected and used as the monitoring function. Execution monitoring method.

Images