JP7239827B2 - Information processing device and compiler program - Google Patents

Description

The present invention relates to an information processing device and a compiler program.

For example, a compiler program (hereinafter simply referred to as a compiler) used for HPC (High Performance Computing) or the like performs optimization processing for improving processing performance such as processing speed when compiling source code. Specifically, the compiler performs loop division, for example, by dividing a loop included in a source code (hereinafter also referred to as a loop to be divided) into a plurality of loops.

This enables the compiler to suppress the occurrence of optimization impediments caused by, for example, hardware resource shortages. In addition, the compiler can, for example, suppress deterioration in cache efficiency (see Patent Documents 1 and 2, for example).

JP-A-2002-123563 JP 2009-104422 A

Here, the compiler as described above analyzes, for example, the dependency relationship between each instruction included in the loop to be divided, and distributes each instruction to a plurality of divided loops based on the analysis result. Split the target loop.

However, the number of combinations of instructions whose dependencies need to be analyzed increases according to the number of instructions included in the loop to be split. Therefore, if the number of instructions included in the loop to be divided is enormous, the compiler will take a long time to divide the loop, and it will be impossible to compile the source code efficiently.

Accordingly, in one aspect, an object of the present invention is to provide an information processing apparatus and a compiler program that enable division of loops included in source code at high speed.

In one aspect of the embodiment, dependency information indicating dependency between instructions included in a loop of the intermediate language generated from the source code is generated, and the generated dependency information is converted into a matrix to obtain the first matrix. an information generation unit for generating; a group allocation unit for allocating each instruction included in the loop to a plurality of groups based on the degree of dependence between each instruction calculated from the generated first matrix; and a loop dividing unit that divides the loop for each group.

According to one aspect, it is possible to divide a loop included in the source code at high speed.

FIG. 1 is a diagram illustrating the configuration of an information processing system 10. As shown in FIG. FIG. 2 is a flowchart for explaining compilation processing performed by the information processing apparatus 1 . FIG. 3 is a diagram for explaining the hardware configuration of the information processing device 1. As shown in FIG. FIG. 4 is a functional block diagram of the information processing apparatus 1. As shown in FIG. FIG. 5 is a flowchart for explaining the outline of the processing of S2. FIG. 6 is a flowchart for explaining the details of the process of S2. FIG. 7 is a flowchart for explaining the details of the process of S2. FIG. 8 is a flowchart for explaining the details of the process of S2. FIG. 9 is a specific example for explaining the contents of the intermediate language 22. As shown in FIG. FIG. 10 is a diagram explaining a specific example of the dependency information 131. As shown in FIG. FIG. 11 is a diagram illustrating a specific example of the dependence graph 131a. FIG. 12 is a diagram illustrating a specific example of the first matrix 132. As shown in FIG. FIG. 13 is a diagram illustrating a specific example of the second matrix 133. As shown in FIG. FIG. 14 is a diagram explaining a specific example of the dependency information 131. As shown in FIG. FIG. 15 is a diagram illustrating a specific example of the first matrix 132. As shown in FIG. FIG. 16 is a diagram illustrating a specific example of the second matrix 133. As shown in FIG. FIG. 17 is a diagram explaining a specific example of the dependency information 131. As shown in FIG. FIG. 18 is a diagram explaining a specific example of the first matrix 132. As shown in FIG. FIG. 19 is a diagram illustrating a specific example of the dependency graph 131a. FIG. 20 is a specific example for explaining the content of the split loop. FIG. 21 is a flowchart for explaining the process of S2 in the second embodiment. FIG. 22 is a flowchart for explaining the processing of S2 in the second embodiment. FIG. 23 is a flowchart for explaining the process of S2 in the second embodiment. FIG. 24 is a diagram explaining a specific example of the dependency information 131. As shown in FIG. FIG. 25 is a diagram illustrating a specific example of the first matrix 132. As shown in FIG. FIG. 26 is a diagram illustrating a specific example of the first matrix 132. As shown in FIG. FIG. 27 is a diagram illustrating a specific example of the dependency graph 131a. FIG. 28 is a specific example for explaining the content of the split loop.

[Configuration of information processing system]
First, the configuration of the information processing system 10 will be described. FIG. 1 is a diagram illustrating the configuration of an information processing system 10. As shown in FIG.

As shown in FIG. 1, the information processing system 10 includes, for example, an information processing device 1 made up of one or more physical machines, a storage unit 130 provided inside or outside the information processing device 1, and an operation terminal 5. include. The operation terminal 5 is, for example, a PC (Personal Computer) used by an operator who compiles the source code, and is connected to the information processing apparatus 1 via the network NW.

The information processing device 1 (the compiler that operates in the information processing device 1) acquires the source code 21 stored in the storage unit 130, for example, when it is time to start compiling (hereinafter also referred to as compilation start timing). , an intermediate language 22 is generated by performing a process of compiling the acquired source code 21 (hereinafter also referred to as a compilation process), and an object code 23 is generated from the generated intermediate language 22 . The compilation start timing may be, for example, the timing at which the operator issues an instruction to start compilation processing via the operation terminal 5 .

Further, when the timing for executing the object code 23 (hereinafter also referred to as code execution timing) comes, the information processing apparatus 1 acquires the object code 23 stored in the storage unit 130, and executes the object generated by the compilation process. Processing for executing code 23 (hereinafter also referred to as code execution processing) is performed. Compilation processing and code execution processing performed by the information processing apparatus 1 will be described below.

[Compile processing by information processing device]
First, the compilation process performed by the information processing apparatus 1 will be described. FIG. 2 is a flowchart for explaining compilation processing performed by the information processing apparatus 1 .

As shown in FIG. 2, the information processing device 1 generates an intermediate language 22 by performing lexical analysis and syntactic analysis of the source code 21 (S1). Then, the information processing device 1 stores the generated intermediate language 22 in the information storage area 130, for example.

After that, the information processing device 1 optimizes the intermediate language 22 generated in the process of S1 (S2). Specifically, the information processing apparatus 1 performs processing such as loop division on each loop included in the intermediate language 22 .

Subsequently, the information processing device 1 generates the object code 23 from the intermediate language 22 optimized in S1, for example (S3). Then, the information processing device 1 stores the generated object code 23 in the storage unit 130, for example.

Here, when performing the processing of S2 described in FIG. 2, the information processing apparatus 1, for example, analyzes the dependency relationships between each instruction included in the loop, and divides each instruction into a plurality of groups based on the analysis result. The loops to be analyzed are divided by allocating them to the loops.

However, the number of combinations of instructions whose dependencies need to be analyzed increases according to the number of instructions included in the loop to be split. Therefore, for example, when the number of instructions included in the loop to be divided is enormous, the information processing apparatus 1 takes a long time to divide the loop, and cannot efficiently compile the source code. Gone.

