JP2005251210A - Processor and recording medium - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To reduce a wasteful area in an instruction in order to improve a problem wherein, whereas an operation corresponding to a plurality of computing units each having a processor is designated to each slot of an instruction of a VLIW processor, a program size is increased by NOP codes placed in the instruction because operations equivalent to the number of slots executable in parallel are not always scheduled by a dependency relationship of operations; and in addition, the more the parallelism of instructions increases, the more the number of inserted NOP codes increases, whereby code efficiency is further deteriorated. <P>SOLUTION: A compiler fills positions of nop codes with effective operations by dividing it as required, and a processor accumulates and executes them. In addition, n NOP codes of instructions of m (m<n) slots are filled with n parallel execution operations, or (n-M) NOP codes of instructions of m slots are filled with (n-m) of n parallel execution operations. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

  The present invention relates to a compiler, a processor, and a storage medium, and particularly relates to a technique for improving the execution code efficiency of a single instruction type or VLIW (Very Long Instruction Word) type processor.

  Due to recent developments in electronic technology, high-performance processors have become widespread and are used in all fields. Such processors achieve high performance by parallel processing of instructions. An architecture called VLIW is also a form of parallel processing of instructions. A processor using the VLIW architecture (hereinafter referred to as “VLIW processor”) has a plurality of arithmetic units inside and is a slot placed in one instruction. The operations specified in multiple fields called are executed simultaneously in parallel. Such a machine instruction program of the VLIW processor is generated after the parallelism at the operation level in a program written in a high-level language is detected and scheduled by a compiler. A machine instruction program is also called an execution code.

(First prior art)
FIG. 21 is a block diagram of a processor in the first prior art.

  The processor in the first prior art executes two operations in parallel, and a program comprising an instruction sequence consisting of first and second slots as shown in FIG. After the operation written in the slot is decoded by the first instruction decoder 4 and the second instruction decoder 5, it is executed by the first arithmetic unit 13 and the second arithmetic unit 14.

(Second prior art)
FIG. 22 is a block diagram of a processor in the second prior art.

  Although the processor in the second prior art executes three operations in parallel, the basic idea is the same as the processor in the first prior art, and the first to third three slots as shown in FIG. Is stored in the ROM 41, and the operations written in the respective slots are decoded by the first instruction decoder 45 by the third instruction decoder 47, and then the first operator 58 receives the first instruction. This is executed by the three computing units 60. That is, the number of slots constituting one instruction is merely increased.

However, any of the above conventional techniques has a problem that the program size increases due to a no-operation code (nop code) placed in the instruction.
An increase in program size is also expressed as a decrease in code efficiency. Each slot of the instruction of the VLIW processor is assigned an operation corresponding to a plurality of arithmetic units provided in the processor. However, due to the dependency of the operation etc., it is not always possible to schedule the operation as many as the number of slots that can be executed in parallel. Because there is no. If a valid operation cannot be placed, the compiler generates nop code in that slot.

  In the first prior art described above, for example, as shown in FIG. 5, two effective operations B and C can be specified in the instruction 2, but an effective operation is specified in the second slot in the instruction 1. It is nop without being able to. In the second prior art described above, for example, as shown in FIG. 14, it is impossible to designate a valid operation in the second and third slots in the instruction 1, and in the third slot in the instruction 2, resulting in nop. ing. As described above, the VLIW processor generally has a problem that the number of inserted nop codes increases as the degree of instruction parallelism increases, and the code efficiency further deteriorates. This is because the probability that an effective operation can be scheduled in all slots in the compiler is inversely proportional to the degree of parallelism.

  Accordingly, the present invention has been made in view of such a point, and a first object thereof is to provide a compiler and a processor that reduce a useless area in an instruction.

  A second object of the present invention is to provide a compiler and a processor that can reduce an increase in nop code accompanying an increase in the degree of instruction parallelism in a VLIW processor.

  The compiler of the present invention generates a long-word instruction format from a plurality of operations that can be executed in parallel by a processor from a high-level language program, and then replaces nop included in the instruction with an effective operation executed after nop, It is characterized in that information indicating that a valid operation is deleted and replaced is added. Thereby, nop can be replaced with a valid operation, and the code size can be reduced.

  A processor that executes such an instruction is a processor that temporarily stores an instruction in an accumulation buffer based on the value of an accumulation bit in the instruction and then executes the instruction accumulated in the accumulation buffer. .

  As apparent from the above description, according to the present invention, the nop can be reduced and the code size can be reduced.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
(Embodiment 1)
In the first embodiment, an instruction in which an effective operation is arranged instead of nop is temporarily stored and then executed, and the code size is reduced.

1. Compiler FIG. 1 is a block diagram showing a configuration of a compiler.

  The compiler 102 translates the C language program 101 written by the user and outputs a machine instruction program 112.

  The compiler 102 reads the C language program 101 into the reading buffer 104, analyzes the syntax and meaning of the C language program read into the reading buffer 104, generates intermediate code, and generates an intermediate code buffer 106. The syntactic analysis unit 105 for writing to the intermediate code and the intermediate code stored in the intermediate code buffer 106 are input to perform instruction scheduling for the purpose of executing two instructions in parallel, and an uncompressed machine instruction program is generated to generate a temporary output buffer. A machine instruction generation unit 107 for writing to 108, a machine instruction compression unit 109 for compressing an uncompressed machine instruction program stored in the temporary output buffer 108 to generate a target machine instruction program and writing it to the output buffer 110, The machine instruction program stored in the output buffer 110 is stored in the file. Composed from the file output unit 111 for outputting Le. Here, “compression of machine instruction program” refers to replacing the nop code included in each instruction of the machine instruction program with a valid operation. Each element other than the machine instruction compression unit 109 that performs this compression may be configured based on a known technique, and thus description thereof is omitted here. As will be described in detail below, the machine instruction compression unit 109 operates based on the following principle.

  The uncompressed machine instruction program is searched in the order of the instructions, the pair of the nop code of the first slot and the nop code of the second slot in the same order is extracted, and the first slot and the second slot of this nop code pair are extracted. Then, the first operation and the second operation of the pair of valid operations appearing first after the pair are respectively replaced and marked as being replaced, and the pair of valid operations used for the replacement is deleted. As a result, an instruction including two valid operations is arranged in place of the nop existing before this, and the nop is reduced.

2 to 4 are flowcharts showing the processing flow of the machine instruction compression unit 109.
The processing flow of the machine instruction compression unit 109 will be described in detail using the following operation example.

