JP2000047902A - Profiling control method - Google Patents

Abstract

(57) [Summary] A profiling control method that enables a computer system to convert a production load program to a load program that collects an execution history without recompiling a source program. When a load program is created by linking the object file with an object file at the time of compiling a source program, address information for the redundant instruction is stored in the load program file. By doing so, the redundant instruction for starting the specific function is changed to a branch instruction to the history collection function.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a history collection control method when a load program is executed.

In the business to which the present control system is applied, the cost of recompiling a source program for collecting an execution history such as a program for large-scale scientific and technological calculation is large, and it is difficult to actually compile the program. Business is conceivable.

[0003]

[Prior Art] "UNIX System V / 386 Release 4 Programmer's Reference Manual" ISBN4-8101-851
5-X prof (1) 1-prof (1) As shown on page 4,
To collect profiling (execution history), compile a source program with a special option (-p) for that, insert an information collection function call for execution history collection into the object, There is a way to re-create the load program linked with it.

However, in this method, when the size of the source of the program whose execution history is to be collected is large, the cost for recompiling becomes large, and it is often difficult to actually recompile.

Further, when a library used by a program is provided by another party, the source program of the library itself cannot be obtained, an object for collecting history cannot be created, and a performance bottleneck occurs in the library. In some cases, analysis could not be performed even if there was.

Also, "Design of UNIX Kernel" ISBN4
As shown on pages 225 to 227 of -320-02551-2, execution information can be collected as a sample by collecting a program counter with a clock interrupt. Cannot be collected, and the amount of information as performance analysis data is small.

[0007]

In order to collect program history information that is highly effective in actual performance analysis, each function (also called a procedure, procedure, or subroutine) used in the program is called a function in the following. ), It is necessary to call a history collection function for acquiring the caller (call relation) of the function. In addition, at the time of the production operation, the execution overhead of the history collection function is large, so a mechanism for removing the history collection function is required. In addition, constantly collecting the history of all functions increases the execution time.Therefore, in order to gradually narrow down the functions for which the history is to be collected, only specific functions should be collected, or conversely, the history should not be collected. It is necessary to be able to easily perform the setting.

An object of the present invention is to select all or a specific function of a production load program without recompiling a source program to collect an execution history so as to satisfy the above requirements. And an execution history collection control method having means for converting all or a specific function of the execution history collection load program so as not to collect the execution history. Is to do.

[0009]

A redundant instruction consisting of NOP (NO OREATION) instructions, which have little effect on the performance at the time of execution, is developed in advance in the object file at the time of compiling the source program for each start part of the text instruction group of the function. The offset information to the redundant instruction is stored in the object file. When the load file is created by linking the object file, the address information for the redundant instruction is merged and stored in the load program file, so that when the execution history becomes necessary, the redundant This is achieved by locating the redundant instruction of the target function based on the address information of the instruction and changing the redundant instruction of the function to branch to the execution history collection function.

[0010]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be described below with reference to the drawings.

FIG. 1 shows an example of a system configuration according to the present invention. The computer system includes a central processing unit 101 and a magnetic disk 107. The central processing unit
An instruction execution processor 102 for executing an instruction and a main storage device 103 accessible by the instruction execution processor 102 without input / output operations. Compiler 104, Linkage Editor 105, Profile Conversion Editor 106
Performs input / output with a file on a magnetic disk.

FIG. 2 shows the file structure of the present invention. Source file 201 and header file 20
2 as an input, the compiler 203 outputs an object file 204. With the object file 204 and the library file 205 which is an aggregate of the object files as inputs, the linkage editor 206
Output the load file 207. This load file is converted by the profile conversion editor 208 into a history information acquisition load file 209, and conversely, from the history information acquisition load file 209 to a normal load file 207 in which history collection processing is not executed. .

FIG. 3 shows an example of a method of expanding a text into an object file according to the present invention.
The object file 302 is created by compiling the source file 301 including the function having the symbol name func1. At this time, three redundant NOP instructions are embedded in advance in the start processing of the text of func1, and the redundant text code address pointer storage area 303 in the object is stored.
The offset from the start address of func1 to the start address of the NOP instruction is stored in advance.