Therefore, the information processing apparatus 1 according to the present embodiment generates information (hereinafter also referred to as dependency information) indicating the dependency relationship between each instruction included in the loop of the intermediate language 22 generated from the source code 21, and generates A matrix (hereinafter also referred to as a first matrix) is generated by transforming the dependency information.

Then, the information processing apparatus 1 divides the instructions included in the loop into a plurality of groups based on the degree of dependence between the instructions calculated from the generated first matrix, and divides the loop into each divided group.

That is, the information processing apparatus 1 according to the present embodiment performs calculations using the first matrix generated from the dependency information, thereby analyzing the dependency relationship for each combination of instructions included in the loop to be divided. Instead, determine the allocation destination of each instruction.

As a result, the information processing apparatus 1 can efficiently perform loop division, and can shorten the time required to compile the source code 21 .

In addition, the information processing apparatus 1 determines the allocation destination of each instruction included in the loop to be split by calculation, thereby specifying the method of loop splitting that minimizes the dependency relationship between instructions included in different split loops. it becomes possible to Therefore, the information processing apparatus 1 can shorten the execution time of the object code 23 generated from the source code 21 by dividing the loop according to the specified method.

[Hardware configuration of information processing system]
Next, the hardware configuration of the information processing system 10 will be described. FIG. 3 is a diagram for explaining the hardware configuration of the information processing device 1. As shown in FIG.

The information processing apparatus 1 has a CPU 101 as a processor, a memory 102, an external interface (I/O unit) 103, and a storage medium 104, as shown in FIG. Each unit is connected to each other via a bus 105 .

The storage medium 104 has, for example, a program storage area (not shown) that stores a program 110 (compiler) for performing compilation processing. The storage medium 104 also has a storage unit 130 (hereinafter also referred to as an information storage area 130) that stores information used when performing compilation processing, for example. Note that the storage medium 104 may be, for example, an HDD (Hard Disk Drive) or an SSD (Sokid State Drive).

The CPU 101 executes the program 110 loaded from the storage medium 104 to the memory 102 to perform compilation processing.

Also, the external interface 103 communicates with the operation terminal 5, for example.

[Functions of information processing system]
Next, functions of the information processing system 10 will be described. FIG. 4 is a functional block diagram of the information processing apparatus 1. As shown in FIG.

As shown in FIG. 4 , the information processing apparatus 1 includes, for example, hardware such as a CPU 101 and a memory 102 and a program 110 organically cooperate to achieve a division determination unit 111, an information generation unit 112, an information Various functions including a management unit 113, a group allocation unit 114, a loop division unit 115, and a proximity determination unit 116 are realized.

The information processing apparatus 1 also stores dependency information 131, a first matrix 132, and a second matrix 133 in the information storage area 130, for example, as shown in FIG.

The division determination unit 111 , for example, determines whether or not each loop included in the intermediate language 22 generated from the source code 21 is to be divided into loops. Specifically, for example, if the intermediate language 22 includes a loop in which the number of registers and the number of streams used at the time of execution exceed the number of registers and the number of streams of the CPU 101, the division determination unit 111 divides the loop. Make a judgment to that effect.

The information generation unit 112 generates dependency information 131 indicating dependency relationships between instructions included in a loop to be divided. Specifically, when there is a loop for which the division determination unit 111 has determined to divide the loop, the information generation unit 112 generates the dependency information 131 corresponding to the loop. The information generation unit 112 also generates the first matrix 132 by converting the generated dependency information 131 into a matrix.

The information management unit 113 stores, for example, the dependency information 131 and the first matrix 132 generated by the information generation unit 112 in the information storage area 130 .

The grouping unit 114 sorts the instructions included in the loop to be divided into a plurality of groups based on the degree of dependence between the instructions calculated from the first matrix 132 generated by the information generating unit 112 .

The loop dividing unit 115 divides the loops to be divided for each group sorted by the group sorting unit 114 .

The proximity determination unit 116 determines, for example, whether or not the loop to be divided includes a plurality of instructions that access data stored at adjacent addresses in the memory 102 .

Then, for example, when the proximity determination unit 116 determines that the loop to be divided includes a plurality of instructions that access data stored at adjacent addresses in the memory 102, the information generation unit 112 generates dependency information 131 corresponding to the dependency relationship between instructions included in the loop to be divided and the positional relationship in the memory 102 of data accessed by each instruction. A description of the second matrix 133 will be given later.

[Outline of the first embodiment]
Next, an outline of the first embodiment will be described. Concretely, the outline of the processing of S2 explained in FIG. 2 will be explained. FIG. 5 is a flowchart for explaining the outline of the processing of S2.

The information generation unit 112 of the information processing device 1 generates dependency information 131 indicating dependency relationships between instructions included in the loop of the intermediate language 22 generated from the source code 21 (S11).

Then, the information generation unit 112 generates the first matrix 132 by converting the dependency information 131 generated in the process of S11 into a matrix (S12).

Subsequently, the grouping unit 114 of the information processing device 1 divides each instruction included in the loop to be divided into a plurality of groups based on the degree of dependence between each instruction calculated from the first matrix 132 generated in the process of S12. Allocate to groups (S13).

After that, the loop dividing unit 115 of the information processing apparatus divides the loop to be divided for each group divided in the process of S13 (S14).

As a result, the information processing apparatus 1 can efficiently perform loop division, and can shorten the time required to compile the source code 21 .

In addition, the information processing apparatus 1 determines the allocation destination of each instruction included in the loop to be split by calculation, thereby specifying the method of loop splitting that minimizes the dependency relationship between instructions included in different split loops. it becomes possible to Therefore, the information processing apparatus 1 can shorten the execution time of the object code 23 generated from the source code 21 by dividing the loop according to the specified method.

[Details of the first embodiment]
Next, details of the first embodiment will be described. 6 to 9 are flowcharts for explaining the details of the process of S2 explained in FIG. 9 to 20 are diagrams for explaining the details of the processing of S2.

As shown in FIG. 6, the division determination unit 111 of the information processing device 1 determines whether or not the intermediate language 22 stored in the information storage area 130 includes a loop to be divided (S21). A specific example of the intermediate language 22 will be described below.

[Concrete example of intermediate language]
FIG. 9 is a specific example for explaining the contents of the intermediate language 22. As shown in FIG. Specifically, FIG. 9 is a specific example for explaining the intermediate language 22 when the source code 21 is expressed in terms of assembler instructions.

The intermediate language 22 shown in FIG. 9 includes an instruction "mov reg_i, 1" indicating setting 1 as an initial value to the variable reg_i and a label "LABEL1:" indicating the loop start position.

Also, the intermediate language 22 shown in FIG. 'load reg2, mem "B(reg_i)"', which is an instruction indicating to set the value stored in the reg_i-th position of the variable reg2 to the variable reg2.

