JPH0377135A - Function rearranging system - Google Patents

Abstract

PURPOSE:To reduce the number of times of paging, to increase the executing speed of the load module and to improve the overall system efficiency by producing a load module after rearranging the object modules so as to reduce the number of times of paging at execution. CONSTITUTION:A rearrangement processing part 2-1 sorts the functions which are called directly/indirectly out of a certain function of an object module 1 into the function which are called out of a function and those called out of plural functions. Then the part 2-1 rearranges successively the functions called out of a function at and after the address following a certain function and arranges in a batch the functions called out of plural functions respectively. Thus a load module 3 is produced. Then the functions are loaded to a main storage from an external storage device storing the module 3 and executed as necessary and for each page. Thus it is possible to reduce the number of times of paging and to improve the executing speed of the module 3.

Description

[Detailed Description of the Invention] [Summary] The present invention solves the problem of reducing processing speed due to the number of paging times when executing a load module in a function reordering method that reorders functions when creating a load module from an object module. To solve this problem, object modules are rearranged on a function-by-function basis to reduce the number of times load modules are paged during execution. This improves load module execution speed, reduces the load on the operating system, and improves overall system efficiency. It is designed to improve the

[Industrial application field]

The present invention relates to a function reordering method for reordering functions when creating a load module.

[Prior Art and Problems to be Solved by the Invention] Conventionally, in order to improve the execution speed of a load module, a load module is created after optimizing an object module obtained by compiling a source program.

However, in the past, when loading a load module stored in an external storage device into the main memory page by page and executing it as necessary, the load module was not placed in consideration of function call relationships, which resulted in an increase in the number of paging times. If the number of load modules increases, the execution speed of the load module cannot be improved, and the load on the operating system increases, resulting in a decrease in the efficiency of the entire system.

The present invention reorders object modules on a function-by-function basis to reduce the number of times of paging when executing a load module, thereby improving the execution speed of the load module and reducing the burden on the operating system, thereby improving the efficiency of the entire system. The purpose is to

[Means to solve problems]

FIG. 1 shows a basic configuration diagram of the present invention.

In FIG. 1, an object module 1 is a compiled source program.

The sorting processing unit 2-1 classifies functions called directly or indirectly from a certain function in object module i into functions called from one function and functions called from a plurality of functions. It sorts the functions that are called from one function in order from the next address of the above-mentioned function, and also sorts the functions that are called from multiple places all at once (for example, sorts the functions that are called from the above-mentioned function in descending order of the number of times they are called).

Load module 3 is an executable module.

[Effect]

