JP2016177652A - Complier program, system, method, and device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To quicken the arithmetic operation of the other portion of a program without degrading the accuracy of an arithmetic operation sensitive to the accuracy of an input value.SOLUTION: A word/phrase syntax analysis part 24 is configured to acquire a plurality of structures representing each of a plurality of arithmetic operations included in a first program as the target of complication and data dependency. Also, an optimization part 26 is configured to, when the arithmetic operation represented by each of the structures is the arithmetic operation whose output result receives a specific influence in accordance with the accuracy of an input value, add a mark to the structure. Also, the optimization part 26 is configured to, on the basis of the data dependency, add another mark to the structure representing the arithmetic operation having the specific data dependency on the arithmetic operation represented by the structure to which the mark is added. Also, the optimization part 26 is configured to execute optimization to the structure as the target of optimization to be replaced with the content of the arithmetic operation in which the execution of a second program scheduled to be acquired by performing complication to the first program generates a different result under a specific condition among the structures to which any mark is not added.SELECTED DRAWING: Figure 15

Description

  The disclosed technology relates to a compiler program, a compiler system, a compiler method, and a compiler apparatus.

  Conventionally, a compiler that translates a source program (source program) written in a high-level language into a machine language program (target program) has a technology to provide an optimization function to increase the efficiency at the time of execution of the target program. Exists.

  For example, convert the instruction expression in the compiler to a tree structure, search the terms that make up the tree structure in descending order of priority, and set the lowest bit that guarantees the accuracy of the intermediate result in the intermediate result term To do. Then, search for the terms that make up the tree structure with the lowest number of bits set, starting from the lowest priority, and assign only if the calculation accuracy of the assignment source exceeds the calculation accuracy of the assignment destination. There is a method of performing expression analysis by replacing the original calculation accuracy with the calculation accuracy of the assignment destination.

  First, prior to optimization other than division, the ratio of each type of instruction in the intermediate format is examined to determine whether division is a performance bottleneck. If division is a bottleneck for performance, calculate the reciprocal of the product of the divisors for multiple divisions that do not depend on each other, and use the quotient for all the divisors other than the divisor corresponding to the reciprocal, reciprocal, and dividend There is a method to find it as the product of

  Further, there is a method of converting a numerical calculation program into an intermediate language, detecting a portion where a loss of accuracy is detected, and converting the portion into one in which a loss of accuracy has been prevented.

JP 63-173132 A JP 2000-181722 A Japanese Patent Laid-Open No. 4-112229

  In one aspect, the disclosed technology speeds up operations in other parts of the program without reducing the accuracy of operations that are sensitive to the accuracy of the input values.

  As one aspect, the disclosed technique is a data dependency that represents a plurality of structures representing each of a plurality of operations included in the first program to be compiled, and a data input / output relationship between the plurality of operations. Get relationships and. In addition, for each of the acquired structures, the operation represented by the acquired structure is an operation whose output result has a specific influence depending on the accuracy of the input value. Add a mark. Further, another mark is added to the structure representing an operation having a specific data dependency with respect to the operation represented by the structure to which the mark is added based on the acquired data dependency. In addition, the optimization is performed on the structure to be optimized among the structures to which the mark is not added. The optimization is an optimization in which the execution of the second program scheduled to be acquired by performing the compilation on the first program is replaced with the content of an operation that generates a different result under a specific condition. .

  As one aspect, it has the effect of speeding up operations in other parts of the program without degrading the accuracy of operations sensitive to the accuracy of input values.

It is the figure which showed the example of the flow of a process of a compiler. It is the figure which showed the example of a syntax tree. It is a figure which shows the example template with respect to floating point division. It is a figure which shows the example of the command preparation by the combination of a template. It is a figure which shows the template of the type conversion to the integer of a floating point. It is a figure which shows the example of the instruction preparation by the single template containing a some node. It is a figure which shows the example which cannot respond with a template. It is a figure which shows an example in case there exists a possibility of data dependence via a load / store instruction. It is a figure which shows the example of the conventional data structure. It is a figure which shows the example of the data structure used in this embodiment. It is a figure which shows the example which added the mark to the node. 1 is a schematic diagram showing a system configuration including a compiler apparatus according to a first embodiment. It is a functional block diagram of the compiler apparatus which concerns on 1st Embodiment. It is a figure which shows the example of a recording table. 1 is a block diagram illustrating a schematic configuration of a computer that functions as a compiler apparatus according to a first embodiment. FIG. It is a flowchart which shows an example of the compilation process which concerns on 1st Embodiment. It is a flowchart which shows an example of the optimization process which concerns on 1st Embodiment. It is a flowchart which shows an example of the search of a syntax tree and the addition process of a mark concerning 1st Embodiment. It is a flowchart which shows an example of the search process of the syntax tree which concerns on 1st Embodiment. It is a flowchart which shows an example of the re-search process of the syntax tree which concerns on 1st Embodiment. It is a flowchart which shows an example of the command and selection production | generation process which concerns on 1st Embodiment. It is a figure which shows an example of a source program. It is a figure which shows the example of a syntax tree. It is a figure which shows the example of a syntax tree. It is a figure which shows the example of selection of a root node. It is a figure which shows the example which adds a mark to the node corresponding to the calculation sensitive to the precision of an input value. It is a figure which shows the example which adds a mark to a node in case the mark is added to the parent node. It is a figure which shows the example which the mark propagated to the leaf of the syntax tree. It is a figure which shows the example of the instruction | indication production | generation of the syntax tree in which the node is marked. It is a figure which shows the example of selection of a root node. It is a figure which shows the example of a search. It is a figure which shows the example of a search. It is a figure which shows the example of a search. It is a figure which shows the example which performed the instruction | indication about the syntax tree where the mark is not added to the node. It is a figure which shows the example of a source program. It is a figure which shows the example of the syntax tree containing the load command and the store command. It is a figure which shows the example showing the state before re-searching of a syntax tree. It is a figure which shows the example which adds a mark to a node in case there exists a possibility that the address which a store instruction and a load instruction point is in agreement. It is a figure which shows the example of the result of a re-search. It is a figure which shows the example of the instruction | indication production | generation of a syntax tree containing a store instruction and a load instruction. It is a figure which shows the example of an optimization recording table. It is a functional block diagram of the compiler apparatus which concerns on 2nd Embodiment. It is a block diagram which shows schematic structure of the computer which functions as a compiler apparatus which concerns on 2nd Embodiment. It is a flowchart which shows an example of the compilation process which concerns on 2nd Embodiment. It is a flowchart which shows an example of the argument analysis process which concerns on 2nd Embodiment. It is a flowchart which shows an example of the optimization process which concerns on 2nd Embodiment. It is a figure which shows an example of a designation | designated process recording table. It is a functional block diagram of the compiler apparatus which concerns on 3rd Embodiment. It is a block diagram which shows schematic structure of the computer which functions as a compiler apparatus which concerns on 3rd Embodiment. It is a flowchart which shows an example of the compilation process which concerns on 3rd Embodiment. It is a flowchart which shows an example of the argument analysis process which concerns on 3rd Embodiment. It is a flowchart which shows an example of the optimization process which concerns on 3rd Embodiment. 14 is a flowchart illustrating an example of syntax tree search and mark addition processing according to the third embodiment. It is a flowchart which shows an example of the search process of the syntax tree which concerns on 3rd Embodiment.

  Hereinafter, embodiments according to the disclosed technology will be described.

  First, before explaining the details of the embodiment, a compiler and optimization which are prerequisites in a system provided by each embodiment described later will be explained.

  As shown in FIG. 1, a compiler is a program for translating a source program (hereinafter referred to as a source program) written in a high-level program language into a machine language program (hereinafter referred to as a target program). is there.

  The operations of the compiler are generally argument analysis processing, lexical / syntax analysis processing, optimization processing, instruction selection / generation processing, and machine language output processing.

  Here, the argument analysis processing analyzes the file name specification and options passed when the compiler is started, and determines the operation of the compiler.

  In the lexical / syntactic analysis process, the source program is read, and the process described in the source program is converted into an intermediate language used in the compiler.

  Here, in many compilers, instead of directly converting the source program into the target program, the source program is once converted into an intermediate representation inside the compiler, and then the intermediate representation is converted into the target program. The method is taken. This intermediate expression is called an intermediate language.

  The advantage of using an intermediate language is that the control structure, data structure, and dependency between instructions of the source program are expressed in a format that is easy for a computer to handle. There are various types of intermediate languages, and a single compiler can use a plurality of formats. In each embodiment described later, a syntax tree format is used as an intermediate language. In addition, you may use other expression methods, such as 3 address sentence format and 4 address sentence format, as an intermediate language.

  The syntax tree includes nodes representing data, operations, etc. included in the source program, and arcs representing dependency relationships between the nodes. An example in which a source program representing a simple operation “c = a / b” is converted into a syntax tree is shown in FIG. Here, a node without input is called “leaf”, and a node without output is called “root”. When a node A and a node B are connected by an arc and the node B receives the output of the node A, the node B is called a “parent” of the node A and the node A is called a “child” of the node B. . This parent-child relationship between nodes is an example of a dependency relationship between nodes. Note that intermediate languages other than syntax trees also include parent-child relationships between components representing data, operations, etc., or dependency relationships representing upstream and downstream relationships. For this reason, even if an intermediate language of another format is used, the processing in the compiler described later can be performed in the same manner as when a syntax tree is used.

  The optimization process is a process of converting an intermediate language for improving the efficiency at the time of executing the target program. A general compiler has many optimization functions, and the optimization functions can be classified into the following three types, for example. Specifically, control analysis / data analysis, normal optimization, and aggressive optimization. Note that the order of execution of the three types of optimization is out of order, and one optimization may be repeated a plurality of times as necessary.

  Here, the control analysis / data analysis is a program control flow and data analysis, but this analysis itself is not an optimization, and the control analysis / data analysis provides information necessary for the implementation of the optimization. Is done. The control analysis / data analysis includes analysis of whether or not the memory addresses pointed to by a plurality of pointer variables are the same.

  The normal optimization is a process of converting the intermediate language obtained from the source program into a more efficient intermediate language so as not to change the meaning of the intermediate language. Note that normal optimization is not necessarily performed. Whether or not normal optimization can be performed depends on whether or not an option for performing normal optimization is specified.

  Active optimization is a kind of optimization, and details will be described later. Whether or not to perform aggressive optimization depends on whether or not an option for aggressive optimization is specified. Note that aggressive optimization is an example of optimization in which the execution of the second program to be acquired is compiled with the contents of an operation that generates different results under a specific condition by compiling the first program. .

  The instruction selection / generation process is a process for converting the intermediate language into a machine language instruction of the corresponding target program. For conversion to machine language instructions, a rule called a template for associating one or more intermediate language instructions with machine language instructions of the target program is used.

  Note that instruction selection is not a process independent of optimization. Prepare multiple instruction selection methods, and select one of them depending on the optimization level (when optimization is not performed at all, only normal optimization is performed, or aggressive optimization is also performed). Can be selected. Of course, the same instruction may be selected regardless of whether or not optimization is performed.

  The machine language output process is a process for outputting a target program.

  One of the important functions of the compiler is the optimization described above. In recent years, many compilers have “aggressive optimization” which is a kind of optimization. Aggressive optimization is optimization that is more efficient than normal optimization that can be achieved by assuming specific conditions that cannot be obtained simply by analyzing a source program. In addition, active optimization can be said to be optimization processing in which execution of an operation in the target program is replaced with the content of an operation that generates a different result under a specific condition. This point will be described in detail.

  In a program used in the field of science and technology, a numerical value is generally expressed by a floating point and operated. There is a standard called IEEE754 for the calculation of floating point numbers. The standard is defined for the data format (basic format, exchange format), operation type, error rounding rules, or exception handling matters.

  For example, as an aggressive optimization for floating point arithmetic conforming to the above-mentioned IEEE754, there is an optimization that enables a significant speedup by loosening the degree of conformance to IEEE754.

  Next, consider two examples of aggressive optimization for the above floating point operations.

  The first example of aggressive optimization is “omitting multiplication by replacing variable x with constant 1.0 by x itself”. In this case, when the calculation target is other than a specific value, the same result is returned depending on whether or not the aggressive optimization is performed, but the result may be different depending on the specific value. For example, if x is a value that exceeds the range that can be expressed by normalizing with IEEE754, the execution result of the multiplication may be different from the original value of x, but the multiplication is omitted as a result of applying the optimization. For example, x is used as the value of the expression.

  A second example of aggressive optimization is: “Floating-point division y / x is not directly divided by x, but replaced by multiplication of the reciprocal of x and y to reduce computation time. "Improve throughput". This is based on the reason that, depending on the hardware design, the combination of the reciprocal operation and the multiplication may reduce the calculation time and the throughput than one division instruction. This example is assumed to be executed in a computer equipped with hardware that supports an operation for obtaining an inverse number. The conventional technology is used for hardware support of the calculation for obtaining the reciprocal. An example is shown in FIG.

  In the example of FIG. 3, when optimization is not performed or when normal optimization is performed, the corresponding template “fdiv% a,% b, Generate target program using "% c". On the other hand, when aggressive optimization is performed, the syntax tree shown in FIG. 3 is first transformed into a structure for obtaining the reciprocal of b by transforming the node of b into the structure of obtaining the reciprocal of b and the product of a. The syntax tree is transformed to have a structure for calculating c. Then, a target program is generated using the templates “reciprocal% b,% t and fmul% t,% a,% c” corresponding to the modified syntax tree.

  In this case, theoretically, the same result is obtained when the division is obtained by directly using the division instruction and when the reciprocal of the divisor is obtained and then obtained by multiplying the dividend and the reciprocal of the divisor. However, depending on the value of the given data, different results may be obtained due to an error when the calculated value is normalized to the format defined by IEEE754.

  As in the above two examples, assuming that the operation target is not a specific value, the result does not change between when optimization is performed and when it is not performed, but whether the operation target is a value other than a specific value. Does not know just by analyzing the source program. Therefore, the above two optimizations can be said to be aggressive optimizations.

  In most cases, the effects of errors resulting from aggressive optimization can be ignored. However, if the result of aggressive optimization is used as the input value for an operation that is sensitive to the accuracy of the input value (the operation that affects the output result depending on the accuracy of the input value), the program is executed. Results may be affected unexpectedly. For this reason, it is necessary to suppress aggressive optimization for an operation that outputs an input value for an operation that is sensitive to the accuracy of the input value.

  Here, an example of calculation sensitive to the accuracy of the input value is shown. As a first example, “conversion of floating point number to integer” will be described.

  When converting a floating-point number to an integer by rounding down the decimal point, for example, if the value of the original data is “1.0000000000000000”, the result value is 1, but the original value is “0.9999999999999999” If there is, the result value is zero.

  Next, “branch by comparison between floating point numbers” will be described as a second example.

  Consider the case of a comparison branch instruction that changes the instruction to be executed later by comparing two floating-point numbers, or a match / mismatch comparison. In this case, for example, when the two values are “1.0” and “1.0000000000000001” and “1.0” and “0.9999999999999999”, the comparison result of the magnitude is reversed, so the behavior of the program after that is It can be quite different.

  As described above, aggressive optimization may be difficult to use in combination with operations sensitive to the accuracy of input values due to its nature. On the other hand, the following three suppression methods such as (1), (2), and (3) are conceivable as positive optimization suppression methods.

