JP4473626B2 - Compiler, recording medium, compiling device, communication terminal device, and compiling method - Google Patents

Description

  The present invention is a compiler language sometimes referred to as a high-level programming language, for example, a classic compiler language such as C language, C ++ language, Java (R) language, FORTRAN and COBOL, or APL, PL / 1, ADA. , Smalltalk, Lisp, assembler language, and any other programming language, and any language for machine such as CPU (Central Processing Unit) (where CPU is MPU (Micro Processing Unit) A machine language (machine language) that can be directly executed by a machine processor (including a microcomputer), a compiler that converts the target program, which is some intermediate language as a process of converting into a machine language, or records this compiler Recording medium, compiling device for compiling, and compiling It relates compiling method for performing a communication terminal apparatus and compiled with the location. The above "Java (R)" is a registered trademark of Sun Microsystems, Inc. In this specification, the symbol (R) represents a registered trademark.

As a conventional partial compiler, for example, the one described in Patent Document 1 is known. The conventional partial compiler described in Patent Document 1 makes it possible to determine the necessity of inline expansion for each function call, perform inline expansion suitable for the execution image, and enable practical and efficient inline expansion. It was intended. In this prior art, for this purpose, the control flow weighting unit estimates the number of execution times of each partial control flow constituting the control flow based on the analysis result of the control flow analysis unit, and each partial control flow is based on the number of execution times. Is weighted. Further, the object generation means determines whether or not inline expansion of the function called by each function call is necessary by referring to the result of weighting by the control flow weighting means, and generates an object program reflecting the determination.
JP-A-6-202875

  In the conventional partial compiler described in Patent Document 1, when calculating the number of executions in order to determine a compilation part, a subprogram executed in a program called from another program has a so-called multiple nested structure of loops. The number of executions is calculated in consideration of the multiplicity of the loop nesting, that is, the depth of the loop. However, this partial compiler does not allow the multiplicity of loop nesting in the read source program, that is, the loop even if the subprogram executed in the calling source program also has a loop nesting structure. It is not considered in the depth of.

  For this reason, the conventional partial compiler described in Patent Document 1 takes into account the depth of the loop executed at the call source and the depth of the loop executed at the call destination, and gives priority to the portion with a large number of executions as a whole. Had the problem of being unable to compile. As a result, this conventional technique has a problem that it is not possible to optimize the improvement in the execution speed of the program and the reduction in the storage capacity of the memory for storing the program.

  Further, in the prior art described in Patent Document 1, for example, even when a loop of a double nesting structure exists, the return destination of each loop is the same address and a different label (that is, a symbol / symbol indicating an address) ) Is not attached, it is possible to determine whether the return destination is a return from the middle of a single loop and a return from the end, or a return destination of a double nested loop. It had the problem that it was not possible. Therefore, this conventional technique has a problem that the depth of the loop or the number of executions cannot be accurately calculated. In other words, this conventional technique cannot select a part with a high number of executions with high accuracy and preferentially compile in this respect, and can optimize the improvement of the execution speed and the reduction of the memory area used. It had the problem that it was not possible.

  The present invention has been made in view of the above-mentioned problems, and enables a portion of a source program that has a high number of executions or a portion that has a high possibility of a high number of executions to be selected with good accuracy and preferentially compiled. And a compiler, a recording medium, a compiling device, a communication terminal device, and a compiling device, which can optimize the improvement of the execution speed of the program and the reduction of the storage capacity of the memory for storing the program with good accuracy. It aims to provide a method.

  In order to solve the above problems and achieve the above object, the invention described in claim 1 is a compiler for converting a source program into a target program, and detects a multiple nested structure included in the source program. Of the detection procedure, the return address detection procedure for detecting the return address of each unit loop constituting the multiple nested structure, and the plurality of return addresses detected by the return address detection procedure, the addresses are common to each other An address duplication determination procedure for determining whether or not there is a duplicate return destination address, and when the address duplication determination procedure determines that there is a duplicate return destination address, A dividing procedure for converting the source program to a target program having a different address; It is intended to be executed by the.

  According to the first aspect of the present invention, when there is an overlap among the return destination addresses of the unit loops constituting the multi-nested structure, the overlapping address is made different from each other. It is possible to correctly calculate the depth. As a result, it is possible to correctly select and preferentially compile a deep part of a loop that is likely to be a part with a large number of executions.

  The invention according to claim 2 is the compiler according to claim 1, wherein the division procedure adds an unnecessary instruction that is an instruction that does not affect execution to any of the duplicate return destination addresses. An instruction addition procedure is provided in which the overlapping return destination addresses are different from each other.

  According to the second aspect of the present invention, since the duplicate return destination addresses are made different from each other by adding unnecessary instructions in the division procedure, the loop depth can be calculated correctly without affecting the execution. Is possible.

  The invention described in claim 3 is a compiler for converting the first and second source programs into a target program, and is included in the first source program, and detects a first loop having a multiple or single nested structure. A first loop detection procedure, a second loop detection procedure for detecting a second loop included in the second source program called from the first loop and having a multiple or single nested structure, A loop depth evaluation procedure for calculating a total nesting number by adding the nesting number of one loop and the nesting number of the second loop, and preferentially compiling the second loop having the large total nesting number, This is for causing a computer to execute a partial compilation procedure for converting the first and second source programs into the target program.

  According to the invention described in claim 3, not only the number of nested first loops included in one primitive program but also the number of nested second loops included in another primitive program called from within this loop is included. The total nesting number is calculated, and the second loop having a large total nesting number is preferentially compiled. In other words, considering the depth of the loop executed at the call source and the depth of the loop executed at the call destination, a loop with a high number of nesting is likely to be a part with a high number of executions. Is compiled into

  According to a fourth aspect of the present invention, there is provided a compiler for converting a plurality of source programs into a target program, wherein a first loop which is included in one of the plurality of source programs and has a multiple or single nested structure is searched. When the first loop detection procedure and the first loop detection procedure detect the first loop, the first loop detection procedure is included in another source program called from the first loop among the plurality of source programs. A second loop detection procedure for searching for a second loop having a single nested structure; and when the second loop detection procedure detects the second loop, the first loop detection means detects the first loop. As a first iterative procedure for performing the second loop detection procedure again, and if either the first loop or the second loop is not detected A loop depth evaluation procedure for calculating a loop depth which is the total number of loops nested and a loop depth evaluation procedure from the first loop detection procedure to the loop depth evaluation procedure is repeated until the first loop is not detected. In order to cause a computer to execute two iterative procedures and a partial compilation procedure for converting the plurality of source programs into the target program by preferentially compiling a loop having a large loop depth among the plurality of source programs. belongs to.

  According to the invention described in claim 4, the total number of nestings including not only the number of nesting of loops included in one source program but also the number of nesting of loops included in the source program sequentially called from this loop is obtained. Computed loops with a large total number of nesting are preferentially compiled. In other words, a loop with a large total number of nesting is preferentially compiled, including a multiple nesting structure formed between each source program that is called from one source program in order. Therefore, a portion of the source program that is likely to be a portion with a high execution frequency is selected and compiled with higher accuracy.

  Invention of Claim 5 is the compiler of Claim 4, Comprising: When the said partial compilation procedure does not satisfy | fill the predetermined threshold value with the maximum value of the loop depth which the said loop depth evaluation procedure calculated | required, No part of the plurality of source programs is compiled.

  According to the fifth aspect of the present invention, when the maximum value of the loop depth is less than the threshold value, no part of the plurality of source programs is compiled, so that the part that does not contribute to the improvement of the execution speed is wasted. Thus, useless use of the memory area can be avoided.

  The invention according to claim 6 is the compiler according to claim 4 or 5, wherein, when the loop depth evaluation procedure calculates a plurality of loop depths, whether or not the plurality of loop depths are uniform. A uniformity evaluation procedure for determining whether or not the partial compilation procedure determines that the plurality of primitives are uniform when the uniformity evaluation procedure determines that the plurality of loop depths are uniform. It does not compile any part of the program.

  According to the sixth aspect of the present invention, when a plurality of loop depths are uniform, any part of the plurality of source programs is not compiled, so there are many parts that contribute to the improvement of the execution speed. Compiling to avoid losing effective use of the memory area can be avoided.

  The invention according to claim 7 is a compiler that converts the first and second source programs into a target program, and is a part that is included in the first source program and executed repeatedly. A first iterative execution part detection procedure for detecting a part and a second iterative execution part that is included in the second original program called from the first iterative execution part and is repeatedly executed A second iterative execution unit detection procedure, a total execution number evaluation procedure for calculating the total number of executions by adding the number of executions of the first iterative execution unit and the number of executions of the second iterative execution unit, By preferentially compiling the second repetitive execution unit having a large number of executions, the computer executes a partial compilation procedure for converting the first and second source programs into the target program. .

  According to the seventh aspect of the present invention, not only the number of executions of the first iterative execution unit included in one source program but also the execution of the second iterative execution unit included in another source program called from this loop. The total number of executions including the number of times is calculated, and the second iterative execution unit having a large total number of executions is preferentially compiled. In other words, the number of executions of the iterative execution unit executed at the call source and the number of executions of the iterative execution unit executed at the call destination are considered together, and the repetitive execution unit having a large number of executions is preferentially compiled.

  The invention according to claim 8 is a compiler that converts a plurality of source programs into a target program, and includes a first iterative execution unit that is included in one of the plurality of source programs and that is repeatedly executed. A first iterative execution unit detection procedure to be searched, and when the first iterative execution unit detection procedure detects the first iterative execution unit, it is called from the first iterative execution unit among the plurality of source programs. A second iterative execution unit detecting procedure for searching for a second iterative execution unit included in another source program that is repeatedly executed, and the second iterative execution unit detecting procedure detects the second iterative execution unit. In this case, the first iterative execution unit detecting means detects the first iterative execution unit, the first iterative procedure for executing the second iterative execution unit detection procedure again, the first iterative execution unit, and the With the second iteration execution unit A total execution number evaluation procedure for calculating the total number of executions, which is the sum of the number of executions of the iterative execution units detected so far, and the total execution number from the first iterative execution unit detection procedure. By preferentially compiling a second iteration procedure that repeats up to the number evaluation procedure until the first iteration execution unit is not detected, and a repetition execution unit having a large total number of executions among the plurality of source programs, And causing a computer to execute a partial compilation procedure for converting the plurality of source programs into the target program.

  According to the eighth aspect of the present invention, not only the number of executions of the repetitive execution unit included in one source program but also the number of executions of the repetitive execution unit included in the source program sequentially called from the repetition execution unit is obtained. The total number of executions is calculated, and the repetitive execution unit having a large total number of executions is preferentially compiled. In other words, the repetitive execution part with the large total number of executions is preferentially compiled, including the multiple structure of the repetitive execution part composed between each source program that is called from one source program in order. The Therefore, the portion of the source program that is frequently executed is selected and compiled with higher accuracy.

  The invention according to claim 9 is the compiler according to claim 8, wherein the partial compilation procedure is performed when the maximum value of the total number of executions calculated by the total execution number evaluation procedure is less than a predetermined threshold value. Does not compile any part of the plurality of source programs.

  According to the ninth aspect of the present invention, when the maximum value of the total number of executions is less than the threshold value, no part of the plurality of source programs is compiled. Thus, useless use of the memory area can be avoided.

  A tenth aspect of the invention is the compiler according to the eighth or ninth aspect, wherein, when the total number of executions evaluation step calculates a plurality of total number of executions, whether or not the plurality of total number of executions is uniform. The computer further executes a uniformity evaluation procedure for determining whether or not the partial compilation procedure determines that the plurality of primitives if the uniformity evaluation procedure determines that the plurality of total execution times are uniform. It does not compile any part of the program.

  According to the tenth aspect of the present invention, when the total number of times of execution is uniform, no part of the plurality of source programs is compiled, so there are many parts that contribute to the improvement of the execution speed. Compiling to avoid losing effective use of the memory area can be avoided.

  The invention described in claim 11 is a compiler for converting the first and second source programs into a target program, and is a loop or non-loop having a multiple or single nested structure included in the first source program. A first call detection procedure for searching for a second processing part that is a loop or non-loop having a multiple or single nested structure included in the second source program called from the first processing part; and the first call A third processing portion that is a processing portion including the first processing portion of the first source program called in the second processing portion when the detection procedure detects the second processing portion. When the second call detection procedure for searching for and the second call detection procedure detects the processing part, among the first and second source programs, By compiling a serial second processing portion and said third processing section, is intended for executing a portion compilation step of converting the first and second source program into the object program in the computer.

  According to the invention described in claim 11, the first and second call detection procedures detect a so-called reentry structure existing between the first and second source programs, and partially compile the detected reentry structure. The procedure compiles. That is, a reentry structure that is a portion of the source program that has a high possibility of execution is selected and compiled.

  The invention according to claim 12 is a compiler for converting a source program into a target program, a multiple nested structure detection procedure for detecting a multiple nested structure included in the source program, and each unit loop constituting the multiple nested structure A return destination address detecting procedure for detecting a return destination address and a plurality of return destination addresses detected by the return destination address detecting procedure include an unnecessary instruction that is an instruction that does not affect execution. And when the unnecessary instruction detection procedure detects a return address having the unnecessary instruction, the source program is converted into the target program from which the unnecessary instruction has been deleted. This is to cause the computer to execute the unnecessary instruction deletion procedure.

  According to the twelfth aspect of the present invention, the unnecessary instruction deletion procedure deletes the unnecessary instruction when there is an unnecessary instruction in the return destination address of the unit loop constituting the multiple nested structure. Speed delays can be avoided. In other words, unnecessary instructions that can be preferentially compiled by correctly selecting the deep part of the loop that is likely to be executed frequently are deleted after compiling and executed while saving the memory area. The speed can be further increased.

  A thirteenth aspect of the invention is a computer-readable recording medium on which the compiler according to any one of the first to twelfth aspects is recorded.

  According to the thirteenth aspect of the invention, since the compiler of the present invention is recorded on the recording medium, the portion of the source program that has been executed frequently or the It is possible to select and compile a part that is highly likely to be accurate.

  The invention according to claim 14 is a compiling device for converting a source program into a target program, a multiple nested structure detecting means for detecting a multiple nested structure included in the source program, and each unit constituting the multiple nested structure It is determined whether there is a duplicate return destination address having a common address among the return destination address detecting means for detecting the return address of the loop and the plurality of return destination addresses detected by the return destination address detecting means. When the address duplication judgment means and the address duplication judgment procedure judge that there is the duplicate return destination address, the source program is converted into the target program having the duplicate return destination address different from each other as the target program. And a dividing means.

  According to the fourteenth aspect of the present invention, when there is an overlap among the return destination addresses of the unit loops constituting the multiple nesting structure, the dividing means makes the overlapping addresses different from each other. It is possible to correctly calculate the depth. As a result, it is possible to correctly select and preferentially compile a deep part of a loop that is likely to be a part with a large number of executions.

