JP3309810B2 - Program link system, method and recording medium - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a technique for linking an object module of each function included in a program in a computer having a cache memory so as to reduce instruction cache misses during program execution. .

[0002]

2. Description of the Related Art When creating a computer program,
Normally, an object module is generated from a source module written in a high-level language using a compiler, and a plurality of object modules are linked using a linker to create a load module in a format that can be executed by a computer. Here, the order in which the object modules are linked is determined by arranging the functions included in the object modules on a certain basis.

When creating a load module that can be executed by such a computer, it is desirable that the execution speed of the created load module be as high as possible. In consideration of the fact that a computer has a cache memory, a program link system for increasing the instruction cache hit rate and increasing the execution speed of a load module is disclosed in
No. 124327.

FIG. 8 shows the configuration of the program link system. This program link system includes an instruction cache miss profile creation unit 801, an arrangement search unit 802, and a relink unit 803.

In this program link system, an instruction cache miss profile creating means 801 simulates the execution of a load module created by using some kind of compiler or linker, traces the execution state of instructions, and indicates the number of occurrences of instruction cache misses. Then, the cache block in which the cache miss has occurred and the function in which the instruction cache miss has occurred are recorded.

Next, in a cache block in which the frequency of occurrence of a cache miss is high, the functions located in the same cache block function to exclude each other from the cache block at the time of execution. An arrangement search is performed to move the colliding function to another cache block.

Then, the object program is re-linked by the re-linking means 803 according to the arrangement searched by the arrangement searching means 802, and the load module is created again. The same processing as described above is repeated for a load module created by relinking, and the most preferable load module is created by searching for a function arrangement that minimizes the frequency of occurrence of cache misses.

[0008]

However, the above conventional example has the following problems. First, in the above-described conventional program link system, the execution of a program is simulated to check the occurrence state of a cache miss, and the function is rearranged until the arrangement of the function that minimizes the occurrence frequency of the cache miss is determined. You have to repeat that. For this reason, there is a problem that it takes time until the optimal function arrangement is determined.

Second, DRAM (Dynamic Random)
In a memory module such as an Access Memory, access to non-consecutive memory addresses is generally slower than access to consecutive memory addresses. In the above-described conventional program link system, functions are often arranged at non-contiguous memory locations regardless of the calling order. Therefore, when a cache miss occurs, the transfer of instructions from the main memory to the cache memory is performed. There is a problem that it takes time.

Third, in a computer that supports multitasking in which a plurality of programs are executed simultaneously,
Since the usage of cache memory is constantly changing,
Even if the occurrence situation of the cache miss is statically analyzed by simulation, the analysis result is different from the actual situation. For this reason, in a computer that supports multitasking, which is generalized in current general-purpose computers, there is a problem that even if a load module is created as described above, its execution speed does not always increase.

Japanese Patent Application Laid-Open Nos. 8-328870 and 9-128245 disclose techniques for reducing the frequency of instruction cache misses and increasing the execution speed of a program. Each is disclosed. However, each of these techniques relates to a compiling process for generating an object module from a source module, and does not relate to a linking process for generating a load module from an object module as in the present invention.

SUMMARY OF THE INVENTION The present invention has been made to solve the above-mentioned problems of the prior art, and reduces the frequency of occurrence of an instruction cache miss by continuously arranging object modules of a frequently executed function. Moreover,
It is an object of the present invention to provide a program link system and method capable of deciding such a function arrangement at high speed, and a recording medium recording this method.

[0013]

In order to achieve the above object, a program link system according to a first aspect of the present invention links a plurality of object modules and stores a part of a program on a main memory. A program link system for creating a load module to be executed by a computer having a cache memory, comprising: a program structure extracting unit for analyzing a structure of a program corresponding to the load module created by the link; and an analysis by the program structure extracting unit. Based on the result,
And ordering means for attaching a sequence for linking the plurality of object modules respectively, according to the order given by the ordered unit, and a link means for creating a load module to link the plurality of object modules, said plurality Object moji
Module is the program for which the load module is created.
Corresponding to each function included in the program,
The program structure extraction means is a target for creating a load module.
Analyze the source program of the program and
Loop containing function calls and function calls
Creating a structure graph representing the relationship of
First refers to the structure graph and first calls
Functions, and then call them in a frequently executed loop.
The called functions are called in the loop in the order
By rearranging the plurality of
It is characterized in that the ordering of the object modules is performed .

