JP6481515B2 - Information processing apparatus, compiling method, and compiler program - Google Patents

Description

  The present invention relates to a compilation technique.

  A compiler, which is a language processor, compiles a source program created by a user and generates an executable application (also called an object program). For example, by describing a source program while specifying an optimization option, the user can cause the compiler to perform optimization and improve the performance of the application. Particularly in the field of HPC (High Performance Computing), it is important to shorten the execution time of a program, and optimization by a compiler (called compiler optimization) is attracting attention.

  A technique called constant propagation is known as compiler optimization. Constant propagation is a technique that replaces variables in mathematical expressions with constants during compilation. Normally, constant calculation based on constant propagation is executed in the middle end or back end of the compiler. On the other hand, a very simple constant calculation is executed in the front end. A constant calculation function based on constant propagation may be implemented in the front end, but it may lead to an increase in compile time and is not preferred because it is a function dependent on the processing system.

  On the other hand, the standard C ++ 11 was formulated in 2011, and a specifier called constexpr (generalized CONSTant EXPRessions) was introduced. The user can add constexpr to variables, functions, and classes in the source program and have the compiler's front end perform these constant calculations. In the case of the above constant propagation, the constant calculation is performed every time the optimization function is applied. However, in the case of constexpr, the constant calculation can be performed all at once, so that the compilation time can be shortened.

  However, there is a problem that it is difficult for a general user to create a source program by using constexpr because there are various restrictions on language specifications in C + 11 constexpr. The prior art does not pay attention to such a problem.

JP 09-006627 A Japanese Translation of National Publication No. 06-501579 Japanese Patent Laid-Open No. 10-40114

  Therefore, the objective of this invention is providing the technique for shortening the execution time of a program in one side.

  The information processing apparatus according to the present invention specifies a specifying unit that specifies a variable that can be handled as a constant during compilation from among one or more variables included in the source program, and handles the specified variable as a constant during compilation. And a conversion unit for converting the source program to which the specifier is added into an object program.

  In one aspect, program execution time can be reduced.