The invention according to claim 15 is a compiling device for converting a plurality of source programs into a target program, and is included in one source program among the plurality of source programs and has a multiple or single nested structure. Each time a loop is searched and the first loop is detected, the second included in another source program called from the first loop among the plurality of source programs and having a multiple or single nested structure When searching for a loop and detecting the second loop, it is assumed that the first loop has been detected, and the second loop is further searched so that the one source program and the one source program are detected. and loop detection means for searching the multiple nested comprised between each source program that is the callee in order, said loop Each time the detecting means detects the first loop, the number of nesting of the first loop, or when said loop detection means detects the second loop, the first loop in order for each of the second loop Loop depth evaluation means for calculating a loop depth which is the total number of nestings obtained by addition, and by preferentially compiling a loop having a large loop depth among the plurality of source programs, Partial compile means for converting the program into the target program.

  According to the fifteenth aspect of the present invention, the total number of nestings including not only the number of nesting loops included in one source program but also the number of nesting loops included in the source program sequentially called from this loop is obtained. Computed loops with a large total number of nesting are preferentially compiled. In other words, a loop with a large total number of nesting is preferentially compiled, including a multiple nesting structure formed between each source program that is called from one source program in order. Therefore, a portion of the source program that is likely to be a portion with a high execution frequency is selected and compiled with higher accuracy.

  The invention according to claim 16 is the compiling device according to claim 15, wherein the partial compiling means has a maximum value of the loop depth calculated by the loop depth evaluating means that is less than a predetermined threshold value. Does not compile any part of the plurality of source programs.

  According to the sixteenth aspect of the present invention, when the maximum value of the loop depth is less than the threshold value, no part of the plurality of source programs is compiled, so that a part that contributes less to improving the execution speed is wasted. Thus, useless use of the memory area can be avoided.

  The invention according to claim 17 is the compiling device according to claim 15 or 16, wherein the plurality of loop depths are uniform when the loop depth evaluation means calculates a plurality of loop depths. A uniformity evaluation means for determining whether or not the partial compilation means does not compile any part of the plurality of source programs when the uniformity evaluation means determines that the uniformity is uniform. is there.

  According to the seventeenth aspect of the present invention, when a plurality of loop depths are uniform, any part of the plurality of source programs is not compiled, so there are many parts that contribute to an improvement in execution speed. Compiling to avoid losing effective use of the memory area can be avoided.

  The invention according to claim 18 is a communication terminal device, the compiling device according to any one of claims 14 to 17, communication means for acquiring a source program to be compiled by the compiling device through a transmission medium, And an execution control means for executing the target program generated by the compiling device.

  According to the invention described in claim 18, since the communication terminal device includes the communication means, the source program can be acquired through the transmission medium, and can be compiled by the compiling device. Furthermore, since the communication terminal device includes the execution control means, the compiled object program can be executed. That is, according to this compiling apparatus, the original program acquired through the transmission medium can be executed. Furthermore, since the communication terminal includes the compiling device according to the present invention, it is possible to optimize the improvement of the execution speed and the reduction of the memory area used with good accuracy.

  The invention according to claim 19 is the communication terminal device according to claim 18, wherein the execution control unit is a non-compiled program that is a source program that is processed by the compiling device and does not compile any part thereof. The execution control unit detects a high-frequency execution portion that is a portion that is executed at a frequency exceeding a predetermined reference value in the target program during execution of the non-compiled program. A frequency detection unit and another partial compilation unit that compiles the high-frequency execution part detected by the frequency detection unit are provided.

  According to the nineteenth aspect of the present invention, the high-frequency execution part detected by the frequency detection means during the execution of the non-compiled program is compiled by the partial compilation means. That is, the non-compiled program is compiled by so-called JIT. Therefore, from the viewpoint of optimizing the execution speed and saving the memory area, when it is not appropriate for the compiling apparatus to perform pre-compilation, optimization can be achieved by JIT instead.

  The invention according to claim 20 is a compiling method in which a computer converts a source program into a target program, and comprises a multi-nested structure detection procedure for detecting a multi-nested structure included in the source program, and the multi-nested structure. A return address detection procedure for detecting a return address of each unit loop and whether there are duplicate return addresses having a common address among a plurality of return addresses detected by the return address detection procedure. When the address duplication determination procedure and the address duplication determination procedure determine that there is the duplicate return destination address, the source program is changed to the target program having the duplicate return destination address different from each other as the target program. And a dividing procedure for converting.

  According to the twentieth aspect of the present invention, when there is an overlap among the return destination addresses of the unit loops constituting the multi-nested structure, the overlapping address is made different from each other. It is possible to correctly calculate the depth. As a result, it is possible to correctly select and preferentially compile a deep part of a loop that is likely to be a part with a large number of executions.

  As described above, according to the compiler, the recording medium, the compiling device, the communication terminal device, and the compiling method of the present invention, the portion of the original program that is frequently executed or the portion that is likely to be frequently executed is selected with high accuracy. Can be compiled. As a result, it is possible to optimize the improvement in the execution speed of the program and the reduction in the storage capacity of the memory for storing the program with good accuracy.

  Embodiments of the present invention will be described in detail with reference to the drawings.