In order to achieve the above object, a program link system according to a second aspect of the present invention provides a program link system for creating a load module to be executed by a computer having a cache memory in which a part of a program on a main memory is stored. A program link system for assigning an order to a plurality of object modules linked by a linker, comprising: a program structure extracting unit for analyzing a structure of a program corresponding to a load module created by the link; and a program structure extracting unit. Ordering means for ordering the plurality of object modules based on the result of the analysis.
Wherein the plurality of object modules are loaded
Each file included in the program for which a module is created
Said program structure extracting means corresponding to the function
Is the source of the program for which the load module is to be created.
Analysis of the source program
A structure representing the relationship with the loop containing the function call
A drawing graph, and the ordering means generates the drawing graph.
First, list each function in the order of calls.
Next, the fan called in the frequently executed loop
Actions are arranged in the loop so that they are consecutive in the calling order.
By replacing, the plurality of object modules
It is characterized in that the rules are ordered .

In the program link system according to the first and second aspects, ordering means for linking the object modules by the ordering means so that modules having a high execution frequency do not compete for the same block in the cache memory. By doing so, the frequency of occurrence of cache misses can be suppressed. For this reason, when the load module finally created is executed by the computer, the substantial execution speed can be increased.

In order to determine the optimal link order of the object modules, the program structure extracting means may analyze the program structure, and the order determining means may order the object modules according to the program structure. That is, in the above program link system, it is not necessary to repeat the simulation each time a load module is actually created, and the processing time for determining the order for linking the object modules can be reduced.

[0017]

A program according to the first and second aspects
In the link system, the program structure extracting means includes means for adding the number of executions of each function in a loop in a program for which a load module is to be created to a program structure graph. The number of executions of each function can be determined by multiplying the execution frequency of each loop by the number of executions of each function.

In the above-mentioned program link system, it is preferable that the cache memory maps and stores a program on the main memory by a direct method or a set associative method.

That is, in a computer adopting the direct method or the set associative method as a mapping method of the cache memory, which block of the cache memory is allocated is determined in block units of the main memory. For this reason, it is possible to reduce the frequency of cache misses by preventing the portions of the load module to be created that have a high execution frequency from competing for the same block of the instruction cache memory. In particular, the effect of the present invention is remarkably exhibited when a load module to be executed by a computer adopting a direct method in which a block of a cache memory allocated to each block of a main memory is uniquely determined.

To achieve the above object, a program linking method according to a third aspect of the present invention is a computer having a cache memory for linking a plurality of object modules and storing a part of a program on a main memory. A program linking method for creating a load module to be executed, comprising: a program structure extracting step of analyzing a structure of a program corresponding to a load module created by the link; and, based on an analysis result in the program structure extracting step, the includes a sequencing step to give the order for a plurality of object modules each link, according to the order given in the ordering step, and a link creating a load module to link the plurality of object modules, Serial multiple object modules
Is included in the program for which the load module is created.
The program structure corresponding to each function
The extraction step is a process for creating a load module.
Analyze the program source program and
Loop with function calls and function calls
Creating a structure graph representing the relationship, and said ordering step
First refers to the structure graph and first calls
Functions, and then call them in a frequently executed loop.
The called functions are called in the loop in the order
By rearranging the plurality of
It is characterized in that the ordering of the object modules is performed .

In order to achieve the above object, a recording medium according to a fourth aspect of the present invention links a plurality of object modules to be executed by a computer having a cache memory in which a part of a program on a main memory is stored. A recording medium for recording a program for creating a load module to be executed, based on a program structure extracting step of analyzing a structure of a program corresponding to the load module created by the link, based on an analysis result in the program structure extracting step. Te, the ordering step to give an order to link the plurality of object modules respectively, said ordered according Tagged sequence in step, computing a link creating a load module to link the plurality of object modules Program for executing device
And the program structure extracting step includes loading
Source program of the program for which the module is created
Analyze the ram for function calls and functions
Structure graph showing the relationship with the loop containing the
Creating and ordering step refers to the structure graph.
First, arrange each function in the order of calling, then
Function that is called in a frequently executed loop
Are sorted in the calling sequence in the loop
By doing so, the plurality of object modules
It is characterized by performing ordering .

[0023]

Embodiments of the present invention will be described below with reference to the accompanying drawings.