(1) Complete suppression of aggressive optimization in file units (2) Modification of source program by user (3) Partial suppression of aggressive optimization using automatic discrimination by compiler

  The method (1) is a method of specifying whether to optimize a program and to what extent the program is optimized by an option given by the user when starting the compiler. By performing this designation, it is possible to completely prevent aggressive optimization.

  The method (2) is a method in which the user inserts a pragma specification related to optimization on the source program. Here, pragma designation is a method of controlling the program translation method in units of lines or blocks of the source program. Specify the part where you want to suppress aggressive optimization by writing the pragma specification to the place where the operation generating the input to the operation sensitive to the accuracy of the source program is described, and aggressive optimization Can be suppressed.

  The method (3) is a method in which the instruction sequence of the target program is associated with a chain of a plurality of intermediate language nodes instead of one intermediate language node in the compiler instruction selection process. By using this method, when an operation that is sensitive to the accuracy of the input value is used as the result of aggressive optimization, it is possible to specify generation of a target program including two intermediate language nodes.

  Next, the method (3) will be described in detail with an example.

  As an example, let us consider a case where an object program is obtained from an intermediate language representing a process of converting a floating-point division result into an integer such as “Formula ii = (int64_t) (aa / xx);” shown in FIG. In this case, it can be realized by a combination of a template representing a single floating-point division and a template representing a single type conversion.

  First, suppose that there are two ways to convert the floating-point division into the target program: a case where aggressive optimization is performed and a case where aggressive optimization is not performed. In this case, as shown in FIG. 3, two templates are prepared for each optimization level. One is a template that is applied to a syntax tree that has been aggressively optimized and converted into a target program, and the other is a template that is applied to a syntax tree that has not been aggressively optimized. This is a template for conversion to the target program. As for type conversion, only one type is prepared regardless of the optimization level as shown in FIG. In this example, when the aggressive optimization shown in FIG. 3 is performed or not performed as shown in FIG. 4 for the intermediate language of “Formula ii = (int64_t) (aa / xx);” These templates and the template shown in FIG. 5 can be applied in combination.

  The syntax tree shown in FIG. 4 shows an example of a syntax tree that has not been aggressively optimized. However, when aggressive optimization is performed, the syntax tree is converted by aggressive optimization. A template for aggressive optimization is applied to the syntax tree.

  In this method, if the optimization level is specified as aggressive optimization, the result of the division operation by multiplication with the reciprocal that may cause an error is used as the input to convert the floating-point number to an integer. There is a possibility of unexpected influence on the execution result of the program.

  In response to the problem, the method (3) above prepares a template for performing aggressive optimization by combining two templates for each of the division and the type conversion instruction using the result. In addition to the template, as shown in FIG. 6, a pattern syntax tree including both division and a type conversion instruction using the result is applied to the syntax tree at all optimization levels. Prepare a template to convert to a program.

  Here, consider a case where a template for each of a plurality of optimization levels can be applied in the generation of the target program (a case where a plurality of optimization levels can be implemented). In this case, the optimization level is determined by determining the priority order of the templates. For example, it is set so that the template in FIG. 6 is selected with priority over the templates in FIGS. In this way, optimization is not performed on the division instruction followed by the type conversion instruction, or normal optimization is performed, and the template of FIG. 6 is applied. Therefore, aggressive optimization can be suppressed.

  However, each of the methods (1) to (3) has the following problems.

  In the method (1), the optimization level is specified in units of files describing the source program. For this reason, if there is an operation sensitive to the accuracy of the input value even in one place in the source program described in the file, it is necessary to drop the optimization level specified in the file according to the operation. With such a method, since the active optimization cannot be performed on the remaining operations existing in the same file, the efficiency of the entire program is hindered, so that the performance is adversely affected.

  In the method (2), in order to correctly insert the pragma, the user needs to have detailed knowledge of the hardware that executes the target program. Therefore, it cannot be said that this method is available to all users. Moreover, it can be said that the burden of having the user modify the source program is large. Further, since the pragma inserted into the source program is not always usable for the purpose of translating into the target program of other hardware, the user needs to change the pragma for each piece of hardware that executes the program. Also, in a large-scale program, it may take a very large amount of man-hours to properly insert pragmas where it is desired to prevent all aggressive optimization.

  The method (3) has problems from two viewpoints. As a first problem (a), the compiler must prepare a template in advance for a combination of operations that may cause a problem. However, in an actual program, a template may not be prepared in advance.

  For example, the source “ii = (int64_t) (aa / xx-yy);”, which is a slightly modified version of the example “ii = (int64_t) (aa / xx);” that was used when explaining the method (3) above Think about the program. The syntax tree of the source program is as shown in FIG. 7, and is different from the syntax tree shown in FIG. For this reason, the template shown in FIG. 6 when the aggressive optimization is not performed cannot be applied, and the aggressive optimization cannot be suppressed. Even if only one template corresponding to the syntax tree of the pattern in FIG. 7 is added to the compiler, there are countless examples of this, so users can make appropriate optimizations actively in the program they are translating. It cannot be confirmed that it will be deterred.

  The second problem (b) is that it cannot cope with a case where there is a possibility that a plurality of syntax trees form a data dependency through a data memory transfer instruction. For example, as shown in FIG. 8, it is assumed that a value obtained in a part of a program is stored in a memory by a store instruction and is extracted from the memory by using a load instruction in another part and used for an operation. FIG. 8 shows an example in which floating-point division is executed in one part of the program and a type conversion instruction is executed in another part.

  In this case, since the floating-point division and type conversion instructions exist in different syntax trees, as in the method (3) above, it is only necessary for the syntax tree of a pattern including both floating-point division and type conversion. One method of preparing a template that does not perform aggressive optimization is not applicable. Therefore, it is necessary for the user to confirm that there is no processing using the store instruction or the load instruction in the program.

  Therefore, in the above method (3), especially when the distance between the operation to be “proactively optimized” and the “operation sensitive to the accuracy of the input value” on the syntax tree is long, By carrying out the optimization, the possibility of problems increases. In addition, even when the connection is indirectly made through a memory, the possibility of a problem increases by performing aggressive optimization.

  This means that if the distance is long, or if it is via a memory, the calculation subject to “active optimization” will be in the range where the influence is retroactive to “the calculation sensitive to the accuracy of the input value”. This is because it becomes difficult for the user to determine whether or not it is included.

  As described above, there is a problem with the positive optimization suppression methods (1) to (3). Therefore, the compiler according to each embodiment to be described later solves the problems (a) and (b) and realizes appropriate implementation or suppression of aggressive optimization. If the problems (a) and (b) can be solved, the need to use the methods (1) and (2) will be significantly reduced. Therefore, the problems (1) and (2) are almost problematic. Don't be.

  Hereinafter, as a summary of the embodiment, a solution to the problems (a) and (b) will be described.

  First, a solution for the problem (a) will be described. For task (a), an operation that generates an input value for an operation sensitive to the accuracy of the input value by performing an existing data dependency analysis starting from the operation sensitive to the accuracy of the input value on the syntax tree Is added and a mark is added.

  Furthermore, by applying the existing data dependence analysis recursively to the operations marked with this mark, all the operations in the same syntax tree that affect operations sensitive to the accuracy of the input value The specific work is completed by enabling the propagation of the mark regardless.

  Then, the marked operation, that is, the operation related to the input value for the operation sensitive to the accuracy of the input value is excluded from the object of active optimization, thereby solving the problem (a).

  In order to solve the problem (a), the data structure inside the compiler according to the embodiment is changed. For example, a mark representing that the node is in contact with an operation sensitive to the accuracy of the input value is added to the structure representing the node including the data dependency information of the conventional node shown in FIG. Change to the structure shown. For example, when a member “error_sensitive” representing a true / false value is added to a structure representing a node as shown in FIG. 10 and the value of the member is true, the node is sensitive to the accuracy of the input value. It can be stated that the operation is contacted. When the member “error_sensitive” is true, as shown in FIG. 11, a mark is added to the conventional node notation, and it is asserted that no aggressive optimization is performed.

  Next, a method for solving the problem (b) will be described. For the problem (b), by performing address analysis between the existing data transfer instructions with the memory, the syntax tree other than the syntax tree including the operation sensitive to the accuracy of the input value can be displayed. Increase the propagation range of By doing so, it is possible to perform specific work across a plurality of syntax trees.

  And it is possible to determine that operations marked across multiple syntax trees are operations related to the input value of operations that are sensitive to the accuracy of the input value. By excluding it, the problem (b) is solved.

  Hereinafter, each embodiment will be described in detail with reference to the drawings. It is assumed that the “operation sensitive to the accuracy of the input value” used in each embodiment is defined in advance. Further, in each embodiment, a detailed description of the description of the premise compiler and optimization described above, and contents common to the outline of the embodiment is omitted.

  FIG. 12 is an example of the compiler system 5 of the first embodiment. As shown in FIG. 12, the compiler system 5 includes a compiler device 1, a user terminal 3 for users, and an external disk 40. The external disk 40 has a source program storage unit 42 and a target program storage unit 46. The compiler apparatus 1 according to the first embodiment is connected to a user terminal 3 and an external disk 40 through a network 2 such as the Internet so that they can communicate with each other. 12 illustrates one case of the user terminal 3, but the number of user terminals 3 is not limited to the illustrated example, and the compiler system 5 may include an arbitrary number of user terminals 3. it can. The user terminal 3 is an information processing apparatus such as a personal computer, and is used by a person who performs compilation.