(Embodiment 1)
FIG. 1 shows a schematic configuration of a main part of a compiler development environment according to an embodiment of the present invention. The development environment 105 also corresponds to a development environment that implements a recording medium, a compiling device, and a compiling method according to an embodiment of the present invention. The development environment 105 includes a Java (R) program language development environment 125, which is an environment for developing a program in, for example, the Java (R) program language.

  In FIG. 1, the Java (R) programming language development environment 125 is illustrated, but the programming language used is not necessarily limited to the Java (R) programming language, and may be called some so-called high-level programming language. Any language can be used. For example, in C language, C ++ language, Java (R) language, FORTRAN, COBOL, and other classic compiler languages, or APL, PL / 1, ADA, Smalltalk and Lisp, so-called assembler languages, and any other programming language, There is no problem even if the source program is described. The development environment 105 may include a development environment using a plurality of languages, or may include only a single language development environment.

  Java (R) program code 121 is developed by the Java (R) program language development environment 125. The Java (R) program code 121 corresponds to an embodiment of the source program according to the present invention. An example of Java (R) program code is shown in FIG. In the example of FIG. 2, Java® program code 121 includes two “do-while” loops that form a double nesting. That is, the Java (R) program code 121 has a double nesting structure.

  In this specification, the “multiple nested structure” is simply referred to as “multiple loop” as appropriate. A single loop, that is, a single loop, and a multiple nested structure, that is, a multiple loop, are appropriately referred to as “loop structure” or “loop”. Furthermore, the individual loops constituting the multiple loop are appropriately referred to as “unit loops” in order to particularly distinguish them. A single loop is also referred to as a “single nested structure”.

  Such a loop structure is subjected to analysis by the compile part determination unit 127. The development environment 105 has a computer (not shown), and the computer implements the function of the compile part determination unit 127 by executing a compiler according to an embodiment of the present invention. The simulator 137 of the compile part determination unit 127 simulates the execution of the Java (R) program code 121 illustrated in FIG. 2, and includes a loop analysis unit 131 and a header division unit 133.

  The loop analysis unit 131 analyzes the loop to detect a duplicate return destination address among the return destination addresses of the multiple loop. For this purpose, the loop analysis unit 131 includes a multiple nesting structure detection unit 135, a return address detection unit 136, and an address duplication determination unit 137. The header dividing unit 133 divides the detected duplicate return address, converts the Java (R) program code 121 into the Java (R) byte code 129 into which the duplicate return address is divided, and outputs it. . For this purpose, the header division unit 133 includes an instruction addition unit 138. Java (R) byte code 129 corresponds to an embodiment of the object program of the present invention.

  FIG. 3 is an explanatory diagram illustrating a Java (R) byte code 129 when the compile part determination unit 127 outputs a duplicate return destination address without being divided as a comparative example. The Java® byte code 129 illustrated in FIG. 3 includes program modules 403, 405, 407, and 409. FIG. 3A is a block flowchart illustrating the processing flow of each module, and FIG. 3B illustrates a program described in each module. In this Java (R) byte code 129, the return destinations of the two loops are both the “15 iinc 2 1” instruction at the head of the program module 405. That is, the return address of the double loop is duplicated.

  In this way, when two return destination addresses of the double loop are the same, when the multiple loop included in the Java (R) byte code 129 is partially compiled, this loop includes one return including a return from the middle. Whether it is a loop or a double loop cannot be determined. That is, it is one loop that repeats the program module 405 and the program module 407 in succession, and whether or not a single loop may be ended only by executing the program module 405 according to a certain condition, or the program module 405 It is impossible to determine whether the loop is a double loop including an inner loop that repeats only the loop and a loop that repeats the program module 407 in addition to the inner loop.

  Therefore, the loop analysis unit 131 detects a duplicate return address in such a multiple loop, and the header division unit 133 divides the detected duplicate return address. That is, as illustrated as the program module 504 in FIG. 4, the header dividing unit 133 inserts “15 nop” and divides the return address of the inner loop and the return address of the outer loop. In FIG. 4, program modules 503, 505, 507 and 509 are different in address from the program modules 403, 405, 407 and 409 shown in FIG. The content is the same.

  In this way, when two return destinations of the double loop are the same, for example, an instruction that is meaningless in processing (referred to as an “unnecessary instruction” in this specification) such as “nop (No Operation)” is inserted. Then, by dividing the return address, it is possible to clarify that this loop is a double loop as shown in the block flowchart of FIG. The Java (R) byte code 129 that has been divided into the double loop return addresses in this way by the header division unit 133 is transferred from the development environment 105 to the server 103. The server 103 stores the transferred Java (R) byte code 129 in preparation for a transmission request from the client terminal device.

  However, the transfer and storage to the server 103 is an example and is not necessarily essential. In another example, the development environment 105 and the server 103 may be different recording units of the same device, or the same device. May be the same recording part, or may have another structure.

  Here, the procedure of the process performed by the compile part determination unit 127 will be described in more detail. FIG. 5 is a flowchart showing a procedure of processing executed by the compilation part determination unit 127. The compile part determination unit 127 converts the Java (R) program code 121 into the Java (R) byte code 129 while executing the processes of steps S1 to S5. When the compile part determining unit 127 starts processing, first, the multiple nested structure detection unit 135 searches for multiple nested structures in the Java (R) program code 121 (S1). When the multiple nested structure detection unit 135 detects the multiple nested structure (Yes in S2), the return destination address detection unit 136 detects the return destination address of each unit loop constituting the detected multiple nested structure (S3).

  If the return address is duplicated (Yes in S4), the instruction adding unit 138 of the header dividing unit 133 divides the duplicate return address by adding a nop instruction to any of the duplicated return addresses. (S5). In general, when the return address of each unit loop having an N-fold (N ≧ 2) nested structure is duplicated, a nop instruction is inserted into each of the N−1 unit loop return destinations. Thus, duplication can be eliminated. Thereafter, the process returns to step S1. On the other hand, if the return address does not overlap (No in S4), the process returns to step S1 as it is. The compile part determination unit 127 repeats the processes of steps S1 to S5 until the multi-nested structure detection unit 135 does not detect the multi-nested structure. When the multi-nested structure is not detected (No in S2), the process ends. To do.