Also, the intermediate language 22 shown in FIG. 9 is an instruction indicating that the value calculated by adding the value set in the variable reg1 and the value set in the variable reg2 is set in the variable reg3. It includes “add reg3, reg1, reg2” and “load reg4, mem “C(reg_i)”, which is an instruction indicating to set the value stored in the reg_i-th position of the array C to the variable reg4.

Also, the intermediate language 22 shown in FIG. "load reg6, mem"C(reg_i+10)", which is an instruction indicating to set the data stored in the reg_i+10th position of the variable reg6 to the variable reg6.

Also, "load reg7, mem"E(reg_i)", which is an instruction indicating that the value stored in the reg_i-th position of the array E is set to the variable reg7, and the value set in the variable reg3 and the variable reg4 "add reg8, reg3, reg4", which is an instruction for setting the variable reg8 to the value calculated by adding the value set to .

Also, the intermediate language 22 shown in FIG. 9 is an instruction indicating that the value calculated by adding the value set in the variable reg4 and the value set in the variable reg8 is set in the variable reg9. Adding the value set in the variable reg9 to the value calculated by multiplying the value set in the variable reg3 and the value set in the variable reg5 with "add reg9, reg4, reg8" and "madd reg10, reg3, reg5, reg9" which is an instruction indicating to set the value calculated by the variable reg10.

Further, the intermediate language 22 shown in FIG. 9 adds the value set in the variable reg10 to the value calculated by multiplying the value set in the variable reg5 and the value set in the variable reg6. ``madd reg11, reg5, reg6, reg10'', which is an instruction indicating to set the value calculated by and "add reg12, reg7, reg11" which is an instruction to set the value calculated by

Also, the intermediate language 22 shown in FIG. 9 stores a command “store mem “F(reg_i)”, reg12” indicating that the value set in the variable reg12 is stored in the reg_i-th position of the array F, and the variable reg_i ``add reg_i, reg_i, 1'', which is an instruction indicating to set the variable reg_i to a value calculated by adding 1 to the value set to .

Furthermore, the intermediate language 22 shown in FIG. 9 contains the command "cmpre reg_i, 100" indicating that the value set in the variable reg_i is compared with 100, and the value set in the variable reg_i is 100 or less. , branch to "LABEL1:" indicating the start position of the loop, and "ble icc, LABAL1", which is an instruction indicating to end the loop if the value set in the variable reg_i exceeds 100. include.

In the intermediate language 22 shown in FIG. 9, the number written at the left end of each instruction is hereinafter also referred to as the instruction number of each instruction. Further, the instructions having the instruction numbers “1” to “13” are also called “instruction 1” to “instruction 13” below.

Returning to FIG. 6, when the intermediate language 22 stored in the information storage area 130 includes a loop to be divided (YES in S22), the information generation unit 112 of the information processing device 1 performs division in the process of S21. Dependency information 131 indicating the dependency relationship between instructions included in the loop determined to be the target loop is generated (S23). A specific example of the dependency information 131 will be described below.

[Specific example of dependency information]
FIG. 10 is a diagram explaining a specific example of the dependency information 131. As shown in FIG.

The dependency information 131 shown in FIG. 10 includes an "instruction number" in which the instruction number of each instruction included in the intermediate language 22 is stored, and a "data dependency list" that is a list of instruction numbers of instructions that are dependent on each instruction. ” and “group name” in which the name of the group (divided loop) containing each instruction is stored.

Specifically, in the intermediate language 22 described with reference to FIG. 9, the variable reg1 whose value is set in the instruction 1 is referenced only in the instruction 3. Therefore, the information generator 112 stores "3" in the "data dependency list" of the information whose "instruction number" is "1", as shown in FIG. 10, for example.

Also, in the intermediate language 22 described with reference to FIG. 9, the variable reg2 whose value is set in the instruction 2 is referenced only in the instruction 3. Therefore, the information generator 112 stores "3" in the "data dependence list" of the information whose "instruction number" is "2", as shown in FIG. 10, for example.

Furthermore, in the intermediate language 22 described with reference to FIG. 9, the instruction 3 refers to the variable reg1 whose value is set by the instruction 1 and the variable reg2 whose value is set by the instruction 2. FIG. Also, in the intermediate language 22 described with reference to FIG. 9, the variable reg3 whose value is set in the instruction 3 is referred to in the instructions 8 and 10 . Therefore, for example, as shown in FIG. 10, the information generating unit 112 adds "1", "2", "8" and "10" to the "data dependency list" of the information whose "instruction number" is "3". memorize

For example, as shown in FIG. 10, the information generator 112 stores the instruction number of each instruction as the initial value of the "group name" corresponding to each instruction. Description of other information included in FIG. 10 is omitted.

The information generator 112 may generate the dependency graph 131a corresponding to the contents included in the dependency information 131 in the process of S23. A specific example of the dependency graph 131a will be described below.

[Specific example of dependency graph (1)]
FIG. 11 is a diagram illustrating a specific example of the dependence graph 131a. Hereinafter, an edge indicating a bidirectional relationship is also referred to as a bidirectional edge, and an edge indicating a unidirectional relationship is also referred to as a unidirectional edge.

Specifically, in the dependency graph 131a shown in FIG. Between the corresponding node and the node corresponding to instruction 8, between the node corresponding to instruction 3 and the node corresponding to instruction 10, and between the node corresponding to instruction 4 and the node corresponding to instruction 8 A bidirectional edge is set for each. Also, in the dependency graph 131a shown in FIG. 11, between the node corresponding to the instruction 4 and the node corresponding to the instruction 9, between the node corresponding to the instruction 5 and the node corresponding to the instruction 10, and Between the node corresponding to the instruction 11 and the node corresponding to the instruction 11, between the node corresponding to the instruction 6 and the node corresponding to the instruction 11, and between the node corresponding to the instruction 7 and the node corresponding to the instruction 12 A bidirectional edge is set. Furthermore, in the dependency graph 131a shown in FIG. 11, between the node corresponding to the instruction 8 and the node corresponding to the instruction 9, between the node corresponding to the instruction 9 and the node corresponding to the instruction 10, and between the node corresponding to the instruction 10 between the node corresponding to instruction 11 and the node corresponding to instruction 11, between the node corresponding to instruction 11 and the node corresponding to instruction 12, and between the node corresponding to instruction 12 and the node corresponding to instruction 13. A bidirectional edge is set. That is, fifteen bidirectional edges are set in the dependency graph 131a shown in FIG.

In the dependency information 131 described with reference to FIG. 10, for example, "3" is stored in the "data dependency list" of information whose "instruction number" is "1". "1" is stored in the "data dependency list" of certain information. Therefore, the information generation unit 112 sets a bidirectional edge between the node corresponding to the instruction 1 and the node corresponding to the instruction 3, as shown in FIG. 11, for example.