FIG. 1 is a diagram for explaining constexpr. FIG. 2 is a diagram for explaining constexpr. FIG. 3 is a diagram for explaining constexpr. FIG. 4 is a functional block diagram of the information processing apparatus. FIG. 5 is a diagram illustrating a processing flow of processing for generating an arrangement table. FIG. 6 is a diagram illustrating an example of a source program. FIG. 7 is a diagram illustrating an example of a syntax tree. FIG. 8 is a diagram illustrating an example of an arrangement table. FIG. 9 is a diagram illustrating an example of a symbol table. FIG. 10 is a diagram showing a main processing flow. FIG. 11 is a diagram illustrating an example of a symbol table. FIG. 12 is a diagram showing a main processing flow. FIG. 13 is a diagram illustrating an example of a symbol table. FIG. 14 is a diagram illustrating an example of the corrected syntax tree. FIG. 15 is a diagram illustrating an example of an arrangement table. FIG. 16 is a diagram illustrating an example of a symbol table. FIG. 17 is a diagram illustrating an example of a modified source program. FIG. 18 is a diagram for explaining a difference between the method of the present embodiment and another method. FIG. 19 is a functional block diagram of a computer.

  Constexpr will be described with reference to FIGS. 1 to 3.

  FIG. 1 shows an example of a source program described using constexpr. The example of FIG. 1 is an example of calculating the area of a circle, and constexpr is added to a variable r, a variable pi, and a variable area. This allows constant calculations to be performed at compile time. In the standard before C ++ 11, an integer of an execution time constant can be handled as a compile time constant, but it is impossible in the standard to handle a floating point, a function, and a class as a compile time constant. A compile time constant is a constant whose value is calculated at the time of compilation, and an execution time constant is a constant whose value is calculated at the time of execution.

  However, as described above, the C ++ 11 constexpr has various restrictions on the language specifications, and therefore, the user does not have to simply add the constexpr. FIG. 2 shows an example in which an error occurs when constexpr is simply added to the source program. In the example of FIG. 2, an example is shown in which the result of adding the variable b to the variable a is returned. If constexpr is simply added to the source program shown in FIG. 2, the program shown in FIG. 3 is obtained. In the program shown in FIG. 3, constexpr is added to variables a and b. In the case of the program shown in FIG. 3, there is no problem with the code before the code “a + = b;”, but since a is a const (constant), a cannot be updated, and “a + = b An error occurs in the code “;”.

  If constexpr is forcibly added to the source program, the source program may be difficult to read or a source program that is not originally intended may be described. Further, even if a constexpr function explicitly created by an STL (Standard Template Library) or a user exists, if a passed argument is not a variable or literal declared as constexpr, it is not calculated at the time of compilation.

  In view of the above points, in the present embodiment, constexpr is added to the source program by the following method.

  FIG. 4 shows a functional block diagram of the information processing apparatus 1 in the present embodiment. The information processing apparatus 1 includes a source program storage unit 101, a lexical analysis unit 102, a syntax analysis unit 103, a syntax tree storage unit 104, a placement table storage unit 105, a symbol table storage unit 106, and a literal checker 108. A semantic analysis unit 107, an output unit 109, an intermediate code storage unit 110, an optimization unit 111, a generation unit 112, and an object program storage unit 113 are included.

  The source program storage unit 101 stores a source program created by a user. The lexical analysis unit 102 executes processing for dividing the source program stored in the source program storage unit 101 into tokens, and outputs the processing result to the syntax analysis unit 103. The syntax analysis unit 103 executes processing for generating a syntax tree based on the processing result received from the lexical analysis unit 102, and stores the syntax tree data as the processing result in the syntax tree storage unit 104. Further, the syntax analysis unit 103 executes processing for generating an allocation table and a symbol table based on the processing result received from the lexical analysis unit 102, stores the allocation table in the allocation table storage unit 105, and stores the symbol table in the symbol table. Stored in the unit 106. The literal checker 108 executes processing based on the data stored in the syntax tree storage unit 104, and based on the processing result, the arrangement table stored in the arrangement table storage unit 105 and the symbol table stored in the symbol table storage unit 106 Update. The output unit 109 corrects the source program based on the syntax tree data stored in the syntax tree storage unit 104 and the symbol table stored in the symbol table storage unit 106, and displays the corrected source program on a display device (for example, a display). To display. The semantic analysis unit 107 executes processing for determining whether there is a compile error based on the syntax tree data stored in the syntax tree storage unit 104, generates intermediate language code (ie, intermediate code), and performs intermediate processing. It is stored in the code storage unit 110. The optimization unit 111 performs compiler optimization on the intermediate code stored in the intermediate code storage unit 110, and outputs a code as an execution result to the generation unit 112. The generation unit 112 generates an object program from the code received from the optimization unit 111 and stores it in the object program storage unit 113.

  In the present embodiment, the lexical analysis unit 102, the syntax analysis unit 103, and the semantic analysis unit 107 correspond to the front end, the optimization unit 111 corresponds to the middle end, and the generation unit 112 corresponds to the back end. The semantic analysis unit 107, the intermediate code storage unit 110, the optimization unit 111, the generation unit 112, and the object program storage unit 113 are not related to the main parts of the present embodiment, and thus detailed description thereof is omitted. To do.

  Next, processing executed by the information processing apparatus 1 will be described with reference to FIGS. At the start of processing, the syntax tree data stored in the syntax tree storage unit 104, the allocation table stored in the allocation table storage unit 105, and the symbol table stored in the symbol table storage unit 106 are initialized.

  First, it is assumed that a source program is stored in the source program storage unit 101 of the information processing apparatus 1. In the present embodiment, it is assumed that the source program shown in FIG. 6 is stored in the source program storage unit 101. Then, the lexical analyzer 102 executes processing for dividing the source program stored in the source program storage unit 101 into tokens, and outputs the processing result to the syntax analyzer 103.

  The syntax analysis unit 103 generates a syntax tree from the processing result received from the lexical analysis unit 102 (FIG. 5: step S1), and stores the generated syntax tree data in the syntax tree storage unit 104. FIG. 7 shows an example of the syntax tree. In the example of FIG. 7, the token is shaded. Since the process of generating a syntax tree is well known, detailed description thereof is omitted here.

  The syntax analysis unit 103 determines whether there is an unprocessed token in the generated syntax tree (step S3). When there is an unprocessed token (step S3: Yes route), the syntax analysis unit 103 identifies one unprocessed token (step S5).

  The syntax analysis unit 103 determines whether the token specified in step S5 is a variable (step S7). In the present embodiment, a token indicated as “Variable” in the syntax tree is a variable. In the example of FIG. 7, a and b are variables. If the token is not a variable (step S7: No route), the process returns to step S3 to process the next token.

  On the other hand, when the token is a variable (step S7: Yes route), the syntax analysis unit 103 determines whether the token is included in the left side of the expression (step S9). In the example of FIG. 7, when the token is “Idx 0” token in “Line2”, or “Idx 0” token in “Line4” or “Idx 0” token in “Line5”, It is judged that it is included.

  When the token is included in the left side of the expression (step S9: Yes route), the syntax analysis unit 103 adds a new entry including the variable name and the left side value to the arrangement table stored in the arrangement table storage unit 105 (step S9). S11). Then, the process returns to step S3. In the present embodiment, the left side value is represented in the format (x), and the right side value is represented in the format (x, y). x is a row number, and y is an index number.

  When the token is not included in the left side of the expression (step S9: No route), the syntax analysis unit 103 adds the right-side value to the existing entry of the arrangement table stored in the arrangement table storage unit 105 (step S13). Then, the process returns to step S3.

  FIG. 8 shows an example of an arrangement table stored in the arrangement table storage unit 105. In the example of FIG. 8, a variable name, a left side value, and a right side value are stored.

  On the other hand, when there is no unprocessed token (step S3: No route), the syntax analysis unit 103 generates a symbol table for the source program, stores it in the symbol table storage unit 106, and ends the process.

  FIG. 9 shows an example of a symbol table. In the example of FIG. 9, the variable type, variable name, and attribute are stored. At the time of this processing, no data is stored in the attribute column.

  Next, processing executed by the literal checker 108 will be described. When the generation of the arrangement table and the symbol table is completed, the literal checker 108 searches for an unprocessed variable in the arrangement table stored in the arrangement table storage unit 105 (FIG. 10: Step S21).

  The literal checker 108 determines whether there is an unprocessed variable in the arrangement table storage unit 105 (step S23). When there is an unprocessed variable (step S23: Yes route), the literal checker 108 specifies one unprocessed variable from the arrangement table (step S29).

  The literal checker 108 determines whether the right side of the expression specified by the line number of the left-side value of the variable specified in step S29 is a compile time constant (step S31). In the present embodiment, if the right side is a constant such as “10” or “20”, it is determined that it is a compile time constant. Further, even if the right side includes a variable, if the attribute of the variable is constexpr, it is determined that it is a compile time constant. That is, in step S31, the literal checker 108 determines whether or not the right side of the expression is a literal.

  If the right side is not a compile time constant (step S31: No route), the process returns to step S21. On the other hand, when the right side is a compile time constant (step S31: Yes route), the literal checker 108 determines whether the variable attribute has already been set to “constexprpr” in the symbol table (step S33).

  If the attribute of the variable is already set to “constexprpr” in the symbol table (step S33: Yes route), the process returns to step S21. On the other hand, if the variable attribute is not yet set to “constexpr” in the symbol table (step S33: No route), the literal checker 108 sets the attribute of the variable identified in step S29 to “constexpr” (step S35). ). The processing shifts to the processing in step S37 in FIG.

  FIG. 11 shows an example of data stored in the symbol table after the process of step S35. In the example of FIG. 11, the attribute of the variable a is set to “constexpr”.

  Shifting to the description of FIG. 12, the literal checker 108 determines whether an entry having the same variable name as the variable name identified in step S29 still exists in the arrangement table (FIG. 12: step S37). If no entry with the same variable name exists in the arrangement table (step S37: No route), the process returns to the process of step S21 via the terminal B.

  On the other hand, if an entry with the same variable name still exists in the allocation table (step S37: Yes route), the literal checker 108 identifies one variable having the same variable name (step S38). Then, the literal checker 108 changes the variable name of the variable identified in step S38 (step S39). In step S39, for example, a new variable name in the SSA format (Static Single Assignment form) is assigned.

  The literal checker 108 registers the new variable name in the symbol table (step S41). FIG. 13 shows an example of data stored in the symbol table after the process of step S41. In the example of FIG. 13, the new variable name “a2” is newly registered in the symbol table.

  The literal checker 108 updates the variable name in the syntax tree and the variable name in the arrangement table for the variable changed to the new variable name (step S43). Then, the process returns to step S37.

  FIG. 14 shows an example of the syntax tree after the processing in step S43. In the example of FIG. 14, the variable name of the token “Idx 0” in “Line 5” and the variable name of the token “Idx 0” in “Line 6” with black arrows are added from “a” to “ a2 ".

  FIG. 15 shows an example of the arrangement table after the process of step S43. In the example of FIG. 15, the variable name in the entry on the third line is changed from “a” to “a2”.

  Returning to the description of FIG. 10, when there is no unprocessed variable (step S23: No route), the literal checker 108 notifies the output unit 109 that the analysis is completed. In response to this, the output unit 109 generates a corrected source program based on the syntax tree data stored in the syntax tree storage unit 104 and the symbol table stored in the symbol table storage unit 106 (step S25).

  FIG. 16 shows an example of data stored in the symbol table at the time of processing in step S25. In the example of FIG. 16, the attribute “constexprr” is set for any of the variable a, the variable b, and the variable a2. In such a state, the output unit 109 corrects the source program as shown in FIG. 17, for example. That is, the output unit 109 adds the specifier “constexpr” to the declaration statement of the variable for which the attribute “constexpr” is set in the symbol table. Here, for the variable a2, the code “a + = b;” is rewritten to the code “a2 = a + b” based on the data of the syntax tree.

  The output unit 109 displays the corrected source program on the display device (step S27). Then, the process ends. As a result, the user can confirm the contents of the modified source code and can be used as a reference for future program development.

  In this way, the constant calculation is executed at the time of compilation instead of at the time of execution, so that the execution time can be shortened. In addition, since the normal optimization unit 111 performs optimization on the intermediate code, the entire source code cannot be grasped, and the effective range of the variable is not known. Therefore, optimization that cannot be performed may occur. However, in this embodiment, since optimization is performed also in the front end, a wider range of optimization can be performed than when optimization is performed only by the optimization unit 111.

  Further, since constexpr is automatically added to the source code, even when the user's knowledge and skills are insufficient, the source level can be optimized.

  Further, by using the arrangement table as described above and replacing only the tokens affected by the change of the variable name among the tokens in the syntax tree, high-speed replacement becomes possible.

  In addition, since there is a high possibility that an argument passed to an existing constexpr function or class becomes a compile time constant, the scope of application of constexpr can be expanded. As a result, the execution time can be further shortened.

  In addition, optimization is performed in the optimization unit 111 after a part that can be calculated in the front end is calculated, so that the processing to be performed by the optimization unit 111 can be reduced.

  Further, since constexpr is added so as to comply with the language standard, it is possible to cause another compiler to compile the corrected source code. Further, the method of the present embodiment does not depend on the architecture.

  The difference between the method of the present embodiment (hereinafter referred to as the present method) and another method will be described with reference to FIG. Here, each method is compared from four viewpoints of dependency on the processing system, compilation time, execution time, and convenience.

  First, this method and the method of manually adding constexpr can be applied to any compiler that supports C ++ 11. On the other hand, constant propagation (that is, optimization by the middle end or back end) requires the creation of the optimization unit 111 of the compiler, so that other compilers cannot use the function of the optimization unit 111. That is, constant propagation depends on the processing system.

  In addition, according to the present method and the method of manually adding constexpr, constant calculation can be executed in a lump, so that the compilation time can be shortened. On the other hand, in the case of constant propagation, constant propagation is performed each time the optimization function is applied in the optimization unit 111, so that the compilation time is longer than that in the present method.

  Further, in this method, constexpr is added without mechanical leakage, so that execution performance is improved and execution time is shortened as compared with a method of adding constexpr manually.

  Moreover, in this method, since the user does not need to understand how to use constexpr, convenience can be improved. Moreover, since it complies with the language specification of C ++ 11, it is possible to compile the corrected source program in another processing system. On the other hand, the method of manually adding constexpr is less convenient than the present method because the user must understand how to use constexpr.

  Although one embodiment of the present invention has been described above, the present invention is not limited to this. For example, the functional block configuration of the information processing apparatus 1 described above may not match the actual program module configuration.

  Further, the configuration of data holding described above is an example, and the configuration as described above is not necessarily required. Further, in the processing flow, the processing order can be changed if the processing result does not change. Further, it may be executed in parallel.

  Further, the corrected source code and the original source code may be displayed side by side. In addition, although an example in which the corrected source code is displayed on the display device has been described, a sheet on which the corrected source code is described may be printed from a printer or the like. Also,

  The information processing apparatus 1 described above is a computer apparatus, and as shown in FIG. 19, a memory 2501, a CPU (Central Processing Unit) 2503, a hard disk drive (HDD: Hard Disk Drive) 2505, and a display device. A display control unit 2507 connected to 2509, a drive device 2513 for the removable disk 2511, an input device 2515, and a communication control unit 2517 for connecting to a network are connected by a bus 2519. An operating system (OS) and an application program for executing the processing in this embodiment are stored in the HDD 2505, and are read from the HDD 2505 to the memory 2501 when executed by the CPU 2503. The CPU 2503 controls the display control unit 2507, the communication control unit 2517, and the drive device 2513 according to the processing content of the application program, and performs a predetermined operation. Further, data in the middle of processing is mainly stored in the memory 2501, but may be stored in the HDD 2505. In the embodiment of the present invention, an application program for performing the above-described processing is stored in a computer-readable removable disk 2511 and distributed, and installed in the HDD 2505 from the drive device 2513. In some cases, the HDD 2505 may be installed via a network such as the Internet and the communication control unit 2517. Such a computer apparatus realizes various functions as described above by organically cooperating hardware such as the CPU 2503 and the memory 2501 described above and programs such as the OS and application programs. .

  The embodiment of the present invention described above is summarized as follows.

  The information processing apparatus according to the first aspect of the present embodiment includes (A) a specifying unit that specifies a variable that can be handled as a constant at compile time among one or more variables included in a source program; B) An adder that adds to the source program a specifier that declares that the specified variable is handled as a constant at compile time, and (C) a conversion unit that converts the source program with the specifier added to an object program. Have.

  In this way, it is possible to perform calculations performed at the time of compilation at the time of compilation, so that the time required for execution can be shortened.

  The specifying unit described above specifies (a1) an expression including the variable on the left side for each of one or more variables included in the source program, and (a2) one or more variables included in the source program. Of the variables, a variable that satisfies the condition that the right side of the specified expression is a constant may be specified. This makes it possible to appropriately specify variables that can be handled as constants at the time of compilation.

  In addition, when the left side of the expression in the source program includes a plurality of the same variables, the information processing apparatus assigns a different variable name to each of the plurality of the same variables, and corrects the source program according to the assignment of the variable names. You may have further the correction part to do. In this way, it is possible to cope with a case where there is a variable whose value is updated.

  The information processing apparatus may further include an output unit that outputs a source program to which (E) a specifier is added. In this way, a source program creator or the like can confirm a description method effective for shortening the execution time.

  In the compiling method according to the second aspect of the present embodiment, (F) one or more variables included in the source program is specified as a constant that can be handled at compile time, and (G) is specified. A specifier for declaring that a variable is handled as a constant at compile time is added to the source program, and (H) includes processing for converting the source program to which the specifier has been added into an object program.

  A program for causing a computer to perform the processing according to the above method can be created. The program can be a computer-readable storage medium such as a flexible disk, a CD-ROM, a magneto-optical disk, a semiconductor memory, a hard disk, or the like. It is stored in a storage device. The intermediate processing result is temporarily stored in a storage device such as a main memory.

  The following supplementary notes are further disclosed with respect to the embodiments including the above examples.

