Information processing apparatus, computer-readable recording medium storing program, and information processing method

An information processing apparatus includes: a memory; and a processor coupled to the memory and the processor configured to calculate shortening rates by comparing execution times for each of a plurality of functions in a case where an evaluation target program is executed in an execution environment with execution times for each of the plurality of functions in a case where the evaluation target program is executed in a simulation environment, and generate a simulation program to be used in the simulation environment based on the calculated shortening rates and the evaluation target program.

CROSS-REFERENCE TO RELATED APPLICATION

This application is based upon and claims the benefit of priority of the prior Japanese Patent Application No. 2018-42075, filed on Mar. 8, 2018, the entire contents of which are incorporated herein by reference.

FIELD

The embodiment discussed herein is related to an information processing apparatus, a computer-readable recording medium storing a program, and an information processing method.

BACKGROUND

A performance of a parallel calculation program may be evaluated by a parallel performance. The parallel performance is an indication of how much a program may adapt to parallelization of processing.

Since the parallel performance roughly estimated by source code analysis or the like from such as data dependency may be inaccurate, the parallel performance may be calculated by performing an execution performance evaluation.

Japanese Laid-open Patent Publication No. 2014-99108 and Japanese Laid-open Patent Publication No. 11-96130 are examples of the related art.

SUMMARY

According to an aspect of the embodiments, an information processing apparatus includes a memory; and a processor coupled to the memory and the processor configured to calculate shortening rates by comparing execution times for each of a plurality of functions in a case where an evaluation target program is executed in an execution environment with execution times for each of the plurality of functions in a case where the evaluation target program is executed in a simulation environment, and generate a simulation program to be used in the simulation environment based on the calculated shortening rates and the evaluation target program.

DESCRIPTION OF EMBODIMENTS

For example, in a program under development, since it is capable of performing only for a sequential calculation and not for a parallel calculation, an accurate performance evaluation may not be possible. In the program under development, a measurement time may be prolonged by performing a plurality of performance measurements to acquire the parallel performance.

Hereinafter, an embodiment will be described with reference to the drawings. However, the following embodiment is merely an example, and there is no intention to exclude the application of various modifications and techniques not explicitly described in the embodiment. The present embodiment may be implemented with various modifications without departing from the gist thereof.

Each figure is not intended to include only the constituent elements illustrated in the drawing, however, may include other functions and the like.

Hereinafter, in the drawings, the same reference signs denote the same portions, and a description thereof will be omitted.

[A] Example of Embodiment

[A-1] System Configuration Example

FIG. 1Ais a graph illustrating a relationship of performance improvement for a program parallelization. InFIG. 1A, a horizontal axis represents a degree of parallelism such as a number of central processing unit (CPU) cores, and a vertical axis represents a performance improvement rate.

InFIG. 1A, a reference sign A1indicates the parallel performance in a case where a proportion of a parallel portion to entire processing is 95%, and a reference sign A2indicates the parallel performance in a case where a proportion of a parallel portion to the entire processing is 90%. A reference sign A3indicates the parallel performance in a case where a proportion of a parallel portion to the entire processing is 75%, and a reference sign A4indicates the parallel performance in a case where a proportion of a parallel portion to the entire processing is 50%.

The performance improvement rate, which is expressed to Speedup, of the program for the degree of parallelism is represented by the following (Expression 1).

T(N) represents the time taken for the entire processing of a program, and N represents a degree of parallelism such as the number of CPU cores used.

In the graph illustrated inFIG. 1A, the parallel performance becomes higher as the curve approaches a linearly rising straight line. That is, in the example illustrated inFIG. 1A, the parallel performance is high in the order of the graphs indicated by reference signs A1, A2, A3, and A4.

When the performance improvement rate Speedup is calculated not by a processing time but by a processing amount, the following (Expression 2) is used.

P(N) is the processing amount per unit time at the time of N parallel processing, for example.

FIG. 1Bis a diagram illustrating a derivation example of the graph illustrated inFIG. 1A.

In the example illustrated inFIG. 1B, 17 points are plotted on the graph indicated by the reference sign A1. In order to calculate the accurate parallel performance, the performance improvement rate may be measured for each of a large number of processes as illustrated in the drawing.

FIG. 2is a block diagram schematically illustrating a hardware configuration of an information processing apparatus1as an example of the embodiment.