Further, in the dependency information 131 explained with reference to FIG. 10, for example, "3" is stored in the "data dependency list" of the information whose "instruction number" is "2", and "3" is stored in the "instruction number". "2" is stored in the "data dependence list" of the information ". Therefore, the information generator 112 sets a bidirectional edge between the node corresponding to the instruction 2 and the node corresponding to the instruction 3, as shown in FIG. 11, for example.

Further, in the dependency information 131 described with reference to FIG. 10, for example, "8" is stored in the "data dependency list" of information whose "instruction number" is "3", and "8" is stored in the "instruction number". " is stored in the "data dependency list" of the information "3". Therefore, the information generator 112 sets a bidirectional edge between the node corresponding to the instruction 3 and the node corresponding to the instruction 8, as shown in FIG. 11, for example. Description of other information included in FIG. 11 is omitted.

Returning to FIG. 6, the information generator 112 generates the first matrix 132 by converting the dependency information 131 generated in the process of S23 into a matrix (S24). A specific example of the first matrix 132 will be described below.

[Specific example of the first matrix]
FIG. 12 is a diagram illustrating a specific example of the first matrix 132. As shown in FIG.

In the first matrix 132 shown in FIG. 12, the rows corresponding to "1" to "13" respectively correspond to the instructions 1 to 13, respectively, and correspond to "1" to "13" respectively. The corresponding columns are columns corresponding to the instructions 1 to 13, respectively. Also, each element (each column) of the first matrix 132 shown in FIG. Alternatively, a value "0" is stored which indicates that there is no dependency between the row-corresponding instruction and the column-corresponding instruction.

Specifically, in the dependency information 131 shown in FIG. 10, "3" is stored in the "data dependency list" of the information whose "instruction number" is "1". Therefore, the information generator 112 stores "1" in the column included in the column corresponding to the command 3 among the columns included in the row corresponding to the command 1, as shown in FIG.

Further, in the dependency information 131 shown in FIG. 10, "3" is stored in the "data dependency list" of the information whose "instruction number" is "2". Therefore, the information generator 112 stores "1" in the column included in the column corresponding to the command 3 among the columns included in the row corresponding to the command 2, as shown in FIG.

Further, in the dependency information 131 shown in FIG. 10, '1', '2', '8' and '10' are stored in the 'data dependency list' of the information whose 'instruction number' is '3'. there is Therefore, as shown in FIG. "1" is stored in each of the column corresponding to the instruction 8, the column included in the column corresponding to the instruction 10, and the column included in the column corresponding to the instruction 10. Description of other information included in FIG. 12 is omitted.

Returning to FIG. 6, the grouping unit 114 of the information processing device 1 generates a second matrix 133 indicating the degree of dependency between instructions from the first matrix 132 generated in the process of S24 (S25). A specific example of the second matrix will be described below.

[Specific example of the second matrix]
FIG. 13 is a diagram illustrating a specific example of the second matrix 133. As shown in FIG.

In the second matrix 133 shown in FIG. 13, the rows corresponding to "1" to "13" respectively correspond to the instructions 1 to 13, respectively, and correspond to "1" to "13" respectively. The corresponding columns are columns corresponding to the instructions 1 to 13, respectively. Each element (each column) of the second matrix 133 shown in FIG. 13 stores the degree of dependence between the instruction corresponding to the row and the instruction corresponding to the column.

Here, the degree of dependence between instructions may be, for example, a clustering index value calculated by the Newman algorithm. In this case, the grouping unit 114 calculates the clustering index value ΔQ using, for example, Equation 1 below.

ΔQ=e _ij +e _ji −2a _{ia j} =2(e _ij −a _{ia j} ) (equation 1)

In Equation 1 above, the variable a _i is the number of unidirectional edges between the node corresponding to the instruction i and the nodes corresponding to other instructions among the unidirectional edges included in the dependency graph 131a described with reference to FIG. The variable _aj indicates the ratio of the number of unidirectional edges between the node corresponding to the instruction j and the nodes corresponding to other instructions among the unidirectional edges included in the dependency graph 131a described with reference to FIG. show. In Expression 1, the variable e _ij is the number of unidirectional edges between the node corresponding to the instruction i and the node corresponding to the instruction j among the unidirectional edges included in the dependency graph 131a described with reference to FIG. indicates the percentage of

Specifically, the state indicated by the dependency graph 131a described with reference to FIG. 11 is a state in which 15 bidirectional edges are included, which is the same as the state in which 30 unidirectional edges are included. In addition, in the dependency graph 131a described with reference to FIG. 11, the number of unidirectional edges between the node corresponding to instruction 12 and other nodes, the number of unidirectional edges between the node corresponding to instruction 13 and other nodes The number and number of unidirectional edges between the node corresponding to number and instruction 12 and the node corresponding to instruction 13 are 3, 1 and 1, respectively. Therefore, for example, when the instruction i is the instruction 12 and the instruction j is the instruction 13, the grouping unit 114 calculates "0.060" as the clustering index value ΔQ as shown in the following equation (2). do.

2*((1/30)-(3/30)*(1/30))=0.06 (Formula 2)

Therefore, as shown in FIG. 13, the grouping unit 114 stores "0.060" in the column included in the column corresponding to the command 13 among the columns included in the row corresponding to the command 12. .

Note that the clustering index value ΔQ when the instruction i is the instruction 13 and the instruction j is 12 is the same value as the clustering index value ΔQ when the instruction i is the instruction 12 and the instruction j is 13. Therefore, for example, when the grouping unit 114 calculates the clustering index value ΔQ when the instruction i is the instruction 12 and the instruction j is 13, the instruction i is the instruction 13 and the instruction j is The calculation of the clustering index value ΔQ in the case of 12 may not be performed. In this case, the grouping unit 114, as shown in FIG. It may store "0.000" which is a value indicating that it is not performed. Description of other information included in FIG. 13 is omitted.

Returning to FIG. 7, the group allocation unit 114 determines the allocation destination of each instruction corresponding to the maximum value among the values of the elements of the second matrix 133 generated in the process of S25 to the same group (S31).

Specifically, in the second matrix 133 described with reference to FIG. Among them, the column included in the column corresponding to the instruction 12 is set with the maximum value of "0.060". Therefore, the grouping unit 114 identifies the combination of the instructions 12 and 13 or the combination of the instructions 7 and 12 among the combinations of instructions corresponding to the elements of the second matrix 133 described with reference to FIG. Then, for example, when the combination of the instructions 12 and 13 is identified, the grouping unit 114 decides to allocate the instructions 12 and 13 to the same group.

