JP2005242879A - Performance information acquiring device and method, and control program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a function which can be used on a text level handled with parallel processing even though it has a similar use interface as prof which can be used only by optionally specifying a compiler. <P>SOLUTION: This system acquires discrimination information of a plurality of threads which are executed in parallel at the time of executing a program, manages pointers to access unique data including executing time information of the threads corresponding to the discrimination information, acquires the executing time information as performance information for every threads respectively accessing the plurality of threads on the basis of the pointers, totals the acquired results, and outputs performance information for every threads respectively together with performance information of the whole program. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

  The present invention relates to a technique for acquiring performance information of a program. In particular, it is used for programs in which a plurality of threads are executed in parallel.

  As an example of a conventional performance information acquisition method, there is prof which is generally used on Linux. This has a function of measuring the time required for processing each function during program execution and displaying the result on a text basis, which is effective for sequential program tuning and the like. The method of use only specifies options when compiling the program, and the result is output as a text file, which is easy to use. However, since it does not support parallel processing, the execution status of each thread cannot be displayed.

Other examples that provide functions that operate on a text basis are provided as libraries, and when using these functions, some programs are compiled by inserting library calls into the program. This also supports parallel processing. Not. What is provided as a library can be developed separately from the compiler and does not require changes to the compiler, but requires a burden on the user in that the program needs to be modified.
JP-A-8-147199 JP-A-9-237203

  As described above, the conventional library does not consider the thread in the process of acquiring the performance information, and thus cannot acquire the performance information of each thread executed in parallel. Although there is a tool separated from the compiler for displaying performance information corresponding to parallel processing, it is different from the text-based function that can be used in sequential processing.

  According to Patent Document 1, an apparatus that acquires the number of times of execution and time of a dynamic library without adding an information acquisition command to a program is disclosed. In order to realize this, a flag is prepared in the kernel in the configuration, and a link is changed to a library at the time of execution by using the flag, or a module for acquiring information at a certain time is started. The effect of the invention is that execution information can be acquired as a normal load module without recompiling (translating) and relinking (joining) the program.

  However, according to Patent Document 1, a flag and measurement monitoring processing means prepared in the kernel are required, and further, a mechanism for controlling execution information acquisition by the value of the kernel flag at the time of execution and a table rewriting operation of the dynamic linker. Means are required and complicated.

  Further, according to Patent Document 2, a system for measuring the performance of a thread is disclosed. The configuration is characterized in that for each thread data, an area related to the parent thread and the child thread is prepared and the data is recorded therein. At this time, the extended part of the parallel support layer that stores the parent-child relationship of the threads is used. As an effect, it is mentioned that a parallel profiler function is provided by determining a plurality of memory cells holding data using a parallel support layer that is a mechanism for identifying a parent thread.

  However, according to Patent Document 2, it is necessary to prepare a memory cell that stores the parent-child relationship of a thread and holds data using the thread, and to store the data in a plurality of memory cells. I need.

  The present invention is made in such a background, and provides a function that can be used at a text level corresponding to parallel processing while having the same use interface as prof that can be used only by specifying a compiler option. With the goal.

  The present invention acquires performance information of each thread as runtime information in parallel execution using threads such as OpenMP, generates performance information of the entire program using them, and provides it to the user together with the performance information of the thread. It is characterized by making it possible.

  Prepare a performance information acquisition library for parallel execution that has the same library call interface and supports parallel execution by threads. Since the library call interface is the same, the compiler code insertion processing performed when acquiring performance information is compatible with the conventional sequential processing.

  Next, the options specified at compile time are analyzed, and if the parallel execution option is specified, the library for parallel execution is linked. Otherwise, the link option is generated so that the conventional library is linked. .

  The interface of the library corresponding to parallel execution is the same as that of the conventional library including arguments, but it is necessary to handle performance information corresponding to each thread at the time of execution. For this reason, the thread identification information (hereinafter referred to as ID) is acquired at the time of execution, and the management information is queried from the identifier that is usually a function name passed as an argument, and the performance information of the corresponding thread is updated. To do.

  At the end of program execution, the performance information of the entire program is calculated from the performance information of each thread and is output together with the performance information of the thread.

  In addition, as in the technique disclosed in Patent Document 1, the present invention provides a mechanism for controlling execution information acquisition based on a flag prepared in the kernel, measurement monitoring setting means, and the value of the kernel flag at the time of execution, a table of a dynamic linker There is an advantage that means relating to the rewriting operation of the part claims is not necessary.

  In the present invention, a program such as OpenMP using threads can provide performance information for each thread to the user, and the same function interface is used for sequential execution and parallel execution using threads. The library inserted inside can be used as it is in parallel execution.

  In addition, unlike the technique disclosed in Patent Document 2, the present invention does not store a parent-child relationship of threads and uses it to determine a memory cell that holds data. There is an advantage that it is not necessary to store in a cell.

  In the present invention, the same library interface can be used for sequential execution and parallel execution by threads.

  In other words, a first aspect of the present invention is a performance information acquisition apparatus including means for acquiring performance information of a program executed using a function provided by an OS or hardware, and is a feature of the present invention. Includes a management information recording unit that acquires IDs of a plurality of threads that are executed in parallel at the time of program execution and manages a pointer for accessing unique data including execution time information of the threads corresponding to the IDs. The means for acquiring information includes means for accessing the plurality of threads based on the pointer and acquiring the execution time information as performance information for each thread, and totaling the acquisition results of the respective means for acquiring, And means for outputting the performance information for each thread together with the overall performance information.

  According to a second aspect of the present invention, there is provided a performance information acquisition method. The feature of the present invention is that a step of searching for the presence or absence of an option for parallel execution when compiling a program for which performance information is to be acquired When there is an option for parallel execution specification, there are a step for adding an option for linking a library for parallel execution, a step for generating an option obtained by these steps as a final option, and a step for compiling and linking. Is in place.

  A third aspect of the present invention is a performance information having a function of acquiring performance information of a program to be executed using a function provided by an OS or hardware by installing the information processing apparatus in the information processing apparatus. A control program for realizing a function corresponding to an acquisition device, which is characterized by acquiring IDs of a plurality of threads that are executed in parallel during program execution, and executing time information of the threads corresponding to the IDs The management information recording function for managing the pointer for accessing the unique data including the information is realized, and as the function for acquiring the performance information, the plurality of threads are accessed based on the pointer, and the execution time information is obtained for each thread. The functions that are acquired as performance information and the acquisition results of the functions that are acquired It is with beam overall performance information performance information for each of the threads at realizing the function of outputting, respectively.

  By recording the control program of the present invention on the recording medium of the present invention, the information processing apparatus can install the control program of the present invention using this recording medium. Alternatively, the control program of the present invention can be directly installed in the information processing apparatus via a network from a server holding the control program of the present invention.

  As a result, it is possible to obtain program performance information in parallel execution such as OpenMP using threads by using a general-purpose information processing apparatus, and also obtain performance information with the same interface in thread parallel execution. A performance information acquisition device that can be used can be realized.

  The first effect is that the performance information of a program in parallel execution such as OpenMP using threads can be obtained for each thread. The reason is that the library performs processing in consideration of threads.

  The second effect is that it is possible to obtain performance information with the same interface even in thread parallel execution. The reason is that the library corresponding to the parallel execution is linked with the same interface by switching the library linked by the compiler when the parallel execution is designated.

  The configuration of the performance information acquisition apparatus according to the embodiment of the present invention will be described with reference to FIG. FIG. 1 is a block diagram of a performance information acquisition apparatus according to the present embodiment.

  As shown in FIG. 1, the present embodiment is a performance information acquisition apparatus including a performance information acquisition unit 1 that acquires performance information of a program executed using a function provided by an OS or hardware. The feature of the example is that a storage unit 3 that acquires IDs of a plurality of threads that are executed in parallel during program execution and manages a pointer for accessing specific data including execution time information of the threads corresponding to the IDs The performance information acquisition unit 1 accesses a plurality of threads based on the pointer and acquires the execution time information as performance information for each thread, and totals the acquisition results of the acquisition means. And means for outputting performance information for each thread together with performance information for the entire program.

  A performance information acquisition method according to an embodiment of the present invention will be described with reference to FIG. FIG. 3 is a flowchart showing an option generation procedure of this embodiment.

  In this embodiment, as shown in FIG. 3, when compiling a program for which performance information is to be acquired, a step (A1) for searching for the presence or absence of a parallel execution designation option and a parallel execution designation option are present. Executing the step (A4) of adding an option for linking a library for parallel use, and the step (A6) of generating an option obtained by these steps as a final option and performing a compile and link process. Features.

  The present invention can be implemented as a control program that, when installed in a general-purpose information processing apparatus, causes the information processing apparatus to realize a function corresponding to the performance information acquisition apparatus of the present invention. The control program is recorded in a recording medium and installed in the information processing apparatus, or installed in the information processing apparatus via a communication line, so that the information processing apparatus has the performance information acquisition unit 1, the processing unit 2, and the storage Functions corresponding to the respective units 3 can be realized.

  Hereinafter, this embodiment will be described in more detail.

