JP4985461B2 - Compiler, compiling method, and program - Google Patents

Description

  The present invention relates to a compiler, a compiling method, and a program. More specifically, the present invention relates to a compiler that generates a program corresponding to a source program, a compiling method, and a program.

  A subprogram (procedure, function, subroutine, etc.) in a program may be described as a “generic subprogram” that operates on a plurality of types of data having different types and structures. In particular, this includes embedded subprograms and runtime library routines provided by the language processor. Since such a generic subprogram is described so as to operate on all possible patterns of the type of target data, it does not necessarily operate in an optimum manner for each pattern. Furthermore, in a parallel language represented by High Performance Fortran (HPF), generic subprograms include a parallelization method (eg, data distribution type) and a parallel execution environment (eg, the number of processors and mutual information) in addition to the type of target data. The topology of the coupled network also needs to be generic. For this reason, the performance overhead is likely to be further increased.

  Here, as a technique related to program optimization in compilation, there are techniques described in Patent Document 1 and Patent Document 2. In Patent Document 1, first, a procedure code (profile code) that records a value taken by a variable in the program in association with a frequency at which the value is taken is added to the optimization target program, and the variable is taken when the program is executed. The value and its frequency are stored as profile information. Next, a program part using a variable is specially added with a value (specific value) of a high-frequency variable and newly added, and when the variable value matches the specific value at the time of execution, the newly added program part Generate code that executes (specialized part). By generating an object program from such code, a program that can be executed at high speed can be obtained.

In Patent Document 2, first, a source program described in a high-level language is compiled to generate a first object code that is an object code for the program. Next, a measurement code for measuring dynamic data when executing the first object code is inserted into the first object code. Subsequently, an optimization process is performed on the first object code using information obtained from the measurement data obtained by executing the first object code. Thereafter, a translation code for performing processing for translating the first object code into the optimized second object code is generated and added to the first object code. In this way, even if the environment for executing the application is different from the environment at the time of compiling the source program, optimization according to the execution environment is possible.
JP-A-11-149380 JP 2002-351474 A

  As a technique to solve the problem of performance overhead caused by the subprogram being “generic”, a “specialized” subprogram is prepared for specific data and parallel execution environments. In addition, if the actual data or parallel execution environment meets the conditions, a method of using the specialized program can be considered. Since the operation of a specialized program is optimized under specific conditions, the performance overhead is small and it can be expected to operate in an optimal manner.

There are five methods (a) to (e) shown below as methods related to specialization of subprograms.
(A) Selection of subprogram by IF syntax on user program:
Determine the specialization application conditions ("specialization conditions") at runtime and select the appropriate subprogram call with IF syntax:
(B) Branch of processing by IF syntax in embedded subprogram or runtime library routine:
In an embedded subprogram or runtime library routine, the optimum process is selected according to the individual pattern of the target data.
(C) Subprogram overload and override:
Generic subprograms and specialized subprograms with the same name are defined by functions such as overloading and overriding of subprograms. Which subprogram is actually called depends on whether the processing system is compiled or executed. decide.
(D) Template specialization:
If a template of a language such as C ++ is used, a specialized subprogram that is applied only when a specific condition is met can be defined.
(E) Automatic specialization by language processing system:
The language processor automatically generates specialized subprograms from information obtained by interprocedural analysis and runtime profiling.
The approaches of Patent Document 1 and Patent Document 2 are close to the above method (d).

  However, the above method (a) has the following problems. That is, in the method (a), since a code for calling a subprogram must be added for each type of specialization, it is necessary to rewrite the code. Further, since only the specialization for the subprogram that is explicitly called on the source program can be described, it cannot be applied to the specialization of the runtime library routine that is implicitly called by the processing system for various runtime processing. In addition, the method (b) has a problem that there is no effect except for a corresponding pattern. In other words, since the user cannot usually deal with the code of the embedded subprogram or the runtime library routine, the user cannot expand the corresponding pattern.

  In the method (c), which subprogram is actually called is determined based only on information (generally, the type and number of arguments) defined by the language specification, so that there are large restrictions on specialization conditions that can be specified. There's a problem. In other words, all specialization conditions must be expressed as the type itself (a type indicating that the size of the e.g. array is a power of 2). Such a method is cumbersome, and not many languages have the "dynamic type generation" function necessary for realizing specialization based on indefinite dynamic information (eg parallel execution environment) at the time of compilation. . That is, it is difficult or difficult to specify flexible specialization conditions based on information such as the type of data distribution and the parallel execution environment.

  In the method (d), only information such as type names and integer values can be specified as template parameters, and template instantiation is performed at compile time. Therefore, as with the method (c), there are large restrictions on the specialization conditions that can be specified. The method (e) can only realize a standard specialization (eg constant convolution) based on the value or type of an argument, and cannot achieve a highly effective advanced specialization (eg algorithm specialization). There is.

  An object of the present invention is to provide a compiling method, a compiler, and a program capable of arbitrary specialization for an arbitrary generic subprogram.

  In order to achieve the above object, the compiling method of the present invention uses a computer and includes a description specifying a specialized subprogram for a generic subprogram and indefinite information at the time of compilation, and the specialized subprogram is applied. Compiling a source program including a description for setting specialization conditions, wherein the computer records the specialization subprogram and specialization conditions included in the source program in a specialization information table; The computer detecting a call of a generic subprogram in which a specialized subprogram is designated based on the source program; and the computer refers to the specialized information table to detect the detected generic subprogram. Specialized subprogram special corresponding to Determining whether or not the condition is satisfied at the time of compiling; and determining whether or not the specialization condition is satisfied at the time of compiling in the determining step; Converting a code to be called into a code to call the specialization subprogram when the specialization condition is satisfied.