Then, the group allocation unit 114 determines the allocation destination in the process of S31 among the rows in the second matrix 133 generated in the process of S25 or the rows in the second matrix 133 regenerated in the process of S33 (process described later). A plurality of rows corresponding to each instruction are converted into a single row whose elements are sums of elements of the same column in the plurality of rows, and reproduced by the second matrix 133 generated by the processing of S25 or by the processing of S33. Among the columns in the formed second matrix 133, a plurality of columns corresponding to each instruction whose allocation destination is determined in the processing of S31 are combined into a single column whose elements are the sum of the elements of the same row in the plurality of columns. , the first matrix 132 is regenerated (S32).

Specifically, the group allocation unit 114 updates the dependency information 131 based on the determination result in the process of S31, for example. Then, the grouping unit 114 regenerates the first matrix 132 by referring to the updated dependency information 131, for example. A specific example of the processing of S32 will be described below.

[Specific example of processing in S32]
14 and 15 are diagrams for explaining a specific example of the process of S32.

For example, if the instructions decided to be assigned to the same group in the process of S31 are the instructions 12 and 13, the group assignment unit 114 assigns the instructions whose "instruction number" is "13" as shown in FIG. The dependency information 131 is updated so that the value stored in the "group name" of the information is updated to "12", which is the value stored in the "group name" of the information whose "instruction number" is "12". do.

After that, as shown in FIG. 15, the grouping unit 114 puts the value set in the column included in the row corresponding to the instruction 12 into the column included in the row corresponding to the instruction 12 and the value set in the column included in the row corresponding to the instruction 13 The values calculated by adding the values set in the columns included in the row corresponding to each column are stored. For example, as shown in FIG. The values calculated by adding the values set in the columns included in the column corresponding to each row are stored.

Specifically, in the first matrix 132 described with reference to FIG. 12, for example, among the columns included in the row corresponding to the instruction 12, the column included in the column corresponding to the instruction 7 stores "1". Among the columns included in the row corresponding to the instruction 13, the column included in the column corresponding to the instruction 7 stores "0". Therefore, as shown in FIG. 15, the grouping unit 114 assigns "1" and "0" to the column included in the column corresponding to the instruction 7 among the columns included in the row corresponding to the instruction 12, for example. stores "1" which is the sum of

Further, in the first matrix 132 described with reference to FIG. 12, for example, among the columns included in the row corresponding to the instruction 11, the column included in the column corresponding to the instruction 12 stores "1", Among the columns included in the row corresponding to the instruction 11, the column included in the column corresponding to the instruction 13 stores "0". Therefore, as shown in FIG. 15, the grouping unit 114 assigns "1" and "0" to the column included in the column corresponding to the instruction 12 among the columns included in the row corresponding to the instruction 11, for example. stores "1" which is the sum of

Furthermore, in the first matrix 132 described with reference to FIG. 12, for example, among the columns included in the row corresponding to the instruction 12, the column included in the column corresponding to the instruction 12 stores "0", Among the columns included in the row corresponding to the instruction 12, the column included in the column corresponding to the instruction 13 stores "1". "1" is stored in the column included in the column corresponding to the instruction 13, and "0" is stored in the column included in the column corresponding to the instruction 13 among the columns included in the row corresponding to the instruction 13. remembered. Therefore, as shown in FIG. 15, the grouping unit 114 assigns "0" and "1" to the columns included in the column corresponding to the instruction 12 among the columns included in the row corresponding to the instruction 12, for example. , '2' which is the sum of '1' and '0'. Description of other information included in FIG. 15 is omitted.

Returning to FIG. 7, the grouping unit 114 regenerates the second matrix 133 from the first matrix 132 regenerated in the process of S32 (S33).

Specifically, the grouping unit 114 generates (regenerates) the second matrix 133 shown in FIG. 16 by, for example, performing the same process as the process of S25 on the first matrix 132 described with reference to FIG. do.

Then, the group allocation unit 114 determines whether or not the number of groups to which each instruction included in the loop determined to be divided in the process of S21 has reached a predetermined number or less (S34).

Specifically, values from "1" to "12" (12 kinds of values) are stored in the "group name" of the dependency information 131 described with reference to FIG. Therefore, in this case, the group allocation unit 114 specifies "12" as the number of groups to which each instruction included in the loop determined to be divided in the process of S21 is to be allocated. Then, for example, when the predetermined number in the process of S34 is "2", the group allocation unit 114 determines that the number of groups to which each instruction included in the loop determined to be divided in the process of S21 is to be allocated is It is determined that the number has not reached the predetermined number or less.

On the other hand, only "1" and "5" (two types of values) are stored in the "group name" of the dependency information 131 shown in FIG. Therefore, in this case, the group allocation unit 114 specifies "2" as the number of groups to which each instruction included in the loop determined to be divided in the process of S21 is to be allocated. Then, for example, when the predetermined number in the process of S34 is "2", the group allocation unit 114 determines that the number of groups to which each instruction included in the loop determined to be divided in the process of S21 is to be allocated is It is determined that the number has reached the predetermined number or less.

Note that the grouping unit 114 generates, for example, the first matrix 132 shown in FIG. 18 in response to generating the dependency information 131 shown in FIG. Further, the grouping unit 114 generates, for example, a dependency graph 131a shown in FIG. 19 in response to generating the dependency information 131 shown in FIG. A specific example of the dependence graph 131a shown in FIG. 19 will be described below.

[Specific example of dependency graph (2)]
In the dependency graph 131a shown in FIG. 19, node groups corresponding to instructions 1, 2, 3, 4, 8 and 9, respectively, and instructions 5, 6, 7, 10, 11, The node groups respectively corresponding to the instructions 12 and 13 are included in different groups.

In the dependency graph 131a shown in FIG. 19, the node corresponding to the instruction 3 and the node corresponding to the instruction 10 are located between the group including the node corresponding to the instruction 1 and the group including the node corresponding to the instruction 5. and an edge between the node corresponding to the instruction 9 and the node corresponding to the instruction 10 are set.

That is, the dependency graph 131a shown in FIG. , 11, 12, and 13 are included in the other divided loop, the number of edges between instructions included in each of the different divided loops can be suppressed to two. It is shown that.

Returning to FIG. 9, when it is determined that the number of groups to which each instruction included in the loop determined to be divided in the process of S21 has reached a predetermined number or less (YES in S41), the information processing apparatus 1 The loop splitting unit 115 performs loop splitting of the loop determined to be split in the process of S21 according to the contents of the second matrix 133 generated in the process of S33 (S42).

After that, the information processing device 1 terminates the process of S2. Similarly, when the information processing apparatus 1 determines that the intermediate language 22 stored in the information storage area 130 does not include the loop to be divided (NO in S22), the processing of S2 ends.

On the other hand, when it is determined that the number of groups to which each instruction included in the loop determined to be divided in the process of S21 has not reached the predetermined number or less (NO in S41), the group allocation unit 114 , the processing after S32 is performed again. A specific example of a divided loop after loop division is described below.