(Embodiment 2)
FIG. 6 is a block diagram showing a schematic configuration diagram of a main part of a terminal device that executes a compiler according to an embodiment of the present invention. The terminal device 205 also corresponds to a compiling device and a communication terminal device according to an embodiment of the present invention. Further, the terminal device 205 corresponds to a recording medium and a device that performs a compiling method according to an embodiment of the present invention.

  The terminal device 205 has a computer (not shown). The computer executes the compiler according to the embodiment of the present invention, thereby realizing the function of the pre-linking unit 231 included in the terminal device 205. The compiler that realizes the function of the pre-link unit 231 may be supplied through a recording medium 31 such as a ROM (Read Only Memory), a flexible disk, or a CD-ROM, or may be supplied through a transmission medium 33 such as a telephone line or a network. Is possible. In FIG. 6, a CD-ROM is depicted as the recording medium 31. The compiler recorded on the CD-ROM can be read by connecting the CD-ROM reader 32 to the input / output interface 211, and further, a storage such as a hard disk or RAM (Random Access Memory) provided in a computer (not shown). It can be stored on a medium.

  When the compiler is supplied as the recording medium 31 in the form of a ROM, the computer can execute the processing of the pre-linking unit 231 according to the compiler by mounting the ROM on the computer. The compiler supplied through the transmission medium 33 is received through the communication interface 210 and stored in a storage medium (not shown) such as a hard disk or a RAM. The transmission medium 33 is not limited to a wired transmission medium and may be a wireless transmission medium. Although not described in the first embodiment, a compiler that realizes the function of the compile part determination unit 127 (FIG. 1) can be supplied to a computer (not shown) included in the development environment 201 in the same manner.

  The terminal device 205 reads the Java® byte code 129 obtained by dividing the return address of the multiple loop from the server 103 into the first file system 243 through the network 32 and the communication interface 210. The Java (R) byte code 221 read into the first file system 243 is read into the pre-link unit 231 of the terminal device 205, and the compile part determination unit 223 included in the compile unit 233 determines the part to be compiled. .

  The compile part determination unit 223 considers the call relationship between a plurality of programs, and considers the depth of the call instruction loop in the call source program and the loop depth of the call destination program in combination with the loop having the largest depth. Is determined to be a loop (instruction) that is most likely to be executed the most times. Furthermore, the compilation part determination unit 223 determines a loop (instruction) having the largest depth as a part to be preferentially subjected to partial compilation.

  Here, “loop depth” or “loop depth” refers to the multiplicity of a loop multiple nested structure or a single nested structure. For example, the loop depth of the single nested structure is 1, and the loop depth of the double nested structure is 2. In general, instead of detecting a loop, a processing part or an instruction (hereinafter referred to as “repetitive execution part”) that is executed repeatedly may be detected. In this sense, “(command)” is added after the loop. The number of executions of the repeated execution part corresponds to the depth of the loop.

  For example, as shown in FIG. 7, it is assumed that calls are sequentially made by three programs, that is, a program 610, a program 630, and a program 670. The program 610 includes program modules 603 to 607, the program 630 includes program modules 624 to 626, and the program 670 includes program modules 643 to 649. Further, it is assumed that the program 630 is called from the program module 605 of the program 610 and the program 670 is called from the program module 625 of the program 630.

  Program module 605 is in a loop of depth 2 in program 610, program module 625 is in a loop of depth 1 in program 630, and program module 646 is 3 in depth in program 670. In the loop. Accordingly, when the program module 646 considers the depth of the loop by the program 670 alone, the depth is “3”. However, the program module 646 determines the depth of the loop as a total in consideration of the calling relationship between all programs. The depth is “2 + 1 + 3 = 6”.

  This is an example, but all other programs and program modules are executed more times in this way by determining the depth of the loop as a total in consideration of the calling relationship throughout all programs. By more accurately detecting a loop (instruction) that is likely to be executed and partially compiling that portion, the execution speed can be maximized more accurately.

  In the Java (R) byte code 221, the return address of the multiple loop is divided by the header division unit 133 of the compilation part determination unit 127 of the development environment 105. Therefore, even in the double loop as illustrated in FIGS. 3 and 4, it is possible to accurately detect the double loop and accurately determine the loop (instruction) that is executed the most times. As a result, a portion to be preferentially compiled can be determined with high accuracy. Therefore, as long as the runtime memory capacity, that is, the memory capacity of the second file system 245 provided in the terminal device 205 in the example of FIG. It can be determined as the part to be compiled.

  The partial native compiling unit 225 included in the compiling unit 233 compiles the part to be compiled determined by the compiling part determining unit 223. The compile part determination unit 223 determines the compile part, preferentially compiles as many instructions as the execution memory capacity allows, giving priority to the deep part of the loop considered as a total and considering the execution memory capacity together. To be done. This is because the execution speed can be increased as much as possible as long as the runtime memory capacity permits.

  Because all the instructions cannot be precompiled due to the limitation of the memory capacity at the time of execution, the precompiled program remains the part of the native code 229 and the Java (R) byte code 227 that have been precompiled. Will coexist. The runtime program in which the part of the native code 229 that has been pre-compiled and the part that remains in the Java (R) byte code 227 coexists is stored and saved in the second file system 245. The first file system 243 and the second file system 245 may be the same or different.

  The runtime program stored and saved in the second file system 245 is executed by the execution control unit 257. Since this runtime program is precompiled preferentially at the deep part of the loop as much as the runtime memory capacity permits, the maximum execution speed can be improved.

  As described above, the compile part determination unit 223 divides the return address of the double loop by the header division unit 133 of the compile part determination unit 127 even if there is a double loop as illustrated in FIGS. 3 and 4. Therefore, it is possible to accurately detect a double loop, accurately determine a loop (instruction) that is executed the most times, and determine a portion to be preferentially compiled. However, as described above, the return address is divided by inserting an unnecessary instruction such as a nop instruction that has no meaning in processing. Since this instruction certainly has no processing meaning, it does not adversely affect the processing contents, but occupies an unnecessary area on the memory. Further, when the execution control unit 257 executes the program, this instruction is decoded, and for example, it is necessary to lose unnecessary time until it is determined that the instruction is a nop instruction. Therefore, the partial native compiling unit 225 deletes such an added instruction which becomes unnecessary if it is determined whether or not it is a double loop, and executes pre-compilation.

  Next, the configuration and operation procedure of the compiling unit 233 will be described in more detail. FIG. 8 is a block diagram illustrating a configuration of the compile part determination unit 223 and the partial native compile unit 225 included in the compile unit 233. The compile part determination unit 223 includes a loop detection unit 261, a call detection unit 262, a loop depth evaluation unit 263, a uniformity evaluation unit 264, a compile part determination unit 265, and a reentry structure determination unit 267. The partial native compilation unit 225 includes a multiple nested structure detection unit 271, a return address detection unit 272, an unnecessary instruction detection unit 273, and an unnecessary instruction deletion unit 274.

  FIG. 9 is a flowchart illustrating a procedure of processes executed by the compiled part determining unit 223 and the partial native compiling unit 225. For convenience of explanation, it is assumed that the compiled part determining unit 223 and the partial native compiling unit 225 are intended to process the Java (R) byte code 221 having the three programs 610, 630, and 670 of FIG. When the compile part determining unit 223 starts processing, the loop detecting unit 261 first has a multiple nested structure or a single nested structure for the main program included in the Java (R) byte code 129, that is, the program 610 in FIG. A loop is searched (S11).

  When the loop detection unit 261 detects a loop included in the program 610 (Yes in S12), the call detection unit 262 detects another program that is called from the detected loop (S14). When the called program, that is, the program 630 is detected (Yes in S14), the loop detection unit 261 searches the program 630 for a loop having a multiple nested structure or a single nested structure (S15).

  When the loop detection unit 261 detects a loop included in the program 630 (Yes in S16), the call detection unit 262 detects another program that is called from the detected loop (S14). When the called program, that is, the program 670 is detected (Yes in S14), the loop detection unit 261 searches the program 670 for a loop having a multiple nested structure or a single nested structure (S15).

  When the loop detection unit 261 detects a loop included in the program 670 (Yes in S16), the call detection unit 262 detects another program that is called from the detected loop (S14). Since the called program is not detected (No in S14), the loop depth evaluation unit 263 calculates the total number of loop nestings detected by the loop detection unit 261 so far, that is, 2 + 1 + 3 = 6 as the loop depth. . That is, the loop depth evaluation unit 263 calculates the multiplicity of the entire loop having a multiple nested structure over the programs 610, 630, and 670 having a calling relationship as the loop depth (S17).

  The loop detection unit 261 searches for a loop for the program 610 (S11). If the loop detection unit 261 does not detect a new loop (No in S12), preferably the uniformity evaluation unit 264 evaluates the uniformity between the loop depths (S19). When the loop depth evaluation unit 263 calculates a plurality of loop depths, the uniformity evaluation unit 264 determines whether or not the plurality of loop depths are uniform according to a predetermined standard. . For example, the uniformity evaluation unit 264 determines that the plurality of loop depths are the same if they are all the same, and determines that they are not uniform if there are some that are not the same. Alternatively, the uniformity evaluation unit 264 determines that the loop is uniform if all of the plurality of loop depths are within the determined reference width, and determines that it is not uniform if there is anything that protrudes from the reference width. . The uniformity evaluation unit 264 determines that the loop depth is not uniform when the loop depth evaluation unit 263 calculates only a single loop depth.

  If the uniformity evaluation unit 264 determines that the loop depth is not uniform (No in S19), the compilation portion determination unit 265 includes a loop having a large loop depth in a portion to be preferentially compiled (S20). For example, the compile part determination unit 265 compiles as many loops as possible from the one with the largest loop depth within the range allowed by the memory capacity allocated in the second file system 245. Include in As another example, the compile part determination unit 265 includes, in the part to be compiled, only a loop with the maximum loop depth or a loop within a predetermined number in order from the largest loop depth. Alternatively, the compile part determination unit 265 includes a loop whose loop depth exceeds a predetermined threshold in the part to be compiled.

  When the process (S20) of the compile part determination unit 265 ends, or when the uniformity evaluation unit 264 determines that the depth of the loop is uniform (Yes in S19), the partial native compile unit 225 includes the compile part determination unit 265. By compiling only the part that is determined to be compiled, Java (R) byte code 227 including native code 229 is generated (S21).

  In this way, a loop with a large total number of nesting is prioritized, including a multiple nesting structure comprised of a plurality of programs 610, 630 and 670 that are included in the Java (R) byte code 221 and have a calling relationship with each other. Compiled. Accordingly, a portion of the Java (R) byte code 221 that has a high possibility of execution is selected and compiled with higher accuracy. As a result, it is possible to optimize the improvement in the execution speed of the program and the reduction in the memory area of the second file system 245 with good accuracy.

  In step S20, the compile part determination unit 265 may determine that there is no part to be compiled when the maximum value of the loop depth is less than a predetermined threshold value. As a result, it is possible to avoid unnecessary use of the memory area of the second file system 245 by compiling wastelessly contributing to the improvement in execution speed.

  Furthermore, when the loop depth evaluation unit 263 determines that the loop depth is uniform (Yes in S19), the compilation part determination unit 265 may determine that there is no part to be compiled. As a result, it is possible to avoid compiling a lot of portions that contribute to the improvement of the execution speed and impairing the effective use of the memory area of the second file system 245.

  When the compile part determination unit 265 determines that there is no part to be compiled, the partial native compile unit 225 performs processing without compiling the Java (R) byte code 221 as the source program to be processed. This is output as it is as a Java (R) byte code 227 which is a later target program. In this case, the Java (R) byte code 227 is desirably subjected to execution by the execution control unit 257, and a portion with high execution frequency is extracted, and the extracted portion is partially compiled. That is, it is desirable that the Java (R) byte code 227 that is not partially compiled before execution is subjected to so-called JIT (Just In Time) processing. Further, the Java (R) byte code 227 partially compiled before execution may be subjected to JIT processing by the execution control unit 257, and thereby a more desirable part may be compiled. A configuration example of the execution control unit 257 for executing JIT will be described later.

  In FIG. 9, the loop detection unit 261 may detect an iterative execution part that is an iteratively executed part instead of detecting a loop. The repeated execution part includes a loop. In this case, the loop depth evaluation unit 263 may calculate the sum of the number of executions of the iterative execution unit instead of the loop depth, that is, the sum of the multiplicity of the loop. As a result, the portion of the Java (R) byte code 221 that has a large number of executions is selected and compiled with higher accuracy. As a result, it is possible to optimize the improvement of the program execution speed and the memory area of the second file system 245 with good accuracy.

  FIG. 10 is a flowchart illustrating a procedure of a desirable process executed by the partial native compiling unit 225 before step S21 or in parallel with the process of step S21. The partial native compiling unit 225 converts the Java (R) byte code 221 into a Java (R) byte code 227 that normally includes the native code 229 while executing the processing of steps S51 to S55, for example. When the partial native compiling unit 225 starts processing, the multiple nested structure detecting unit 271 first searches the Java (R) byte code 221 for multiple nested structures (S51). When the multiple nested structure detection unit 271 detects the multiple nested structure (Yes in S52), the return destination address detection unit 272 detects the return destination address of each unit loop constituting the detected multiple nested structure (S53).

  Next, the unnecessary instruction detection unit 273 determines whether there is any detected return destination address that includes an unnecessary instruction (S54). If the unnecessary instruction detection unit 273 detects a return address having an unnecessary instruction (Yes in S54), the unnecessary instruction deletion unit 274 deletes the unnecessary instruction from the detected return address (S55). Thereafter, the process returns to step S51. On the other hand, if a return address having an unnecessary instruction is not detected (No in S54), the process directly returns to step S51. The partial native compiling unit 225 repeats the processing of steps S51 to S55 until the multiple nested structure detecting unit 271 does not detect the multiple nested structure. When the multiple nested structure is not detected (No in S52), an unnecessary instruction is issued. The process of FIG. 10 for deleting is terminated.

  As described above, the partial native compiling unit 225 preferentially compiles the part to be compiled determined by the compiling part determining unit 265 (S21). For example, when the memory area allocated to the second file system 245 overflows, the partial native compiling unit 225 ends the compiling process of step S21.

  FIG. 11 is a block diagram illustrating a configuration example of the execution control unit 257. In the example of FIG. 11, the execution control unit 257 includes a first execution control unit 257A and a second execution control unit 257B. When the Java (R) byte code 227 read from the second file system 245 includes the native code 229, the Java (R) byte code 227 is executed by the first execution control unit 257A. On the other hand, when the Java (R) byte code 227 does not include the native code 229, the Java (R) byte code 227 is executed by the second execution control unit 257B. The second execution control unit 257B executes what is called JIT.

  The Java (R) byte code 227 including the native code 229 input to the first execution control unit 257A is subjected to link processing by the linker unit 281, and then the portion of the native code 229 is held in the cache 282, and Java ( R) The part of the byte code 227 is held in the cache 283. In accordance with the flow of execution processing, the native code 229 and the Java (R) byte code 227 are selected by the switching unit 284, and the selected part is executed by the execution unit 285. Even when all of the Java (R) byte code 227 is replaced with the native code 229, that is, when all the parts of the Java (R) byte code 221 are compiled by the compiling unit 233, the program is 1 executed by the execution control unit 257A.

  The second execution control unit 257B includes an execution partial frequency detection unit 286 and a partial native compilation unit 287 in addition to the configuration of the first execution control unit 257A. The execution part frequency detection unit 286, while the execution unit 285 is executing the Java (R) byte code 227 that does not include the native code 229 at the beginning, frequently exceeds a predetermined standard of this program. Detect high-frequency execution parts that are executed. The partial native compiling unit 287 compiles the high-frequency execution part detected by the execution part frequency detection unit 286. As a result, the Java (R) byte code 227 that includes the native code 229 is executed by the execution unit 285 via the caches 282 and 283 and the switching unit 284 in the same manner as the first execution control unit 257A. .

  The Java (R) byte code 227 that has been executed by the execution control unit 257B and already includes the native code 229 can be stored in the second file system 245 in preparation for the next execution. Since the saved Java (R) byte code 227 has already been partially compiled, it can be executed by the first execution control unit 257A.

  According to the execution control unit 257 configured as shown in FIG. 11, the Java (R) byte code 227 determined to have no part to be compiled by the compilation part determination unit 265 of the compilation unit 233 is provided for so-called JIT. It will be. Therefore, instead of pre-compilation, Java (R) byte code 227 determined by the compile unit 233 that pre-compilation is not appropriate is optimized by JIT for optimization of execution speed and memory area saving. Can be achieved.

  FIG. 11 illustrates a form in which the first execution control unit 257A and the second execution control unit 257B coexist. On the other hand, the execution control unit 257 includes only the execution control unit 257B, and the execution partial frequency detection unit 286 and the partial native depending on whether the input Java (R) byte code 227 includes the native code 229 or not. The execution control unit 257 may be configured to control the compiling unit 287 on / off.

  Returning to FIG. 8, the compile part determination unit 223 also realizes the processing described below by operating the reentry structure determination unit 267. It is assumed that the source program to be processed by the compile part determining unit 223, that is, the Java (R) byte code 221 has a loop structure shown in FIG. 12, for example. The Java® byte code 221 illustrated in FIG. 12 includes a program 710 and a program 730. The program 710 includes program modules 703 to 707, and the program 730 includes program modules 724 to 726.

  The program module 705 constituting a double loop in the call source program 710 calls the program module 724 included in the program 730. On the other hand, in the program 730, the program module 725 executed following the program module 724 has a single loop structure. Further, the program module 725 is included in the caller program 710 and calls the program module 704 that leads to the execution of the program module 705 that called itself.

  In general, such structures are sometimes referred to as “re-entrant” or “Re-entrant” structures. That is, the program modules 704, 705, 706, 724, 725 and 726 constitute a reentry structure. When the reentry structure determination unit 267 of the compile part determination unit 223 finds such a reentry structure in the program to be compiled, the compile part determination unit 233 determines that part as the compile part with the highest priority. Therefore, the reentry structure is preferentially compiled by the partial native compiling unit 225. Since the reentry structure, which is a portion of the Java (R) bytecode 221 that is likely to be executed frequently, is preferentially compiled, the execution speed is improved and the memory area of the second file system 245 is saved. Optimized with good accuracy.

  Next, the operation procedure related to the determination of the reentry structure of the compiled part determination unit 223 will be described in more detail. FIG. 13 is a flowchart showing an operation procedure of the compile part determination unit 233 regarding determination of the reentry structure. The processing procedure of FIG. 13 can be executed in parallel with the processing procedure of FIG. For convenience of explanation, it is assumed that the compile part determination unit 223 targets the Java (R) byte code 221 illustrated in FIG.

  When the compile part determination unit 223 starts the process of FIG. 13, the call detection unit 262 searches for a process part that calls another program for the program 710 that is the main program (S31). When the call detection unit 262 detects such a processing part, that is, the program module 705 (Yes in S32), the call detection unit 262 includes the program 730 that is the call destination in the program 710 that is the call source program. A processing portion (ie, program module 725) that calls a processing portion (ie, program modules 704, 705, and 706) including the calling portion (ie, program module 705) is searched (S33).

  When the call detection unit 262 detects such a processing portion, that is, the program module 725 (Yes in S34), the reentry structure determination unit 267 performs the call destination processing (ie, the program modules 724, 725, and 726), It is determined that the process of the read source (that is, the program modules 704, 705, and 706) that has been called from the read destination is the reentry structure (S35). Thereafter, the call detection unit 262 executes the process of step S33 again. When the call detection unit 262 does not detect a new processing part (No in S34), the call detection unit 262 executes the process of step S31 again. When the call detection unit 262 does not detect a new processing part (No in S32), the compilation part determination unit 265 should compile the processing part that the reentry structure determination unit 267 determines to have a reentry structure. It is included in the part (S36).

  Thereafter, the compile part determination unit 223 ends the process of FIG. The partial native compiling unit 225 includes a loop determined by the compiling part determination unit 265 as a part to be compiled by the process of FIG. 9 and a reentry structure determined by the compiling part determination unit 265 as a part to be compiled by the process of FIG. Will be compiled preferentially.