The information processing apparatus1includes a CPU11, a memory12, a display control unit13, a storage device14, an input interface (I/F)15, a read and write processing unit16, and a communication I/F17.

The memory12is illustratively a storage device including a read only memory (ROM) and a random access memory (RAM). In the ROM of the memory12, a program such as a basic input/output system (BIOS) may be written. A software program of the memory12may be read and executed appropriately by the CPU11. The RAM of the memory12may be used as a primary recording memory or a working memory.

The storage device14is illustratively a device that stores data in a readable and writable manner, and for example, a hard disk drive (HDD), a solid state drive (SSD), a storage class memory (SCM) may be used.

The input I/F15is connected to an input device such as a mouse151and/or a keyboard152, and controls the input device such as the mouse151or the keyboard152. The mouse151or the keyboard152is an example of the input device, and the operator performs various input operations via these input devices.

The read and write processing unit16is configured so that a recording medium160may be mounted. The read and write processing unit16is configured to be capable of reading information recorded on the recording medium160in a state in which the recording medium160is mounted. In the example, the recording medium160has portability. For example, the recording medium160is a flexible disk, an optical disk, a magnetic disk, a magneto-optical disk, a semiconductor memory, or the like.

The communication I/F17is an interface for enabling communication with an external device.

FIG. 3is a block diagram schematically illustrating a functional configuration of the information processing apparatus1illustrated inFIG. 2.

The CPU11is a processing device that performs various controls and arithmetic operations, and implements various functions by executing an operating system (OS) and a program stored in the memory12. As illustrated inFIG. 3, the CPU11of the information processing apparatus1functions as a similarity function retrieval unit111, a similarity function performance measurement unit112, a shortening rate calculation unit113, and a shortening rate application unit114.

A program for realizing the functions of the similarity function retrieval unit111, the similarity function performance measurement unit112, the shortening rate calculation unit113, and the shortening rate application unit114is provided, for example, in a form recorded on the recording medium160which is described above. The computer reads the program from the recording medium160via the read and write processing unit16, transfers and stores the program to the internal storage device or the external storage device, and uses the program. The program may be recorded in a storage device (recording medium) such as a magnetic disk, an optical disk, a magneto-optical disk or the like, and may be provided from the storage device to the computer via a communication path.

When implementing the functions of the similarity function retrieval unit111, the similarity function performance measurement unit112, the shortening rate calculation unit113, and the shortening rate application unit114, the program stored in the internal storage device is executed by a microprocessor of the computer. At this time, the computer may read and execute the program recorded in the recording medium160. In the present embodiment, the internal storage device is the memory12, and the microprocessor is the CPU11.

The CPU11illustratively controls an operation of the entire information processing apparatus1. A device for controlling the operation of the entire information processing apparatus1is not limited to the CPU11, and may be, for example, any one of an MPU, a DSP, an ASIC, a PLD, and an FPGA. Devices for controlling the operation of the entire information processing apparatus1may be a combination of two or more of a CPU, an MPU, a DSP, an ASIC, a PLD, and an FPGA. The MPU is an abbreviation for micro processing unit, the DSP is an abbreviation for digital signal processor, and the ASIC is an abbreviation for application specific integrated circuit. The PLD is an abbreviation for programmable logic device, and the FPGA is an abbreviation for field programmable gate array.

The similarity function performance measurement unit112is an example of a measurement unit. The similarity function performance measurement unit112measures execution times in a case where similarity functions retrieved by the similarity function retrieval unit111are executed in a simulation environment20(described later with reference toFIG. 4and the like). Details of functions in the similarity function performance measurement unit112will be described later with reference toFIG. 6and the like.

The shortening rate calculation unit113is an example of a calculation unit. The shortening rate calculation unit113compares execution times for each of the plurality of functions in a program development execution environment10(described later with reference toFIG. 4and the like) with execution times for each of the plurality of functions in the simulation environment20(described later with reference toFIG. 4and the like) to calculate shortening rates. The execution times for each of the plurality of functions in the program development execution environment10are execution times for each of a plurality of functions in a case where the program under development101(described later with reference toFIG. 4and the like) is executed in the program development execution environment10. The execution times for each of the plurality of functions in the simulation environment20are execution times for each of a plurality of functions in a case where the program under development101is executed in the simulation environment20.