The compiler of the present invention includes a description for specifying a specialized subprogram for a generic subprogram and a description for setting specialization conditions to which the specialized subprogram is applied, including indefinite information at the time of compilation. to enter the source program, the syntax analysis unit for a specialized sub-program and specialized conditions Ru is recorded in specialized information table, to the computer, on the basis of the source program, the special subprogram is specified and specialization detector for Ru is detected the call generic subprogram, the computer, the by referring to specialized information table, special conditions of specialized sub-programs corresponding to the detected generic subprogram and special conditions determination unit for but that Ru is determined whether or not satisfied at compile When the front Symbol specialized conditions Ru is determined that established at compile time, the computer, the code that calls the generic subprogram, the specialized conditions is converted to the code that calls the specialized subprogram satisfied, the special conditions When but Ru is determined whether established at compile time is indefinite, the code that calls the generic subprogram, code conversion for Ru is converted to code that calls the special subprogram during establishment of the special conditions A generation unit is provided.

  The program of the present invention includes a description for specifying a specialized subprogram for the generic subprogram in the computer and a description for setting specialization conditions to which the specialized subprogram is applied, including indefinite information at the time of compilation. A program for executing a process of compiling a source program, wherein the computer records the specialization subprogram and specialization conditions included in the source program in a specialization information table, and based on the source program , Processing for detecting a call of a generic subprogram with a specified special subprogram, and referring to the specialization information table, the specialization condition of the specialization subprogram corresponding to the detected generic subprogram is determined at compile time. A process for determining whether or not it is established; If it is determined in the processing that the specialization condition is satisfied at the time of compilation, the computer calls the generic subprogram code that calls the specialization subprogram when the specialization condition is satisfied And a process of converting the data into the data.

  The compiling method, compiler, and program of the present invention can perform any specialization for any generic subprogram.

  Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings. FIG. 1 shows a compiler according to an embodiment of the present invention. The compiler 101 includes a syntax analysis unit 102, a specialization unit 103, a parallelization unit 107, an optimization unit 108, and a code generation unit 109. The compiler 101 inputs the source program 100 and outputs an object program 110. The function of each part in the compiler 101 is realized by executing a predetermined program on a computer. The compiler 101 has a function of statically evaluating an expression in the source program 100, such as constant propagation and constant folding.

  The source program 100 is a program written in a predetermined language. The source program 100 includes a description for specifying a specialized subprogram for the generic subprogram and a description for setting the specialization condition. The syntax analysis unit 102 performs syntax analysis of the source program 100 and generates various information tables including a specialization information table 111 and a subprogram information table 112. The syntax analysis unit 102 records in the specialization information table 111 the specialization subprogram described in the source program 100 and the specialization conditions set in the specialization subprogram. The syntax analysis unit 102 records information on all subprograms appearing in the source program 100 in the subprogram information table 112. At this time, for a subprogram that has been declared specialization, a flag indicating that specialization is declared (“specialization flag”) is set to ON, and the corresponding specialization information table 111 is displayed. Set the link.

  The specialization unit 103 specializes the subprogram. In subprogram specialization, the subprogram information table 112 is referred to and it is determined whether or not specialization is declared for the generic subprogram called when the source program is executed. When specialization is declared, it is determined by referring to the specialization information table 111 whether the specialization condition is satisfied at the time of compilation. If it is determined that it is established, the generic subprogram call is replaced with a specialized subprogram call. When it is not possible to determine whether or not it is established at the time of compilation (indefinite), the calling portion of the generic subprogram is converted into a code that calls the specialized subprogram when the specialization condition is satisfied at the time of execution. If it is determined that it does not hold, the generic subprogram is still called. The parallelization unit 107 parallelizes the program as necessary. The optimization unit 108 applies various optimizations. The code generation unit 109 generates an object code.