First, a computer having a cache memory in which a source program is compiled in this embodiment and a load module to which the compiled object module is linked is to be executed will be described with reference to the block diagram of FIG. explain.

As shown in the figure, the computer includes a CPU (Central Processing Unit) 701 for executing an operation, an instruction cache memory 702 for caching instructions, a data cache memory 703 for caching data, and a main memory 704. I have.

When executing a program, the CPU 701 reads instructions one by one from the instruction cache memory 702. When an instruction to be executed is not stored in the instruction cache register 702 (instruction cache miss), a block including an instruction of a part required for execution is loaded from the main memory 704 to the instruction cache memory 702.

There are generally three methods of mapping the cache memory: a direct method, a set associative method, and a full associative method. In this computer, the direct cache or the set method is used as the mapping method of the instruction cache memory 702. One of the associative methods is adopted. here,
A brief description will be given of the direct method in which the effect of this embodiment is the largest. The position of the instruction cache memory 702 to which the block in the main memory 704 is allocated is the number of the block at the address of the main memory 704. The remainder is divided by the number of blocks.

FIG. 2 is a block diagram showing a functional configuration of a program link system for creating a load module executable by the computer shown in FIG. 1 from a source program according to this embodiment. As shown, the program link system comprises a program structure extracting means 1
01, function ordering means 102, link means 103, and compiling means 104.

The program structure extraction means 101 operates under program control, reads a source program (including a source module corresponding to a plurality of functions) of a program for which a load module is to be created, and
A flow analysis of a function in a source program is performed, and a program structure graph representing a relationship between a function call and a loop including the function call is created.

The function ordering means 102 operates under program control, and the program structure extracting means 1
01, referring to the program structure graph created in
The functions are arranged in the order of call, and the functions are rearranged so that functions called in the next most frequently executed loop are consecutive in the order of calls, and all the functions included in the source module are ordered.

The linking unit 103 operates under program control, and links the object modules for each function created by the compiling unit 104 so as to be arranged in the main memory 704 in the order ordered by the function ordering unit 102. To create a load module.

The compiling means 104 operates under program control, and creates an object module corresponding to each source module included in the source program from the source program.

Hereinafter, processing in the program link system according to this embodiment will be described. First, the program structure extracting unit 101 and the function ordering unit 102 order each function so that object modules of frequently executed functions are continuously arranged.

FIG. 3 is a flowchart showing a process executed by the program structure extracting means 101 and the function ordering means 102 for ordering the functions.

When the process starts, the program structure extracting means 101 reads a source program for which a load module is to be created, and analyzes the flow of the program (step S1). Next, program structure extracting means 1
01 extracts a loop configuration including a function call relationship and a function call, and creates a program structure graph (step S2).

At this time, the program structure extracting means 101
Checks the execution frequency of the loop, and adds the number of executions of each function in the loop as information. When a loop is nested, the execution frequency of each loop is a value obtained by multiplying the number of executions, and indicates the number of executions of a function in the loop when the program is executed. In a condition determination loop such as a while statement and a do-while statement in the C language, the execution frequency of the loop is not known unless the program is actually executed. In this case, an appropriate number of times is determined by the execution frequency in the loop. Assume.

Next, the function ordering means 102
Refers to the program structure graph, and sorts each function in the program in order from the main function,
They are arranged in the order in which they are first called (step S3). Next, the function ordering means 102
Sets all the loops in the program structure graph to unordered (step S4).

Next, the function ordering means 102
Checks whether there is a loop whose ordering is undetermined (step S5). If it is determined that there is a loop whose ordering is undetermined, first, it is determined whether or not a function in the loop is called by any other function in the program. If the function is used elsewhere in the program, compare the execution frequency of the function, and if the current loop is larger, move the function so that it is located at the calling position in the current loop. (Step S6).

When step S6 ends, the function ordering means 102 returns to step S5, and checks whether there is a loop whose ordering is undetermined. If it is determined in step S5 that there is no loop whose ordering has not been determined, the processing of this flowchart ends, and the ordering of the functions is determined.

On the other hand, while the program structure extracting means 101 and the function ordering means 102 perform the above processing, the compiling means 104 compiles the source module of each function included in the source program and corresponds to each function. Create a new object module.

