JP4131909B2 - Compile method - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a compiling method, a compiler, a recording medium storing the compiler, a storage device storing an object code created by the compiling method, and a processor including the storage device, and in particular, the amount of heat generated by the processor does not exceed a specified value. Thus, the compiler function for converting a user program into object code is targeted.
[0002]
[Prior art]
2. Description of the Related Art Semiconductor devices such as microprocessors tend to increase the amount of heat generated from elements as the frequency increases in recent years. When the temperature of the element rises, the semiconductor device may cause a temporary malfunction or a semi-permanent failure. In order to avoid such problems, conventionally, the following measures have been generally taken.
[0003]
(1) A sufficient heat treatment or a heat dissipation device is applied to the semiconductor device so that the temperature of the element does not exceed a specified temperature even when the amount of heat generated from the element becomes maximum.
(2) Lower the operating frequency of the element under the constraint that the heat dissipation of the device is constant.
(3) The temperature rise of the element is monitored, and the operating frequency of the device is dynamically reduced when the temperature rises above a specified temperature.
[0004]
[Problems to be solved by the invention]
However, each of the measures described above has the following problems.
That is, the measure (1) generally involves an increase in cost, so it is difficult to adopt it for a device intended for general consumers, particularly a consumer game machine.
[0005]
As for the countermeasures of (2) and (3), although hardware for realizing this has conventionally existed, if the OS tries to manage the operating frequency according to the amount of heat dissipation, the degree of freedom decreases. There is a problem that creating a program for explicitly controlling the temperature imposes an excessive burden on the user.
[0006]
The present invention has been made in view of the above circumstances, and an object of the present invention is to convert a user program into an object code so that the amount of heat generated by an element or device is a specified value or less. How to compile Is to provide.
[0007]
[Means for Solving the Problems]
The present invention solves the above problems by statically controlling the heat generation of the processor and the system including the processor by software.
[0008]
That is, according to the first aspect of the present invention,
A compiling method using a computer into which a compiler program has been read, wherein the computer receives input from a user program and generates a provisional object code that can be interpreted by the target hardware; The amount of heat generated from the hardware when the object code is executed by the hardware is referred to a first table that describes the relationship between the amount of heat generated by the hardware and an instruction or instruction sequence in the user program. A procedure for calculating, and a procedure for determining whether or not the calculated calorific value is within the specification range by referring to a second table in which the computer describes the specification range regarding the heat of the hardware. The computer calculates the calorific value calculated above. If the computer determines that the calculated calorific value exceeds the specified range, the procedure for outputting the provisional object code as the final object code when it is determined to be within the specified range. The code part that causes the heat generation exceeding the above specification range is found as an optimization target part, and the temperature by the optimization target part using a plurality of instructions or instruction sequences for low power described in the third table. A procedure for executing an optimization process in consideration of an increase, and a procedure for the computer to output the provisional object code that has executed the optimization process as a final object code. The hardware has a plurality of pipelines set so that the heat generation amount when the use is stopped is smaller than the heat generation amount when the use is stopped, and the procedure for executing the optimization process is as follows. The computer includes a procedure of stopping issuing instructions to some of the plurality of pipelines; A compilation method is provided.
[0010]
According to the second aspect of the present invention,
A compiling method using a computer into which a compiler program has been read, wherein the computer receives input from a user program and generates a provisional object code that can be interpreted by target hardware; The amount of heat generated from the hardware when the object code is executed by the hardware is referred to a first table that describes the relationship between the amount of heat generated by the hardware and an instruction or instruction sequence in the user program. A procedure for calculating, and a procedure for determining whether or not the calculated calorific value is within the specification range by referring to a second table in which the computer describes the specification range regarding the heat of the hardware. The computer calculates the calorific value calculated above. If it is determined that it is within the range, the provisional object code is output as the final object code. If the computer determines that the calculated heat generation amount exceeds the specification range, the provisional object code A code part that causes heat generation exceeding the specification range is found as an optimization target part, and a temperature rise due to the optimization target part using a plurality of instructions or instruction sequences for low power described in the third table And a procedure for executing an optimization process considering the above and a procedure for the computer to output the provisional object code that has executed the optimization process as a final object code, and the hardware includes a multiprocessor system, The optimization target part has a processor with a short processing time and a processor with a long processing time. The procedure for executing the optimization process corresponds to the part that must be waited until the operation is completed, and the computer sacrifices the processing speed from the plurality of instructions or instruction sequences in the third table. Compiling method including a procedure of selecting an instruction or instruction sequence that generates a small amount of heat and replacing the instruction or instruction sequence of the portion that must be waited with the selected instruction or instruction sequence Is provided.
[0014]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, some embodiments of the present invention will be described with reference to the drawings.
First, an example of a heat generation mode of a semiconductor device to which a compiling method according to the present invention is applied will be described with reference to the drawings.
[0015]
FIG. 1 is a graph showing the amount of heat generated per unit cycle of one semiconductor chip used in a certain game machine. For this semiconductor chip, as shown in the figure, a total heat generation amount H1 and a limit peak heat generation amount H2 allowed in each time interval are set. In the case of this semiconductor chip, the total heat generation amount exceeds the allowable amount H1 in the time interval TI0, and the heat generation amount exceeds the limit peak heat generation amount H2 in a certain time zone within the time interval TI1. If such a state is left unattended, there is a possibility that a temporary malfunction may occur in the game machine, which in turn may cause a failure of the device, so it is necessary to suppress the heat generation of the chip. One feature of the present invention is that the margin of processing time is determined for each instruction or instruction sequence (hereinafter referred to as an instruction or the like) in the user program, and the processing has a time margin and it is desired to suppress the temperature. For example, a command for starting a function for suppressing heat generation is added, and for example, a subroutine with a small amount of heat generation is selected. As a result, the temperature of the device is controlled so as to obtain the best performance in the critical part of the process and at the same time meet the specification.
[0016]
(1) Compiler embodiment
First, an embodiment of a compiler according to the present invention will be described with reference to FIG.
FIG. 2 is a schematic diagram for explaining the schematic function of an embodiment of the compiler according to the present invention. The compiler 2 of the present embodiment is executed by a computer (not shown) provided with an auxiliary storage device. Libraries L2-L8 are connected to this computer. The library L2 stores various parameters necessary for compilation. These parameters include the limit temperature of the target system and the expected temperature during program execution. The library L4 stores a table of calorific value vs. instruction and the like obtained by calculating in advance the design of the calorific value generated in the processor in the chip when executing an instruction or the like by a CAD tool or simulation. The library L6 stores low-power subroutines, and the library L8 stores high-speed subroutines. Examples of the high-speed operation subroutine include a function that provides a high-quality image in image processing but increases the amount of heat generation. An example of the low power subroutine is a function that can suppress the amount of heat generated although the image quality is slightly inferior in image processing. If the processor itself has hardware functions, a special instruction that lowers the frequency and power supply voltage of the processor and a special instruction that reduces the number of processing pipes are prepared in advance in the low power subroutine. Also good. The handling of these subroutines will be described in detail later.
[0017]
The compiler 2 fetches various parameters from the library L2, creates a normal assembler sequence for the user program SC as source code, and outputs it as a provisional object code OC2. Next, the compiler 2 provisionally executes the provisional object code OC2, and creates a profile PF in which the heat generation amount is described corresponding to each instruction while referring to a table of the heat generation amount versus instruction in the library L4. Based on this profile PF, the compiler 2 generates a portion that generates heat exceeding the limit peak heat generation amount and a code portion that generates heat exceeding the total heat generation amount in each interval (hereinafter referred to as an optimization target portion) in the provisional object code OC2. ) To discover. If the user explicitly specifies in advance that the heat generation amount is more important than the processing speed in the program, the compiler 2 prompts the user to perform optimization processing on the optimization target portion. If there is no explicit designation by the user, the compiler 2 takes out various subroutines from the libraries L6 and L8, and executes a temperature optimization process in consideration of the heat generation amount for the optimization target portion using these subroutines. . The compiler 2 repeats the above processing until the temperature condition of the element or the like targeted by the temporary object code is satisfied, and outputs the temporary object code that satisfies the temperature condition as the final object code OC4.
More specific functions of the compiler 2 shown in FIG. 2 will be described below as some embodiments of the compiling method according to the present invention.
[0018]
(2) First embodiment of compiling method
First, a first embodiment of a compiling method according to the present invention will be described with reference to FIGS. FIG. 3 is a flowchart showing a schematic procedure of the compiling method of the present embodiment.
First, the compiler 2 takes in various parameters from the libraries L2 and L4 (step S1). Next, the compiler 2 creates a normal assembler string for the user program SC and outputs it as the provisional object code OC2 (step S2). Next, the compiler 2 creates and outputs the profile PF by provisionally executing the provisional object code OC2 while referring to the above-described table of the amount of generated heat versus the instruction (step S3). In this profile PF, predicted peak heat generation data and total heat generation data associated with each subroutine at the time of provisional execution are described. Subsequently, the compiler 2 determines whether or not the created assembler string satisfies the temperature condition based on the profile PF (step S4). When the temperature condition is satisfied, it is not necessary to perform the object code optimization process. Therefore, it is confirmed that the processing by the created assembler sequence is completed within a predetermined time (step S11). The object code OC4 is output and the compilation operation is terminated.
[0019]
When the created assembler string does not satisfy the temperature condition, the compiler 2 finds an optimization target portion in the provisional object code OC2 based on the profile PF (step S5). As described above, when the user explicitly specifies the optimization target portion in advance (step S6), the compiler 2 instructs the optimization target portion (step S7), and prompts the user to perform optimization processing (step S7). Step S8). A specific example of the optimization target portion designated by the user is shown in FIG. In the program shown in the figure, “begin low_power” and “end low_power” are compiler directives (indicators), and the program part “bar ();” surrounded by these gives priority to temperature over processing speed. To optimize. FIG. 5 shows an example of a method in which the compiler 2 finds a corresponding portion when the optimization target portion is not designated in advance by the user. FIG. 5A shows an example of the main function in the user program, and FIG. 4B shows the total in each interval associated with each function in the main function shown in FIG. Indicates the maximum calorific value. As shown in FIG. 5B, the maximum total calorific value of the bar function is 100, the maximum total calorific value of the barbar function is 10, and the maximum total calorific value of the barbarbar function is 20. . Here, for example, when the total calorific value 100 exceeds the allowable total calorific value H1 (see FIG. 1) of the processor, a command is given to give priority to the temperature, ie, the low calorific value, over the processing speed for the bar function. Will be optimized.
[0020]
Referring to FIG. 3 again, when the optimization target portion is not explicitly specified in advance by the user (step S6), the compiler 2 performs an optimization process in consideration of the temperature rise due to the optimization target portion. Execute. That is, the compiler 2 refers to the data of the predicted peak heat generation amount and the total heat generation amount for each subroutine described in the profile PF with respect to the optimization target portion found in step S5, and stores it in the library L6 (see FIG. 2). An optimum subroutine is selected from the stored low power subroutines (step S9). Subsequently, the compiler 2 rearranges the instruction sequence by replacing each subroutine with the selected low-power subroutine (step S10). FIG. 6 is a schematic diagram for explaining a specific example for selecting the optimum subroutine. In this example, the processor includes an arithmetic unit that processes a complex operation such as sqrt (√). The low-power library L6 (see FIG. 2) stores a single-precision version of a subroutine used when calculation accuracy is not a concern, while the library L8 (see FIG. 2) gives priority to calculation accuracy. A double precision version of the subroutine is stored. As shown in the figure, the compiler 2 assigns an optimal library and subroutine according to the situation. Such a mapping process is particularly advantageous in the case of an operation in which the amount of heat generation is severe in view of the allowable value, but the image may be slightly rough, in the case of a graphic processor.
[0021]
Returning to FIG. 3, the compiler 2 performs provisional execution again on the rearranged instruction sequence, and repeats the above-described procedure until the temperature condition is satisfied (steps S3 to S10). When the temperature condition is satisfied by these procedures (step S4), the compiler 2 confirms that the processing by the last rearranged instruction sequence is completed within a predetermined time (step S11). When the processing ends within a predetermined time, both the processing speed and the heat generation meet the specifications of the processor, so the last instruction sequence is output as the final object code OC4, and the compiling operation ends. If the processing does not end within the predetermined time, both the processing speed and the heat generation do not satisfy the processor specifications, so the compiler 2 indicates an optimization target portion and outputs an error (step S12), and the operation ends. To do. As described above, even if the object code that satisfies the processor specifications in both the processing speed and the heat generation amount cannot be obtained, the optimization target part in question is shown to the user. The user program can be reviewed without the need to search for the program. In the present embodiment, the form in which the optimization process by the subroutine is executed has been described. However, the present invention is not limited to this. For example, the optimization may be performed using a finer granularity than the subroutine. This also applies to the second to fourth embodiments described below.
[0022]
(3) Second embodiment of compiling method
Next, a second embodiment of the compiling method according to the present invention will be described with reference to FIGS. This embodiment is a mode suitable for a case where a processor for executing object code or a system including the same is provided with a function for reducing frequency and power supply voltage.
FIG. 7 is a flowchart for explaining a schematic procedure of the compiling method of this embodiment. As is clear from the comparison with FIG. 3, the feature of the present embodiment is in step S26 representing the program optimization processing procedure. Therefore, hereinafter, step S26 will be mainly described.
[0023]
That is, as in the first embodiment, various parameters are fetched (step S11), a normal assembler string is created for the user program SC, and the provisional object code OC2 is output (step S22). Next, the compiler 2 creates and outputs a profile PF by provisionally executing the provisional object code OC2 while referring to a table of the amount of generated heat vs. instructions (step S23). Subsequently, the compiler 2 determines whether or not the created assembler string satisfies the temperature condition based on the profile PF (step S24). If the created assembler string does not satisfy the temperature condition, the compiler 2 finds an optimization target portion in the provisional object code OC2 based on the output profile PF (step S25).
[0024]
In the present embodiment, the compiler 2 automatically inserts an instruction or the like for suppressing the amount of generated heat (step S26). FIG. 8 shows a specific example in which the compiler 2 inserts an instruction or the like for suppressing the heat generation amount. A block BL2 shown in the upper part of the figure is a block in which heat generation is a problem in the bar function, and is an example of an optimization target portion discovered by the compiler 2. As shown in the lower part of FIG. 8, in this embodiment, the compiler 2 adds special instructions lowpwr and normal to the entrance and exit of the bar function of the block BL2. Here, the lowpwr instruction is an instruction for reducing the frequency and the power supply voltage, and the normal instruction is an instruction for restoring the changed frequency and power supply voltage.
As described above, according to the present embodiment, when the processor or system has a function of reducing the frequency and the power supply voltage, an instruction or the like for suppressing the amount of generated heat is inserted into the assembler row, so that the device can easily generate heat. Can be suppressed.
[0025]
(4) Third embodiment of compiling method
Next, a third embodiment of the compiling method according to the present invention will be described with reference to FIGS. The present embodiment is suitable for a processor including a plurality of pipelines and a pipeline that is set so that the heat generation amount when the use is stopped is smaller than the heat generation amount when the use is stopped. It is a form. Such a processor typically includes a superscalar processor and a VLIW processor.
FIG. 9 is a flowchart for explaining a schematic procedure of the compiling method of this embodiment. Similar to the third embodiment described above, the present embodiment is characterized in step S46 representing a program optimization process. Since the other procedures of this embodiment are substantially the same as those of the second embodiment shown in FIG. 7, the following description will focus on step S46.
[0026]
First, as in the second embodiment, the compiler 2 takes in various parameters (step S41), creates a normal assembler string for the user program SC, and outputs the provisional object code OC2 (step S42). Then, the provisional object code OC2 is provisionally executed while referring to the table of the heat generation amount instruction, etc., and the profile PF is created and output (step S43). Subsequently, the compiler 2 determines whether the created assembler string satisfies the temperature condition based on the profile PF (step S44). If the created assembler string does not satisfy the temperature condition, the compiler 2 finds an optimization target portion in the provisional object code OC2 based on the output profile PF (step S45). As a result, when it is found that the heat generation amount exceeds the limit value at a certain interval, the compiler 2 stops issuing instructions to some of the pipelines and further suppresses the heat generation. An instruction or the like is added (step S46). 10 and 11 are schematic diagrams for specifically explaining the procedure of step 46. FIG. 10 shows operation modes of two pipelines (pipe 0 and pipe 1) of a processor having a function of suppressing heat generation in response to a nop instruction or the like. If it is found from the information of the profile PF that the amount of heat generation exceeds the limit value at intervals T2 and T3, the compiler 2 adds an instruction or the like that stops issuing instructions to the pipeline 1 and suppresses heat generation. In the specific example shown in the figure, the compiler 2 issues a single issue mode for issuing an instruction for operating only a single pipe from a dual issue mode for issuing an instruction for operating two pipes independently. Change the order to 11 shows the operation of the pipelines 0 and 1 shown in FIG. 10, (a) shows the operation in the dual issue mode, (b) shows the operation in the single issue mode, (C) represents a state in which the nop instruction has been inserted by the compiler 2.
[0027]
As described above, according to the compiling method of the present embodiment, when the target hardware has a pipeline that suppresses the amount of heat generation during normal use, the instruction to change the operation mode is inserted. Therefore, the object code that suppresses the heat generation amount of the device can be easily generated.
[0028]
(5) Fourth embodiment of compiling method
Next, a fourth embodiment of the compiling method according to the present invention will be described with reference to FIG. This embodiment is a compiling method when the procedure shown in FIG. 1 is applied to a multiprocessor system. Therefore, description of the overall procedure is omitted, and the following description will focus on the optimization method (step S9 in FIG. 1).
[0029]
Usually, in a multiprocessor system, the processing is different for each processor, and therefore it is necessary to synchronize the processors in each part of the program. Therefore, in a program part sandwiched between a certain synchronization point and the next synchronization point, a processor with a light process (short processing time) operates a processor with a heavy process (long processing time) in the same program part. You have to wait until it finishes. At this time, if the amount of heat generation is large enough to affect the normal operation of the entire device in a lightly processed processor, select an instruction or subroutine that emphasizes a small amount of heat generation rather than an instruction that emphasizes processing speed. It is desirable to make it. The feature of the compiling method of this embodiment is that when the optimization target part corresponds to a part waiting for synchronization and there is no problem even if the processing speed is reduced, the instruction of that part is an instruction that places importance on the amount of heat generation. It is in the point of substituting with an equal or subroutine.
[0030]
FIG. 12 is a schematic diagram showing the amount of heat generated when an object code is executed by a multiprocessor including processors A, B, and C, before and after the optimization process. As shown on the left side of the figure, in the multiprocessor shown in this example, the processors B and C are waiting for synchronization until the processing of the processor A is completed because the processing is lighter than the processor A. On the other hand, the amount of heat generated between the synchronization points of the processors B and C is 100 and 130, respectively, including the synchronization wait, and this affects the normal operation of the entire device.
[0031]
The compiler 2 generates an instruction sequence for the user programs for the processors B and C so that the heat generation amount is reduced at the expense of the processing speed. The amount of heat generated after such optimization processing is shown on the right side of FIG. Although the processing speeds of the processors B and C are slowed down by the optimization processing, the heat generation amount between the synchronization points becomes 50 and 60, respectively, and it can be seen that the heat generation amount of the entire device is greatly reduced.
[0032]
As described above, according to the present embodiment, object code is generated by giving priority to the smaller amount of heat generation than the processing speed for the extra synchronization waiting program part, so that hardware resources can be used effectively. A compiling method for suppressing calorific value is provided.
[0033]
(6) Recording medium
The above-described compiler may be stored in a storage medium such as a floppy disk or a CD-ROM, and read by a computer and executed. Thereby, the compiling method concerning this invention is realizable using a general purpose computer. The recording medium is not limited to a portable medium such as a magnetic disk or an optical disk, but may be a fixed storage medium such as a hard disk device or a memory. Further, the compiler described above may be distributed via a communication line (including wireless communication) such as the Internet. Further, the above-described compiler may be distributed via a wired line or a wireless line such as the Internet or in a storage medium in a state where the compiler is encrypted, modulated, or compressed.
[0034]
(7) Storage device and processor
The object code generated by the above-described compiling method or compiler may be stored in a storage device and executed by a processor. Further, when the processor has a built-in storage device, the object code generated by the above-described compiling method or compiler may be stored in the internal storage device and executed by the processor. This provides a storage device or processor that can suppress the amount of heat generation while effectively utilizing hardware resources.
[0035]
【The invention's effect】
As described above in detail, the present invention has the following effects.
That is, according to the present invention, there are provided a compiling method capable of suppressing heat generation from hardware, a compiler for causing a computer to execute the compiling method, and a recording medium storing the compiling method.
[0036]
Further, according to the present invention, since the object code generated by the above-described compiling method and subjected to the optimization process is stored, a storage device capable of suppressing the heat generation amount of the hardware within the specification range is provided.
[0037]
Furthermore, according to the present invention, since the storage device described above is provided, a processor that operates stably without generating heat exceeding the specification range is provided.
[Brief description of the drawings]
FIG. 1 is a graph showing a heat generation amount per unit cycle of one semiconductor chip used in a certain game machine.
FIG. 2 is a schematic diagram illustrating a schematic function of an embodiment of a compiler according to the present invention.
FIG. 3 is a flowchart showing a schematic procedure of a first embodiment of a compiling method according to the present invention.
FIG. 4 is a diagram illustrating a specific example of an optimization target portion designated by a user.
FIG. 5A shows an example of a main function in a user program, and FIG. 5B shows a maximum total calorific value in each interval associated with each function in the main function shown in FIG. Indicates the value.
FIG. 6 is a schematic diagram for explaining a specific example for selecting an optimum subroutine.
FIG. 7 is a flowchart illustrating a schematic procedure of a second embodiment of a compiling method according to the present invention.
8 is a diagram for specifically explaining a flow for inserting a command or the like for suppressing the amount of generated heat in the flow shown in FIG. 7. FIG.
FIG. 9 is a flowchart illustrating a schematic procedure of a third embodiment of a compiling method according to the present invention.
10 is a schematic diagram for explaining a main part of the compiling method shown in FIG. 9. FIG.
11 is a schematic diagram for explaining a main part of the compiling method shown in FIG. 9;
FIG. 12 is a schematic diagram for explaining a fourth embodiment of a compiling method according to the present invention;
[Explanation of symbols]
2 Compiler
BL2 block
L2, L4, L6, L8 library
OC2, OC4 Object code
PF profile
SC user program
T0, T1, T2, T3 Time interval