In the present invention, as shown in FIG.
is for a function in object module 1, and for functions that are called directly or indirectly from this function, 1
Sort the functions called by one function and the functions called by multiple functions, sort the functions called by one function in order from the next address of the above function, and sort the functions called by multiple functions together (e.g. (The above-mentioned functions are sorted in descending order of the number of times they are called), and a load module is created for the object modules after these sorts.

Therefore, by loading the load module generated for the rearranged object module into the main memory in page units as necessary from the external storage device and executing it, the number of times of paging can be reduced and the load module can be executed. It is possible to increase the speed and reduce the burden on the operating system, thereby improving the efficiency of the entire system.

〔Example〕

Next, the configuration and operation of one embodiment of the present invention will be explained in detail using FIGS. 1 to 4.

In FIG. 1, a linkage editor 2 is an editor that creates a load module 3 from an object module l obtained by compiling a source program, and includes a rearrangement processing unit 2-1 and a load module creation unit 2-2 according to the present embodiment. It is composed of etc.

The sorting processing unit 2-1 sorts functions that are called directly or indirectly from a certain function in the object module 1.
Sorting is performed so that the number of paging is reduced (described later with reference to FIGS. 3 and 4).

The load module creation unit 2-2 includes a rearrangement processing unit 2-2.
The load module 3 is created from the object module 1 after the functions are sorted by 1.

Load module 3 is an executable module.

FIG. 2 shows a detailed explanatory flow chart of the present invention.

In FIG. 2, ■ creates a source program.

0 compiles the source program (2) to generate object module 1.

@ is for classification. Regarding the object module 1 compiled in ■, functions that are called directly or indirectly from a certain function are classified into functions that are called from one function and functions that are called from multiple functions.

■Performs sorting. This arranges the functions that are called from one of the categories classified in ■ sequentially starting from the next address of a certain main function, and sorts the functions that are called from multiple functions in descending order of the number of times they are called (
(See Figures 4 (b) and (c)).

(2) Performs normal processing. This performs processing of unresolved symbols, creation of a load module file, etc. for object module 1 after sorting by ■.

As described above, by classifying the functions that are called directly or indirectly from a function in the compiled object module 1 and rearranging them to reduce the number of paging, by creating the load module 3, the load module It becomes possible to improve the processing speed by reducing the number of times of paging during execution, and it also becomes possible to reduce the burden on the operating system and improve the efficiency of the entire system. A detailed explanation will be given below.

FIG. 3(A) shows a flowchart of the sorting process.

In FIG. 3 (a), ■ performs classification of functions. As described above, functions that are called directly or indirectly from a certain function are classified into functions that are called from one function and functions that are called from multiple functions.

(2) performs processing that can only be called from one function. This is to rearrange functions that are called from only one function in order from the next address of a certain function (this will be explained in detail using FIG. 4).

■ Processes things that are called from multiple functions.

This involves rearranging functions called from a plurality of functions in order from the end of a certain function (this will be explained in detail using FIG. 4).

FIG. 3(b) shows a processing flowchart for a process that is called only from L functions.

In Figure 3 (b), [phase] is main (a certain function; Figure 4 (b) is the function main of the object module.
) is to be processed.

O determines whether there are any remaining functions to be processed. If No (if any remain), use 0 to place the called function (for example, function a in Figure 4 (b)) at the next address of main, and use ■ to place the called function (for example, the 4th function).
Figure (b) Function C), which is called from function a, is the processing target, and the operation of ■ is repeated. By processing these ONO, @, [phase], aSbXc is generated next to main in Figure 4 (c).
, d.

g are arranged as shown. On the other hand, in the case of YES (if there are none left), it is determined whether the processing target is main with [phase], and when it is YES, it is finished, and when it is NO, it is [
[phase] makes the calling function the target of processing, and repeats the operations after ■.

As a result of the above processing, for a function that is called from only one function, the function is placed from the next 7 addresses of a certain function (function main) (for example, in Figure 4 (C), the function is placed from the next address of function main). a, function b, function C1
Function d, function g, and function s are arranged as shown).

Note that functions that are called by multiple functions are listed in descending order of the number of times they have been called, for example, in Figure 4 (C) function r.
, are arranged like the function e.

FIG. 4 shows a detailed illustration of the invention.

FIG. 4(a) shows an example of a source program.

Each of these functions is called from the function main as shown in the figure, and is stored in files 5 to 3, respectively.

FIG. 4(B) shows an example of an object module. This shows an example of an object module obtained by compiling the example source program in FIG. 4(B), in which files 1 to 3 are compiled into object modules E to 3. has been done. Here, the arrows indicate call relationships (external reference relationships) written in the source program. As can be seen from these arrows, function a, function S, function C2, function d, and function g are called from one function. Function e is called by two functions. Function f is called by three functions.

FIG. 4(c) shows an example of a load module.

This is an arrangement of functions from the object module in FIG. 4 (b) so that the number of paging times is reduced. This will be explained in detail below.

First, function a, which is called only from one function,
Place b, c, d, and H.

(1) Place the function main at the beginning (■).

(2) Function a called from function main.

Among the functions, the function a with the smallest caller address in the function main is placed second (■).

(3) Function C called from function a placed in ■
Place it in the third position (■).

(4) Function d called from function C placed in ■
(Function f is not applicable because it is called from three sources) is placed in the fourth position (■).

(5) Function g called from function d placed in ■
Place it in the fifth position (■).

(6) Nothing is called from the function g in ■, so if you go back and search for functions that still have processing remaining, you will find the function main, and the function called from this function main will be placed in the 6th position. Do (■).

With the above processing, the processing of the function being called from one end is completed.

Next, arrange functions e and f that are called by multiple functions.

(7) Function e is called from two functions (functions a, b), and function f is called from three functions (functions a, b, c), so function r is called from the eighth (■), and place the function e at the seventh position (■).

With the above processing, the processing of the function that is being called from multiple sources is completed.

As a result of rearranging the load modules as shown in FIG. 4(c), the following characteristics are obtained.

(J) A function called from one function is a function (
(main), page faults are less likely to occur during function calls during execution and during return.

(2) Since functions called from multiple functions are grouped together, the grouped portion (page) is accessed more frequently during execution, making it difficult to swap out pages.

〔Effect of the invention〕

As explained above, according to the present invention, a configuration is adopted in which a load module is created after object modules generated by compiling a source program are rearranged so as to reduce the number of times of paging during execution. Therefore, when loading a load module page by page from an external storage device to main memory and executing it, it is possible to reduce the number of paging times and improve the execution speed of the load module, and the operating system also performs swapping. This can reduce the burden and improve the efficiency of the entire system.

[Brief explanation of drawings]

FIG. 1 is a diagram showing the basic configuration of the present invention, FIG. 2 is a detailed flow chart explaining the present invention, FIG. 3 is a flow chart explaining the operation of the present invention, and FIG. 4 is a detailed diagram explaining the present invention. In the figure, 1 represents an object module, 2 a linkage editor, 2-1 a rearrangement processing section, 2 a load module construction section, and 3 a load module.

Claims (1)

[Claims] In a function reordering method that reorders functions when creating a load module, for a function in an object module compiled from a source program, one function is called directly or indirectly from the function. Classified into functions called from and functions called from multiple functions,
Sort functions that are called from one function in order from the next address (or nearby address) of the above function, and also rearrange functions that are called from multiple sources at once (
For example, a sorting processing unit (2-1) that sorts the above-mentioned function in descending order of the number of times it has been called, and generates a load module for the object modules that have been sorted by the sorting processing unit (2-1). , a function reordering method characterized by being configured to reduce the number of times of paging during execution of this load module.