When both the processing by the program structure extracting means 101 and the function ordering means 102 and the processing by the compiling means 104 are completed,
The linking unit 103 links the object modules for each function compiled by the compiling unit 104 in the order of the corresponding functions determined in the processing of FIG. 3 to create a load module.

Hereinafter, the processing in this embodiment will be described in detail based on a specific example. FIG. 4 is a diagram showing an example of a program for specifically explaining the processing in this embodiment. This program is described using the C language. However, the description of the program other than the function call and the loop is omitted here.

In the program shown in FIG. 4, the main program main () has four functions fa (), fb (), f
Calls c () and fd (). Function fc () returns f
It has a loop that is repeatedly executed 50 times described by or (i = 0; i <50; i ++), and calls three functions fa (), fe () and ff () in this loop. Further, the function fc () calls the function fg () outside the loop.

The function fe () is for (j = 0; j <100; j
++) has a loop that executes 100 times repeatedly, and three functions fa (), fh (), f
Calling i (). This loop is a function f
Nested (nested) with the loop in c (). Therefore, the functions fa (), fh (), f
i () is 50 × 100 = 5000 in this loop
Will be called multiple times. In addition, the function fe
() Calls the function fd () outside the loop.

On the left side of FIG. 4, there is shown a program structure graph showing a flow analysis of the program of FIG. 3 and showing a function call and a loop configuration. The result of the flow analysis of the program is the same as the result obtained by adding information indicating the loop and the number of loops to the output result of the command cflow in the UNIX program development environment. In FIG.
A square frame indicates a loop. Here, loop 1
And loop 2. A function surrounded by a rectangular frame indicates that the function is included in the loop, and a number in parentheses <> indicates the number of times the function is executed in the loop.

Next, a method of ordering each function will be described. First, place each function in the order in which it is called. This can be done by arranging the functions in order of appearance from the top of the program structure graph. The result of arranging the functions is shown in the center of FIG.

Next, the order of the functions in the loop is determined. First, loop 2 is composed of 3 of fa (), fh (), fi ()
Has functions. Each of these functions is executed 5,000 times, and is executed most frequently in a program. Therefore, the function fa () arranged at another position moves within this loop, and is arranged in the order of functions fa (), fh (), fi (). Next, the functions in the loop 1 are ordered.

In loop 1, in addition to fa (), fh (), fi () included in loop 2 and having already determined the order, fa (), fe (), f
It has four functions of d () and ff (). Each of these functions is executed 50 times. Function fa () is excluded because loop 2 has its placement determined.
The functions fe (), fd (), and ff () are arranged in this order. At this time, the function fe () containing loop 2
Followed by the function f whose placement is determined in loop 2
a (), fh (), fi () are arranged. As a result, there is no undetermined loop, and the arrangement of functions can be determined as shown on the right side of FIG.

The method of instructing the linker (link means 103) on the arrangement of functions differs depending on the type of linker, and there are several methods. For example, a link directive (linkdi
rective) file. For information on how to write a link directive file, see "NE
C User's Manual CA732 / CA830
-CA850 V800 Series-C Compiler-Package Operation UNIX Base "(Document number U110
13JJ1V0UM00, 1995) at pages 113 to 188.

Next, consider a case where the load module created from the source program of FIG. 4 is executed by the computer of FIG. Here, the instruction cache memory 7
02 is divided into 0th to 3rd blocks and is mapped in a direct system. In the created load module, functions fa () to fg ()
Has a size of one block each, and the load module is stored in a continuous area from the 0th block of the main memory 704.

As shown in the center part of FIG. 5, when the object modules of each function are linked in the order of calling the functions, the function fa () and the function fh () are stored in the instruction cache memory 70.
The second 0-th block will be allocated. Here, when executing the loop 2, the function fh () to be stored in the zeroth block must be executed immediately after the function fa () is transferred to the zeroth block of the instruction cache memory 702 and executed. No. That is, a cache miss always occurs when the function fh () is executed. On the other hand, when returning to the beginning of the loop 2 and executing the function fa (), a cache miss will also occur. That is, in the loop 2, 5000 × 2 = 10000 cache misses occur, which causes a reduction in the execution speed of the created load module.