(Configuration of Example)
Referring to FIG. 1, the performance information acquisition apparatus according to the present exemplary embodiment includes a performance information acquisition unit 1, a processing unit 2, and a storage unit 3. The performance information acquisition unit 1 acquires performance information of a program being executed using functions provided by the OS and hardware. The processing unit 2 acquires the thread ID at the time of execution, and updates the performance information 32 and the management information 31 using the argument of the library call and the management information 31 included in the storage unit 3. The storage unit 3 includes management information 31 and performance information 32.

  The management information 31 holds information for managing correspondence such as a function executed in each thread and a pointer for accessing the performance information of the thread. The management information 31 and performance information 32 include data 11 common to threads and performance information 32 of each thread, as shown in FIG.

(Operation of the embodiment)
Next, the operation of the embodiment of the present invention will be described in detail with reference to FIGS.

  When there is a program for which performance information is to be acquired, the program is first compiled in the same manner as normal processing (step F1 in FIG. 5). At this time, by specifying a compile option for referring to performance information as an option, the library call insertion processing and library linking are performed by the compiler as in the past. The performance information to be obtained can be obtained (step F3) by executing the generated execution object on the computer (step F2).

  Here, when compiling for the first time, according to the procedure shown in FIG. 3, the method switches the library to be linked depending on whether or not the parallel execution option is specified. In the procedure, first, the designated option is searched (step A1 in FIG. 3). And the presence or absence of the option which validates the function which acquires performance information there is checked (step A2). If this is not specified, the specified option is output (step A6). If performance information acquisition is specified, the presence of parallel execution options is further checked (step A3). If parallel execution is specified, an option for linking a parallel library is added (step A4), and if not specified, an option for linking a conventional sequential library is added (step A5). The options obtained by the above processing are generated as final options (step A6), and compile and link processing is performed.

  When an option for acquiring performance information is specified, the compiler inserts library calls (B1 and B3) for acquiring performance information before and after the processing of the original procedure (B2 in FIG. 4) As a procedure (B4), an execution object is generated.

  In executing the generated execution object, performance information is acquired by a library call inserted by the compiler or a library call specified by the user. The library call inserted by the compiler has a function name including the call as an argument, and performance information is recorded using this as an identifier. The function for recording the performance information includes the performance information acquisition unit 1, the processing unit 2, and the storage unit 3 shown in FIG. Further, the storage unit 3 includes management information 31 and performance information 32.

  This function works as follows when called at the beginning of a function. When the library is called, the processing unit 2 first acquires and records performance information from the performance information acquisition unit 1, and checks the thread ID that called the library. Here, when a library such as a main function is called for the first time in the thread, initialization processing of related data is performed. In other cases, the function executed before calling the function passed by the argument is checked from the thread ID and the management information 31. This information is recorded in the thread specific data 12. Then, the performance information of the function in the thread is calculated and updated from the performance information recorded first, the function that called this function, and the thread ID. Thereafter, the information on the function currently processed by the thread in the management information 31 is updated with the function name passed as an argument of the library. This update is performed by pushing the stack. Finally, since the processing time in the library is not included in the execution time of the program, the performance information is acquired again and recorded as the execution start information of the current function.

  When called at the end of a function, it behaves as follows: When the library is called, the performance information and thread ID are acquired in the same manner as the process at the start time. Then, new performance information is calculated and updated from the performance information recorded in the management information 31 and the performance information recorded at the beginning of the library call. After that, a stack pop operation is performed to return the function currently being processed to the function that called it. As a result, the function that called the current function becomes the function currently being processed, and the performance information acquired again is recorded as execution start information.

  The performance information of each thread recorded in the above procedure is used when calculating the performance information of the entire program by the library call registered to be called at the end of program execution. Since all the performance information of each thread can be referred to from the common data area 11 of the thread, it is possible to access all at the end of program execution. After the calculation, the performance information of the entire program and the performance information of each thread are output.

  Next, effects of the embodiment of the present invention will be described.

  As described in the embodiment of the present invention, the performance information acquisition and recording management part considers threads, so it is possible to record the performance information of each thread and display it after program execution. ing. Further, since the compiler switches the library to be linked depending on the option, the library interface corresponding to the parallel execution is the same as the conventional one. Thus, even when the user explicitly inserts a library call into the program to obtain performance information, the user does not need to make corrections between sequential execution and parallel execution. In addition, no new compiler options have been added, and no modification is necessary in this respect.

  The present invention can be widely used for research and development of programs because it can be used at a text level corresponding to parallel processing while using the same interface as prof that can be used only by specifying options of the compiler.