[Specific example of split loop]
FIG. 20 is a specific example for explaining the content of the split loop. FIG. 20A is a specific example for explaining one of the divided loops, and FIG. 20B is a specific example for explaining the other of the divided loops.

The divided loop shown in FIG. 20(A) includes instruction 1, instruction 2, instruction 3, instruction 4, instruction 8, and instruction 9 of the intermediate language described with reference to FIG.

The divided loop shown in FIG. 20A is an instruction "store tmp_array1 (reg_i), reg3 ” and “store tmp_array2 (reg_i), reg9” which is an instruction indicating that the value set in the variable reg9 is stored in the reg_i-th position of the array tmp_array2.

On the other hand, the divided loop shown in FIG. 20(B) includes the instructions 5, 6, 7, 10, 11, 12 and 13 of the intermediate language described in FIG.

The divided loop shown in FIG. 20B is an instruction "load reg3, tmp_array1 (reg_i )” and “load reg9, tmp_array2 (reg_i)” which is an instruction indicating to set the value stored in the reg_i-th position of the array tmp_array2 to the variable reg9.

That is, as described with reference to FIG. 19, the value set to the variable reg3 (value corresponding to instruction 3) and the value set to variable reg9 (value corresponding to instruction 9) are shown in FIG. is referenced in the instruction 10 contained in the split loop shown in FIG. Therefore, the divided loop shown in FIG. 20A includes an instruction to store the value set in the variable reg3 and the value set in the variable reg9 in the temporary array. Also, the split loop shown in FIG. 20B includes an instruction for retrieving the values stored in the temporary array.

As described above, the information processing apparatus 1 according to the present embodiment generates the dependency information 131 indicating the dependency relationship between the instructions included in the loop of the intermediate language 22 generated from the source code 21, and converts the generated dependency information 131 into A first matrix 132 is generated by converting to a matrix.

Then, the information processing apparatus 1 distributes the instructions included in the loop to a plurality of groups based on the degree of dependence between the instructions calculated from the generated first matrix 132, and divides the loop for each of the divided groups. .

That is, the information processing apparatus 1 according to the present embodiment performs an operation using the first matrix 132 generated from the dependency information 131, thereby analyzing the dependency relationship for each combination of instructions included in the loop to be divided. Determines the allocation destination of each instruction without performing

As a result, the information processing apparatus 1 can efficiently perform loop division, and can shorten the time required to compile the source code 21 .

In addition, the information processing apparatus 1 determines the allocation destination of each instruction included in the loop to be split by calculation, thereby specifying the method of loop splitting that minimizes the dependency relationship between instructions included in different split loops. it becomes possible to Therefore, the information processing apparatus 1 can shorten the execution time of the object code 23 generated from the source code 21 by dividing the loop according to the specified method.

Note that when the information processing apparatus 1 determines in the processes of S21 and S22 that the intermediate language 22 stored in the information storage area 130 includes a plurality of loops to be divided, the information processing apparatus 1 performs the processes of S23 and thereafter on the loops to be divided. It may be performed for each loop.

The information processing apparatus 1 may use an algorithm other than the Newman algorithm (for example, a label propagation method, a K-means method, or the like) when calculating the clustering index value in the process of S25.

[Second embodiment]
Next, details of the second embodiment will be described. 21 to 23 are flowcharts for explaining the processing of S2 in the second embodiment. 24 to 28 are diagrams for explaining the details of the processing of S2 in the second embodiment.

Unlike the compilation process in the first embodiment, the compilation process in the second embodiment also refers to the positional relationship in the memory 102 of the data accessed by each instruction to divide the loop.

As shown in FIG. 21, the division determination unit 111 determines whether or not the intermediate language 22 stored in the information storage area 130 includes a loop to be divided (S51).

Then, when it is determined that the intermediate language 22 stored in the information storage area 130 includes the loop to be divided (YES in S52), the proximity determination unit 116 of the information processing apparatus 1 stores the is included in the loop to be divided (S53).

Specifically, the proximity determination unit 116 determines, for example, whether or not a plurality of instructions that access data stored in the same array are included in the same loop to be divided.

That is, when the object code 23 is executed, for example, when the first data in the first array is accessed with the execution of the first instruction, the CPU 101 executes each data in the first array stored in the memory 102. is temporarily stored in a cache memory (not shown), and the first data stored in the cache memory is accessed.

Then, for example, when access to the second data in the first array occurs due to the execution of a second instruction that is different from the first instruction, the CPU 101 determines if each data in the first array is still stored in the cache memory. , to access the second data stored in the cache memory. On the other hand, if each data in the first array has already been evicted from the cache memory due to the occurrence of access to other data, etc., the CPU 101 retrieves data of a predetermined size including each data in the first array stored in the memory 102 . is stored again in the cache memory, and the second data stored in the cache memory is accessed.

Therefore, for example, when the first instruction and the second instruction as described above are included in the loop to be split, the information processing apparatus 1 divides the loop so that the first instruction and the second instruction are included in the same split loop. By dividing, the execution timing of the first instruction and the execution timing of the second instruction are brought close to each other.

As a result, the information processing apparatus 1 can reduce the probability that the first data will be evicted from the cache memory during execution of the loop to be divided. Therefore, the information processing device 1 can reduce the frequency of occurrence of the process of re-storing the first data in the cache memory, and can shorten the execution time of the object code 23 .

Therefore, in the processing of S53, the proximity determination unit 116 identifies, for example, a plurality of instructions that access each piece of data included in the same array from the instructions included in the loop to be divided.

Note that the proximity determination unit 116 may, for example, identify a plurality of instructions for accessing data within a range corresponding to a predetermined number of rotations among data contained in a certain array.

Returning to FIG. 21, the information generation unit 112 indicates the dependency relationship between each instruction included in the loop determined to be divided in the process of S51 and the positional relationship in the memory 102 of the data accessed by each instruction. Dependency information 131 is generated (S54).

[Specific example of dependency information]
FIG. 24 is a diagram explaining a specific example of the dependency information 131. As shown in FIG.

Dependency information 131 shown in FIG. 24 includes, in addition to the items included in the dependency information 131 described with reference to FIG. It has as an item "cache sharing dependency list" which is a list.

Specifically, in the intermediate language 22 described with reference to FIG. 9, the data stored in the array C is referenced in each of the instructions 4 and 6. FIG. Therefore, for example, as shown in FIG. 24, the information generating unit 112 stores "6" in the "cache sharing dependency list" of the information whose "instruction number" is "4", "4" is stored in the "cache sharing dependency list" of the information ". Also, in this case, the information generation unit 112 determines that there is no information in the “cache share dependency list” of information with “instruction numbers” other than “4” and “6”, as shown in FIG. 24, for example. "-" indicating is stored.