The shortening rate calculation unit113calculates shortening rates based on the execution times for each of the plurality of functions in the program development execution environment10(described later with reference toFIG. 4and the like) and execution times for each of a plurality of similarity functions measured by the similarity function performance measurement unit112.

Details of functions in the shortening rate calculation unit113will be described later with reference toFIG. 7and the like.

The shortening rate application unit114is an example of a generation unit. The shortening rate application unit114generates a dummy program304(described later with reference toFIG. 15AandFIG. 15Band the like) to be used in the simulation environment20based on the shortening rate calculated by the shortening rate calculation unit113and the program under development101.

The shortening rate application unit114generates the dummy program304by using a minimum shortening rate out of a plurality of shortening rates calculated for each of the plurality of functions.

The shortening rate application unit114generates the dummy program304based on a dummy trace202(described later with reference toFIG. 8and the like) which records values obtained by multiplying processing times of each of the plurality of functions by the shortening rates.

Details of functions in the shortening rate application unit114will be described later with reference toFIG. 7and the like.

FIG. 4is a block diagram explaining an outline of processing in the information processing apparatus1illustrated inFIG. 2.

The information processing apparatus1is divided into the program development execution environment (may be simply referred to as “execution environment”)10and the simulation environment20.

In the program development execution environment10, a program under development (may be referred to as “evaluation target program”)101is executed and an execution trace102is recorded (see reference sign B1).

In the simulation environment20, a dummy trace generation system201generates the dummy trace202(see reference sign B3) with the execution trace102as an input (see reference sign B2).

In other words, the dummy trace generation system201functions as a trace shortening unit2011. The trace shortening unit2011receives the execution trace102(see reference sign B2) as an input and generates the dummy trace202(see reference sign B3).

In the simulation environment20, the generated dummy trace202is input to a simulator203(see reference sign B4) and the simulator203executes the program while changing a degree of parallelism. Then, the simulator203outputs a simulation result (see reference sign B5).

FIG. 5Ais a block diagram explaining a generation process of a dummy program603in a related example.FIG. 5Bis a block diagram explaining a generation process of a dummy program304in the information processing apparatus1illustrated inFIG. 2.

As illustrated inFIG. 5A, in a program development execution environment60developed in an information processing apparatus6according to the related example, a dummy program generation system602directly generates a dummy program603from a program under development601.

As described above, a generation of the dummy program603in the related example has to be performed in a state where the program development execution environment60is in place. Further, a processing time of the dummy program603becomes the same as a processing time of the program under development601.

On the other hand, as illustrated inFIG. 5B, in the program development execution environment10developed in the information processing apparatus1according to one example of the embodiment, the execution trace102is generated based on the program under development101. In the simulation environment20, the dummy trace generation system201receives an input of the execution trace102and generates a dummy program304. Then, in the simulation environment20, the simulator203executes the dummy program304.

In this manner, the generation of the dummy program304in one example of the embodiment may be executed in the simulation environment20even if the program development execution environment10is not in place. Further, a processing time of the dummy program304may become shorter than a processing time of the program under development101.

FIGS. 6 to 8are block diagrams explaining a generation process of a dummy trace202in the information processing apparatus1illustrated inFIG. 2.

As illustrated inFIG. 6, the program under development101is executed in the program development execution environment10(see reference sign C1inFIG. 6), thereby the execution trace102is generated.

In the simulation environment20, the similarity function retrieval unit111receives functions of the execution trace102as an input (see reference sign C2inFIG. 6), retrieves similarity functions similar to each function of the execution trace102, and outputs the similarity functions to a similarity trace205(see reference sign C3inFIG. 6).

In the simulation environment20, the similarity function performance measurement unit112receives function names of the similarity trace205as an input (see reference sign C4inFIG. 6), measures a processing time for each similarity function of the similarity trace205, and outputs the processing times to the similarity trace205(see reference sign C5inFIG. 6).

As illustrated inFIG. 7, in any environment30, a shortening rate calculation unit113receives the processing times of the execution trace102as an input (refer to reference sign C6inFIG. 7) and also receives the processing times of the similarity trace205as an input (see reference sign C7inFIG. 7). Then, the shortening rate calculation unit113calculates a shortening rate r by comparing the processing time of the execution trace102with the processing time of the similarity trace205.

A shortening rate r_N for a function_N may be calculated by the following (Expression 3).

T_N represent processing times in the execution trace102, Tsim_N represent processing times in the similarity trace205, and N is a natural number.