The block block diagram of the performance information acquisition apparatus of a present Example. The figure which shows the relationship between the common data area | region and thread specific data of a present Example. The flowchart which shows the procedure of the option production | generation of a present Example. The flowchart which shows the procedure of the performance information recording start process of a procedure of a present Example, and a recording end process. The flowchart which shows the procedure of the compilation of a present Example.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 Performance information acquisition part 2 Processing part 3 Storage part 11 Common data area 12 Thread specific data 31 Management information 32 Performance information A1-A6, B1-B4, F1-F3 Step

Claims (3)

In a performance information acquisition device comprising means for acquiring performance information of a program executed using a function provided by an OS or hardware,
Management information recording means for acquiring identification information of a plurality of threads executed in parallel at the time of program execution and managing a pointer for accessing specific data including execution time information of the thread corresponding to the identification information,
The means for acquiring the performance information includes:
Means for accessing the plurality of threads based on the pointer and obtaining the execution time information as performance information for each thread;
A performance information acquisition apparatus comprising: means for totalizing the acquisition results of the respective acquisition means and outputting performance information for each thread together with performance information of the entire program. When compiling a program for performance information acquisition,
A step of searching for the presence or absence of an option for specifying parallel execution;
When there is an option to specify parallel execution, adding an option to link the library for parallel execution,
A method for generating performance information of a program, comprising: generating an option obtained by these steps as a final option and performing compiling and linking processing. By installing on an information processing device,
In a control program for realizing a function corresponding to a performance information acquisition apparatus having a function of acquiring performance information of a program executed using a function provided by an OS or hardware,
Acquiring identification information of a plurality of threads executed in parallel at the time of program execution, realizing a management information recording function for managing a pointer for accessing specific data including execution time information of the thread corresponding to the identification information,
As a function of acquiring the performance information,
A function of accessing the plurality of threads based on the pointer and acquiring the execution time information as performance information for each thread;
A control program that aggregates the acquisition results of the respective acquired functions and outputs the performance information for each thread together with the performance information of the entire program.

Images