Claims (2)

Compiling method using a computer loaded with a compiler program,
A procedure in which a computer receives input from a user program and generates provisional object code that can be interpreted by target hardware;
When the computer executes the provisional object code, the amount of heat generated from the hardware is described as a relationship between the amount of heat generated by the hardware and an instruction or instruction sequence in the user program. The procedure for calculating while referring to the table of
A step of determining whether or not the calculated calorific value is within the specification range by referring to a second table in which the computer describes a specification range regarding the heat of the hardware;
A step of outputting the provisional object code as a final object code when the computer determines that the calculated calorific value is within the specification range;
When the computer determines that the calculated amount of heat generation exceeds the specification range, the computer finds a code portion that causes heat generation that exceeds the specification range in the provisional object code as a portion to be optimized, and A procedure for performing optimization processing in consideration of a temperature increase due to the optimization target portion using a plurality of instructions or instruction sequences for low power described in the table of
The computer outputs a provisional object code that has executed the optimization process as a final object code;
Equipped with a,
The hardware includes a plurality of pipelines set so that the amount of heat generated when use is stopped is smaller than the amount of heat generated when used,
The procedure for executing the optimization process includes a procedure in which the computer stops issuing instructions to some of the plurality of pipelines.
Compilation method. Compiling method using a computer loaded with a compiler program,
A procedure in which a computer receives input from a user program and generates provisional object code that can be interpreted by target hardware;
When the computer executes the provisional object code, the amount of heat generated from the hardware is described as a relationship between the amount of heat generated by the hardware and an instruction or instruction sequence in the user program. The procedure for calculating while referring to the table of
A step of determining whether or not the calculated calorific value is within the specification range by referring to a second table in which the computer describes a specification range regarding the heat of the hardware;
A step of outputting the provisional object code as a final object code when the computer determines that the calculated calorific value is within the specification range;
When the computer determines that the calculated amount of heat generation exceeds the specification range, the computer finds a code portion that causes heat generation that exceeds the specification range in the provisional object code as a portion to be optimized, and A procedure for performing optimization processing in consideration of a temperature increase due to the optimization target portion using a plurality of instructions or instruction sequences for low power described in the table of
The computer outputs a provisional object code that has executed the optimization process as a final object code;
Equipped with a,
The hardware comprises a multiprocessor system,
Wherein the optimization target portion, the processing time is short processors, it corresponds to the portion where operation of a long-processor processing time must wait until the end,
In the procedure for executing the optimization process, the computer selects, from the plurality of instructions or instruction sequences in the third table, an instruction or instruction sequence that generates a small amount of heat at the expense of processing speed, and Replacing a portion of the instruction or instruction sequence that must be waited with the selected instruction or instruction sequence;
Compilation method.

Images