(Appendix 1)
A specifying unit for specifying a variable that can be handled as a constant during compilation from among one or more variables included in the source program;
An adder that adds to the source program a specifier that declares that the identified variable is treated as a constant at compile time;
A conversion unit that converts the source program to which the specifier is added into an object program;
An information processing apparatus.

(Appendix 2)
The specific part is:
For each of one or more variables included in the source program, specify an expression that includes the variable on the left side,
Specifying a variable that satisfies a condition that the right side of the specified expression is a constant among one or more variables included in the source program,
The information processing apparatus according to attachment 1.

(Appendix 3)
Appendix 1 or 2. The information processing apparatus according to 2.

(Appendix 4)
The information processing apparatus according to any one of supplementary notes 1 to 3, further comprising: an output unit that outputs the source program to which the specifier has been added.

(Appendix 5)
Identify one or more variables included in the source program that can be handled as constants at compile time,
Add a specifier to the source program that declares the identified variable to be treated as a constant at compile time,
Converting the source program to which the specifier is added into an object program;
A compilation method in which processing is performed by a computer.

(Appendix 6)
Identify one or more variables included in the source program that can be handled as constants at compile time,
Add a specifier to the source program that declares the identified variable to be treated as a constant at compile time,
Converting the source program to which the specifier is added into an object program;
A compiler program that causes a computer to execute processing.