1.1 Example of Operation of Machine Instruction Compression Unit 109 FIG. 5 is an exemplary diagram of an uncompressed machine instruction program, which is generated by the machine instruction generation unit 107 in accordance with the first prior art described above.

  The instruction consists of first and second slots, the symbols A to J indicate a valid operation, and nop indicates that nop code is generated.

  FIG. 6 is a view showing an example of a compressed machine instruction program. The machine instruction compression unit 109 compresses the uncompressed machine instruction program of FIG. 5 according to the following procedure.

  The instruction is composed of first and second slots, and each slot includes one accumulation bit and an operation (OP) field. Symbols A to J indicate valid operations as in FIG.

  The operation of the machine instruction compression unit 109 when the program of FIG. 5 is input will be described below with reference to FIGS.

  As shown in FIG. 2, initialization is first performed. Initialization is performed by setting the instruction pointer N to the first instruction, that is, the instruction 1 in FIG. 5, setting the instruction prefetch counter m to 1, and setting the first slot nop counter C1 and the second slot nop counter C2 to 0. The first slot buffer counter B1 is set to 0, and the second slot buffer counter B2 is set to 0 (step S201). Here, N, m, C1, C2, B1, and B2 are parameters created internally by the machine instruction compression unit 109.

  Next, the instruction indicated by N, that is, the type of instruction 1 in FIG. 5 is evaluated. Since the instruction 1 is an operation A in which the first slot is valid and the second slot is a nop code, “OP (1): nop (2) type” is applicable and jumps to the process A (step S202). (1) and (2) mean the first slot and the second slot.

  In process A shown in FIG. 3, first, the second slot nop counter C2 is incremented to C2 = 1, and the second slot buffer counter B2 is incremented to B2 = 1 (step S301). Next, the value of the first slot nop counter C1 is substituted into the internally generated parameter C1X of the machine instruction compression unit 109, so that C1X = 0 (step S302). Next, the instruction indicated by (N + m), that is, the type of instruction 2 in FIG. 5 is evaluated. Since the instruction 2 is the operations A and B in which the first and second slots are valid, “OP (1): OP (2) type” is applicable and the process jumps to step S312 (step S303). Now, B2 = 1 and B2 ≦ 2 is satisfied, but C1X ≧ 1 in step S307 is not satisfied (C1 = 0), and then the process jumps to step S305. Here, the condition of C1X ≧ 1 is that the replacement target is newly replaced by replacing only the second slot, such as replacing OP (1): OP (2) with OP (1): NOP (2). This is to prevent the generation of. That is, by adding this condition, OP (1): OP (2) is eventually replaced with NOP (1): NOP (2) and deleted. The condition of B2 ≦ 2 is that the processor shown in FIG. 7 to be described later has two sets of buffers for each of the first and second slots, and prevents replacement beyond this. Here, since the instruction indicated by (N + m), that is, instruction 2 in FIG. 5, is not the last instruction, the process proceeds to step S306 (step S305), the instruction prefetch counter m is set to 2, and the process proceeds to the next instruction. Return (step S306).

  Next, the instruction indicated by (N + m), this time the type of instruction 3 in FIG. 5, is evaluated. Since the instruction 3 is an operation D in which the first slot is valid and the second slot is a nop code, “OP (1): nop (2) type” is applicable and the process jumps to step S305 (step S303). Since the instruction indicated by (N + m), that is, instruction 3 in FIG. 5, is not the last instruction, the process proceeds to step S306 (step S305), the instruction prefetch counter m is set to 3 and the process proceeds to the next instruction, and the process returns to step S303 ( Step S306).

  Next, the instruction indicated by (N + m), this time the type of instruction 4 in FIG. 5, is evaluated. Since the instruction 4 is an operation E in which the first slot is a nop code and the second slot is valid, “nop (1): OP (2) type” is applicable and the process jumps to step S304 (step S303). Here, 1 is added to C1X, so that C1X = 1 (step S304). Since the instruction indicated by (N + m), that is, instruction 4 in FIG. 5, is not the last instruction, the process proceeds to step S306 (step S305), the instruction prefetch counter m is set to 4 and the process proceeds to the next instruction, and the process returns to step S303 ( Step S306).

  Next, the instruction indicated by (N + m), that is, the type of instruction 5 in FIG. 5 is evaluated. Since the instruction 5 is the operations F and G in which the first and second slots are valid, “OP (1): OP (2) type” is applicable and the process jumps to step S312 (step S303). Now, B2 = 1 and B2 ≦ 2 is satisfied, and C1X ≧ 1 (C1X = 1) in step S307 is satisfied, and the process jumps to step S308. Here, since OP (2) remains valid, the process jumps to step S309 (step S308), sets the instruction indicated by N, that is, the accumulated bit of the first slot of instruction 1 in FIG. Set the slot storage bit to "1" and fill the OP field with operation G instead of nop. In this way, it is confirmed that OP (2) is valid if it is an instruction that is already placed in place of nop even if OP (2) exists and is not actually present. Because there is. In this way, instruction 1 in FIG. 6 is generated. Subsequently, the instruction indicated by (N + m), that is, OP (2) of the instruction 5 in FIG. 5 is invalidated (step S309). At this time, since OP (1) is still valid, the process A is terminated and the process jumps to step S206 (step S310). As will be described later, when OP (1) is invalid (already replaced), the instruction is deleted in step S311.

  Returning from the processing A, the instruction indicated by N, that is, the instruction 1 in FIG. 5 moves to step S207 where the instruction is not the last instruction (step S206), and the instruction pointer N is advanced to the next instruction, that is, instruction 2 in FIG. The instruction prefetch counter m is returned to 1, and the process returns to step S202 (step S207).

  Subsequently, the instruction indicated by N, ie, the type of instruction 2 in FIG. 5, is evaluated. As described above, the instruction 2 corresponds to “OP (1): OP (2) type”, and the process proceeds to step S205 (step S202). Here, the accumulation bit in the first and second slots of the instruction indicated by N, that is, instruction 2 in FIG. 5, is set to “0”. Thus, instruction 2 in FIG. 6 is generated. Subsequently, the instruction indicated by N, that is, the instruction 2 in FIG. 5 moves to step S207 where it is not the last instruction (step S206), and the instruction pointer N is advanced to the next instruction, that is, instruction 3 in FIG. m is returned to 1, and the process returns to step S202 (step S207).

  Subsequently, the instruction indicated by N, that is, the type of instruction 3 in FIG. 5 is evaluated. Command 3 corresponds to “OP (1): nop (2) type” as described above, and jumps to process A (step S202).

  In the process A, first, the second slot nop counter C2 is incremented to C2 = 2, and the second slot buffer counter B2 is incremented to B2 = 2 (step S301). Next, the value of the first slot nop counter C1 is substituted into the parameter C1X, so that C1X = 0 (step S302). Next, the instruction indicated by (N + m), that is, the type of instruction 4 in FIG. 5 is evaluated. Command 4 corresponds to “nop (1): OP (2) type” as described above, and jumps to step S304 (step S303). Here, 1 is added to C1X, so that C1X = 1 (step S304). Since the instruction indicated by (N + m), that is, the instruction 4 in FIG. 5, is not the last instruction, the process proceeds to step S306 (step S305), the instruction prefetch counter m is set to 2 and the process proceeds to the next instruction, and the process returns to step S303 ( Step S306).

  Next, the instruction indicated by (N + m), that is, the type of instruction 5 in FIG. 5 is evaluated. As described above, the instruction 5 corresponds to “OP (1): OP (2) type” and jumps to step S307 (step S303). Since C1X = 1, C1X ≧ 1 is satisfied and the process jumps to step S308. Here, since OP (2) has been previously invalidated, the process jumps to step S305 (step S308). Since the instruction indicated by (N + m), that is, instruction 5 in FIG. 5, is not the last instruction, the process proceeds to step S306 (step S305), the instruction prefetch counter m is set to 3 and the process proceeds to the next instruction, and the process returns to step S303 ( Step S306).

  Next, the instruction indicated by (N + m), that is, the type of the instruction 6 in FIG. 5 is evaluated. Since the instruction 6 is an operation H in which the first slot is a nop code and the second slot is valid, “nop (1): OP (2) type” is applicable and the process jumps to step S304 (step S303). Here, 1 is added to C1X, resulting in C1X = 2 (step S304). Since the instruction indicated by (N + m), that is, instruction 6 in FIG. 5, is not the last instruction, the process proceeds to step S306 (step S305), the instruction prefetch counter m is set to 4 and the process proceeds to the next instruction, and the process returns to step S303 ( Step S306).

  Next, the instruction indicated by (N + m), that is, the type of the instruction 7 in FIG. 5 is evaluated. Since the instruction 7 is the operations I and J in which the first and second slots are valid, “OP (1): OP (2) type” is applicable and the process jumps to step S312 (step S303). Now, B2 = 2 and B2 ≦ 2 is satisfied, and C1X ≧ 1 (C1X = 2) in step S307 is satisfied, and the process jumps to step S308. Here, since OP (2) remains valid, the process jumps to step S309 (step S308), sets the instruction indicated by N, that is, the accumulated bit of the first slot of instruction 3 in FIG. Set the slot accumulation bit to “1” and fill the OP field with operation J instead of nop. Thus, instruction 3 in FIG. 6 is generated. Subsequently, the instruction indicated by (N + m), that is, OP (2) of the instruction 7 in FIG. 5 is invalidated (step S309). At this time, since OP (1) is still valid, the process A is terminated and the process jumps to step S206 (step S310).

  Returning from the process A, the instruction indicated by N, that is, the instruction 3 in FIG. 5 moves to step S207 where the instruction is not the last instruction (step S206), and the instruction pointer N is advanced to the next instruction, that is, instruction 4 in FIG. The instruction prefetch counter m is returned to 1, and the process returns to step S202 (step S207).

  Subsequently, the instruction indicated by N, that is, the type of instruction 4 in FIG. 5 is evaluated. The instruction 4 corresponds to “nop (1): OP (2) type” as described above, and jumps to the process B (step S202).

  In the process B, first, the first slot nop counter C1 is incremented to C1 = 1, and the first slot buffer counter B1 is incremented to B1 = 1 (step S401). Next, the value of the second slot nop counter C2 is substituted into the internally generated parameter C2X of the machine instruction compression unit 109, so that C2X = 2 (step S402). Next, the instruction indicated by (N + m), that is, the type of instruction 5 in FIG. 5 is evaluated. The instruction 5 corresponds to “OP (1): OP (2) type” as described above, and jumps to step S412 (step S403). Now, B1 = 1 and B1 ≦ 2 are satisfied, and C2X ≧ 1 (C2X = 2) in step S407 is satisfied, and the process jumps to step S408. Here, since OP (1) remains valid, the process jumps to step S409 (step S408), and the instruction indicated by N, that is, the accumulation bit of the second slot of instruction 4 in FIG. Set the slot accumulation bit to "1" and fill the OP field with operation F instead of nop. Thus, instruction 4 in FIG. 6 is generated. Subsequently, the instruction indicated by (N + m), that is, OP (1) of the instruction 5 in FIG. 5 is invalidated (step S409). Next, since OP (2) has been previously invalidated, the process jumps to step S411 (step S410). Here, the instruction indicated by (N + m), that is, the instruction 5 in FIG. 5, is deleted, and the first slot nop counter C1 and the second slot nop counter C2 are decremented, C1 = 0, C2 = 1, and the first slot. The buffer counter B1 and the second slot buffer counter B2 are decremented to be B1 = 0 and B2 = 1 (step S411). This completes process B, and the process jumps to step S206.

  Returning from the process B, the instruction indicated by N, that is, the instruction 4 in FIG. 5 moves to step S207 where the instruction is not the last instruction (step S206), and the instruction pointer N is changed to the next instruction, that is, the instruction 6 (instruction (5 is deleted), the instruction prefetch counter m is returned to 1, and the process returns to step S202 (step S207).

  Subsequently, the instruction indicated by N, that is, the type of instruction 6 in FIG. 5 is evaluated. The instruction 6 corresponds to “nop (1): OP (2) type” as described above and jumps to the process B (step S202).

  In the process B, the first slot nop counter C1 is first incremented to C1 = 1, and the first slot buffer counter B1 is incremented to B1 = 1 (step S401). Next, the value of the second slot nop counter C2 is substituted into the parameter C2X, so that C2X = 1 (step S402). Next, the instruction indicated by (N + m), that is, the type of the instruction 7 in FIG. 5 is evaluated. As described above, the instruction 7 corresponds to “OP (1): OP (2) type” and jumps to step S412 (step S403). Now, B1 = 1 and B1 ≦ 2 is satisfied, and C2X ≧ 1 (C2X = 1) in step S407 is satisfied, and the process jumps to step S408. Since OP (1) remains valid, the process jumps to step S409 (step S408), and the instruction indicated by N, that is, the accumulated bit of the second slot of instruction 6 in FIG. Set the slot accumulation bit to "1" and fill the OP field with operation I instead of nop. In this way, instruction 5 in FIG. 6 is generated. Subsequently, the instruction indicated by (N + m), that is, OP (1) of the instruction 7 in FIG. 5 is invalidated (step S409). Next, since OP (2) has been previously invalidated, the process jumps to step S411 (step S410). Here, the instruction indicated by (N + m), that is, the instruction 7 in FIG. 5, is deleted, the first slot nop counter C1 and the second slot nop counter C2 are decremented, and C1 = 0, C2 = 0, and the first slot. The buffer counter B1 and the second slot buffer counter B2 are decremented to become B1 = 0 and B2 = 0 (step S411). This completes process B, and the process jumps to step S206.

  Returning from the process B, since the instruction indicated by N, that is, the instruction 6 in FIG. 5, is the last instruction (the instruction 7 has been deleted), all the processes are terminated (step S206).

  As described above, the uncompressed machine instruction program shown in FIG. 5 is converted into the compressed machine instruction program shown in FIG. In the above operation example, there are unpassed steps in FIG. 3 and FIG. 4, but FIG. 3 and FIG.

2. Processor FIG. 7 is a schematic configuration diagram of a processor.

  This processor has a three-stage pipeline structure composed of three stages: an instruction fetch stage (hereinafter referred to as IF stage), a decoding and register read stage (hereinafter referred to as DEC stage), and an execution stage (hereinafter referred to as EX stage). .

In FIG. 7, 1 is a ROM for storing a machine language program, 2 and 3 are I1 and I2 latches for storing the contents of the first and second slots of machine language instructions (hereinafter abbreviated as instructions), respectively. Reference numeral 5 denotes a first instruction decoder and a second instruction decoder which decode the contents of the first and second slots of the instructions held in the I1 latch 2 and I2 latch 3, respectively, and control each part of the processor, and 6 stores an operand. A register file, 7 and 8, respectively, are a D1 selector and a D2 selector for selecting one of two inputs of a part of the contents of the I1 latch 2 and the I2 latch 3 and an output of the register file 6; D11 latch and D12 latch for storing the output of the D2 selector 8 and 11 and 12 are the D21 latch and D22 latch for storing the output of the register file 6, and 13 11 is a first arithmetic unit that performs arithmetic logic operations using the contents of the latches 9 and D21 11, and 14 is a second arithmetic unit that performs arithmetic logic operations using the contents of the D12 latches 10 and D22 latches 12. The outputs of the calculator 13 and the second calculator 14 are both connected to the register file 6. Reference numerals 15 and 16 denote an IB11 buffer and an IB12 buffer for holding the contents of the first slot and the second slot of the instructions held in the I1 latch 2 and the I2 latch 3, respectively, which are collectively referred to as an IB1 buffer. Reference numerals 17 and 18 denote an IB21 buffer and an IB22 buffer that hold the contents of the first slot and the second slot of the instructions held in the I1 latch 2 and the I2 latch 3, respectively. The contents are taken into the IB1 buffer and the IB2 buffer when the accumulation bit of each slot is "1". 23 and 24 are selectors that select and output either the IB1 buffer or the IB2 buffer, and 19 is either the contents of the first slot of the instruction read from the ROM 1 or the selector 23 and outputs it to the I1 latch 2 The I1 selector, 20 selects the contents of the second slot of the instruction read from the ROM 1 or the selector 24 and outputs it to the I2 latch 3, and 21 and 22 are stored in the I1 latch 2 and I2 latch 3 A nop generator that outputs nop (No Operation) when the accumulated bit of the data is “1”, and 25 and 26 invert the write signal to “0” and “1” when the accumulated bit becomes “1”. A write signal generator that outputs "0" when the accumulation bit is "0", 27 and 28 are AND circuits that detect completion of instruction accumulation, Reference numeral 29 denotes an OR circuit for generating a signal or the like for stopping instruction fetch when the stored instruction is decoded and executed, and reference numerals 30 and 31 denote clocked buffers. The nop generators 21 and 22 are composed of AND circuits that calculate the logical product of the output bits of the I1 latch 2 and I2 latch 3 and the inverted one of the stored bits, and the stored bits are “1”. When "", (00... 0) ₂ indicating nop is output. The write signal generators 25 and 26 are composed of a T-type flip-flop and an AND circuit, and perform an AND operation between the normal output and the trigger input of the T-type flip-flop (stored bits of the I1 latch 2 and I2 latch 3). The output of the circuit is a write signal to the IB11 buffer 15 and the IB12 buffer 16, and the output of the AND circuit that takes the logical product of the inverted output and the trigger input of the T-type flip-flop is the write signal to the IB21 buffer 17 and IB22 buffer 18. Yes.

  The register file 6 includes general-purpose registers R0 to R7, and has 4 read ports and 2 write ports. That is, reading of four registers (duplication is possible) and writing of two registers (duplication is impossible) are allowed at the same time. The D1 selector 7 and the D2 selector 8 select this when a constant value such as an immediate value accompanies the instruction according to instructions from the first instruction decoder 4 and the second instruction decoder 5, respectively.

  This processor is based on instructions in the so-called VLIW (Very Long Instruction Word) format, and operations such as two operations are defined by one instruction. The operation of the first slot is stored in the I1 latch 2, decoded by the first instruction decoder 4, and executed by the first arithmetic unit 13. The operation of the second slot is stored in the I2 latch 3, decoded by the second instruction decoder 5, and executed by the second calculator 14. In this way, the VLIW processor is highly efficient because it performs two operations simultaneously.

2.1 Example of Processor Operation Hereinafter, the operation of the processor having the above configuration when the machine instruction program of FIG. 6 is stored in the ROM 1 will be described with reference to FIG.

  FIG. 8 is an operation timing chart of the processor when the machine instruction program of FIG. 6 is stored in the ROM 1. The figure shows the machine cycle of the processor operation that is read from ROM1 at the IF stage of the pipeline, the instruction that is decoded at the DEC stage, the instruction that is executed at the EX stage, and the instructions held in the IB1 and IB2 buffers. It is shown for each timing called. Hereinafter, the operation will be described for each timing in the order in which time passes. In the figure, “:” represents a slot delimiter, the left represents the first slot and the right represents the second slot, and “−” represents that a valid operation is not held or is not acting.

  In the initial state, it is assumed that the IB11 buffer 15, the IB12 buffer 16, the IB21 buffer 17, and the IB22 buffer 18 are reset.

(Timing t1) • IF stage: Instruction 1
Instruction 1 is read from ROM 1 and the first slot (accumulation bit is “0” and operation A) is stored in I1 latch 2, and the second slot (accumulation bit is “1” and operation G) is stored in I2 latch 3. . That is, since the operation is not yet accumulated in the IB buffer (the accumulation bit is not “1”), both I1SEL19 and I2SEL20 select and output the output from the ROM1.

(Timing t2)-DEC stage: Instruction 1
The contents of the I2 latch 3 whose accumulation bit is “1” (operation G when the accumulation bit is “1”) are taken into the IB12 buffer 16. Specifically, since the accumulation bit is “1”, the write signal generator 26 enables the write signal of the IB12 buffer 16 and the contents of the I2 latch 3 are accumulated in the IB12 buffer 16. Further, since the accumulated bit of the second slot of the instruction 1 stored in the I2 latch 3 is “1”, the nop generator 22 outputs nop (00... 0) ₂ and the second instruction decoder 5 Outputs a decoding result that does not substantially perform any operation in the EX stage.

On the other hand, the first slot of the instruction 1 stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it becomes clear that the operation is A. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and D21 latch 11.
-IF stage: Instruction 2
Instruction 2 is read from ROM1, the first slot (accumulation bit is "0" and operation B) is stored in I1 latch 2, and the second slot (accumulation bit is "0" and operation C) is stored in I2 latch 3. .

(Timing t3)-EX stage: Instruction 1
The operands stored in the D11 latch 9 and D21 latch 11 are input to the first computing unit 13 to perform the operation A. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, in the operation G, since the accumulated bit is “1” and the nop generator 22 invalidates the nop, the second arithmetic unit 14 does not work.
-DEC stage: Instruction 2
The first slot of the instruction 2 stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it becomes clear that it is operation B. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and D21 latch 11. On the other hand, the second slot of the instruction 2 stored in the I2 latch 3 is decoded by the second instruction decoder 5. The result of the decryption reveals that it is operation C. Based on this decoding, the general purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D12 latch 10 and the D22 latch 12. At this time, since the accumulated bits of both operations B and C are “0”, the write signal of any IB buffer is not enabled, and writing is not performed.
-IF stage: Instruction 3
Instruction 3 is read from ROM1, and the first slot (accumulation bit is "0" and operation D) is stored in I1 latch 2, and the second slot (accumulation bit is "1" and operation J) is stored in I2 latch 3. .

(Timing t4)-EX stage: Instruction 2
The operands stored in the D11 latch 9 and D21 latch 11 are input to the first computing unit 13 to perform the operation B. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, the operands stored in the D12 latch 10 and D22 latch 12 are input to the second computing unit 14 to perform the operation C. The calculation result is stored in a general-purpose register of the register file 6 as necessary.
-DEC stage: Instruction 3
The contents of the I2 latch 3 whose accumulation bit is “1” (operation J when the accumulation bit is “1”) are taken into the IB 22 buffer 18. Specifically, since the accumulation bit is “1”, data is written to the IB12 buffer 16 or the IB22 buffer 18, but since data has already been written to the IB12 buffer 16, the write signal generator 26 The write signal of the IB22 buffer 18 is enabled. Further, since the accumulated bit of the second slot of the instruction 3 stored in the I2 latch 3 is “1”, the nop generator 22 outputs nop, and the second instruction decoder 5 substantially does nothing at the EX stage. The decoding result that does not operate is output.

On the other hand, the first slot of the instruction 3 stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it is proved to be operation D. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and D21 latch 11.
-IF stage: Instruction 4
Instruction 4 is read from ROM 1 and the first slot (accumulation bit is "1" and operation F) is stored in I1 latch 2, and the second slot (accumulation bit is "0" and operation E) is stored in I2 latch 3. .

(Timing t5)-EX stage: Instruction 3
The operands stored in the D11 latch 9 and D21 latch 11 are input to the first computing unit 13 to perform the operation D. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, since the operation bit is “1” and the nop generator 22 invalidates the operation J, the second computing unit 14 does not work.
-DEC stage: Instruction 4
The contents of the I1 latch 2 whose accumulation bit is “1” (operation F when the accumulation bit is “1”) are taken into the IB11 buffer 15. Specifically, since the accumulation bit is “1”, the write signal generator 25 enables the write signal in the IB11 buffer 15 and the contents of the I1 latch 2 are accumulated in the IB11 buffer 15. Further, since the accumulated bit of the first slot of the instruction 4 stored in the I2 latch 2 is “1”, the nop generator 21 outputs nop, and the first instruction decoder 4 substantially does nothing at the EX stage. The decoding result that does not operate is output.

On the other hand, the second slot of the instruction 4 stored in the I2 latch 3 is decoded by the second instruction decoder 5. As a result of the decryption, it becomes clear that it is operation E. Based on this decoding, the general purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D12 latch 10 and the D22 latch 12. IF stage: IB1 buffer accumulation instruction Since the accumulation bits of the IB11 buffer 15 and the IB12 buffer 16 are both “1”, the AND circuit 27 outputs “1” as data is accumulated in the accumulation buffer, and further OR The circuit 29 outputs “1” to interrupt the instruction fetch. Thereby, the instruction fetch is interrupted. At the same time, since the accumulated bit of the IB11 buffer 15 is “1”, the selectors 23 and 24 select and output the IB1 buffer. Further, according to the output of the OR circuit 29, the I1 selector 19 and the I2 selector 20 select the IB11 buffer 15 and the IB21 buffer 16, respectively, and the accumulated instructions are stored in the I1 latch 2 and the I2 latch 3. As a result, since the instructions stored in the IB11 buffer 15 and the IB21 buffer 16 are used, the timing is adjusted by the clocked buffer 30, the contents of the IB11 buffer 15 and the IB21 buffer 21 are reset, and the accumulated bits are set. Set to “0”. Although the buffer itself is reset here, only the accumulation bit may be set to “0”. Although not shown in the drawing, when selecting the stored instruction, the I1 selector 19 and the I2 selector 20 set the storage bit to “0” and output it to the I1 latch 2 and the I2 latch 3. This is to prevent the nop generators 21 and 22 from invalidating stored instructions to nop. In addition, the switching signal of the selectors 23 and 24 is set to only the accumulation bit of the IB11 buffer 15 because the IB11 buffer 15 and the IB12 buffer 16 (or the IB21 buffer 17 and the IB22 buffer 18) are always executed when the accumulated instruction is executed. Since the accumulated bit of “1” is “1”, it is not necessary to look at the accumulated bit of the IB12 buffer 16, and executing the instruction accumulated in the IB1 buffer means that the instruction accumulated in the IB2 buffer is still executed. This is because it means a state of not performing. For this reason, the switching signal is not limited to the accumulation bit of the IB11 buffer 15 but can be determined by the value of any accumulation bit.

(Timing t6)-EX stage: Instruction 4
In the operation F, since the accumulation bit is “1” and the nop generator 21 invalidates the nop, the first arithmetic unit 13 does not operate. On the other hand, the operands stored in the D12 latch 10 and the D22 latch 12 are input to the second computing unit 14 to perform the operation E. The calculation result is stored in a general-purpose register of the register file 6 as necessary.
DEC stage: IB1 buffer accumulation instruction The first slot stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it becomes clear that it is operation F. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and D21 latch 11. On the other hand, the second slot stored in the I2 latch 3 is decoded by the second instruction decoder 5. As a result of the decryption, it is proved to be operation G. Based on this decoding, the general purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D12 latch 10 and the D22 latch 12.
-IF stage: Instruction 5
Instruction 5 is read from ROM1, and the first slot (accumulation bit is "1" and operation I) is stored in I1 latch 2, and the second slot (accumulation bit is "0" and operation H) is stored in I2 latch 3. .

(Timing t7) EX stage: IB1 buffer accumulation instruction Operands stored in the D11 latch 9 and D21 latch 11 are input to the first computing unit 13 to perform the operation F. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, the operands stored in the D12 latch 10 and D22 latch 12 are input to the second computing unit 14 to perform the operation G. The calculation result is stored in a general-purpose register of the register file 6 as necessary.
-DEC stage: Instruction 5
The contents of the I1 latch 2 whose accumulation bit is “1” (operation I when the accumulation bit is “1”) are taken into the IB 21 buffer 17. Specifically, since the accumulation bit is “1”, data is to be written to the IB11 buffer 15 or IB21 buffer 17, but since data has already been written to the IB11 buffer 15, the write signal generator 25 The write signal of the IB21 buffer 17 is enabled. Further, since the accumulated bit of the first slot of the instruction 5 stored in the I1 latch 2 is “1”, the nop generator 21 outputs nop, and the first instruction decoder 4 substantially does nothing at the EX stage. The decoding result that does not operate is output.

On the other hand, the second slot of the instruction 5 stored in the I2 latch 3 is decoded by the second instruction decoder 5. As a result of the decryption, it becomes clear that the operation is H. Based on this decoding, the general purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D12 latch 10 and the D22 latch 12. IF stage: IB2 buffer accumulation instruction Since the accumulation flags of the IB21 buffer 17 and the IB22 buffer 18 are both "1", the AND circuit 27 outputs "1" as data is accumulated in the accumulation buffer, and OR The circuit 29 outputs “1” to interrupt the instruction fetch. Thereby, the instruction fetch is interrupted. At the same time, since the accumulation bit of the IB11 buffer 15 is “0” (there is a possibility that an instruction accumulated in the IB2 buffer exists), the selectors 23 and 24 select and output the IB2 buffer. Furthermore, the I1 selector 19 and the I2 selector 20 select the IB21 buffer 17 and the IB22 buffer 18 according to the output of the OR circuit 29, respectively, and the accumulated instructions are stored in the I1 latch 2 and the I2 latch 3. As a result, since the instructions stored in the IB21 buffer 17 and the IB22 buffer 18 are used, the timing is adjusted by the clocked buffer 31, the contents of the IB21 buffer 17 and the IB22 buffer 18 are reset, and the accumulation flag is set. Set to “0”.

(Timing t8)-EX stage: Instruction 5
In the operation I, since the accumulation bit is “1” and the nop generator 21 invalidates the nop, the first arithmetic unit 13 does not operate. On the other hand, the operands stored in the D12 latch 10 and the D22 latch 12 are input to the second computing unit 14 to perform the operation H. The calculation result is stored in a general-purpose register of the register file 6 as necessary.
DEC stage: IB2 buffer accumulation instruction The first slot stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it becomes clear that it is operation I. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and D21 latch 11. On the other hand, the second slot stored in the I2 latch 3 is decoded by the second instruction decoder 5. The result of the decryption reveals that it is operation J. Based on this decoding, the general purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D12 latch 10 and the D22 latch 12.

(Timing t9) EX stage: IB2 buffer accumulation instruction Operands stored in the D11 latch 9 and D21 latch 11 are input to the first computing unit 13 to perform the operation I. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, the operands stored in the D12 latch 10 and the D22 latch 12 are input to the second computing unit 14 to perform the operation J. The calculation result is stored in a general-purpose register of the register file 6 as necessary.

3. Recording Medium As an embodiment of the recording medium of the present invention, a magnetic disk (flexible disk, hard disk, etc.), optical disk (CD-ROM, PD, etc.), magneto-optical disk, semiconductor memory (semiconductor memory ( ROM and flash memory).

  As described above, according to the present embodiment, the machine instruction compression unit 109 of the compiler extracts a pair of the nop code of the first slot and the nop code of the second slot in the same order, and the first of the nop code pairs is extracted. 1 slot and 2 slot are replaced with the operations of the first slot and the second slot of the pair of valid operations that appear first after the pair, respectively, and the pair of valid operations used for the replacement is deleted, thereby wasting in the instruction. The area is reduced, and the program size can be reduced.

  Further, according to the processor of the present embodiment, an IB1 buffer and an IB2 buffer for accumulating effective operations buried in the positions of scattered conventional nop codes are provided, and there are two effective operations in either the IB1 buffer or the IB2 buffer. By executing this when it is ready, it is possible to execute a compressed machine instruction program while maintaining the conventional processing performance.

  Furthermore, according to the present embodiment, since the effective operation in the same slot as the nop code is filled in the position of the conventional nop code, the operations are transferred between the first slot and the second slot. There is an effect that the configuration of the processor is simplified. Specifically, the operation of the I1 latch 2 is stored only in the IB11 buffer 15 or the IB21 buffer 17, and the operation stored in them is only returned to the I1 latch 2. Conversely, the operation of the I2 latch 3 is performed in the IB12 buffer 16 or Since only the IB22 buffer 18 is stored and the operations stored in the IB22 buffer 18 need only be returned to the I2 latch 3, no transfer path and transfer control means between the first slot and the second slot are required.

  In the processor of this embodiment, the I1 selector 19 and the I2 selector 20 are provided on the input side of the I1 latch 2 and the I2 latch 3, respectively, but are provided on the output side of the I1 latch 2 and the I2 latch 3, respectively. The inputs of the instruction decoder 4 and the second instruction 2 decoder 5 may be selected. In this case, the input to the IB1 buffer and the IB2 buffer must be changed to be performed directly from the ROM 1 in the IF stage. However, the input to the IB1 buffer and the IB2 buffer and the selection of the I1 selector 19 and the I2 selector 20 are selected. As with the present embodiment, the value of the accumulated bit may be controlled.

  Further, in the processor of the present embodiment, two storage buffers, the IB1 buffer and the IB2 buffer, are provided, but any number is possible. As the number of storage buffers increases, the opportunity to fill the nop code with valid operations increases, and the program size can be further reduced. For example, if there is no IB2 buffer in the processor of this embodiment, the nop code of the second slot of the instruction 3 in FIG. 5 is not filled with a valid operation.

(Embodiment 2)
The second embodiment is higher than the first embodiment in that the degree of freedom in filling the nop code slot in the effective operation is increased.

1. Compiler The configuration of the compiler is the same as that described in the first embodiment except for the operation of the machine instruction compression unit 109. The machine instruction compression unit 109 is shown in FIGS. 10 to 12 and operates based on the following principle.

  An uncompressed machine instruction program is searched in the order of instructions, and two nop codes whose appearance order is continuous regardless of either the first slot or the second slot are extracted. Replaced with the operations of the first slot and second slot of the first valid operation pair that appears first after the two nop codes, marking the replacement, and deleting the deleted valid operation pair that was used for the replacement Mark deleted in either the first slot or the second slot of the instruction immediately preceding the pair. That is, the nop is deleted for each slot in the compiler of the first embodiment, but the compiler in the present embodiment is unaware of the slot and replaces the nop with an effective operation in the order of appearance. For this reason, even if nop is concentrated in any slot, it can be replaced with an effective operation.

1.1 Example of Operation of Machine Instruction Compression Unit 109 FIG. 9 is an illustration of a compressed machine instruction program. The machine instruction compression unit 109 compresses the uncompressed machine instruction program of FIG. 5 according to the above procedure. It is. The compressed instruction is composed of first and second slots, and each slot includes a storage bit, a position bit, and an operation (OP) field. The symbols A through J indicate valid operations. The stored bits and position bits are encoded as follows.
00, 01 Do nothing 10 Should be stored in the IB1 buffer 11 Should be stored in the IB2 buffer Specifically, operation F and operation G of instruction 5 in FIG. , The operation I and operation J of the instruction 7 are filled in the nop code slots of the instruction 4 and the instruction 6, the accumulated bits of the filled slots are set to 01, and the instructions 5 and 7 are deleted. To do. Operation F, operation G, operation I, and operation J are assumed to be stored in this order in the first slot, the second slot, the first slot, and the second slot of the IB2 buffer, and are deleted. 10 is set in the accumulated bit of the second slot of the instruction 4 immediately before the instruction 5, and 11 is set in the accumulated bit of the second slot of the instruction 6 immediately before the deleted instruction 7. The accumulated bits of the other slots are 00. The machine instruction program generated in this way is shown in FIG. Note that the instruction 5 in FIG. 9 is generated from the instruction 6 in FIG.

  10 and FIG. 2 are different in that there is one nop counter (S501) and a position bit is set (S505). The reason why the number of nop counters is one is that in the present embodiment, unlike the first embodiment, it is not necessary to be aware of the slot. However, this nop counter is used for a completely different purpose from the nop counter of FIG. 2, and repeats “0” and “1” every time nop applies to determine the value of the position bit. .

  11 and 12 are basically the same as FIGS. 3 and 4, except that the position bit value is determined by a nop counter (S609, S709). Further, because of the use of the above-described nop count, C = 0 is also different when an instruction is deleted (S611, S711).

2. Processor FIG. 13 is a schematic configuration diagram of the IF stage portion of the processor.

  Portions not shown of the DEC stage and the EX stage have the same configuration as in FIG. 7, and the same components as those in the first embodiment are denoted by the same reference numerals. Compared with FIG. 7, the difference is that it has selectors 32 and 33. That is, depending on the value of the position bit, even if the instruction is stored in the I1 latch 2, even if the instruction is stored in the IB12 buffer 16 or IB22 buffer 18, the instruction is stored in the IB11 buffer 15 or IB21 buffer 17 even if the instruction is stored in the I2 latch 3. Can be stored, and nop can be further reduced as compared with the first embodiment. Since other operations are the same as those in the first embodiment, description thereof is omitted.

3. Recording Medium As an embodiment of the recording medium of the present invention, a magnetic disk (flexible disk, hard disk, etc.), an optical disk (CD-ROM, PD, etc.), a magneto-optical disk, a semiconductor memory (ROM) recording the machine instruction program of FIG. And flash memory).

  As described above, according to the present embodiment, the machine instruction compression unit 109 of the compiler extracts two nop codes whose appearance order is continuous regardless of either the first slot or the second slot, and this nop code The slot is replaced with the operation of the first slot and the second slot of the valid operation pair that appears first after the two nop codes, and the valid operation pair used for the replacement is deleted, thereby eliminating the waste area in the instruction. And the program size can be reduced.

  In addition, according to the processor of the present embodiment, an IB1 buffer and an IB2 buffer for accumulating valid operations buried in the positions of scattered conventional nop codes are provided, and the IB1 buffer stores the IB1 buffer in the instruction immediately before the position to be executed. By executing the accumulated operation by designating either the buffer or the IB2 buffer, it is possible to execute the compressed machine instruction program while maintaining the conventional processing performance.

  Furthermore, according to the present embodiment, since it is based on the idea that nop codes are filled with valid operations in the order of appearance regardless of the position of the slot, it is necessary to identify whether the nop code is in the first slot or the second slot This has the effect that the configuration of the compiler becomes simpler than that of the first embodiment.

  In the processor of this embodiment, the I1 selector 19 and the I2 selector 20 are provided on the input side of the I1 latch 2 and the I2 latch 3, respectively, but are provided on the output side of the I1 latch 2 and the I2 latch 3, respectively. The inputs of the decoder 4 and the second decoder 5 may be selected. In this case, the input to the IB1 buffer and the IB2 buffer is changed to be performed directly from the ROM 1 in the IF stage, and the IB1 selector 31 and the IB2 selector 32 are controlled by the value of the stored bit of the instruction read from the ROM 1 However, it is only necessary to control the fetching into the IB1 buffer and the IB2 buffer and the selection of the I1 selector 19 and the I2 selector 20 with the value of the accumulated bit as in this embodiment.

  Further, in the processor of the present embodiment, two storage buffers, the IB1 buffer and the IB2 buffer, are provided, but any number is possible. As the number of storage buffers increases, the opportunity to fill the nop code with valid operations increases, and the program size can be further reduced. For example, if there is no IB2 buffer in the processor of the present embodiment, the nop code of the first slot of the instruction 4 in FIG.

(Embodiment 3)
The third embodiment is a VLIW architecture compiler and processor that execute three operations in parallel with an instruction having only two slots.

1. Compiler The configuration of the compiler is the same as that described in the first embodiment except for the operations of the machine instruction generation unit 107 and the machine instruction compression unit 109. The machine instruction generation unit 107 inputs the intermediate code stored in the intermediate code buffer 106, schedules an instruction for the purpose of three-parallel execution of the instruction (in the first embodiment, two-parallel execution), and performs uncompressed A machine instruction program is generated and written to the temporary output buffer 108. The machine instruction compression unit 109 operates based on the following principle.

  An uncompressed machine instruction program is searched in the order of instructions, and three nop codes whose appearance order is continuous regardless of either the first slot or the second slot except the third slot are extracted. The slot is replaced with the first to third slot operations of the designated instruction, and the three valid operations appearing first after the three nop codes are marked, and the 3 used for the replacement Instructions with one valid operation are deleted and marked as deleted in either the first slot or the second slot of the instruction immediately preceding the deleted pair.

1.1 Example of Operation of Machine Instruction Compression Unit 109 FIG. 15 is an exemplary diagram of a compressed machine instruction program. The machine instruction compression unit 109 compresses the uncompressed machine instruction program of FIG. 14 according to the above procedure. It is. The compressed instruction is composed of first and second slots, and each slot includes two storage bits and an operation (OP) field. Symbols A through H indicate valid operations. Two bits, the accumulation bit (left side) and the execution bit (right side) are encoded as follows.
00 Do nothing 10 The operation has been replaced, and the IB buffer should be stored sequentially in the order of the first, second, and third slots. 01 The instruction immediately after is deleted, so the IB buffer instruction should be executed. 11 (Unused)
Specifically, operation F, operation G, and operation H of instruction 5 in FIG. 14 are filled in the slot of nop code of the second slot of instruction 1, the second slot of instruction 3, and the first slot of instruction 4. The accumulated bits of the slots that have been filled are set to 01, and the instruction 5 is deleted. Operation F, operation G, and operation H are assumed to be stored in the first slot, the second slot, and the third slot of the IB buffer in this order, and the instruction 4 of the instruction 4 immediately before the deleted instruction 5 is stored. The accumulation bit of 2 slots is set to “1” and the execution bit is set to “0”. The storage bits of other slots are set to “0” and the execution bits are set to “0”. The machine instruction program generated in this way is shown in FIG. The “IB buffer” will be described next.

2. Processor FIG. 16 is a schematic configuration diagram of a processor.

  Compared to FIG. 7, in order to execute three operations in parallel with an instruction having only two slots, the instructions in the two slots are stored in the three buffers including the IB3 buffer 41 so that the instructions in the three slots are internally stored. To convert. It has an I3 latch 38 for giving an instruction of the third slot, a nop generator 39, and a third instruction decoder 40, and further, a D3 selector 34, D13 for executing the instruction of the third slot The difference is that a latch 35, a D23 latch 36, and a third arithmetic unit 37 are provided. The ring counter 42 enables write signals in the IB1 buffer 15, IB2 buffer 16, and IB3 buffer 41 in order.

2.1 Example of Processor Operation Hereinafter, the operation of the processor having the above configuration when the machine instruction program of FIG. 15 is stored in the ROM 1 will be described with reference to FIG.

  FIG. 17 is an operation timing chart of the processor when the machine instruction program of FIG. 15 is stored in the ROM 1. The figure shows the timing at which a processor operation is read from the ROM 41 at the IF stage of the pipeline, an instruction decoded at the DEC stage, an instruction executed at the EX stage, and an instruction held in the IB buffer is called a machine cycle. Shown for each. Hereinafter, the operation will be described for each timing in the order in which time passes. In the figure, “:” indicates a slot delimiter, the left indicates the first slot, the center indicates the second slot, and the right indicates the third slot, and “−” indicates that a valid operation is not held or acts. It means not.

(Timing t1)
As an initial state, it is assumed that the IB1 buffer 15, the IB2 buffer 16, and the IB3 buffer 41 are reset and (0... 00) ₂ are stored in each. The ring counter 42 is also set to (001) ₂ as an initial state, and when the first operation with the accumulated bit “1” is stored in the I1 latch 2 or the I2 latch 3, it becomes (100) ₂ and the IB1 buffer 15 Operations will be accumulated.
-IF stage: Instruction 1
The instruction 1 is read from the ROM 1, and the first slot (operation A) is stored in the I 1 latch 2 and the second slot (operation F) is stored in the I 2 latch 3. In the I3 latch 38, (0... 00) ₂ of the IB3 buffer 41 is stored.

(Timing t2)-DEC stage: Instruction 1
The contents (operation F) of the I2 latch 3 whose accumulation bit is “1” are taken into the IB1 buffer 15. More specifically, since the ring counter 42 outputs (100) ₂ because the storage bit is the first operation of “1”, the write signal of the IB1 buffer 15 is enabled, and the content of the I2 latch 3 is changed to the IB1 buffer 15. Accumulated in.

The first slot of the instruction 1 stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it becomes clear that the operation is A. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and D21 latch 11. On the other hand, since the accumulated bit of the second slot of the instruction 1 stored in the I2 latch 3 is “1”, the nop generator 22 outputs nop, and the second instruction decoder 5 does not substantially do anything at the EX stage. The decoding result that does not operate is output. In addition, since it is not necessary to operate the third arithmetic unit 37 except when executing instructions in three slots, when the execution bit is “0”, the nop generator 39 outputs nop.
-IF stage: Instruction 2
The instruction 2 is read from the ROM 1, and the first slot (operation B) is stored in the I 1 latch 2 and the second slot (operation C) is stored in the I 2 latch 3. The (0... 00) _{2 of the} IB3 buffer 41 is stored in the I3 latch 31 again.

(Timing t3)-EX stage: Instruction 1
The operands stored in the D11 latch 9 and D21 latch 11 are input to the first computing unit 13 to perform the operation A. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, the second computing unit 14 and the third computing unit 37 do not work because they are invalidated by the nop generators 22 and 39.
-DEC stage: Instruction 2
The first slot of the instruction 2 stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it becomes clear that it is operation B. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and D21 latch 11. On the other hand, the second slot of the instruction 2 stored in the I2 latch 3 is decoded by the second instruction decoder 5. The result of the decryption reveals that it is operation C. Based on this decoding, the general purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D12 latch 10 and the D22 latch 12. Since the execution bit of the I3 latch 38 is “0”, the nop generator 39 outputs nop, and the third instruction decoder 40 outputs a decoding result that does not perform any operation at the EX stage. To do.
-IF stage: Instruction 3
Instruction 3 is read from ROM 1 and the first slot (accumulation D is (00) ₂ and operation D) is stored in I1 latch 2, and the second slot (accumulation bit is (01) ₂ and operation G) is stored in I2 latch 3. Is done. In the I3 latch 38, (0... 00) _{2 of the} IB3 buffer 41 is stored again.

(Timing t4)-EX stage: Instruction 2
The operands stored in the D11 latch 9 and the D21 latch 55 are input to the first arithmetic unit 13 to perform the operation B. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, the operands stored in the D12 latch 11 and the D22 latch 12 are input to the second computing unit 14 to perform the operation C. The calculation result is stored in a general-purpose register of the register file 6 as necessary. Further, the third computing unit 37 does not work because it is invalidated by the nop generator 39.
-DEC stage: Instruction 3
The contents (operation G) of the I2 latch 3 whose accumulated bit is (10) ₂ are taken into the IB2 buffer 16. Specifically, the operation is almost the same as the timing t1, but since the operation F has already been accumulated in the IB1 buffer 15, the ring counter 42 outputs (010) ₂ to write to the IB2 buffer 16. The signal is enabled and the operation is stored in the IB2 buffer 16.

The first slot of the instruction 3 stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it is proved to be operation D. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and the D21 latch 55. On the other hand, since the accumulated bit of the second slot of the instruction 3 stored in the I2 latch 3 is “1”, the nop generator 22 outputs nop, and the second instruction decoder 5 is substantially not in the EX stage. The decoding result that does not operate is output. Since the execution flag is “0”, the nop generator 39 outputs nop, and the third instruction decoder 40 outputs a decoding result that does not perform any operation at the EX stage.
-IF stage: Instruction 4
The instruction 4 is read from the ROM 1, and the first slot (operation H) is stored in the I 1 latch 2 and the second slot (operation E) is stored in the I 2 latch 3. In the I3 latch 38, (0... 00) _{2 of the} IB3 buffer 41 is stored again.

(Timing t5)-EX stage: Instruction 3
The operands stored in the D11 latch 9 and the D21 latch 55 are input to the first arithmetic unit 13 to perform the operation D. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, the second computing unit 14 and the third computing unit 37 do not work because they are invalidated by the nop generators 22 and 39.
-DEC stage: Instruction 4
The contents (operation H) of the I1 latch 2 whose accumulation bit is “1” are taken into the IB3 buffer 41. At this time, since the operations are already stored in the IB1 buffer 15 and the IB2 buffer 16, the ring counter 42 outputs (001) ₂ to enable the write signal of the IB3 buffer 41, and the operation to the IB3 buffer 41 is performed. Accumulated. Further, since the accumulated bit of the first slot of the instruction 4 stored in the I1 latch 2 is “1”, the nop generator 21 outputs nop, and the first instruction decoder 4 substantially does nothing at the EX stage. The decoding result that does not operate is output.

On the other hand, the second slot of the instruction 4 stored in the I2 latch 3 is decoded by the second instruction decoder 5. As a result of the decryption, it becomes clear that it is operation E. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D12 latch 11 and the D22 latch 12. Since the execution flag is “0”, the nop generator 39 outputs nop, and the third instruction decoder 40 outputs a decoding result that does not perform any operation at the execution stage.
IF stage: IB buffer accumulation instruction Since the execution bit of the second slot of the instruction 4 stored in the I2 latch 3 is “1”, the instruction fetch control unit interrupts the instruction fetch. At the same time, the I1 selector 19 and the I2 selector 20 select the IB1 buffer 15 and the IB2 buffer 16, respectively, and the contents of the IB1 buffer 15, IB2 buffer 16, and IB3 buffer 41 are stored in the I1 latch 2, I2 latch 3, and I3 latch 38, respectively. Stored. When the execution bit of the I3 latch 38 becomes “1”, the contents of the IB buffer are reset.

(Timing t6)-EX stage: Instruction 4
The first calculator 13 and the third calculator 37 do not work because they are invalidated by the nop generator 21 and the nop generator 39. On the other hand, the operands stored in the D12 latch 10 and the D22 latch 12 are input to the second computing unit 14 to perform the operation E. The calculation result is stored in a general-purpose register of the register file 6 as necessary.
DEC stage: IB buffer storage instruction The first slot stored in the I1 latch 2 is decoded by the first instruction decoder 4. As a result of the decryption, it becomes clear that it is operation F. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D11 latch 9 and the D21 latch 55. On the other hand, the second slot stored in the I2 latch 3 is decoded by the second instruction decoder 5. As a result of the decryption, it is proved to be operation G. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D12 latch 11 and the D22 latch 12. The third slot stored in the I3 latch 3 is decoded by the third instruction decoder 40. That is, since the execution bit is “1”, the nop generator 39 outputs the contents of the I3 latch 38 as it is, and it becomes clear that the operation is H as a result of decoding. Based on this decoding, the general-purpose register is read from the register file 6 and the read value or the constant value in the instruction is stored in the D13 latch 35 and D23 latch 36.

(Timing t7) EX stage: IB buffer accumulation instruction Operands stored in the D11 latch 9 and D21 latch 55 are input to the first computing unit 13 to perform the operation F. The calculation result is stored in a general-purpose register of the register file 6 as necessary. On the other hand, the operands stored in the D12 latch 11 and D22 latch 12 are input to the second computing unit 14 to perform the operation G. The calculation result is stored in a general-purpose register of the register file 6 as necessary. The operands stored in the D13 latch 35 and the D23 latch 36 are input to the third calculator 37 to perform the operation H. The calculation result is stored in a general-purpose register of the register file 6 as necessary.

3. Recording Medium As an embodiment of the recording medium of the present invention, a magnetic disk (flexible disk, hard disk, etc.), an optical disk (CD-ROM, PD, etc.), a magneto-optical disk, a semiconductor memory (ROM) recording the machine instruction program of FIG. And flash memory).

  As described above, according to the present embodiment, the machine instruction compression unit 109 of the compiler extracts three nop codes whose appearance order is continuous regardless of any of the first slot and the second slot except the third slot. Then, the slots of these nop codes are replaced with the operations of the first slot to the third slot of the instruction in which the three valid operations appearing first after the three nop codes are designated, and the three used for the replacement are replaced. By deleting an instruction for which a valid operation is specified, a useless area in the instruction is reduced, and a program size can be reduced. In particular, according to the present embodiment, since it is possible to execute a conventional three-slot instruction with three slots by using a two-slot instruction using a slot with a conventional nop code, the code efficiency is extremely high. Is expensive. In the operation example shown above, it can be seen that 3 slots × 5 instructions = 15 slots in FIG. 12 are compressed into 2 slots × 4 instructions = 8 slots in FIG.

  Further, according to the processor of the present embodiment, an IB buffer for storing valid operations buried in the positions of scattered conventional nop codes is provided, and the IB buffer is designated by the storage bit in the instruction immediately before the position to be executed. By executing the accumulated operations, it is possible to execute the compressed machine instruction program while maintaining the conventional processing performance.

  In the processor of this embodiment, the I1 selector 19 and the I2 selector 20 are provided on the input side of the I1 latch 2 and the I2 latch 43, respectively, but are provided on the output side of the I1 latch 2 and the I2 latch 3, respectively. The inputs of the instruction interrupter 4 and the second instruction decoder 4 may be selected. In this case, the input to the IB buffer must be changed so as to be performed directly from the ROM 1 in the IF stage, and the IB selector 66 must be controlled according to the value of the accumulated bit of the instruction read from the ROM 1. However, the loading into the IB buffer and the selection of the I1 selector 19 and the I2 selector 20 may be controlled by the value of the accumulated bit as in this embodiment.

  In the processor of this embodiment, one storage buffer called an IB buffer is provided, but a plurality of storage buffers may be provided. As the number of storage buffers increases, the opportunity to fill the nop code with valid operations increases, and the program size can be further reduced.

  Furthermore, in the processor of the present embodiment, three instruction decoders and three arithmetic units are provided to achieve a maximum of three parallel executions, but four of these may be provided and four parallel executions may be performed, Or more than that. In the case of four parallel executions, as in the present embodiment, four slots that become nop codes may be used when an instruction consisting of two slots is uncompressed, and valid operations may be filled. The valid operation may be filled using four slots that become nop codes when not compressed. However, in the former case, it is necessary to provide more IB buffers for one slot. The former is effective when the number of slots that become nop codes when uncompressed is very large compared to the latter, and a considerable improvement in code efficiency can be expected. By doing so, the increase in nop code can be greatly reduced even if the parallelism of instructions in the VLIW processor is improved.