In this embodiment,
(1) Language function for describing specialization of generic subprogram in source program 100 (2) Specialization unit 103
(3) Specialization information table 111
is important. Each will be described in more detail below.

  First, language functions for describing the specialities of generic subprograms will be described. Extends the language and adds the following functions to declare specializations for generic subprograms and to set specialization conditions. FIG. 2 shows an example of a program that specializes generic subprograms in HPF. Note that the language extension grammar used in FIG. 2 is an example, and the grammar is not limited to this. That is, the language functions that can be realized by the grammar illustrated in FIG. 2 are defined, and the grammar itself is not defined.

-Function for declaring specialization for generic subprograms Specify specialized subprograms for generic subprograms (including built-in subprograms and runtime library routines). In FIG. 2, a specialized subprogram for the runtime library procedure redist_copy of the HPF is specified by a syntax obtained by extending the Fortran citation specification declaration. Two specialized subprograms redist_copy_square and redist_copy_block are designated as specialized subprograms for redist_copy.

  hpf (redist_copy) specified as a generic name in the interface statement indicates that the citation specification declaration specifies a generic citation specification for the HPF runtime library procedure redist_copy. The cited specification body is described between the paired end interface. The special specifier specified as the prefix of the subroutine statement in the citation specification body declares that the procedure declared in the subroutine statement is a "specialized citation specification" of the generic procedure specified by the citation specification declaration. To do. a1 and a2 of redist_copy_square (a1, a2) represent arguments of the specialized subprogram. Between the subroutine and the end subroutine, variable declarations including arguments and specialization conditions are described.