(Other embodiments)
In the first embodiment, the example in which the conversion from the Java (R) program code 121 to the Java (R) byte code 129 is performed in the development environment 105 is shown. In response to this, the terminal device 205 downloads the Java (R) program code 121 from the server 103 through the communication interface 210, for example, and executes conversion into the Java (R) byte code 129 in the pre-link unit 231. May be.

  The compiler, recording medium, compiling device, communication terminal device, and compiling method of the present invention can optimize the improvement of the execution speed of the program and the reduction of the storage capacity of the memory for storing the program with good accuracy. Therefore, it is industrially useful.

1 is a schematic configuration diagram of a development environment for executing a compiler according to a first embodiment of the present invention. The figure which shows the example of the Java (R) program code developed by the development environment of FIG. The figure which illustrates the Java (R) bytecode in which the return destination of two loops overlaps. The figure which illustrates the Java (R) bytecode in which the return destination of two loops was divided. The flowchart which shows the process sequence for dividing | segmenting the return destination of the overlapping loop. The block diagram which shows the structure of the terminal device by Embodiment 2 of this invention. The figure which illustrates the Java (R) bytecode which calls in sequence between three programs. The block diagram which shows the structure of the compilation part of FIG. The flowchart which shows the process sequence by the compilation part of FIG. The flowchart which shows the process sequence by the partial native compilation part of FIG. The block diagram which shows the structure of the execution control part of FIG. The figure which illustrates the program which has a reentry structure. FIG. 9 is a flowchart showing a processing procedure for preferentially compiling a reentry structure by a compile part determining unit in FIG. 8.