(Embodiment 4)
The fourth embodiment is different from the third embodiment in that only the operation of the third slot is filled in the slot of the nop code of the first or second slot.

1. Compiler The configuration of the compiler is the same as that described in the third embodiment except for the operation of the machine instruction compression unit 109. The machine instruction compression unit 109 operates based on the following principle.

  An uncompressed machine instruction program is searched in the order of instructions, one nop code is extracted regardless of any of the first slot and the second slot excluding the third slot, and the slot of the nop code is defined as the nop code. The third slot appearing first after this is replaced with the operation of the instruction in which the valid operation is specified, marking the replacement, and deleting the third slot of the instruction in which the valid operation used for the replacement is specified, The deletion is marked in either the first slot or the second slot of the instruction.

1.1 Example of Operation of Machine Instruction Compression Unit 109 FIG. 18 is an exemplary diagram of a compressed machine instruction program. The machine instruction compression unit 109 compresses the uncompressed machine instruction program of FIG. 12 according to the above procedure. It is. The compressed instruction is composed of first and second slots, and each slot includes two storage bits and an operation (OP) field. Symbols A through H indicate valid operations, and nop indicates nop codes that are not valid. The two stored bits are encoded as follows.
00 No action 01 The operation has been replaced and should be stored in the IB buffer 10 Since the third slot has been deleted, the IB buffer operation should be executed in the third slot 11 (unused)
More specifically, the operation H of the instruction 5 in FIG. 14, which is the operation placed in the third slot, is buried in the slot of the nop code of the second slot of the instruction 1, and the accumulated bit of the filled slot is 01. And the third slot of instruction 5 is deleted. Operation H is premised on the accumulation in the IB buffer, and 10 is set in the accumulation bit of the second slot of the instruction 5 in which the third slot is deleted (even if the accumulation bit of the first slot is Good). The accumulated bits of the other slots are 00. The machine instruction program generated in this way is shown in FIG. Here, the nop codes of the second slot of instruction 3 and the first slot of instruction 4 remain without being replaced. The “IB buffer” will be described next.