The shortening rate calculation unit113inputs the minimum value out of the shortening rates r_N for each of the function_N as a shortening rate r to a shortening rate application unit114.

In any environment30, the shortening rate application unit114acquires the shortening rate r from the shortening rate calculation unit113(see reference sign C8inFIG. 7).

As illustrated inFIG. 8, the shortening rate application unit114applies the shortening rate r to the execution trace102, and generates a dummy trace202(see reference sign C9inFIG. 8). The shortening rate application unit114acquires processing times of shortening functions T_N×r in the dummy trace202by multiplying the processing time of each function in the execution trace102by the shortening rate r.

FIGS. 9 to 11are block diagrams explaining a generation process of a similarity trace205in the information processing apparatus1illustrated inFIG. 2.

As illustrated inFIG. 9, in the simulation environment20, the similarity function retrieval unit111selects one function (“function_1” in the example illustrated inFIG. 9) in the execution trace102(see reference sign D1inFIG. 9and a 10th line of the similarity trace generation program301). The similarity function retrieval unit111retrieves a similarity function (“function_1” in the example illustrated inFIG. 9) similar to the selected function from a function list206including a plurality of similarity functions. Then, the similarity function retrieval unit111registers the retrieved similarity function in a similarity trace205(see reference sign D2inFIG. 9and the 11th to 12th, and the 15th lines of the similarity trace generation program301).

The program describing the processing by the similarity function retrieval unit111is represented by 1st to 15th lines of the similarity trace generation program301, for example.

In the similarity trace generation program301exemplified inFIG. 9, 1st to 2nd lines include an acquisition process of the function list206, and 3rd to 4th lines include an acquisition process of the execution trace102. In the similarity trace generation program301exemplified inFIG. 9, the 6th to 21st lines include processing of retrieving similarity functions for each of lines of the execution trace102and acquiring execution times of the retrieved similarity functions. The 9th to 15th lines out of the 6th to 21st lines include a retrieval process of similarity functions.

As illustrated inFIG. 10, in the simulation environment20, the similarity function performance measurement unit112measures a processing time (“Tsim_1” in the example illustrated inFIG. 10) of the similarity function (“function_1” in the example illustrated inFIG. 10) in the similarity trace205(see reference sign D3inFIG. 10and the 18th to 21st lines of the similarity trace generation program301).

The program describing the processing by the similarity function performance measurement unit112is represented by the 6th to 8th lines and the 17th to 21st lines of the similarity trace generation program301, for example.

In the similarity trace generation program301exemplified inFIG. 10, the 6th to 21st lines include processing for retrieving similarity functions for each of the lines of the execution trace102and acquiring execution times of the retrieved similarity functions. The 17th to 21st lines out of the 6th to 21st lines include an acquisition process of the execution times of the similarity functions.

In the example illustrated inFIG. 11, in the simulation environment20, the similarity function retrieval unit111retrieves a similarity function similar to a function_4in the execution trace102from the function list206. In the example illustrated inFIG. 11, the function list206includes a function_4′ and a function_4″ as similarity functions similar to the function_4of the execution trace102.

The function_4′ and the function_4″ may be selectively used depending on the purpose of the function in the execution trace102and the size of the code. In the example illustrated inFIG. 11, the function_4′ is used when the usage of the function_4in the execution trace102is “XX”, whereas the function_4″ is used when the usage of the function_4in the execution trace102is “YY”.

In the example illustrated inFIG. 11, since the usage of the function_4in the execution trace102is “YY”, the similarity function retrieval unit111selects the function_4″ from the function list206as a similarity function. Then, the similarity function retrieval unit111registers the selected function_4″ in a similarity trace205(see reference sign D4inFIG. 11and the 13th to 15th lines of the similarity trace generation program301).

FIG. 12Ais a table illustrating shortening rates for each of the functions in the information processing apparatus1illustrated inFIG. 2. FIG.12B is a block diagram illustrating an example of a dummy trace generation program302in the information processing apparatus1illustrated inFIG. 2.

In the table illustrated inFIG. 12A, the execution trace execution time, the similarity trace execution time, and the shortening rate are associated and registered.

The execution trace execution time indicates the execution times (in other words, the processing times) of the functions in the execution trace102. The similarity trace execution time indicates the execution times (in other words, the processing times) of the similarity functions in the similarity trace205. The shortening rate indicates proportions of shortening similarity trace execution times to execution trace execution times.