Explanation of symbols

103 Server 105 Development environment
121 Java (R) program code 125 Java (R) program language development environment 127 Compiled part determination unit 129 Java (R) byte code 131 Loop analysis unit 133 Header division unit 135 Multiple nested structure detection unit 136 Return destination address detection unit 137 Address Duplicate determination unit 138 Instruction addition unit 137 Simulator 205 Terminal device (communication terminal device) 210 Communication interface (communication means)
221 Java (R) byte code 223 Compiled part determining part 225 Partial native compiling part (partial compiling means)
227 Java (R) byte code 229 Native code 231 Pre-link unit 233 Compile unit (compile device)
243 First file system 245 Second file system 257 Execution control unit 261 Loop detection unit 262 Call detection unit 263 Loop depth evaluation unit 264 Uniformity evaluation unit 265 Compiled part determination unit 267 Reentry structure determination unit 271 Multiple nested structure Detection unit 272 Return address detection unit 273 Unnecessary instruction detection unit 274 Unnecessary instruction deletion unit 286 Execution partial frequency detection unit 287 Partial native compilation unit (partial compilation means)
403, 405, 407, 409 Program module 503, 504, 505, 507, 509 Program module 603, 604, 605, 606, 607 Program module 610, 630, 670 Program 624, 625, 626 Program module 643, 644, 645 646, 647, 648, 649 program modules