2. Processor FIG. 19 is a schematic configuration diagram of the IF stage portion of the processor.

  Portions not shown of the DEC stage and the EX stage have the same configuration as in FIG. 16, and the same components as those in FIG. 16 are denoted by the same reference numerals. This processor differs from that shown in FIG. 14 in that it has only one IB buffer 50. Therefore, as compared with FIG. 16, one IB buffer is sufficient, and selectors 41 and 42 for accumulating data in the three buffers from the left are not required, and the circuit can be simplified. Since the operation is the same as that of the third embodiment except that the storage destination is fixed to the IB buffer 50, the description thereof is omitted.

3. Recording Medium As an embodiment of the recording medium of the present invention, a magnetic disk (flexible disk, hard disk, etc.), an optical disk (CD-ROM, PD, etc.), a magneto-optical disk, a semiconductor memory (ROM) recording the machine instruction program of FIG. And flash memory).

  As described above, according to the present embodiment, the machine instruction compression unit 109 of the compiler extracts one nop code regardless of either the first slot or the second slot except the third slot, and this nop code. Is replaced with the operation of the instruction in which the valid operation is designated in the third slot appearing first after the nop code, and the third slot of the instruction in which the valid operation used for the replacement is designated is deleted. The useless area in the instruction is reduced, and the program size can be reduced. In particular, according to the present embodiment, since it is possible to execute a conventional three-slot instruction with three slots by using a two-slot instruction using a slot with a conventional nop code, the code efficiency is extremely high. Is expensive. In the operation example shown above, it can be seen that 3 slots × 5 instructions = 15 slots in FIG. 12 are compressed into 2 slots × 5 instructions = 10 slots in FIG.

  In addition, according to the processor of the present embodiment, an IB buffer for accumulating valid operations buried in the position of the conventional nop code is provided, and the IB buffer is specified by the accumulation bit in the instruction and stored with the operation of the instruction. By executing the operations in parallel, it is possible to execute a compressed machine instruction program while maintaining the conventional processing performance.

  In the processor of this embodiment, one storage buffer called an IB buffer is provided, but a plurality of storage buffers may be provided. As the number of storage buffers increases, the opportunity to fill the nop code with valid operations increases, and the program size can be further reduced. For example, the nop code of the second slot of instruction 3 and the first slot of instruction 4 remains without being replaced, but a valid operation is placed in the third slot immediately after instruction 5 of uncompressed (FIG. 14). If one instruction follows, or two follow, one or both of these nop codes can be filled with valid operations, respectively.

  Furthermore, in the processor of the present embodiment, three instruction decoders and three arithmetic units are provided to achieve a maximum of three parallel executions, but four of these may be provided and four parallel executions may be performed, Or more than that. In the case of 4-parallel execution, as in the present embodiment, two slots that become nop codes may be used when an instruction consisting of two slots is uncompressed, and valid operations may be filled. A valid operation may be filled using one slot that becomes a nop code when uncompressed. However, in the former case, it is necessary to provide more IB buffers for one slot. The former is effective when the number of slots that become nop codes when uncompressed is very large compared to the latter, and a considerable improvement in code efficiency can be expected. By doing so, the increase in nop code can be greatly reduced even if the parallelism of instructions in the VLIW processor is improved.