-Function to set specialization conditions Clarify the conditions for applying specialization subprograms in the cited specification body. Specialize_if (...) that appears in the declaration part of the cited specification body specifies the "specialization condition" for the specialization procedure. A special condition can be specified in parentheses in the specialize_if statement as a logical scalar whose all operations are built-in and whose primary is a restricted expression or special condition temporary variable. Is an expression. Here, the special condition temporary variable is a variable having an initial value expression in which all the operations therein are built-in and all the primary elements are restriction expressions or special condition temporary variables ( eg Variable np in Figure 2).

  By defining the specialization conditions described above, dynamic conditions that are undefined at the time of compilation and may be determined at the time of execution, such as the number of processors in parallel execution and values of certain variables, can be set as the specialization conditions. Further, the descriptive distribution directive (e.g. distribute directive in the citation specification body of FIG. 2) for the dummy argument specified in the specialization citation specification is regarded as an implicit specialization condition.

  Next, the specialization unit 103 will be described in detail. The specialization unit 103 includes a specialization detection unit 104, a specialization condition determination unit 105, and a code conversion / generation unit 106. The specialization detection unit 104 refers to the subprogram information table 112 when processing the call of the generic subprogram called by program execution, and whether or not a specialization subprogram is specified for the subprogram. Is detected. The specialization condition determination unit 105 refers to the specialization information table 111 when the specialization subprogram for the generic subprogram being processed is designated, and determines whether the corresponding specialization condition is successful. When a plurality of specialized subprograms are designated for one generic subprogram, one entry is taken out from the specialization information table 111, and each specialization condition is determined.

  When the specialization condition determination unit 105 determines that the specialization condition is satisfied, the code conversion / generation unit 106 replaces the generic subprogram call with the specialization subprogram call. If it is uncertain at the time of compilation whether or not the specialization condition is satisfied, the success or failure of the specialization condition is determined at execution time, and the corresponding specialized subprogram or the original generic subprogram is called based on the result Generate code. When a plurality of specialization conditions are satisfied, a code is generated so that the specialization subprogram that appears at the top of the specialization information table 111 is called preferentially.

  Next, the specialization information table 111 will be described. The specialization information table 111 has a plurality of tables corresponding to the generic subprograms that have been declared specialization. In each table, the names, arguments, and specialization conditions of each specialized subprogram specified for the corresponding generic subprogram are recorded in the order in which they appear in the quoted specification declaration of the generic subprogram.

  FIG. 3 shows an operation procedure of the specialization unit 103. When the specialization detection unit 104 detects a subprogram call, the specialization detection unit 104 refers to the subprogram information table 112 and determines whether or not the specialization flag of the subprogram is on (step S1). If it is determined that the specialization flag is not on, there is no specialized subprogram for the subprogram, and the code conversion / generation unit 106 generates a call to the original generic subprogram (step S13). That is, the generic subprogram is not replaced with the specialized subprogram.

  If the specialization detection unit 104 determines that the specialization flag is on in step S1, the specialization detection unit 104 determines whether there is an unprocessed entry in the corresponding specialization information table 111 (step S2). If there is an unprocessed entry, the first entry among the unprocessed entries is selected as the current entry. The specialization condition determination unit 105 determines whether or not the specialization condition of the current entry is satisfied at the time of compilation, or whether it cannot be determined at the time of compilation and is indefinite (step S3). If the condition is not satisfied, the current entry has been processed, the process returns to step S2, and the next unprocessed entry is selected. When it is not determined that any specialization condition is satisfied or indefinite, and the determination of the specialization condition for all entries is completed, the process proceeds from step S2 to step S13 to generate the original generic subprogram call. To do. When it is determined in step S3 that the specialization condition of any entry is satisfied, the code conversion / generation unit 106 converts the code obtained by converting the subprogram call into the specialization subprogram call of the entry. Generate (step S10).

  If it is determined in step S3 that the code conversion / generation unit 106 is indefinite, the code conversion / generation unit 106 generates an IF syntax using the specialization condition of the current entry as a conditional expression (step S4). When a specialization temporary variable appears in the specialization condition, the declaration is generated in the declaration part, and the definition is generated immediately before the IF syntax. Formal arguments appearing in the definition of specialization conditions or specialization temporary variables are replaced with the corresponding actual arguments. Thereafter, the code conversion / generation unit 106 generates a call for the specialized subprogram of the current entry in the IF syntax generated in step S4, and sets the current entry as processed (step S5). In step S5, the specialized subprogram is described as a subprogram that is executed when the conditional expression is satisfied in the IF syntax generated in step S4, so that the part that calls the generic subprogram is special when the specialization condition is satisfied. Is converted into code that calls the generalized subprogram.

  Subsequently, the specialization detection unit 104 determines whether or not there is an unprocessed entry in the specialization information table 111 (step S6). If there is an unprocessed entry, the first entry is selected as the current entry. The specialization condition determination unit 105 determines whether or not the specialization condition of the current entry is satisfied at the time of compilation or is indefinite (step S8). If determined to be indeterminate, the code conversion / generation unit 106 generates an ELSE IF statement that uses the specialization condition of the current entry as a conditional expression (step S11). At this time, if a specialization temporary variable appears in the specialization condition, the declaration is generated in the declaration part, and the definition is generated immediately before the IF syntax. A dummy argument that appears in the definition of a specialization condition or specialization temporary variable is replaced with the corresponding actual argument. The code conversion / generation unit 106 generates a call to the specialization subprogram of the current entry and sets the current entry as processed (step S12). The specialized subprogram generated in step S12 is a subprogram executed when the ELSE IF conditional expression generated in step S11 is satisfied. Thereafter, the process returns to step S6, and the next entry is selected.

  If the specialization detection unit 104 determines in step S8 that the specialization condition is satisfied, the code conversion / generation unit 106 generates an ELSE statement (step S9), and proceeds to step S10 to call the specialization subprogram. Generate. That is, a call to a specialized subprogram that is executed when a conditional expression of the immediately preceding IF syntax is not satisfied is generated. When the specialization condition is not satisfied, the process returns to step S6. If it is determined in step S6 that there is no unprocessed entry, that is, if all the specialization conditions have been determined, the code conversion / generation unit 106 generates an ELSE statement (step S7), and the process proceeds to step S13. Go ahead and generate generic subprogram calls. That is, a generic subprogram call that is executed when the conditional expression of the immediately preceding IF syntax is not satisfied is generated.

  A specific example of the operation of the specialization unit 103 will be described below using the program shown in FIG. For ease of explanation, the program shown in FIG. 2 clearly shows the call to redist_copy, but the HPF runtime library procedure is originally called implicitly by the processing system, and from the user program. Note that it is not usually called directly. Prior to the processing shown in FIG. 3, the syntax analysis unit 102 generates a specialized information table 111 and a subprogram information table 112 from the program shown in FIG.

  FIG. 4 shows data examples of the specialization information table 111 and the subprogram information table 112. In FIG. 2, a special specifier exists between interface and end interface for redist_copy specified as a generic name in the interface statement, so the specialization flag is set to ON for the generic subprogram redist_copy. . In addition, a link to a specialization information table that records information of the specialization subprogram for the created / created redist_copy is set.

  In FIG. 2, two specialized subprograms redist_copy_square and redist_copy_block are declared for the HPF runtime library procedure redist_copy. The syntax analysis unit 102 registers these specialized subprograms in each entry of the specialized information table 111 for redist_copy. Each entry has a procedure name, arguments, and specialization conditions for the specialization procedure. For example, for the procedure name `` redist_copy_square '', arguments `` real a1 (:, :), a2 (:, :), distribute a1 (*, block), distribute a2 (block, *) '', specialization condition `` mod (size (a1,1), np) == 0 .and. mod (np, 2) == 0 ”is registered.

  The specialization unit 103 detects a part that calls a subprogram in the program. At this time, the specialization unit 103 detects not only a subprogram that is explicitly called on the source program but also a subprogram that is implicitly called when the source program is executed. When the specialization unit 103 detects the call to redist_copy (x1, x2), the specialization detection unit 104 searches the subprogram information table 112 in step S1 to check whether the specialization flag of redist_copy is on. . Since the specialization flag is on, the process proceeds to step S2. The specialization condition determination unit 105 sets the first entry (redist_copy_square) in the specialization information table 111 as the current entry. Thereafter, in step S3, it is determined whether or not a special condition for the current entry is satisfied.

  In determining the specialization condition, the argument (a1, a2) included in the specialization condition is converted into the argument (x1, x2) at the time of calling the subprogram, and then the condition determination is performed. Referring to FIG. 2, the size of the first dimension of the first argument x1 is 1024, and the value of np (= number_of_processors ()) is 8 (2nd and 3rd lines). The former part mod (size (x1,1), np) == 0 holds. Further, the latter part mod (np, 2) == 0 also holds. Accordingly, the process proceeds from step S3 to step S10. The code conversion / generation unit 106 generates a call to the specialization subprogram (redist_copy_square), and ends the process for redist_copy (x1, x2).

  Next, when the specialization unit 103 detects a call to redist_copy (y1, y2), the specialization detection unit 104 searches the subprogram information table 112 in step S1 and determines that the specialization flag of redist_copy is on. judge. The specialization condition determination unit 105 sets the first entry (redist_copy_square) in the specialization information table 111 as the current entry in step S2, and determines whether the specialization condition for the current entry is satisfied in step S3.

  When the success / failure of the specialization condition of redist_cpoy_square is determined, it is uncertain whether mod (size (y1,1), np) == 0, which is the preceding part of the specialization condition, is satisfied. Accordingly, the process proceeds from step S3 to steps S4 and S5, and the code conversion / generation unit 106 calls the IF syntax that uses the specialization condition as a conditional expression and the calling of the specialization subprogram executed when the conditional expression is satisfied ( redist_copy_square). At this time, since the distribute directive is regarded as an implicit specialization condition, a condition corresponding to the distribute directive is added to the specialization condition. Prior to the IF syntax, a declaration (integer np) and a definition (np = number_of_processors ()) of the specialization temporary variable np are also generated.

  In step S5, after calling a specialized subprogram, the process proceeds to step S6. The specialization condition determination unit 105 selects the second entry (redist_copy_block) as the current entry in step S6, and determines whether the specialization condition for the current entry is satisfied in step S8. Since the success or failure of the specialization condition is also undefined, the process proceeds from step S8 to step S11. In steps S11 and S12, the code conversion / generation unit 106 generates an else if statement and a call to a specialized subprogram (redist_copy_square) that is executed when the conditional expression of the else if statement is satisfied. Then, it returns to step S6.

  If an attempt is made to select the next entry in step S6, since no unprocessed entries remain in the specialization information table 111, the process proceeds from step S6 to step S7. In step S7, the code conversion / generation unit 106 generates an else statement corresponding to the else if generated in step S11. In step S13, the code conversion / generation unit 106 generates a call to the original generic subprogram (redist_copy), and redist_copy (y1, The process for y2) is terminated.

  Subsequently, when the specialization unit 103 detects a call to redist_copy (z1, z2), the specialization detection unit 104 searches the subprogram information table 112 in step S1, and determines that the specialization flag of redist_copy is on. judge. The specialization condition determination unit 105 sets the first entry (redist_copy_square) in the specialization information table 111 as the current entry in step S2, and determines whether the specialization condition for the current entry is satisfied in step S3. Since this specialization condition is not satisfied, the process returns to step 2 to select the next entry (redist_cpoy_block).

  If it is determined in step S3 whether or not the specialization condition for redist_cpoy_block is satisfied, the condition is not satisfied, and the process returns to step 2. If an attempt is made to select the next entry in step S2, since there are no unprocessed entries remaining in the specialization information table 111, the process proceeds from step S2 to step S13. In step S13, the code conversion / generation unit 106 generates a call to the original generic subprogram (redist_copy), and ends the process for redist_copy (z1, z2). In this case, since specialization conditions are not satisfied for all specialized subprograms, conversion into specialized subprograms is not performed.

  FIG. 5 shows a processing result by the specialization unit 103. If the three redist_copy calls included in the program shown in FIG. 2 are processed by the process shown in FIG. 3, the result shown in FIG. 5 is obtained. The first redist_copy is a case where the specialization condition of redist_copy_square is satisfied at the time of compilation, and redist_copy (x1, x2) is replaced with redist_copy_square (x1. X2). The second redist_copy calls redist_copy_square when the redist_copy_square specialization condition is met at execution time, calls redist_copy_block when the redist_copy_block specialization condition is met, and when both are not met, the original redist_copy_block Is converted into code that calls. Since the third redist_copy does not satisfy any specialization condition at the time of compilation, the original redist_copy is still called.

  In the present embodiment, for the subprograms defined generically in the programming language, a function for specifying a specialized subprogram having higher performance under a specific condition and a function for setting the application condition are provided. Give it. In setting specialization conditions, dynamic information can be set as specialization conditions. The compiler detects a call to a subprogram with specialization, and determines whether the specialization condition is successful at the time of compilation. When the condition is met, the original generic subprogram call is replaced with a specialized subprogram call. When the success or failure of the specialization condition is unknown at the time of compilation, the success or failure of the specialization condition is determined at the time of execution, and a code for calling the specialization subprogram or the original generic subprogram is generated.

  In this embodiment, the user can set more flexible specialization conditions by performing condition determination at the time of execution as necessary. In addition, since the processing system automatically performs the determination of the specialization condition and the call of the specialization subprogram, it is not necessary to modify the source program in accordance with the change of the execution environment and the problem setting. By providing the source program with a function for specifying a specialized subprogram and a function for setting a specialization condition, it is possible to target an embedded subprogram or a runtime library routine. Also, any specialization can be realized by the user defining the specialization subprogram in the source program.

  In the above embodiment, an example in which Fortran is used as a source program has been described. However, the language of the source program is not limited to Fortran or an extended language thereof. For example, a parallel language Unified Parallel C (UPC), which is an extension of the C language, can be used. FIG. 6 shows an example of UPC. In the first line, a prototype of a function ArrayCopy that declares a generic array, that is, a shared array of an arbitrary type and an arbitrary block size is declared. In the second line, specialize (ArrayCopy), a specialized subprogram is specified for the generic function ArrayCopy. In the third and subsequent lines, specialization conditions and specialization functions (ArrayCopy_Congruent) for ArrayCopy are declared. The operation of the compiler for such a source program is the same as that of the above embodiment, except for the difference in syntax between Fortran and C.

  Although the present invention has been described based on the preferred embodiment, the compiler, the compilation method, and the program of the present invention are not limited to the above embodiment, and various configurations are possible from the configuration of the above embodiment. Modifications and changes are also included in the scope of the present invention.