On the other hand, as shown on the right side of FIG. 5, when the object module of each function is created by changing the order of the functions, the functions fa (), fh (), fi The third, zeroth, and first blocks of the instruction cache memory 702 are respectively assigned to (). Therefore, when the functions fa (), fh (), fi () are repeatedly executed in the loop 2, a cache miss does not occur. On the other hand, in the loop 1, for example, a cache miss occurs when the blocks of the instruction cache memory 702 are held by the functions fe () and fd (), but the number of times is 50 × 2 = 100 times, and the frequency is extremely small. It will be. Therefore, the execution speed of the created load module increases.

As described above, according to the program link system of this embodiment, a load module is created in which functions in frequently executed portions of a program are arranged at consecutive addresses. . Therefore, when the load module is executed by the computer, it does not occur that frequently executed functions compete for blocks in the instruction cache memory 702. Therefore, the frequency of occurrence of cache misses in the entire program is reduced, and the execution speed of the program is increased.

Each function in a frequently executed loop is ordered in its calling order, and a load module arranged so as to have continuous addresses is created. Therefore, when a cache miss occurs, the next program to be executed can be transferred from consecutive addresses of the main memory 704 to the instruction cache memory 702.
It takes less time to transfer instructions to the server.

Further, a program structure graph is created only by the program structure extracting means 101 performing the program flow analysis once. Next, after the function ordering means 102 arranges the functions in the calling order, the function may be rearranged by examining the program structure graph from the loop having a high execution frequency. Therefore, it is not necessary to repeat the same processing many times, and the processing time required to determine the arrangement of the functions can be reduced.

The present invention is not limited to the above embodiment,
Various modifications and applications are possible. Hereinafter, modifications of the above-described embodiment applicable to the present invention will be described.

In the above embodiment, the link means 104
The computer that executes the load module created in the above has an instruction data cache memory 702 and a data cache memory 703 separately. However, the present invention may be applied to the creation of a load module to be executed by a computer having a cache memory for storing instructions and data without distinction.

In the above embodiment, each function in the program is ordered by the function ordering means 102 and compiled by the compiling means 104 to create a load module for each function. However, according to the present invention, when parsing a source program with a compiler, an order may be assigned to object modules corresponding to each function based on the result of the syntax analysis, and information about the order may be included in each object module. Good. Then, according to the information on the order in which the linker includes the object modules, the object modules may be linked to create a load module.

In the above embodiment, the load module is created from the source program by the program structure extracting means 101, the function ordering means 102, the linking means 103 and the compiling means 104 which operate under program control. However, the program for realizing the program link system of the present invention may be stored on a magnetic disk, a semiconductor memory, or another recording medium and distributed.

That is, as shown in FIG.
002 is installed in an external storage device (such as a hard disk) 1003 of the computer 1001, and the computer 1001 executes the program installed in the external storage device 1003, whereby the program structure extracting means operates under program control. 101,
Function ordering means 102, link means 103
And the compiling means 104 may be realized. The computer 1001 may be the computer shown in FIG. 1, that is, a computer that executes the created load module.
As a computer other than this, that is, a computer different from the computer that executes the created load module, a load module may be created from a source program by cross compiling and cross linking.

[0061]

As described above, according to the present invention,
Modules with high execution frequency can be prevented from competing for the same block in the cache memory, and the frequency of occurrence of cache misses can be suppressed. For this reason, the execution speed of the program is increased.

Further, it is not necessary to repeat the same processing to determine the optimum link order of the object modules, and the processing time for the processing can be reduced.

[Brief description of the drawings]

FIG. 1 is a block diagram illustrating a configuration example of a computer that employs a cache memory.

FIG. 2 is a block diagram showing a functional configuration of a program link system according to the embodiment of the present invention.

FIG. 3 is a flowchart showing processing executed by a program structure extracting unit and a function ranking unit in FIG. 2 in the embodiment of the present invention.

FIG. 4 is an example of a program for specifically explaining processing according to the embodiment of the present invention.

5 is a diagram showing the relationship between the structure of the program shown in FIG. 4 and the ranking of functions.

FIG. 6 is a block diagram showing a configuration of a computer system applied to a modification of the embodiment of the present invention.

FIG. 7 is a block diagram showing a functional configuration of a program link system according to the related art.

[Explanation of symbols]

 101 program structure extracting means 102 function ordering means 103 linking means 104 compiling means 701 CPU 702 instruction cache memory 703 data cache memory 704 main memory