As mentioned above, although the compiler and processor concerning this invention were demonstrated based on said 4 embodiment, of course, this invention is not limited to these embodiment. That is,
(1) In the above-described four embodiments, the architecture is a VLIW format in which two or three operations are specified in one instruction. However, an architecture other than the VLIW format in which one operation is specified by one instruction may be used.

  In particular, in the case of fixed-length instructions, many instructions having unused areas may be defined. For example, the processor “R3000” based on the MIPS RISC architecture executes a 32-bit fixed-length instruction. The arithmetic instruction of this processor is a 12-bit operation field (“op1” and “op2” as shown in FIG. 23A). ) And three 5-bit register fields (source operands “rs” and “rt” and destination operand “rd”), and 5 bits of “res”. Has a use area. According to the present invention, it is possible to avoid occurrence of a waste area that occurs during such a single operation instruction. Specifically, as shown in FIG. 23B, the compiler divides one instruction to be executed after the instruction F by using the unused areas a to f of the six instructions A to F. The instruction is deleted, this instruction is deleted, these are stored in order in an instruction storage register provided in the processor, and the contents of this register are executed after the instruction F is executed. By doing so, the useless area in the program is eliminated and the code efficiency is improved. The contents of the instruction storage register may be executed not immediately after the instruction F but after execution of another instruction following the instruction F, or may be executed in parallel with the instruction F. In particular, the latter idea is useful because it is possible to realize a VLIW-type architecture that specifies two operations although it is local in an architecture that does not specify a single operation with a single instruction. Further, by providing a plurality of such instruction storage registers, it is possible to realize a VLIW architecture of three or more parallels. Note that the six instructions A to F do not necessarily have to be continuous without gaps.

  (2) In the above four embodiments, the instruction storage register (IB1 buffer, IB2 buffer, and IB buffer is equivalent) is read and erased at the same time, but is read and reused multiple times without being erased. May be. For example, the third and fourth embodiments do not use the state where the two accumulated bits are 11, so this is used, and when the accumulated bit is 11, the IB buffer is executed without being erased. It can be. By doing so, for example, when the program repeatedly executes the same instruction that constitutes a loop, it is not necessary to repeatedly store the same instruction in the IB buffer many times, and the code efficiency is further improved. It is also possible to provide two types of instruction storage registers, one whose contents are erased immediately after reading and one which can be reused without being erased.

  (3) In the above-described four embodiments, in the compiler, the machine instruction generation unit 107 once generates the same machine instruction program as before, and then the machine instruction compression unit 109 compresses the machine instruction program. The target compressed machine instruction program may be directly generated without generating the same machine instruction program as the conventional one.

  (4) The processors of the above four embodiments are configured by a three-stage pipeline of instruction fetch, decoding, and execution. However, the number of pipeline stages may be any number, and a pipeline is adopted. Not necessary.