The block diagram which shows the compiler of one Embodiment of this invention. The figure which shows the example of a source program. The flowchart which shows the operation | movement procedure of a specialization part. The figure which shows the example of data of a subprogram information table and a specialization information table. The figure which shows the program after the process by the specialization part. The figure which shows the program described in the UPC language.

Explanation of symbols

100: source program 101: compiler 102: syntax analysis unit 103: specialization unit 104: specialization detection unit 105: specialization condition determination unit 106: code conversion / generation unit 107: parallelization unit 108: optimization unit 109: code Generation unit 110: Object program 111: Specialization information table 112: Subprogram information table

Claims (16)

Using a computer, compile a source program that includes a description that specifies a specialized subprogram for the generic subprogram and a description that includes indefinite information at the time of compilation and sets a specialization condition to which the specialized subprogram is applied. A method,
The computer recording the specialization subprogram and specialization conditions included in the source program in a specialization information table;
The computer detecting a call of a generic subprogram to which a specialized subprogram is designated based on the source program;
The computer refers to the specialization information table to determine whether a specialization condition of the specialization subprogram corresponding to the detected generic subprogram is satisfied at the time of compilation;
If it is determined in the determination step that the specialization condition is satisfied at the time of compilation, it is determined that the computer calls code for calling the generic subprogram when the specialization condition is satisfied. A compiling method comprising the step of converting the code into a code that calls the program.   The description that specifies the specialization subprogram includes a description that specifies a plurality of specialization subprograms for one generic subprogram, and the description that sets the specialization condition includes the plurality of specialization subprograms. The computer program includes a description for setting specialization conditions to which each of the programs is applied, and the computer registers the plurality of specialization subprograms and specialization conditions by dividing the entries into the specialization information table. The compiling method according to Item 1.   The computer selects one entry of the specialization information table one by one until it is determined that the specialization condition is satisfied at the time of compilation, or until the determination of all specialization conditions is completed, and the selected entry The compiling method according to claim 2, wherein it is determined whether or not the specialization condition is satisfied at the time of compiling.   If it is determined in the determination step that the specialization condition is satisfied at compile time, and then it is determined that another specialization condition is satisfied at the time of compilation, When the specialization condition determined to be indefinite is not satisfied and the other specialization condition determined to be indefinite is satisfied, the computer executes a specialization subprogram corresponding to the other specialization condition. The compiling method according to claim 3, further comprising generating and adding code to be called.   If it is determined in the determination step that the specialization condition is satisfied at the time of compilation, and if it is determined that another specialization condition is satisfied, the computer determines that the special is determined to be indefinite. 4. The compiling method according to claim 3, further comprising a step of generating and adding a code for calling a specialization subprogram corresponding to the specialization condition determined to be satisfied when the optimization condition is not satisfied.   After determining that the specialization condition is satisfied at the time of compiling in the determination step, and after determining all the specialization conditions, the computer determines the specialization condition determined to be indefinite. The compiling method according to claim 3, further comprising a step of generating and adding a code that calls the generic subprogram when the above is not established.   When it is determined that the specialization condition is satisfied at the time of compilation, the computer further includes a step of converting a code called by the generic subprogram into a code called by the specialization subprogram that satisfies the specialization condition. Item 4. The compiling method according to any one of Items 1 to 3.   Prior to the step of detecting the call of the generic subprogram, the computer searches for the generic subprogram that is called when the source program is executed, and specializes the generic subprogram in which the specialized subprogram is specified. 8. The compiling method according to claim 1, further comprising a step of registering in a subprogram information table together with a flag indicating that a subprogram is designated. Detecting a call to a generic subprogram with the specialized subprogram specified;
The computer detecting a call to a generic subprogram based on the source program;
The compiling method according to claim 8, further comprising: determining whether a specialized subprogram is designated for the detected generic subprogram with reference to the flag. The computer, the description that specifies the special subprogram for generic subprogram includes indeterminate information at compile time, to input a source program including a description and to the specialized sub program sets the special conditions that apply, a parser for Ru is recorded in specialized information table the specialized subprograms and special conditions,
The computer, and on the basis of the source program, specialization detector for Ru is detected the call to the generic subprogram special subprogram is specified,
The computer, said by referring to specialized information table, special conditions determined for the special conditions of specialized sub-programs corresponding to the detected generic subprogram Ru is determined whether or not satisfied at compile And
When the front Symbol specialized conditions Ru is determined that established at compile time, the computer, the code that calls the generic subprogram, the specialized conditions is converted to the code that calls the specialized subprogram satisfied, the special conditions When but Ru is determined whether established at compile time is indefinite, the code that calls the generic subprogram, code conversion for Ru is converted to code that calls the special subprogram during establishment of the special conditions A compiler having a generation unit.   The description that specifies the specialization subprogram includes a description that specifies a plurality of specialization subprograms for one generic subprogram, and the description that sets the specialization condition includes the plurality of specialization subprograms. 11. The description includes setting a specialization condition for each program, and the syntax analysis unit registers the plurality of specialization subprograms and specialization conditions separately in the specialization information table. The listed compiler. The specialization condition judging unit, the special conditions are determined to be satisfied at compile time until, or until the determination of all the specialized conditions is ended, the computer, the entry of the specialized information table 1 one each is selected is for special conditions of the entry the selected Ru is determined whether or not satisfied at compile time, the compiler according to claim 11. When the computer determines that whether or not the specialization condition is satisfied at compile time and then determines that another specialization condition is satisfied or not is determined at compile time, the code When the specialization condition determined to be indefinite is not satisfied and the other specialization condition determined to be indefinite is satisfied in the computer , the conversion / generation unit sets the other specialization condition to characterized in that to produce a code that calls the corresponding special subprogram Ru is added, the compiler according to claim 12. The computer, after the specialized conditions is determined to whether established at compile time is indefinite, when other special conditions is judged to be satisfied, the code conversion-generating unit, the computer, when the undefined determined as special conditions is not satisfied, characterized in that to generate the code that calls the special subprogram corresponding to the determined specialized conditions as established Ru is added, in claim 12 The listed compiler. The computer, after the specialized conditions is determined to whether established at compile time is indefinite, when the determination of all the specialized conditions determined to have ended, the code conversion-generating unit, the the computer, when the undefined determined as special conditions is not satisfied, wherein the Ru was added to produce a code that calls the generic subprogram, according to claim 12 compiler. Processing for compiling a source program including a description for specifying a specialized subprogram for a generic subprogram and a description for setting specialization conditions to which the specialized subprogram is applied, including indefinite information at the time of compilation. A program for causing the computer to execute
A process of recording the specialization subprogram and specialization conditions included in the source program in a specialization information table;
A process for detecting a call to a generic subprogram in which a specialized subprogram is specified based on the source program;
A process of referring to the specialization information table to determine whether a specialization condition of the specialization subprogram corresponding to the detected generic subprogram is satisfied at the time of compilation;
If it is determined in the determination processing that the specialization condition is satisfied at compile time, the computer calls the generic subprogram code for calling the generic subprogram, and the specialization subprogram is executed when the specialization condition is satisfied. A program that executes processing to convert into code to be called.

Images