Each source program is stored in the source program storage unit 42.

  The target program storage unit 46 stores each of the target programs.

  FIG. 13 shows a functional block diagram of the compiler apparatus 1 according to the first embodiment. As shown in FIG. 13, the compiler apparatus 1 includes an argument analysis unit 22, a lexical syntax analysis unit 24, an optimization unit 26, an instruction generation unit 28, a target program output unit 30, a template storage unit 32, and a recording table storage unit 44. A compiler 20 is included.

  The compiler 20 is activated based on the input information (command) received from the user terminal 3 and acquires the target source program from the source program storage unit 42 via the network 2. The compiler 20 converts the acquired source program into a target program and stores it in the target program storage unit 46 via the network 2.

  The argument analysis unit 22 determines the operation of the compiler based on the input information received from the user terminal 3. Specifically, the argument analysis unit 22 receives a file name specification such as a file stored from the user terminal 3 that stores the source program passed when the compiler is started or a file that stores the target program. Determine the target file. Further, the argument analysis unit 22 analyzes the option that is received from the user terminal 3 and is passed when the compiler is started and specifies what kind of optimization is performed, and determines the optimization to be performed. The argument analyzing unit 22 analyzes the option received from the user terminal 3 and specifying the format of the target program to be output, and determines the format of the target program to be output. Note that the optimization to be determined covers all the syntax trees generated in the lexical syntax analysis unit 24 described later.

  The lexical syntax analysis unit 24 is a syntax that is an intermediate language used in the compiler for processing described in the target source program based on the file name storing the target source program determined by the argument analysis unit 22. Convert to tree format. The lexical syntax analysis unit 24 generates each syntax tree of a specific operation unit. The lexical syntax analysis unit 24 can acquire a data dependency representing a data input / output relationship between a plurality of operations.

  Specifically, the lexical syntax analysis unit 24 first acquires the target source program from the source program storage unit 42 based on the file name that stores the target source program determined by the argument analysis unit 22. To do. Next, the lexical syntax analysis unit 24 performs lexical analysis on the processing described in the acquired source program. Next, the lexical syntax analysis unit 24 performs syntax analysis based on the lexical analysis result, and generates each syntax tree of a specific operation unit.

  The optimization unit 26 performs optimization on each syntax tree generated by the lexical syntax analysis unit 24 based on the compiler operation related to optimization determined by the argument analysis unit 22. Specifically, first, the optimization unit 26 performs control analysis and data analysis, and acquires information necessary for performing normal optimization or aggressive optimization. In the first embodiment, the optimization unit 26 uses a conventional technique to determine whether or not the addresses indicated by the store instructions and the load instructions included in all the syntax trees match. get.

  Here, the determination result of whether or not the addresses match is classified into three types of matching, non-matching, and unknown, but in the first embodiment, when matching and unknown It shall be determined that they match.

  Next, the optimization unit 26 searches each syntax tree for a node of the syntax tree, and relates to an operation related to an input value of an operation sensitive to the accuracy of the input value among the nodes included in the syntax tree. Add a mark to the node.

  Specifically, first, the optimization unit 26 determines the root node of the syntax tree to be processed among the syntax trees as the node to be processed. Next, the optimization unit 26 satisfies at least one of the two conditions that the node is “a node representing an operation sensitive to the accuracy of the input value” and “a parent node is marked”. Judgment is made. Next, when the optimization unit 26 determines that the condition is satisfied, the optimization unit 26 adds a mark to the node. For example, when a node is represented by a data structure as shown in FIG. 10, a mark is added to the node by changing the value of “error_sensitive” of the data structure of the node to 1 (true). be able to. The optimization unit 26 determines whether the node is a load instruction. If the node is a load instruction, the optimization unit 26 stores the address indicated by the load instruction in a recording table stored in the recording table storage unit 44 as illustrated in FIG.

  Next, when an unprocessed child node exists in the node, the optimization unit 26 selects the child node as a processing target node, and repeats the same processing recursively. Next, when the process is completed for all the child nodes, the optimization unit 26 changes the node to be processed to the parent node of the node, and determines whether there is an unprocessed child node. Next, when there is an unprocessed child node, the optimization unit 26 recursively repeats the above processing. On the other hand, when there is no unprocessed child node, the process of setting the parent node of the processing target node as the processing target node is repeated. The optimization unit 26 performs processing for adding a mark to each of the nodes included in the syntax tree by repeating the above processing.

  Next, for each syntax tree, the optimization unit 26 re-searches the node of the syntax tree, and among the nodes included in the syntax tree, an operation sensitive to the accuracy of the input value included in another syntax tree. A mark is added to a node related to an operation related to the input value of.

  Specifically, first, the optimization unit 26 determines the root node of the syntax tree to be processed among the syntax trees as the node to be processed. Next, the optimization unit 26 indicates that the node is “a node representing a store instruction and the address indicated by the store instruction is stored in the recording table stored in the recording table storage unit 44”, and “ It is determined whether at least one of the conditions “a mark is added to the parent node” is satisfied. Next, when the optimization unit 26 determines that the condition is satisfied, the optimization unit 26 adds a mark to the node.

  Next, when an unprocessed child node exists in the node, the optimization unit 26 selects the child node as a processing target node, and repeats the same processing recursively. Next, when the process is completed for all the child nodes, the optimization unit 26 changes the node to be processed to the parent node of the node, and determines whether there is an unprocessed child node. Next, when there is an unprocessed child node, the optimization unit 26 recursively repeats the above processing. On the other hand, when there is no unprocessed child node, the process of setting the parent node of the processing target node as the processing target node is repeated. The optimization unit 26 performs processing for adding a mark to each of the nodes included in the syntax tree by repeating the above processing.

  Next, the optimization unit 26 performs optimization on each syntax tree based on the compiler operation related to optimization determined by the argument analysis unit 22. Specifically, when the argument analyzing unit 22 determines that the option for performing optimization is not specified, the optimization unit 26 performs normal optimization and aggressive optimization for all the syntax trees. Do not do. If the optimization unit 26 determines that the option for performing optimization is specified in the argument analysis unit 22 and that the option for aggressive optimization is not specified, the optimization unit 26 normally performs processing for all syntax trees. Perform optimization. When the optimization unit 26 determines that the option for performing optimization is specified in the argument analysis unit 22 and the option for aggressive optimization is specified, for each of the syntax trees, Perform normal optimization or aggressive optimization.

  Here, when the option for performing optimization is specified and the option for aggressive optimization is specified, it is determined whether to perform normal optimization or aggressive optimization. Will be described. The optimization unit 26 determines whether or not a mark is added to a node included in the syntax tree to be processed. When a mark is added to a node included in the syntax tree to be processed, the optimization unit 26 performs normal optimization on the syntax tree. On the other hand, when the mark is not added to the node included in the syntax tree to be processed, the optimization unit 26 performs positive optimization on the syntax tree. The optimization unit 26 performs each of the processed syntax trees including the result of optimization processing (optimization level) in which normal optimization is performed, optimization is not performed, and optimization is performed. Is output to the instruction generator 28. The processed syntax tree is an optimized or aggressively optimized syntax tree when optimization or aggressive optimization is performed, and when optimization is not performed. This is a syntax tree as it is generated by the lexical syntax analysis unit 24.

  The instruction generation unit 28 converts each processed syntax tree in the optimization unit 26 into a target program based on each template stored in the template storage unit 32. The instruction generation unit 28 outputs the target program to the target program output unit 30.

  Specifically, first, the instruction generation unit 28 selects a syntax tree to be processed. Next, the instruction generation unit 28 selects a template corresponding to the syntax tree to be processed from the templates stored in the template storage unit 32.

  Here, each template corresponding to each pattern of the syntax tree is stored in the template storage unit 32 classified for each optimization level. Specifically, each template corresponding to each pattern of the syntax tree is a template group when optimization is not performed, a template group when normal optimization is performed, and when aggressive optimization is performed The template groups are classified and stored.

  Therefore, the instruction generation unit 28, when the optimization is not performed on the syntax tree to be processed, from the template group stored in the template storage unit 32 when the optimization is not performed. Select the template that corresponds to the syntax tree. In addition, when normal optimization is performed on the syntax tree to be processed, the instruction generation unit 28 uses the template group when the normal optimization stored in the template storage unit 32 is performed. , A template corresponding to the syntax tree is selected. Further, the instruction generation unit 28 stores the template stored in the template storage unit 32 when the optimization is performed positively when the processing target syntax tree is positively optimized. A template corresponding to the syntax tree is selected from the group.

  Next, the instruction generation unit 28 converts the syntax tree into a target program based on the syntax tree to be processed and the selected template.

  The target program output unit 30 collects each of the target programs converted by the instruction generation unit 28 and stores it as a single target program in the target program storage unit 46 stored in the external disk 40 via the network 2. .

  The recording table storage unit 44 stores a recording table for storing a combination of information indicating the node of the load instruction with a mark and an address, as shown in FIG.

  The compiler apparatus 1 can be realized by a computer 200 shown in FIG. 15, for example. The computer 200 includes a CPU 202, a memory 204 as a temporary storage area, and a nonvolatile storage device 206. The computer 200 also includes an input / output interface (I / F) 210 to which an input / output device 208 is connected. The computer 200 also includes a read / write (R / W) unit 214 that controls reading and writing of data with respect to the recording medium 212 and a network I / F 216 connected to the network 2 such as the Internet. The CPU 202, the memory 204, the storage device 206, the input / output I / F 210, the R / W unit 214, and the network I / F 216 are connected to each other via a bus 218.

  The storage device 206 can be realized by a hard disk drive (HDD), a solid state drive (SSD), a flash memory, or the like. A storage device 206 as a storage medium stores a compiler program 300 for causing the computer 200 to function as the compiler device 1. In addition, the storage device 206 has a template storage area 350 in which each template is stored. In addition, it has a recording table storage area 354 in which a recording table is recorded.

  The CPU 202 reads the compiler program 300 from the storage device 206 and expands it in the memory 204. Further, the CPU 202 sequentially executes processes included in the compiler program 300. In addition, the CPU 202 reads each template stored in the template storage area 350 and develops it in the memory 204. Further, the CPU 202 reads the recording table stored in the recording table storage area 354 and develops it in the memory 204.

  The compiler program 300 includes an argument analysis process 302, a lexical syntax analysis process 304, an optimization process 306, an instruction generation process 308, and an object program output process 310.

  The CPU 202 operates as the argument analysis unit 22 illustrated in FIG. 13 by executing the argument analysis process 302. The CPU 202 operates as the lexical syntax analysis unit 24 shown in FIG. 13 by executing the lexical syntax analysis process 304. Further, the CPU 202 operates as the optimization unit 26 illustrated in FIG. 13 by executing the optimization process 306. Further, the CPU 202 operates as the instruction generation unit 28 illustrated in FIG. 13 by executing the instruction generation process 308. Further, the CPU 202 operates as the target program output unit 30 shown in FIG. 13 by executing the target program output process 310.

  As a result, the computer 200 that has executed the compiler program 300 functions as the compiler apparatus 1.

  The compiler apparatus 1 can be realized by, for example, a semiconductor integrated circuit, more specifically, an ASIC (Application Specific Integrated Circuit) or the like.

  Next, the operation of the compiler apparatus 1 according to the first embodiment will be described. First, when the compiler apparatus 1 receives input information received from the user terminal 3, the compiler apparatus 1 executes a compilation process shown in FIG. The compiling process executed by the compiler apparatus 1 is an example of a compiler method of the disclosed technology.

  FIG. 16 is a flowchart illustrating an example of compilation processing. In the flowchart of the compilation process shown in FIG. 16, first, in step S100, the argument analysis unit 22 analyzes a file name designation, options, and the like included in the input information.

  Next, in step S <b> 102, the argument analysis unit 22 acquires each template from the template storage unit 32.

  Next, in step S <b> 104, the argument analysis unit 22 acquires the source program file to be processed acquired in step S <b> 100 from the source program storage unit 42 via the network 2.

  Next, in step S106, the lexical syntax analysis unit 24 performs lexical analysis and syntax analysis on the source program acquired in step S104, and acquires each syntax tree that is an intermediate language.

  Next, in step S108, the optimization unit 26 performs optimization on each syntax tree acquired in step S104 based on the result of the option analysis acquired in step S100.

  Next, in step S110, the instruction generation unit 28 converts each of the syntax trees into an instruction of the target program based on each of the syntax trees acquired in step S108 and each of the templates acquired in step S102. .

  Next, in step S112, the target program output unit 30 combines the instructions of the target program acquired in step S110 into one target program. The target program output unit 30 stores the collected target programs in the target program storage unit 46 via the network 2. Then, the target program output unit 30 ends the compilation process.

  The optimization process in step S108 described above will be described in detail with reference to FIG. FIG. 17 is a flowchart illustrating an example of the optimization process in step S108. In the flowchart of the optimization process shown in FIG. 17, first, in step S200, the optimization unit 26 performs control analysis and data analysis for each of the syntax trees acquired in step S106, and is necessary for performing the optimization. Get information. The optimization unit 26 acquires the correspondence between the addresses of the store instruction and the load instruction included in each of the syntax trees.

  Next, in step S202, the optimization unit 26 searches the syntax tree for each of the syntax trees acquired in step S106, and performs processing on the nodes related to the calculation related to the input value of the calculation sensitive to the accuracy of the input value. Add a mark.

  Next, in step S204, the optimization unit 26 determines whether an option for performing optimization is designated based on the result of the option analysis acquired in step S100. If the optimization unit 26 determines that the option is specified, the optimization process proceeds to step S206. On the other hand, if the optimization unit 26 determines that no option is specified, it determines that optimization is not performed for all the syntax trees, and the optimization process ends.

  Next, in step S206, the optimization unit 26 determines a syntax tree to be processed.

  Next, in step S210, the optimization unit 26 determines whether an option for performing aggressive optimization is specified based on the result of the option analysis acquired in step S100. If the optimization unit 26 determines that an aggressive optimization option is designated, the optimization process proceeds to step S212. On the other hand, when the optimization unit 26 determines that the option for aggressive optimization is not designated, the optimization process proceeds to step S216.

  Next, in step S212, the optimization unit 26 determines whether or not a node to which a mark is added is included in a node included in the syntax tree to be processed. If the optimization unit 26 determines that the node included in the syntax tree to be processed includes a node with a mark, the optimization process proceeds to step S216. On the other hand, if the optimization unit 26 determines that the node included in the syntax tree to be processed does not include a node with a mark, the optimization process proceeds to step S214.

  Next, in step S214, the optimization unit 26 performs active optimization on the syntax tree to be processed.

  In step S216, the optimization unit 26 performs normal optimization on the syntax tree to be processed.

  Next, in step S220, the optimization unit 26 determines whether or not the processing from step S206 to step S214 or step S216 has been completed for all the syntax trees. If the optimization unit 26 determines that the processing from step S206 to step S216 has been completed for all the syntax trees, the optimization processing ends. On the other hand, if the optimization unit 26 determines that the processing from SS 206 to step S 216 has not been completed for all the syntax trees, the optimization processing proceeds to step S 206.

  The syntax tree search and mark addition processing in step S202 will be described in detail with reference to FIG. FIG. 18 is a flowchart illustrating an example of syntax tree search and mark addition processing in step S202. In the flowchart of the syntax tree search and mark addition process shown in FIG. 18, first, in step S300, the optimization unit 26 determines a syntax tree to be processed.

  Next, in step S302, the optimization unit 26 searches for a syntax tree to be processed and adds a mark to the target node.

  Next, in step S304, the optimization unit 26 determines whether or not the processing in step S302 has been completed for all the syntax trees. If the optimization unit 26 determines that the process of step S302 has been completed for all the syntax trees, the process proceeds to step S306. On the other hand, when the optimization unit 26 determines that the process of step S302 has not been completed for all the syntax trees, the process proceeds to step S300.

  Next, in step S306, the optimization unit 26 determines a syntax tree to be processed.

  Next, in step S308, the optimization unit 26 re-searches the syntax tree to be processed and adds a mark to the target node.

  Next, in step S310, the optimization unit 26 determines whether or not the processing in step S308 has been completed for all the syntax trees. If the optimization unit 26 determines that the process of step S308 has been completed for all syntax trees, the syntax tree search and marking process ends. On the other hand, if the optimization unit 26 determines that the process of step S308 has not been completed for all syntax trees, the syntax tree search and marking process proceeds to step S306.

  The syntax tree search process in step S302 will be described in detail with reference to FIG. FIG. 19 is a flowchart illustrating an example of syntax tree search processing in step S302. In the flowchart of the syntax tree search process shown in FIG. 19, first, in step S400, the optimization unit 26 selects the root node of the syntax tree to be processed as the node to be processed.

  Next, in step S402, the optimization unit 26 determines whether or not the node represents an operation sensitive to the accuracy of a predetermined input value. When the optimization unit 26 determines that the node represents an operation sensitive to the accuracy of a predetermined input value, the syntax tree search process proceeds to step S406. On the other hand, if the optimization unit 26 determines that the node does not represent an operation sensitive to the accuracy of a predetermined input value, the syntax tree search process proceeds to step S404.

  Next, in step S404, the optimization unit 26 determines whether or not a mark is added to the parent node of the node. When the optimization unit 26 determines that the mark is added to the parent node of the node, the syntax tree search process proceeds to step S406. On the other hand, when the optimization unit 26 determines that the mark is not added to the parent node of the node, the syntax tree search processing moves to step S412.

  Next, in step S406, the optimization unit 26 adds a mark to the node.

  Next, in step S408, the optimization unit 26 determines whether the node represents a load instruction. If the optimization unit 26 determines that the node represents a load instruction, the syntax tree search process proceeds to step S410. On the other hand, if the optimization unit 26 determines that the node does not represent a load instruction, the syntax tree search process moves to step S412.

  Next, in step S410, the optimization unit 26 stores the address indicated by the load instruction of the node acquired in step S200 in the recording table stored in the recording table storage unit 44.

  Next, in step S412, the optimization unit 26 determines whether or not the processing in steps S402 to S410 has been completed for all child nodes of the node. If the optimization unit 26 determines that the process in step S402 has not been completed for all child nodes of the node, the syntax tree search process proceeds to step S414. On the other hand, if the optimization unit 26 determines that the process of step S402 has been completed for all child nodes of the node, the syntax tree search process proceeds to step S416.

  Next, in step S414, the optimization unit 26 selects a node to be processed from child nodes of the node, and proceeds to step S402.

  In step S416, the optimization unit 26 determines whether the node is a root node. When the optimization unit 26 determines that the node is the root node, the syntax tree search process ends. On the other hand, if the optimization unit 26 determines that the node is not a root node, the syntax tree search process moves to step S418.

  Next, in step S418, the optimization unit 26 determines the parent node of the node as a node to be processed, and the syntax tree search processing moves to step S412.

  The syntax tree re-search process in step S308 will be described in detail with reference to FIG. FIG. 20 is a flowchart illustrating an example of syntax tree re-search processing in step S308. In the flowchart of the syntax tree re-search process shown in FIG. 20, first, in step S500, the optimization unit 26 selects the root node of the syntax tree to be processed as the node to be processed.

  Next, in step S502, the optimization unit 26 determines whether the node is a node representing a store instruction. When the optimization unit 26 determines that the node is a node representing a store instruction, the syntax tree re-search process proceeds to step S504. On the other hand, when the optimization unit 26 determines that the node is not a node representing a store instruction, the syntax tree re-search process proceeds to step S506.

  Next, in step S504, the optimization unit 26 matches the address indicated by the store instruction represented by the node based on the analysis result acquired in step S200 and the recording table stored in the recording table storage unit 44. It is determined whether or not there is a load instruction that may occur. If the optimization unit 26 determines that there is a load instruction that may match the address indicated by the store instruction represented by the node, the syntax tree re-searching process proceeds to step S508. On the other hand, if the optimization unit 26 determines that there is no load instruction that may match the address indicated by the store instruction represented by the node, the process proceeds to step S506.

  Next, in step S506, the optimization unit 26 determines whether or not a mark is added to the parent node of the node. If the optimization unit 26 determines that a mark is added to the parent node of the node, the syntax tree re-search process proceeds to step S508. On the other hand, when the optimization unit 26 determines that the mark is not added to the parent node of the node, the syntax tree re-search process moves to step S514.

  Next, in step S508, the optimization unit 26 adds a mark to the node.

  Next, in step S514, the optimization unit 26 determines whether or not the processing in step S502 has been completed for all child nodes of the node. When the optimization unit 26 determines that the process of step S502 has not been completed for all child nodes of the node, the syntax tree re-search process proceeds to step S516. On the other hand, when the optimization unit 26 determines that the process of step S502 has been completed for all child nodes of the node, the syntax tree search process proceeds to step S518.

  Next, in step S516, the optimization unit 26 selects a node to be processed from child nodes of the node, and the syntax tree re-search process proceeds to step S502.

  In step S518, the optimization unit 26 determines whether the node is a root node. If the optimization unit 26 determines that the node is a root node, the syntax tree re-search process is terminated. On the other hand, when the optimization unit 26 determines that the node is not a root node, the syntax tree re-search process proceeds to step S520.

  Next, in step S520, the optimization unit 26 determines the parent node of the node as a node to be processed, and the syntax tree re-search process proceeds to step S514.

  The instruction selection / generation process in step S110 will be described in detail with reference to FIG. FIG. 21 is a flowchart illustrating an example of the instruction selection / generation process in step S110. In the instruction selection / generation process flowchart shown in FIG. 21, first, in step S600, the instruction generation unit 28 determines a syntax tree to be processed.

  Next, in step S604, the instruction generation unit 28 determines whether or not optimization has been performed on the syntax tree based on the result of the optimization process of the syntax tree to be processed determined in step S108. When the instruction generation unit 28 determines that the optimization has been performed on the syntax tree, the instruction selection / generation process proceeds to step S608. On the other hand, if the instruction generation unit 28 determines that the optimization is not performed on the syntax tree, the process proceeds to step S606.

  Next, in step S606, the instruction generation unit 28 selects a template corresponding to the syntax tree from the template group when optimization is not performed, from the templates acquired in step S102. Then, the instruction generation unit 28 converts the syntax tree to be processed into a target program based on the selected template.

  Next, in step S608, the instruction generation unit 28 determines whether or not positive optimization has been performed on the syntax tree based on the result of the optimization process of the syntax tree to be processed acquired in step S108. judge. If the instruction generation unit 28 determines that aggressive optimization has been performed on the syntax tree, the instruction selection / generation process proceeds to step S614. On the other hand, when the instruction generation unit 28 determines that normal optimization has been performed on the syntax tree, the instruction selection / generation process proceeds to step S612.

  In step S612, the instruction generation unit 28 selects, from the templates acquired in step S102, a template corresponding to the syntax tree from the template group when normal optimization is performed. Then, the instruction generation unit 28 converts the syntax tree to be processed into a target program based on the selected template.

  In step S614, the instruction generation unit 28 selects a template corresponding to the syntax tree from the templates obtained when aggressive optimization is performed among the templates acquired in step S102. Then, the instruction generation unit 28 converts the syntax tree to be processed into a target program based on the selected template.

  Next, in step S618, the instruction generation unit 28 determines whether or not the processing in step S604 has been completed for all the syntax trees. If the instruction generation unit 28 determines that the process of step S604 has been completed for all the syntax trees, the instruction / selection generation process ends. On the other hand, if the instruction generation unit 28 determines that the process of S604 has not been completed for all the syntax trees, the instruction / selection generation process proceeds to step S600.

  Next, the syntax tree search and the syntax tree re-search according to the first embodiment will be briefly described with reference to the example 1 and the example 2 of the program.

  First, consider the source program shown in FIG. 22 as a first example. The syntax tree generated from the source program by the processing of the lexical syntax analysis unit 24 is shown in FIG. 23 and FIG. Here, regarding the syntax tree of FIG. 23, a syntax tree search process will be considered. First, as shown in FIG. 25, the optimization unit 26 starts a search recursively from the root node of the syntax tree of FIG. 23 to the child node. At this time, as shown in FIG. 26, the optimization unit 26 adds a mark to a node that is an operation sensitive to the accuracy of the input value as a result of the search. In addition, as illustrated in FIGS. 27 and 28, the optimization unit 26 adds a mark to a search target node when the parent node is marked as a result of the search. When the optimization unit 26 includes a node with a mark in the syntax tree, aggressive optimization is suppressed. FIG. 29 shows the result of processing of the instruction generation unit 28 for the syntax tree.

  On the other hand, a syntax tree search process will be considered for the syntax tree of FIG. First, as shown in FIG. 30, the optimization unit 26 recursively starts searching from the root node of the syntax tree of FIG. 24 to the child node. At this time, as shown in FIGS. 31 to 33, the optimization unit 26 does not include a node that is an operation sensitive to the accuracy of the input value or a node to which a mark is added to the parent node, as a result of the search. , Do not mark all nodes. Therefore, if the option to perform aggressive optimization is specified, the syntax tree does not include a node with a mark indicating that aggressive optimization is prohibited. The optimization unit 26 actively performs optimization on the syntax tree. FIG. 34 shows the result of processing of the instruction generation unit 28 for the syntax tree.

  As described above, with regard to the syntax tree of FIG. 23, it has been clarified that there is an operation sensitive to the accuracy of the input value at a node close to the root of the syntax tree. Deterred. Similarly, since it is clear that there is no operation sensitive to the accuracy of input values in the syntax tree of FIG. 24, aggressive optimization is performed.

  Next, consider the source program shown in FIG. 35 as a second example. The syntax tree generated from the source program by the processing of the lexical syntax analysis unit 24 is the left side of FIG. 36 and the right side of FIG. Here, a syntax tree re-search process is considered for the right and left syntax trees in FIG. First, at the stage of re-searching, the states of the right and left syntax trees in FIG. 36 are the states of the syntax trees shown in right and left in FIG. 37 and are stored in the recording table storage unit 44. 14 is stored in the recording table. In this case, since the root node of the left syntax tree in FIG. 37 is a node representing the store instruction, the optimization unit 26 determines that the address indicated by the store instruction of the node and the address of the load instruction stored in the recording table are Analyze for possible matches. If there is a possibility of a match, the node is marked and the re-search process is continued. FIG. 38 shows an example when there is a possibility of matching. FIG. 39 shows the end state of the re-search process of the optimization unit 26. FIG. 40 shows the result of processing of the instruction generation unit 28 for the syntax tree.

  As described above, since the floating-point instruction in the syntax tree having the node representing the store instruction on the left in FIG. 39 has a mark indicating that “the operation sensitive to the accuracy of the input value is communicated” is added. , Aggressive optimization is deterred.

  As described above, according to the first embodiment, it is possible to speed up operations in other parts of the program without degrading the accuracy of operations sensitive to the accuracy of input values.

  In the compiler apparatus according to the first embodiment, the processing other than the processing for adding a mark and the processing for suppressing the active optimization of the syntax tree including the node to which the mark is added. The processing content may be changed depending on the configuration of the compiler.

  Next, a second embodiment will be described. In addition, about the part which becomes the structure and effect | action similar to 1st Embodiment, the same code | symbol is attached | subjected and description is abbreviate | omitted.

  The second embodiment is different from the first embodiment in that a specific type of aggressive optimization is specified by an option to be passed at the time of starting the compiler, and the particular type of aggressive optimization is excluded from suppression. Is different. Note that, in the second embodiment, an option for specifying the type of aggressive optimization to be excluded from the suppression target is newly provided as a compiler startup option. In addition, a character string corresponding to the type of aggressive optimization designated as an option in advance is defined. In addition, as shown in FIG. 41, an optimization record table storing the types of processing performed in the aggressive optimization, the character strings corresponding to the types of the processing, and information on whether or not the suppression is performed is provided. Provide. Here, the information in the “optimization function” column of the optimization record table indicates the type of processing to be performed, the information in the “option character string” column indicates the corresponding character string, and “unsuppressed” Indicates whether the column information is not subject to suppression. Note that the initial value of “not subject to inhibition” in the optimization record table is “No”. In the second embodiment, it is assumed that there is only one type of aggressive optimization targeted in one syntax tree.

  FIG. 12 is an example of the compiler system 405 of the second embodiment. As shown in FIG. 12, the compiler system 405 includes a compiler device 401, a user terminal 3, and an external disk 40. The compiler device 401 according to the second embodiment is connected to the user terminal 3 for users and the external disk 40 through the network 2 such as the Internet so as to be able to communicate with each other.

  FIG. 42 shows a functional block diagram of the compiler apparatus 401 according to the second embodiment. As shown in FIG. 42, the compiler device 401 includes a compiler 420 including an argument analysis unit 422, a lexical syntax analysis unit 24, an optimization unit 426, an instruction generation unit 28, and a target program output unit 30. The compiler 420 includes a template storage unit 32, a recording table storage unit 44, and an optimized recording table storage unit 448.

  The compiler 420 is activated based on input information (command) received from the user terminal 3 and acquires a target source program from the source program storage unit 42 via the network 2. Further, the compiler 420 converts the acquired source program into a target program and stores it in the target program storage unit 46 via the network 2.

  The argument analysis unit 422 determines the operation of the compiler based on the input information received from the user terminal 3. The argument analysis unit 422 determines whether or not there is a character string corresponding to the aggressive optimization type that is not subject to suppression, as the acquired compiler startup option. If the argument analysis unit 422 determines that the character string exists, the argument analysis unit 422 stores “not subject to inhibition” corresponding to the character string in the optimization recording table illustrated in FIG. 41 and stored in the optimization recording table storage unit 448. "" Is set to "Yes". Since the other processing of the argument analysis unit 422 is the same as that of the argument analysis unit 22 of the first embodiment, the description thereof is omitted.

  The optimization unit 426 performs optimization for each syntax tree acquired by the lexical syntax analysis unit 24 based on the compiler operation related to optimization acquired by the argument analysis unit 422. The optimization unit 426 performs control analysis and data analysis for each syntax tree acquired by the lexical syntax analysis unit 24. Further, the optimization unit 426 performs syntax tree search and mark addition processing for each syntax tree.

  Next, when the optimization unit 426 determines that the option for performing the optimization is not specified based on the operation of the compiler related to the optimization acquired by the argument analysis unit 422, the optimization unit 426 normally performs processing for all the syntax trees. Do not perform optimization or aggressive optimization.

  Further, when the optimization unit 426 determines that the option for performing optimization is specified in the argument analysis unit 422 and the option for aggressive optimization is not specified, for all syntax trees, Perform normal optimization.

  Further, the optimization unit 426 determines that an option for performing optimization is specified in the argument analysis unit 422, and determines that an aggressive optimization option is specified, for each syntax tree. Normal optimization or aggressive optimization.

  Here, when the option for performing optimization is specified and the option for aggressive optimization is specified, it is determined whether to perform normal optimization or aggressive optimization. Will be described. First, the optimization unit 426 obtains a target aggressive optimization type based on each of the nodes included in the processing target syntax tree. Next, the optimization unit 426 determines whether or not the acquired positive optimization type is in the optimization record table stored in the optimization record table storage unit 448. Here, when the optimization record table includes the type of aggressive optimization acquired, the optimization unit 426 selects “not subject to inhibition” corresponding to the aggressive optimization in the optimization record table. It is determined whether or not the column is “YES”. If the optimization unit 426 determines that the answer is “YES”, it performs aggressive optimization on the syntax tree to be processed.

  On the other hand, the optimization unit 426 does not have the type of aggressive optimization acquired in the optimization record table, or the column “Non-suppressed” corresponding to the target aggressive optimization is “No”. Is determined based on whether or not a mark is added to a node included in the syntax tree.

  When a mark is added to a node included in the syntax tree to be processed, the optimization unit 426 performs normal optimization on the syntax tree. On the other hand, when there is no node with a mark added to a node included in the syntax tree to be processed, the optimization unit 426 performs aggressive optimization on the syntax tree.

  The optimization record table storage unit 448 stores an optimization record table as shown in FIG.

  The compiler apparatus 401 can be realized by a computer 500 shown in FIG. 43, for example. The computer 500 includes a CPU 502, a memory 504 as a temporary storage area, and a nonvolatile storage device 506. The computer 500 also includes an input / output I / F 210 to which the input / output device 208 is connected. The computer 500 also includes an R / W unit 214 that controls reading and writing of data with respect to the recording medium 212 and a network I / F 216 connected to the network 2 such as the Internet. The CPU 502, memory 504, storage device 506, input / output I / F 210, R / W unit 214, and network I / F 216 are connected to each other via a bus 218.

  The storage device 506 can be realized by an HDD, an SSD, a flash memory, or the like. A storage device 506 serving as a storage medium stores a compiler program 600 for causing the computer 500 to function as the compiler device 501. The storage device 506 includes a template storage area 350 in which each template is stored. Further, the storage device 506 has a recording table storage area 354 in which a recording table is recorded, and an optimized recording table storage area 558 in which an optimized recording table is recorded.

  The CPU 502 reads the compiler program 600 from the storage device 506 and expands it in the memory 504. The CPU 502 sequentially executes processes included in the compiler program 600. In addition, the CPU 502 reads the optimization record table stored in the optimization record table storage area 658 and develops it in the memory 504. Various data stored in other storage areas are also expanded in the memory 504 as in the first embodiment.

  The compiler program 600 includes an argument analysis process 602, a lexical syntax analysis process 304, an optimization process 606, an instruction generation process 308, and an object program output process 310.

  The CPU 502 operates as the argument analysis unit 422 illustrated in FIG. 42 by executing the argument analysis process 602. Further, the CPU 502 operates as the optimization unit 426 illustrated in FIG. 42 by executing the optimization process 606. Other processes are the same as those of the compiler program 300 in the first embodiment.

  The compiler device 501 can be realized by, for example, a semiconductor integrated circuit, more specifically, an ASIC or the like.

  Next, the operation of the compiler apparatus 501 according to the second embodiment will be described. First, when the compiler apparatus 501 receives input information received from the user terminal 3, the compiler apparatus 501 executes a compilation process shown in FIG. Note that the compilation processing executed by the compiler apparatus 501 is an example of a compiler method of the disclosed technology.

  FIG. 44 is a flowchart illustrating an example of compilation processing. 44, first, in step S700, the argument analysis unit 422 acquires an optimization record table from the optimization record table storage unit 448.

  Next, in step S702, the argument analysis unit 422 performs argument analysis.

  In step S704 subsequent to step S106, the optimization unit 426 performs optimization on each syntax tree acquired in step S104 based on the result of the option analysis acquired in step S702.

  The argument analysis process in step S702 will be described in detail with reference to FIG. In FIG. 45, although not shown, the argument analysis process performed in step S100 of the first embodiment is also performed in the argument analysis process. FIG. 45 is a flowchart illustrating an example of the argument analysis process in step S702. In the argument analysis processing flowchart shown in FIG. 45, first, in step S800, the argument analysis unit 422 determines whether or not an option for specifying aggressive optimization to be excluded from the suppression target is specified in the input information. To do. If the argument analysis unit 422 determines that an option that specifies aggressive optimization to be excluded from the suppression target is specified, the argument analysis processing proceeds to step S802. On the other hand, when the argument analysis unit 422 determines that the option for specifying the positive optimization to be excluded from the suppression target is not specified, the argument analysis process ends.

  Next, in step S802, the argument analysis unit 422 cuts out an optional character string that specifies aggressive optimization to be removed from the suppression target acquired in step S800.

  Next, in step S806, the argument analysis unit 422 sets the “non-suppression target” field in which the “option character string” field of the optimization record table acquired in step S700 is the character string acquired in step S802. Change to "YES".

  The optimization process in step S704 described above will be described in detail with reference to FIG. FIG. 46 is a flowchart illustrating an example of the optimization process in step S704. In the optimization process flowchart shown in FIG. 46, if an affirmative determination is made in step S210, the optimization process proceeds to step S900. In step S900, the optimization unit 426 acquires a target aggressive optimization type based on each node included in the processing target syntax tree.

  In step S902, the optimization unit 426 determines that the active optimization to be processed is not to be inhibited based on the type of aggressive optimization acquired in step S900 and the optimization record table acquired in step S700. It is determined whether or not. If the optimization unit 426 determines that the aggressive optimization to be processed is not the suppression target, the optimization process proceeds to step S214. On the other hand, when the optimizing unit 426 determines that the active optimization to be processed is a suppression target, the process proceeds to step S212.

  In step S900, the optimization unit 426 determines whether the active optimization to be processed is out of the suppression target based on the active optimization acquired in step S900 and the optimization record table acquired in step S700. Determine whether. If the optimization unit 426 determines that the aggressive optimization to be processed is not the suppression target, the optimization process proceeds to step S214. On the other hand, when the optimizing unit 426 determines that the active optimization to be processed is a suppression target, the process proceeds to step S212.

  As described above, according to the second embodiment, it is possible to speed up operations in other parts of the program without degrading the accuracy of operations sensitive to the accuracy of input values.

  Further, by making it possible to specify options that are not subject to aggressive optimization suppression, higher speed can be realized. For example, even if some of the aggressive optimizations that the compiler can perform are applied, the data generated by the process targeted for the optimization will not affect operations sensitive to the accuracy of the input values. This is a case where it can be determined.

  Next, a third embodiment will be described. In addition, about the part which becomes the structure and effect | action similar to 1st Embodiment, the same code | symbol is attached | subjected and description is abbreviate | omitted.

  In the third embodiment, an operation that is sensitive to the accuracy of a specific type of input value is specified by an option that is passed when the compiler is started, and all types of aggressive optimization that generates input data of the operation are to be suppressed. This is different from the first embodiment in that it is removed from the first embodiment. In the third embodiment, an option for specifying the type of operation sensitive to the accuracy of the input value, which is excluded from the suppression target, is newly provided as a compiler startup option. In addition, a character string corresponding to the type of calculation sensitive to the accuracy of the input value, which is designated as an option in advance, is defined. Further, as shown in FIG. 47, there is provided a designation process record table storing the type of calculation, a character string corresponding to the type of calculation, and information on whether or not the object is a suppression target. Here, the information in the “Calculation type” column of the specified processing record table indicates the type of calculation to be performed, the information in the “Option character string” column indicates the corresponding character string, and the “Not subject to suppression” column This information indicates whether or not the information is not subject to suppression. It is assumed that the initial value of “not subject to inhibition” in the designation processing record table is “No”.

  FIG. 12 is an example of the compiler system 705 according to the third embodiment. As shown in FIG. 12, the compiler system 705 includes a compiler device 701, a user terminal 3, and an external disk 40. A compiler apparatus 701 according to the third embodiment is connected to a user terminal 3 for users and an external disk 40 via a network 2 such as the Internet so as to be able to communicate with each other.

  FIG. 48 shows a functional block diagram of a compiler apparatus 701 according to the third embodiment. As shown in FIG. 48, the compiler apparatus 701 includes a compiler 720 including an argument analysis unit 722, a lexical syntax analysis unit 24, an optimization unit 726, an instruction generation unit 28, a target program output unit 30, and a template storage unit 32. . Further, the compiler 720 includes a recording table storage unit 44 and a designation processing recording table storage unit 748.

  The compiler 720 is activated based on input information (command) received from the user terminal 3, and acquires a target source program from the source program storage unit 42 via the network 2. Further, the compiler 720 converts the acquired source program into a target program and stores it in the target program storage unit 46 via the network 2.

  The argument analysis unit 722 determines the operation of the compiler based on the input information received from the user terminal 3. The argument analysis unit 722 determines whether there is a character string corresponding to an operation sensitive to the accuracy of an input value that is not subject to suppression, as the acquired compiler startup option. If the argument analysis unit 722 determines that the character string exists, the argument analysis unit 722 stores “not subject to inhibition” corresponding to the character string in the designation process record table illustrated in FIG. 47 stored in the designation process record table storage unit 748. "" Is set to "Yes". Since the other processing of the argument analysis unit 722 is the same as that of the argument analysis unit 22 of the first embodiment, description thereof is omitted.

  The optimization unit 726 performs optimization for each syntax tree acquired by the lexical syntax analysis unit 24 based on the compiler operation related to optimization acquired by the argument analysis unit 722. The optimization unit 726 performs control analysis and data analysis for each syntax tree acquired by the lexical syntax analysis unit 24.

  Next, the optimization unit 726 searches each syntax tree for a node of the syntax tree, and relates to an operation related to an input value that is sensitive to the accuracy of the input value among the nodes included in the syntax tree. Mark the node.

  Specifically, first, the optimization unit 726 determines the root node of the syntax tree to be processed among the syntax trees as the node to be processed. Next, the optimization unit 726 says that the node is “a node representing an operation sensitive to the accuracy of the input value”, “the operation is not subject to inhibition”, and “the parent node is marked”. It is determined whether at least one of the two conditions is satisfied. Here, in determining whether or not “the operation is not subject to inhibition”, there is an operation type corresponding to the target operation in the specified process record table stored in the specified process record table storage unit 748. In addition, the determination is made based on whether the “non-suppression subject” column is “Nо”. If the optimization unit 726 determines that there is an operation type and that the “not subject to inhibition” column is “No”, it determines that “the operation is not subject to inhibition”. On the other hand, when the optimization unit 726 determines that there is an operation type and the “not subject to inhibition” field is “YES”, the optimization unit 726 judges that “the operation is not subject to inhibition”. .

  Next, when the optimization unit 726 determines that the condition is satisfied, the optimization unit 726 adds a mark to the node. Next, the optimization unit 726 determines whether the node is a load instruction. When the node is a load instruction, the optimization unit 726 stores the address indicated by the load instruction in the recording table stored in the recording table storage unit 44. Similar to the optimization unit 26 of the first embodiment, the optimization unit 726 recursively repeats the same processing until there are no unprocessed child nodes in the processing target node, thereby generating a syntax tree. For each, a process of adding a mark to each of the nodes included in the syntax tree is performed.

  Next, the optimization unit 726 re-searches the syntax tree for each syntax tree, and sets the input value of an operation sensitive to the accuracy of the input value of another syntax tree among the nodes included in the syntax tree. A mark is added to a node related to an operation involved.

  The designation process record table storage unit 748 stores a designation process record table as shown in FIG.

  The compiler apparatus 701 can be realized by a computer 800 shown in FIG. 49, for example. The computer 800 includes a CPU 802, a memory 804 as a temporary storage area, and a nonvolatile storage device 806. The computer 800 also includes an input / output I / F 210 to which the input / output device 208 is connected. The computer 800 also includes an R / W unit 214 that controls reading and writing of data with respect to the recording medium 212 and a network I / F 216 connected to the network 2 such as the Internet. The CPU 802, the memory 804, the storage device 806, the input / output I / F 210, the R / W unit 214, and the network I / F 216 are connected to each other via a bus 218.

  The storage device 806 can be realized by an HDD, an SSD, a flash memory, or the like. A storage device 806 as a storage medium stores a compiler program 900 for causing the computer 800 to function as the compiler device 701. The storage device 806 includes a template storage area 350 in which each template is stored. Further, the storage device 806 has a recording table storage area 354 in which a recording table is recorded, and a designated process recording table storage area 958 in which a designated process recording table is recorded.

  The CPU 802 reads the compiler program 900 from the storage device 806 and expands it in the memory 804. The CPU 802 sequentially executes processes included in the compiler program 900. Further, the CPU 802 reads the designated process record table stored in the designated process record table storage area 958 and develops it in the memory 804. Various data stored in other storage areas are also expanded in the memory 504 as in the first embodiment.

  The compiler program 900 includes an argument analysis process 902, a lexical syntax analysis process 304, an optimization process 906, an instruction generation process 308, and an object program output process 310.

  The CPU 802 operates as the argument analysis unit 722 illustrated in FIG. 48 by executing the argument analysis process 902. Further, the CPU 802 operates as the optimization unit 726 illustrated in FIG. 48 by executing the optimization process 906. Other processes are the same as those of the compiler program 300 in the first embodiment.

  The compiler device 701 can be realized by, for example, a semiconductor integrated circuit, more specifically, an ASIC or the like.

  Next, the operation of the compiler apparatus 701 according to the third embodiment will be described. First, when the compiler apparatus 701 receives input information received from the user terminal 3, the compiler apparatus 701 executes a compilation process shown in FIG. Note that the compilation processing executed by the compiler device 701 is an example of a compiler method of the disclosed technology.

  FIG. 50 is a flowchart illustrating an example of the compiling process. In the flowchart of the compilation process shown in FIG. 50, first, in step S1100, the argument analysis unit 722 acquires a designated process record table from the designated process record table storage unit 748.

  Next, in step S1102, the argument analysis unit 722 performs argument analysis.

  In step S1104 following step S106, the optimization unit 726 performs optimization on each syntax tree acquired in step S104 based on the result of the option analysis acquired in step S1102.

  The argument analysis processing in step S1102 will be described in detail with reference to FIG. In FIG. 51, although not shown, the argument analysis process performed in step S100 of the first embodiment is also performed in the argument analysis process. FIG. 51 is a flowchart illustrating an example of the argument analysis processing in step S1102. In the flowchart of the argument analysis processing shown in FIG. 51, first, in step S1150, the argument analysis unit 722 determines whether or not an option for specifying an operation sensitive to the accuracy of the input value to be excluded from the suppression target is specified in the input information. Determine whether. If the argument analysis unit 722 determines that an option for specifying an operation sensitive to the accuracy of the input value to be excluded from the suppression target is specified, the argument analysis process proceeds to step S1152. On the other hand, when the argument analysis unit 722 determines that the option for specifying the operation sensitive to the accuracy of the input value to be excluded from the suppression target is not specified, the argument analysis process is terminated.

  Next, in step S1152, the argument analysis unit 722 cuts out an optional character string that specifies an operation sensitive to the accuracy of the input value excluded from the suppression target acquired in step S1150.

  Next, in step S1154, the argument analysis unit 722 sets the “non-suppression target” field in which the “option character string” field of the designation processing record table acquired in step S1100 is the character string acquired in step S1152. Change to "YES".

  The optimization process in step S1104 described above will be described in detail with reference to FIG. FIG. 52 is a flowchart illustrating an example of the optimization process in step S1104. In the optimization processing flowchart shown in FIG. 52, in step S1200 subsequent to step S200, the optimization unit 726 searches the syntax tree for each of the syntax trees acquired in step S106. Further, the optimization unit 726 adds a mark to a node related to an operation related to an input value of an operation sensitive to the accuracy of the input value of the searched syntax tree.

  The syntax tree search and marking process in step S1200 will be described in detail with reference to FIG. FIG. 53 is a flowchart illustrating an example of syntax tree search and mark addition processing in step S1200. In the flowchart of the syntax tree search and mark addition process shown in FIG. 53, in step S1300 subsequent to step S300, the optimization unit 726 searches for the syntax tree to be processed and marks the target node. Append.

  The syntax tree search process in step S1300 will be described in detail with reference to FIG. FIG. 54 is a flowchart illustrating an example of syntax tree search processing in step S1300. In the flowchart of the syntax tree search process shown in FIG. 54, if an affirmative determination is made in step S402 that the operation indicated by the processing target node is the target operation, the syntax tree search process proceeds to step S1400. In step S1400, the optimization unit 726 determines whether or not the operation indicated by the processing target node exists in the designated processing record table acquired in step S1100, and the “non-suppression subject” column corresponding to the operation is “YES”. Determine whether. If the optimization unit 726 determines that the “non-suppression subject” column corresponding to the calculation is “YES”, the syntax tree search process proceeds to step S404. To do. On the other hand, when the optimization unit 726 determines that the column of “non-suppression target” corresponding to the calculation does not exist or “No” is “No”, The process proceeds to step S406.

  As described above, according to the third embodiment, it is possible to speed up operations in other parts of the program without degrading the accuracy of operations sensitive to the accuracy of input values.

  Further, it is possible to realize a higher speed by making it possible to specify an option that excludes an operation that is sensitive to the accuracy of the input value from the object of aggressive optimization suppression. For example, if it can be determined that the data does not contain special values that produce results that differ from normal optimization when aggressive optimization is applied to the program, such aggressive optimization is suppressed. Can be removed from the target.

  In the above description, the mode in which the programs according to the disclosed technology are stored (installed) in advance in the storage devices 206, 506, and 806 has been described. However, the present invention is not limited to this. Each program according to the disclosed technology can be provided in a form recorded on a recording medium such as a CD-ROM, a DVD-ROM, or a USB memory.

  Regarding the above embodiment, the following additional notes are disclosed.