The block diagram which shows the structure of the compiler which concerns on Embodiment 1 The flowchart which showed the processing flow of the machine instruction compression part 109 of the compiler which concerns on Embodiment 1 The flowchart which showed the processing flow of the machine instruction compression part 109 of the compiler which concerns on Embodiment 1 The flowchart which showed the processing flow of the machine instruction compression part 109 of the compiler which concerns on Embodiment 1 Example of uncompressed machine instruction program Exemplary diagram of a compressed machine instruction program according to the first embodiment Schematic configuration diagram of a processor according to the first embodiment Operation timing chart corresponding to the machine instruction program of FIG. 6 of the processor according to the first embodiment. Exemplary diagram of compressed machine instruction program according to Embodiment 2 The flowchart which showed the processing flow of the machine instruction compression part 109 of the compiler which concerns on Embodiment 2. FIG. The flowchart which showed the processing flow of the machine instruction compression part 109 of the compiler which concerns on Embodiment 2. FIG. The flowchart which showed the processing flow of the machine instruction compression part 109 of the compiler which concerns on Embodiment 2. FIG. Schematic configuration diagram of the IF stage part of the processor according to the second embodiment Example of uncompressed machine instruction program Exemplary diagram of compressed machine instruction program according to Embodiment 3 Schematic configuration diagram of a processor according to Embodiment 3 Operation timing chart corresponding to the machine instruction program of FIG. 13 of the processor according to the third embodiment. Exemplary diagram of compressed machine instruction program according to Embodiment 4 Schematic configuration diagram of the IF stage part of the processor according to the embodiment Operation Timing Diagram Corresponding to Machine Instruction Program in FIG. 16 of Processor according to Embodiment 4 1 is a schematic configuration diagram of a processor in the first prior art Schematic configuration diagram of the processor in the second prior art Instruction Format of Instructions According to Other Prior Art and Other Embodiments