Claims (20)

A compiler that converts a source program into a target program,
A multiple nested structure detection procedure for detecting multiple nested structures included in the source program;
A return address detection procedure for detecting a return address of each unit loop constituting the multiple nested structure;
An address duplication determination procedure for determining whether there is a duplicate return destination address having a common address among the plurality of return destination addresses detected by the return destination address detection procedure;
When the address duplication determination procedure determines that there is the duplicate return destination address, a dividing procedure for converting the source program into a target program having the duplicate return destination address different from each other as the target program A compiler to make it run.   2. The division procedure includes an instruction addition procedure in which an unnecessary instruction that is an instruction that does not affect execution is added to any one of the duplicate return destination addresses to make the duplicate return destination addresses different from each other. The listed compiler. A compiler for converting first and second source programs into a target program,
A first loop detection procedure for detecting a first loop included in the first source program and having a multiple or single nested structure;
A second loop detection procedure for detecting a second loop included in the second source program called from the first loop and having a multiple or single nested structure;
A loop depth evaluation procedure for calculating a total nesting number by adding the nesting number of the first loop and the nesting number of the second loop;
A compiler for causing a computer to execute a partial compilation procedure for converting the first and second source programs into the target program by preferentially compiling the second loop having a large total number of nestings. A compiler for converting a plurality of source programs into a target program,
A first loop detection procedure for searching for a first loop included in one of the plurality of source programs and having a multiple or single nested structure;
When the first loop detection procedure detects the first loop, it is included in another source program that is called from the first loop among the plurality of source programs and has a multiple or single nested structure A second loop detection procedure for searching the second loop;
A first iterative procedure for performing the second loop detection procedure again, assuming that the first loop detection means detects the first loop when the second loop detection procedure detects the second loop;
A loop depth evaluation procedure for calculating a loop depth, which is the total number of loop nestings detected so far, when either the first loop or the second loop is not detected;
A second iteration procedure for iterating from the first loop detection procedure to the loop depth evaluation procedure until the first loop is no longer detected;
A compiler for causing a computer to execute a partial compilation procedure for converting the plurality of source programs into the target program by preferentially compiling a loop having a large loop depth among the plurality of source programs.   5. The partial compile procedure does not compile any portion of the plurality of source programs when the maximum value of the loop depth calculated by the loop depth evaluation procedure is less than a predetermined threshold. compiler. When the loop depth evaluation procedure calculates a plurality of loop depths, the computer further executes a uniformity evaluation procedure for determining whether or not the plurality of loop depths are uniform,
6. The partial compilation procedure according to claim 4 or 5, wherein when the uniformity evaluation procedure determines that the plurality of loop depths are uniform, no portion of the plurality of source programs is compiled. compiler. A compiler for converting first and second source programs into a target program,
A first iterative execution unit detection procedure for detecting a first iterative execution unit that is included in the first source program and is executed repeatedly;
A second iterative execution unit detecting procedure for detecting a second iterative execution unit that is included in the second original program called from the first iterative execution unit and is repeatedly executed;
A total execution number evaluation procedure for calculating the total number of executions by adding the number of executions of the first iteration execution unit and the number of executions of the second iteration execution unit;
A compiler for causing a computer to execute a partial compilation procedure for converting the first and second source programs into the target program by preferentially compiling the second repetitive execution unit having a large total number of executions. A compiler for converting a plurality of source programs into a target program,
A first iterative execution unit detection procedure for searching for a first iterative execution unit that is included in one of the plurality of source programs and is executed repeatedly;
When the first iterative execution unit detection procedure detects the first iterative execution unit, it is included in another source program called from the first iterative execution unit among the plurality of source programs, and is repeatedly executed. A second iterative execution unit detection procedure for searching for a second iterative execution unit to be executed;
When the second iterative execution unit detection procedure detects the second iterative execution unit, it is assumed that the first iterative execution unit detection means has detected the first iterative execution unit, and the second iterative execution unit detection procedure is detected. A first iterative procedure for performing again;
Total number of executions evaluation that calculates the total number of executions, which is the sum of the number of executions of the repeated execution units detected so far, when either the first iteration execution unit or the second iteration execution unit is not detected Procedure and
A second iterative procedure that iterates from the first iterative execution unit detection procedure to the total execution number evaluation procedure until the first iterative execution unit is not detected;
A compiler for causing a computer to execute a partial compilation procedure for converting the plurality of source programs into the target program by preferentially compiling an iterative execution unit having a large total number of executions among the plurality of source programs.   9. The partial compilation procedure does not compile any part of the plurality of source programs when the maximum value of the total execution number calculated by the total execution number evaluation procedure is less than a predetermined threshold value. The listed compiler. When the total execution count evaluation procedure calculates a plurality of total execution counts, the computer further executes a uniformity evaluation procedure for determining whether the plurality of total execution counts are uniform,
10. The partial compilation procedure according to claim 8 or 9, wherein the uniformity evaluation procedure does not compile any portion of the plurality of source programs when the plurality of total execution times are determined to be uniform. compiler. A compiler for converting first and second source programs into a target program,
A loop having a multiple or single nested structure included in the first source program, or a loop having a multiple or single nested structure included in the second source program called from the first processing part that is a non-loop. Or a first call detection procedure for searching for a second processing part that is non-loop;
A processing portion including the first processing portion of the first source program called in the second processing portion when the first calling detection procedure detects the second processing portion; A second call detection procedure for searching for a third processing part;
When the second call detection procedure detects the third processing portion, the first processing portion is compiled by compiling the second processing portion and the third processing portion of the first and second source programs. And a compiler for causing a computer to execute a partial compilation procedure for converting the second source program into the target program. A compiler that converts a source program into a target program,
A multiple nested structure detection procedure for detecting multiple nested structures included in the source program;
A return address detection procedure for detecting a return address of each unit loop constituting the multiple nested structure;
An unnecessary instruction detection procedure for determining whether or not there is an unnecessary instruction that is an instruction that does not affect execution among a plurality of return destination addresses detected by the return address detection procedure;
When the unnecessary instruction detection procedure detects a return address having the unnecessary instruction, the target program executes an unnecessary instruction deletion procedure for converting the source program to the target program from which the unnecessary instruction has been deleted. Compiler to let you do. A computer-readable recording medium,
A recording medium on which the compiler according to any one of claims 1 to 12 is recorded. A compiling device for converting a source program into a target program,
Multiple nested structure detecting means for detecting multiple nested structures included in the source program;
Return address detecting means for detecting a return address of each unit loop constituting the multiple nested structure;
Address duplication determination means for determining whether there is a duplicate return destination address having a common address among the plurality of return destination addresses detected by the return destination address detection means;
When the address duplication determination procedure determines that there is the duplicate return destination address, the target program includes a dividing unit that converts the source program into a target program having the duplicate return destination addresses different from each other. Compile device. A compiling device for converting a plurality of source programs into a target program,
Included in one source program in the plurality of source program searches the first loop having multiple or singlet nested structure, each for detecting said first loop, the plurality of source program, the The second loop included in another primitive program called from the first loop and having a multiple or single nested structure is searched, and when the second loop is detected, the first loop is detected. as things loop further by searching the second loop to search for multiple nested comprised between each source program that is the callee in order from the one of the source program and the one source program Detection means ;
Each time the loop detection means detects the first loop, the number of nestings of the first loop, or each second loop from the first loop when the loop detection means detects the second loop. Loop depth evaluation means for calculating the loop depth, which is the total number of nestings obtained by adding in order,
A compiling device comprising: a partial compiling unit that preferentially compiles a loop having a large loop depth among the plurality of source programs to convert the plurality of source programs into the target program.   The partial compiling means does not compile any part of the plurality of source programs when the maximum value of the loop depth calculated by the loop depth evaluation means is less than a predetermined threshold. The compiling device described. When the loop depth evaluation means calculates a plurality of loop depths, it further comprises a uniformity evaluation means for determining whether or not the plurality of loop depths are uniform,
The compiling device according to claim 15 or 16, wherein the partial compiling means does not compile any part of the plurality of source programs when the uniformity evaluation means determines that they are uniform. A compiling device according to any one of claims 14 to 17,
A communication means for acquiring a source program to be compiled by the compiling device through a transmission medium;
A communication terminal device comprising execution control means for executing a target program generated by the compiling device. The execution control unit is also a non-compiled program that is a source program that has been compiled by the compiling device and has not been compiled in any part thereof,
The execution control unit
A frequency detection means for detecting a high-frequency execution part that is a part executed at a frequency exceeding a predetermined reference value in the target program during the execution of the non-compiled program;
The communication terminal device according to claim 18, further comprising: another partial compiling unit that compiles the high-frequency execution part detected by the frequency detection unit. A compiling method in which a computer converts a source program into a target program,
A multiple nested structure detection procedure for detecting multiple nested structures included in the source program;
A return address detection procedure for detecting a return address of each unit loop constituting the multiple nested structure;
An address duplication determination procedure for determining whether there is a duplicate return destination address having a common address among the plurality of return destination addresses detected by the return destination address detection procedure;
When the address duplication determination procedure determines that there is the duplicate return destination address, the target program includes a division procedure for converting the source program into a target program having the duplicate return destination address different from each other. Compilation method.

Images