(Appendix 1)
Obtaining a plurality of structures representing each of a plurality of operations included in the first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations;
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program Performing the optimization on the structure to be optimized,
Compiler program that causes a computer to execute a process including the above.
(Appendix 2)
The process of obtaining the plurality of structures further obtains a structure representing an instruction for reading data, a structure representing an instruction for storing data, and a data dependency relationship between the operation and the instruction to be read.
The process of marking a structure representing an operation having the data dependency relationship is an operation having a data dependency relationship with the operation of the structure to which the mark is added based on the acquired data dependency relationship. The structure having the mark added thereto by adding another mark to the structure representing the read instruction having a data dependency relationship with the structure of the structure to which the mark is added and the operation of the structure to which the mark has been added The compiler program according to appendix 1, wherein another mark is added to a structure representing an instruction for storing data read by the read instruction.
(Appendix 3)
The process of performing the optimization is further the structure representing the optimization target operation that is designated as the suppression target out of the optimization target operations, and the mark The compiler program according to appendix 1 or 2, wherein the optimization is performed on the structure to which is added.
(Appendix 4)
The process of adding a mark to the structure in the case of the operation is an operation in which, for each of the structures representing the acquired operation, the operation has a specific influence on the output result according to the accuracy of the input value. Or 1 to add a mark to the structure when the calculation is not targeted for the optimization among the calculations targeted for optimization. 2. The compiler program described in 2.
(Appendix 5)
Obtaining a plurality of structures representing each of a plurality of operations included in the first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations;
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program Performing the optimization on the structure to be optimized,
A compiler method that includes:
(Appendix 6)
The process of obtaining the plurality of structures further obtains a structure representing an instruction for reading data, a structure representing an instruction for storing data, and a data dependency relationship between the operation and the instruction to be read.
The process of marking a structure representing an operation having the data dependency relationship is an operation having a data dependency relationship with the operation of the structure to which the mark is added based on the acquired data dependency relationship. The structure having the mark added thereto by adding another mark to the structure representing the read instruction having a data dependency relationship with the structure of the structure to which the mark is added and the operation of the structure to which the mark has been added The compiler method according to appendix 5, wherein another mark is added to a structure representing an instruction for storing data read by the read instruction.
(Appendix 7)
The process of performing the optimization is further the structure representing the optimization target operation that is designated as the suppression target out of the optimization target operations, and the mark The compiler method according to appendix 5 or 6, wherein the optimization is performed on the structure to which is added.
(Appendix 8)
The process of adding a mark to the structure in the case of the operation is an operation in which, for each of the structures representing the acquired operation, the operation has a specific influence on the output result according to the accuracy of the input value. Or 5 for adding a mark to the structure when the calculation is not targeted for optimization among the calculations targeted for optimization 6. The compiler method according to 6.
(Appendix 9)
A lexical parsing unit for acquiring a plurality of structures representing each of a plurality of operations included in a first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations; ,
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program An optimization unit that performs the optimization on the structure to be optimized;
Compiler device including
(Appendix 10)
The lexical parsing unit further acquires a structure representing an instruction for reading data, a structure representing an instruction for storing data, and a data dependency relationship between the operation and the instruction to be read.
The optimization unit includes a structure representing an operation having a data dependency relationship with the operation of the structure to which the mark is added based on the acquired data dependency relationship, and the mark is added. Another mark is added to the structure representing the read instruction having data dependency with the operation of the structure, and the read instruction of the structure to which the mark is added represents the instruction to store the read data The compiler apparatus according to appendix 9, wherein another mark is added to the structure.
(Appendix 11)
The optimization unit is the structure that represents the optimization target operation that is designated as a non-suppression target among the optimization target operations, and the mark is added. The compiler apparatus according to appendix 9 or 10, wherein the optimization is performed on the structure.
(Appendix 12)
The optimization unit is a case where, for each of the structures representing the acquired operations, the operation is an operation whose output result has a specific influence according to the accuracy of an input value, and the optimum 11. The compiler apparatus according to appendix 9 or 10, wherein a mark is added to the structure when the operation to be optimized is not the operation to be optimized that is designated as not subject to suppression.
(Appendix 13)
A lexical parsing unit for acquiring a plurality of structures representing each of a plurality of operations included in a first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations; ,
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program An optimization unit that performs the optimization on the structure to be optimized;
A compiler apparatus including
An information terminal for transmitting input information to the compiler device by a user operation;
Including compiler system.
(Appendix 14)
Obtaining a plurality of structures representing each of a plurality of operations included in the first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations;
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program Performing the optimization on the structure to be optimized,
The recording medium which stored the compiler program which makes a computer perform the process including this.