Explanation of symbols

1, 41 ROM
2, 42 I1 latch 3, 43 I2 latch 4, 45 First instruction decoder 5, 46 Second instruction decoder 6, 48 Register file 7, 49 D1 selector 8, 50 D2 selector 9, 52 D11 latch 10, 53 D12 Latch 11, 55 D21 latch 12, 56 D22 latch 13, 58 First computing unit 14, 59 Second computing unit 15, 33 IB11 buffer 16, 34 IB12 buffer 17, 35 IB21 buffer 18, 36 IB22 buffer 19, 64 I1 selector 20, 65 I2 selector 21, 37, 67, 72 Control circuit 31 IB1 selector 32 IB2 selector 44 I3 latch 47 Third instruction decoder 51 D3 selector 54 D13 latch 57 D23 latch 60 Third arithmetic unit 61 IB1 buffer 62 IB2 buffer 63 IB3 bar Buffer 66 IB selector 71 IB buffer 101 C language program 102 Compiler 103 File reading unit 104 Reading buffer 105 Syntax analysis unit 106 Intermediate code buffer 107 Machine instruction generation unit 108 Temporary output buffer 109 Machine instruction compression unit 110 Output buffer 111 File output unit 112 Machine instruction program

Claims (6)

In a processor that simultaneously executes instructions in multiple slots in parallel,
A processor which stores an instruction once in an accumulation buffer based on a value of an accumulation bit in the instruction and then executes the instruction accumulated in the accumulation buffer. In a processor that simultaneously executes instructions in multiple slots in parallel,
A storage buffer for storing the instructions;
The instruction has a storage bit that controls whether the instruction is executed immediately or stored once;
A processor which stores an instruction once in an accumulation buffer based on a value of an accumulation bit in the instruction and then executes the instruction accumulated in the accumulation buffer. In a processor that simultaneously executes instructions in multiple slots in parallel,
A storage buffer for storing the instructions;
The instruction has an accumulation bit that controls whether the instruction is executed immediately or is temporarily accumulated, and a position bit that controls which accumulation buffer is accumulated.
A processor, wherein the instruction is temporarily stored in the accumulation buffer based on the value of the accumulation bit and the position bit in the instruction, and then the instruction accumulated in the accumulation buffer is executed. In a processor that simultaneously executes instructions in multiple slots in parallel,
Having more storage buffers than the number of slots for storing the instructions;
The instruction has a storage bit that controls whether the instruction is executed immediately or stored once;
A processor which stores an instruction once in an accumulation buffer based on a value of an accumulation bit in the instruction and then executes the instruction accumulated in the accumulation buffer. A recording medium recording machine instructions to be executed by a processor,
The machine instruction includes a plurality of operation descriptions and a storage bit for controlling whether the instruction is immediately executed or stored. A recording medium recording machine instructions to be executed by a processor,
The machine instruction includes a plurality of operation descriptions, an accumulation bit for controlling whether the instruction is immediately executed or accumulated, and a position bit indicating where the instruction is accumulated. .

Images