Returning to FIG. 21, the information generator 112 generates the first matrix 132 by converting the dependency information 131 generated in the process of S54 into a matrix (S55). A specific example of the first matrix 132 will be described below.

[Specific example of the first matrix]
FIG. 25 is a diagram illustrating a specific example of the first matrix 132. As shown in FIG.

Each element (each column) of the first matrix 132 illustrated in FIG. "5" which is a value indicating that the positions of data accessed by the corresponding instruction and the instruction corresponding to the column are close to each other in the memory 102, or the instruction corresponding to the row and the instruction corresponding to the column. A value "0" is stored as a value indicating that there is no dependency between the be done.

Specifically, in the dependency information 131 described with reference to FIG. 24, "6" is stored in the "cache shared dependency list" of information whose "instruction number" is "4", and "6" is stored in the "instruction number" of "4". "4" is stored in the "cache sharing dependency list" of the information "6". Therefore, the information generator 112 stores "5" in the column included in the column corresponding to the command 6 among the columns included in the row corresponding to the command 4, as shown in FIG. 25, the information generator 112 stores "5" in the column included in the column corresponding to command 4 among the columns included in the row corresponding to command 6, for example.

That is, an increase in the number of occurrences of cache misses has a greater impact on the execution time of the object code 23 than the inclusion of a plurality of dependent instructions in different divided loops. can be determined to be large. Therefore, as shown in FIG. 25, the information generating unit 112 generates a value indicating that the positions of the data accessed by each instruction in the memory 102 are close to each other, indicating that there is a dependency relationship between each instruction. The first matrix 132 is generated so as to be larger than the value indicating .

Returning to FIG. 21, the group allocation unit 114 generates a second matrix 133 indicating the degree of dependency between instructions from the first matrix 132 generated in the process of S55 (S56).

Then, as shown in FIG. 22, the group allocation unit 114 determines the allocation destination of a plurality of instructions corresponding to the maximum value among the values of the elements of the second matrix 133 generated in the process of S56 to the same group. (S61).

Subsequently, the grouping unit 114 corresponds to each instruction, among the rows in the second matrix 133 generated in the process of S56 or the second matrix 133 regenerated in the process of S63, for which the allocation destination is determined in the process of S61. are converted into a single row whose elements are sums of elements of the same column in the plurality of rows, and the second matrix 133 generated in the process of S56 or the second matrix 133 regenerated in the process of S63 To convert a plurality of columns of the matrix 133 corresponding to each instruction whose allocation destination is determined in the processing of S61 into a single column whose element is the sum of the elements of the same row in the plurality of columns. to regenerate the first matrix 132 (S62).

Further, the grouping unit 114 regenerates the second matrix 133 from the first matrix 132 regenerated in the process of S62 (S63).

After that, the group allocation unit 114 determines whether or not the number of groups to which each instruction included in the loop determined to be divided in the process of S51 has reached a predetermined number or less (S64).

Specifically, for example, when the predetermined number in the process of S64 is "2", if the first matrix 132 shown in FIG. It is determined that the number of groups to which each instruction included in the loop determined to exist has reached a predetermined number or less.

As shown in FIG. 27, in the dependency graph 131a corresponding to the first matrix 132 shown in FIG. 26, each instruction (instruction 4 and instruction 6) referencing each data stored in the same array is assigned to the same group. It is

Subsequently, when it is determined that the number of groups to which each instruction included in the loop determined to be divided in the process of S51 has reached a predetermined number or less (YES in S71), the loop dividing unit 115 According to the contents of the second matrix 133 generated in the process of S63, loop division is performed for the loop determined to be to be divided in the process of S51 (S72).

Then, the information processing device 1 terminates the process of S2. Similarly, when the information processing apparatus 1 determines that the intermediate language 22 stored in the information storage area 130 does not include the loop to be divided (NO in S52), the processing of S2 ends.

On the other hand, when it is determined that the number of groups to which each instruction included in the loop determined to be divided in the process of S51 has not reached the predetermined number or less (NO in S71), the group allocation unit 114 , the processing after S62 is performed again. A specific example of a divided loop after loop division is described below.

[Specific example of split loop]
FIG. 28 is a specific example for explaining the content of the split loop. FIG. 28A is a specific example for explaining one of the divided loops, and FIG. 28B is a specific example for explaining the other of the divided loops.

The divided loop shown in FIG. 28(A) includes instruction 1, instruction 2, instruction 3, instruction 4, instruction 6, instruction 8, and instruction 9 of the intermediate language described in FIG.

The divided loop shown in FIG. 28A is an instruction "store tmp_array1 (reg_i), reg3 "store tmp_array2 (reg_i), reg6" which is an instruction indicating to store the value set in the variable reg6 in the reg_i-th position of the array tmp_array2, and the value set in the variable reg9 to the reg_i 'store tmp_array3 (reg_i), reg9', which is an instruction to store in the th.

On the other hand, the divided loop shown in FIG. 28(B) includes the instructions 5, 7, 10, 11, 12 and 13 of the intermediate language described in FIG.

In addition, the divided loop shown in FIG. 28B is an instruction "load reg3, tmp_array1 (reg_i )”, “load reg6, tmp_array2 (reg_i)” which is an instruction indicating to set the value stored in the reg_i-th position in the array tmp_array2 to the variable reg6, and the value stored in the reg_i-th position in the array tmp_array3. ``load reg9, tmp_array3 (reg_i)'', which is an instruction to set the variable reg9.

That is, the split loop shown in FIG. 28 has more temporary arrays than the split loop described in FIG. However, in the split loop shown in FIG. 28, each instruction (instruction 4 and instruction 6) that references each data stored in the same array is included in the same split loop.

As a result, the information processing device 1 can further shorten the execution time of the object code 23 .

The above embodiments are summarized as follows.

(Appendix 1)
an information generation unit that generates dependency information indicating dependency relationships between instructions included in a loop of an intermediate language generated from a source code and converts the generated dependency information into a matrix to generate a first matrix;
a group sorting unit that sorts the instructions included in the loop into a plurality of groups based on the degree of dependence between the instructions calculated from the generated first matrix;
a loop dividing unit that divides the loop for each of the plurality of divided groups;
An information processing device characterized by:

(Appendix 2)
In Appendix 1,
The information generation unit
determining whether the dependency information indicates that there is a dependency between instructions included in each combination for each combination of instructions included in the loop;
Among the combinations of instructions, the element corresponding to the combination in which the dependency information indicates that there is a dependency between instructions included in each combination is set as a first value, and each combination of the instructions includes: generating the first matrix by setting, as a second value, an element corresponding to a combination in which the dependency information does not indicate that there is a dependency between the included instructions;
An information processing device characterized by:

(Appendix 3)
In Appendix 1,
The grouping unit sorts each instruction included in the loop into a plurality of groups so as to reduce dependencies existing between instructions included in different groups.
An information processing device characterized by:

(Appendix 4)
In Appendix 1,
The group allocation unit
generating a second matrix indicating the degree of dependency between instructions from the first matrix;
Allocating each instruction included in the loop to the plurality of groups based on the generated second matrix;
An information processing device characterized by:

(Appendix 5)
In Appendix 4,
The group allocation unit
calculating the degree of dependence between instructions included in each combination for each combination of instructions included in the loop;
generating the second matrix by using each of the calculated degrees of dependence as elements;
An information processing device characterized by:

(Appendix 6)
In Appendix 5,
The group allocation unit calculates the degree of dependence by using the Newman algorithm,
An information processing device characterized by:

(Appendix 7)
In Appendix 5,
The group allocation unit
determining to assign to the same group a plurality of instructions corresponding to the largest value among the values of the elements of the second matrix;
converting the plurality of rows corresponding to the plurality of instructions in the second matrix into a single row whose elements are sums of the same column-wise elements in the plurality of rows; and regenerate the first matrix by transforming the columns corresponding to the instruction of to a single column whose elements are the sums of the same row-wise elements in the columns;
regenerating the second matrix from the regenerated first matrix;
The determining process, the regenerating the first matrix, and the regenerating the second matrix are repeated until the number of groups determined as allocation destinations of the instructions included in the loop becomes equal to or less than a predetermined number. repeat,
An information processing device characterized by:

(Appendix 8)
In Supplementary Note 2, further,
a proximity determination unit that determines whether or not the loop includes a plurality of instructions for accessing data stored in adjacent storage areas;
The information generation unit generates the first matrix based on a determination result as to whether the plurality of instructions are included in the loop.
An information processing device characterized by:

(Appendix 9)
In Appendix 8,
When the information generating unit determines that the plurality of instructions are included in the loop, the information generation unit sets the element corresponding to the plurality of instructions to a third value larger than the first value, generating the first matrix;
An information processing device characterized by:

(Appendix 10)
In Appendix 8,
each data stored in the adjacent storage area is the same array,
An information processing device characterized by:

(Appendix 11)
Generate dependency information that indicates the dependency between each instruction included in the intermediate language loop generated from the source code,
generating a first matrix by converting the generated dependency information into a matrix;
Allocating each instruction included in the loop into a plurality of groups based on the degree of dependence between each instruction calculated from the generated first matrix,
dividing the loop for each of the divided groups;
A compiler program that causes a computer to execute processing.

(Appendix 12)
In Appendix 11,
In the process of generating the first matrix,
determining whether the dependency information indicates that there is a dependency between instructions included in each combination for each combination of instructions included in the loop;
Among the combinations of instructions, the element corresponding to the combination in which the dependency information indicates that there is a dependency between instructions included in each combination is set as a first value, and each combination of the instructions includes generating the first matrix by setting, as a second value, an element corresponding to a combination in which the dependency information does not indicate that there is a dependency between the included instructions;
A compiler program characterized by:

(Appendix 13)
In Appendix 11,
In the process of assigning to the plurality of groups, each instruction included in the loop is assigned to a plurality of groups so as to reduce dependencies existing between instructions included in different groups.
A compiler program characterized by:

(Appendix 14)
In Appendix 11,
In the process of sorting into the plurality of groups,
generating a second matrix indicating the degree of dependency between instructions from the first matrix;
Allocating each instruction included in the loop to the plurality of groups based on the generated second matrix;
A compiler program characterized by:

1: Information processing device 5: Operation terminal 21: Source code 22: Intermediate language 23: Object code 130: Storage part NW: Network

Claims (11)

an information generation unit that generates dependency information indicating dependency relationships between instructions included in a loop of an intermediate language generated from a source code and converts the generated dependency information into a matrix to generate a first matrix;
a group sorting unit that sorts the instructions included in the loop into a plurality of groups based on the degree of dependence between the instructions calculated from the generated first matrix;
a loop dividing unit that divides the loop for each of the plurality of divided groups;
An information processing device characterized by: In claim 1,
The information generation unit
determining whether the dependency information indicates that there is a dependency between instructions included in each combination for each combination of instructions included in the loop;
Among the combinations of instructions, the element corresponding to the combination in which the dependency information indicates that there is a dependency between instructions included in each combination is set as a first value, and each combination of the instructions includes generating the first matrix by setting, as a second value, an element corresponding to a combination in which the dependency information does not indicate that there is a dependency between included instructions;
An information processing device characterized by: In claim 1,
The grouping unit sorts each instruction included in the loop into a plurality of groups so as to reduce dependencies existing between instructions included in different groups.
An information processing device characterized by: In claim 1,
The group allocation unit
generating a second matrix indicating the degree of dependency between instructions from the first matrix;
Allocating each instruction included in the loop to the plurality of groups based on the generated second matrix;
An information processing device characterized by: In claim 4,
The group allocation unit
calculating the degree of dependence between instructions included in each combination for each combination of instructions included in the loop;
generating the second matrix by using each of the calculated degrees of dependence as elements;
An information processing device characterized by: In claim 5,
The group allocation unit calculates the degree of dependence by using the Newman algorithm,
An information processing device characterized by: In claim 5,
The group allocation unit
determining to assign to the same group a plurality of instructions corresponding to the largest value among the values of the elements of the second matrix;
converting the plurality of rows corresponding to the plurality of instructions in the second matrix into a single row whose elements are sums of the same column-wise elements in the plurality of rows; and regenerate the first matrix by transforming the columns corresponding to the instruction of to a single column whose elements are the sums of the same row-wise elements in the columns;
regenerating the second matrix from the regenerated first matrix;
The determining process, the regenerating the first matrix, and the regenerating the second matrix are repeated until the number of groups determined as allocation destinations of the instructions included in the loop becomes equal to or less than a predetermined number. repeat,
An information processing device characterized by: In claim 2, further,
a proximity determination unit that determines whether or not the loop includes a plurality of instructions for accessing data stored in adjacent storage areas;
The information generation unit generates the first matrix based on a determination result as to whether the plurality of instructions are included in the loop.
An information processing device characterized by: In claim 8,
When the information generating unit determines that the plurality of instructions are included in the loop, the information generation unit sets the element corresponding to the plurality of instructions to a third value larger than the first value, generating the first matrix;
An information processing device characterized by: In claim 8,
each data stored in the adjacent storage area is the same array,
An information processing device characterized by: Generate dependency information that indicates the dependency between each instruction included in the intermediate language loop generated from the source code,
generating a first matrix by converting the generated dependency information into a matrix;
Allocating each instruction included in the loop into a plurality of groups based on the degree of dependence between each instruction calculated from the generated first matrix,
dividing the loop for each of the divided groups;
A compiler program that causes a computer to execute processing.

Images