In the example illustrated inFIG. 12A, for example, a shortening rate r_1indicated in the following (Expression 4) is associated with an execution trace execution time T_1and a similarity trace execution time Tsim_1.

A shortening rate r_N for a function_N may be calculated by the above-described (Expression 3).

In the example illustrated inFIG. 12B, the dummy trace generation program302includes an acquisition process of the execution trace102in the 1st to 2nd lines and includes an acquisition process of the similarity trace205in the 3rd to 4th lines. The dummy trace generation program302includes processing for acquiring processing times for each line of the two traces102and205in the 6th to 16th lines and calculating the shortening rate, and includes processing for acquiring processing times and function names in the trace102and205in the 10th to 13th lines. The dummy trace generation program302includes processing for calculating the shortening rates in each line of the traces102and205in the 15th to 16th lines, and includes processing for acquiring the minimum value of the shortening rate in the 18th to 19th lines.

FIG. 13Ais a table illustrating adjustment times for each of the functions in the information processing apparatus1illustrated inFIG. 2.FIG. 13Bis a diagram illustrating an example of a continuation of the dummy trace generation program302illustrated inFIG. 12B.

In the table illustrated inFIG. 13A, the shortening rates and the adjustment times are registered in association.

The shortening rate indicates proportions of shortening the similarity trace execution times to execution trace execution times. The adjustment time is a value to be added to the execution time of each similarity function (in other words, additional processing time) so that the execution time of each similarity function looks like being shortened at the same shortening rate (the minimum value r_2of the shortening rate in the example illustrated inFIG. 13A).

In the example illustrated inFIG. 13A, for example, an adjustment time Δt_1is associated with a shortening rate r_1.

The shortening rate r_1may be indicated by the above-described (Expression 4) similarly to the shortening rate r_1illustrated inFIG. 12A.

The adjustment time Δt_1may be indicated by the following (Expression 5).
Δt_1=T_1×r_2−Tsim_1  (Expression 5)

The r_2indicates the minimum shortening rate out of the shortening rates with respect to the plurality of similarity functions. In the example illustrated inFIG. 13A, out of the shortening rates r_1to r_8, the shortening rate r_2of the execution time Tsim_2of the similarity_function_2with respect to the execution time T_2of the function_2, is the minimum.

An adjustment time Δt_N for a similarity_function_N (N is a natural number) may be indicated by the following (Expression 6).
Δt_N=T_N×r_min−Tsim_N(Expression 6)

An r_min indicates the minimum shortening rate out of the shortening rates with respect to the plurality of similarity functions.

In the example illustrated inFIG. 13B, the dummy trace generation program302includes an output process of each line of the dummy trace202in the 21st to 28th lines, and includes processing for calculating an adjustment time of each line of the dummy trace202in the 23rd to 24th lines. The dummy trace generation program302includes processing for outputting the function name of the dummy function, the processing time of the dummy function (in other words, the adjustment time), the function name of the similarity function, and the processing time of the similarity function as the dummy trace202in the 26th to 28th lines.

The dummy trace generation program302treats one line for executing the dummy function and one line for executing the similarity function as one group in the dummy trace202to be generated, so that the similarity functions are executed with the execution times using the minimum shortening rate. The processing times of each of the similarity functions in the dummy trace202may be made to appear to have been shortened at the same shortening rate.

When the execution time of each function in the execution trace102is indicated by a ratio (in other words, a proportion occupied by the execution time of each function in the processing time of the entire execution trace102), and when the ratio is maintained, a parallel performance is accurately evaluated even when the actual execution time is shortened.

The parallel performance depends on an execution timing of each thread in a parallel program. For example, a program includes processing that is capable of being executed in parallel and processing that is not capable of being executed in parallel (in other words, processing in which same operations may not be executed simultaneously by a plurality of threads). When such a program is executed in parallel by a plurality of threads, the processing performance of the parallel program changes depending on which processing and timing each thread has executed.

Therefore, unless the execution time of each function in the execution trace102is shortened by the same shortening rate, the operation of each thread (in other words, the execution timing of each function) may be different from the operation of the thread to be measured.

In one example of the present embodiment, the processing time of each function in the execution trace102is shortened at the same shortening rate so that accurate parallel performance is able to be obtained even if the execution time is shortened.