1, 401, 701 Compiler device 2 Network 3 User terminal 5, 405, 705 Compiler system 20, 420, 720 Compiler 22, 422, 722 Argument analysis unit 24 Lexical syntax analysis unit 26, 426, 726 Optimization unit 28 Instruction generation Unit 30 target program output unit 32 template storage unit 40, external disk 42 source program storage unit 44 recording table storage unit 46 target program storage unit 448 optimization recording table storage unit 748 designation processing recording table storage unit

Claims (7)

Obtaining a plurality of structures representing each of a plurality of operations included in the first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations;
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program Performing the optimization on the structure to be optimized,
Compiler program that causes a computer to execute a process including the above. The process of obtaining the plurality of structures further obtains a structure representing an instruction for reading data, a structure representing an instruction for storing data, and a data dependency relationship between the operation and the instruction to be read.
The process of marking a structure representing an operation having the data dependency relationship is an operation having a data dependency relationship with the operation of the structure to which the mark is added based on the acquired data dependency relationship. The structure having the mark added thereto by adding another mark to the structure representing the read instruction having a data dependency relationship with the structure of the structure to which the mark is added and the operation of the structure to which the mark has been added The compiler program according to claim 1, wherein another mark is added to a structure representing an instruction for storing data to be read by the read instruction.   The process of performing the optimization is further the structure representing the optimization target operation that is designated as the suppression target out of the optimization target operations, and the mark The compiler program according to claim 1, wherein the optimization is performed on the structure to which is added.   The process of adding a mark to the structure in the case of the operation is an operation in which, for each of the structures representing the acquired operation, the operation has a specific influence on the output result according to the accuracy of the input value. The mark is added to the structure when it is not the operation to be the optimization target specified as the suppression target among the operations to be optimized. Or the compiler program of 2 description. Obtaining a plurality of structures representing each of a plurality of operations included in the first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations;
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program Performing the optimization on the structure to be optimized,
A compiler method that includes: A lexical parsing unit for acquiring a plurality of structures representing each of a plurality of operations included in a first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations; ,
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program An optimization unit that performs the optimization on the structure to be optimized;
Compiler device including A lexical parsing unit for acquiring a plurality of structures representing each of a plurality of operations included in a first program to be compiled, and a data dependency representing a data input / output relationship between the plurality of operations; ,
For each of the acquired structures, the structure is marked when the operation represented by the acquired structure is an operation whose output result is specifically affected according to the accuracy of the input value. Add
Based on the acquired data dependency relationship, another mark is added to the structure representing an operation having a specific data dependency relationship with respect to the operation represented by the structure to which the mark is added,
Of the structures not marked with the mark, the optimal replacement of the first program with the content of the operation that generates a different result under a specific condition by executing the compilation on the first program An optimization unit that performs the optimization on the structure to be optimized;
A compiler apparatus including
An information terminal for transmitting input information to the compiler device by a user operation;
Including compiler system.

Images