FIG. 4 shows a linkage method of a load program. The linkage editor combines (links) the objects of the object file 1 (401) and the object of the object file 2 (402) to create a load program, determines the linked address of the function func1, and stores it in the object file. The offset information to the redundant code address is added, and the offset from the text start position after linkage of the redundant text code to the load program file is stored in a redundant text code address pointer storage area (hereinafter referred to as profile pointer information) 404. I do.

FIG. 5 shows a case where the redundant NOP instruction of the text 501 of the load file from which the history information is not collected is converted into the text of the load program for acquiring the history information. After the conversion, the NOP instruction is stored in the argument register 2 with information for determining the call relation, and converted into an instruction for branching to the history information collection function. To perform this conversion, the profile pointer information 50 of the load program is used.
2, 504, and after conversion, a flag for identifying that conversion is being performed is stored as ON.

FIG. 6 shows the file format of the load file. The header structure 601 stores text information 602, data information 603, symbol information 604, and offsets to the profile pointer information 604 of the load program in the load file, and information of each size.

FIG. 7 shows profile pointer information 605.
Detailed file format is shown below. The profile pointer header structure 701 stores the number of function symbols managed by the profile pointer. Symbol name 70 of function 1 stored in the load program
2, the redundant text code address 702 in the function,
A flag 703 indicating whether the redundant code of the function 1 has been converted for history acquisition or has not been converted as a NOP instruction is stored as a set for each of three sets of information functions.

FIG. 8 shows a flowchart of the linkage method. The linkage editor searches for a function in the input object file (step 801). If there is a function, profile pointer information of the function to be stored in the load file is created from the redundant text code pointer information storage area of the object file (step 802). If there are no unresolved symbols in the load program as a result of linking the objects, the process is terminated, and if there is, an object file containing the unresolved symbols is searched from the library file (step 804). If the search is successful, step 80
Repeat from 1.

FIG. 9 is a flowchart of the load program conversion method. A history information collection target function symbol is searched from the profile pointer information (step 901). If not found, the process ends. If found, the process proceeds to flag determination processing (step 903). If the flag is on, it is determined that it has been converted for history collection,
The conversion process is skipped and the process ends (step 904). If the flag is off, the instruction is changed to branch the redundant code of the function to the history collection function from the profile pointer information (step 905).

[0020]

According to the present invention, without recompiling the source program to collect the execution history, all or a specific function of the load program for the production operation is selected and the load for the execution history collection is selected. Since the means for converting to a program and, conversely, all or a specific function of the load program for collecting execution history can be converted so as not to collect execution history, efficiency of performance analysis can be improved.

[Brief description of the drawings]

FIG. 1 is a diagram showing a file configuration according to an embodiment of the present invention.

FIG. 2 is a flowchart showing a file configuration according to an embodiment of the present invention.

FIG. 3 is a diagram illustrating a method of expanding a text instruction in an object file.

FIG. 4 is a diagram showing a linkage method of a load program.

FIG. 5 is a diagram showing a text instruction conversion method of a load program.

FIG. 6 is a diagram showing a file format of a load program.

FIG. 7 is a diagram showing a detailed format of profile pointer information.

FIG. 8 is a flowchart showing a linkage method.

FIG. 9 is a flowchart showing a conversion method of a load program.

[Explanation of symbols]

201: source file, 203: compiler, 204: object file, 206: linkage editor, 207: load file,
208: Profile conversion editor, 209: History acquisition load file.

 ────────────────────────────────────────────────── ─── Continuing on the front page (72) Inventor Isao Ohara 5030 Totsuka-cho, Totsuka-ku, Yokohama-shi, Kanagawa Prefecture F-term in the Software Development Division, Hitachi, Ltd. F-reference (reference) 5B042 FD02 FD13

Claims (1)

[Claims] In a method for controlling the collection of a history when a load program is executed in a computer system, a redundant instruction is provided in an object file at the time of compiling a source program, and the load program is linked by linking the object file. By storing the address information for the redundant instructions in the load program file at the time of creation, the entire or specific function execution history can be collected from the load program that does not collect the execution history without recompiling the source program. A profiling control method comprising: means for converting a load program into a load program to be executed; and means for converting the entire load program for collecting an execution history or a load program from which the execution history of a specific function is not collected.