FIG. 14is a diagram illustrating an example of the dummy trace202in the information processing apparatus1illustrated inFIG. 2.

The dummy trace202illustrated inFIG. 14is generated based on the table illustrated inFIG. 12AandFIG. 13A.

In the example illustrated inFIG. 14, immediately before processing of a similarity_function_1with a processing time Tsim_1, a similarity_function_3with a processing time Tsim_3, and a similarity_function_4with a processing time Tsim_4, a dummy function indicated by dummy_run is inserted respectively. Specifically, a dummy_run with a processing time of delta_1is inserted immediately before the similarity_function_1(see reference sign E1). A dummy_run with a processing time of delta_3is inserted immediately before the similarity_function_3(see reference sign E3). A dummy_run with a processing time of delta_4is inserted immediately before the similarity_function_4(see reference sign E4).

On the other hand, in the example illustrated inFIG. 14, as described with reference toFIG. 13A, regarding the similarity_function_2related to the minimum shortening rate out of the shortening rates for the plurality of similarity functions, the dummy function is not inserted immediately before the similarity_function_2(see reference sign E2).

FIG. 15Ais a block diagram illustrating an example of a dummy program generation program303in the information processing apparatus1illustrated inFIG. 2.FIG. 15Bis a block diagram illustrating an example of a dummy program304in the information processing apparatus1illustrated inFIG. 2.

In the dummy program generation program303illustrated inFIG. 15A, the 1st to 6th lines include processing for acquiring functions in the dummy trace202, and the 8th to 12th lines include processing for outputting a main process of the dummy program304.

In the dummy program304illustrated inFIG. 15B, the 1st to 9th lines include execution contents of each thread, and the 10th to 19th lines include the main process of simulation. The 12th to 14th lines include processing for generating threads of the specified degree of parallelism, and the 16th to 19th lines include processing for acquiring a processing amount per unit time of all the threads.

In the area indicated by a reference sign F1in the dummy program304, an execution result of processing for outputting the main process to the dummy program304in the dummy program generation program303(the 8th to 12th lines in the example illustrated inFIG. 15A) is output.

In this way, by executing the dummy program304, the number of threads executing the dummy trace202is generated by the number specified by the degree of parallelism. Then a processing amount of all threads per unit time (for example, the maximum execution number of traces) is obtained, a performance improvement rate in a case where the degree of parallelism is one is calculated, and a calculation results are plotted on a graph as illustrated inFIG. 1B.

[A-2] Operation Example

The processing in the information processing apparatus1illustrated inFIG. 2will be described according to the flowchart (steps S1to S6) illustrated inFIG. 16.

Regarding each function included in the execution trace102, the similarity function retrieval unit111retrieves a similarity function from the function list206(step S1). Then, the similarity function retrieval unit111registers the retrieved similarity functions in the similarity trace205.

The similarity function performance measurement unit112measures performance (in other words, execution time) of the retrieved similarity functions (step S2). Then, the similarity function performance measurement unit112registers the measured performance of the similarity functions in the similarity trace205.

The shortening rate calculation unit113compares the execution times of each of the functions in the execution trace102with the execution times of each of the similarity functions in the similarity trace205and calculates shortening rates for each of the similarity functions (step S3).

The shortening rate application unit114applies the minimum shortening rate out of the shortening rates for the calculated each similarity function to each similarity function by registering the minimum shortening rate to the dummy trace202(step S4).

The shortening rate application unit114generates the dummy program304based on the dummy trace202to which the minimum shortening rate is applied (step S5).

The CPU11of the information processing apparatus1(in other words, the “simulator203” illustrated inFIG. 4and the like) executes a simulation by executing the generated dummy program304(step S6). Then, the simulation result (in other words, the parallel performance of the program under development101)305is obtained, and the processing is terminated.

According to the information processing apparatus1in the example of the above-described embodiment, for example, the following effects may be obtained.

The shortening rate calculation unit113compares execution times for each of a plurality of functions in a case where the program under development101is executed in the program development execution environment10with execution times for each of a plurality of functions in a case of executing the program under development101in the simulation environment20, and calculates shortening rates. The shortening rate application unit114generates a dummy program304to be used in the simulation environment20based on the shortening rate calculated by the shortening rate calculation unit113and the program under development101.