DESCRIPTION OF SYMBOLS 1 Information processing apparatus 101 Source program storage part 102 Lexical analysis part 103 Syntax analysis part 104 Syntax tree storage part 105 Arrangement table storage part 106 Symbol table storage part 107 Semantic analysis part 108 Literal checker 109 Output part 110 Intermediate code storage part 111 Optimization Unit 112 generation unit 113 object program storage unit

Claims (6)

A specifying unit for specifying a variable that can be handled as a constant at the time of compiling among one or more variables included in the source program;
An adder that adds to the source program a specifier that declares that the identified variable is treated as a constant at compile time;
A conversion unit that converts the source program to which the specifier is added into an object program;
An information processing apparatus. The specific part is:
For each of one or more variables included in the source program, specify an expression that includes the variable on the left side,
Specifying a variable that satisfies a condition that the right side of the specified expression is a constant among one or more variables included in the source program,
The information processing apparatus according to claim 1. When the left side of the expression in the source program includes a plurality of the same variables, the modification unit further assigns a different variable name to each of the plurality of the same variables, and modifies the source program according to the assignment of the variable names. Or the information processing apparatus of 2. The information processing apparatus according to claim 1, further comprising: an output unit that outputs the source program to which the specifier is added. Identify one or more variables included in the source program that can be handled as constants at compile time,
Add a specifier to the source program that declares the identified variable to be treated as a constant at compile time,
Converting the source program to which the specifier is added into an object program;
A compilation method in which processing is performed by a computer. Identify one or more variables included in the source program that can be handled as constants at compile time,
Add a specifier to the source program that declares the identified variable to be treated as a constant at compile time,
Converting the source program to which the specifier is added into an object program;
A compiler program that causes a computer to execute processing.

Images