──────────────────────────────────────────────────続 き Continuation of the front page (56) References JP-A-4-165537 (JP, A) JP-A-6-202875 (JP, A) H. Hashimi et al., Efficient Procedures Mapping Using Cache Line Coloring, ACM SIGPLAN NOTICES, 1997, Vol. 32, No. 5, p. 171-182 K.P. Pettis, Profile guided code positioning, ACM SIGGPLAN NOTICES, 1990, Vol. 25, No. 6, p. 16-27 S.C. McFarring, Program Optimization for Instructions Caches, ACM SIGPLAN NO TICES, 1989, VOL. 24, special serial Issue, p. 183-191 (58) Field surveyed (Int. Cl. ⁷ , DB name) G06F 9/45 G06F 12/08

Claims (6)

(57) [Claims] 1. A program link system for linking a plurality of object modules and creating a load module to be executed by a computer having a cache memory in which a part of a program on a main memory is stored. Program structure extracting means for analyzing a structure of a program corresponding to a load module to be loaded, ordering means for assigning an order for linking the plurality of object modules based on an analysis result by the program structure extracting means, according to the order given by the means, and a link means for creating a load module to link the plurality of object modules, the plurality of object modules, load modules
Each function included in the program for which
The program structure extracting means corresponds to the operation of the load module.
Analyze the source program of the target program
Function call and function call
Create a structure graph representing the relationship with the loop including, the ordering means refers to the structure graph, first,
Arrange each function in call order, then execute frequency
Function called in a loop with high
In the order of calling within
To order the plurality of object modules.
Program link system, characterized in that the cormorant. 2. A program link system for ordering a plurality of object modules linked by a linker when creating a load module to be executed by a computer having a cache memory in which a part of a program on a main memory is stored. Program structure extracting means for analyzing a structure of a program corresponding to a load module created by the link; and an order for linking the plurality of object modules based on an analysis result by the program structure extracting means. and a sequencing means for attaching said plurality of object modules are loaded modules
Each function included in the program for which
The program structure extracting means corresponds to the operation of the load module.
Analyze the source program of the target program
Function call and function call
Create a structure graph representing the relationship with the loop including, the ordering means refers to the structure graph, first,
Arrange each function in call order, then execute frequency
Function called in a loop with high
In the order of calling within
To order the plurality of object modules.
Program link system, characterized in that the cormorant. 3. The program structure extracting means includes means for adding the number of executions of each function in a loop in a program for which a load module is to be created to a program structure graph. 3. The program link system according to claim 1, wherein the number of executions of the function is the product of the execution frequencies of the respective loops as the number of executions of each function. 4. Wherein said cache memory includes a program link according to any one of claims 1 to 3, characterized by storing mapping program on the main memory in a direct manner or set associative method system. 5. A program linking method for linking a plurality of object modules and creating a load module to be executed by a computer having a cache memory in which a part of a program on a main memory is stored. A program structure extracting step of analyzing a structure of a program corresponding to a load module to be loaded, and an ordering step of assigning an order for linking the plurality of object modules based on a result of the analysis in the program structure extracting step. according to the order given in ordered step, and a link creating a load module to link the plurality of object modules, the plurality of object modules, load modules
Each function included in the program for which
The program structure extraction step corresponds to a load module.
Analyzes the source program of the program to be created
Function call and function call
Creating a structure graph representing a relationship with the loop including the structure graph, wherein the ordering step refers to the structure graph,
Instead, arrange each function in the order of invocation, and then execute
Functions called in frequent loops
In the order that they are called in the group
Thus, the ordering of the plurality of object modules
Program linking method and performing. 6. A recording medium for linking a plurality of object modules and recording a program for creating a load module to be executed on a computer having a cache memory in which a part of the program on a main memory is stored, wherein the link is A program structure extracting step of analyzing a structure of a program corresponding to a load module created by the above, and an ordering step of assigning an order for linking the plurality of object modules based on an analysis result in the program structure extracting step. When, according to the order given in the ordering step, and a link creating a load module to link the plurality of object modules Computing
A program to be executed by the data device, and the program structure extracting step includes a load module.
Analysis of the source program of the programs that will be created object
Function call and function call
Creating a structure graph representing a relationship with the loop including the structure graph, wherein the ordering step refers to the structure graph,
Instead, arrange each function in the order of invocation, and then execute
Functions called in frequent loops
In the order that they are called in the group
Thus, the ordering of the plurality of object modules
A computer-readable recording medium and performs.