In this way, it is possible to efficiently perform the performance evaluation of the program under development101. Specifically, it is possible to evaluate the parallel performance of the program under development101in a short time while maintaining the configuration related to the parallel performance of the program under development101.

The shortening rate application unit114generates the dummy program304by using the minimum shortening rate out of a plurality of shortening rates calculated for each of the plurality of functions.

In this way, the shortening rates of each of the similarity functions are able to be equalized.

The shortening rate application unit114generates the dummy program304based on a dummy trace202which records values obtained by multiplying processing times of each of the plurality of functions by the shortening rates.

In this way, a generation of the dummy program304is able to be appropriately performed.

The similarity function retrieval unit111retrieves a plurality of similarity functions similar to each of a plurality of functions included in a program under development101from a predetermined function list206. The similarity function performance measurement unit112measures execution times in a case where similarity functions retrieved by the similarity function retrieval unit111are executed in a simulation environment20. The shortening rate calculation unit113calculates shortening rates based on the execution times for each of the plurality of functions in the program development execution environment10and execution times for each of a plurality of similarity functions measured by the similarity function performance measurement unit112.

In this way, the shortening rates are able to be appropriately calculated.

[B] Modification Example

FIG. 17is a block diagram schematically illustrating a functional configuration of an information processing apparatus1ain a modification example.

The information processing apparatus1ain the modification example includes a CPU11aillustrated inFIG. 17in place of the CPU11included in the information processing apparatus1as an example of the embodiment illustrated inFIG. 3.

In addition to the functions as the similarity function retrieval unit111, the similarity function performance measurement unit112, the shortening rate calculation unit113and the shortening rate application unit114illustrated inFIG. 3, the CPU11aincludes functions as a function classification unit115and a function simplification unit116.

The function classification unit115is an example of a classification processing unit. The function classification unit115classifies a plurality of functions included in the program under development101into non-exclusive processing, exclusive resource acquisition processing, and exclusive resource release processing. Details of functions in the function classification unit115will be described later with reference toFIG. 18and the like.

The function simplification unit116is an example of a simplification processing unit. The function simplification unit116generates a simplified trace402that records continuous functions out of the functions classified as the non-exclusive processing by the function classification unit115as a single simplified function. Details of functions in the function simplification unit116will be described later with reference toFIG. 18and the like.

FIGS. 18 to 20are block diagrams explaining a generation process of a dummy trace202in the information processing apparatus1aillustrated inFIG. 17.

As illustrated inFIG. 18, the program under development101is executed in the program development execution environment10(see reference sign G1inFIG. 18). In this way, the execution trace102is generated.

In any environment30b, the function classification unit115receives function names of the execution trace102as an input (see reference sign G2inFIG. 18), classifies each function into a group, and generates group information401.

In the example illustrated inFIG. 18, each function in the execution trace102is classified into one of a function_Gr_A indicating the non-exclusive processing, a function Gr_B indicating the exclusive resource acquisition processing, and a function_Gr_C indicating exclusive resource release processing. Specifically, in the example illustrated inFIG. 18, as indicated in the group information401, a function_1, a function_2, a function_4, and a function_6to a function_8are classified into the function_Gr_A, a function_3is classified as the function_Gr_B, and a function_5is classified as the function_Gr_C. The non-exclusive processing indicates processing other than lock and unlock, the exclusive resource acquisition processing indicates processing such as lock, and the exclusive resource release processing indicates processing such as unlock.

The function simplification unit116acquires the group information401generated by the function classification unit115(see reference sign G3inFIG. 18).

Based on the group information401, the function simplification unit116simplifies the execution trace102and generates the simplified trace402(see reference sign G4inFIG. 18). The function simplification unit116combines a plurality of continuous functions out of functions that are non-exclusive processing belonging to the function_Gr_A into one simplified function and registers the simplified function to the simplified trace402.

In the example illustrated inFIG. 18, the function_1and the function_2in the execution trace102are combined in the simplified_function_1in the simplified trace402and the function_6to the function_8in the execution trace102are combined in the simplified_function_5in the simplified trace402. The function_3to function_5in the execution trace102respectively correspond to the simplified_function_2to the simplified_function_4in the simplified trace402.

