|Publication number||US7200738 B2|
|Application number||US 10/125,331|
|Publication date||Apr 3, 2007|
|Filing date||Apr 18, 2002|
|Priority date||Apr 18, 2002|
|Also published as||US7734899, US8006072, US8612728, US20030200421, US20070150706, US20100228953, US20110296144, US20140101415|
|Publication number||10125331, 125331, US 7200738 B2, US 7200738B2, US-B2-7200738, US7200738 B2, US7200738B2|
|Inventors||Neal Andrew Crook, Alan T Wootton, James Peterson|
|Original Assignee||Micron Technology, Inc.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (10), Referenced by (11), Classifications (13), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This invention relates to pipelined computer processors. More particularly, this invention relates to pipelined computer processors that reduce data hazards to provide high processor utilization.
A processor, also known as a central processing unit, processes a set of instructions from a stored program. The processing of an instruction is typically divided into multiple stages, where each stage generally requires one clock cycle to complete and typically requires different hardware within the processor.
For example, the processing of an instruction can be divided into the following stages: fetch, decode, execute, and write-back. At the fetch stage, the processor retrieves an instruction from memory. The instruction is typically encoded as a string of bits that represent input information (e.g., operands), an operation code (“opcode”), and output information (e.g., a destination address). An opcode represents an arithmetic or logic function associated with the operands. Once the instruction is retrieved from memory, a program counter is either incremented for linear program execution or updated to show a branch destination. The program counter contains a pointer to an address in memory from which a next instruction is fetched. At the decode stage, the processor decodes the instruction into an opcode, operands, and a destination. The opcode can include one of the following: add, subtract, multiply, divide, shift, load, store, loop, branch, etc. The operands, depending on the opcode, can be constants, values stored at one or more memory addresses, or the contents of one or more registers. The destination can be a register or a memory address where a result produced from execution of the opcode is stored. At the execute stage, the processor executes the decoded opcode using the operands. For instructions such as add and subtract, the execute stage typically requires one clock cycle. For more complicated instructions, such as multiply and divide, the execute stage typically requires more than one clock cycle. At the write-back stage, the processor stores the result from the execute stage at the specified destination.
Pipelining is a known technique that improves processor performance by overlapping the execution of instructions such that different instructions are in each stage of the pipeline during a same clock cycle. For example, while a first instruction is in the write-back stage, a second instruction can be in the execute stage, a third instruction can be in the decode stage, and a fourth instruction can be in the fetch stage. In an ideal situation, one instruction completes processing each clock cycle, and processor utilization is 100%. Processor utilization can be determined by dividing the number of program instructions that complete processing by the number of clock cycles in which those instructions complete processing.
Although pipelining can increase throughput (the number of instructions executed per unit time), it increases instruction latency (the time to completely process an instruction). Increases in throughput are restricted by data hazards. A data hazard is a dependence of one instruction on another instruction. An example is a load-use hazard, which occurs when the result of one instruction is needed as input for a subsequent instruction. Instructions (1) and (2) below illustrate a load-use hazard. R0, R1, R2, R3, and R4 represent register contents.
In the four-stage pipeline described above, the result of instruction (1) is stored in register R0 and is available at the end of the write-back stage. Data dependent instruction (2) needs the contents of register R0 at the beginning of the decode stage. If instruction (2) is immediately subsequent to instruction (1) or is separated from instruction (1) by only one instruction, instruction (2) will retrieve an old value from register R0.
Software techniques that do not require hardware control for reducing such data hazards are known. One technique eliminates data hazards by exploiting instruction-level parallelism to reorder instructions. To eliminate a data hazard, an instruction and its associated data-dependent instruction are separated by sufficient independent instructions such that a result from the first instruction is available to the data-dependent instruction by the start of the data-dependent instruction's decode stage. However, there is a limit to the amount of instruction-level parallelism possible in a program and, therefore, a limit to the extent that data hazards can be eliminated by instruction reordering.
Data hazards that cannot be eliminated by instruction reordering can be eliminated by introducing one or more null (i.e., no-operation or nop) instructions immediately before the data-dependent instruction. Each nop instruction, which advances in the pipeline, simply delays the processing of the rest of the program by a clock cycle. The addition of nop instructions increases program size and total program execution time, which decreases utilization (since nop instructions do not process any data). For example, when each instruction is data-dependent on an immediately preceding instruction (such that the instructions cannot be reordered), two nop instructions should be inserted between each program instruction (e.g., A . . B . . C, where each letter represents a program instruction and each “.” represents a nop instruction). The utilization becomes less than 100% for a processor running in steady state (e.g., for instructions A, B, and C, the utilization is 3/7 or 43%; for nine similar instructions, the utilization is 9/25 or 36%), which does not take into account priming or draining. Priming is the initial entry of instructions into the pipeline and draining is the clearing of instructions from the pipeline.
In addition to software techniques, hardware techniques, such as “data forwarding,” are known. Without data forwarding, the result of an instruction, which is known at the end of the execute stage, is not available as input to another instruction until the end of the write-back stage. Data forwarding forwards that result one cycle earlier so that the result is available as input to another instruction at the end of the execute stage. With data forwarding, an instruction only needs to be separated from a data-dependent instruction by one independent instruction or one nop instruction. For example, in hardware, a state register R0 can hold a register value X. Without data forwarding, a new value Y can be written into R0 during a cycle n (e.g., a write-back stage) such that Y is available at a next cycle (n+1). Because the new value Y may be needed by an instruction in cycle n, control logic associated with data forwarding enables a multiplexer to output the new result Y, making Y available for another instruction one cycle earlier (cycle n). While data forwarding advantageously provides data one cycle earlier (which improves processor utilization), data forwarding hardware requires additional circuit area which increases cost. Data forwarding also increases hardware complexity, which increases design and verification time.
Furthermore, many hazards cannot be resolved by data forwarding (e.g., cases in which a new value cannot be forwarded). In these instances, stalling the pipeline is an alternative hardware method. Stalling allows instructions ahead of a data-dependent instruction to proceed while the processing of that data-dependent instruction is stalled. Once the hazard is resolved, the stalled section of the pipeline is restarted. Stalling the pipeline is analogous to the software technique of introducing nop instructions, except that the hardware stalling technique is automatic and avoids increasing program size. However, stalling also reduces performance and thus utilization.
In view of the foregoing, it would be desirable to provide a pipelined processor that reduces data hazards such that high processor utilization is attained.
It is an object of this invention to provide a pipelined processor that reduces data hazards such that high processor utilization is attained.
In accordance with this invention, a processor is provided that uses a restructured set of instructions such that the instructions operate concurrently on multiple pieces of data in multiple passes. A pass is a number of clock cycles in which a subset of instructions operates on a piece of data. In each pass, the same set of instructions operates concurrently on different pieces of data. To attain high processor utilization, the processor is pipelined in two ways. First, the processor preferably has a conventional hardware pipeline in which the execution of an instruction is divided into a number of stages that are overlapped with the stages of other instructions. Second, a piece of data is “software pipelined” in multiple passes by the processor.
Software pipelining in accordance with the invention involves restructuring a set of instructions (e.g., by a compiler) by first reordering instructions to minimize data hazards and then by adding no-operation (nop) instructions to eliminate as many remaining data hazards as possible. The set of instructions is then divided into multiple subsets of instructions, where each is subset of instructions operates on a same piece of data in different consecutive passes. While one subset of instructions operates on a piece of data, a different subset of instructions operates on a different piece of data in the same pass. For example, in a first pass, a first subset of instructions operates on a first piece of data. In the next pass, a second subset of instructions operates on the first piece of data and the first subset of instructions operates on a second piece of data, and so on until all subsets of instructions are operating on data concurrently.
At the beginning and end of the program, the software pipeline is primed and drained, respectively. Priming involves the entry of the first piece of data into the pipeline. When the first subset of instructions starts to process the first piece of data, all other subsets of instructions have no valid data to process and so these instructions act as nops. As each new piece of data starts to be processed, additional subsets of instructions begin to perform useful work and the number of nop instructions decreases until the processor preferably runs at maximum (e.g., 100%) utilization with an instruction exiting the pipeline every clock cycle. Draining involves the clearing of the final piece of data out of the pipeline. As each subset of instructions completes processing the final piece of data, that subset of instructions continues by executing nop instructions until program execution is complete. During priming and draining, the software pipeline runs at less than maximum utilization with only some subsets of instructions processing valid data in a pass. After priming and before draining, the software pipeline preferably runs at maximum utilization as each subset of instructions operates on a different piece of data in the pipeline. As more pieces of data are processed, the overhead of priming and draining the software pipeline becomes smaller and the overall performance of the processor (which includes priming and draining) approaches maximum utilization.
The invention includes a “LOOP” mechanism that allows a program to loop (i.e., to start a new pass). The LOOP mechanism can be implemented explicitly (e.g., by having a LOOP instruction encoded as one of the instructions in the program executed by the processor) or implicitly (e.g., by detecting when a program counter reaches an “end-of-program” value). The effect is the same in both cases: the program counter is typically reset to the address of the first instruction of the first subset, causing the first subset to begin processing a new piece of data. The LOOP mechanism has other effects as well. It can cause a “CurrentPass” counter, which tracks a current pass number, to be updated.
The invention also includes a validity pipeline, which is a piece of hardware that tracks the priming and draining of the software pipeline. The LOOP mechanism preferably causes a validity pipeline to advance. Each pass of a subset of instructions is associated with a stage in the validity pipeline. Before a program begins, a validity bit for each stage is initially cleared. When a subset of instructions begins processing, an associated validity bit is set (e.g., to “1”). When there is no new input data for a particular pass, the validity bit is cleared (e.g., reset to “0”). The processor stops processing when all validity bits are cleared. Every instruction that performs a write to a destination register or memory address is associated with a particular pass. If the validity bit associated with that pass is set, the write is allowed to proceed. Otherwise, the write is inhibited so that the instruction acts as a nop.
Because subsets of instructions execute on is multiple pieces of data concurrently, new addressing modes are provided in accordance with the invention for data-dependent access to processor and system resources (e.g., general-purpose registers and memory). “Pass-dependent register file addressing” is used to access registers within a processor. One arrangement for mapping pass-dependent registers requires that the number of temporary registers for each piece of data be initially known, but not the number of subsets in a program loop. A more preferred arrangement requires that the number of subsets of a loop be known, but not the number of temporary registers.
“Pass-dependent memory addressing” in accordance with the invention is used for memory reads and writes. A memory address is calculated by adding an offset to a base address. The base address, which is the same for all instructions run against a particular piece of data, is preferably stored in the validity pipeline. The offset is preferably encoded within an opcode of an instruction, which is different for each output of a processed piece of data.
The above and other objects and advantages of the invention will be apparent upon consideration of the following detailed description, taken in conjunction with the accompanying drawings, in which like reference characters refer to like parts throughout, and in which:
In a pipeline that processes multiple instructions with no data hazards (which can thus run at maximum utilization), an instruction enters the pipeline at each clock cycle and propagates through each stage with each subsequent clock cycle. Upon a first instruction completing the write-back stage, an instruction ideally completes processing every clock cycle thereafter.
In a pipeline that processes multiple instructions with data hazards, the hazards can be avoided with software that inserts nop instructions between dependent instructions. However, this increases program execution time.
The invention provides a pipelined processor that reduces data hazards to improve processor utilization by executing a set of instructions in multiple passes concurrently, with subsets of the instructions operating on different pieces of data. The type of program preferably processed by the invention is one that is repeatedly executed (e.g., on different sets of input data) until a predefined condition occurs (e.g., a counter reaches a predefined number). A program's set of instructions is processed in multiple passes. In each pass, one or more subsets of those instructions are processed. For example, a program of nine instructions may be processed in three passes, with subsets of three instructions being processed in each pass. This technique, called “software pipelining,” is advantageous for processing many different sets of input data with a fixed algorithm. The more sets of input data, the more likely the processor is to run at maximum utilization, which may be less than 100% depending on the number of cycles required to process each instruction.
In accordance with the invention, a program is first restructured (e.g., by a specialized compiler) before being run on a software pipelined processor. The program's instructions are first preferably expressed as a single instruction sequence without data-dependent branches. Branches can be eliminated by providing an instruction set that allows predicated execution. Predicated execution is the conditional execution of instructions based on a boolean (e.g., true or false) value known as a predicate. These instructions may be executed depending on whether or not a branch would be taken. When the predicate is true, the instructions execute normally and the results, if any, are written to memory or to registers. However, when the predicate is false, the instructions are skipped (i.e., not executed). Second, data hazards are removed by re-ordering instructions and inserting nop instructions. At this point, the processor will operate at less than maximum utilization because of the nop instructions. Third, the sequence of instructions is divided into a number of subsets and interleaved so that all of the nop instructions are replaced by instructions from different subsets. A detailed example of this process is now described.
The instruction sequence A, B, C, D, E, F, G, H, and I (nine instructions) processes a single piece of input data, where each instruction requires two subsequent nop instructions to eliminate data hazards. (Note that the invention is not limited to regular sequences of this type, but is advantageously applicable to instruction sequences with arbitrary data hazards on arbitrary instructions within the sequence.) The execution sequence for this example is expressed as a single instruction sequence without data hazards in accordance with the invention as follows:
A . . B . . C . . D . . E . . F . . G . . H . . I (3)
where each period represents a nop instruction. This sequence is then divided into three subsets of instructions in accordance with the invention as follows:
Subset I: A . . B . . C . . (4)
Subset II: . D . . E . . F . (5)
Subset III: . . G . . H . . I (6)
The subsets are arranged so that each subset contains a linear sequential fragment of the original sequence, and each of the subsets are of equal length. If necessary, the lengths of the subsets can be made equal by the addition of nop instructions. As shown, two additional nop instructions are introduced (one between instructions C and D, and one between instructions F and G). The optimum number of subsets required varies from program to program. For a given program, increasing the number of subsets allows processor utilization to increase until it reaches a maximum (which may be less than 100%). This maximum is reached when the number of nop instructions in the program reaches a minimum. Increasing the number of subsets beyond this point will require the addition of nop instructions and will therefore decrease the processor utilization.
The processor preferably runs a set of instructions on multiple pieces of data concurrently, with each subset of instructions operating on different pieces of data during the same pass, in accordance with the invention. Using the example above with three pieces of data, in pass 1, subset I operates on a first piece of data. In pass 2, subset II operates on the first piece of data while subset I begins operating on a second piece of data. Subsets I and II are preferably interleaved in the hardware pipeline. This can be represented using the notation A(2)D(1)G(-)B(2)E(1)H(-)C(2)F(1)I(-) where the number in parentheses (n) represents the ordinal number of the piece of data being processed and (-) represents a subset that is not yet executing valid data and is therefore executing nop instructions. In passes 1 and 2, the software pipeline is primed as more subsets of instructions are processing valid data, reducing the number of nop instructions processed in the hardware pipeline. In pass 3, subset III operates on the first piece of data, while subset II operates on the second piece of data and subset I operates on a third piece of data. The instructions are again preferably interleaved in the hardware pipeline (e.g., A(3)D(2)G(1)B(3)E(2)H(1) C(3)F(2)I(1)). At this point, the software pipeline is fully primed and the processor is advantageously running at maximum utilization. One instruction completes processing each cycle. This continues until each piece of data has been processed through each subset of instructions. As subsets of instructions finish processing the final piece of data, the software pipeline drains as nop instructions enter the hardware pipeline.
The utilization attained when processing a sequence of instructions is dependent upon the following: the total number of instructions in a program, the number of subsets into which the program is divided, and the number of pieces of data processed. For the 3-subset example above, the utilization is given by equation (7):
where “I” is the number of instructions in the program and “N” is the number of pieces of data. In reduced form, utilization depends on only N. Because the value of the numerator (N) will always be less than the value of the denominator (N+2), utilization will be less than loot. This occurs because of nop instructions during priming and draining of the software pipeline. However, as N increases, utilization approaches 100% (i.e., for very large N, the “+2” becomes negligible and (N+2) approximately equals N).
A “LOOP” mechanism in accordance with the invention causes a first program instruction of a subset to begin operating on a next piece of data at the start of a next pass. For example, as shown in
The LOOP instruction has several other functions. When the loop instruction is executed, a current pass counter can be incremented, modulo NumberOfSubsets. The modulo function divides the counter value by NumberOfSubsets and stores the integer remainder in the current pass counter. The current pass counter keeps track of a current piece of data through a given loop. In addition, a validity pipeline can be advanced.
The validity pipeline is a hardware pipeline that uses preferably one or more bits to keep track of valid data in the software pipeline. In particular, it is used to track the priming and draining of the software pipeline. The validity pipeline has a number of stages equal to NumberOfSubsets and a validity bit associated with each stage. Each piece of data can be associated with a validity bit (V) that propagates along the validity pipeline. When a program begins, the validity bit for each stage is initially cleared. When a first subset of instructions (in a first pass) begins processing a first piece of data, a validity bit associated with the first piece of data is set (e.g., to “1”) and enters a first stage of the validity pipeline. When a second subset of instructions (in a second pass) begins processing the first piece of data, the validity bit propagates to a second stage of the validity pipeline. Concurrently, when the first subset of instructions begins processing a second piece of data, a validity bit associated with the second piece of data is set (e.g., to “1”) and enters the first stage of the validity pipeline.
A data write that changes the state of a system (e.g., by writing to a destination register or to memory) is preferably only allowed if it is caused by an instruction associated with a valid bit (e.g., a bit of “1”). All other writes should be inhibited. This mechanism can cause normal instructions to behave like nop instructions at certain times, particularly during priming and draining of the software pipeline. While reads that have no effect on the state of the system do not need to be inhibited, system performance may be improved by eliminating unnecessary reads associated with invalid passes. When there is no new input data (i.e., the last piece of data has already entered the software pipeline), a cleared validity bit enters the first stage of the validity pipeline. The program stops processing when the validity bits in each stage are cleared.
Because a subset of instructions operating on a particular piece of data can be interleaved with other subsets of instructions operating on different pieces of data, new data-dependent addressing modes are preferably implemented in accordance with the invention for some processor and system resources (e.g., memory and general-purpose registers). Global resources (e.g., constants), however, can still be accessed in a data-independent way.
There is preferably a separate set of registers allocated for each piece of data processed by program instructions and an addressing mechanism to access those registers correctly. For example, for a three-subset program, there are preferably three sets of registers: one set associated with each of the first three pieces of data in the software pipeline. For a fourth piece of data to be processed in a fourth pass, the set of registers allocated for the first piece of data can be reused for the fourth piece of data (because the first piece of data has completely processed). This is known as pass-dependent register file addressing.
There are two ways of implementing pass-dependent register file addressing in accordance with the invention. One approach is to allocate a group of physical registers for each piece of data. Each group of physical registers is associated with a parallel set of temporary registers, which can be addressed by the program. The number of temporary registers (NumberOfTemporaries) is typically programmed at the start of program execution. This approach does not require that NumberOfSubsets be known. A more preferred second approach is to allocate a group of physical registers equal to NumberOfSubsets, with the same temporary register number assigned to each physical register in each group, but for a different pass of the program. In both approaches, the number of physical registers required is equal to (NumberOfSubsets*NumberOfTemporaries), and should not exceed the number of registers available.
Instructions operating on a particular piece of data during different passes (subsets) may need to access the same physical register using pass-dependent register file addressing. Using the more preferred register mapping (
Physical Register=(Register*NumberOfSubsets)+(CurrentPass−PassUsed) % NumberOfSubsets (8)
where “Register” is the temporary register number (e.g., 0 for R0, 1 for R1); “PassUsed” is the pass number for a particular subset of instructions for a given piece of data (e.g., a first subset of instructions has PassUsed=1, a second subset of instructions has PassUsed=2, a third subset of instructions has PassUsed=3); and symbol “%” represents the modulo operator. Register and PassUsed are typically invariant for a particular instruction and are preferably encoded within the operands of the instruction. The value of “NumberOfSubsets” is fixed for a given program. “CurrentPass” is the pass at which a piece of data begins processing (e.g., for a 3-subset program, a first piece of data has CurrentPass=1, a second piece of data has CurrentPass=2, a third piece of data has CurrentPass=3, a fourth piece of data has CurrentPass=1). As the processor processes successive passes, it maintains the value of CurrentPass by incrementing a counter. When the counter reaches NumberOfSubsets, the counter resets to 1. As a result, CurrentPass is a number between 1 and NumberOfSubsets (i.e., 1≦CurrentPass≦NumberofSubsets).
In addition to pass-dependent register addressing, it may also be necessary for the program flow associated with a particular piece of data to perform memory reads and writes. A form of pass-dependent memory addressing is therefore provided in accordance with the invention. Because multiple subsets of instructions preferably operate concurrently on different pieces of data, memory locations corresponding to each piece of data are preferably known before a pass starts. For example, if each piece of input data causes the program to perform three writes, it may be necessary to be able to determine a base address for the three writes as a function of an ordinal number of a piece of data. The memory address can be calculated by summing at least two values: one a function of the ordinal number of a piece of data and the other a function of the particular write which is preferably encoded within the program instructions.
For example, if a piece of code generates three outputs for each piece of input data, these outputs can be stored sequentially in memory at offsets 0, 1, and 2 from a base address. Writing to offsets 0, 1, and 2 can occur in any order and the value of each offset (0, 1, 2) can be encoded within the stored instruction.
The address for storing the outputs generated by a piece of code can be calculated by adding a base address (which differs for each piece of input data) to an offset (e.g., the offset can be “0” for a first output, “1” for a second output, and “2” for a third output), which is preferably encoded within the operands of an instruction. Before a program starts, the base address is preferably set and the number of outputs for each input is preferably specified. Each piece of input data can have an associated base address for outputs as shown in (9) below.
Data 0−>base address (x)
Data 1−>base address (x+3)
Data 2−>base address (x+6) (9)
The base address for each subsequent piece of data is preferably incremented by three to allow storage space for the three outputs from each piece of input data. Alternatively, each piece of data may be assigned a unique base address independent of the base addresses for other pieces of data. The number of separate copies of the base address that are maintained equals NumberOfSubsets. These stored values are called “frame pointers” and are preferably stored in a field within the validity pipeline.
When a valid pass starts, the current value of the base address can be placed into the frame pointer field of stage 1 of the validity pipeline, with a corresponding validity bit set (e.g., to “1”). For invalid passes (V=0), particularly during the priming and draining of the software pipeline, the value of the frame pointer field is irrelevant, since a cleared validity bit (V=0) will inhibit any write instruction, forcing it to act as a nop. The value of the base address is only incremented after it has been assigned to a frame pointer field associated with a valid pass (V=1). Meanwhile, the previous base address is propagated down the frame pointer fields of the validity pipeline to a stage 2 associated with a second subset of instructions for the same piece of data. The size of the output data is preferably not determined during program execution time, but calculated during “compile” time when the program is restructured and the NumberOfSubsets is determined.
When an instruction performs a load or a store, it preferably specifies the pass in which the load or store is to be done and can also be used to select an associated frame pointer in the validity pipeline. For example, if instructions A, D, and G (in passes 1, 2, and 3, respectively) are to access memory at offsets 2, 0, and 1, respectively, the physical address can be calculated by selecting the appropriate frame pointer from the validity pipeline and adding the frame pointer value to the respective offsets.
Invalid passes (e.g., when V=0) occur during priming and draining of the software pipeline, and may occur during processing, particularly when handling periodic gaps of input data. If input data is available for a new pass, the validity bit is set and the pass proceeds as normal. If input data is not available when the pass starts, the validity bit is cleared for that pass and the pass can still proceed. If input data is available for the next pass, there will be a one-pass “bubble” in the software pipeline, represented by the cleared validity bit. If input data is not available for a time equal to NumberOfSubsets (indicating that all instructions have completely processed the last piece of data), each stage of the validity pipeline will have their validity bits cleared, indicating that the software pipeline has completely drained.
The address of a current instruction in local program memory 1502 is stored in program counter 1504. After the current instruction is fetched, the value in program counter 1504 is updated to reference a next instruction. Control logic 1516 fetches and decodes the current instruction from local program memory 1502. The current instruction is processed in an instruction pipeline 1518, which preferably contains a number of (hardware pipeline) stages to process each instruction. Instruction pipeline 1518 can process input data and data reads from general-purpose registers 1520.
Control logic 1516 controls instruction pipeline 1518 and validity pipeline 1512. Instruction pipeline 1518, validity pipeline 1512, and control logic 1516 are preferably all coupled to a clock 1522, which synchronizes their operation. Each time the program code in program memory 1502 executes a LOOP function, Current-Pass-Counter 1514 is incremented modulo the value in Number-Of-Subsets register 1510, validity pipeline 1512 is advanced, and the current value of base address register 1506 is introduced into the frame pointer field of the first entry of validity pipeline 1512. When the LOOP function is executed and new input data is available, the value introduced into the valid field of the validity pipeline is a “1” and the value in base address register 1506 is incremented by the value in Number-Of-Outputs register 1508. When the LOOP function is executed and no new input data is available, the value introduced into the valid field of the validity pipeline is “0” and the value in base address register 1506 is not modified. Instruction pipeline 1518 reads/writes data from/to either general purpose registers 1520 using pass-dependent or pass-independent register file addressing, or a memory 1524 using pass-dependent or pass-independent memory addressing.
Thus it is seen that data hazards in pipelined processors can be reduced such that high processor utilization is attained. One skilled in the art will appreciate that the invention can be practiced by other than the described embodiments, which are presented for purposes of illustration and not of limitation, and the invention is limited only by the claims which follow.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5450556 *||Oct 25, 1993||Sep 12, 1995||North American Philips Corporation||VLIW processor which uses path information generated by a branch control unit to inhibit operations which are not on a correct path|
|US5712996 *||Mar 1, 1994||Jan 27, 1998||Siemens Aktiengesellschaft||Process for dividing instructions of a computer program into instruction groups for parallel processing|
|US5805914 *||Jun 7, 1995||Sep 8, 1998||Discovision Associates||Data pipeline system and data encoding method|
|US5911057 *||Dec 19, 1996||Jun 8, 1999||Texas Instruments Incorporated||Superscalar microprocessor having combined register and memory renaming circuits, systems, and methods|
|US6044450 *||Mar 27, 1997||Mar 28, 2000||Hitachi, Ltd.||Processor for VLIW instruction|
|US6230253 *||Mar 31, 1998||May 8, 2001||Intel Corporation||Executing partial-width packed data instructions|
|US6279100 *||Dec 3, 1998||Aug 21, 2001||Sun Microsystems, Inc.||Local stall control method and structure in a microprocessor|
|US6292939 *||Mar 11, 1999||Sep 18, 2001||Hitachi, Ltd.||Method of reducing unnecessary barrier instructions|
|US6324639 *||Mar 29, 1999||Nov 27, 2001||Matsushita Electric Industrial Co., Ltd.||Instruction converting apparatus using parallel execution code|
|US6360312 *||Mar 29, 1999||Mar 19, 2002||Matsushita Electric Industrial Co., Ltd.||Processor for making more efficient use of idling components and program conversion apparatus for the same|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7475393 *||Nov 19, 2004||Jan 6, 2009||Motorola, Inc.||Method and apparatus for parallel computations with incomplete input operands|
|US7681187 *||Mar 31, 2005||Mar 16, 2010||Nvidia Corporation||Method and apparatus for register allocation in presence of hardware constraints|
|US7882332||Oct 13, 2008||Feb 1, 2011||Marvell International Ltd.||Memory mapped register file|
|US7945768||Jun 5, 2008||May 17, 2011||Motorola Mobility, Inc.||Method and apparatus for nested instruction looping using implicit predicates|
|US8006072||May 18, 2010||Aug 23, 2011||Micron Technology, Inc.||Reducing data hazards in pipelined processors to provide high processor utilization|
|US8078828||Jan 31, 2011||Dec 13, 2011||Marvell International Ltd.||Memory mapped register file|
|US8392900 *||Mar 17, 2005||Mar 5, 2013||Hewlett-Packard Development Company, L.P.||Methods and systems for barrier reduction in parallel processing systems|
|US8407420||Jun 23, 2010||Mar 26, 2013||International Business Machines Corporation||System, apparatus and method utilizing early access to shared cache pipeline for latency reduction|
|US8612728||Aug 8, 2011||Dec 17, 2013||Micron Technology, Inc.||Reducing data hazards in pipelined processors to provide high processor utilization|
|US20050071835 *||Nov 19, 2004||Mar 31, 2005||Essick Raymond Brooke||Method and apparatus for parallel computations with incomplete input operands|
|US20060225061 *||Mar 31, 2005||Oct 5, 2006||Nvidia Corporation||Method and apparatus for register allocation in presence of hardware constraints|
|U.S. Classification||712/219, 712/E09.078, 712/213, 712/E09.05|
|International Classification||G06F9/30, G06F9/32, G06F9/50, G06F9/38|
|Cooperative Classification||G06F9/325, G06F9/30079, G06F9/3885|
|European Classification||G06F9/38T, G06F9/32B6|
|Apr 18, 2002||AS||Assignment|
Owner name: MICRON TECHNOLOGY, INC., IDAHO
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:CROOK, NEAL ANDREW;WOOTTON, ALAN T.;PETERSON, JAMES;REEL/FRAME:012825/0416;SIGNING DATES FROM 20020319 TO 20020326
|Jul 17, 2007||CC||Certificate of correction|
|Sep 1, 2010||FPAY||Fee payment|
Year of fee payment: 4
|Sep 3, 2014||FPAY||Fee payment|
Year of fee payment: 8