JP3726992B2 - Batch function call method - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a program conversion technique such as a compiler, and in particular, for a language having a function call mechanism, collective function calls at the time of program conversion for analyzing the relationship between functions and function calls and generating them as function information and call information. It relates to the conversion method.
[0002]
[Prior art]
In programming in a high-level language, structuring is generally performed by a function (also called a procedure, but hereinafter unified by function). A function is a series of processes described in a parameterized form (hereinafter referred to as a function definition), and by calling it (hereinafter simply referred to as a call), the process within the function definition can be realized. The parameters on the function definition side include dummy arguments and return variables (hereinafter referred to as temporary return numbers). In the description in the function definition, processing is performed using dummy arguments and temporary return numbers (hereinafter referred to as temporary parameters). Is described. Caller parameters include actual arguments and return variables (hereinafter referred to as actual return numbers), and the parameters are specified using the caller variables / expressions (the variables / expressions used as this call interface are the actual parameters). Called). Hereinafter, the temporary parameter and the actual parameter are collectively referred to as an interface variable / expression. Various values can be specified for the actual parameter, and the same process (= function definition) can be repeatedly executed.
[0003]
Thus, while functions are a convenient mechanism for programming, they have a problem that overhead is required at the time of calling. That is, processing performance is reduced by passing arguments, updating / saving / recovering the stack pointer at the time of calling, and increasing the possibility of a cache miss accompanying an instruction jump. In particular, when a function with simple processing contents is repeatedly called, the call overhead cannot be ignored in terms of performance.
[0004]
In order to cope with such a situation, high-level languages often have an inline expansion function. Inline expansion replaces a function call with the contents of the function definition body and suppresses the call. Specifically, it is realized by expanding the contents of the function definition at each call point and replacing the temporary parameter with the actual parameter. For inline development, see Masataka Sasa's Iwanami lecture, Software Science 5 "Programming Language Processor" (Iwanami Shoten, 1989) Details on 450-451.
[0005]
[Problems to be solved by the invention]
Inline expansion is almost the only means of reducing call overhead in high-level languages. However, if the code size becomes too large due to the application of inline expansion, the chance of a cache miss increases and the performance may decrease. For this reason, inline expansion is usually restricted when a large function is called or there are many call locations. That is, when the code amount is extremely increased, the call overhead cannot be reduced by inline expansion. That is, the conventional technique has a problem that there is no means for reducing the call overhead when inline expansion cannot be applied.
An object of the present invention is to provide a means for reducing call overhead that does not depend on inline expansion, so that even when inline expansion cannot be applied, call overhead can be reduced and the processing performance of the object program can be improved. It is to provide a batch function call method.
[0006]
[Means for Solving the Problems]
Inline expansion expands the processing contents of the function definition at each call point and removes the call (at that call point). Therefore, whether or not inline expansion is applied determines whether or not the number of calls at each call point is zero. In the case of multiple calls to the same function, even if inline expansion cannot be applied, if the processing for multiple calls is expanded on the function definition side, the number of calls can be reduced without significantly increasing the code size. It is. In other words, by creating a batch function that executes multiple times of processing of the same function at once and providing a batch call generation means for replacing multiple calls of the same function with a single batch function call, inline expansion It is possible to provide a means for reducing call overhead that does not depend on.
As a result, even when inline expansion cannot be applied, it is possible to reduce the call overhead and contribute to the improvement of the processing performance of the object program.
[0007]
DETAILED DESCRIPTION OF THE INVENTION
The present invention relates to a method for converting a plurality of calls of the same function into a call of a batch function for batch processing.
Hereinafter, an embodiment of the present invention will be described with reference to the drawings.
Note that the present invention can be similarly applied when generating a converted source program from a source program and when the compiler converts an intermediate language into an intermediate language after conversion. Will be explained (however, the intermediate language is shown in the form of an equivalent source program).
[0008]
FIG. 1 is a configuration diagram of a computer system in which a compiler that implements the compiling method of the present invention operates. The computer system includes a CPU 101, a display device 102, a keyboard 103, a main storage device 104, and an external storage device 105.
A compiler activation command from the user is received from the keyboard 103. The compiler end message and the error message are displayed on the display device 102. A source program 106 and an object program 107 are stored in the external storage device 105.
The main storage device 104 includes a compiler 108, which stores an intermediate language 3, a function information table 4, a call information table 5, a collective call information table 6, and a collective function information table 7 that are necessary in the compiling process.
The compilation process is controlled by the CPU 101.
[0009]
FIG. 2 shows the processing procedure of the compiler of this embodiment.
In the syntax analysis 201, the lexical syntax analysis is performed with the source program 106 as an input, and the intermediate language 3 is output.
The loop expansion process 202 receives 3 after the middle, performs loop expansion that expands the iterative process to reduce the number of iterations, and outputs the intermediate word 3.
The batch functioning process 2 receives the intermediate language 3 as input, performs batch functioning processing that converts a plurality of function calls into batch command function calls, and outputs the intermediate language 3.
The code generation process 203 converts the intermediate language into the final object program 107 format.
The loop expansion 202 is a desirable process for increasing the application opportunities of the present invention, but is not an essential process.
[0010]
FIG. 3 is a flowchart showing an embodiment of the function call batching method according to the present invention, and shows the procedure of the function call batching process 2 of FIG.
First, the function information table generation process 21 extracts various information of the function definition in the source program and creates the function information table 4. Similarly, the call information table generation process 22 extracts information related to function calls and generates the call information table 5.
[0011]
Next, the batch call information table generation processing 23 extracts information on a batch function for batch processing a plurality of identical function calls from the call information table 5 to generate a batch function information table 6. The batch call information table generation processing 23 includes a homomorphic call extraction processing 230 that extracts information on the same function call, a batch call extraction processing 231 that extracts calls that can be batch-called from the same-type call set, and batches the extracted batch calls. It consists of a batch call information table registration process 232 to be registered in the call information table. Each process will be described in detail with reference to FIGS.
[0012]
Next, a collective function generation process 24 generates a collective function 3 after the middle based on the collective function information table 7.
Finally, the function call in the intermediate language 3 is converted into a batch function call based on the batch call information table 6 by the batch call conversion process 25.
[0013]
FIG. 4 is a processing configuration diagram showing the relationship between the function call batching related processing shown in FIG. 3 and intermediate words and tables as input / output. However, since the intermediate language 3 is generally referred to, only the main input / output relationships are shown.
The function information table generation process 21 receives the intermediate language 31 before calling a batch function as an input, and generates a function information table 4 storing function definition information. The function information table 4 includes a function table 41 that stores a list of functions, and a temporary parameter table 42 that stores information on a dummy argument and a temporary return number serving as a function interface.
The call information table generation process 22 receives the pre-call intermediate language 31 and generates a call information table 5 storing function call information. The call information table 5 includes a call table 51 that stores a list of function calls, and an actual parameter table 52 that stores information on actual arguments and actual return numbers serving as function call interfaces.
[0014]
The batch call information table generation processing 23 receives the call information table 5 and receives a batch call information table 6 that stores information on function calls that can be batch-called, and a batch function that stores information on function definitions to be collectively called. An information table 7 is generated. The batch call information table 6 includes a batch call table 61 that stores a list of calls that can be batch-called, and an actual parameter table 62 that stores information on actual arguments and the number of actual returns serving as a batch call interface. Similarly, the collective function information table 7 includes a collective function table 71 that stores a list of function definitions to be collectively called, and a formal parameter table 72 that stores information on dummy arguments and provisional numbers that serve as an interface for the collective function. Become.
[0015]
The batch function generation process 24 receives the intermediate language 31 before batch calling and the batch function information table 7 as input, and generates a batch function in the intermediate language 32 after batch calling.
The batch call conversion processing 25 receives the intermediate language 31 before batch calling and the batch call information table 6 as input, converts the function call of the intermediate language 31 before batch calling into a batch function call, and performs the intermediate language 32 after batch calling. To generate.
[0016]
Next, in order to explain a specific application example, an example of a source program to be processed is given.
FIG. 5 is an example of a source program (an example of a program written in C language) for explaining an embodiment of the present invention.
In this embodiment, the intermediate language 3 has information equivalent to that of the source program and does not need to be in the form of an intermediate language. Therefore, in the example of the intermediate language 3, it is described in the form of a source program. Therefore, FIG. 5 is an example of the source program and also an example of the intermediate language 31 (before the batch call).
Further, as described in the description of FIG. 2, in this embodiment, loop expansion (essentially unnecessary) is performed. In FIG. 5, loop expansion is not applied, but it can also be applied without loss of generality when a call to the same function is generated after loop expansion.
In the example of the program shown in FIG. 5, there are three functions f, g, and main. The function main calls the function g once, and the function g calls the function f twice. Calling the function f on lines 17 and 20 is a function that can be called collectively.
[0017]
FIG. 6 shows an example of a source program after the batch function call with respect to the source program example of FIG. 5, and corresponds to the intermediate language 32 after the batch function call. In FIG. 6, a collective function F that was not shown in FIG. 5 is newly generated (from line 30 to line 36). In FIG. 5, the function g called the function f twice, but in FIG. Performs processing equivalent to two calls of function f The batch function F is called once (16 lines). That is, this is an example of the result of performing batch call conversion by converting two calls of the function f into one call of the batch function F.
[0018]
Hereinafter, details of the batch function call processing 2 will be described.
In the description, the intermediate language in FIG. 5 is used as an input example, and output examples of various tables are sequentially shown. Therefore, first, a configuration example of various tables will be described, and then a processing procedure will be described.
Hereinafter, configuration examples of the function information table 4, the call information table 5, the collective call information table 6, and the collective function information table 7 will be described in this order.
[0019]
FIG. 7 is a configuration example of the function table 41 obtained for the example of FIG.
In the function table, an entry is created for each function definition that appears in the program. Each function is given a unique function number, and each entry can be accessed by the function number. Each entry includes a function number column 411, a function name column 412, a definition line number column 413, a provisional return number column 414, a formal argument set column 415, and a call set column 416.
[0020]
The function number column 411 stores the entry number of the function table, and the function name column 412 stores the name of the corresponding function.
The definition line number column 413 stores function definition information in the intermediate language 3 of the function. With this definition line number column, all information of the corresponding function definition can be obtained. For example, it is possible to acquire various interface information of a function and read / copy the function definition body. In this embodiment, as shown in FIG. 7, the line numbers of the source program are shown.
The temporary return number column 414 and the temporary argument set column 415 store the temporary return number and the dummy argument information of the function in the form of entry numbers in the temporary parameter table 42.
In the call set column 416, information on function calls existing in the function is stored in the entry number format of the call table 51.
[0021]
FIG. 8 is a configuration example of the temporary parameter table 42 obtained for the example of FIG.
The temporary parameter table is an auxiliary table for storing the function interface information of the function table 41. An entry is created for each temporary return number or dummy argument, and the entry number is stored in the temporary return number column or dummy argument set column of the function table 41.
Each entry includes a temporary parameter number column 421, a temporary parameter position number column 422, a temporary parameter type column 423, and a temporary parameter variable column 424.
[0022]
The temporary parameter number field 421 stores the entry number of the temporary parameter table.
In the temporary parameter position number field 422, the appearance position of the temporary parameter is indicated by a number. The position number of the temporary return number is 0, and the i-th dummy argument is the position number i.
The temporary parameter type field 423 stores temporary parameter type information.
The temporary parameter variable column 424 stores the name of the corresponding temporary parameter.
[0023]
FIG. 9 is a configuration example of the call table 51 obtained for the example of FIG.
An entry is created in the call table for each function call that appears in the program. Each entry includes a call number column 511, a call line number column 512, a call function number column 513, an actual return number column 514, and an actual argument set column 515.
[0024]
The call number column 511 stores the entry number of the call table, and the call line number column 512 stores the line number of the corresponding function call.
The call function number column 513 stores the function number of the function table 41 for the function called by the call.
The actual return number column 514 and the actual argument set column 515 store the actual return number and actual argument information of the call in the form of entry numbers in the actual parameter table 52.
[0025]
FIG. 10 is a configuration example of the actual parameter table 52 obtained for the example of FIG.
The actual parameter table is an auxiliary table for storing call interface information of the call table 51. An entry is created for each actual return number or actual argument, and the entry number is stored in the actual return number column or actual argument set column of the call table 51. Each entry includes an actual parameter number field 521, an actual parameter position number field 522, and an actual parameter expression field 522.
[0026]
The actual parameter number column 521 stores the entry number of the actual parameter table.
In the actual parameter position number column 522, the appearance position of the actual parameter is indicated by a number. The position number of the actual return number is 0 (similar to the temporary parameter position number field 422 of the temporary parameter table 42), and the i-th actual argument is the position number i.
The actual parameter expression field 523 stores the name of the corresponding actual parameter.
[0027]
FIG. 11 is a configuration example of the collective call table 61 obtained for the example of FIG.
In the batch call table, an entry is created for each (batch) call of a batch function. Each entry includes a batch call number column 611, a generation source call set column 612, a batch function number column 613, an actual return number column 614, an actual return type column 615, an actual return number set column 616, and an actual argument set column 617. Composed.
[0028]
The batch call number column 611 stores the entry number of the batch call table.
In the generation call set column 612, a set of calls to be collectively called is stored in the entry number format of the call table 51.
In the batch function number column 613, a batch function called by the batch call is stored as an entry number (batch function function number) of the batch function table 71.
The actual return number column 614 and the actual return type column 615 store the return name and return type.
The actual return number column 616 and the actual argument set column 617 store the actual return number and actual argument information of the batch call in the form of the entry number of the batch actual parameter table 62.
[0029]
FIG. 12 is a configuration example of the collective actual parameter table 62 obtained for the example of FIG.
The collective actual parameter table is an auxiliary table for storing the call interface information of the collective call table 61. An entry is created for each actual return number or actual argument, and the entry number is stored in the actual return number column or actual argument set column of the batch call table 61. Each entry includes a collective actual parameter number column 621, a collective actual parameter position number column 622, a generation source actual parameter number column 623, a pre-conversion name column 624, and a post-conversion name column 625.
[0030]
The batch actual parameter number field 621 stores the entry number of the batch call actual parameter table.
In the collective actual parameter position number column 622, the appearance position of the actual parameter is indicated by a number.
In the generation call set column 623, calls to be batched are stored in the form of a set of entry numbers in the call table 51.
The pre-conversion name column 724 stores the actual parameter name in the generation source call, and the post-conversion name column 725 stores the (collective) actual parameter name after the batch call. The pre-conversion name field 724 and the post-conversion name field 725 are fields that are valid only for the actual return number (the actual argument is always blank).
[0031]
FIG. 13 is a configuration example of the collective function table 71 obtained for the example of FIG.
In the batch function table, an entry is created for each function that generates a batch function. Each function is given a unique batch function number, and each entry can be accessed by the batch function number. Each entry includes a batch function number column 711, a batch function name column 712, a batch coefficient factor column 713, a generation function number column 714, a provisional return type column 715, a provisional return number name column 716, a provisional return number set column 717, It consists of a dummy argument number set column 718.
[0032]
In the batch function number column 711, the entry number of the batch function table,
The collective function name column 712 stores the name of the collective function to be generated.
The batching coefficient column 713 stores the number of calls to be batched.
In the generation function number column 714, functions to be grouped are stored in the function number format of the function table 41.
The provisional return type column 715 and provisional return number name column 716 store the return type and return number name.
The temporary return number column 717 and the temporary argument set column 718 store the temporary return number and dummy argument information of the batch function in the form of the entry number of the batch temporary parameter table 72.
[0033]
FIG. 14 is a configuration example of the collective temporary parameter table 72 obtained for the example of FIG.
The batch temporary parameter table is an auxiliary table for storing the function interface information of the batch function table 71. An entry is created for each temporary return number or dummy argument, and the entry number is stored in the temporary return number set column or dummy argument set column of the batch function table 71. Each entry includes a batch temporary parameter number column 721, a generation source temporary parameter number column 722, a batch temporary parameter position number column 723, a repetition number column 724, a pre-conversion name column 725, and a post-conversion name column 726.
[0034]
The batch temporary parameter number field 721 stores the entry number of the batch temporary parameter table.
In the generation source temporary parameter number column 722, the corresponding temporary parameter of the generation source function is stored in the format of the temporary parameter number in the temporary parameter table 42.
In the batch temporary parameter position number column 723, the appearance position of the temporary parameter is indicated by a number. In the batch temporary parameter position number, the temporary return number and the dummy argument are counted independently, and the i-th temporary return number / the dummy argument is the position number i.
[0035]
The iteration number column 724 stores the number of the temporary function parameter at the time of batching. This repetition number starts counting from 0, and when the batching coefficient is n, numbers up to n-1 are given.
The pre-conversion name field 725 stores a temporary parameter name in the generation source function, and the post-conversion name field 726 stores a (collective) temporary parameter name after batch function conversion.
This is the end of the description of various table configurations used in this embodiment.
[0036]
Hereinafter, various processes for generating / referencing these tables will be described in order.
FIG. 15 is a flowchart of the function information table generation process 21. In the function information table generation process, the intermediate language 3 is sequentially scanned, and when a function definition is detected, a function information table 4 in which the function definition information is collected and registered is generated. The procedure will be described below.
[0037]
First, the function number fi and the temporary parameter number fpi are initialized with 0 (step 1501).
Next, it is determined whether or not there is an unprocessed function (step 1502), and the processing after step 1503 is performed until there is no unprocessed function.
If there is an unprocessed function f, first, a function entry F is generated, and the function number fi is incremented (step 1503). Thereafter, the function information of the function f is stored in the function entry F in step 1504 and subsequent steps.
[0038]
First, the definition line number of f is set to fl, and the function name is set to fn (step 1504). Next, in order to obtain a temporary parameter set FPS, the FPS is initialized with an empty set (step 1505). Then, it is determined whether or not there is an unprocessed temporary parameter (step 1506), and processing from step 1507 is performed until there is no unprocessed temporary parameter.
If there is an unprocessed temporary parameter fp, a temporary parameter entry FP is generated and the temporary parameter number fpi is incremented (step 1507).
[0039]
Next, the temporary parameter information of fp is stored in the temporary parameter table 42 (step 1508), and the entry number fpi is added to the temporary parameter set FPS (step 1509). Thereafter, step 1506 to step 1509 are repeatedly executed until there is no unprocessed temporary parameter. Step 1508 stores temporary parameter information, temporary parameter number, temporary parameter position, temporary parameter type, temporary parameter type, and temporary parameter name in the entry FP, but details are omitted (in the temporary parameter table 42 of FIG. 8). See description).
[0040]
When the determination in step 1506 becomes no, collection of the temporary parameter set FPS ends, so all function information is stored in F (step 1510), and the next unprocessed function determination (step 1502) is performed. The process ends when all functions have been processed.
[0041]
7 and 8 are examples of function information tables indicating the results of performing the above processing on the source program shown in FIG.
For example, the entry 417 stores information on the function f defined in lines 003 to 008 in FIG. Further, it can be seen from the provisional return number column that there is a provisional return number having the name r, the provisional parameter position 0 (= provisional return number), and the provisional parameter type int.
[0042]
FIG. 16 is a flowchart of the call information table generation process 22.
In the call information table generation process, the intermediate language 3 is sequentially scanned, and when a function call is detected, a call information table 5 that collects and registers the call information is generated. The procedure will be described below.
[0043]
First, the call number ci and the actual parameter number api are initialized with 0 (step 1601).
Next, it is determined whether or not there is an unprocessed function (step 1602), and the processing from step 1603 is performed until there is no unprocessed function.
If there is an unprocessed function f, first, the function entry is set to F (step 1603), and the call set CS is initialized with an empty set (step 1604).
Next, it is determined whether or not there is an unprocessed function call in f (step 1605), and if it exists, call information is registered in step 1606 and subsequent steps.
In registering the call information, first, a call entry C is generated, and the call number ci is incremented (step 1606).
Next, the call line number cl and the call function number fi are obtained (step 1607). The call function number fi can be easily obtained by searching the function information table 41 (if it does not exist in the function information table, it is left blank and excluded from the target of batching).
[0044]
Next, in order to obtain the actual parameter set APS, the APS is initialized with an empty set (step 1608). Then, it is determined whether or not there is an unprocessed actual parameter (step 1609), and processing from step 1610 is performed until there is no unprocessed actual parameter.
That is, if there is an unprocessed actual parameter ap, an actual parameter entry AP is generated, the actual parameter number api is incremented (step 1610), and the actual parameter information of ap is stored in the actual parameter table 52 (step 1611). The entry number api is added to the actual parameter set APS (step 1612). In step 1611, the actual parameter number, the actual parameter position number, and the actual parameter expression, which are actual parameter information, are stored in the entry AP, but the details are omitted (see the description of the actual parameter table 52 in FIG. 14).
[0045]
Since the collection of the actual parameter set APS ends when the determination in step 1609 becomes no, all call information is stored in C (step 1613). (The actual parameter set APS combines the actual return number and the actual argument. Stored in the actual return number field and the actual argument field of the call information table). Then, ci is added to CS (step 1614), and the next unprocessed call determination (step 1605) is performed. Since all calls in the function f have been processed when the determination in step 1605 becomes no, CS is stored in the call set column of F (step 1615), and the next unprocessed function is determined (step 1602). Proceed to The process ends when all functions have been processed.
[0046]
9 and 10 are examples of the call information table 5 indicating the result of performing the above processing on the example of the source program of FIG. For example, the entry 516 in FIG. 9 stores the call information of the function f on the 17th line. In this call, (p * p, q * q) is passed as an actual argument, and the return value is stored in the actual return number r1.
[0047]
FIG. 17 is a flowchart of the batch call information table generation process 23.
The batch call information table generation process sequentially scans the call information table 51 and, when a call that can be batch-called is detected, generates a batch call information table 6 and a batch function information table 7 that collect and register the batch call information. To do. The procedure will be described below.
[0048]
First, the batch call number aci, the batch actual parameter number aapi, the batch function number afi, and the batch actual parameter number afpi are initialized to 0 (step 1701). Next, it is determined whether or not there is an unprocessed function entry (step 1702), and the processes in and after step 1703 are performed until there is no unprocessed function entry.
If there is an unprocessed function entry F, first, the call set is set as CS (step 1703).
[0049]
Next, the process proceeds to extraction processing (from step 1704 to step 1711) of the same type call set SCS which is a set of calls of the same function from CS. This extraction process of the isomorphic call set SCS corresponds to step 230 in FIG.
First, CS is stored in the work set WCS, and the SCS is initialized with an empty set (step 1704).
Next, it is determined whether or not there is an unprocessed call entry C in the CS (step 1705). If there is a call entry C, the call number ci and call function number fi of C are obtained (step 1706). ci is excluded (step 1707).
Next, it is determined whether or not there is an unprocessed entry WC in the WCS (step 1708), and if it exists, the WC call number wci and call function number wfi are obtained (step 1709).
Then, it is checked whether the same function is called by determining whether fi and wfi match (step 1710). If the functions are the same, wci is added to the SCS (step 1711) and the process proceeds to step 1708.
[0050]
When the elements of all work call sets are determined in step 1708, the extraction of the isomorphic call set SCS is completed.
Here, it is determined whether or not the SCS has a plurality of elements (step 1712). Only when there are a plurality of SCSs, collective call information extraction processing (step 231; see FIG. 18 for details) is executed, and step 1705 is performed. Thereafter, the process proceeds to the next isomorphic call set SCS.
When all entries have been processed in step 1705, the process proceeds to step 1702 to process the next function entry.
When all the function entries have been processed, the batch call information table generation process ends.
[0051]
FIG. 18 is a flowchart of the batch call information extraction process 231. In the batch call information extraction process, a batch call set ASCS obtained by collecting calls that can be batch-called is extracted from the given same-type call set SCS, and a batch call information table 6 and a batch function information table 7 are generated. The procedure will be described below.
First, it is determined whether or not there is an unprocessed call entry SC in the SCS (step 1801), and if it exists, the C call number sci is obtained (step 1802).
Next, the SCS is stored in the work set WSCS, the ASCS is initialized with an empty set (step 1803), and then sci is removed from the WSCS (step 1804).
Next, it is determined whether or not there is an unprocessed entry WSC in the WSCS (step 1805), and if it exists, the call number wsci of the WSC is acquired (step 1806).
[0052]
Then, it is determined whether sci and wsci can be collectively called (step 1807). If yes, wsci is added to ASCS (step 1808). The possibility of batch call is determined based on whether the call of wsci can be moved to the position of the call line number of sci or the like, but the details are omitted because it is not directly related to the present invention.
Thereafter, the process proceeds to step 1805 to examine the next WSC element.
When the elements of all work call sets WSCS are determined in step 1805, the extraction of the batch call set ASCS is completed.
Here, it is determined whether or not the ASCS has a plurality of elements (step 1809), and the batch call information registration process (step 232, see FIG. 19 for details) is executed only when there are a plurality of elements.
Next, ASCS is removed from the SCS (step 1810), and the process proceeds to the processing of the elements of the next isomorphic call set SCS after step 1801.
When all entries have been processed in step 1801, the batch call information extraction processing is terminated.
[0053]
FIG. 19 is a flowchart of the batch call information registration process 232. In the batch call information registration process, the batch call information table 6 and the batch function information table 7 are generated from the given batch call set ASCS. The procedure will be described below.
First, a batch call entry AC is created, aci is incremented (step 1901), and then ASCS is stored in the AC generation source call set column (step 1902).
Next, the call function number (of any element) of ASCS is ci and the number of elements is afk (step 1903).
Then, a type art as a variable is generated from the ASCS (step 1904), and stored in the return type column of the AC (step 1905). Although art is an array type in this embodiment, any type may be used as long as it can represent all the return numbers of the generation call set. Since the generation method is not essential to the present invention, details are omitted.
[0054]
Next, a unique name acn is generated and stored in the AC actual return name column (step 1906), and then a batch call actual argument registration process (step 233, details are shown in FIG. 20), a batch call actual return number registration process ( Step 234. Details are performed as shown in FIG.
[0055]
Next, registration to the batch function information table is performed.
First, a batch function entry AF is created, and afi is incremented (step 1911).
Next, art is stored in the AF return type column (step 1912).
Next, a unique name afn is generated and stored in the AF temporary return name column (step 1913), and then afk is stored in the batch coefficient column (step 1914).
Finally, a batch function dummy argument registration process (step 235, details are shown in FIG. 22) and a batch function temporary return number registration process (step 236, details are shown in FIG. 23) are performed to complete registration in the batch function information table.
Since the registration into the batch call information table and the batch function information table is completed, the batch call information registration process is terminated.
[0056]
FIG. 20 is a flowchart of the collective call actual return number registration process 233. In the batch call actual return number registration process, the batch actual parameter table 62 is generated from the source call set in each entry of the batch call table and registered in the batch call actual return number set column 616 of the batch call table 61. The procedure will be described below.
First, the batch call actual return number set AARS is initialized with an empty set (step 2001). The batch call actual return number position number aapr is also initialized to 0 (step 2002).
[0057]
Then, the generation call source set of AC is set as ACS (step 2003), and it is determined whether there is an unprocessed call C in the ACS (step 2004). If there is, the steps 2005 to 2013 are repeatedly executed.
In this iterative process, an actual return number set of C is set to ARS (step 2005), it is determined whether there is an unprocessed actual return number AR in the ARS (step 2006), and if there is, step 2007 to step 2012 are performed. Run repeatedly.
In this iterative process, first, aapr is incremented (step 2007).
Next, the actual parameter number and name of AR are set to ari and arn, respectively (step 2008).
Next, a collective call actual return number name aarn is generated (step 2009).
Next, a batch call actual parameter entry AAP is generated, and aapi is incremented (step 2010).
[0058]
Next, the batch call actual return number information is registered in the AAP (step 2011), and aari is added to the AARS (step 2012).
When the result of determination in step 2006 is no, the processing of all the actual return numbers is completed. Therefore, after the AARS is stored in the AC collective call actual return number set column (step 2013), the next ACS process is performed.
When all the call entries of ACS have been processed, the batch call actual return number registration process 233 ends.
[0059]
FIG. 21 is a flowchart of the batch call actual argument registration process 234. In the batch call actual argument registration process, the batch actual parameter table 62 is generated from the source call set in each entry of the batch call table and registered in the batch call actual argument set column 617 of the batch call table 61. The procedure will be described below.
[0060]
First, the batch call actual argument set AAAS is initialized with an empty set (step 2101). The batch call actual argument position number aapa is also initialized with 0 (step 2102).
Then, the generation call source set of AC is set as ACS (step 2103), and it is determined whether there is an unprocessed call C in the ACS (step 2104). If there is, the steps 2105 to 2113 are repeatedly executed.
In this iterative process, the actual argument set of C is set to APS (step 2105), it is determined whether there is an unprocessed actual argument AP in the APS (step 2106), and if there is, the process from step 2107 to step 2112 is repeated. Execute.
In this iterative process, first, aapa is incremented (step 2107).
[0061]
Next, the actual parameter number and name of the AP are set to api and apn, respectively (step 2108).
Next, a batch call actual argument name aapn is generated (step 2109).
Next, a batch call actual parameter entry AAP is generated, and aapi is incremented (step 2110).
Next, the batch call actual argument information is registered in the AAP (step 2111), and then aapi is added to the AAAS (step 2112).
When the determination in step 2106 is no, processing of all actual arguments is completed, so AAAS is stored in the AC batch call actual return number column (step 2013), and then the next ACS processing is performed.
When all the ACS call entries have been processed, the batch call actual argument registration process 234 ends.
[0062]
11 and 12 are examples of the collective call information table 6 that shows the results of performing the processes of FIGS. 20 and 21 with the call information table 5 shown in FIGS. 9 and 10 as an input.
For example, entry 618 in FIG. 11 indicates that calls of entry 516 and entry 517 of call table 51 shown in FIG. 9 can be collectively called. In this batch call, it is understood that (p * p, q * q, p * q, q * p) is passed as an actual argument, and the return value is stored in the actual return number arf that is an array of type int. .
[0063]
FIG. 22 is a flowchart of the batch function temporary return number registration process 235. In the batch function temporary return number registration process, the batch temporary parameter table 72 is generated from the source function number and the batching coefficient in each entry of the batch function table, and the batch function temporary return number set column 717 of the batch function table 71 is entered. register. The procedure will be described below.
First, the batch function temporary return number set AFRS is initialized with an empty set (step 2201). The batch function temporary return position number afpr is also initialized to 0 (step 2202).
Next, the AF batching coefficient is afk, and the AF source function entry is F (step 2203. Both have already been calculated in the batch call regular registration process).
Further, after initializing the number of iterations i to 0 (step 2204), it is determined whether i is equal to afk (step 2205), so that steps i2206 to 2212 are repeatedly executed until i becomes equal to afk. .
In this iterative process, first, i is incremented (step 2206).
Next, afpr is incremented (step 2207).
[0064]
Next, the temporary parameter number and name of AF are set to fpi and fpn, respectively (step 2208).
Next, a batch function temporary return name apfn is generated (step 2209).
Next, a batch function formal parameter entry AFP is generated, and afpi is incremented (step 2210).
Next, the batch function temporary return number information is registered in the AFP (step 2211), and afpi is added to the AFRS (step 2212).
When the determination in step 2205 is no, AFRS is stored in the AF batch function provisional number set column (step 2213), and the batch function provisional number registration process 235 ends.
[0065]
FIG. 23 is a flowchart of the batch function dummy argument registration process 236. In the batch function dummy argument registration process, a batch temporary parameter table 72 is generated from the source function number and batching coefficient in each entry of the batch function table and registered in the batch function dummy argument set column 718 of the batch function table 71. . The procedure will be described below.
First, the batch function dummy argument set AFAS is initialized with an empty set (step 2301). The batch function dummy argument position number afpa is also initialized to 0 (step 2302).
Next, the AF batching coefficient is afk, and the AF source function entry is F (step 2303. Both have already been calculated in the batch call regular registration process).
[0066]
Further, after initializing the number of iterations i to 0 (step 2304), it is determined whether i is equal to afk (step 2305), so that steps 2306 to 2315 are repeatedly executed until i becomes equal to afk. .
In this iterative process, first, i is incremented (step 2206). Next, the F parameter set of F is set to FAS (step 2307), and it is determined whether there is an unprocessed dummy parameter FA in the FAS (step 2308). If there is, the steps 2309 to 2314 are repeatedly executed. .
In this iterative process, first, afpa is incremented (step 2309).
Next, the temporary parameter number and name of AF are set to fpi and fpn, respectively (step 2310).
[0067]
Next, a collective function formal argument name apfn is generated (step 2311).
Next, a batch function formal parameter entry AFP is generated, and afpi is incremented (step 2312).
Next, the batch function dummy argument information is registered in the AFP (step 2313), and afpi is added to the AFAS (step 2314).
When the determination in step 2308 results in no, the processing of all dummy arguments is completed, so AFAS is stored in the AF batch function dummy argument set column (step 2315).
Perform the next iteration.
The batch function formal argument registration process 236 ends when the batch coefficient is repeatedly executed until i and afk match.
[0068]
FIGS. 13 and 14 are examples of the collective function information table 7 showing the results of performing the processes of FIGS. 17 to 23 with the function information table 4 and the call information table 5 shown in FIGS. 7 to 10 as inputs. It has become.
For example, the entry 719 in FIG. 13 indicates that the entry 417 in the function table 41 shown in FIG. This batch function is passed (x0, y0, x1, y1) as a dummy argument, and returns a temporary return number frf that is an array of type int.
This is the end of the description of the batch call information table generation process 23.
After the batch call information table generation process 23, a batch function generation process 24 and a batch call conversion process 25 are performed. This will be described in order below.
[0069]
FIG. 24 is a flowchart of the batch function generation process 24.
The batch function generation process generates a batch function in the intermediate language 3 from each entry of the batch function information table 7. The procedure will be described below.
It is checked whether or not there is an unprocessed batch function entry AF (step 2401), and the processing from step 2402 is performed on all existing batch function entries.
First, it is assumed that the AF generation function number is fi, and the AF batch coefficient is afk (step 2402).
Next, a batch function provisional number definition is generated from the AF provisional number set AFRS (step 2403).
Next, a batch function dummy argument definition is generated from the AF dummy argument set AFAS (step 2404).
Thus, generation of the batch function call interface is completed. Next, in step 2406 to step 2413, a batch function body is generated.
[0070]
First, after the definition section iteration count m is initialized to 0 (step 2405), the definition section FB of fi is copied (step 2406).
Next, the temporary parameters in the copied area FB are converted.
First, the union set of the AF temporary return number set AFRS and the dummy argument set AFAS is set as a batch function temporary parameter set AFPS (step 2407).
It is determined whether or not there is an unprocessed temporary parameter entry AFP in the AFPS (step 2408). If it exists, the temporary parameter is converted in step 2409 and subsequent steps.
[0071]
First, the pre-conversion name of AFP is bcn, and the post-conversion name is acn (step 2409).
Next, after the name bcn appearing in the FB is converted to acn (step 2410), the process proceeds to step 2408 to convert the next formal parameter.
When all the AFPS elements have been processed, m is incremented (step 2411), and it is determined whether or not it matches the batch coefficient afk (step 2412).
If not, the process proceeds to step 2406 and is repeatedly executed. If m matches afk, a batch function temporary return is generated using the AF temporary return name (step 2413). Perform batch function entry processing.
When all the batch function entry processes have been completed, the batch function generation process ends.
[0072]
FIG. 6 is an example of an intermediate language (in the source program format) showing the result of performing the processing of FIG. 24 using the collective function information table 7 shown in FIGS. 13 and 14 as an input. The batch function indicated by the entry 719 in FIG. 13 is generated from the 30th line to the 36th line in FIG. Line 32 generates a batch function provisional return number definition, and line 35 generates a batch function provisional return number.
[0073]
FIG. 25 is a flowchart of the batch call conversion process 25.
The batch call conversion processing uses the batch call information table 6 to convert batchable isomorphic calls in the intermediate language 3 into batch calls. The procedure will be described below.
It is checked whether or not there is an unprocessed batch call entry AC (step 2501), and the processing from step 2502 is performed on all existing batch call entries.
First, a batch call actual return number definition is generated from the AC actual return number name (step 2502).
Next, it is assumed that the generation call set of AC is CS and the actual return number set of AC is AAPS (step 2503).
Next, an arbitrary element C of CS is taken out and the call function number fi is acquired (step 2504).
[0074]
Next, the batch call generation position acp is determined from the call line number of C (step 2505). The collective call generation position may be anywhere as long as it is guaranteed by the determination of the possibility of collective call. In this embodiment, for convenience, it is set immediately before the first call position.
Next, a batch call is created from the AC and generated in an acp (step 2506). The batch call can be easily created by the batch call actual return number name, the batch function number, and the batch call actual argument set, and the details are omitted.
Next, it is determined whether or not there is an unprocessed call entry C in the CS (step 2507), and if it exists, the call is deleted by looking at the call line number of C (step 2508).
[0075]
When all calls of CS are deleted, it is determined whether or not there is an unprocessed batch call actual argument entry AAR in AARS (step 2509). If there is, conversion of the actual return number is performed in steps 2510 to 2511. I do.
The name of AAR before conversion is bcn, the name after conversion is acn (step 2510), and bcn that appears in the function body area of fi is converted to acn (step 2511).
When the determination in step 2509 is no, the conversion of all the batch call actual return numbers is completed, and the conversion process for AC is completed.
Thereafter, the process proceeds to step 2501 to perform batch call conversion processing of the next batch call entry.
When all the batch call entries have been processed, the batch call conversion process ends.
[0076]
FIG. 6 is an example of an intermediate language (in the source program format) showing the result of performing the processing of FIG. 25 using the collective call information table 6 shown in FIGS. 13 and 14 as an input.
The two function calls of lines 17 and 21 in FIG. 5 are converted into a batch call of 16 lines in FIG. In line 14, a batch call actual return number definition is generated.
According to this embodiment, it is possible to reduce the call overhead by reducing the number of function calls, which contributes to the improvement of the processing performance of the object program.
[0077]
FIG. 26 shows the processing procedure of the compiler according to another embodiment of the present invention. FIG. 26 shows a compiler processing procedure common to the second embodiment in which a batch function is called during loop expansion and the third embodiment in which a batch function is called during loop parallelization.
Since the syntax analysis 201 and the code generation process 203 are the same as those in the figure, description thereof is omitted.
Loop expansion or loop parallelization and batch function call processing 205 receives 3 after the middle, and performs loop expansion / loop parallelization that repeats serial processing in parallel / loop parallel processing, and intermediate language 3 subjected to batch function call conversion is obtained. Output. The case of loop expansion is the second embodiment, and the case of loop parallelization is the third embodiment. Since most of the processing and the table configuration are the same as in the first embodiment, only the outline will be described below.
[0078]
FIG. 27 is a flowchart showing the processing procedure of step 205 in FIG. 26 when the batch function is called at the time of loop expansion according to the second embodiment of the present invention. This will be described in order below.
First, the function information table generation process 2701 extracts various information of the function definition in the source program, and creates the function information table 4.
Next, it is determined whether or not an unprocessed loop L exists (step 2702). If there is an unprocessed loop L, steps 2703 to 2710 are repeatedly executed.
In this iterative process, it is first determined whether or not L can be loop-expanded (step 2704), and if it exists, step 2705 to step 2710 are repeatedly executed.
[0079]
In this iterative process, L is first loop expanded n times (step 2704).
Next, call information table generation processing (step 2705) is performed, information related to function calls is extracted, and the call information table 5 is generated.
Next, n calls of the same function generated by loop expansion from L are defined as an isomorphic call set SCS (step 2706).
Next, a batch call extraction process (step 2707) for extracting calls that can be batch-called from the same type call set SCS is performed (step 2707), and the extracted batch calls are registered in the batch call information table (step 2708).
When the answer is no in step 2702, the processing is completed for all the loops, batch function generation processing (step 2709) and batch call conversion processing (step 2710) are performed, and the processing ends.
[0080]
The correspondence between the steps of FIG. 27 and the steps of FIG. 3 is shown below. The processing content of each step below is the same processing as the step of FIG. 3 shown in parentheses.
Step 2701 (Step 21 in FIG. 3)
Step 2705 (Step 22 in FIG. 3)
Step 2709 (Step 231 in FIG. 3)
Step 2710 (Step 232 in FIG. 3)
Step 2711 (Step 24 in FIG. 3)
Step 2712 (Step 25 in FIG. 3)
[0081]
FIG. 28 shows an example of a source program for explaining the second and third embodiments of the present invention. Also in this embodiment, it is described in the form of an intermediate language 3 source program. Therefore, FIG. 28 is an example of a source program and also an example of the intermediate language 31 (before the collective call). In the program example of FIG. 28, there is a loop that calls the function f on the 16th to 22nd lines of the function g.
[0082]
FIG. 29 is a representation of the intermediate language 3 at the stage of loop expansion in step 2704 of FIG. 27 in a source program format. A loop including function calls on lines 16 to 22 in FIG. 28 is expanded from lines 16 to 22 in FIG.
[0083]
FIG. 30 represents the intermediate language 3 as a result of performing the processing of FIG. 26 with the source program of FIG. 27 as an input, in the source program format. In FIG. 29, the call of the function f during the loop expansion from the 16th line to the 22nd line is made into a batch function call.
According to this embodiment, since the batch function call is performed at the time of loop expansion, efficient batch function call according to the number of loop expansions can be performed.
[0084]
FIG. 31 is a flowchart showing the processing procedure of step 205 in FIG. 26 in the case of performing a batch function call during loop parallelization according to the third embodiment of the present invention. Since this processing procedure is almost the same as that in FIG. 27, a description thereof will be omitted (steps 3104 and 3106 are slightly different).
[0085]
FIG. 32 shows the intermediate language 3 at the stage where the loop is parallelized in step 2704 of FIG. 30 in a source program format. The notation “x || y;” on lines 18 and 19 in FIG. 32 indicates that x and y are executed in parallel. It can be seen that the loop including the function call from the 16th line to the 22nd line in FIG. 28 is loop-parallelized from the 16th line to the 21st line in FIG.
[0086]
FIG. 33 represents the intermediate language 3 as a result of performing the processing of FIG. 30 with the source program of FIG. 27 as an input, in a source program format. It can be seen that the call to the function f during the loop parallelization from the 16th line to the 22nd line in FIG. 31 is a batch function call.
According to the present embodiment, since the batch function call is performed at the time of loop parallelization, efficient batch function call according to the parallel degree of the loop can be performed.
[0087]
【The invention's effect】
According to the present invention, the compiler or the source conversion program can convert a call of the same function into a call of a batch function. In other words, a means for reducing call overhead that does not depend on inline expansion is provided. ,
As a result, even when inline expansion cannot be applied, it is possible to reduce the call overhead and contribute to the improvement of the processing performance of the object program.
[Brief description of the drawings]
FIG. 1 is a configuration diagram of a computer system in which a compiler that implements the present invention operates.
FIG. 2 is a flowchart showing a processing procedure of a compiler implementing the present invention.
FIG. 3 is a flowchart of batch function call processing 2 of a compiler.
FIG. 4 is a processing configuration diagram of compiler batch function call processing 2 according to the present invention;
FIG. 5 is an example of a source program (a configuration example of the intermediate language 31 before calling a batch function in a source program format).
FIG. 6 is a configuration example of the intermediate language 32 after the batch function call in the source program format.
7 is a configuration example of a function table 41. FIG.
8 is a configuration example of a temporary parameter table 42. FIG.
9 is a configuration example of a call table 51. FIG.
10 is a configuration example of an actual parameter table 52. FIG.
11 is a configuration example of a collective call table 61. FIG.
12 is a configuration example of a collective actual parameter table 62. FIG.
13 is a configuration example of a batch function table 71. FIG.
14 is a configuration example of a collective temporary parameter table 72. FIG.
15 is a flowchart of function information table generation processing 21. FIG.
16 is a flowchart of a call information table generation process 22. FIG.
FIG. 17 is a flowchart of batch call information table generation processing 23;
FIG. 18 is a flowchart of batch call information extraction processing 231;
FIG. 19 is a flowchart of batch call information registration processing 232;
FIG. 20 is a flowchart of batch call actual return number registration processing 233;
FIG. 21 is a flowchart of batch call actual argument registration processing 234;
FIG. 22 is a flowchart of a batch function temporary return number registration process 235;
FIG. 23 is a flowchart of a batch function formal argument registration process 234;
24 is a flowchart of a batch function generation process 24. FIG.
FIG. 25 is a flowchart of batch call conversion processing 25;
FIG. 26 shows the processing procedure of the compilers of the second and third embodiments.
FIG. 27 is a flowchart of a loop expansion batch function calling process;
FIG. 28 is an example of a source program for explaining the second and third embodiments.
FIG. 29 is a configuration example of an intermediate language source program format after loop expansion;
FIG. 30 is a configuration example of the intermediate language source program format after the loop expansion batch function call conversion.
FIG. 31 is a flowchart of batch function call processing for loop parallelization;
FIG. 32 is a configuration example of the intermediate language 3 after the loop expansion in the source program format;
FIG. 33 is a configuration example of the intermediate language in a source program format after the conversion into a batch function for loop parallelization conversion.

Claims (7)

A function call method for analyzing a relationship between a function and a function call to generate function information and function call information, and performing a program conversion process using the function information and the function call information,
A plurality of instruction sequences constituting the a call, collective call-information generating step of generating information for an instruction sequence which constitutes a call equivalent single function of the same function,
From the top Symbol collective call-information, and collectively function generation step of generating an instruction sequence that constitutes the bulk function of performing an instruction sequence composing the multiple execution of the same function at a time,
A collective call conversion step for converting from the collective call information into an instruction sequence constituting a plurality of calls of the same function into an instruction sequence constituting a single collective function call; call Shutsuka way. In the batch function calling method according to claim 1,
The collective call information generation step recognizes an isomorphic function call that is a call of an instruction sequence that constitutes the same function using the function call information, and generates an isomorphic call information step; and
A batch function call method comprising: a batch call selection step for selecting a call that can be converted into an instruction sequence constituting a batch function call from the same type call generated by the same type call recognition step. In the batch function calling method according to claim 2,
A batch call determination step for determining whether or not the plurality of isomorphic calls can be converted into an instruction sequence constituting a batch function call;
And a collective call information registration step for generating collective call information of a group of functions determined to be convertible into an instruction sequence constituting a collective function call by the collective call determination step. Batch function call method. In the batch function calling method according to claim 2,
The isomorphic call recognition step is a loop expansion isomorphic call recognition step that recognizes a call of the same function generated at the time of loop expansion and generates isomorphic call information at the time of loop expansion.
The batch call selection step generates batch call information in which a call that can be converted into a call of an instruction sequence constituting a batch function is selected from the loop expansion type isomorphic call information generated by the loop expansion type call recognition step. A collective function calling method characterized by The collective function calling method according to claim 4 ,
A collective function calling method, wherein the collective coefficient determined in the collective call information generating step is a loop expansion number. In the batch function calling method according to claim 2,
The isomorphic call recognition step is a loop parallelization isomorphic call recognition step for recognizing a call of the same function generated at the time of loop parallelization and generating isomorphic call information at the time of loop parallelization.
The batch call selection step generates batch call information by selecting a call that can be converted into a call to an instruction sequence constituting a batch function from the loop parallel type isomorphic call information generated by the loop parallelization isomorphic call recognition step. A collective function calling method characterized by: In the batch function calling method according to claim 6 ,
A collective function calling method, wherein the collective coefficient determined in the collective call information generating step is the number of loop parallelizations.

Images