The processing time of each simplified function in the simplified trace402is equal to the sum of the processing times of the corresponding functions in the execution trace102. For example, the processing time of the simplified_function_1in the simplified trace402is T_1+T_2which is the sum of the processing times of the corresponding function_1and function_2in the execution trace102. The processing time of the simplified_function_2in the simplified trace402is T_3which is the processing time of the corresponding function_3in the execution trace102. The processing time of the simplified_function_3in the simplified trace402is T_4which is the processing time of the corresponding function_4in the execution trace102. The processing time of the simplified_function_4in the simplified trace402is T_5which is the processing time of the corresponding function_5in the execution trace102. The processing time of the simplified_function_5in the simplified trace402is T_6+T_7+T_8which is the sum of the processing times of the corresponding function_6to function_8in the execution trace102.

As illustrated inFIG. 19, in the simulation environment20, the similarity function retrieval unit111receives each of simplified functions in the simplified trace402as an input (see reference sign G5inFIG. 19).

The similarity function retrieval unit111retrieves similarity functions similar to the inputted simplified functions and outputs the retrieved similarity functions to the similarity trace205(see reference sign G6inFIG. 19). In the example illustrated inFIG. 19, the similarity function retrieval unit111outputs the similarity_function_A to the similarity trace205as a function similar to the simplified_function_1, the simplified_function_3, and the simplified_function_5in the simplified trace402. The similarity function retrieval unit111outputs the simplified_function_B to the simplified trace402as a function similar to the simplified_function_2in the simplified trace402, and also outputs the simplified_function_C to the simplified trace402as a function similar to the simplified_function_4in the simplified trace402.

The similarity function performance measurement unit112receives each of the similarity functions in the similarity trace205as an input (see reference sign G5inFIG. 19).

The similarity function performance measurement unit112measures the processing time of each inputted similarity function and outputs the measured processing time to the similarity trace205(see reference sign G6inFIG. 19). In the example illustrated inFIG. 19, the similarity function performance measurement unit112outputs Tsim_A, Tsim_B, and Tsim_C, respectively to the similarity trace205as the processing time of the similarity_function_A, the similarity_function_B, and the similarity_function_C.

As illustrated inFIG. 20, in any environment30a, the shortening rate calculation unit113receives the processing times of each of the simplified functions in the simplified trace402as an input (see reference sign G7inFIG. 20). The shortening rate calculation unit113receives the processing times of each of the similarity functions in the similarity trace205as an input (see reference sign G8inFIG. 20).

The shortening rate calculation unit113compares the processing times of each of the simplified functions with the processing times of each of the similarity functions and calculates shortening rates of the similarity functions corresponding to each of the simplified functions. Then, the shortening rate calculation unit113inputs the shortening rates r of each of the calculated similarity functions to the shortening rate application unit114(see reference sign G9inFIG. 20).

The shortening rate application unit114applies the minimum shortening rate r out of the shortening rates r of each of the input similarity functions to the dummy trace202(see reference sign G10inFIG. 20).

In the example illustrated inFIG. 20, in the dummy trace202, (T_1+T_2)×r is set in a processing time of a shortening_function_1, T_3×r is set in a processing time of a shortening_function_2, T_4×r is set in a processing time of a shortening_function_3. In the dummy trace202, T_5×r is set in a processing time of a shortening_function_4, and (T_6+T_7+T_8)×r is set in a processing time of a shortening_function_5.

Regarding the function having the minimum shortening rate, the processing time in the dummy trace202is not shortened with respect to the processing time for the similarity trace205. Therefore, parentheses are attached to “shortening” of “shortening function” in the function name of the dummy trace202.

According to the information processing apparatus1ain the modification example of the above-described embodiment, for example, the following effects may be obtained.

The function classification unit115classifies a plurality of functions included in the program under development101into non-exclusive processing, exclusive resource acquisition processing, and exclusive resource release processing. The function simplification unit116generates a simplified trace402that records continuous functions out of the functions classified as the non-exclusive processing by the function classification unit115as a single simplified function. The shortening rate calculation unit113calculates shortening rates based on execution times for each of the simplified functions included in the simplified trace402generated by the function simplification unit116and execution times for each of a plurality of similarity functions measured by the similarity function performance measurement unit112.

As a result, the shortening rate applied to the dummy trace202may be increased, and the number of lines of the dummy trace202may be reduced. A simulation of the program under development101may be completed in a short time.

[C] Other

The disclosed technology is not limited to the above-described embodiment, and various modifications may be made without departing from the gist of the present embodiment. Each configuration and each process of the present embodiment may be selected as desired or may be combined as appropriate.