US5651125A - High performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations - Google Patents

High performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations Download PDF

Info

Publication number
US5651125A
US5651125A US08/501,243 US50124395A US5651125A US 5651125 A US5651125 A US 5651125A US 50124395 A US50124395 A US 50124395A US 5651125 A US5651125 A US 5651125A
Authority
US
United States
Prior art keywords
microprocessor
instructions
instruction
functional unit
bus
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Expired - Fee Related
Application number
US08/501,243
Inventor
David B. Witt
William M. Johnson
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
GlobalFoundries Inc
Original Assignee
Advanced Micro Devices Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority to US08/501,243 priority Critical patent/US5651125A/en
Application filed by Advanced Micro Devices Inc filed Critical Advanced Micro Devices Inc
Priority to US08/599,699 priority patent/US5751981A/en
Priority to US08/599,697 priority patent/US5655098A/en
Priority to US08/599,698 priority patent/US5655097A/en
Priority to US08/599,700 priority patent/US5664136A/en
Priority to US08/599,696 priority patent/US5867682A/en
Priority to US08/845,978 priority patent/US5867683A/en
Application granted granted Critical
Publication of US5651125A publication Critical patent/US5651125A/en
Assigned to GLOBALFOUNDRIES INC. reassignment GLOBALFOUNDRIES INC. AFFIRMATION OF PATENT ASSIGNMENT Assignors: ADVANCED MICRO DEVICES, INC.
Anticipated expiration legal-status Critical
Expired - Fee Related legal-status Critical Current

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003Arrangements for executing specific machine instructions
    • G06F9/30007Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/3001Arithmetic instructions
    • G06F9/30014Arithmetic instructions with variable precision
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003Arrangements for executing specific machine instructions
    • G06F9/30007Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/30025Format conversion instructions, e.g. Floating-Point to Integer, decimal conversion
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003Arrangements for executing specific machine instructions
    • G06F9/30007Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/30036Instructions to perform operations on packed data, e.g. vector, tile or matrix operations
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30094Condition code generation, e.g. Carry, Zero flag
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098Register arrangements
    • G06F9/30105Register structure
    • G06F9/30112Register structure comprising data of variable length
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30145Instruction analysis, e.g. decoding, instruction word fields
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30145Instruction analysis, e.g. decoding, instruction word fields
    • G06F9/30149Instruction analysis, e.g. decoding, instruction word fields of variable length instructions
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/3017Runtime instruction translation, e.g. macros
    • G06F9/30174Runtime instruction translation, e.g. macros for non-native instruction set, e.g. Javabyte, legacy code
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3802Instruction prefetching
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3802Instruction prefetching
    • G06F9/3804Instruction prefetching for branches, e.g. hedging, branch folding
    • G06F9/3806Instruction prefetching for branches, e.g. hedging, branch folding using address prediction, e.g. return stack, branch history buffer
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3802Instruction prefetching
    • G06F9/3814Implementation provisions of instruction buffers, e.g. prefetch buffer; banks
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3818Decoding for concurrent execution
    • G06F9/3822Parallel decoding, e.g. parallel decode units
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3836Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3836Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3838Dependency mechanisms, e.g. register scoreboarding
    • G06F9/384Register renaming
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3836Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3842Speculative instruction execution
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3854Instruction completion, e.g. retiring, committing or graduating
    • G06F9/3856Reordering of instructions, e.g. using queues or age tags
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3854Instruction completion, e.g. retiring, committing or graduating
    • G06F9/3858Result writeback, i.e. updating the architectural state or memory
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3885Concurrent instruction execution, e.g. pipeline, look ahead using a plurality of independent parallel functional units

Definitions

  • This invention relates in general to microprocessors and, more particularly, to high performance superscalar microprocessors.
  • microprocessor design is a technology in which engineers and scientists continually strive for increased speed, efficiency and performance.
  • microprocessors can be divided into two classes, namely scalar and vector processors.
  • the most elementary scalar processor processes a maximum of one instruction per machine cycle. So called “superscalar” processors can process more than one instruction per machine cycle.
  • a vector processor can process a relatively large array of values during each machine cycle.
  • Instruction parallelism may be thought of as the inherent property of a sequence of instructions which enable such instructions to be processed in parallel.
  • data parallelism may be viewed as the inherent property of a stream of data which enables the elements thereof to be processed in parallel.
  • Instruction parallelism is related to the number of dependencies which a particular sequence of instructions exhibits. Dependency is defined as the extent to which a particular instruction depends on the result of another instruction. In a scalar processor, when an instruction exhibits a dependency on another instruction, the dependency generally must be resolved before the instruction can be passed to a functional unit for execution. For this reason, conventional scalar processors experience undesirable time delays while the processor waits pending resolution of such dependencies.
  • Disatch is the act of sending an instruction from the instruction decoder to a functional unit.
  • Issue is the act of placing an instruction in execution in a functional unit.
  • Comppletion is achieved when an instruction finishes execution and the result is available.
  • An instruction is said to be “retired” when the instruction's result is written to the register file. This is also referred to as "writeback”.
  • FIGS. 1, 1A, and 1B comprise a block diagram of a microprocessor 10 which depicts the implementation of a superscalar microprocessor described in the Johnson book.
  • Microprocessor 10 includes an integer unit 15 for handling integer operations and a floating point unit 20 for handling floating point operations.
  • Integer unit 15 and floating point unit 20 each include their own respective, separate and dedicated instruction decoder, register file, reorder buffer, and load and store units.
  • integer unit 15 includes instruction decoder 25, a register file 30, a reorder buffer 35, and load and store units (60 and 65), while floating point unit 20 includes its own instruction decoder 40, register file 45, reorder buffer 50, and load and store units (75 and 80) as shown in FIG. 1.
  • the reorder buffers contain the speculative state of the microprocessor, whereas the register files contain the architectural state of the microprocessor.
  • Microprocessor 10 is coupled to a main memory 55 which may be thought of as having two portions, namely an instruction memory 55A for storing instructions and a data memory 55B for storing data.
  • Instruction memory 55A is coupled to both integer unit 15 and floating point unit 20.
  • data memory 55B is coupled to both integer unit 15 and floating point unit 20.
  • instruction memory 55A is coupled to decoder 25 and decoder 40 via instruction cache 58.
  • Data memory 55B is coupled to load functional unit 60 and store functional unit 65 of integer unit 15 via a data cache 70.
  • Data memory 55B is also coupled to a float load functional unit 75 and a float store functional unit 80 of floating point unit 20 via data cache 70.
  • Load unit 60 performs the conventional microprocessor function of loading selected data from data memory 55B into integer unit 15, whereas store unit 70 performs the conventional microprocessor function of storing data from integer unit 15 in data memory 55B.
  • a computer program includes a sequence of instructions which are to be executed by microprocessor 10.
  • Computer programs are typically stored in a hard disk, floppy disk or other non-volatile storage media which is located in a computer system.
  • main memory 55 When the program is run, the program is loaded from the storage media into main memory 55. Once the instructions of the program and associated data are in main memory 55, the individual instructions can be prepared for execution and ultimately be executed by microprocessor 10.
  • Instruction decoder 25 examines each instruction and determines the appropriate action to take. For example, decoder 25 determines whether a particular instruction is a PUSH, POP, LOAD, AND, OR, EX OR, ADD, SUB, NOP, JUMP, JUMP on condition (BRANCH) or other type of instruction. Depending on the particular type of instruction which decoder 58 determines is present, the instruction is dispatched to the appropriate functional unit. In the superscalar architecture proposed in the Johnson book, decoder 25 is a multi-instruction decoder which is capable of decoding 4 instructions per machine cycle. It can thus be said that decoder 58 exhibits a bandwidth which is four instructions wide.
  • an OP CODE bus 85 is coupled between decoder 25 and each of the functional units, namely, branch unit 90, arithmetic logic units 95 and 100, shifter unit 105, load unit 60 and store unit 65. In this manner, the OP CODE for each instruction is provided to the appropriate functional unit.
  • instructions typically include multiple fields in the following format: OP CODE, OPERAND A, OPERAND B, DESTINATION REGISTER.
  • sample instruction ADD A, B, C would mean ADD the contents of register A to the contents of register B and place the result in the destination register C.
  • the OP CODE for a particular instruction not only must the OP CODE for a particular instruction be provided to the appropriate functional unit, but also the designated OPERANDS for that instruction must be retrieved and sent to the functional unit. If the value of a particular operand has not yet been calculated, then that value must be first calculated and provided to the functional unit before the functional unit can execute the instruction. For example, if a current instruction is dependent on a prior instruction, the result of the prior instruction must be determined before the current instruction can be executed. This situation is referred to as a dependency.
  • operand bus 110 is coupled to each of the functional units.
  • operand bus 110 conveys the operands to the appropriate functional unit.
  • operand bus 110 includes separate buses for OPERAND A and OPERAND B.
  • the functional unit executes the instruction and places the result on a result bus 115 which is coupled to the output of all of the functional units and to reorder buffer 35 (and to the respective reservation stations at the input of each functional unit as will now be discussed).
  • each functional unit is provided with a "reservation station" for storing OP codes from instructions which are not yet complete in the sense that the operands for that instruction are not yet available to the functional unit.
  • the reservation station stores the instruction's OP CODE together with operand tags which reserve places for the missing operands that will arrive at the reservation station later. This technique enhances performance by permitting the microprocessor to continue executing other instructions while the pending instruction is being assembled together with its operands at the reservation station. As seen in FIG.
  • branch unit 90 is equipped with a reservation station 90R; ALU's 95 and 100 are equipped with reservation stations 95R and 100R, respectively; shifter unit 105 is equipped with a reservation station 105R; load unit 60 is equipped with a reservation station 60R; and store unit 65 is equipped with a reservation station 65R.
  • reservation stations are employed in place of the input latches which were typically used at the inputs of the functional units in earlier microprocessors.
  • the classic reference with respect to reservation stations is R. M. Tomasulo, "An Efficient Algorithm For Exploiting Multiple Arithmetic Units" IBM Journal, Volume 11, January 1967, pp. 25-33.
  • a pipeline can be used to increase the effective throughput in a scalar microprocessor up to a limit of one instruction per machine cycle.
  • multiple pipelines are employed to achieve the processing of multiple instructions per machine cycle. This technique is referred to as "super-pipelining".
  • register renaming Another technique referred to as "register renaming" can also be employed to enhance superscalar microprocessor throughput. This technique is useful in the situation where two instructions in an instruction stream both require use of the same register, for example a hypothetical register 1. Provided that the second instruction is not dependent on the first instruction, a second register called register 1A is allocated for use by the second instruction in place of register 1. In this manner, the second instruction can be executed and a result can be obtained without waiting for the first instruction to be done using register 1.
  • the superscalar microprocessor 10 shown in FIG. 1 uses a register renaming approach to increase instruction handling capability. The manner in which register renaming is implemented in microprocessor 10 is now discussed in more detail.
  • register renaming eliminates storage conflicts for registers.
  • integer unit 15 and floating point unit 20 are associated with respective reorder buffers 35 and 50.
  • reorder buffer 35 in integer unit 15 Only register renaming via reorder buffer 35 in integer unit 15 will be discussed, although the same discussion applies to similar circuitry in floating point unit 20.
  • Reorder buffer 35 includes a number of storage locations which are dynamically allocated to instruction results. More specifically, when an instruction is decoded by decoder 25, the result value of the instruction is assigned a location in reorder buffer 35 and its destination register number is associated with this location. This effectively renames the destination register number of the instruction to the reorder buffer location. A tag, or temporary hardware identifier, is generated by the microprocessor hardware to identify the result. This tag is also stored in the assigned reorder buffer location. When a later instruction in the instruction stream refers to the renamed destination register, in order to obtain the value considered to be stored in the register, the instruction instead obtains the value stored in the reorder buffer or the tag for this value if the value has not yet been computed.
  • Reorder buffer 35 is implemented as a first-in-first-out (FIFO) circular buffer which is a content-addressable memory. This means that an entry in reorder buffer 35 is identified by specifying something that the entry contains, rather than by identifying the entry directly. More particularly, the entry is identified by using the register number that is written into it. When a register number is presented to reorder buffer 35, the reorder buffer provides the latest value written into the register (or a tag for the value if the value is not yet computed). This tag contains the relative speculative position of a particular instruction in reorder buffer 35. This organization mimics register file 30 which also provides a value in a register when it is presented with a register number. However, reorder buffer 35 and register file 30 use very different mechanisms for accessing values therein.
  • FIFO first-in-first-out
  • the reorder buffer compares the requested register number to the register numbers in all of the entries of the reorder buffer. Then, the reorder buffer returns the value (or tag) in the entry that has a matching register number. This is an associative lookup technique. In contrast, when register file 30 is presented with a requested register number, the register file simply decodes the register number and provides the value at the selected entry.
  • the register numbers of the decoded instruction's source operands are used to access both reorder buffer 35 and register file 30 at the same time. If reorder buffer 35 does not have an entry whose register number matches the requested source register number, then the value in register file 30 is selected as the source operand. However, if reorder buffer 35 does contain a matching entry, then the value in this entry is selected as the source operand because this value must be the most recent value assigned to the reorder buffer. If the value is not available because the value has not yet been computed, then the tag for the value is instead selected and used as the operand. In any case, the value or tag is copied to the reservation station of the appropriate functional unit. This procedure is carried out for each operand required by each decoded instruction.
  • reorder buffer 35 prioritizes multiple matching entries by order of allocation, and returns the most recent entry when a particular register value is requested.
  • a functional unit When a functional unit produces a result, the result is written into reorder buffer 35 and to any reservation station entry containing a tag for this result.
  • a result value When a result value is written into the reservation stations in this manner, it may provide a needed operand which frees up one or more waiting instructions to be issued to the functional unit for execution.
  • subsequent instructions After the result value is written into reorder buffer 35, subsequent instructions continue to fetch the result value from the reorder buffer. This fetching continues unless the entry is superseded by a new value and until the value is retired by writing the value to register file 30. Retiring occurs in the order of the original instruction sequence, thus preserving the in-order state for interrupts and exceptions.
  • floating point unit 20 includes other functional units as well, For instance, floating point unit 20 includes a float add unit 120, a float convert unit 125, a float multiply unit 130 and a float divide unit 140.
  • An OP CODE bus 145 is coupled between decoder 40 and each of the functional units in floating point unit 20 to provide decoded instructions to the functional units.
  • Each functional unit includes a respective reservation station, namely, float add reservation station 120R, float convert reservation station 125R, float multiply reservation station 130R and float divide reservation station 140R.
  • An operand bus 150 couples register file 45 and reorder buffer 50 to the reservation stations of the functional units so that operands are provided thereto.
  • a result bus 155 couples the outputs of all of the functional units of floating point unit 20 to reorder buffer 50.
  • Reorder buffer 50 is then coupled to register file 45. Reorder buffer 50 and register file 45 are thus provided with results in the same manner as discussed above with respect to integer unit 15.
  • Integer reorder buffer 35 holds 16 entries and floating point reorder buffer 50 holds 8 entries. Integer reorder buffer 35 and floating point reorder buffer 50 can each accept two computed results per machine cycle and can retire two results per cycle to the respective register file.
  • microprocessor 10 of FIG. 1 which employs "out-of-order-issue" achieves this type of instruction issue by isolating decoder 25 from the execution units (functional units). This is done by using reorder buffer 35 and the aforementioned reservation stations at the functional units to effectively establish a distributed instruction window. In this manner, the decoder can continue to decode instructions even if the instructions can not be immediately executed.
  • the instruction window acts as a pool of instructions from which the microprocessor can draw as it continues to go forward and execute instructions.
  • a look ahead capability is thus provided to the microprocessor by the instruction window.
  • Microprocessor 10 includes a branch prediction unit 90 to enhance its performance. It is well known that branches in the instruction stream of a program hinder the capability of a microprocessor to fetch instructions. This is so because when a branch occurs, the next instruction which the fetcher should fetch depends on the result of the branch. Without a branch prediction unit such as unit 90, the microprocessor's instruction fetcher may become stalled or may fetch incorrect instructions. This reduces the likelihood that the microprocessor can find other instructions in the instruction window to execute in parallel. Hardware branch prediction, as opposed to software branch prediction, is employed in branch prediction unit 90 to predict the outcomes of branches which occur during instruction fetching. In other words, branch prediction unit 90 predicts whether or not branches should be taken. For example, a branch target buffer is employed to keep a running history of the outcomes of prior branches. Based on this history, a decision is made during a particular fetched branch as to which branch the fetched branch instruction will take.
  • software branch prediction also may be employed to predict the outcome of a branch. In that branch prediction approach, several tests are run on each branch in a program to determine statistically which branch outcome is more likely.
  • Software branch prediction techniques typically involve imbedding statistical branch prediction information as to the favored branch outcome in the program itself. It is noted that the term "speculative execution" is often applied to microprocessor design practices wherein a sequence of code (such as a branch) is executed before the microprocessor is sure that it was proper to execute that sequence of code.
  • microprocessor 10 is indeed a powerful but very complex structure. Further increases in processing performance as well as design simplification are however always desirable in microprocessors such as microprocessor 10.
  • one advantage of the superscalar microprocessor of the present invention is its increased performance in terms of processing instructions in parallel.
  • Another advantage of the superscalar microprocessor of the present invention is reduced complexity.
  • Still another advantage of the superscalar microprocessor of the present invention is reduced die size as compared to other superscalar microprocessors.
  • a superscalar microprocessor for processing instructions stored in a main memory.
  • the microprocessor includes a multiple instruction decoder for decoding multiple instructions in the same microprocessor cycle.
  • the decoder decodes both integer and floating point instructions in the same microprocessor cycle.
  • the microprocessor includes a data processing bus coupled to the decoder.
  • the microprocessor further includes an integer functional unit and a floating point functional unit coupled to and sharing the same data processing bus.
  • a common reorder buffer is coupled to the data processing bus for use by both the integer functional unit and the floating point functional unit.
  • a common register file is coupled to the reorder buffer for accepting instruction results which are retired from the reorder buffer.
  • FIG. 1, 1A, and 1B comprise a block diagram showing a conventional superscalar microprocessor.
  • FIG. 2, 2A, and 2B comprise a simplified block diagram of one embodiment of the high performance superscalar microprocessor of the present invention.
  • FIGS. 3, 3A, 3B, 3C, 3D, and 3E comprise a more detailed block diagram of another embodiment of the high performance superscalar microprocessor of the present invention.
  • FIG. 4 is a chart representing the priority which functional units receive when arbitrating for result buses.
  • FIG. 5 is a block diagram of the internal address data bus arbitration arrangement in the microprocessor of the invention.
  • FIG. 5A is a timing diagram of the operation of the microprocessor of FIG. 3 throughout the multiple stages of the pipeline thereof during sequential processing.
  • FIG. 5B is a timing diagram similar to the timing diagram of FIG. 5A but directed to the case where a branch misprediction and recovery occurs.
  • FIG. 6, 6A, 6B, and 6C comprise a block diagram of another embodiment of the superscalar microprocessor of the invention.
  • FIG. 7 is a block diagram of the register file, reorder buffer and integer core of the microprocessor of FIG. 6.
  • FIG. 8 is a more detailed block diagram of the reorder buffer of FIG. 7.
  • FIG. 9 is a block diagram of a generalized functional unit employed by the microprocessor of FIG. 6.
  • FIG. 10 is a block diagram of a branch functional unit employed by the microprocessor of FIG. 6.
  • FIG. 11 is a timing diagram of the operation of the microprocessor of FIG. 6 during sequential execution.
  • FIG. 12 is a timing diagram of the operation of the microprocessor of FIG. 6 during a branch misprediction and recovery.
  • the high performance superscalar microprocessor of the present invention desirably permits parallel out-of-order issue of instructions and out-of-order execution of instructions. More particularly, in the disclosed superscalar microprocessor, instructions are dispatched in program order, issued and completed out of order, and retired in order.
  • the superscalar microprocessor 200 of FIGS. 2, 2A, and 2B achieves increased performance without increasing die size by sharing several key components.
  • the architecture of the microprocessor provides that the integer unit 215 and the floating point unit 225 are coupled to a common data processing bus 535.
  • Data processing bus 535 is a high speed, high performance bus primarily due to its wide bandwidth. Increased utilization of both the integer functional unit and the floating point functional unit is thus made possible as compared to designs where these functional units reside on separate buses.
  • the integer and floating point functional units include multiple reservation stations which are also coupled to the same data processing bus 535. As seen in the more detailed representation of the microprocessor of the invention in FIGS. 3, 3A, 3B, 3C, 3D and 3E, the integer and floating point functional units also share a common branch unit 520 on data processing bus 535. Moreover, the integer and floating point functional units share a common load/store unit 530 which is coupled to the same data processing bus 535.
  • the disclosed microprocessor architecture advantageously increases performance while more efficiently using the size of the microprocessor die.
  • the microprocessor of the present invention is a reduced instruction set computer (RISC) wherein the instructions processed by the microprocessor exhibit the same width and the operand size is variable.
  • RISC reduced instruction set computer
  • Superscalar microprocessor 200 includes a four instruction wide, two-way set associative, partially decoded 8K byte instruction cache 205.
  • Instruction cache 205 supports fetching of multiple instructions per machine cycle with branch prediction. For purposes of this document, the terms machine cycle and microprocessor cycle are regarded as synonymous.
  • Instruction cache 205 will also be referred to as ICACHE.
  • Microprocessor 200 further includes an instruction decoder (IDECODE) 210 which is capable of decoding and dispatching up to four instructions per machine cycle to any of six independent functional units regardless of operand availability.
  • IDECODE instruction decoder
  • these functional units include two arithmetic logic units (ALU 0 and ALU 1 shown collectively as ALU 505).
  • ALU 0 and ALU 1 shown collectively as ALU 505
  • SHFSEC shifter section 510
  • the functional units also include a branch section (BRNSEC) 520 for processing instruction branches and for performing branch prediction.
  • BRNSEC branch section
  • One branch unit which may be employed as branch unit 520 is described in U.S. Pat. No.
  • FIGS. 3A and 3B together form microprocessor 500 and should be viewed together in side by side relationship.
  • microprocessor 200 further includes multiple reservation stations at the functional units where dispatched instructions are queued pending execution. In this particular embodiment, two reservation stations are provided at the input of each functional unit. More particularly, integer core 215 includes two reservation stations 220 and floating point core 225 includes two reservation stations 230 in this particular embodiment. The number of reservation stations employed per functional unit may vary according to the degree of queuing desired. Integer core 215 processes integer instructions and floating point core 225 processes floating point instructions. In actual practice, integer core 215 and floating point core 225 each include multiple functional units, each of which is equipped with multiple reservation stations in one embodiment of the invention.
  • microprocessor 200 is capable of handling up to three functional unit results per machine cycle. This is so because microprocessor 200 includes three result buses designated RESULT0, RESULT 1 and RESULT 2 which are coupled to all functional units (ie. to integer core 215 and floating point core 225 in FIG. 2).
  • the invention is not limited to this number of result buses and a greater or lesser number of result buses may be employed commensurate with the performance level desired.
  • the invention is not limited to the particular number of functional units in the embodiments depicted.
  • Microprocessor 200 further includes a unified register file 235 for storing results which are retired from a reorder buffer 240.
  • Register file 235 is a multi-ported, multiple register storage area which permits 4 reads and 2 writes per machine cycle in one embodiment.
  • Register file 235 accommodates different size entries, namely both 32 bit integer and 64 bit floating point operand entries in the same register file in one embodiment.
  • Register file 235 exhibits a size of 194 32 bit registers in this particular embodiment.
  • Reorder buffer 240 also accommodates different size entries, namely both 32 bit integer and 64 bit floating point operand entries in the same reorder buffer in one embodiment. Again, these particular numbers are given for purposes of illustration rather than limitation.
  • Reorder buffer 240 is a circular buffer or queue which receives out-of-order functional unit results and which updates register file 235 in sequential instruction program order.
  • reorder buffer 240 is implemented as a first in first out (FIFO) buffer with 10 entries.
  • the queue within FIFO ROB 240 includes a head and a tail.
  • Another embodiment of the invention employs a reorder buffer with 16 entries.
  • Reorder buffer 240 contains positions allocated to renamed registers, and holds the results of instructions which are speculatively executed. Instructions are speculatively executed when branch logic predicts that a certain branch will be taken such that instructions in the predicted branch are executed on speculation that the branch was indeed properly taken in a particular instance.
  • the branch results which are in reorder buffer 240 are effectively cancelled. This is accomplished by microprocessor effectively backing up to the mispredicted branch instruction, flushing the speculative state of the microprocessor and resuming execution from a point in the program instruction stream prior to the mispredicted branch.
  • the reorder buffer can also accommodate 64 bit quantities such as 64 bit floating point quantities, for example. This is accomplished by storing the 64 bit quantity within the reorder buffer as two consecutive ROP's. (ROP's, pronounced R-ops, refer to RISC or RISC-like instructions/operations which are processed by the microprocessor.) Such stored consecutive ROP's have information linking them as one structure and are retired together as one structure.
  • Each reorder buffer entry has the capacity to hold one 32 bit quantity, namely 1/2 a double precision floating point quantity, one single precision floating point quantity or a 32 bit integer.
  • a program counter is employed to keep track of the point in the program instruction stream which is the boundary between those instructions which have been retired into register file 235 as being no longer speculative, and those instructions which have been speculatively executed and whose results are resident in reorder buffer (ROB) 240 pending retirement.
  • This PC is referred to as the retire PC, or simply the PC.
  • the retire PC is stored and updated at the head of the ROB queue.
  • ROB entries contain relative PC update status information.
  • the retire PC is updated by status information associated with the head of the reorder buffer queue. More particularly, the reorder buffer queue indicates the number of instructions that are ready to retire, up to a maximum of four instructions in this particular embodiment.
  • the retire PC section which is situated within retire logic 242 holds the current retired PC. If four (4) sequential instructions are to be retired in a particular clock cycle, then the retire PC logic adds [4 instructions*4 bytes/instruction] to the current retire PC to produce the new retire PC. If a taken branch exists, then the retire PC is advanced to the target of the branch once the branch is retired and no longer speculative. The retire PC is subsequently incremented from that point by the number of instructions retired.
  • the retire PC is present on an internal bus within retire logic 242, namely PC(31:0).
  • FIG. 2 shows a simplified block diagram of one embodiment of the high performance superscalar microprocessor of the present invention as microprocessor 200.
  • instruction cache 205 and a data cache 245 are coupled to each other via a 32 bit wide internal address data (IAD) bus 250.
  • IAD bus 250 is a communications bus which, in one embodiment, exhibits relatively low speed when compared with data processing bus 535.
  • IAD bus 250 serves to interconnect several key components of microprocessor 200 to provide communication of both address information and data among such components.
  • IAD bus 250 is employed for those tasks which do not require high speed parallelism as do operand handling and result handling which data processing bus 535 handles.
  • IAD bus 250 is a 32 bit wide bus onto which both data and address information are multiplexed in each clock cycle. The bandwidth of IAD bus 250 is thus 64 bits/clock in one example.
  • a main memory 255 is coupled to IAD bus 250 via a bus interface unit 260 as shown in FIG. 2. In this manner, the reading and writing of information to and from main memory 255 is enabled.
  • main memory 255 is shown in FIG. 2 as being a part of microprocessor 200. In actual practice, main memory 225 is generally situated external to microprocessor 200. Implementations of microprocessor 200 are however contemplated wherein main memory 255 is located within microprocessor 200 as in the case of a microcontroller, for example.
  • Decoder 210 includes a fetcher 257 which is coupled to instruction cache 205. Fetcher 257 fetches instructions from cache 205 and main memory 255 for decoding and dispatch by decoder 210.
  • a bus interface unit (BIU) 260 is coupled to IAD bus 250 to interface microprocessor 200 with bus circuitry (not shown) external to microprocessor 200. More particularly, IAD bus 260 interfaces microprocessor 200 with a system bus, local bus or other bus (not shown) which is external to microprocessor 200.
  • One bus interface unit which may be employed as BIU 260 is the bus interface unit from the AM29030 microprocessor which is manufactured by Advanced Micro Devices.
  • BIU 260 includes an address port designated A(31:0) and a data port designated D(31:0).
  • BIU 260 also includes a bus hand shake port (BUS HAND SHAKE) and grant/request lines designated XBREQ (not bus request) and XBGRT (not bus grant).
  • the bus interface unit of the AM29030 microprocessor is described in more detail in the Am29030 User's Manual published by Advanced Micro Devices, Inc.
  • main memory 255 When instructions and data are read from memory 255, the instructions and data are respectively stored in instruction cache 205 and data cache 245 before the instructions can be fetched, decoded and dispatched to the functional units by decoder 210.
  • decoder 210 When a particular instruction is decoded by decoder 210, decoder 210 sends the OP CODE of the decoded instruction to the appropriate functional unit for that type of instruction. Assume for example purposes that the following instruction has been fetched: ADD R1, R2, R3 (ADD the integer in register 1 to the integer in register 2 and place the result in register 3. Here, R1 is the A operand, R2 is the B operand and R3 is the destination register).
  • decoder 210 decodes four (4) instructions per block at one time and identifies the opcode associated with each instruction. In other words, decoder 210 identifies an opcode type for each of the four dispatch positions included in decoder 210. The four decoded opcode types are then broadcast on the four TYPE busses, respectively, to the functional units. The four decoded opcodes are broadcast on respective OP CODE busses to the functional units. Operands, if available, are retrieved from ROB 240 and register file 235. The operands are broadcast to the functional units over the A operand and B operand busses. If a particular operand is not available, an A or B operand tag is instead transmitted to the appropriate functional unit over the appropriate A or B operand bus. The four instructions decoded by decoder 210 are thus dispatched to the functional units for processing.
  • one of the functional units namely the arithmetic logic unit (ALU) in integer core 215 will recognize the opcode type and latch in its reservation station 220 the information including opcode, A operand tag, A operand (if available), B operand tag, B operand (if available) and destination tag.
  • the ALU functional unit determines the result and places the result on the result bus 265 for storage in ROB 240 and for retrieval by any other functional unit needing that result to process a pending instruction.
  • reorder buffer 240 provides either the result value which is stored in the location allocated to that register or the tag for that value if the result has not yet been computed.
  • a signal is placed on the result tag bus to let reorder buffer 240 and the reservation stations of the functional units know that the result is now available on the result bus. The result is thus stored in reorder buffer 240.
  • the destination tag line runs from reorder buffer 240 to the functional units.
  • Decoder 210 informs the reorder buffer of the number of instructions which are presently ready for allocation of reorder buffer entries.
  • the reorder buffer then assigns each instruction a destination tag based on the current state of the reorder buffer. Decoder 210 then validates whether each instruction is issued or not.
  • the reorder buffer takes those instructions that are issued and validates the temporary allocation of reorder buffer entries.
  • the operands for a particular instruction are transported to the appropriate functional unit over the A Operand bus (A OPER) and the B Operand bus (B OPER) of common data processing bus 535.
  • the results of respective instructions are generated at the functional units assigned to those instructions.
  • Those results are transmitted to reorder buffer 240 via composite result bus 265 which includes 3 result buses RESULT 0, RESULT1 and RESULT 2.
  • Composite result bus 265 is a part of data processing bus 535.
  • the operand tags are actually transmitted to the reservation stations of the functional unit via the A OPER and B OPER buses.
  • the A OPER and B OPER buses are referred to as the A TAG and B TAG buses as indicated in FIG. 2.
  • FIG. 3 shows a more detailed implementation of the microprocessor of the present invention as microprocessor 500.
  • microprocessor 500 Like numerals are used to indicate like elements in the microprocessors depicted in FIGS. 2, and 3. It is noted that portions of microprocessor 500 have already been discussed above.
  • Decoder 210 decodes multiple instructions per microprocessor cycle and forms a dispatch window from which the decoded instructions are dispatched in parallel to functional units.
  • ICACHE 205 is capable of providing four instructions at a time to decoder 210 over lines INS0, INS1, INS2 and INS3 which couple ICACHE 205 to decoder 210.
  • Data processing bus 535 includes 4 OP CODE buses, 4 A OPER/A TAG buses, 4 B OPER/B TAG buses and 4 OP CODE TYPE buses. Since the 4 OP CODE buses, 4 A OPER/A TAG buses, 4 B OPER/B TAG buses and 4 OP CODE TYPE buses cooperate to transmit decoded instructions to the functional units, they are together also referred to as 4 instruction buses designated XI0B, XI1B, XI2B and XI3B (not separately labelled in the figures.) These similar instruction bus names are distinguished from one another by a single digit.
  • This digit indicates the instruction's position in a 0 mod 16 byte block of memory, with 0 being the earlier instruction.
  • These names are given in generic form here with the digit replaced by a lowercase “n” (ie. the four instruction buses XI0B, XI1B, XI2B and XI3B are referred to as XInB).
  • Microprocessor 500 includes a four-instruction-wide, two-way set associative, partially-decoded 8K byte instruction cache 205 (ICACHE) to support fetching of four instructions per microprocessor cycle with branch prediction.
  • ICACHE eight-instruction-wide, two-way set associative, partially-decoded 8K byte instruction cache 205
  • Microprocessor 500 provides for decode and dispatch of up to four instructions per cycle by decoder 210 (IDECODE) to any of five independent functional units regardless of operand availability.
  • These functional units include branching section BRNSEC 520, arithmetic logic unit ALU 505, shifter section SHFSEC 510, floating point section FPTSEC 525 and LOAD/STORE section 530.
  • Microprocessor 500 provides tagging of instructions to preserve proper ordering of operand dependencies and allow out-of-order issue.
  • Microprocessor 500 further includes reservation stations in the functional units at which dispatched instructions that cannot yet be executed are queued.
  • Three result buses (RESULT0, RESULT1 and RESULT2) are provided to permit handling of up to three functional unit results per cycle.
  • a circular buffer or FIFO queue namely reorder buffer 240, receives out-of-order functional unit results and updates the register file 235. More particularly, the register file is updated in correct program order with results from the reorder buffer. In other words, retirement of results from the reorder buffer to the register file is in the order of correct execution with all the branches, arithmetic and load/store operations which that entails.
  • Multiported register file 235 is capable of 4 reads and 2 writes per machine cycle.
  • RESULT0, RESULT1 and RESULT2 are written in parallel to ROB 240.
  • results are retired from ROB 240, they are written in parallel to register file 235 via write buses WRITEBACK0 and WRITEBACK1.
  • Microprocessor 500 also includes an on-board direct mapped 8K byte coherent data cache 245 to minimize load and store latency.
  • Instruction decoder (IDECODE) 210 includes an instruction fetcher 257 which fetches instructions from instruction cache (ICACHE) 205.
  • instruction cache which may be employed as cache 205 is described in copending U.S. patent application Ser. No. 07/929,770, filed Apr. 12, 1992, entitled “Instruction Decoder And Superscalar Processor Utilizing Same” which was incorporated herein by reference earlier in this document.
  • One decoder which may be employed as decoder 210 (IDECODE) is also described in U.S. patent application Serial No. Ser. No. 07/929,770, filed Apr. 12, 1992, entitled “Instruction Decoder And Superscalar Processor Utilizing Same".
  • main memory 255 As a particular program in main memory 255 is being run by microprocessor 500, the instructions of the program are retrieved in program order for execution. Since instructions aren't normally in ICACHE 205 to begin with, a typical ICACHE refill operation will first be discussed.
  • BIU bus interface unit
  • a four word block is the minimum transfer size, since in this particular embodiment there is only one valid bit per block in the cache. A valid bit indicates that the current 16 byte entry and tag is valid. This means that the entry has been loaded and validated to the currently running program.
  • a block of instructions returns (low-order word first, as opposed to word-of-interest first), it passes through a predecode network (not shown) which generates four bits of information per instruction. If the previous block of instructions has been dispatched, the next instruction block (new instruction block) advances to instruction register 258 and IDECODE 210. Otherwise the next instruction block waits in prefetch buffer 259. Instruction register 258 holds the current four instructions that are the next instructions to be dispatched for speculative execution. Prefetch buffer 259 holds a block of prefetched instructions that ICACHE 205 has requested. These instructions will be subsequently predecoded and fed into ICACHE 205 and IDECODE 210. By holding a block of prefetched instructions in this manner, a buffering action is provided such that dispatching by IDECODE 210 and prefetching need not to run in lockstep.
  • the next instruction block is written into ICACHE 205 when the next instruction which is predicted executed advances to decode if there are no unresolved conditional branches. This approach desirably prevents unneeded instructions from being cached.
  • the predecode information is also written in the cache. Predecode information is information with respect to the size and content of an instruction which assists in quickly channelling a particular instruction to the appropriate functional unit. More information with respect to predecoding is found in the U.S. patent application entitled "Pre-Decoded Instruction Cache And Method Therefor Particularly Suitable For Variable Byte-Length Instructions (Ser. No.
  • branch prediction is used to predict which branches are taken as a program is executed. The prediction is later validated when the branch is actually executed. Prediction occurs during the fetch stage of the microprocessor pipeline.
  • prefetch stream continues until BIU 260 has to give up the external bus (not shown) coupled thereto, the data cache 245 needs external access, the prefetch buffer 259 overflows, a cache hit occurs or a branch or interrupt occurs. From the above it will be appreciated that prefetch streams tend not to be very long. Generally, external prefetches are at most two blocks ahead of what is being dispatched.
  • ICACHE 205 instruction cache 205
  • branch prediction information for each block. This information is cleared on a refill.
  • a 32 bit Fetch PC (FPC) bus is coupled between instruction cache (ICACHE) 205 and fetcher 257 of decoder (IDECODE) 210. More particularly, the FPC bus extends between FPC block 207 in ICACHE 205 and fetcher 257.
  • the Fetch PC or FPC block 207 in instruction cache 205 controls the speculative fetch program counter, designated FPC, located therein.
  • FPC block 207 holds the program count, FPC, associated with the instructions which fetcher 257 prefetches ahead of the dispatch of instructions by decoder 210 to the functional units.
  • the FPC bus indicates the location for the ICACHE to go on an exception or branch prediction.
  • the fetch PC block 207 uses branch prediction information stored in instruction cache 205 to prefetch instructions (4 wide) into decoder 210.
  • the Fetch PC block can either predict sequential accesses, in which case it increments the current Fetch PC by 16 bytes when a new block is required, or branch to a new block.
  • the new branch positions can either be received from the instruction cache for predicted branches, or from the branch functional unit on misprediction or exceptions.
  • the Fetch PC or FPC is to be distinguished from the retire PC discussed earlier.
  • the Fetch PC (FPC) is incremented at PH1 and the next block is read out of ICACHE 205, although IDECODE 210 will stall fetcher 257 by asserting HOLDIFET if it has not dispatched all the instructions from the first block.
  • the function of the HOLDIFET signal is to hold the instruction fetch because the four instructions in instruction register 258 cannot advance.
  • Fetcher 257 also assists in the performance of branch prediction.
  • the branch prediction is an output of instruction cache 205.
  • the four instructions of the next block which is predicted are output by instruction cache 205 onto instruction lines INS0, INS1, INS2 and INS3.
  • An array IC -- NXTBLK (not shown) in instruction cache 205 defines for each block in the cache what instructions are predicted executed in that particular block and also indicates what the next block is predicted to be. In the absence of a branch, execution would always be sequential block by block. Thus, branches that are taken are the only event which changes this block oriented branch prediction. In other words, in one embodiment of the invention, the sequential block by block prediction changes only when a branch predicted not taken is taken and subsequently mispredicted.
  • branch prediction unit (branch unit) 520 notifies ICACHE 205, which updates the prediction information for that block to reflect 1) the branch was taken, 2) the location within the block of the branch instruction and 3) the location in the cache of the target instruction. Fetcher 257 is also redirected to begin fetching at the target.
  • fetcher 257 notes that it contains a branch that was previously taken and does a nonsequential fetch with the following actions: 1) instruction valid bits are set only up to and including the branch's delay slot; Branch delay is a concept of always executing the instruction after a branch and is also referred to as delayed branching. This instruction is already prefetched in a scalar RISC pipeline, so that in the event of a branch there is no overhead lost in executing it. 2) an indication that the branch was predicted taken is sent along with the block to decoder 210; 3) the cache index for the next fetch is taken from the prediction information; (The cache index is the position within the cache for the next block that is predicted executed when a branch occurs.
  • the cache index is not the absolute PC. Rather, the absolute PC is formed by concatenating the TAG at that the position with the cache index.) 4) the block at this cache index is fetched and a predicted target address is formed from the block's tag and the prediction information is placed in the Branch FIFO (BRN FIFO) 261; 5) valid bits for this next block are set starting with the predicted target instruction.
  • BBN FIFO Branch FIFO
  • the Branch FIFO 261 is used to communicate the target address predicted by fetcher 257 to the branch functional unit (BNRSEC) 550. It is noted that, although shown separately, the Branch FIFO 261 is considered to be a part of branching section BRNSEC 550. Branch FIFO 261 is loaded with the PC of the instruction where the branch was predicted taken as well as the target. When the branch instruction is actually dispatched, the branch instruction is compared to the entry in the Branch FIFO, namely the PC stored therein. If there is a match, then the entry is flushed from the Branch FIFO and the branch instruction is returned to reorder buffer 240 as predicted successfully. If there is a misprediction, then the PC that is correct is provided to reorder buffer 240.
  • the prediction bit is dispatched by decoder 210 along with the branch instruction to branch unit 520.
  • the prediction bit indicates whether a particular branch was predicted taken from the information stored in the IC -- NXTBLK array.
  • branch unit 520 executes the instruction, the outcome is compared with the prediction and, if taken, the actual target address is compared with the entry at the top of the Branch FIFO (waiting if necessary for it to appear). If either check fails, branch unit 520 redirects fetcher 257 to the proper target address and updates the prediction. Note that this is how a cache miss is detected for a predicted non-sequential fetch, rather than by fetcher 257.
  • the prediction information contains only a cache index, not a full address, so the tag of the target block cannot be checked for a hit; the target address is assumed to be the address of the block at that index as specified by its tag. If the actual target block has been replaced since the branch was last executed, this will result in a miscompare and correction upon execution. When a misprediction does occur, many instructions past the branch may have been executed, not just its delay slot.
  • branch prediction unit 520 One branch prediction unit which can be used as branch prediction unit 520 is described in U.S. Pat. No. 5,136,697, W. M. Johnson, entitled "System For Reducing Delay For Execution Subsequent To Correctly Predicted Branch Instruction Using Fetch Information Stored With Each Block Of Instructions In Cache, issued Aug. 4, 1992, the disclosure of which is incorporated herein by reference.
  • IDECODE 210 The primary function of IDECODE 210 is to classify instructions according to the functional units that will handle the instructions and dispatch the instructions to those functional units. This is done by broadcasting four 3-bit instruction type codes (INSTYPn) to all the functional units, and in any given cycle asserting a signal for each instruction that is being dispatched (XINSDISP(3:0)). (In this document, some signals appear with and without the X designation. The X, such as in the XINSDISP signal, indicates that a false assertion discharges the bus.) As seen in FIG.3, microprocessor 500 includes 4 TYPE buses, INSTYPn(7:0), for the purpose of broadcasting the type codes to the functional units. A respective TYPE bus is provided for each of the four instructions of a particular block of instructions.
  • INSTYPn 3-bit instruction type codes
  • a particular functional unit When a particular functional unit detects a TYPE signal corresponding to its type, that functional unit knows which one of the four instructions of the current block of instructions in the current dispatch window of IDECODE 210 it is to receive because of the position of the detected type signal on the type bus.
  • the type bus has four sections corresponding to respective dispatch positions of the IDECODE 210. That functional unit also determines which function it is to perform on the operand data of that instruction by the operation code (opcode) occurring on that section of the dispatch information bus corresponding to the detected type. Also, since the functional unit knows which instruction it is to execute, it will align its hardware with the respective destination tag bus, DEST. TAG(0:3), and operand data bus for receiving the operand data and the destination tag.
  • opcode operation code
  • one embodiment of the invention includes two ALUs to reduce the occurrence of class conflict among the functional units: ALU0, ALU1, SHFSEC, BRNSEC, LSSEC, FPTSEC and SRBSEC. Instructions are dispatched to SRBSEC 512 only at serialization points. In other words, only instructions which must be executed serially are sent to SRBSEC 512.
  • Register file (RF) 235 ports not available--in this embodiment there are only four RF read ports, not eight as one might expect for feeding eight operand buses. It has been found that having such a reduced number of read ports is not as limiting as it might first appear since many instructions do not require two operands from register file 235 or can be satisfied via operand forwarding by ROB 240. Other embodiments of the invention are contemplated wherein a greater number of RF read ports, such as eight, for example are employed to avoid a potential register file port not available situation.
  • ROBSTAT reorder buffer
  • IDECODE decoder
  • ROBSTAT (3:0) indicates from the ROB to IDECODE how many of the four current instructions have an ROB entry allocated. It is noted here that it is possible to fill up the entries of the ROB.
  • Serialization--some instructions modify state which is beyond the scope of the mechanisms that preserve sequential state--these instructions must be executed in program order with respect to surrounding instructions (for example, MTSR, MFSR, IRET instructions).
  • ROB 240 keeps track of this and is accessed in parallel with Register File access. Note that operand unavailability or register conflicts are of no concern for dispatch.
  • ROB 240 can be viewed as a circular buffer with a predetermined number of entries and a head and tail pointer.
  • Each entry in the ROB When an instruction is dispatched, an entry in the ROB is reserved for its destination register.
  • Each entry in the ROB consists of: 1) the instruction's destination register address; 2)space for the instruction's result (which may require two entries for a double precision operation or a CALL/JMPFDEC type of instruction), as well as exception status information; and 3) bits to indicate that a) an entry has been allocated and b) a result has returned.
  • Entries are assigned sequentially beginning at the tail pointer.
  • the Allocate bit is set to indicate the instruction has been dispatched.
  • the Allocate bit is associated with each ROB entry.
  • the Allocate bit indicates that a particular ROB entry has been allocated to a pending operation.
  • the Allocate bit is deallocated when an entry retires or an exception occurs.
  • a separate valid bit indicates whether a result has completed and has been written to the register file.
  • the address of an entry (called the result or destination tag) accompanies the corresponding instruction from dispatch through execution and is returned to ROB 240 along with the instruction's result via one of the result buses.
  • the destination tags are employed when an instruction is dispatched to a functional unit and the result tags are employed when the instruction returns, that is, when the result returns from the functional unit to the ROB.
  • destination tags are associated with the dispatched instructions and are provided to the functional unit by the reorder buffer to inform the functional unit as to where the result of a particular instruction is to be stored.
  • the destination tag associated with an instruction is stored in the functional unit and then forwarded on the result bus. Such destination tags are still designated as destination tags when they are transmitted on the result bus. These tags are compared with operand tags in the reservation stations of the other functional units to see if such other functional units need a particular result. The result from a particular functional unit is forwarded back to the corresponding relative speculative position in the ROB.
  • the result of an instruction is placed in the ROB entry identified by the instruction's destination tag which effectively becomes the result tag of that instruction.
  • the valid bit of that particular ROB entry is then set.
  • the results remain there until it is their turn for writeback to the register file. It is possible for entries to be allocated faster to ROB 240 than they are removed, in which case ROB 240 will eventually become full.
  • the reorder buffer full condition is communicated via the ROBSTAT (3:0) bus back to decoder 210.
  • decoder 210 generates the HOLDIFET signal to halt instructions from being fetched from ICACHE 205. It is thus seen that the ROB full condition will stall dispatch by decoder 210.
  • ROB 240 drives the corresponding results on the appropriate operand buses in place of register file 235.
  • ROB 240 activates the OVERRIDE line between ROB 240 and register file 235 to instruct register file 235 not to drive any operands on the A and B operand buses.
  • decoder 210 is decoding the instruction ADD R3, R5, R7 which is defined to mean add the contents of register R3 to the contents of register R5 and place the results in register R7.
  • the source register addresses R3 and R5 decoded in IDECODE are compared with the destination register addresses in ROB 240.
  • the result R3 is contained in ROB 240 and that the result R5 is contained in register file 235.
  • the compare between source address R3 in the decoded instruction and the destination register address R3 in ROB 240 would be positive.
  • ROB entry for register R3 is retrieved from ROB 240 and is broadcast on the operand A bus for latching by the reservation station of the appropriate functional unit, namely ALU0 or ALU1. Since a match was found with an ROB entry in this case, the OVERRIDE line is driven to prevent register file 235 from driving the A operand bus with any retired R3 value it may contain.
  • the compare between the source address R5 in the decoded instruction and the destination register addresses contained in ROB 240 is not successful.
  • the result value R5 contained in register file 235 is thus driven onto the B operand bus where that result is broadcast to the functional units, namely ALU0 for execution.
  • the instruction is issued to ALUO and is executed by ALU0.
  • the result (result operand) is placed on the result bus 265 for transmission to the reservation stations of other functional units which are looking for that result operand.
  • the result operand is also provided to ROB 240 for storage therein at the entry allocated for that result.
  • ROB 240 sends the index of the matching entry (i.e. the result tag of the instruction that will eventually produce the result) to the functional unit in place of the operand.
  • A/B tag buses ie. 4 A tag buses and 4 B tag buses, namely TAGnAB(4:0) and TAGnBB(4:0) wherein n is an integer
  • MSB most significant bit
  • the predecode information that is generated when caching instructions comes into play in decode. It is noted that the predecode information passes from ICACHE 205 to IDECODE 210 over the PREDECODE line.
  • Predecoding operates in the following fashion. For each instruction, there is a predecode signal, PREDECODE, which includes a 2 bit code that speeds up allocation of ROB entries by indicating how many entries are needed (some instructions require one entry, some instructions require two entries). For example, the add instruction ADD (RA+RB) ⁇ RC requires one entry for the single 32 bit result which is to be placed in register RC. It contrast, the multiply instruction DFMULT (RA+RB)(double precision) requires two ROB entries to hold the 64 bit result. In this particular embodiment of the invention, each ROB entry is 32 bits wide. This 2-bit code further indicates how many result operands will result from a given instruction (ie. none--e.g. branches, one--most, or two--double precision).
  • the predecode information includes two additional bits which indicate whether or not a register file access is required for A and B operands. Thus, there are 4 bits of predecode information per 32 bit instruction in microprocessor 500. These bits enable efficient allocation of the register file ports in PH1 prior to the PH2 access. If an instruction is not allocated the register file ports that it needs, but ROB 240 indicates the operands can be forwarded, the instruction may still be dispatched anyway.
  • FIG. 3 shows that all of the functional units of microprocessor 500 reside on a common data processing bus 535.
  • Data processing bus 535 is a high speed bus due to its relatively wide bandwidth.
  • Each of the functional units is equipped with two reservation stations at its input. Other embodiments of the invention are contemplated wherein a greater or lesser number of reservation stations are employed at the functional units.
  • integer unit 515 includes arithmetic logic units ALU0 and ALU1.
  • ALU0 is provided with reservation stations 540 and ALU1 is provided with reservation stations 545.
  • Branching unit 520 (BRNSEC) is furnished with reservation stations 550 at its input.
  • Floating point unit (FPTSEC) 525 includes floating point add unit 555 which is provided with reservation stations 560.
  • Floating point unit 525 further includes a floating point convert unit 565 which is equipped with reservation stations 570.
  • Floating point unit 525 also includes a floating point multiply unit 575 which is equipped with reservation stations 580.
  • floating point unit 525 further includes a floating point divide unit 585 which is furnished with reservation stations 590 at its input.
  • Load/store unit 530 also resides on data processing bus 535 and includes reservation stations 600.
  • each functional unit ie. to each reservation station associated with a functional unit
  • main inputs to each functional unit are provided by the constituent buses of main data processing bus 535, namely:
  • IDECODE 210 designated INSTYPn(7:0) wherein n is an integer from 0-3);
  • a result bus 265 including 3 bidirectional result operand buses (designated XRESOB(31:0), XRES1B(31:0), XRES2B(31:0);
  • a reservation station is essentially a first-in-first-out (FIFO) buffer at which instructions are queued while waiting for execution by the functional unit. If an instruction is dispatched with a tag in place of an operand, or the functional unit is stalled or busy, the instruction is queued in the reservation station, with subsequent instructions queuing up behind it. (Note that issue within a particular functional unit is strictly in-order). If the reservation station fills up, a signal indicating this is asserted to IDECODE. This causes dispatch to stall if another instruction of the same type is encountered.
  • FIFO first-in-first-out
  • Each reservation station includes reservation station logic that watches the instruction TYPE buses (at PH2) for a corresponding instruction type. The reservation station then selects the corresponding opcode, A and B operand and A and B operand tag buses when such an instruction type is encountered. If two or more instructions are seen that will execute in the associated functional unit, the earlier one with respect to program order takes precedence. The instruction is not accepted by the reservation station however until it sees the corresponding dispatch bit set (XINSDISP(n) at PH1).
  • the instruction will immediately go into execution in the same clock cycle. Otherwise, the instruction is placed in the reservation station. If an instruction has been dispatched with an operand tag in place of an operand, the reservation station logic compares the operand tag with result tags appearing on the result tag buses (XRESTAG0B and XRESTAG1B). If a match is seen, the result is taken from the corresponding result bus of result bus group 265. This result is then forwarded into the functional unit if it enables the instruction to issue. Otherwise, the result is placed in the reservation station as an operand where it helps complete the instruction and the corresponding tag valid bit is cleared. Note that both operands may be simultaneously forwarded from either or both of the general purpose result buses.
  • the three result buses forming result bus 265 include two general purpose result buses, XRESOB(31:0) and XRES1B(31:0), and further include one result bus dedicated to branches and stores, XRES2B(31:0). Since result bus XRES2B(31:0) is dedicated to branches and stores, the results that it handles (like the Branch PC address, for example) are not forwarded.
  • the functional units monitor result buses XRES0B(31:0) and XRES1B(31:0) whereas reorder buffer (ROB) 240 monitors all three result buses.
  • any valid operand tags are likewise compared with result tags and similar forwarding is done. Result forwarding between functional units and within a functional unit is done in this manner.
  • This tagging in conjunction with the reservation stations, allows instructions to execute out of order in different functional units while still maintaining proper sequencing of dependencies, and further prevents operand hazards from blocking execution of unrelated subsequent instructions.
  • the instruction types and A/B tags are available in PH2 while the decision to issue is made in the subsequent PH1.
  • Operands in the reservation station have a tag and valid bit if they were not sent actual operand data.
  • an instruction is dispatched to the reservation station and a particular operand is not yet available, then an operand tag associated with that operand is instead provided to the reservation station in place of the actual operand.
  • a valid bit is associated with each operand tag.
  • results are completed at the functional units the results are provided to the result buses which are coupled to the other functional units and to ROB 240.
  • the results are compared against operand tags in the reservation stations and if a hit occurs, the tag valid bit is cleared and the operand from the result bus is forwarded to the location in the functional unit designated for operands. In other words, a tag compare on result tags 0 and 1 that matches any entry in a reservation station forwards the value into that station.
  • the two reservation stations form a first-in-first-out (FIFO) arrangement wherein the first instruction dispatched to the reservation station forms the head of the FIFO and the last instruction dispatched to the FIFO forms the tail of the FIFO.
  • FIFO first-in-first-out
  • Local decoding by the functional unit means that by monitoring the type bus the functional unit first determines that an instruction of its type is being dispatched. Then once the functional unit identifies an instruction which it should process, the functional unit examines the corresponding opcode on the opcode bus to determine the precise instruction which the functional unit should execute.
  • execution time depends on the particular instruction type and the functional unit which is executing that instruction. More particularly, execution time ranges from one cycle for all ALU, shifter, branch operations and load/stores that hit in the cache, to several cycles for floating point, load/store misses and special register operations.
  • a special register is defined as any not general purpose register which is not renamed.
  • Result Bus 2 is used for stores which don't return an operand and also for branches which return the calculated target address. It is noted that branches have priority.
  • General purpose Result Buses 0 and 1 handle results from either ALU0 or ALU1, from shifter unit 510, from floating point unit 525, and also loads and special register accesses.
  • Microprocessor 500 employs 32 bit operand buses to send a double precision (DP) number. More particularly, when a double precision number is transmitted over the operand buses, the number is transmitted in two 32 bit portions, namely an upper 32 bit portion and a lower 32 bit portion. The upper and lower portions are generally transmitted over two cycles and 2 operand buses. The denial of a request for access to a particular result bus by a functional unit will stall that functional unit and may propagate back to decode as a reservation station full condition.
  • Results include a 3-bit status code (RESULT STATUS) indicating the type of result (none, normal or exception, plus instruction specific codes, namely data cache miss, assert trap and branch misprediction).
  • a result also includes a 32-bit result operand and detailed execution or exception status depending on the unit and instruction.
  • the result buses 235 are used to return results to ROB 240 as well as for forwarding results to the functional unit reservation stations. All of the result information is stored in ROB 240, but functional units only look at the result status code and result operand.
  • SRBSEC Special Register Block Section
  • LSSEC Load/Store Section
  • the SRBSEC functional unit keeps machine state information such as status and control registers which are infrequently updated and which are not supported by register renaming. Moves to and from the special registers of SRBSEC 512 are always serialized with respect to surrounding instructions. Thus, the SRBSEC, while being a separate functional unit, does not need a reservation station since serialization assures that operands are always available from register file 235. Examples of instructions which are executed by the SRBSEC functional unit are the "move to special register" MTSR and "move from special register" MFSR instructions. Before executing such an instruction which requires serialization, microprocessor 500 serializes or executes all speculative states before this instruction. The same special register block as employed in the AM29000 microprocessor manufacturing by Advanced Micro Devices may be employed as SRBSEC 512.
  • the load/store section LSSEC 530 uses a reservation station in the same manner as the other functional units. Load/store section 530 controls the loading of data from data cache 245 and the storing of data in data cache 245. However, with respect to execution of instructions, it is the most complex functional unit.
  • the LSSEC is closely coupled with the data cache (DCACHE) 245 and memory management unit (MMU) 247.
  • Microprocessor 500 is designed such that any action that modifies data cache 245 or main memory 255 may not be undone. Moreover, such modification must take place in program order with respect to surrounding instructions. This means that the execution of loads that miss in the data cache, and all stores, must be coordinated with retire logic 242 in the ROB 240. This is done using a mechanism called the Access Buffer 605, which is a FIFO where these operations are queued until the corresponding ROB entries are encountered by the ROB retire logic.
  • Access buffer 605 is located in LSSEC 530.
  • access buffer 605 is a 2-4 word FIFO of stores (hit/miss) or loads that miss. A store that hits cannot be written until it is next to execute.
  • an access or store buffer allows this state to be held in a temporary storage which can subsequently forward data references in a manner similar to the way the ROB forwards register references.
  • the access buffer finally writes to data cache 245 (CACHE) when the access buffer contents are next in program order.
  • an access buffer or store buffer is a FIFO buffer which stores one or more load/store instructions so that other load/store instruction can continue to be processed. For example, access buffer 605 can hold a store while a subsequent load is being executed by load/store unit LSSEC 530.
  • Access buffers which are also known as store buffers, and a load/store functional unit used in conjunction with a data cache are discussed in more detail in copending patent application entitled High Performance Load/Store Functional Unit And Data Cache, filed concurrently herewith and assigned to the instant assignee, the disclosure of which is incorporated herein by reference.
  • ROB retire logic 242 determines which instructions are to be retired into register file 235 from ROB 240.
  • the criteria for such retirement of an ROB entry are that the entry be valid and allocated, that the result has been returned from a functional unit, and that the entry has not been marked with a misprediction or exception event.
  • a store operation requires two operands, namely memory address and data.
  • a store When a store is issued, it is transferred from the LSSEC reservation station 600 to the Access Buffer 605 and a store result status is returned to ROB 240.
  • the store may be issued even though the data is not yet available, although the address must be there. In that case, the Access Buffer will pick up the store data from result buses 235 using the tag in a manner similar to a reservation station.
  • the translation lookaside buffer (TLB) 615 lookup is done in memory management unit (MMU) 247 and the Data Cache is accessed to check for a hit.
  • MMU memory management unit
  • the physical address from the MMU and the page portion of the virtual address along with status info from the data cache is placed in the Access Buffer. In other words, the cache is physically addressed. If a TLB miss occurs, this is reflected in the result status and an appropriate trap vector is driven on Result Bus 2--no other action is taken at that time. (The TLB lookup for loads is done the same way, although any trap vector goes on Result Bus 1.)
  • a trap vector is an exception.
  • Microprocessor 500 takes a TLB trap to load a new page into physical memory and update the TLB. This action may take several hundred cycles but it is a relatively infrequent event.
  • Microprocessor 500 freezes the PC, stores out the microprocessor registers, executes the vector, restores the register state, then executes an interrupt return.
  • LSSEC 530 provides ROB 240 with a signal indicating when LSSEC has completed an operation by asserting LSDONE. It is noted that ROB 240 stalls on a store (or load) if it has not seen LSDONE since the previous store was retired.
  • a load operation that hits in data cache 245 does not have to be coordinated with ROB 240. However, a miss must be coordinated with ROB 240 to avoid unnecessary refills and invalid external references past a mispredicted branch.
  • the cache access is done right away (provided the cache is not busy). If there is a hit in the cache, the result is returned to the ROB on the Result Bus with a normal status code. If there is a miss, the load is placed in the Access Buffer 605 and a load -- miss result code is returned.
  • ROB 240 retire logic 242 When the ROB 240 retire logic 242 encounters this condition, it asserts LSRETIRE and the refill starts with the desired word being placed on the Result Bus with a load -- valid result status code as soon as it comes along (no wait for refill to finish). It is noted that ROB 240 can't retire a load upon asserting LSRETIRE like it does for a store. Rather, ROB 240 must wait for the data to return.
  • a load may be processed even if there are previous uncompleted store operations waiting in the Access Buffer.
  • microprocessor 500 ensures that the load is not done from a location that is yet to be modified by a previous (with respect to program order) store. This is done by comparing the load address with any store addresses in Access Buffer 605, in parallel with the cache access. If none match, the load goes ahead. If one does match (the most recent entry if more than one), then the store data is forwarded from Access Buffer 605 to the result bus 265 instead of the cache data. Any cache miss that may have occurred is ignored (ie. no refill occurs). If the store data is not yet present, the load stalls until the store data arrives. Moreover, these actions desirably prevent memory accesses from unnecessarily inhibiting parallelism.
  • TLB translation lookaside buffer
  • Access Buffer forwarding is not done for partial-word load/store operations. If a word-address match is detected and there is any overlap between the load and store, the load is forced to look like a cache miss and is queued in access buffer 605 so that it will execute after the store (and may or may not actually hit in the cache). If there is no overlap, the load proceeds as though there were no address match.
  • load/store multiple instructions are executed in serialized fashion, that is, when load/store multiple operation are being executed, no other instructions are executed in parallel.
  • a load or store (load/store) multiple instruction is a block move to or from the register file. This instruction includes a given address, a given register, and a count field.
  • An example of a load/store multiple instruction is LOADM (C,A,B) wherein C is the destination register, A is the address register and B is the number of transfers.
  • results are written into the entry specified by the result tag, which will be somewhere between the head and tail pointers of the ROB.
  • the retire logic 242 which controls writeback, the execution of stores and load misses, traps and updating of PC0, PC1 and PC2, looks at entries with valid results in program order.
  • PC0, PC1 and PC2 are mapped registers containing the PC values of DEC, EXEC and WRITEBACK0,1.
  • the signal DEC, EXEC and WRITEBACK 0,1 refer to the stages decode, execute and writeback from the scalar AM29000 pipeline, the AMD2900 being a microprocessor available from Advanced Micro Devices, Inc. These signals are used to restart the pipeline upon an exception. More than one PC is used because of delayed branching.
  • PC0, PC1 and PC2 are used on an interrupt or trap to hold the old value of DEC, EXEC and WRITEBACK0,1 to which microprocessor 500 can return upon encountering a branch misprediction or exception.
  • PC0, PC1 and PC2 are used on interrupt return for restarting the pipeline, and are contained in retirement logic 242 in reorder buffer 240.
  • PC1 maps the current retire PC.
  • ROB 240 can additionally retire one store and one branch, for a maximum of four instructions being retireable per microprocessor cycle.
  • CPS refers to the current processor status
  • CPS indicates program state and condition code registers.
  • FPS refers to floating point status register bits.
  • FPS indicates status/condition code registers for the floating point functional unit 525.
  • FPS Sticky Bits are bits that can be set by a set condition and not cleared on clear condition. FPS Sticky Bits are used for rounding control on floating point numbers. For example, if microprocessor 500 subtracts or shifts a value, some of the least significant bits (LSB's) may be shifted off the mantissa. The FPS Sticky Bits give an indication that this condition has occurred.
  • ROB 240 An entry in ROB 240 whose results have not yet returned causes further processing to stall until the results come back. None past that entry may be retired, even if valid.
  • ROB 240 gives the go-ahead to the load/store section to actually do the store and then retires the instruction.
  • ROB 240 gives the go-ahead to execute the load.
  • the load completes, the requested load operand is returned to ROB 240 with load hit status, which allows the instruction to be retired and which is also seen by any reservation stations waiting for that operand.
  • ROB 240 uses it to update PC1
  • the architectural state of the microprocessor is the current state of the retirement PC in the program.
  • the speculative state of the microprocessor is all of the entries in the reorder buffer, in the decoder and the current value of the FETCHPC. These form the current speculative queue of instructions which is dynamically updated. On exception or misprediction, all of the speculative state can be cleared, but not the architectural state, since it is the current state of the register file.
  • the corresponding entry in the ROB is allocated as being mispredicted.
  • the subsequent entries are forwarded from the functional unit, they are marked as completed but mispredicted.
  • the retire logic 242 in reorder buffer 240 ignores these entries and de-allocates them.
  • the branch result status which indicates taken/not-taken and correct/incorrect prediction, is returned to ROB 240.
  • a mispredict result causes the ROB to immediately set a Cancel bit in all entries from the second one after the branch entry (to account for the delay slot) to the tail pointer.
  • decode will begin dispatching the target instructions, which are assigned tags as usual starting from the tail pointer.
  • the cancelled entries are encountered by ROB retire logic 242, they are discarded.
  • Load/store unit 530 is notified of any cancellations for which it is waiting on a go-ahead from the ROB via an LSCANCEL signal which is transmitted on an LSCANCEL line between ROB 240 and load/store section LSSEC 530.
  • the LSCANCEL signal indicates any pending store or load miss in access buffer 605 which is to be cancelled.
  • Access buffer 605 behaves as a FIFO and the next oldest store is the instruction which is cancelled. More detail with respect to one load/store section and access buffer which may be employed as load/store section LSSEC 530 and access buffer (store buffer) 605 is found in the copending patent application entitled "High Performance Load/Store Functional Unit And Data Cache" (Ser. No. 08,146,376), the disclosure of which is incorporated herein by reference.
  • the appropriate trap vector number is generally returned in place of the normal result operand (except in cases where the RF update is not inhibited, in which case the ROB generates the vector number).
  • the trap vector number is the number that indicates which of the may kinds of traps has occurred and where to go upon the occurrence of a particular trap. Typical examples which result in the occurrence of a trap are a divide by zero, arithmetic overflow and a missing TLB page.
  • ROB 240 When ROB 240 encounters the exception status in the process of retiring instructions, it initiates a trap operation which consists of clearing all entries from ROB 240, asserting an EXCEPTION signal to all functional units to clear them (and IDECODE), generating a trap vector per the Vf bit and redirecting the fetcher 257 to trap handling code.
  • the Vf bit indicates whether a trap should be taken as an external fetch (as a load from a table of vectors) or internally generated by concatenating a constant with the vector number.
  • the Vf bit is a feature of the architecture of the Advanced Micro Devices Am29000 microprocessor series.
  • register file 235 represents the current execution state of the microprocessor.
  • data stored in ROB 240 represents the predicted execution state of the microprocessor.
  • the corresponding result stored in ROB 240 is transmitted to register file 235 and is then retired.
  • Table 2 depicts the pipeline stages of microprocessor 500 together with significant events which occur during each of those stages. The stages of the pipeline are listed below in the first column of Table 2.
  • Table 2 shows what happens in each phase (PH1 and PH2 of each microprocessor cycle) as a basic integer instruction flows through microprocessor 500 with no stalls, as well as branch correction timing (in brackets).
  • Memory Management Unit (MMU) 247 is essentially the same as in the AM29050 microprocessor manufactured by Advanced Micro Devices, Inc. MMU 247 translates virtual addresses to physical addresses for instruction fetch as well as for data access. A difference with respect to instruction fetch between the AM29050 and microprocessor 500 is that in the AM29050 the MMU is consulted on a reference to the branch target cache BTC whereas microprocessor 500 does not employ a branch target cache and does not consult the MMU for a BTC reference.
  • the branch target cache is a cache of branch targets only.
  • the branch target cache forms part of the scalar pipeline of the Am29050 microprocessor manufactured by Advanced Micro Devices.
  • the BTC fetches instructions once per clock cycle.
  • ICACHE 205 contains a one-entry translation lookaside buffer (TLB) 615 to which ICACHE refers on cache misses.
  • TLB translation lookaside buffer
  • the TLB is refilled when a translation is required that does not hit in the one entry TLB.
  • TLB 615 is refilled as needed from the MMU. Since MMU 247 is not closely coupled to ICACHE 205, this reduces refill time and also desirably reduces the load on the MMU.
  • Data cache 245 is organized as a physically-addressed, 2 way set associative 8K cache.
  • the address translation is done first. This requirement is true for 1K and 2K page sizes, and increases the latency of loads that hit to two cycles.
  • 4K page sizes which have one bit of uncertainty in the cache index, are handled by splitting the cache into two 4K arrays which allows access to both possible blocks.
  • a 4-way compare is done between the two cache tags and the two physical addresses from the MMU to select the right one.
  • Data cache 245 implements a mixed copyback/writethrough policy. More particularly, write misses are done as writethrough, with no allocation; write hits occur only on blocks previously allocated by a load, and may cause a writethrough, depending on cache coherency.
  • Microprocessor 500 supports data cache coherency for multi-processor systems and efficient I/O of cacheable memory using the known MOESI--Modified Owned Exclusive Shared Invalid (Futurebus) protocol.
  • the MOESI protocol indicates 1 of 5 states of a particular cache block. Whereas microprocessor 500 of FIG. 3 employs the MOESI protocol, the later discussed microprocessor of FIG. 6 employs the similar MESI protocol.
  • Bus interface unit (BIU) 260 employs the same external interface as the AMD29030 microprocessor manufactured by Advanced Micro Devices, Inc.
  • BIU 260 employs a single internal 32 bit bus for addresses, instructions, and data, namely internal address data (IAD) bus 250.
  • IAD internal address data
  • main memory 255 is a single flat space with only a distinction between I/O and data/instruction.
  • memory 255 includes no read only memory (ROM) and exhibits no distinction between instructions and data.
  • ROM read only memory
  • Other types of external memory arrangements may alternatively be employed as main memory 255.
  • IAD bus 250 is used mainly for communication between the BIU 260 and the caches (ICACHE 205, DCACHE 245), for external accesses on cache misses and coherency operations.
  • IAD bus 250 handles both addresses and data. It is a static bus, with BIU 260 driving during PH1 and all other units driving during PH2. Any request for the IAD bus 250 must go through bus arbitration and granting which is provided by bus arbitration block 700 shown in FIG. 5. To conserve space, bus arbitration block 700 is not shown in the block diagram of microprocessor 500 of FIG. 3.
  • Arbitration for the IAD bus includes bus watching (for cache coherency) which gets first priority in the arbitration activities.
  • a request for the IAD bus is made during early PH1 and is responded to in very late PH1. If a functional unit is granted the IAD bus in PH1, it may drive an address onto the IAD bus during the following PH2 and request some action by the BIU (for example, instruction fetch, load)
  • IAD bus 250 is a relatively low frequency address, data and control bus that links all the major arrays in microprocessor 500 to each other and the external bus. IAD bus 250 provides relatively low frequency transfers of operations such as bus watching, cache refill, MMU translations and special register updates to mapped arrays. In one embodiment of the invention, IAD bus 250 includes 32 bits onto which address and data are multiplexed. IAD 250 bus 250 also includes 12 control lines, namely a read control line and a write control line for each of the blocks coupled thereto, namely for ICACHE, DCACHE, the TLB, the SRBSEC, the LSSEC and the BIU.
  • the IAD arbitration block 700 shown in FIG. 5 employs a request/grant protocol to determine which component (ICACHE 205, BIU 260, BRNSEC 520, DCACHE 245, SRBSEC 512 or MMU 247) is granted access to IAD bus 250 at any particular time.
  • the external memory 255 via BIU 260 is granted the highest priority for bus watching purposes.
  • Bus watching is part of data consistency protocol for microprocessor 500. Since microprocessor 500 can include modified data which can be held locally in the data cache, such data is updated when writes to memory occur. Microprocessor 500 also provides the modified data if a read occurs to a modified block which is locally held in the data cache. A copy back scheme with bus watching is employed in the caching operation of microprocessor 500.
  • IAD arbitration block 700 includes a respective grant line for each of ICACHE 205, BIU 260, BRNSEC 520, DCACHE 245, SRBSEC 512 or MMU 247.
  • IAD arbitration block 700 includes a respective grant line for each of ICACHE 205, BIU 260, BRNSEC 520, DCACHE 245, SRBSEC 512 or MMU 247.
  • BIU 260 transmits an IAD bus access request to IAD arbitration block 700 and control 705.
  • IAD arbitration block 700 determines the priority of requests when multiple requests for access to IAD bus 250 are present at the same time.
  • Arbitration block 700 then issues a grant on the grant line of the particular device which it has decided should be granted access to the IAD bus according the priority scheme. In the present example, a grant signal is issued on the BIU grant line and BIU 260 then proceeds to access IAD bus 250.
  • control circuit 705 The output of control circuit 705 is coupled to IAD bus 250.
  • Each of the following components ICACHE 205, BIU 260, BRNSEC 520, SRBSEC 512, DCACHE 245 and MMU 247 are equipped with a driver circuit 710 to enable such components to drive IAD bus 250.
  • Each of these components is further equipped with a latch 715 to enable these components to latch values from IAD bus 250.
  • Control circuit 705 provides the request grant protocol for the IAD bus.
  • a functional unit locally realizes that access to the IAD bus is desired and sends a request to arbitration block 700.
  • Arbitration block 700 takes the highest priority request and grants access accordingly.
  • Latch 715 signifies the read of the requested data if a transfer is occurring to this block.
  • Driver 710 signifies the driving of the locally available value, to drive some other position where another block will read it. Going through this bus arbitration to gain access to IAD bus 250 adds some latency, but has been found to nevertheless provide acceptable performance. Providing microprocessor 500 with IAD bus 250 is significantly more cost effective than providing dedicated paths among all the sections listed above which are connected to the IAD bus.
  • FIG. 5A is a timing diagram illustrating the status of selected signals in microprocessor 500 throughout the multiple stages of the pipeline thereof.
  • FIG. 5A shows such pipeline for sequential processing.
  • the timing diagram of FIG. 5B shows a similar timing diagram for microprocessor 500 except that the timing diagram of FIG. 5B is directed to the case where a branch misprediction and recovery occurs.
  • FIG. 5A and 5B depict the operation of microprocessor 500 throughout the five effective pipeline stages of fetch, decode, execute, result/ROB (result forward--result forwarded to the ROB), retire/register file (writeback--operand retired from the ROB to the register file).
  • the five stages of the microprocessor pipeline are listed horizontally at the top of these timing diagrams.
  • the signals which compose these timing diagrams are listed vertically at the left of the diagrams and are listed as follows:
  • the Ph1 signal is the clocking signal for microprocessor 500.
  • FPC(31:0) is the fetch PC bus (FPC).
  • IRO-3 (31:0) represent the instruction buses.
  • the timing diagrams also shows the source A/B pointers which indicate which particular operands that a particular decode instruction needs in the ROB.
  • the timing diagram also includes REGF/ROB access which indicates register file/ROB access.
  • the Issue instr/dest tags signal indicates the issuance of instructions/destination tags.
  • the A/B read operand buses signal indicates the transfer of A and B operands on the A and B operand buses.
  • the Funct unit exec. signal indicates execution of an issued instruction at a functional unit.
  • the Result bus arb signal indicates arbitration for the result bus.
  • the Result bus forward signal indicates the forwarding of results on the result bus once such results are generated by the functional unit.
  • the ROB write result signal indicates that the result is written to the ROB.
  • the ROB tag forward signal indicates the forwarding of an operand tag from the ROB to a functional unit.
  • the REGF write/retire signal indicates the retirement of a result from the ROB to the register file.
  • the PC(31:0) signal indicates the program counter (PC) which is updated whenever an instruction is retired as no longer being speculative.
  • the pipeline is illustrated for executing a sequential instruction stream.
  • the predicted execution path is actually taken as well as being available directly from the cache.
  • instructions are fetched from the cache for processing by the microprocessor.
  • An instruction is decoded in the decode pipeline stage and executed in the execute pipeline stage.
  • the source operand buses and result buses are 32 bits in width which corresponds to the integer size. Two cycles are required of an instruction buses operand buses to drive a 64-bit value for a double precision floating point operation.
  • operand values are forwarded directly from the functional unit which generated the result to other functional units for execution.
  • clock phase PH1 of the result stage the location of the speculative instruction is written with the destination result as well as any status.
  • the result generated by a functional unit is placed in an entry in the reorder buffer and this entry is given an indication of being valid as well as being allocated.
  • the reorder buffer can now directly forward operand data for a requested operand rather than forwarding an operand tag.
  • the newly allocated tag can be detected by subsequent instructions that require the tag to be one of their source operands. This is illustrated in the timing diagram of FIG.
  • the retire pipeline stage which is the last stage of the pipeline, is where the real Program Counter (PC) or retire PC is kept.
  • PC Program Counter
  • the result of the operation is written from the reorder buffer to the register file and the retire PC is updated to reflect this writeback.
  • the retire PC is updated to include the instruction which was just retired to the register file as being no longer speculative.
  • the entry for this instruction or result in the reorder buffer is de-allocated. Since the entry is deallocated, subsequent references to the register "c" will result in a read from the register file instead of a speculative read from the reorder buffer.
  • FIG. 5B shows the same 5 pipeline stages as the timing diagram of FIG. 5A. However, the timing diagram of FIG. 5B shows the operation of microprocessor 500 when a branch misprediction occurs.
  • XFPC designates an inversion of the FPC bus signal.
  • microprocessor 800 is capable of processing instructions wherein the opcodes are variable in size.
  • microprocessor 800 is capable of processing so-called X86 instructions which are employed by the familiar IntelTM instruction set which uses variable length opcodes.
  • Microprocessor 800 employs a RISC core which is similar to the RISC core of microprocessor 500 above.
  • RISC core refers to the central kernel of microprocessor 500 which is an inherently RISC (Reduced Instruction Set Computer) architecture including the functional units, reorder buffer, register file and instruction decoder of microprocessor 500.
  • microprocessor 800 is capable of taking so-called CISC (Complete Instruction Set Computer) instructions such as those found in the IntelTM X86 instruction set and converting these instructions to RISC-like instructions (ROP's) which are then processed by the RISC core.
  • CISC Complete Instruction Set Computer
  • ROP's RISC-like instructions
  • Decoder 805 decodes CISC instructions, converts the CISC instructions to ROP's, and then dispatches the ROP's to functional units for execution. More detail with respect to the structure and operation of decoder 805 is found in the co-pending patent application entitled “Superscalar Instruction Decoder” (Ser. No. 08/146,383) filed concurrently herewith and assigned to the instant assignee, the disclosure of which is incorporated herein by reference.
  • Instruction cache 810 is the component of microprocessor 800 which provides this instruction supply as a queue of bytes or byte queue (byte Q) 815.
  • instruction cache 810 is a 16K byte effective four-way set associative, linearly addressed instruction cache.
  • the byte Q 815 of instruction cache 810 is supplied to instruction decoder 805.
  • Instruction decoder 805 maps each instruction provided thereto into one or more ROP's.
  • the ROP dispatch window 820 of decoder 805 includes four dispatch positions into which an instruction from ICACHE 810 can be mapped.
  • the four dispatch positions are designated as D0, D1, D2, and D3.
  • the instruction provided by byte Q 815 to decoder 805 is an instruction which can be mapped to two ROP dispatch positions.
  • decoder 805 maps the instruction into a first ROP which is provided to dispatch position D0 and a second ROP which is provided to dispatch position D1.
  • a subsequent second instruction is mappable to three ROP positions.
  • this second instruction is provided by byte Q 815 to decoder 805, the instruction is mapped into a third ROP which is provided to dispatch position D2 and a fourth ROP which is provided to dispatch position D3.
  • the ROP's present at dispatch positions D0 through D3 are then dispatched to the functional units. It is noted that the remaining third ROP onto which the second instruction is mapped must wait for the next dispatch window to be processed before such ROP can be dispatched.
  • Branch prediction block 825 is the next block array indicating on a block by block basis the next predicted branch location.
  • Branch functional unit 835 executes branches in a manner similar to that of BRNSEC 520 of microprocessor 500 of FIG. 3.
  • Instruction cache 810 is also equipped with a prefetcher block 830 which fetches requested instruction cache misses from external memory.
  • Microprocessor 800 includes four integer functional units to which the four ROP positions of decoder 805 can be issued, namely, branch functional unit 835, ALU0/shifter functional unit 840, ALU1 functional unit 845, and special register functional unit 850.
  • Branch functional unit 835 has a one cycle latency such that one new ROP can be accepted by branch functional unit 835 per clock cycle.
  • Branch unit 835 includes a two entry reservation station 835R. For purposes of this document, a reservation station including two entries is considered to be synonymous with two reservation stations.
  • Branch function unit 835 handles all X86 branch, call, and return instructions. It also handles conditional branch routines.
  • ALU0/shifter functional unit 840 exhibits a one cycle latency. One new ROP can be accepted into unit 840 per clock cycle.
  • ALU0/shifter functional unit 840 includes a two entry reservation station 840R which holds up to two speculative ROP's. All X86 arithmetic and logic calculations go through this functional unit or alternatively the other arithmetic logic unit ALU1, 845. Moreover, shift. rotate or find first one instructions are provided to ALU0/shifter function unit 840.
  • the ALU1 functional unit 845 exhibits a one cycle latency as well. It is noted that one new ROP can be accepted by ALU1 functional unit 845 per clock cycle.
  • the ALU1 functional unit includes a two entry reservation station 845R which holds up to two speculative ROP's. All X86 arithmetic and logic calculations go through this function unit or the other arithmetic logic unit, ALU0. ALU0 and ALU1 allow up to two integer result operations to be calculated per clock cycle.
  • the special register functional unit 850 is a special block for handling internal control, status, and mapped state that is outside the X86 register file 855.
  • special register functional unit 850 has no reservation station because no speculative state is pending when an ROP is issued to special register functional unit 850.
  • Special register block 850 is similar in structure and function to the special register block 512 described earlier in this document.
  • a load/store functional unit 860 and a floating point functional unit 865 are coupled to ROP dispatch window 820 of decoder 805.
  • Load/store functional unit 860 includes a multiple entry reservation station 860R.
  • Floating point functional unit 865 includes two reservation stations 865R.
  • a data cache 870 is coupled to load/store functional unit 860 to provide data storage and retrieval therefor.
  • Floating point functional unit 865 is linked to a 41 bit mixed integer/floating point operand bus 875 and result buses 880.
  • operand buses 875 include eight read operand buses exhibiting a 41 bit width.
  • Result buses 880 include 5 result buses exhibiting a 41 bit width.
  • floating point unit 865 to the mixed integer/floating point operand and result buses allows one register file 855 and one reorder buffer 885 to be used for both speculative integer and floating point ROP's.
  • Two ROP's form an 80 bit extended precision operation that is input from floating point reservation station 865R into an 80 bit floating point core within floating point function 865.
  • the 80 bit floating point core of floating point functional unit 865 includes a floating point adder, a floating point multiplier and a floating point divide/square root functional units.
  • the floating point adder functional unit within floating point unit 865 exhibits a two cycle latency.
  • the floating point adder calculates an 80 bit extended result which is then forwarded.
  • the floating point multiplier exhibits a six cycle latency for extended precision multiply operations.
  • a 32 ⁇ 32 multiplier is employed for single precision multiplication operations.
  • the 32 ⁇ 32 multiplier within floating point functional unit 865 is multi-cycled for 64 bit mantissa operations which require extended precision.
  • the floating point divide/square root functional unit employs a radix-4 interactive divide to calculate 2 bits/clock of the 64 bit mantissa.
  • bus width of the A/B operand buses is 41 bits, that with respect to those A/B operand buses running to the integer units, 32 bits is dedicated to operands and the remaining 9 bits is control information. It should also be noted that other embodiments of the invention are contemplated wherein the bus width of the A/B operand buses is not 41 bits, but rather is 32 bits or other size. In such a 32 bit operand bus width arrangement, control lines separate from the operand bus are employed for transmission of control information.
  • Load store functional unit 860 includes a four entry reservation station 860R. Load store functional unit 860 permits two load or store operations to be issued per clock cycle. The load store section also calculates the linear address and checks access rights to a requested segment of memory. The latency of a load or store operation relative to checking a hit/miss in data cache 870 is one cycle. Up to two load operations can simultaneously access data cache 870 and forward their operation to result buses 880. Load store section 860 handles both integer and floating point load and store operations.
  • microprocessor 800 includes a register file 855 which is coupled to a reorder buffer 885. Both register file 855 and reorder buffer 885 are coupled via operand steering circuit 890 to operand buses 875. Register file 855, reorder buffer 885 and operand steering circuit 890 cooperate to provide operands to the functional units. As results are obtained from the functional units, these results are transmitted to reorder buffer 885 and stored as entries therein.
  • register file 855 and reorder buffer 885 provide storage for operands during program execution.
  • Register file 855 contains the mapped X86 registers for both the integer and floating point instructions.
  • the register file contains temporary integer and floating point registers as well for holding intermediate calculations.
  • all of the registers in register file 855 are implemented as eight read and four write latches.
  • the four write ports thus provided allow up to two register file destinations to be written per clock. This can be either one integer value per port or one-half a floating point value per port if a floating point result is being written to the register file.
  • the eight read ports allow four ROPS with two source read operations each to be issued per clock cycle.
  • Reorder buffer 885 is organized as a 16 entry circular FIFO which holds a queue of up to 16 speculative ROP's. Reorder buffer 885 is thus capable of allocating 16 entries, each of which can contain an integer result or one-half of a floating point result. Reorder buffer 885 can allocate four ROP's per clock cycle and can validate up to five ROP's per clock cycle and retire up to four ROP's into register file 855 per clock cycle. The current speculative state of microprocessor 800 is held in reorder buffer 885 for subsequent forwarding as necessary. Reorder buffer 885 also maintains a state with each entry that indicates the relative order of each ROP. Reorder buffer 885 also marks mispredictions and exceptions for handling by an interrupt or trap routine.
  • Reorder buffer 885 can drive the eight operand buses 875 with eight operands, respectively. Reorder buffer 885 can receive up to five results per clock cycle on the five result buses 880. It is noted that the operand buses are eight 41 bit shared integer/floating point buses. The eight operand buses correspond to the four ROP dispatch positions in ROP dispatch window 820 of decoder 805. Each of the four ROP dispatch positions can have a source A read operand and a source B read operand. Each of the four A and B read operand bus pairs thus formed are dedicated to a fixed ROP and source read location in ROP dispatch window 820.
  • Register file 855 and reorder buffer 885 are the devices in microprocessor 800 which drive read operand buses 875. If no speculative destination exists for a decoded ROP, that is if an operand requested by the ROP does not exist in the reorder buffer, then the register file supplies the operand. However, if a speculative destination does exist, that is if an operand requested by the decoded ROP does exist in the reorder buffer, then the newest entry in the reorder buffer for that operand is forwarded to a functional unit instead of the corresponding register.
  • This reorder buffer result value can be a speculative result if it is present in the reorder buffer or a reorder buffer tag for a speculative destination that is still being completed in a functional unit.
  • the five result buses 880 are 41 bit buses. It is also noted that the read operand and result buses are inputs and outputs to all of the integer functional units. These same read operand and result buses are also inputs and outputs to the floating point reservation station 865R of the floating point functional unit 865.
  • the floating point reservation station 865R converts the 41 bit operand and result buses to 80 bit extended precision buses that it routes to its constituent dedicated functional units as necessary.
  • the integer and floating point functional units of microprocessor 800 are provided with local buffering of ROP's via the reservation stations of those units. In most of these functional units, this local buffering takes the form of two entry reservation stations organized as FIFO's.
  • the purpose of such reservation stations is to allow the dispatch logic of decoder 805 to send speculative ROP's to the functional units regardless of whether the source operands of such speculative ROP's are currently available.
  • a large number of speculative ROP's can be issued (up to 16) without waiting for a long calculation or a load to complete. In this manner, much more of the instruction level parallelism is exposed and microprocessor 800 is permitted to operate closer to its peak performance.
  • Each entry of a reservation station can hold two source operands or tags plus information with respect to the destination and opcode associated with each of the entries.
  • the reservation stations can also forward source operand results which the reorder buffer has marked as being pending (those operands for which the reorder buffer has marked by instead providing an operand tag rather than the operand itself) directly to other functional units which are waiting for such results.
  • reservation stations at the functional units typically accept one new entry per clock cycle and can forward one new entry per clock cycle to the functional unit.
  • load/store section 860 which can accept and retire two entries per clock cycle from its reservation station.
  • Load/store section 860 also has a deeper reservation station FIFO of four entries.
  • All reservation station entries can be deallocated within a clock cycle should an exception occur. If a branch misprediction occurs, intermediate results are flushed out of the functional units and are deallocated from the reorder buffer.
  • Microprocessor 800 includes an internal address data bus 895 which is coupled to instruction cache 810 via prefetch unit 830 and to bus interface unit 900.
  • Bus interface unit 900 is coupled to a main memory or external memory (not shown) so that microprocessor 800 is provided with external memory access.
  • IAD bus 895 is also coupled to load/store functional unit 860 as shown in FIG. 6.
  • a data cache 870 is coupled to load/store unit 860.
  • data cache 870 is an 8k byte, linearly addressed, two way set associative, dual access cache. Address and data lines couple data cache 870 to load/store functional unit 860 as shown. More specifically, data cache 870 includes two sets of address and data paths between cache 870 and load/store unit 860 to enable two concurrent accesses from load/store functional unit 860. These two accesses can be between 8 and 32 bit load or store accesses aligned to the 16 byte data cache line size. Data cache 870 is organized into 16 byte lines or blocks. In this particular embodiment, data cache 870 is linearly addressed or accessed from the segment based address, but not a page table based physical address.
  • Data cache 870 includes four banks which are organized such that one line in the data cache has 4 bytes in each of the 4 banks. Thus, as long as the linear address of bits [3:2] of the two accesses are not identical, the two accesses can access the data array in cache 870 concurrently.
  • Data cache 870 is two-way associative. It takes the two linear addresses in phase PH1 of the clock and accesses its four banks. The resultant load operations complete in the following clock phase PH2, and can then drive one of the result buses. Requests by functional units for the result busses are arbitrated with requests from the other functional units that desire to write back a result.
  • Instruction cache 810 and data cache 870 include a respective instruction cache linear tag array and a data cache linear tag array corresponding to the addresses of those instructions and data entries which are stored in these cache's.
  • microprocessor 800 also includes a physical tags I/D block 910 which is coupled to IAD bus 895 for the purpose of tracking the physical addresses of instructions and data in instruction cache 810 and data cache 870, respectively. More specifically, physical tags I/D block 910 includes physical instruction/data tag arrays which maintain the physical addresses of these caches.
  • the physical instruction tag array of block 910 mirrors the organization for the corresponding linear instruction tag array of the instruction cache 810. Similarly, the organization of the physical data tag array within block 910 mirrors the organization of the corresponding linear data tag array within instruction cache 810.
  • the physical I/D tags have valid, shared, and modified bits, depending on whether they are instruction cache or data cache tags. If a data cache physical tag has a modified bit set, this indicates that the data element requested is at the equivalent location in the linear data cache. Microprocessor 800 will then start a back-off cycle to external memory and write the requested modified block back to memory where the requesting device can subsequently see it.
  • a translation lookaside buffer (TLB 915) is coupled between IAD bus 895 and physical tags I/D block 910 as shown.
  • TLB 915 stores 128 linear to physical page translation addresses and page rights for up to 128 4K byte pages.
  • This translation lookaside buffer array is organized as a four-way set associative structure with random replacement.
  • TLB 915 handles the linear to physical address translation mechanism defined for the X86 architecture. This mechanism uses a cache of the most recent linear to physical address translations to prevent searching external page tables for a valid translation.
  • Bus interface unit 900 interfaces IAD bus 895 to external apparatus such as memory.
  • IAD bus 895 is a global 64 bit shared address/data/control bus that is used to connect the different components of microprocessor 800.
  • IAD bus 895 is employed for cache block refills, writing out modified blocks, as well as passing data and control information to such functional blocks as the special register unit 850, load/store functional unit 860, data cache 870, instruction cache 810, physical I/D tags block 910 and translation lookaside buffer 915 as well as bus interface unit 900.
  • the instructions and data of the CISC program are loaded into main memory from whatever storage media was employed to store those instructions and data.
  • the instructions are fetched in program order into decoder 805 for dispatch and processing by the functional units. More particularly, four instructions are decoded at a time by decoder 805. Instructions flow from main memory to bus interface unit 900, across IAD bus 895, through prefetch unit 830, to instruction cache 810 and then to decoder 805.
  • Instruction cache 810 serves as a depository of instructions which are to be decoded by decoder 805 and then dispatched for execution. Instruction cache 810 operates in conjunction with branch prediction unit 835 to provide decoder 805 with a four instruction-wide block of instructions which is the next predicted block of instructions to be speculatively executed.
  • instruction cache 810 includes a store array designated ICSTORE which contains blocks of instructions fetched from main memory via bus interface unit 900.
  • ICACHE 810 is a 16K byte effective linearly addressed instruction cache which is organized into 16 byte lines or blocks. Each cache line or block includes 16 ⁇ 86 bytes. Each line or block also includes a 5 bit predecode state for each byte.
  • ICACHE 810 is responsible for fetching the next predicted X86 instruction bytes into instruction decoder 805.
  • ICACHE 810 maintains a speculative program counter designated FETCHPC (FPC).
  • FPC speculative program counter
  • This speculative program counter FETCHPC is used to access the following three separate random access memory (RAM) arrays that maintain the cache information.
  • the three aforementioned RAM arrays which contain the cache information include 1) ICTAGV, an array which maintains the linear tags and the byte valid bits for the corresponding block in the store array ICSTORE. Each entry in the cache includes 16 byte valid bits and a 20 bit linear tag. In this particular embodiment, 256 tags are employed. 2)
  • the array ICNXTBLK maintains branch prediction information for the corresponding block in the store array ICSTORE.
  • the ICNXTBLK array is organized into four sets of 256 entries, each corresponding to a 16K byte effective X86 instruction. Each entry in this next block array is composed of a sequential bit, a last predicted byte, and a successor index. 3)
  • the ICSTORE array contains the X86 instruction bytes plus 5 bits of predecode state. The predecode state is associated with every byte and indicates the number of ROP's to which a particular byte will be mapped. This predecode information speeds up the decoding of instructions once they are provided to decoder 805.
  • the byte queue or ICBYTEQ 815 provides the current speculative state of an instruction prefetch stream provided to ICACHE 810 by prefetch unit 830.
  • Decoder 805 performs instruction decode and dispatch operations in microprocessor 800. More particularly, decoder 805 performs the two stages of the microprocessor pipeline referred to as Decode 1 and Decode 2. During the beginning of Decode 1, the bytes that are prefetched and predicted executed are driven to the byte queue at a designated fill position. These bytes are then merged with independent bytes in the byte queue 815. In the decode to a pipeline stage, reorder buffer entries are allocated for corresponding ROP's that may issue in the next clock phase.
  • Decoder 805 takes raw X86 instruction bytes and predecode information from byte queue 815 and allocates them to four ROP positions in ROP dispatch unit 820. Decoder 805 determines which particular functional unit each ROP should be transmitted to. A more detailed discussion of one decoder which may be employed as decoder 805 is found in the U.S. Patent Application entitled "Superscalar Instruction Decoder” by David B. Witt and Michael D. Goddard (Ser. No. 08/146,383), the disclosure of which is incorporated herein by reference.
  • the ICACHE and decoder circuitry permits microprocessor 800 to decode and drive four ROP's per clock cycle into a RISC-like data path. The four ROP's are dispatched to the functional units which send results back to reorder buffer 385 and to other functional units which require these results.
  • Register file 855 and reorder buffer 885 work together to provide speculative execution to instructions in the program stream.
  • a more detailed discussion of register file 855, reorder buffer 885 and the integer core of microprocessor 800 is now provided with reference to FIG. 7.
  • the integer core of microprocessor 800 is designated as integer core 920 and includes the branch functional unit 835, ALU0, ALU1, and special register 860.
  • register file 855 is organized as 12 32 bit registers (integer registers) and 24 41 bit registers (floating point registers). These registers are accessed for up to four ROP's in parallel from decoder 805. Register file pointers provided by decoder 805 determine which particular register or registers are requested as operand values in a particular ROP as well as the size of the access.
  • register file 855 contains the architectural state of microprocessor 800 whereas reorder buffer 885 contains the speculative state of microprocessor 800.
  • the timing of register file 855 is such that it is accessed in phase PH2 of the decode 2 pipeline stage with up to 8 parallel read pointers. In response to reception of these up to 8 read pointers, register file 855 then drives the operand values thus selected onto the corresponding operand buses in the following PH1 phase of the clock.
  • a disable bus is shown in FIG. 7 coupling reorder buffer 885 to register file 855.
  • the disable bus is 8 lines wide and includes 8 override signals which indicate to register file 855 that the requested read value has been found as a speculative entry in reorder buffer 885.
  • register file 855 is subject to an override and is not permitted to place a requested read operand value on an operand bus. Rather, since a speculative entry is present in reorder buffer 885, reorder buffer 885 will then provide either the actual operand value requested or an operand tag for that value.
  • Reorder buffer 885 includes 16 entries in this particular embodiment and operates as a queue of speculative ROP result values. As seen in more detail in FIG. 8, reorder buffer 885 includes two pointers which correspond to the head and the tail of the queue, namely the head pointer and the tail pointer. Shifting an allocation of the queue to dispatched ROP's occurs by incrementing or decrementing these pointers.
  • the inputs provided to reorder buffer 885 include the number of ROP's that decoder 805 wants to attempt to allocate therein (up to 4 ROP's per block), source operand pointer values for these four ROP's, and the respective destination pointer values. Reorder buffer 885 then attempts to allocate these entries from its current speculative queue. Provided entry space is available for dispatched ROP's, entries are allocated after the tail pointer.
  • a dedicated destination tag bus designated "4 ROP destination tags" is shown in FIG. 7 as an output from reorder buffer 885 to the functional units of integer core 920 and the remaining functional units of microprocessor 800.
  • the functional units are thus provided with destination information for each ROP to be executed such that the functional unit effectively knows where the result of an ROP is to be transmitted via the result buses.
  • speculatively executed result values or operands are temporarily stored in reorder buffer 885 until such result operands are no longer speculative.
  • a pool of potential operand values is thus provided by reorder buffer 885 for use by subsequent ROP's which are provided to and decoded by decoder 805.
  • FIG. 8 shows the entries that are in a speculative state between the tail and head pointers by dashed vertical lines in those entries. Each reorder buffer entry is referenced back to its original destination register number.
  • Reorder buffer 885 maintains the correct speculative state of new ROP's dispatched by decoder 805 by allocating these ROP's in program order. The 4 ROP's then scan from their present position down to the tail position of the reorder buffer queue looking for a match on either of their read operands. If a match occurs in a particular reorder buffer entry, then the corresponding read port in register file 855 is disabled and either the actual result operand or operand tag is presented to the operand bus for reception by the appropriate functional unit. This arrangement permits multiple updates of the same register to be present in the reorder buffer without affecting operation. Result forwarding is thus achieved.
  • reorder buffer 885 includes retire logic 925 which controls the retirement of result operands stored in the reorder buffer queue or array 930.
  • retire logic 925 controls the retirement of result operands stored in the reorder buffer queue or array 930.
  • a result operand stored in queue 930 is no longer speculative, such result operand is transferred under retire logic control to register file 855.
  • the retire logic interfacing the retirement of ROP's, the writeback to the register file, and the state of the last 4 ROP entries are scanned.
  • the retire logic 925 determines how many of the allocated ROP entries now have valid results.
  • the retire logic also checks how many of these ROP entries have writeback results to the register file versus ROP's with no writeback.
  • the retire logic scans for taken branches, stores and load misses.
  • retire logic 925 contains the program counter or retire PC which represents the rolling demarcation point in the program under execution which divides those executed instructions which are nonspeculative from those instructions which have been executed upon speculation.
  • the EIP or retire PC is continually updated upon retirement of result operands from reorder buffer 885 to register file 855 to reflect that such retired instructions are no longer speculative.
  • reorder buffer 885 readily tracks the speculative state and is capable of retiring multiple X86 instructions or ROP's per clock cycle. Microprocessor 800 can quickly invalidate and begin fetching a corrected instruction stream upon encountering an exception condition or branch misprediction.
  • This functional unit monitors the type bus at the "find first FUNC type” input to multiplexer 940. More particularly, the functional unit looks for the first ROP that matches the type of the functional unit, and then enables the 1:4 multiplexers 932, 935, and 940 to drive the corresponding operands and tag information into reservation station 1 of the functional unit of FIG. 9. For example, assuming that execution unit 945 is Arithmetic Logic Unit 1 (ALU1) and that the instruction type being presented to the functional unit at the TYPE input of multiplexer 940 is an ADD instruction, then the destination tag, opcode, A operand and B operand of the dispatched instruction is driven into reservation station 1 via the selecting multiplexers 932, 935, and 940.
  • ALU1 Arithmetic Logic Unit 1
  • reservation station 0 A second reservation station, namely reservation station 0 is seen between reservation station 1 and execution unit 945.
  • the functional unit of FIG. 9 is thus said to include two reservation stations, or alternatively, a reservation station capable of holding two entries.
  • This two entry reservation station is implemented as a FIFO with the oldest entry being shown as reservation 0.
  • the reservation stations 0 and 1 can hold either operands or operand tags depending upon what was sent to the functional unit on the operand buses from either register file 855 or reorder buffer 885.
  • the functional unit includes A forwarding logic 950 and B forwarding logic 955.
  • a forwarding logic 950 scans the five result buses for tags to match either the source A operand and when a match occurs, A forwarding logic 950 routes the corresponding result bus to the A data portion 960 of reservation station 1. It should be noted here that when an A operand tag is provided via multiplexer 930 instead of the actual A operand, then the A operand tag is stored at the location designated A tag 965. It is this A operand tag stored in A tag position 965 which is compared with the scanned result tags on the five result buses for a match.
  • B forward logic 955 scans the five result buses for any result tags which match the B operand tag stored in B operand tag position 970. Should a match be found, the corresponding result operand is retrieved from the result buses and stored in B data location 975.
  • the destination tag and opcode of the ROP being executed by the functional unit are stored in tag and opcode location 980.
  • the ROP instruction is then issued to execution unit 945 for execution. More particularly, the A operand and the B operand are provided to execution unit 945 by the reservation station. The opcode and destination tag for that instruction are provided to execution unit 945 by the tag and opcode location 980.
  • the execution unit executes the instruction and generates a result.
  • the execution unit then arbitrates for access to the result bus by sending a result request signal to an arbitrator (not shown). When the execution unit 945 is granted access to the result bus, a result grant signal is received by execution unit 945 from the arbitrator. Execution unit 945 then places the result on the designated result bus.
  • the result is forwarded to other functional units with pending operands having the same tag as this result.
  • the result is also provided to reorder buffer 885 for storage therein at the entry associated with the destination tag of the executed ROP.
  • the functional unit arbitrates for the result bus while the instruction is executing. More particularly, when a valid entry is present in the functional unit, namely when all operand, opcode and destination tag information necessary for execution have been assembled, the instruction is issued to execution unit 945 and the functional unit arbitrates for the result bus while execution unit 945 is actually executing the instruction.
  • each reservation station contains storage for the local opcode as well as the destination tag. This tag indicates the location that the ROP will eventually write back to during the result pipeline stage. This destination tag is also kept with each entry in the reservation station and pushed through the FIFO thereof.
  • execution unit 945 may be any of branch functional unit 835, ALU0/Shifter 840, ALU1 845, load/store 860, floating point unit 865 and special register 850 with appropriate modification for those particular functions.
  • the result buses include a 41 bit result, a destination tag and also status indication information such as normal, valid and exception.
  • the result buses include a 41 bit result, a destination tag and also status indication information such as normal, valid and exception.
  • the timing of the functional unit activities just described occurs during the execute stage.
  • the operands, destination tags and opcodes are driven as the ROP is dispatched and placed in a reservation station.
  • the operation described by the OP code is executed if all operands are ready, and during execution the functional unit arbitrates for the result buses to drive the value back to the reorder buffer.
  • FIG. 10 is a more detailed representation of branch functional unit 835.
  • Branch functional unit 835 handles all non-sequential fetches including jump instructions as well as more complicated call and return micro-routines.
  • Branch unit 835 includes reservation station 835R, and a branch FIFO 980 for tracking predicted taken branches.
  • Branch functional unit 835 also includes an adder 985, an incrementer 990, and a branch predict comparator 995 all for handling PC relative branches.
  • Branch functional unit 835 controls speculative branches by using the branch predicted taken FIFO 980 shown in FIG. 10. More specifically, every non-sequential fetch predicted by the instruction cache 810 is driven to branch predicted FIFO 980 and latched therein along with the PC (program counter) of that branch. This information is driven on to the target bus (XTARGET) and decode PC buses to the branch functional unit. When the corresponding branch is later decoded and issued, the PC of the branch, offset, and prediction information is calculated locally by branch functional unit 835. If a match occurs, the result is sent back correctly to reorder buffer 885 with the target PC and a status indicating a match.
  • PC program counter
  • branch functional unit 835 sends both the new target address as well as the index to the block where the prediction information was to update this array. This means that the microprocessor begins fetching the new correct stream of instructions while simultaneously updating the prediction array information. It is noted that the microprocessor also accesses the prediction information with the new block to know which bytes are predicted executed.
  • the ICNXTBLK array is dual ported so that the prediction information can be updated though a second port thereof.
  • the prediction information from the block where the misprediction occurs is information such as sequential/non-sequential, branch position, and location of the first byte predicted executed within the cache array.
  • Adder 985 and incrementer 990 calculate locally the current PC+offset of the current branch instruction, as well as the PC+instruction length for the next PC if sequential. These values are compared by comparator 995 against the predicted taken branches in a local branch taken queue (FIFO 980) for predicting such branches.
  • microprocessor 800 The major internal buses of microprocessor 800 are now summarized as a prelude to discussing timing diagrams which depict the operation of microprocessor 800 throughout its pipeline stages. It is noted that a leading X on a bus line indicates a false bus that is dynamically precharged in one phase and conditionally asserted in the other phase.
  • the microprocessor 800 internal buses include:
  • FPC (31:0)--Ph1 static. This fetch PC bus is used for speculative instruction prefetches from the instruction cache 810 into byte queue 815.
  • the FPC bus is coupled to FPC block 813 within ICACHE 810 which performs substantially the same function as FPC block 207 of microprocessor 500 of FIG. 3.
  • This bus is the output of the instruction cache store array ICSTORE of the currently requested prefetched X86 instruction plus corresponding predecode information.
  • ICSTORE the instruction cache store array
  • a total of 16 bytes can be asserted per clock cycle aligned such that the next predicted executed byte fills the first open byte position in the byte queue.
  • BYTEQn (7:0) Ph1 static. This represents the queue of predicted executed X86 instruction bytes that have been prefetched from the instruction cache. In this particular embodiment, a total of 16 bytes are presented to the decode paths of decoder 805. Each byte contains predecode information from the instruction cache with respect to the location of instruction start and end positions, prefix bytes, and opcode location. The ROP size of each X86 instruction is also included in the predecode information. The predecode information added to each byte represents a total of 6 bits of storage per byte in the byte queue, namely 1 valid bit plus 5 predecode bits.
  • IAD bus 895 is the general interconnect bus for major microprocessor 800 blocks. It is used for address, data, and control transfer between such blocks as well as to and from external memory all as illustrated in the block diagram of FIG. 6.
  • XRDnAB (40:0) Ph1, dynamic.
  • This designation represents the source operand A bus for each ROP provided to the functional units and is included in operand buses 875. More specifically, it includes a total of four 41 bit buses for ROP 0 through ROP 3.
  • a corresponding tag bus included in the operand buses indicates when a forwarded tag from reorder buffer 885 is present instead of actual operand data from reorder buffer 885.
  • XRDnBB (40:0)--Ph1, dynamic. This designation indicates the source operand B bus for each ROP sent to the functional units.
  • This bus structure includes four 41 bit buses for ROP 0 through ROP 3 and is included in the eight read operand buses 875. It is again noted that a corresponding tag bus indicates when a forwarded operand tag is present on this bus instead of actual operand data from reorder buffer 885.
  • XRESnB (40:0)--Ph1, dynamic. This designation indicates result bus 880 for 8, 16, 32 bit integers, or 1/2 an 80 bit extended result. It is noted that corresponding tag and status buses 882 validate an entry on this result bus.
  • Microprocessor 800 includes a six stage pipeline including the stages of fetch, decode1, decode2, execute, result/ROB and retire/register file. For clarity, the decode stage has been divided into decode1 and decode2 in FIG. 11.
  • FIG. 11 shows the microprocessor pipeline when sequential execution is being conducted. The successive pipeline stages are represented by vertical columns in FIG. 11. Selected signals in microprocessor 800 are presented in horizontal rows as they appear in the various stages of the pipeline.
  • the sequential execution pipeline diagram of FIG. 11 portrays the following selected signals:
  • Ph1 which represents the leading edge of the system clocking signal.
  • the system clocking signal includes both Ph1 and Ph2 components.
  • FPC(31:0) which denotes the fetch PC bus from byte queue 815.
  • ROPmux (3:0) which is a decoder signal which indicates the instruction block and predecode information being provided to the decoder.
  • Source A/B pointers which are the read/write pointers for the A and B operands provided by decoder 805 to reorder buffer 815.
  • the source pointers are the register file values that are inputs into both the register file and the reorder buffer from the decode block.
  • REGF/ROB access indicates access to the register file and reorder buffer for the purpose of obtaining operand values for transmission to functional units.
  • Issue ROPs/dest tags indicates the issuance of ROPs and destination tags by decoder 805 to the functional units.
  • A/B read oper buses indicates the reading of the A and B operand buses by the functional units to obtain A and B operands or tags therefore.
  • “Funct unit exec” indicates execution by the functional units. It is noted that in FIGS. 11 and 12, the designations a&b ⁇ c and c&d ⁇ e and c&g ⁇ indicate arbitrary operations and are in the form "source 1 operand, source 2 operand ⁇ destination". More specifically, the designated source registers are registers, namely temporary or mapped X86 registers. In the a&b ⁇ c example, the "c" value represents the destination and shows local forwarding from both the result buses as well as the reorder buffer to subsequent references in the predicted executed stream.
  • Results Bus arb indicates the time during which a functional unit is arbitrating for access to result bus 880 for the purpose of transmission of the result to the reorder buffer and any other functional units which may need that result since that unit holds an operand tag corresponding to such result.
  • Result bus forward indicates the time during which results are forwarded from a functional unit to other functional units needing that result as a pending operand.
  • ROB write result indicates the time during which the result from a functional unit is written to the reorder buffer.
  • ROB tag forward indicates the time during which the reorder buffer forwards operand tags to functional units in place of operands for which it presently does not yet have results.
  • REGF write/retire indicates the time during which a result is retired from the FIFO queue of the reorder buffer to the register file.
  • EIP (31:0) indicates the retire PC value. Since an interrupt return does not have delayed branches, the microprocessor can restart upon an interrupt return with only one PC.
  • the retire PC value or EIP is contained in the retire logic 925 of reorder buffer 885. The EIP is similar to the retire PC already discussed with respect to microprocessor 500. Retire logic 925 performs a function similar to the retire logic 242 of microprocessor 500.
  • the timing diagram of FIG. 11 shows microprocessor 800 executing a sequential stream of X86 bytes.
  • the predicted execution path is actually taken as well as being available directly from the instruction cache.
  • the first stage of instruction processing is the instruction fetch. As shown, this clock cycle is spent conducting instruction cache activities.
  • Instruction cache 810 forms a new fetch PC (FPC) during Ph1 of the clock cycle and then accesses the cache arrays of the instruction cache in the second clock cycle.
  • the fetch PC program counter (shown in the timing diagram as FPC (31:0)) accesses the linear instruction cache's tag arrays in parallel with the store arrays. Late in clock phase Ph2 of the fetch, a determination is made whether the linear tags match the fetch PC linear address. If a match occurs, the predicted executed bytes are forwarded to the byte queue 815.
  • the fetch PC In addition to accessing the tag and store arrays in instruction cache, the fetch PC also accesses the block prediction array, ICNXTBLK. This block prediction array identifies which of the X86 bytes are predicted executed and whether the next block predicted executed is sequential or nonsequential. This information, also accessed in Ph2, determines which of the bytes of the currently fetched block will be driven as valid bytes into byte queue 815.
  • Byte queue 815 may currently have X86 bytes stored therein that have been previously fetched and not yet issued to functional units. If this is the case, a byte filling position is indicated to instruction cache 810 to shift the first predicted byte over by this amount to fill behind the older X86 bytes.
  • the branch prediction information occurs in clock phase Ph2 of the fetch, the next block to be prefetched by prefetch unit 830 can be sequential or nonsequential since in either case there is one clock cycle in which to access the cache arrays again.
  • the branch prediction arrays allow a branch out of the block to have the same relative performance as accessing the next sequential block thus providing performance enhancement.
  • Decode1/Decode2 pipeline stages are now discussed.
  • the bytes that were prefetched and predicted executed are driven into byte queue 815 at the designated fill position. This is shown in the timing diagram of FIG. 11 as ICBYTEnB (12:0) asserting in Ph1 of decode1.
  • ICBYTEnB (12:0) asserting in Ph1 of decode1.
  • These bytes are then merged with any pending bytes in the byte queue.
  • the byte queue contains the five bits of predecode state plus the raw X86 bytes to show where instruction boundaries are located.
  • the head of the byte queue is at the beginning of the next predicted executed X86 instruction.
  • Decoder 805 determines the number of ROPs each instruction takes and the position of the opcode to enable alignment of these opcodes to the corresponding ROP issue positions D0, D1, D2, and D3 with the ROP at D0 being the next ROP to issue.
  • Decoder 805 maintains a copy of the program counters PC's of each of the X86 instructions in byte queue 815 by counting the number of bytes between instruction boundaries, or detecting a branch within the instruction cache and attaching the target PC value to the first X86 byte fetched from that location.
  • decoder 805 statically determines the following information during clock phase Ph2 of decode1 and clock phase Ph1 of decode2: 1) functional unit destination, 2) source A/B and destination operand pointer value, 3) size of source and destination operations, and 4) immediate address and data values if any.
  • clock phase Ph1 of decode2 By the end of clock phase Ph1 of decode2 all the register read and write pointers are resolved and the operation is determined. This is indicated in the timing diagram of FIG. 11 by the assertion of the source A/B pointer values.
  • the reorder buffer entries are allocated for corresponding ROPs that may issue in the next clock phase.
  • up to four additional ROPs are allocated entries in the 16 entry reorder buffer 885 during the Ph1 clock phase of decode 2.
  • the source read pointers for all allocated ROPs are then read from the register file while simultaneously accessing the queue of speculative ROPs contained in the reorder buffer. This simultaneous access of both the register file and reorder buffer arrays permits microprocessor 800 to late select whether to use the actual register file value or to forward either the operand or operand tag from the reorder buffer.
  • microprocessor 800 can simultaneously look for read dependencies with the current ROPs being dispatched as well as all previous ROPs that are still in the speculative state. This is indicated in the timing diagram of FIG. 11 by the REGF/ROB access and the check on the tags.
  • ROPs are issued to the functional units by dedicated OP code buses as well as the read operand buses.
  • the dedicated OP code buses communicate the OP code of an ROP to a functional unit whereas the read operand buses transmit operands or operand tags to such functional units.
  • the time during which the operand buses communicate operands to the functional units is indicated in the timing diagram of FIG. 11 by the designation A/B read operand buses.
  • the functional units determine which ROPs have been issued to such functional units and whether any pending ROPs are ready to issue from the local reservation stations in such functional units. It is noted that a FIFO is maintained in a functional unit's reservation station to ensure that the oldest instructions contained in the reservation stations execute first.
  • an instruction In the event that an instruction is ready to execute within a functional unit, it commences such execution in the late Ph1 of the execute pipeline stage and continues statically through Ph2 of that stage. At the end of Ph2, the functional unit arbitrates for one of the five result buses as indicated by the result bus ROB signal in FIG. 11. In other words, the result bus arbitration signal is asserted during this time. If a functional unit is granted access to the result bus, then it drives the allocated result bus in the following Ph1.
  • the result pipeline stage shown in the timing diagram of FIG. 11 portrays the forwarding of a result from one functional unit to another which is in need of such result.
  • clock phase Ph1 of the result pipeline stage the location of the speculative ROP is written in the reorder buffer with the destination result as well as any status. This entry in the reorder buffer is then given an indication of being valid as well as allocated. Once an allocated entry is validated in this matter, the reorder buffer is capable of directly forwarding operand data as opposed to an operand tag upon receipt of a requested read access.
  • the newly allocated tag can be detected by subsequent ROPs that require it to be one of its source operands. This is shown in the timing diagram of FIG. 11 as the direct forwarding of result C via "ROB tag forward" onto the source A/B operand buses.
  • the retire pipeline stage is the last stage of the pipeline in the timing diagram of FIG. 11. This stage is where the real program counter (retire PC) in the form of the EIP register is maintained and updated as indicated by the bus designation EIP (31:0).
  • the EIP (31:0) timing diagram shows where a new PC (or retire PC) is generated upon retirement of an instruction from the reorder buffer to the register file.
  • the actual act of retirement of a result from the reorder buffer to the register file is indicated by the signal designated REGF write/retire in FIG. 11. It is seen in FIG. 11 that in the clock phase Ph1 of the retire pipeline stage, the result of an operation is written to the register file and the EIP register is updated to reflect that this instruction is now executed.
  • the corresponding entry in the reorder buffer is deallocated in the same clock phase Ph1 that the value is written from the reorder buffer to the register file. Since this entry in the reorder buffer is now deallocated, subsequent references to the register C will result in a read from the register file instead of a speculative read from the reorder buffer. In this manner the architectural state of the microprocessor is truly reflected.
  • FIG. 12 depicts a timing diagram of processor 800 during a branch misprediction.
  • the timing diagram of FIG. 12 shows the same signal types as the timing diagram of FIG. 11 with the following exceptions:
  • the BRN -- MISP signal indicates when a branch misprediction has occurred.
  • the XTARGET (31:0) signal denotes the time at which a predicted target branch instruction is communicated to branch unit 835.
  • the timing diagram of FIG. 12 shows the stages of the microprocessor 800 pipeline during a branch misprediction and recovery. This timing diagram assumes that the first cycle is the execute cycle of the branch and that the following cycles are involved in correcting the prediction and fetching the new instruction stream. It is noted that in this particular embodiment, a three cycle delay exists from the completion of execution of the branch instruction that was mispredicted to the beginning of execution of a corrected path.
  • the fetch stage of the pipeline depicted in FIG. 12 is similar to the normal fetch stage depicted in FIG. 11 with the exception that the XTARGET (31:0) bus is driven from branch functional unit 835 to instruction cache 810 in order to provide instruction cache 810 with information with respect to the predicted target.
  • the branch functional unit is the block of microprocessor 800 which determines that a branch mispredict has in fact occurred.
  • the branch functional unit also calculates the correct target. This target is sent at the same time as a result is returned to the reorder buffer with a mispredicted status indication on result bus 880.
  • the result bus also contains the correct PC value for updating the EIP register upon retiring the branch instruction if a real branch has occurred.
  • the XTARGET bus is then driven on to the fetched PC bus and the instruction cache arrays are accessed. If a hit occurs, the bytes are driven to the byte queue as before.
  • the misprediction status indication is sent to all speculative ROPs after the misprediction so that they will not be allowed to write to the register file or to memory.
  • these instructions are next to retire, their entries in the reorder buffer are deallocated to allow additional ROPs to issue.
  • the rest of the path for decoding the corrected path is identical to the sequential fetch case with the exception of the updating of the prediction information in the ICNXTBLK array of instruction cache 810.
  • the correct direction of the branch is now written to the prediction array ICNXTBLK to the cache block therein where the branch was mispredicted.
  • the pipeline stages decode2, execute, result, retire during a misprediction appear substantially similar to those discussed in FIG. 11.
  • High performance is achieved in the microprocessor of the invention by extracting substantial parallelism from the code which is executed by the microprocessor. Instruction tagging, reservation stations and result buses with forwarding prevent operand hazards from blocking the execution of unrelated instructions.
  • the microprocessor's reorder buffer achieves multiple benefits.
  • the ROB employs a type of register renaming to distinguish between different uses of the same register as a destination, which would otherwise artificially inhibit parallelism.
  • the data stored in the reorder buffer represents the predicted execution state of the microprocessor, whereas the data stored in the register file represents the current execution state of the microprocessor. Also, the reorder buffer preserves the sequential state of the program in the event of interrupts.
  • the reorder buffer enables more parallelism by allowing execution beyond unresolved conditional branches.
  • Parallelism is further promoted by the on-board instruction cache (ICACHE) which provides high bandwidth instruction fetch, by branch prediction which minimizes the impact of branches, and by an on-board data cache (DCACHE) to minimize latency for load and store operations.
  • ICACHE on-board instruction cache
  • DCACHE on-board data cache
  • the superscalar microprocessor of the present invention achieves increased performance by efficiently utilizing die space through sharing of several components. More particularly, the integer unit and floating point unit of the microprocessor reside on a common, shared data processing bus. These functional units include multiple reservation stations also coupled to the same data processing bus. The integer and floating point functional units share a common branch unit on the data processing bus. Moreover, the integer and floating point functional units share a common decoder and a common load/store unit 530. An internal address data (IAD) bus provides local communications among several components of the microprocessor of the invention.
  • IAD internal address data

Abstract

A superscalar microprocessor is provided which includes a integer functional unit and a floating point functional unit that share a high performance main data processing bus. The integer unit and the floating point unit also share a common reorder buffer, register file, branch prediction unit and load/store unit which all reside on the same main data processing bus. Instruction and data caches are coupled to a main memory via an internal address data bus which handles communications therebetween. An instruction decoder is coupled to the instruction cache and is capable of decoding multiple instructions per microprocessor cycle. Instructions are dispatched from the decoder in speculative order, issued out-of-order and completed out-of-order. Instructions are retired from the reorder buffer to the register file in-order. The functional units of the microprocessor desirably accommodate operands exhibiting multiple data widths. High performance and efficient use of the microprocessor die size are achieved by the sharing architecture of the disclosed superscalar microprocessor.

Description

This application is a continuation division of application Ser. No. 08/146,382, filed Oct. 29, 1993 now abandoned.
CROSS REFERENCE TO RELATED PATENT APPLICATIONS
This patent application is related to continued and abandoned U.S. patent application Ser. No. 07/929,770, filed Apr. 12, 1992 entitled "Instruction Decoder And Superscalar Processor Utilizing Same" which has the same inventive entity and assignee as the subject patent application, the disclosure of which is incorporated herein by reference.
This patent application is related to the copending U.S. patent application Ser. No. 08/146,383 filed Oct. 29, 1993 which is abandoned and continued as Ser. No. 08/628,389 filed Apr. 5, 1996 entitled "Superscalar Instruction Decoder" by David B. Witt and Michael D. Goddard, the disclosure of which is incorporated herein by reference.
This patent application is related to the copending U.S. patent application Ser. No. 08/146,381 filed Oct. 29, 1993 which is abandoned and continued as Ser. No. 08/506,509 filed Jul. 24, 1995 entitled "Linearly Addressable Microprocessor Cache" by David B. Witt, the disclosure of which is incorporated herein by reference.
This patent application is related to the copending U.S. patent application Ser. No. 08/146,376 filed Oct. 29, 1993 which is abandoned and continued as Ser. No. 08/703,299 filed Aug. 26, 1996 entitled "High Performance Load/Store Functional Unit And Data Cache" by William M. Johnson, David B. Witt and Murali Chinnakonda the disclosure of which is incorporated herein by reference.
This patent application is related to the copending U.S. patent application Ser. No. 08/145,905 filed Oct. 29, 1993, entitled "Pre-Decoded Instruction Cache And Method Therefor Particularly Suitable For Variable Byte-Length Instructions" by David B. Witt and Michael D. Goddard, the disclosure of which is incorporated herein by reference.
This patent application is related to the copending U.S. patent application Ser. No. 08/145,902 filed Oct. 29, 1993 which is abandoned and continued as Ser. No. 08/311,286 filed Sep. 23, 1994 entitled "Speculative Instruction Queue And Method Therefor Particularly Suitable For Variable Byte-Length Instructions" by David B. Witt, the disclosure of which is incorporated herein by reference.
In addition to the above related and co-pending applications, the present application is a divisional application, and therefore has additional related and co-pending applications, as follows:
The related U.S. Pat 5,574,928 entitled "MIXED INTEGER/FLOATING POINT CORE," by Scott A. White, et al. issued on Nov. 12, 1996.
The related U.S. Patent Application entitled "HIGH PERFORCE SUPERSCALER MICROPROCESSOR INCLUDING A COMMON REORDER BUFFER AND COMMON REGISTER FILE FOR BOTH INTEGER AND FLOATING POINT OPERATIONS," Ser. No. 08/501,243, fled Jul. 10, 1995, by David B. Witt, et al. is pending.
The related U.S. Patent Application entitled "HIGH PERFORMANCE SUPERSCALER MICROPROCESSOR INCLUDING A CIRCUIT FOR CONVERTING CISC INSTRUCTIONS TO RISC OPERATIONS," Ser. No. 08/599,696, by David B. Wilt and William M. Johnson is pending.
The related U.S. Patent Application entitled "HIGH PERFORMANCE SUPERSCALAR MICROPROCESSOR INCLUDING A CIRCUIT FOR BYTE-ALIGNING CISC INSTRUCTIONS STORED IN A VARIABLE BYTE-LENGTH FORMAT," Ser. No. 08/599,697, by David B. Witt and William M. Johnson is pending.
The related U.S. Patent Application entitled "HIGH PERFORMANCE SUPERSCALAR MICROPROCESSOR INCLUDING A DUAL-PATHWAY CIRCUIT FOR CONVERTING CISC INSTRUCTIONS TO RISC OPERATIONS," Ser. No. 08/599,700, by David B. Witt and William M. Johnson is pending.
The related U.S. Patent Application entitled "HIGH PERFORMANCE SUPERSCALAR MICROPROCESS OR INCLUDING A SPECULATIVE INSTRUCTION QUEUE FOR BYTE-ALIGNING CISC INSTRUCTIONS STORED IN A VARIABLE BYTE-LENGTH FORMAT," Ser. No. 08/599,699, by David B. Witt and William M. Johnson is pending.
The related U.S. Patent Application entitled "HIGH PERFORMANCE SUPERSCALAR MICROPROCESSOR INCLUDING A CIRCUIT FOR CONVERTING SIMPLE AND COMPLEX CISC INSTRUCTIONS TO RISC OPERATIONS," Ser. No. 08/599,701: by David B. Witt and William M. Johnson is pending.
The related U.S. Patent Application entitled "HIGH PERFORMANCE SUPERSCALAR MICROPROCESSOR INCLUDING AN INSTRUCTION CACHE CIRCUIT FOR BYTE-ALIGNING CISC INSTRUCTIONS STORED IN A VARIABLE BYTE-LENGTH FORMAT," Ser. No. 08/599,698, by David B. Witt and William M. Johnson is pending.
The related U.S. Patent Application entitled "METHOD OF OPERATING A HIGH PERFORMANCE SUPERSCALAR MICROPROCESSOR INCLUDING A COMMON REORDER BUFFER AND COMMON REGISTER FILE FOR BOTH INTEGER AND FLOATING POINT OPERATIONS," Ser. No. 08/571,321, by David B. Witt and William M. Johnson is pending.
The related U.S. Patent Application entitled "MIXED INTEGER/FLOATING POINT CORE," Ser. No. 08/602,642, by Scott A. White, Michael D. Goddard and William M. Johnson is pending.
BACKGROUND OF THE INVENTION
This invention relates in general to microprocessors and, more particularly, to high performance superscalar microprocessors.
Like many other modern technical disciplines, microprocessor design is a technology in which engineers and scientists continually strive for increased speed, efficiency and performance. Generally speaking, microprocessors can be divided into two classes, namely scalar and vector processors. The most elementary scalar processor processes a maximum of one instruction per machine cycle. So called "superscalar" processors can process more than one instruction per machine cycle. In contrast with the scalar processor, a vector processor can process a relatively large array of values during each machine cycle.
Vector processors rely on data parallelism to achieve processing efficiencies whereas superscalar processors rely on instruction parallelism to achieve increased operational efficiency. Instruction parallelism may be thought of as the inherent property of a sequence of instructions which enable such instructions to be processed in parallel. In contrast, data parallelism may be viewed as the inherent property of a stream of data which enables the elements thereof to be processed in parallel. Instruction parallelism is related to the number of dependencies which a particular sequence of instructions exhibits. Dependency is defined as the extent to which a particular instruction depends on the result of another instruction. In a scalar processor, when an instruction exhibits a dependency on another instruction, the dependency generally must be resolved before the instruction can be passed to a functional unit for execution. For this reason, conventional scalar processors experience undesirable time delays while the processor waits pending resolution of such dependencies.
Several approaches have been employed over the years to speed up the execution of instructions by processors and microprocessors. One approach which is still widely used in microprocessors today is pipelining. In pipelining, an assembly line approach is taken in which the three microprocessor operations of 1) fetching the instruction, 2) decoding the instruction and gathering the operands, and 3) executing the instruction and writeback of the result, are overlapped to speed up processing. In other words, instruction 1 is fetched and instruction 1 is decoded in respective machine cycles. While instruction 1 is being decoded and its operands are gathered, instruction 2 is fetched. While instruction 1 is being executed and the result written, instruction 2 is being decoded and its operands are gathered, and instruction 3 is being fetched. In actual practice, the assembly line approach may be divided into more assembly line stations than described above. A more in-depth discussion of the pipelining technique is described by D. W. Anderson et also in their publication "The IBM System/360 Model 91: Machine Philosophy", IBM Journal, Vol. 11, January 1967, pp. 8-24.
The following definitions are now set forth for the purpose of promoting clarity in this document. "Dispatch" is the act of sending an instruction from the instruction decoder to a functional unit. "Issue" is the act of placing an instruction in execution in a functional unit. "Completion" is achieved when an instruction finishes execution and the result is available. An instruction is said to be "retired" when the instruction's result is written to the register file. This is also referred to as "writeback".
The recent book, Superscalar Microprocessor Design, William Johnson, 1991, Prentice-Hall, Inc., describes several general considerations for the design of practical superscalar microprocessors. FIGS. 1, 1A, and 1B comprise a block diagram of a microprocessor 10 which depicts the implementation of a superscalar microprocessor described in the Johnson book. Microprocessor 10 includes an integer unit 15 for handling integer operations and a floating point unit 20 for handling floating point operations. Integer unit 15 and floating point unit 20 each include their own respective, separate and dedicated instruction decoder, register file, reorder buffer, and load and store units. More specifically, integer unit 15 includes instruction decoder 25, a register file 30, a reorder buffer 35, and load and store units (60 and 65), while floating point unit 20 includes its own instruction decoder 40, register file 45, reorder buffer 50, and load and store units (75 and 80) as shown in FIG. 1. The reorder buffers contain the speculative state of the microprocessor, whereas the register files contain the architectural state of the microprocessor.
Microprocessor 10 is coupled to a main memory 55 which may be thought of as having two portions, namely an instruction memory 55A for storing instructions and a data memory 55B for storing data. Instruction memory 55A is coupled to both integer unit 15 and floating point unit 20. Similarly, data memory 55B is coupled to both integer unit 15 and floating point unit 20. In more detail, instruction memory 55A is coupled to decoder 25 and decoder 40 via instruction cache 58. Data memory 55B is coupled to load functional unit 60 and store functional unit 65 of integer unit 15 via a data cache 70. Data memory 55B is also coupled to a float load functional unit 75 and a float store functional unit 80 of floating point unit 20 via data cache 70. Load unit 60 performs the conventional microprocessor function of loading selected data from data memory 55B into integer unit 15, whereas store unit 70 performs the conventional microprocessor function of storing data from integer unit 15 in data memory 55B.
A computer program includes a sequence of instructions which are to be executed by microprocessor 10. Computer programs are typically stored in a hard disk, floppy disk or other non-volatile storage media which is located in a computer system. When the program is run, the program is loaded from the storage media into main memory 55. Once the instructions of the program and associated data are in main memory 55, the individual instructions can be prepared for execution and ultimately be executed by microprocessor 10.
After being stored in main memory 55, the instructions are passed through instruction cache 58 and then to instruction decoder 25. Instruction decoder 25 examines each instruction and determines the appropriate action to take. For example, decoder 25 determines whether a particular instruction is a PUSH, POP, LOAD, AND, OR, EX OR, ADD, SUB, NOP, JUMP, JUMP on condition (BRANCH) or other type of instruction. Depending on the particular type of instruction which decoder 58 determines is present, the instruction is dispatched to the appropriate functional unit. In the superscalar architecture proposed in the Johnson book, decoder 25 is a multi-instruction decoder which is capable of decoding 4 instructions per machine cycle. It can thus be said that decoder 58 exhibits a bandwidth which is four instructions wide.
As seen in FIG. 1, an OP CODE bus 85 is coupled between decoder 25 and each of the functional units, namely, branch unit 90, arithmetic logic units 95 and 100, shifter unit 105, load unit 60 and store unit 65. In this manner, the OP CODE for each instruction is provided to the appropriate functional unit.
Departing momentarily from the immediate discussion, it is noted that instructions typically include multiple fields in the following format: OP CODE, OPERAND A, OPERAND B, DESTINATION REGISTER. For example, the sample instruction ADD A, B, C would mean ADD the contents of register A to the contents of register B and place the result in the destination register C. The handling of the OP CODE portion of each instruction has already been discussed above. The handling of the OPERANDs for each instruction will now be described.
Not only must the OP CODE for a particular instruction be provided to the appropriate functional unit, but also the designated OPERANDS for that instruction must be retrieved and sent to the functional unit. If the value of a particular operand has not yet been calculated, then that value must be first calculated and provided to the functional unit before the functional unit can execute the instruction. For example, if a current instruction is dependent on a prior instruction, the result of the prior instruction must be determined before the current instruction can be executed. This situation is referred to as a dependency.
The operands which are needed for a particular instruction to be executed by a functional unit are provided by either register file 30 or reorder buffer 35 to operand bus 110. Operand bus 110 is coupled to each of the functional units. Thus, operand bus 110 conveys the operands to the appropriate functional unit. In actual practice, operand bus 110 includes separate buses for OPERAND A and OPERAND B.
Once a functional unit is provided with the OP CODE and OPERAND A and OPERAND B, the functional unit executes the instruction and places the result on a result bus 115 which is coupled to the output of all of the functional units and to reorder buffer 35 (and to the respective reservation stations at the input of each functional unit as will now be discussed).
The input of each functional unit is provided with a "reservation station" for storing OP codes from instructions which are not yet complete in the sense that the operands for that instruction are not yet available to the functional unit. The reservation station stores the instruction's OP CODE together with operand tags which reserve places for the missing operands that will arrive at the reservation station later. This technique enhances performance by permitting the microprocessor to continue executing other instructions while the pending instruction is being assembled together with its operands at the reservation station. As seen in FIG. 1, branch unit 90 is equipped with a reservation station 90R; ALU's 95 and 100 are equipped with reservation stations 95R and 100R, respectively; shifter unit 105 is equipped with a reservation station 105R; load unit 60 is equipped with a reservation station 60R; and store unit 65 is equipped with a reservation station 65R. In this approach, reservation stations are employed in place of the input latches which were typically used at the inputs of the functional units in earlier microprocessors. The classic reference with respect to reservation stations is R. M. Tomasulo, "An Efficient Algorithm For Exploiting Multiple Arithmetic Units" IBM Journal, Volume 11, January 1967, pp. 25-33.
As mentioned earlier, a pipeline can be used to increase the effective throughput in a scalar microprocessor up to a limit of one instruction per machine cycle. In the superscalar microprocessor shown in FIG. 1, multiple pipelines are employed to achieve the processing of multiple instructions per machine cycle. This technique is referred to as "super-pipelining".
Another technique referred to as "register renaming" can also be employed to enhance superscalar microprocessor throughput. This technique is useful in the situation where two instructions in an instruction stream both require use of the same register, for example a hypothetical register 1. Provided that the second instruction is not dependent on the first instruction, a second register called register 1A is allocated for use by the second instruction in place of register 1. In this manner, the second instruction can be executed and a result can be obtained without waiting for the first instruction to be done using register 1. The superscalar microprocessor 10 shown in FIG. 1 uses a register renaming approach to increase instruction handling capability. The manner in which register renaming is implemented in microprocessor 10 is now discussed in more detail.
From the above, it is seen that register renaming eliminates storage conflicts for registers. To implement register renaming, integer unit 15 and floating point unit 20 are associated with respective reorder buffers 35 and 50. For simplicity, only register renaming via reorder buffer 35 in integer unit 15 will be discussed, although the same discussion applies to similar circuitry in floating point unit 20.
Reorder buffer 35 includes a number of storage locations which are dynamically allocated to instruction results. More specifically, when an instruction is decoded by decoder 25, the result value of the instruction is assigned a location in reorder buffer 35 and its destination register number is associated with this location. This effectively renames the destination register number of the instruction to the reorder buffer location. A tag, or temporary hardware identifier, is generated by the microprocessor hardware to identify the result. This tag is also stored in the assigned reorder buffer location. When a later instruction in the instruction stream refers to the renamed destination register, in order to obtain the value considered to be stored in the register, the instruction instead obtains the value stored in the reorder buffer or the tag for this value if the value has not yet been computed.
Reorder buffer 35 is implemented as a first-in-first-out (FIFO) circular buffer which is a content-addressable memory. This means that an entry in reorder buffer 35 is identified by specifying something that the entry contains, rather than by identifying the entry directly. More particularly, the entry is identified by using the register number that is written into it. When a register number is presented to reorder buffer 35, the reorder buffer provides the latest value written into the register (or a tag for the value if the value is not yet computed). This tag contains the relative speculative position of a particular instruction in reorder buffer 35. This organization mimics register file 30 which also provides a value in a register when it is presented with a register number. However, reorder buffer 35 and register file 30 use very different mechanisms for accessing values therein.
In the mechanism employed by reorder buffer 35, the reorder buffer compares the requested register number to the register numbers in all of the entries of the reorder buffer. Then, the reorder buffer returns the value (or tag) in the entry that has a matching register number. This is an associative lookup technique. In contrast, when register file 30 is presented with a requested register number, the register file simply decodes the register number and provides the value at the selected entry.
When instruction decoder 25 decodes an instruction, the register numbers of the decoded instruction's source operands are used to access both reorder buffer 35 and register file 30 at the same time. If reorder buffer 35 does not have an entry whose register number matches the requested source register number, then the value in register file 30 is selected as the source operand. However, if reorder buffer 35 does contain a matching entry, then the value in this entry is selected as the source operand because this value must be the most recent value assigned to the reorder buffer. If the value is not available because the value has not yet been computed, then the tag for the value is instead selected and used as the operand. In any case, the value or tag is copied to the reservation station of the appropriate functional unit. This procedure is carried out for each operand required by each decoded instruction.
In a typical instruction sequence, a given register may be written many times. For this reason, it is possible that different instructions cause the same register to be written into different entries of reorder buffer 35 in the case where the instructions specify the same destination register. To obtain the correct register value in this scenario, reorder buffer 35 prioritizes multiple matching entries by order of allocation, and returns the most recent entry when a particular register value is requested. By this technique, new entries to the reorder buffer supersede older entries.
When a functional unit produces a result, the result is written into reorder buffer 35 and to any reservation station entry containing a tag for this result. When a result value is written into the reservation stations in this manner, it may provide a needed operand which frees up one or more waiting instructions to be issued to the functional unit for execution. After the result value is written into reorder buffer 35, subsequent instructions continue to fetch the result value from the reorder buffer. This fetching continues unless the entry is superseded by a new value and until the value is retired by writing the value to register file 30. Retiring occurs in the order of the original instruction sequence, thus preserving the in-order state for interrupts and exceptions.
With respect to floating point unit 20, it is noted that in addition to the float load functional unit 75 and a float store functional unit 80, floating point unit 20 includes other functional units as well, For instance, floating point unit 20 includes a float add unit 120, a float convert unit 125, a float multiply unit 130 and a float divide unit 140. An OP CODE bus 145 is coupled between decoder 40 and each of the functional units in floating point unit 20 to provide decoded instructions to the functional units. Each functional unit includes a respective reservation station, namely, float add reservation station 120R, float convert reservation station 125R, float multiply reservation station 130R and float divide reservation station 140R. An operand bus 150 couples register file 45 and reorder buffer 50 to the reservation stations of the functional units so that operands are provided thereto. A result bus 155 couples the outputs of all of the functional units of floating point unit 20 to reorder buffer 50. Reorder buffer 50 is then coupled to register file 45. Reorder buffer 50 and register file 45 are thus provided with results in the same manner as discussed above with respect to integer unit 15.
Integer reorder buffer 35 holds 16 entries and floating point reorder buffer 50 holds 8 entries. Integer reorder buffer 35 and floating point reorder buffer 50 can each accept two computed results per machine cycle and can retire two results per cycle to the respective register file.
When a microprocessor is constrained to issue decoded instructions in order ("in-order issue"), the microprocessor must stop decoding instructions whenever a decoded instruction generates a resource conflict (ie. two instructions both wanting to use the R1 register) or when the decoded instruction has a dependency, In contrast, microprocessor 10 of FIG. 1 which employs "out-of-order-issue" achieves this type of instruction issue by isolating decoder 25 from the execution units (functional units). This is done by using reorder buffer 35 and the aforementioned reservation stations at the functional units to effectively establish a distributed instruction window. In this manner, the decoder can continue to decode instructions even if the instructions can not be immediately executed. The instruction window acts as a pool of instructions from which the microprocessor can draw as it continues to go forward and execute instructions. A look ahead capability is thus provided to the microprocessor by the instruction window. When dependencies are cleared up and as operands become available, more instructions in the window are executed by the functional units and the decoder continues to fill the window with yet more decoded instructions.
Microprocessor 10 includes a branch prediction unit 90 to enhance its performance. It is well known that branches in the instruction stream of a program hinder the capability of a microprocessor to fetch instructions. This is so because when a branch occurs, the next instruction which the fetcher should fetch depends on the result of the branch. Without a branch prediction unit such as unit 90, the microprocessor's instruction fetcher may become stalled or may fetch incorrect instructions. This reduces the likelihood that the microprocessor can find other instructions in the instruction window to execute in parallel. Hardware branch prediction, as opposed to software branch prediction, is employed in branch prediction unit 90 to predict the outcomes of branches which occur during instruction fetching. In other words, branch prediction unit 90 predicts whether or not branches should be taken. For example, a branch target buffer is employed to keep a running history of the outcomes of prior branches. Based on this history, a decision is made during a particular fetched branch as to which branch the fetched branch instruction will take.
It is noted that software branch prediction also may be employed to predict the outcome of a branch. In that branch prediction approach, several tests are run on each branch in a program to determine statistically which branch outcome is more likely. Software branch prediction techniques typically involve imbedding statistical branch prediction information as to the favored branch outcome in the program itself. It is noted that the term "speculative execution" is often applied to microprocessor design practices wherein a sequence of code (such as a branch) is executed before the microprocessor is sure that it was proper to execute that sequence of code.
To understand the operation of superscalar microprocessors, it is helpful to compare scalar and superscalar microprocessors at each stage of the pipeline, namely at fetch, decode, execute, writeback and result commit. Table 1 below provides such a comparison.
              TABLE 1                                                     
______________________________________                                    
                        Pipelined                                         
                        Superscalar Processor                             
          Pipelined     (with out-of-order issue                          
Pipeline Stage                                                            
          Scalar Processor                                                
                        & out-of-order completion)                        
______________________________________                                    
Fetch     fetch one instruction                                           
                        fetch multiple instructions                       
Decode    decode instruction                                              
                        decode instructions                               
          access operands from                                            
                        access operands from                              
          register file register file and                                 
                        reorder buffer                                    
          copy operands to                                                
                        copy operands to                                  
          functional unit                                                 
                        functional unit                                   
          input latches reservation stations                              
Execute   execute instruction                                             
                        execute instructions                              
                        arbitrate for result buses                        
Writeback write result to register                                        
                        write results to                                  
          file          reorder buffer                                    
          forward results to                                              
                        forward results to                                
          functional unit input                                           
                        functional unit                                   
          latches       reservation stations                              
Result Commit                                                             
          n/a           write result to register file                     
______________________________________                                    
From the above description of superscalar microprocessor 10, it is appreciated that this microprocessor is indeed a powerful but very complex structure. Further increases in processing performance as well as design simplification are however always desirable in microprocessors such as microprocessor 10.
SUMMARY OF THE INVENTION
Accordingly, one advantage of the superscalar microprocessor of the present invention is its increased performance in terms of processing instructions in parallel.
Another advantage of the superscalar microprocessor of the present invention is reduced complexity.
Still another advantage of the superscalar microprocessor of the present invention is reduced die size as compared to other superscalar microprocessors.
In accordance with one embodiment of the present invention, a superscalar microprocessor is provided for processing instructions stored in a main memory. The microprocessor includes a multiple instruction decoder for decoding multiple instructions in the same microprocessor cycle. The decoder decodes both integer and floating point instructions in the same microprocessor cycle. The microprocessor includes a data processing bus coupled to the decoder. The microprocessor further includes an integer functional unit and a floating point functional unit coupled to and sharing the same data processing bus. A common reorder buffer is coupled to the data processing bus for use by both the integer functional unit and the floating point functional unit. A common register file is coupled to the reorder buffer for accepting instruction results which are retired from the reorder buffer.
BRIEF DESCRIPTION OF THE DRAWINGS
The features of the invention believed to be novel are specifically set forth in the appended claims. However, the invention itself, both as to its structure and method of operation, may best be understood by referring to the following description and accompanying drawings.
FIG. 1, 1A, and 1B comprise a block diagram showing a conventional superscalar microprocessor.
FIG. 2, 2A, and 2B comprise a simplified block diagram of one embodiment of the high performance superscalar microprocessor of the present invention.
FIGS. 3, 3A, 3B, 3C, 3D, and 3E comprise a more detailed block diagram of another embodiment of the high performance superscalar microprocessor of the present invention.
FIG. 4 is a chart representing the priority which functional units receive when arbitrating for result buses.
FIG. 5 is a block diagram of the internal address data bus arbitration arrangement in the microprocessor of the invention.
FIG. 5A is a timing diagram of the operation of the microprocessor of FIG. 3 throughout the multiple stages of the pipeline thereof during sequential processing.
FIG. 5B is a timing diagram similar to the timing diagram of FIG. 5A but directed to the case where a branch misprediction and recovery occurs.
FIG. 6, 6A, 6B, and 6C comprise a block diagram of another embodiment of the superscalar microprocessor of the invention.
FIG. 7 is a block diagram of the register file, reorder buffer and integer core of the microprocessor of FIG. 6.
FIG. 8 is a more detailed block diagram of the reorder buffer of FIG. 7.
FIG. 9 is a block diagram of a generalized functional unit employed by the microprocessor of FIG. 6.
FIG. 10 is a block diagram of a branch functional unit employed by the microprocessor of FIG. 6.
FIG. 11 is a timing diagram of the operation of the microprocessor of FIG. 6 during sequential execution.
FIG. 12 is a timing diagram of the operation of the microprocessor of FIG. 6 during a branch misprediction and recovery.
DETAILED DESCRIPTION OF THE INVENTION
I. SUPERSCALAR MICROPROCESSOR OVERVIEW
The high performance superscalar microprocessor of the present invention desirably permits parallel out-of-order issue of instructions and out-of-order execution of instructions. More particularly, in the disclosed superscalar microprocessor, instructions are dispatched in program order, issued and completed out of order, and retired in order. Several aspects of the invention which permit achievement of high performance are now discussed before proceeding to a more detailed description.
The superscalar microprocessor 200 of FIGS. 2, 2A, and 2B achieves increased performance without increasing die size by sharing several key components. The architecture of the microprocessor provides that the integer unit 215 and the floating point unit 225 are coupled to a common data processing bus 535. Data processing bus 535 is a high speed, high performance bus primarily due to its wide bandwidth. Increased utilization of both the integer functional unit and the floating point functional unit is thus made possible as compared to designs where these functional units reside on separate buses.
The integer and floating point functional units include multiple reservation stations which are also coupled to the same data processing bus 535. As seen in the more detailed representation of the microprocessor of the invention in FIGS. 3, 3A, 3B, 3C, 3D and 3E, the integer and floating point functional units also share a common branch unit 520 on data processing bus 535. Moreover, the integer and floating point functional units share a common load/store unit 530 which is coupled to the same data processing bus 535. The disclosed microprocessor architecture advantageously increases performance while more efficiently using the size of the microprocessor die. In the embodiment of the invention shown in FIGS. 2 and 3, the microprocessor of the present invention is a reduced instruction set computer (RISC) wherein the instructions processed by the microprocessor exhibit the same width and the operand size is variable.
Returning to FIG. 2, a simplified block diagram of the superscalar microprocessor of the invention is shown as microprocessor 200. Superscalar microprocessor 200 includes a four instruction wide, two-way set associative, partially decoded 8K byte instruction cache 205. Instruction cache 205 supports fetching of multiple instructions per machine cycle with branch prediction. For purposes of this document, the terms machine cycle and microprocessor cycle are regarded as synonymous. Instruction cache 205 will also be referred to as ICACHE.
Microprocessor 200 further includes an instruction decoder (IDECODE) 210 which is capable of decoding and dispatching up to four instructions per machine cycle to any of six independent functional units regardless of operand availability. As seen in the more detailed embodiment of the invention depicted in FIG. 3 as microprocessor 500, these functional units include two arithmetic logic units (ALU 0 and ALU 1 shown collectively as ALU 505). These functional units further include a shifter section 510 (SHFSEC) which together with ALU section 505 form an integer unit 515 for processing integer instructions. The functional units also include a branch section (BRNSEC) 520 for processing instruction branches and for performing branch prediction. One branch unit which may be employed as branch unit 520 is described in U.S. Pat. No. 5,136,697 entitled "System For Reducing Delay For Execution Subsequent To Correctly Predicted Branch Instruction Using Fetch Information Stored With Each Block Of Instructions In Cache", issued Aug. 4, 1992, the disclosure of which is incorporated herein by reference. A floating point section (FPTSEC) 525 and a load/store section (LSSEC) 530 are also included among the functional units to which decoder (IDECODE) 210 dispatches instructions. The above described functional units all share a common main data processing bus 535 as shown in FIG. 3A, 3B, 3C, 3D and 3E. (For purposes of this document, FIGS. 3A and 3B together form microprocessor 500 and should be viewed together in side by side relationship.)
In the simplified block diagram of superscalar microprocessor 200 of FIG. 2, branches are considered to be integer operations and the branching unit is viewed as being a part of integer core 215. It is also noted that superscalar microprocessor 200 provides for tagging of instructions to preserve proper ordering of operand dependencies and to allow out-of-order issue. Microprocessor 200 further includes multiple reservation stations at the functional units where dispatched instructions are queued pending execution. In this particular embodiment, two reservation stations are provided at the input of each functional unit. More particularly, integer core 215 includes two reservation stations 220 and floating point core 225 includes two reservation stations 230 in this particular embodiment. The number of reservation stations employed per functional unit may vary according to the degree of queuing desired. Integer core 215 processes integer instructions and floating point core 225 processes floating point instructions. In actual practice, integer core 215 and floating point core 225 each include multiple functional units, each of which is equipped with multiple reservation stations in one embodiment of the invention.
In this particular embodiment, microprocessor 200 is capable of handling up to three functional unit results per machine cycle. This is so because microprocessor 200 includes three result buses designated RESULT0, RESULT 1 and RESULT 2 which are coupled to all functional units (ie. to integer core 215 and floating point core 225 in FIG. 2). The invention is not limited to this number of result buses and a greater or lesser number of result buses may be employed commensurate with the performance level desired. Similarly, the invention is not limited to the particular number of functional units in the embodiments depicted.
Microprocessor 200 further includes a unified register file 235 for storing results which are retired from a reorder buffer 240. Register file 235 is a multi-ported, multiple register storage area which permits 4 reads and 2 writes per machine cycle in one embodiment. Register file 235 accommodates different size entries, namely both 32 bit integer and 64 bit floating point operand entries in the same register file in one embodiment. Register file 235 exhibits a size of 194 32 bit registers in this particular embodiment. Reorder buffer 240 also accommodates different size entries, namely both 32 bit integer and 64 bit floating point operand entries in the same reorder buffer in one embodiment. Again, these particular numbers are given for purposes of illustration rather than limitation.
Reorder buffer 240 is a circular buffer or queue which receives out-of-order functional unit results and which updates register file 235 in sequential instruction program order. In one embodiment, reorder buffer 240 is implemented as a first in first out (FIFO) buffer with 10 entries. The queue within FIFO ROB 240 includes a head and a tail. Another embodiment of the invention employs a reorder buffer with 16 entries. Reorder buffer 240 contains positions allocated to renamed registers, and holds the results of instructions which are speculatively executed. Instructions are speculatively executed when branch logic predicts that a certain branch will be taken such that instructions in the predicted branch are executed on speculation that the branch was indeed properly taken in a particular instance. If it should be determined that the branch was mispredicted, then the branch results which are in reorder buffer 240 are effectively cancelled. This is accomplished by microprocessor effectively backing up to the mispredicted branch instruction, flushing the speculative state of the microprocessor and resuming execution from a point in the program instruction stream prior to the mispredicted branch.
Although the 10 entries of reorder buffer are 32 bits wide each (which corresponds to the width of a 32 bit integer quantity), the reorder buffer can also accommodate 64 bit quantities such as 64 bit floating point quantities, for example. This is accomplished by storing the 64 bit quantity within the reorder buffer as two consecutive ROP's. (ROP's, pronounced R-ops, refer to RISC or RISC-like instructions/operations which are processed by the microprocessor.) Such stored consecutive ROP's have information linking them as one structure and are retired together as one structure. Each reorder buffer entry has the capacity to hold one 32 bit quantity, namely 1/2 a double precision floating point quantity, one single precision floating point quantity or a 32 bit integer.
A program counter (PC) is employed to keep track of the point in the program instruction stream which is the boundary between those instructions which have been retired into register file 235 as being no longer speculative, and those instructions which have been speculatively executed and whose results are resident in reorder buffer (ROB) 240 pending retirement. This PC is referred to as the retire PC, or simply the PC. The retire PC is stored and updated at the head of the ROB queue. ROB entries contain relative PC update status information.
The retire PC is updated by status information associated with the head of the reorder buffer queue. More particularly, the reorder buffer queue indicates the number of instructions that are ready to retire, up to a maximum of four instructions in this particular embodiment. The retire PC section which is situated within retire logic 242 holds the current retired PC. If four (4) sequential instructions are to be retired in a particular clock cycle, then the retire PC logic adds [4 instructions*4 bytes/instruction] to the current retire PC to produce the new retire PC. If a taken branch exists, then the retire PC is advanced to the target of the branch once the branch is retired and no longer speculative. The retire PC is subsequently incremented from that point by the number of instructions retired. The retire PC is present on an internal bus within retire logic 242, namely PC(31:0).
II. SIMPLIFIED BLOCK DIAGRAM OF THE SUPERSCALAR MICROPROCESSOR
The discussion of this section will focus on aspects of the simplified microprocessor block diagram of FIG. 2 not already discussed above. A general perspective will be presented.
FIG. 2 shows a simplified block diagram of one embodiment of the high performance superscalar microprocessor of the present invention as microprocessor 200. In microprocessor 200, instruction cache 205 and a data cache 245 are coupled to each other via a 32 bit wide internal address data (IAD) bus 250. IAD bus 250 is a communications bus which, in one embodiment, exhibits relatively low speed when compared with data processing bus 535. IAD bus 250 serves to interconnect several key components of microprocessor 200 to provide communication of both address information and data among such components. IAD bus 250 is employed for those tasks which do not require high speed parallelism as do operand handling and result handling which data processing bus 535 handles. In one embodiment of the invention, IAD bus 250 is a 32 bit wide bus onto which both data and address information are multiplexed in each clock cycle. The bandwidth of IAD bus 250 is thus 64 bits/clock in one example.
A main memory 255 is coupled to IAD bus 250 via a bus interface unit 260 as shown in FIG. 2. In this manner, the reading and writing of information to and from main memory 255 is enabled. For convenience of illustration, main memory 255 is shown in FIG. 2 as being a part of microprocessor 200. In actual practice, main memory 225 is generally situated external to microprocessor 200. Implementations of microprocessor 200 are however contemplated wherein main memory 255 is located within microprocessor 200 as in the case of a microcontroller, for example.
Decoder 210 includes a fetcher 257 which is coupled to instruction cache 205. Fetcher 257 fetches instructions from cache 205 and main memory 255 for decoding and dispatch by decoder 210.
A bus interface unit (BIU) 260 is coupled to IAD bus 250 to interface microprocessor 200 with bus circuitry (not shown) external to microprocessor 200. More particularly, IAD bus 260 interfaces microprocessor 200 with a system bus, local bus or other bus (not shown) which is external to microprocessor 200. One bus interface unit which may be employed as BIU 260 is the bus interface unit from the AM29030 microprocessor which is manufactured by Advanced Micro Devices. BIU 260 includes an address port designated A(31:0) and a data port designated D(31:0). BIU 260 also includes a bus hand shake port (BUS HAND SHAKE) and grant/request lines designated XBREQ (not bus request) and XBGRT (not bus grant). The bus interface unit of the AM29030 microprocessor is described in more detail in the Am29030 User's Manual published by Advanced Micro Devices, Inc.
Those skilled in the art will appreciate that programs including sequences of instructions and data therefor are stored in main memory 255. When instructions and data are read from memory 255, the instructions and data are respectively stored in instruction cache 205 and data cache 245 before the instructions can be fetched, decoded and dispatched to the functional units by decoder 210.
When a particular instruction is decoded by decoder 210, decoder 210 sends the OP CODE of the decoded instruction to the appropriate functional unit for that type of instruction. Assume for example purposes that the following instruction has been fetched: ADD R1, R2, R3 (ADD the integer in register 1 to the integer in register 2 and place the result in register 3. Here, R1 is the A operand, R2 is the B operand and R3 is the destination register).
In actual practice, decoder 210 decodes four (4) instructions per block at one time and identifies the opcode associated with each instruction. In other words, decoder 210 identifies an opcode type for each of the four dispatch positions included in decoder 210. The four decoded opcode types are then broadcast on the four TYPE busses, respectively, to the functional units. The four decoded opcodes are broadcast on respective OP CODE busses to the functional units. Operands, if available, are retrieved from ROB 240 and register file 235. The operands are broadcast to the functional units over the A operand and B operand busses. If a particular operand is not available, an A or B operand tag is instead transmitted to the appropriate functional unit over the appropriate A or B operand bus. The four instructions decoded by decoder 210 are thus dispatched to the functional units for processing.
With respect to the ADD opcode in the present example, one of the functional units, namely the arithmetic logic unit (ALU) in integer core 215 will recognize the opcode type and latch in its reservation station 220 the information including opcode, A operand tag, A operand (if available), B operand tag, B operand (if available) and destination tag. The ALU functional unit then determines the result and places the result on the result bus 265 for storage in ROB 240 and for retrieval by any other functional unit needing that result to process a pending instruction.
It is noted that when an instruction is decoded by decoder 210, a register is allocated in reorder buffer 240 for the result. The destination register of the instruction is then associated with the allocated register. A result tag (a temporary unique hardware identifier) corresponding to the not yet available result of the instruction is then placed in the allocated register. "Register renaming" is thus implemented. When an instruction later in the program instruction sequence refers to this renamed destination register in reorder buffer 240, reorder buffer 240 provides either the result value which is stored in the location allocated to that register or the tag for that value if the result has not yet been computed. When the result is finally computed, a signal is placed on the result tag bus to let reorder buffer 240 and the reservation stations of the functional units know that the result is now available on the result bus. The result is thus stored in reorder buffer 240.
As seen in FIG. 3A, the destination tag line runs from reorder buffer 240 to the functional units. Decoder 210 informs the reorder buffer of the number of instructions which are presently ready for allocation of reorder buffer entries. The reorder buffer then assigns each instruction a destination tag based on the current state of the reorder buffer. Decoder 210 then validates whether each instruction is issued or not. The reorder buffer takes those instructions that are issued and validates the temporary allocation of reorder buffer entries.
The operands for a particular instruction are transported to the appropriate functional unit over the A Operand bus (A OPER) and the B Operand bus (B OPER) of common data processing bus 535. The results of respective instructions are generated at the functional units assigned to those instructions. Those results are transmitted to reorder buffer 240 via composite result bus 265 which includes 3 result buses RESULT 0, RESULT1 and RESULT 2. Composite result bus 265 is a part of data processing bus 535.
The fact that one or more operands are not presently available when a particular instruction is decoded does not prevent dispatch of the instruction from decoder 210 to a functional unit. Rather, in the case where one or more operands are not yet available, an operand tag (a temporary unique hardware identifier) is sent to the appropriate functional unit/reservation station in place of the missing operand. The OP CODE for the instruction and the operand tag are then stored in the reservation station of that functional unit until the operand corresponding to the tag becomes available in reorder buffer 240 via the result bus. Once all missing operands become available in reorder buffer 240, the operand corresponding to the tag is retrieved from reorder buffer 240. The operand(s) and OP CODE are then sent from the reservation station to the functional unit for execution. The result is placed on the result bus for transmission to reorder buffer 240.
It is noted that in the above operand tag transaction, the operand tags are actually transmitted to the reservation stations of the functional unit via the A OPER and B OPER buses. When used in this fashion to communicate operand tags, the A OPER and B OPER buses are referred to as the A TAG and B TAG buses as indicated in FIG. 2.
III. SUPERSCALAR MICROPROCESSOR; A MORE DETAILED DISCUSSION
FIG. 3 shows a more detailed implementation of the microprocessor of the present invention as microprocessor 500. Like numerals are used to indicate like elements in the microprocessors depicted in FIGS. 2, and 3. It is noted that portions of microprocessor 500 have already been discussed above.
In microprocessor 500, instructions are dispatched in speculative program order, issued and completed out of order, and retired in order. It will become clear in the subsequent discussion that many signals and buses are replicated to promote parallelism, especially for instruction dispatch. Decoder 210 decodes multiple instructions per microprocessor cycle and forms a dispatch window from which the decoded instructions are dispatched in parallel to functional units. ICACHE 205 is capable of providing four instructions at a time to decoder 210 over lines INS0, INS1, INS2 and INS3 which couple ICACHE 205 to decoder 210.
In microprocessor 500, the main data processing bus is again designated as data processing bus 535. Data processing bus 535 includes 4 OP CODE buses, 4 A OPER/A TAG buses, 4 B OPER/B TAG buses and 4 OP CODE TYPE buses. Since the 4 OP CODE buses, 4 A OPER/A TAG buses, 4 B OPER/B TAG buses and 4 OP CODE TYPE buses cooperate to transmit decoded instructions to the functional units, they are together also referred to as 4 instruction buses designated XI0B, XI1B, XI2B and XI3B (not separately labelled in the figures.) These similar instruction bus names are distinguished from one another by a single digit. This digit indicates the instruction's position in a 0 mod 16 byte block of memory, with 0 being the earlier instruction. These names are given in generic form here with the digit replaced by a lowercase "n" (ie. the four instruction buses XI0B, XI1B, XI2B and XI3B are referred to as XInB).
The features of superscalar microprocessor 500 which permit parallel out-of-order instruction execution are now briefly reiterated before commencing a more detailed discussion of the microprocessor. Microprocessor 500 includes a four-instruction-wide, two-way set associative, partially-decoded 8K byte instruction cache 205 (ICACHE) to support fetching of four instructions per microprocessor cycle with branch prediction. Microprocessor 500 provides for decode and dispatch of up to four instructions per cycle by decoder 210 (IDECODE) to any of five independent functional units regardless of operand availability. These functional units include branching section BRNSEC 520, arithmetic logic unit ALU 505, shifter section SHFSEC 510, floating point section FPTSEC 525 and LOAD/STORE section 530.
Microprocessor 500 provides tagging of instructions to preserve proper ordering of operand dependencies and allow out-of-order issue. Microprocessor 500 further includes reservation stations in the functional units at which dispatched instructions that cannot yet be executed are queued. Three result buses (RESULT0, RESULT1 and RESULT2) are provided to permit handling of up to three functional unit results per cycle. A circular buffer or FIFO queue, namely reorder buffer 240, receives out-of-order functional unit results and updates the register file 235. More particularly, the register file is updated in correct program order with results from the reorder buffer. In other words, retirement of results from the reorder buffer to the register file is in the order of correct execution with all the branches, arithmetic and load/store operations which that entails. Multiported register file 235 is capable of 4 reads and 2 writes per machine cycle. RESULT0, RESULT1 and RESULT2 are written in parallel to ROB 240. As results are retired from ROB 240, they are written in parallel to register file 235 via write buses WRITEBACK0 and WRITEBACK1. Microprocessor 500 also includes an on-board direct mapped 8K byte coherent data cache 245 to minimize load and store latency.
III (A) Instruction Flow--FETCH
The instruction flow through microprocessor 500 is now discussed. Instruction decoder (IDECODE) 210 includes an instruction fetcher 257 which fetches instructions from instruction cache (ICACHE) 205. One instruction cache which may be employed as cache 205 is described in copending U.S. patent application Ser. No. 07/929,770, filed Apr. 12, 1992, entitled "Instruction Decoder And Superscalar Processor Utilizing Same" which was incorporated herein by reference earlier in this document. One decoder which may be employed as decoder 210 (IDECODE) is also described in U.S. patent application Serial No. Ser. No. 07/929,770, filed Apr. 12, 1992, entitled "Instruction Decoder And Superscalar Processor Utilizing Same".
As a particular program in main memory 255 is being run by microprocessor 500, the instructions of the program are retrieved in program order for execution. Since instructions aren't normally in ICACHE 205 to begin with, a typical ICACHE refill operation will first be discussed. On a cache miss, a request is made to the bus interface unit (BIU) 260 for a four-word block of instructions aligned in memory at 0 mod 16 bytes (the cache block size). This starts a continuing prefetch stream of instruction blocks, with the assumption being that subsequent misses will also occur. A four word block is the minimum transfer size, since in this particular embodiment there is only one valid bit per block in the cache. A valid bit indicates that the current 16 byte entry and tag is valid. This means that the entry has been loaded and validated to the currently running program.
As a block of instructions returns (low-order word first, as opposed to word-of-interest first), it passes through a predecode network (not shown) which generates four bits of information per instruction. If the previous block of instructions has been dispatched, the next instruction block (new instruction block) advances to instruction register 258 and IDECODE 210. Otherwise the next instruction block waits in prefetch buffer 259. Instruction register 258 holds the current four instructions that are the next instructions to be dispatched for speculative execution. Prefetch buffer 259 holds a block of prefetched instructions that ICACHE 205 has requested. These instructions will be subsequently predecoded and fed into ICACHE 205 and IDECODE 210. By holding a block of prefetched instructions in this manner, a buffering action is provided such that dispatching by IDECODE 210 and prefetching need not to run in lockstep.
The next instruction block is written into ICACHE 205 when the next instruction which is predicted executed advances to decode if there are no unresolved conditional branches. This approach desirably prevents unneeded instructions from being cached. The predecode information is also written in the cache. Predecode information is information with respect to the size and content of an instruction which assists in quickly channelling a particular instruction to the appropriate functional unit. More information with respect to predecoding is found in the U.S. patent application entitled "Pre-Decoded Instruction Cache And Method Therefor Particularly Suitable For Variable Byte-Length Instructions (Ser. No. 08/145,905), filed concurrently herewith and assigned to the instant assignee, the disclosure of which is incorporated herein by reference.) It is noted that branch prediction is used to predict which branches are taken as a program is executed. The prediction is later validated when the branch is actually executed. Prediction occurs during the fetch stage of the microprocessor pipeline.
The prefetch stream continues until BIU 260 has to give up the external bus (not shown) coupled thereto, the data cache 245 needs external access, the prefetch buffer 259 overflows, a cache hit occurs or a branch or interrupt occurs. From the above it will be appreciated that prefetch streams tend not to be very long. Generally, external prefetches are at most two blocks ahead of what is being dispatched.
It is noted that, in this particular embodiment, there is only one valid bit per block in instruction cache 205 (ICACHE) so partial blocks do not exist--all external fetches are done in blocks of four instructions. Again, there is only one valid bit per block in the cache. ICACHE 205 also contains branch prediction information for each block. This information is cleared on a refill.
Now that instructions have progressed into ICACHE 205, superscalar execution can commence. It is noted that once an externally fetched block advances to decode, operation is the same as though it were fetched from ICACHE 205, but overall performance is limited by the maximum external fetch rate of one instruction per cycle. A four word block of instructions is fetched and advanced to decode along with the predecode information (cache read at PH2, instruction buses driven at PH1). PH1 is defined as the first of the two phases of the clock and PH2 is defined as the second of the two phases of the clock. PH1 and PH2 constitute the fundamental timing of a pipelined processor.
As seen in FIG. 3A, a 32 bit Fetch PC (FPC) bus, FPC(31:0), is coupled between instruction cache (ICACHE) 205 and fetcher 257 of decoder (IDECODE) 210. More particularly, the FPC bus extends between FPC block 207 in ICACHE 205 and fetcher 257. The Fetch PC or FPC block 207 in instruction cache 205 controls the speculative fetch program counter, designated FPC, located therein. FPC block 207 holds the program count, FPC, associated with the instructions which fetcher 257 prefetches ahead of the dispatch of instructions by decoder 210 to the functional units. The FPC bus indicates the location for the ICACHE to go on an exception or branch prediction. The fetch PC block 207 uses branch prediction information stored in instruction cache 205 to prefetch instructions (4 wide) into decoder 210. The Fetch PC block can either predict sequential accesses, in which case it increments the current Fetch PC by 16 bytes when a new block is required, or branch to a new block. The new branch positions can either be received from the instruction cache for predicted branches, or from the branch functional unit on misprediction or exceptions. The Fetch PC or FPC is to be distinguished from the retire PC discussed earlier.
The Fetch PC (FPC) is incremented at PH1 and the next block is read out of ICACHE 205, although IDECODE 210 will stall fetcher 257 by asserting HOLDIFET if it has not dispatched all the instructions from the first block. The function of the HOLDIFET signal is to hold the instruction fetch because the four instructions in instruction register 258 cannot advance.
Fetcher 257 also assists in the performance of branch prediction. The branch prediction is an output of instruction cache 205. When a branch is predicted, the four instructions of the next block which is predicted are output by instruction cache 205 onto instruction lines INS0, INS1, INS2 and INS3. An array IC-- NXTBLK (not shown) in instruction cache 205 defines for each block in the cache what instructions are predicted executed in that particular block and also indicates what the next block is predicted to be. In the absence of a branch, execution would always be sequential block by block. Thus, branches that are taken are the only event which changes this block oriented branch prediction. In other words, in one embodiment of the invention, the sequential block by block prediction changes only when a branch predicted not taken is taken and subsequently mispredicted.
The first time a block containing a branch instruction is sent to decoder 210 (IDECODE), subsequent fetching is sequential, assuming the branch will not be taken. When the branch is executed and some time later turns out to actually be taken, branch prediction unit (branch unit) 520 notifies ICACHE 205, which updates the prediction information for that block to reflect 1) the branch was taken, 2) the location within the block of the branch instruction and 3) the location in the cache of the target instruction. Fetcher 257 is also redirected to begin fetching at the target. The next time that block is fetched, fetcher 257 notes that it contains a branch that was previously taken and does a nonsequential fetch with the following actions: 1) instruction valid bits are set only up to and including the branch's delay slot; Branch delay is a concept of always executing the instruction after a branch and is also referred to as delayed branching. This instruction is already prefetched in a scalar RISC pipeline, so that in the event of a branch there is no overhead lost in executing it. 2) an indication that the branch was predicted taken is sent along with the block to decoder 210; 3) the cache index for the next fetch is taken from the prediction information; (The cache index is the position within the cache for the next block that is predicted executed when a branch occurs. Note that the cache index is not the absolute PC. Rather, the absolute PC is formed by concatenating the TAG at that the position with the cache index.) 4) the block at this cache index is fetched and a predicted target address is formed from the block's tag and the prediction information is placed in the Branch FIFO (BRN FIFO) 261; 5) valid bits for this next block are set starting with the predicted target instruction.
The Branch FIFO 261 is used to communicate the target address predicted by fetcher 257 to the branch functional unit (BNRSEC) 550. It is noted that, although shown separately, the Branch FIFO 261 is considered to be a part of branching section BRNSEC 550. Branch FIFO 261 is loaded with the PC of the instruction where the branch was predicted taken as well as the target. When the branch instruction is actually dispatched, the branch instruction is compared to the entry in the Branch FIFO, namely the PC stored therein. If there is a match, then the entry is flushed from the Branch FIFO and the branch instruction is returned to reorder buffer 240 as predicted successfully. If there is a misprediction, then the PC that is correct is provided to reorder buffer 240.
The prediction bit is dispatched by decoder 210 along with the branch instruction to branch unit 520. The prediction bit indicates whether a particular branch was predicted taken from the information stored in the IC-- NXTBLK array.
When branch unit 520 executes the instruction, the outcome is compared with the prediction and, if taken, the actual target address is compared with the entry at the top of the Branch FIFO (waiting if necessary for it to appear). If either check fails, branch unit 520 redirects fetcher 257 to the proper target address and updates the prediction. Note that this is how a cache miss is detected for a predicted non-sequential fetch, rather than by fetcher 257. The prediction information contains only a cache index, not a full address, so the tag of the target block cannot be checked for a hit; the target address is assumed to be the address of the block at that index as specified by its tag. If the actual target block has been replaced since the branch was last executed, this will result in a miscompare and correction upon execution. When a misprediction does occur, many instructions past the branch may have been executed, not just its delay slot.
One branch prediction unit which can be used as branch prediction unit 520 is described in U.S. Pat. No. 5,136,697, W. M. Johnson, entitled "System For Reducing Delay For Execution Subsequent To Correctly Predicted Branch Instruction Using Fetch Information Stored With Each Block Of Instructions In Cache, issued Aug. 4, 1992, the disclosure of which is incorporated herein by reference.
III (B) Instruction Flow--Decode, Register File Read, Dispatch
The instructions advance to IDECODE 210 one block at a time and occupy specific locations in instruction register 258 corresponding to their positions in the memory block (0=earliest in sequence). Accompanying each instruction is its predecode information and a valid bit.
The primary function of IDECODE 210 is to classify instructions according to the functional units that will handle the instructions and dispatch the instructions to those functional units. This is done by broadcasting four 3-bit instruction type codes (INSTYPn) to all the functional units, and in any given cycle asserting a signal for each instruction that is being dispatched (XINSDISP(3:0)). (In this document, some signals appear with and without the X designation. The X, such as in the XINSDISP signal, indicates that a false assertion discharges the bus.) As seen in FIG.3, microprocessor 500 includes 4 TYPE buses, INSTYPn(7:0), for the purpose of broadcasting the type codes to the functional units. A respective TYPE bus is provided for each of the four instructions of a particular block of instructions.
When a particular functional unit detects a TYPE signal corresponding to its type, that functional unit knows which one of the four instructions of the current block of instructions in the current dispatch window of IDECODE 210 it is to receive because of the position of the detected type signal on the type bus. The type bus has four sections corresponding to respective dispatch positions of the IDECODE 210. That functional unit also determines which function it is to perform on the operand data of that instruction by the operation code (opcode) occurring on that section of the dispatch information bus corresponding to the detected type. Also, since the functional unit knows which instruction it is to execute, it will align its hardware with the respective destination tag bus, DEST. TAG(0:3), and operand data bus for receiving the operand data and the destination tag.
As instructions are dispatched, their valid bits are reset and their type becomes "null". All four instructions of a particular block must be dispatched before the next block of instructions is fetched. All four instructions of a block may be dispatched at once, but the following events can, and often do occur, to slow this process down: 1) Class conflict--this occurs when two or more instructions need the same functional unit. Integer codes are important for microprocessor 500. For this reason, one embodiment of the invention includes two ALUs to reduce the occurrence of class conflict among the functional units: ALU0, ALU1, SHFSEC, BRNSEC, LSSEC, FPTSEC and SRBSEC. Instructions are dispatched to SRBSEC 512 only at serialization points. In other words, only instructions which must be executed serially are sent to SRBSEC 512.
2) Functional unit unable to accept instructions.
3) Register file (RF) 235 ports not available--in this embodiment, there are only four RF read ports, not eight as one might expect for feeding eight operand buses. It has been found that having such a reduced number of read ports is not as limiting as it might first appear since many instructions do not require two operands from register file 235 or can be satisfied via operand forwarding by ROB 240. Other embodiments of the invention are contemplated wherein a greater number of RF read ports, such as eight, for example are employed to avoid a potential register file port not available situation.
4) Lack of space in reorder buffer 240--each instruction must have a corresponding reorder buffer entry (or as in the case of double and extended precision floating point instructions,two reorder buffer entries are provided), and the reorder buffer indicates through ROBSTAT(3:0) how many of the predicted instructions it can find a place for. As seen in FIG. 3A, a status bus designated ROBSTAT (3:0) is coupled between reorder buffer (ROB) 240 and decoder (IDECODE) 210. ROBSTAT (3:0) indicates from the ROB to IDECODE how many of the four current instructions have an ROB entry allocated. It is noted here that it is possible to fill up the entries of the ROB.
5) Serialization--some instructions modify state which is beyond the scope of the mechanisms that preserve sequential state--these instructions must be executed in program order with respect to surrounding instructions (for example, MTSR, MFSR, IRET instructions).
When one of the above listed five conditions occurs, the affected instruction stops dispatch; no subsequent instructions may be dispatched even though there may be nothing else holding them up. For each dispatch position there is a set of A and B operand buses (also referred to as XRDnAB/XRDnBB buses) that supply source operands to the functional units. Register file 235 is accessed at PH2 in parallel with decode and the operands are driven on these buses at PH1. If an instruction which will modify a source register is still in execution, the value in the Register File 235 is invalid. This means that Register File 235 and ROB 240 do not contain the data and therefore a tag is substituted for the data. Reorder buffer (ROB) 240 keeps track of this and is accessed in parallel with Register File access. Note that operand unavailability or register conflicts are of no concern for dispatch. ROB 240 can be viewed as a circular buffer with a predetermined number of entries and a head and tail pointer.
When an instruction is dispatched, an entry in the ROB is reserved for its destination register. Each entry in the ROB consists of: 1) the instruction's destination register address; 2)space for the instruction's result (which may require two entries for a double precision operation or a CALL/JMPFDEC type of instruction), as well as exception status information; and 3) bits to indicate that a) an entry has been allocated and b) a result has returned.
Entries are assigned sequentially beginning at the tail pointer. The Allocate bit is set to indicate the instruction has been dispatched. The Allocate bit is associated with each ROB entry. The Allocate bit indicates that a particular ROB entry has been allocated to a pending operation. The Allocate bit is deallocated when an entry retires or an exception occurs. A separate valid bit indicates whether a result has completed and has been written to the register file. The address of an entry (called the result or destination tag) accompanies the corresponding instruction from dispatch through execution and is returned to ROB 240 along with the instruction's result via one of the result buses.
In more detail, the destination tags are employed when an instruction is dispatched to a functional unit and the result tags are employed when the instruction returns, that is, when the result returns from the functional unit to the ROB. In other words, destination tags are associated with the dispatched instructions and are provided to the functional unit by the reorder buffer to inform the functional unit as to where the result of a particular instruction is to be stored.
In more detail, the destination tag associated with an instruction is stored in the functional unit and then forwarded on the result bus. Such destination tags are still designated as destination tags when they are transmitted on the result bus. These tags are compared with operand tags in the reservation stations of the other functional units to see if such other functional units need a particular result. The result from a particular functional unit is forwarded back to the corresponding relative speculative position in the ROB.
The result of an instruction is placed in the ROB entry identified by the instruction's destination tag which effectively becomes the result tag of that instruction. The valid bit of that particular ROB entry is then set. The results remain there until it is their turn for writeback to the register file. It is possible for entries to be allocated faster to ROB 240 than they are removed, in which case ROB 240 will eventually become full. The reorder buffer full condition is communicated via the ROBSTAT (3:0) bus back to decoder 210. In response, decoder 210 generates the HOLDIFET signal to halt instructions from being fetched from ICACHE 205. It is thus seen that the ROB full condition will stall dispatch by decoder 210.
Returning to a discussion of the handling of operands, it is noted that the results that are waiting in ROB 240 for writeback can be forwarded to other functional units if needed. This is done by comparing the source register addresses of instructions in IDECODE 210 with the destination register addresses in the ROB, in parallel with register file access at decode time. For the most recent address matches which occur for the A and B source operands and which have the result Valid bit set, ROB 240 drives the corresponding results on the appropriate operand buses in place of register file 235. When this match occurs, ROB 240 activates the OVERRIDE line between ROB 240 and register file 235 to instruct register file 235 not to drive any operands on the A and B operand buses.
For example, assume that decoder 210 is decoding the instruction ADD R3, R5, R7 which is defined to mean add the contents of register R3 to the contents of register R5 and place the results in register R7. In this instance, the source register addresses R3 and R5 decoded in IDECODE are compared with the destination register addresses in ROB 240. Assume for purposes of this example that the result R3 is contained in ROB 240 and that the result R5 is contained in register file 235. Under these circumstances, the compare between source address R3 in the decoded instruction and the destination register address R3 in ROB 240 would be positive. The result in the ROB entry for register R3 is retrieved from ROB 240 and is broadcast on the operand A bus for latching by the reservation station of the appropriate functional unit, namely ALU0 or ALU1. Since a match was found with an ROB entry in this case, the OVERRIDE line is driven to prevent register file 235 from driving the A operand bus with any retired R3 value it may contain.
In the present example, the compare between the source address R5 in the decoded instruction and the destination register addresses contained in ROB 240 is not successful. The result value R5 contained in register file 235 is thus driven onto the B operand bus where that result is broadcast to the functional units, namely ALU0 for execution. When both the A operand and B operand are present in a reservation station of the ALU0 functional unit, the instruction is issued to ALUO and is executed by ALU0. The result (result operand) is placed on the result bus 265 for transmission to the reservation stations of other functional units which are looking for that result operand. The result operand is also provided to ROB 240 for storage therein at the entry allocated for that result.
Even if a desired operand value is not yet in ROB 240 (as indicated by an asserted Valid bit), the instruction can still be dispatched by decoder 210. In this case, ROB 240 sends the index of the matching entry (i.e. the result tag of the instruction that will eventually produce the result) to the functional unit in place of the operand. It is again noted that there are effectively eight A/B tag buses (ie. 4 A tag buses and 4 B tag buses, namely TAGnAB(4:0) and TAGnBB(4:0) wherein n is an integer) that correspond to the eight operand buses. The most significant bit (MSB) of a tag indicates when a tag is valid.
When more than one ROB entry has the same destination register tag, the most recent entry is used. This distinguishes between different uses of the same register as a destination by independent instructions, which otherwise would artificially decrease available parallelism. (This is known as a Write-after-Write hazard.)
The predecode information that is generated when caching instructions comes into play in decode. It is noted that the predecode information passes from ICACHE 205 to IDECODE 210 over the PREDECODE line.
Predecoding operates in the following fashion. For each instruction, there is a predecode signal, PREDECODE, which includes a 2 bit code that speeds up allocation of ROB entries by indicating how many entries are needed (some instructions require one entry, some instructions require two entries). For example, the add instruction ADD (RA+RB)→ RC requires one entry for the single 32 bit result which is to be placed in register RC. It contrast, the multiply instruction DFMULT (RA+RB)(double precision) requires two ROB entries to hold the 64 bit result. In this particular embodiment of the invention, each ROB entry is 32 bits wide. This 2-bit code further indicates how many result operands will result from a given instruction (ie. none--e.g. branches, one--most, or two--double precision). The predecode information includes two additional bits which indicate whether or not a register file access is required for A and B operands. Thus, there are 4 bits of predecode information per 32 bit instruction in microprocessor 500. These bits enable efficient allocation of the register file ports in PH1 prior to the PH2 access. If an instruction is not allocated the register file ports that it needs, but ROB 240 indicates the operands can be forwarded, the instruction may still be dispatched anyway.
III (C) Instruction Flow--Functional Units, Reservation Stations
FIG. 3 shows that all of the functional units of microprocessor 500 reside on a common data processing bus 535. Data processing bus 535 is a high speed bus due to its relatively wide bandwidth. Each of the functional units is equipped with two reservation stations at its input. Other embodiments of the invention are contemplated wherein a greater or lesser number of reservation stations are employed at the functional units.
To review, integer unit 515 includes arithmetic logic units ALU0 and ALU1. ALU0 is provided with reservation stations 540 and ALU1 is provided with reservation stations 545. Branching unit 520 (BRNSEC) is furnished with reservation stations 550 at its input. Floating point unit (FPTSEC) 525 includes floating point add unit 555 which is provided with reservation stations 560. Floating point unit 525 further includes a floating point convert unit 565 which is equipped with reservation stations 570. Floating point unit 525 also includes a floating point multiply unit 575 which is equipped with reservation stations 580. And finally, floating point unit 525 further includes a floating point divide unit 585 which is furnished with reservation stations 590 at its input. Load/store unit 530 also resides on data processing bus 535 and includes reservation stations 600.
As seen in FIG. 3 the main inputs to each functional unit (ie. to each reservation station associated with a functional unit) are provided by the constituent buses of main data processing bus 535, namely:
1) the four OPCODE buses from IDECODE 210 (designated INSOPn(7:0) wherein n is an integer from 0-3);
2) the four instruction type buses from IDECODE 210 (designated INSTYPn(7:0) wherein n is an integer from 0-3);
3) the four four-bit dispatch vector buses from IDECODE 210 (designated XINSDISP(3:0);
4) the four pairs of A operand buses and B operand buses (designated XRDnAB/XRDnBB(31:0)) wherein n is an integer from 0-3);
5) the four pairs of associated A/B tag buses (designated TAGnAB/TAGnBB(4:0) wherein n is an integer from 0-3);
6) a result bus 265 including 3 bidirectional result operand buses (designated XRESOB(31:0), XRES1B(31:0), XRES2B(31:0);
7) two result tag buses (designated XRESTAG0B/XRESTAG1B(2:0)) and 8) two result status buses (designated XRESSTAT0B and XRESSTAT1B(2:0)
One or more reservation stations are positioned in front of each of the above functional units. A reservation station is essentially a first-in-first-out (FIFO) buffer at which instructions are queued while waiting for execution by the functional unit. If an instruction is dispatched with a tag in place of an operand, or the functional unit is stalled or busy, the instruction is queued in the reservation station, with subsequent instructions queuing up behind it. (Note that issue within a particular functional unit is strictly in-order). If the reservation station fills up, a signal indicating this is asserted to IDECODE. This causes dispatch to stall if another instruction of the same type is encountered.
Instruction dispatch takes place as follows: Each reservation station includes reservation station logic that watches the instruction TYPE buses (at PH2) for a corresponding instruction type. The reservation station then selects the corresponding opcode, A and B operand and A and B operand tag buses when such an instruction type is encountered. If two or more instructions are seen that will execute in the associated functional unit, the earlier one with respect to program order takes precedence. The instruction is not accepted by the reservation station however until it sees the corresponding dispatch bit set (XINSDISP(n) at PH1).
At that point, if the required operands are available, and provided that the functional unit is not stalled for some reason or busy, and further provided that no previous instructions are waiting in the reservation station, the instruction will immediately go into execution in the same clock cycle. Otherwise, the instruction is placed in the reservation station. If an instruction has been dispatched with an operand tag in place of an operand, the reservation station logic compares the operand tag with result tags appearing on the result tag buses (XRESTAG0B and XRESTAG1B). If a match is seen, the result is taken from the corresponding result bus of result bus group 265. This result is then forwarded into the functional unit if it enables the instruction to issue. Otherwise, the result is placed in the reservation station as an operand where it helps complete the instruction and the corresponding tag valid bit is cleared. Note that both operands may be simultaneously forwarded from either or both of the general purpose result buses.
The three result buses forming result bus 265 include two general purpose result buses, XRESOB(31:0) and XRES1B(31:0), and further include one result bus dedicated to branches and stores, XRES2B(31:0). Since result bus XRES2B(31:0) is dedicated to branches and stores, the results that it handles (like the Branch PC address, for example) are not forwarded. The functional units monitor result buses XRES0B(31:0) and XRES1B(31:0) whereas reorder buffer (ROB) 240 monitors all three result buses.
As instructions wait in the reservation station, any valid operand tags are likewise compared with result tags and similar forwarding is done. Result forwarding between functional units and within a functional unit is done in this manner. This tagging, in conjunction with the reservation stations, allows instructions to execute out of order in different functional units while still maintaining proper sequencing of dependencies, and further prevents operand hazards from blocking execution of unrelated subsequent instructions. The instruction types and A/B tags are available in PH2 while the decision to issue is made in the subsequent PH1.
Operands in the reservation station have a tag and valid bit if they were not sent actual operand data. In other words, if an instruction is dispatched to the reservation station and a particular operand is not yet available, then an operand tag associated with that operand is instead provided to the reservation station in place of the actual operand. A valid bit is associated with each operand tag. As results are completed at the functional units the results are provided to the result buses which are coupled to the other functional units and to ROB 240. The results are compared against operand tags in the reservation stations and if a hit occurs, the tag valid bit is cleared and the operand from the result bus is forwarded to the location in the functional unit designated for operands. In other words, a tag compare on result tags 0 and 1 that matches any entry in a reservation station forwards the value into that station.
Determining which instruction source (the reservation station or one of the four incoming buses coupled to the reservation station) is the next candidate for local decoding and issue is done in PH2 by examining the Reservation Station Valid bit for the entry at the head of the reservation station and the decoded/prioritized instruction type buses; an entry in the reservation station takes precedence. In a functional unit with two reservation stations, the two reservation stations form a first-in-first-out (FIFO) arrangement wherein the first instruction dispatched to the reservation station forms the head of the FIFO and the last instruction dispatched to the FIFO forms the tail of the FIFO.
Local decoding by the functional unit means that by monitoring the type bus the functional unit first determines that an instruction of its type is being dispatched. Then once the functional unit identifies an instruction which it should process, the functional unit examines the corresponding opcode on the opcode bus to determine the precise instruction which the functional unit should execute.
In this embodiment of the invention, execution time depends on the particular instruction type and the functional unit which is executing that instruction. More particularly, execution time ranges from one cycle for all ALU, shifter, branch operations and load/stores that hit in the cache, to several cycles for floating point, load/store misses and special register operations. A special register is defined as any not general purpose register which is not renamed.
The functional units arbitrate for the result buses as follows: Result Bus 2 is used for stores which don't return an operand and also for branches which return the calculated target address. It is noted that branches have priority. General purpose Result Buses 0 and 1 handle results from either ALU0 or ALU1, from shifter unit 510, from floating point unit 525, and also loads and special register accesses.
The priority among the functional units with respect to obtaining access to Result Bus 0 (also designated XRES0B(31:0) and Result Bus 1 (also designated XRES1B(31:0) is set forth in FIG. 4. In the chart of FIG. 4, the term "low-order half of DP" means the lower half of a double precision number. Microprocessor 500 employs 32 bit operand buses to send a double precision (DP) number. More particularly, when a double precision number is transmitted over the operand buses, the number is transmitted in two 32 bit portions, namely an upper 32 bit portion and a lower 32 bit portion. The upper and lower portions are generally transmitted over two cycles and 2 operand buses. The denial of a request for access to a particular result bus by a functional unit will stall that functional unit and may propagate back to decode as a reservation station full condition.
Results include a 3-bit status code (RESULT STATUS) indicating the type of result (none, normal or exception, plus instruction specific codes, namely data cache miss, assert trap and branch misprediction). In one embodiment, a result also includes a 32-bit result operand and detailed execution or exception status depending on the unit and instruction. The result buses 235 are used to return results to ROB 240 as well as for forwarding results to the functional unit reservation stations. All of the result information is stored in ROB 240, but functional units only look at the result status code and result operand.
Most functional units operate in the manner described above. However, the Special Register Block Section (SRBSEC) 512 and Load/Store Section (LSSEC) 530 are somewhat different. The SRBSEC functional unit keeps machine state information such as status and control registers which are infrequently updated and which are not supported by register renaming. Moves to and from the special registers of SRBSEC 512 are always serialized with respect to surrounding instructions. Thus, the SRBSEC, while being a separate functional unit, does not need a reservation station since serialization assures that operands are always available from register file 235. Examples of instructions which are executed by the SRBSEC functional unit are the "move to special register" MTSR and "move from special register" MFSR instructions. Before executing such an instruction which requires serialization, microprocessor 500 serializes or executes all speculative states before this instruction. The same special register block as employed in the AM29000 microprocessor manufacturing by Advanced Micro Devices may be employed as SRBSEC 512.
The load/store section LSSEC 530 uses a reservation station in the same manner as the other functional units. Load/store section 530 controls the loading of data from data cache 245 and the storing of data in data cache 245. However, with respect to execution of instructions, it is the most complex functional unit. The LSSEC is closely coupled with the data cache (DCACHE) 245 and memory management unit (MMU) 247. Microprocessor 500 is designed such that any action that modifies data cache 245 or main memory 255 may not be undone. Moreover, such modification must take place in program order with respect to surrounding instructions. This means that the execution of loads that miss in the data cache, and all stores, must be coordinated with retire logic 242 in the ROB 240. This is done using a mechanism called the Access Buffer 605, which is a FIFO where these operations are queued until the corresponding ROB entries are encountered by the ROB retire logic.
One data cache which can be employed as data cache (DCACHE) 245 and one load/store section which can be employed as load/store section (LSSEC) 530 is described in the U.S. patent application entitled "High Performance Load/Store Functional Unit And Data Cache" (Ser. No. 08/146,376), filed concurrently herewith and assigned to the instant assignee, the disclosure of which is incorporated herein by reference. More information with respect to addressing of instruction caches and data caches is provided in the copending U.S. patent application entitled "Linearly Addressable Microprocessor Cache" (Ser. No. 08/146,381), filed concurrently herewith and assigned to the instant assignee, the disclosure of which is incorporated herein by reference.
Access buffer 605 is located in LSSEC 530. In one embodiment, access buffer 605 is a 2-4 word FIFO of stores (hit/miss) or loads that miss. A store that hits cannot be written until it is next to execute. However, an access or store buffer allows this state to be held in a temporary storage which can subsequently forward data references in a manner similar to the way the ROB forwards register references. The access buffer finally writes to data cache 245 (CACHE) when the access buffer contents are next in program order. In other words, an access buffer or store buffer is a FIFO buffer which stores one or more load/store instructions so that other load/store instruction can continue to be processed. For example, access buffer 605 can hold a store while a subsequent load is being executed by load/store unit LSSEC 530.
Access buffers, which are also known as store buffers, and a load/store functional unit used in conjunction with a data cache are discussed in more detail in copending patent application entitled High Performance Load/Store Functional Unit And Data Cache, filed concurrently herewith and assigned to the instant assignee, the disclosure of which is incorporated herein by reference.
The function of ROB retire logic 242 is to determine which instructions are to be retired into register file 235 from ROB 240. The criteria for such retirement of an ROB entry are that the entry be valid and allocated, that the result has been returned from a functional unit, and that the entry has not been marked with a misprediction or exception event.
A store operation requires two operands, namely memory address and data. When a store is issued, it is transferred from the LSSEC reservation station 600 to the Access Buffer 605 and a store result status is returned to ROB 240. The store may be issued even though the data is not yet available, although the address must be there. In that case, the Access Buffer will pick up the store data from result buses 235 using the tag in a manner similar to a reservation station. As the store is issued, the translation lookaside buffer (TLB) 615 lookup is done in memory management unit (MMU) 247 and the Data Cache is accessed to check for a hit.
The physical address from the MMU and the page portion of the virtual address along with status info from the data cache is placed in the Access Buffer. In other words, the cache is physically addressed. If a TLB miss occurs, this is reflected in the result status and an appropriate trap vector is driven on Result Bus 2--no other action is taken at that time. (The TLB lookup for loads is done the same way, although any trap vector goes on Result Bus 1.)
A trap vector is an exception. Microprocessor 500 takes a TLB trap to load a new page into physical memory and update the TLB. This action may take several hundred cycles but it is a relatively infrequent event. Microprocessor 500 freezes the PC, stores out the microprocessor registers, executes the vector, restores the register state, then executes an interrupt return.
When the Store reaches the head of the Access Buffer (which will be immediately if it's empty) it waits for ROB 240 to assert a signal designated LSRETIRE which indicates that the corresponding ROB entry has reached the retire stage; it then proceeds with the cache access. The access may be delayed however if the cache is busy completing a previous refill or doing a coherency operation. Meanwhile, ROB 240 will carry on and may encounter another store instruction. To keep that store instruction from being retired before LSSEC is ready to complete it, handshaking is employed as follows. LSSEC 530 provides ROB 240 with a signal indicating when LSSEC has completed an operation by asserting LSDONE. It is noted that ROB 240 stalls on a store (or load) if it has not seen LSDONE since the previous store was retired.
A load operation that hits in data cache 245 does not have to be coordinated with ROB 240. However, a miss must be coordinated with ROB 240 to avoid unnecessary refills and invalid external references past a mispredicted branch. When a load is issued, the cache access is done right away (provided the cache is not busy). If there is a hit in the cache, the result is returned to the ROB on the Result Bus with a normal status code. If there is a miss, the load is placed in the Access Buffer 605 and a load-- miss result code is returned. When the ROB 240 retire logic 242 encounters this condition, it asserts LSRETIRE and the refill starts with the desired word being placed on the Result Bus with a load-- valid result status code as soon as it comes along (no wait for refill to finish). It is noted that ROB 240 can't retire a load upon asserting LSRETIRE like it does for a store. Rather, ROB 240 must wait for the data to return.
A load may be processed even if there are previous uncompleted store operations waiting in the Access Buffer. When allowing a load to be done out-of-order with respect to stores, microprocessor 500 ensures that the load is not done from a location that is yet to be modified by a previous (with respect to program order) store. This is done by comparing the load address with any store addresses in Access Buffer 605, in parallel with the cache access. If none match, the load goes ahead. If one does match (the most recent entry if more than one), then the store data is forwarded from Access Buffer 605 to the result bus 265 instead of the cache data. Any cache miss that may have occurred is ignored (ie. no refill occurs). If the store data is not yet present, the load stalls until the store data arrives. Moreover, these actions desirably prevent memory accesses from unnecessarily inhibiting parallelism.
Additional load/store considerations are now discussed. For 1K byte and 2K byte page sizes, the translation lookaside buffer (TLB) lookup is done prior to the cache access. This causes an additional cycle of load/store latency. It is also noted that when LSSEC "completes" a load or store, this does not mean the associated cache activity is completed. Rather, there may still be activity in either the ICACHE or DCACHE, the BIU, and externally, such as a refill.
Access Buffer forwarding is not done for partial-word load/store operations. If a word-address match is detected and there is any overlap between the load and store, the load is forced to look like a cache miss and is queued in access buffer 605 so that it will execute after the store (and may or may not actually hit in the cache). If there is no overlap, the load proceeds as though there were no address match.
It is noted that load/store multiple instructions are executed in serialized fashion, that is, when load/store multiple operation are being executed, no other instructions are executed in parallel. A load or store (load/store) multiple instruction is a block move to or from the register file. This instruction includes a given address, a given register, and a count field. An example of a load/store multiple instruction is LOADM (C,A,B) wherein C is the destination register, A is the address register and B is the number of transfers.
It is also noted that loads misses don't necessarily cause a refill. Rather, the page may be marked as uncachable, or the load may have been satisfied from access buffer.
III (D) Instruction Flow--Reorder Buffer and Instruction Retiring
As results are returned to ROB 240, they are written into the entry specified by the result tag, which will be somewhere between the head and tail pointers of the ROB. The retire logic 242, which controls writeback, the execution of stores and load misses, traps and updating of PC0, PC1 and PC2, looks at entries with valid results in program order.
PC0, PC1 and PC2 are mapped registers containing the PC values of DEC, EXEC and WRITEBACK0,1. The signal DEC, EXEC and WRITEBACK 0,1 refer to the stages decode, execute and writeback from the scalar AM29000 pipeline, the AMD2900 being a microprocessor available from Advanced Micro Devices, Inc. These signals are used to restart the pipeline upon an exception. More than one PC is used because of delayed branching. PC0, PC1 and PC2 are used on an interrupt or trap to hold the old value of DEC, EXEC and WRITEBACK0,1 to which microprocessor 500 can return upon encountering a branch misprediction or exception. PC0, PC1 and PC2 are used on interrupt return for restarting the pipeline, and are contained in retirement logic 242 in reorder buffer 240. PC1 maps the current retire PC.
As entries with normal results are encountered, the result operands (if any) are written to the register file (RF) 235 locations specified in the entries. There are two RF write ports (WR), so two result operands may be retired to the register file at the same time. ROB 240 can additionally retire one store and one branch, for a maximum of four instructions being retireable per microprocessor cycle.
Other states such as CPS bits and FPS Sticky bits may also be updated at this time. CPS refers to the current processor status, CPS indicates program state and condition code registers. FPS refers to floating point status register bits. FPS indicates status/condition code registers for the floating point functional unit 525. FPS Sticky Bits are bits that can be set by a set condition and not cleared on clear condition. FPS Sticky Bits are used for rounding control on floating point numbers. For example, if microprocessor 500 subtracts or shifts a value, some of the least significant bits (LSB's) may be shifted off the mantissa. The FPS Sticky Bits give an indication that this condition has occurred.
An entry in ROB 240 whose results have not yet returned causes further processing to stall until the results come back. Nothing past that entry may be retired, even if valid. When a store result is encountered, ROB 240 gives the go-ahead to the load/store section to actually do the store and then retires the instruction. When a load miss result is encountered, ROB 240 gives the go-ahead to execute the load. When the load completes, the requested load operand is returned to ROB 240 with load hit status, which allows the instruction to be retired and which is also seen by any reservation stations waiting for that operand. When a branch result is encountered, ROB 240 uses it to update PC1
The architectural state of the microprocessor is the current state of the retirement PC in the program. The speculative state of the microprocessor is all of the entries in the reorder buffer, in the decoder and the current value of the FETCHPC. These form the current speculative queue of instructions which is dynamically updated. On exception or misprediction, all of the speculative state can be cleared, but not the architectural state, since it is the current state of the register file.
Earlier it was mentioned that instructions beyond a mispredicted branch's delay slot may be executed before the misprediction is apparent. This occurrence is sorted out by ROB 240. When a misprediction is detected, any undispatched instructions are cleared and fetcher 257 is redirected. None of the functional units are notified of the misprediction (the branch unit 520 does however set "cancel" bits in any valid entries in its own reservation station 550 so that those branches execute harmlessly and return to ROB 240 without causing mispredictions.)
When such a misprediction occurs, the corresponding entry in the ROB is allocated as being mispredicted. When the subsequent entries are forwarded from the functional unit, they are marked as completed but mispredicted. The retire logic 242 in reorder buffer 240 ignores these entries and de-allocates them.
At the same time, the branch result status, which indicates taken/not-taken and correct/incorrect prediction, is returned to ROB 240. A mispredict result causes the ROB to immediately set a Cancel bit in all entries from the second one after the branch entry (to account for the delay slot) to the tail pointer. In the second cycle following this occurrence, decode will begin dispatching the target instructions, which are assigned tags as usual starting from the tail pointer. When the cancelled entries are encountered by ROB retire logic 242, they are discarded. Load/store unit 530 is notified of any cancellations for which it is waiting on a go-ahead from the ROB via an LSCANCEL signal which is transmitted on an LSCANCEL line between ROB 240 and load/store section LSSEC 530. The LSCANCEL signal indicates any pending store or load miss in access buffer 605 which is to be cancelled. Access buffer 605 behaves as a FIFO and the next oldest store is the instruction which is cancelled. More detail with respect to one load/store section and access buffer which may be employed as load/store section LSSEC 530 and access buffer (store buffer) 605 is found in the copending patent application entitled "High Performance Load/Store Functional Unit And Data Cache" (Ser. No. 08,146,376), the disclosure of which is incorporated herein by reference.
When an exception occurs in the execution of a particular instruction, no global action is required. Rather, the exception status is merely reflected in the result status returned to ROB 240. The appropriate trap vector number is generally returned in place of the normal result operand (except in cases where the RF update is not inhibited, in which case the ROB generates the vector number). The trap vector number is the number that indicates which of the may kinds of traps has occurred and where to go upon the occurrence of a particular trap. Typical examples which result in the occurrence of a trap are a divide by zero, arithmetic overflow and a missing TLB page. When ROB 240 encounters the exception status in the process of retiring instructions, it initiates a trap operation which consists of clearing all entries from ROB 240, asserting an EXCEPTION signal to all functional units to clear them (and IDECODE), generating a trap vector per the Vf bit and redirecting the fetcher 257 to trap handling code. The Vf bit indicates whether a trap should be taken as an external fetch (as a load from a table of vectors) or internally generated by concatenating a constant with the vector number. The Vf bit is a feature of the architecture of the Advanced Micro Devices Am29000 microprocessor series.
It is noted that the data stored in register file 235 represents the current execution state of the microprocessor. However, the data stored in ROB 240 represents the predicted execution state of the microprocessor. When an instruction is to be retired, the corresponding result stored in ROB 240 is transmitted to register file 235 and is then retired.
III (E). Instruction Flow Timing
To illustrate the operation of superscalar microprocessor 500 in terms of instruction flow timing, Table 2 is provided below. Table 2 depicts the pipeline stages of microprocessor 500 together with significant events which occur during each of those stages. The stages of the pipeline are listed below in the first column of Table 2.
              TABLE 2                                                     
______________________________________                                    
1) Fetch                                                                  
        PH1    Instruction fetch address is formed (Fetch PC              
               (FPC)).                                                    
        PH2    ICACHE is accessed.                                        
2) Decode                                                                 
        PH1    Instruction block is driven to decode on XInB;             
               Register File ports are assigned and Stack Pointer         
               addition is performed.                                     
        PH2    Intructions are classified and dispatching is set up;      
               Opcodes, types and operand tags are broadcast to           
               units; Register File is accessed; RA/RB fields             
               checked against ROB contents.                              
3) Execute                                                                
        PH1    A/B operand buses are driven by RF/ROB, or                 
               operands may by picked off a result bus, dispatch          
               bits (XINDISP) are asserted; instruction issues            
               or is placed in reservation station; result bus            
               requested.                                                 
        PH2    Instruction executes; functional unit signals its          
               reservation station's full/empty status to dispatch;       
               [branch misprediction determined (late PH2)].              
4) Result                                                                 
        PH1    Result buses granted to functional units, result           
    Forward    driven on result bus to ROB (and is available for          
               result bus forwarding to any unit); [Fetch PC (FPC)        
               updated with correct target PC.]                           
        PH2    ROB examines entry for retiring; [cache access             
               for branch target].                                        
5) Write-                                                                 
        PH1    Result is driven to Register File and written back;        
    back       PC1 updated [branch target block driven to decode].        
        PH2    [branch target block at decode]                            
______________________________________                                    
Table 2 shows what happens in each phase (PH1 and PH2 of each microprocessor cycle) as a basic integer instruction flows through microprocessor 500 with no stalls, as well as branch correction timing (in brackets).
III (F). Memory Management Unit, Data Cache and Bus Interface Unit
Memory Management Unit (MMU) 247 is essentially the same as in the AM29050 microprocessor manufactured by Advanced Micro Devices, Inc. MMU 247 translates virtual addresses to physical addresses for instruction fetch as well as for data access. A difference with respect to instruction fetch between the AM29050 and microprocessor 500 is that in the AM29050 the MMU is consulted on a reference to the branch target cache BTC whereas microprocessor 500 does not employ a branch target cache and does not consult the MMU for a BTC reference. The branch target cache is a cache of branch targets only. The branch target cache forms part of the scalar pipeline of the Am29050 microprocessor manufactured by Advanced Micro Devices. The BTC fetches instructions once per clock cycle.
To further reduce the demand on MMU 247 for instruction fetch address translations, ICACHE 205 contains a one-entry translation lookaside buffer (TLB) 615 to which ICACHE refers on cache misses. The TLB is refilled when a translation is required that does not hit in the one entry TLB. Thus, TLB 615 is refilled as needed from the MMU. Since MMU 247 is not closely coupled to ICACHE 205, this reduces refill time and also desirably reduces the load on the MMU.
Data cache 245 is organized as a physically-addressed, 2 way set associative 8K cache. In this embodiment, for page sizes less than 4K, the address translation is done first. This requirement is true for 1K and 2K page sizes, and increases the latency of loads that hit to two cycles. However, 4K page sizes, which have one bit of uncertainty in the cache index, are handled by splitting the cache into two 4K arrays which allows access to both possible blocks. A 4-way compare is done between the two cache tags and the two physical addresses from the MMU to select the right one.
Data cache 245 implements a mixed copyback/writethrough policy. More particularly, write misses are done as writethrough, with no allocation; write hits occur only on blocks previously allocated by a load, and may cause a writethrough, depending on cache coherency. Microprocessor 500 supports data cache coherency for multi-processor systems and efficient I/O of cacheable memory using the known MOESI--Modified Owned Exclusive Shared Invalid (Futurebus) protocol. The MOESI protocol indicates 1 of 5 states of a particular cache block. Whereas microprocessor 500 of FIG. 3 employs the MOESI protocol, the later discussed microprocessor of FIG. 6 employs the similar MESI protocol.
Bus interface unit (BIU) 260 employs the same external interface as the AMD29030 microprocessor manufactured by Advanced Micro Devices, Inc. In addition, BIU 260 employs a single internal 32 bit bus for addresses, instructions, and data, namely internal address data (IAD) bus 250.
In this particular embodiment, main memory 255, alternatively referred to as external memory, is a single flat space with only a distinction between I/O and data/instruction. In the particular embodiment shown, memory 255 includes no read only memory (ROM) and exhibits no distinction between instructions and data. Other types of external memory arrangements may alternatively be employed as main memory 255.
As seen in FIG. 3, BIU 260, ICACHE 205, DCACHE 245, MMU 247 and SRBSEC 512 are all tied together by the 32-bit IAD bus 250. IAD bus 250 is used mainly for communication between the BIU 260 and the caches (ICACHE 205, DCACHE 245), for external accesses on cache misses and coherency operations. IAD bus 250 handles both addresses and data. It is a static bus, with BIU 260 driving during PH1 and all other units driving during PH2. Any request for the IAD bus 250 must go through bus arbitration and granting which is provided by bus arbitration block 700 shown in FIG. 5. To conserve space, bus arbitration block 700 is not shown in the block diagram of microprocessor 500 of FIG. 3.
Arbitration for the IAD bus includes bus watching (for cache coherency) which gets first priority in the arbitration activities. A request for the IAD bus is made during early PH1 and is responded to in very late PH1. If a functional unit is granted the IAD bus in PH1, it may drive an address onto the IAD bus during the following PH2 and request some action by the BIU (for example, instruction fetch, load)
IAD bus 250 is a relatively low frequency address, data and control bus that links all the major arrays in microprocessor 500 to each other and the external bus. IAD bus 250 provides relatively low frequency transfers of operations such as bus watching, cache refill, MMU translations and special register updates to mapped arrays. In one embodiment of the invention, IAD bus 250 includes 32 bits onto which address and data are multiplexed. IAD 250 bus 250 also includes 12 control lines, namely a read control line and a write control line for each of the blocks coupled thereto, namely for ICACHE, DCACHE, the TLB, the SRBSEC, the LSSEC and the BIU.
The IAD arbitration block 700 shown in FIG. 5 employs a request/grant protocol to determine which component (ICACHE 205, BIU 260, BRNSEC 520, DCACHE 245, SRBSEC 512 or MMU 247) is granted access to IAD bus 250 at any particular time. The external memory 255 via BIU 260 is granted the highest priority for bus watching purposes. Bus watching is part of data consistency protocol for microprocessor 500. Since microprocessor 500 can include modified data which can be held locally in the data cache, such data is updated when writes to memory occur. Microprocessor 500 also provides the modified data if a read occurs to a modified block which is locally held in the data cache. A copy back scheme with bus watching is employed in the caching operation of microprocessor 500.
As seen in FIG. 5, a respective request line is coupled between IAD arbitration block 700 and each of ICACHE 205, BIU 260, BRNSEC 520, DCACHE 245, SRBSEC 512 or MMU 247. Each of these request lines is coupled to control logic 705, the output of which is coupled to driver 710. IAD arbitration block 700 includes a respective grant line for each of ICACHE 205, BIU 260, BRNSEC 520, DCACHE 245, SRBSEC 512 or MMU 247. When a particular component desires access to IAD bus 250, that component transmits a request signal to IAD arbitration block 700 and to control 705. For example, assume that BIU 260 desires to gain access to IAD bus 250 to perform a memory access. In that case, BIU 260 transmits an IAD bus access request to IAD arbitration block 700 and control 705. IAD arbitration block 700 determines the priority of requests when multiple requests for access to IAD bus 250 are present at the same time. Arbitration block 700 then issues a grant on the grant line of the particular device which it has decided should be granted access to the IAD bus according the priority scheme. In the present example, a grant signal is issued on the BIU grant line and BIU 260 then proceeds to access IAD bus 250.
The output of control circuit 705 is coupled to IAD bus 250. Each of the following components ICACHE 205, BIU 260, BRNSEC 520, SRBSEC 512, DCACHE 245 and MMU 247 are equipped with a driver circuit 710 to enable such components to drive IAD bus 250. Each of these components is further equipped with a latch 715 to enable these components to latch values from IAD bus 250. Control circuit 705 provides the request grant protocol for the IAD bus. A functional unit locally realizes that access to the IAD bus is desired and sends a request to arbitration block 700. Arbitration block 700 takes the highest priority request and grants access accordingly. Latch 715 signifies the read of the requested data if a transfer is occurring to this block. Driver 710 signifies the driving of the locally available value, to drive some other position where another block will read it. Going through this bus arbitration to gain access to IAD bus 250 adds some latency, but has been found to nevertheless provide acceptable performance. Providing microprocessor 500 with IAD bus 250 is significantly more cost effective than providing dedicated paths among all the sections listed above which are connected to the IAD bus.
FIG. 5A is a timing diagram illustrating the status of selected signals in microprocessor 500 throughout the multiple stages of the pipeline thereof. FIG. 5A shows such pipeline for sequential processing. In contrast, the timing diagram of FIG. 5B shows a similar timing diagram for microprocessor 500 except that the timing diagram of FIG. 5B is directed to the case where a branch misprediction and recovery occurs.
More specifically, FIG. 5A and 5B depict the operation of microprocessor 500 throughout the five effective pipeline stages of fetch, decode, execute, result/ROB (result forward--result forwarded to the ROB), retire/register file (writeback--operand retired from the ROB to the register file). The five stages of the microprocessor pipeline are listed horizontally at the top of these timing diagrams. The signals which compose these timing diagrams are listed vertically at the left of the diagrams and are listed as follows: The Ph1 signal is the clocking signal for microprocessor 500. FPC(31:0) is the fetch PC bus (FPC). IRO-3 (31:0) represent the instruction buses. The timing diagrams also shows the source A/B pointers which indicate which particular operands that a particular decode instruction needs in the ROB. The timing diagram also includes REGF/ROB access which indicates register file/ROB access. The Issue instr/dest tags signal indicates the issuance of instructions/destination tags. The A/B read operand buses signal indicates the transfer of A and B operands on the A and B operand buses. The Funct unit exec. signal indicates execution of an issued instruction at a functional unit. The Result bus arb signal indicates arbitration for the result bus. The Result bus forward signal indicates the forwarding of results on the result bus once such results are generated by the functional unit. The ROB write result signal indicates that the result is written to the ROB. The ROB tag forward signal indicates the forwarding of an operand tag from the ROB to a functional unit. The REGF write/retire signal indicates the retirement of a result from the ROB to the register file. The PC(31:0) signal indicates the program counter (PC) which is updated whenever an instruction is retired as no longer being speculative.
In the timing diagrams of FIG. 5A, the pipeline is illustrated for executing a sequential instruction stream. In this example, the predicted execution path is actually taken as well as being available directly from the cache. Briefly, in the fetch pipeline stage, instructions are fetched from the cache for processing by the microprocessor. An instruction is decoded in the decode pipeline stage and executed in the execute pipeline stage. It is noted that the source operand buses and result buses are 32 bits in width which corresponds to the integer size. Two cycles are required of an instruction buses operand buses to drive a 64-bit value for a double precision floating point operation.
In the Result pipeline stage, operand values are forwarded directly from the functional unit which generated the result to other functional units for execution. In clock phase PH1 of the result stage, the location of the speculative instruction is written with the destination result as well as any status. In other words, the result generated by a functional unit is placed in an entry in the reorder buffer and this entry is given an indication of being valid as well as being allocated. In this manner, the reorder buffer can now directly forward operand data for a requested operand rather than forwarding an operand tag. In clock phase PH2 of the result pipeline stage, the newly allocated tag can be detected by subsequent instructions that require the tag to be one of their source operands. This is illustrated in the timing diagram of FIG. 5A by the direct forwarding of result "c" via ROB tag forwarding onto the source A/B operand buses as indicated by the arrow in FIG. 5A. It is noted that in FIG. 5A, "a" and "b" are operands which yield a result "c" and that "c" and "d" are operands which yield a result "e".
The retire pipeline stage, which is the last stage of the pipeline, is where the real Program Counter (PC) or retire PC is kept. In the PH1 clock phase of the retire pipeline stage, the result of the operation is written from the reorder buffer to the register file and the retire PC is updated to reflect this writeback. In other words the retire PC is updated to include the instruction which was just retired to the register file as being no longer speculative. The entry for this instruction or result in the reorder buffer is de-allocated. Since the entry is deallocated, subsequent references to the register "c" will result in a read from the register file instead of a speculative read from the reorder buffer.
FIG. 5B shows the same 5 pipeline stages as the timing diagram of FIG. 5A. However, the timing diagram of FIG. 5B shows the operation of microprocessor 500 when a branch misprediction occurs. XFPC designates an inversion of the FPC bus signal.
IV, An Alternative Embodiment of the Superscalar Microprocessor
Whereas the superscalar microprocessor embodiment described above is most advantageously used to process RISC programs wherein all instruction opcodes are the same size, the embodiment of the microprocessor now described as microprocessor 800 is capable of processing instructions wherein the opcodes are variable in size. For example, microprocessor 800 is capable of processing so-called X86 instructions which are employed by the familiar Intel™ instruction set which uses variable length opcodes. Microprocessor 800 employs a RISC core which is similar to the RISC core of microprocessor 500 above. The term "RISC core" refers to the central kernel of microprocessor 500 which is an inherently RISC (Reduced Instruction Set Computer) architecture including the functional units, reorder buffer, register file and instruction decoder of microprocessor 500.
The architecture of microprocessor 800 is capable of taking so-called CISC (Complete Instruction Set Computer) instructions such as those found in the Intel™ X86 instruction set and converting these instructions to RISC-like instructions (ROP's) which are then processed by the RISC core. This conversion process takes place in decoder 805 of microprocessor 800 as illustrated in FIGS. 6, 6A, and 6B. Decoder 805 decodes CISC instructions, converts the CISC instructions to ROP's, and then dispatches the ROP's to functional units for execution. More detail with respect to the structure and operation of decoder 805 is found in the co-pending patent application entitled "Superscalar Instruction Decoder" (Ser. No. 08/146,383) filed concurrently herewith and assigned to the instant assignee, the disclosure of which is incorporated herein by reference.
The ability of microprocessor 800 to supply the RISC core thereof with a large number of instructions per clock cycle is one source of the significant performance enhancement provided by this superscalar microprocessor. Instruction cache (ICACHE) 810 is the component of microprocessor 800 which provides this instruction supply as a queue of bytes or byte queue (byte Q) 815. In this particular embodiment of the invention, instruction cache 810 is a 16K byte effective four-way set associative, linearly addressed instruction cache.
As seen in FIG. 6, the byte Q 815 of instruction cache 810 is supplied to instruction decoder 805. Instruction decoder 805 maps each instruction provided thereto into one or more ROP's. The ROP dispatch window 820 of decoder 805 includes four dispatch positions into which an instruction from ICACHE 810 can be mapped. The four dispatch positions are designated as D0, D1, D2, and D3. In a first example, it is assumed that the instruction provided by byte Q 815 to decoder 805 is an instruction which can be mapped to two ROP dispatch positions. In this event, when this first instruction is provided to decoder 805, decoder 805 maps the instruction into a first ROP which is provided to dispatch position D0 and a second ROP which is provided to dispatch position D1. It is then assumed that a subsequent second instruction is mappable to three ROP positions. When this second instruction is provided by byte Q 815 to decoder 805, the instruction is mapped into a third ROP which is provided to dispatch position D2 and a fourth ROP which is provided to dispatch position D3. The ROP's present at dispatch positions D0 through D3 are then dispatched to the functional units. It is noted that the remaining third ROP onto which the second instruction is mapped must wait for the next dispatch window to be processed before such ROP can be dispatched.
Information with respect to which particular bytes that instruction cache 810 is to drive out into byte Q 815 is contained in branch prediction block 825 which is an input to instruction cache 810. Branch prediction block 825 is the next block array indicating on a block by block basis the next predicted branch location. Branch functional unit 835 executes branches in a manner similar to that of BRNSEC 520 of microprocessor 500 of FIG. 3. Instruction cache 810 is also equipped with a prefetcher block 830 which fetches requested instruction cache misses from external memory.
Microprocessor 800 includes four integer functional units to which the four ROP positions of decoder 805 can be issued, namely, branch functional unit 835, ALU0/shifter functional unit 840, ALU1 functional unit 845, and special register functional unit 850. Branch functional unit 835 has a one cycle latency such that one new ROP can be accepted by branch functional unit 835 per clock cycle. Branch unit 835 includes a two entry reservation station 835R. For purposes of this document, a reservation station including two entries is considered to be synonymous with two reservation stations. Branch function unit 835 handles all X86 branch, call, and return instructions. It also handles conditional branch routines.
ALU0/shifter functional unit 840 exhibits a one cycle latency. One new ROP can be accepted into unit 840 per clock cycle. ALU0/shifter functional unit 840 includes a two entry reservation station 840R which holds up to two speculative ROP's. All X86 arithmetic and logic calculations go through this functional unit or alternatively the other arithmetic logic unit ALU1, 845. Moreover, shift. rotate or find first one instructions are provided to ALU0/shifter function unit 840.
The ALU1 functional unit 845 exhibits a one cycle latency as well. It is noted that one new ROP can be accepted by ALU1 functional unit 845 per clock cycle. The ALU1 functional unit includes a two entry reservation station 845R which holds up to two speculative ROP's. All X86 arithmetic and logic calculations go through this function unit or the other arithmetic logic unit, ALU0. ALU0 and ALU1 allow up to two integer result operations to be calculated per clock cycle.
The special register functional unit 850 is a special block for handling internal control, status, and mapped state that is outside the X86 register file 855. In one embodiment of the invention, special register functional unit 850 has no reservation station because no speculative state is pending when an ROP is issued to special register functional unit 850. Special register block 850 is similar in structure and function to the special register block 512 described earlier in this document.
A load/store functional unit 860 and a floating point functional unit 865 are coupled to ROP dispatch window 820 of decoder 805. Load/store functional unit 860 includes a multiple entry reservation station 860R. Floating point functional unit 865 includes two reservation stations 865R. A data cache 870 is coupled to load/store functional unit 860 to provide data storage and retrieval therefor. Floating point functional unit 865 is linked to a 41 bit mixed integer/floating point operand bus 875 and result buses 880. In more detail, operand buses 875 include eight read operand buses exhibiting a 41 bit width. Result buses 880 include 5 result buses exhibiting a 41 bit width. The linkage of floating point unit 865 to the mixed integer/floating point operand and result buses allows one register file 855 and one reorder buffer 885 to be used for both speculative integer and floating point ROP's. Two ROP's form an 80 bit extended precision operation that is input from floating point reservation station 865R into an 80 bit floating point core within floating point function 865.
The 80 bit floating point core of floating point functional unit 865 includes a floating point adder, a floating point multiplier and a floating point divide/square root functional units. The floating point adder functional unit within floating point unit 865 exhibits a two cycle latency. The floating point adder calculates an 80 bit extended result which is then forwarded. The floating point multiplier exhibits a six cycle latency for extended precision multiply operations. A 32×32 multiplier is employed for single precision multiplication operations. The 32×32 multiplier within floating point functional unit 865 is multi-cycled for 64 bit mantissa operations which require extended precision. The floating point divide/square root functional unit employs a radix-4 interactive divide to calculate 2 bits/clock of the 64 bit mantissa.
It is noted that in the present embodiment wherein the bus width of the A/B operand buses is 41 bits, that with respect to those A/B operand buses running to the integer units, 32 bits is dedicated to operands and the remaining 9 bits is control information. It should also be noted that other embodiments of the invention are contemplated wherein the bus width of the A/B operand buses is not 41 bits, but rather is 32 bits or other size. In such a 32 bit operand bus width arrangement, control lines separate from the operand bus are employed for transmission of control information.
Load store functional unit 860 includes a four entry reservation station 860R. Load store functional unit 860 permits two load or store operations to be issued per clock cycle. The load store section also calculates the linear address and checks access rights to a requested segment of memory. The latency of a load or store operation relative to checking a hit/miss in data cache 870 is one cycle. Up to two load operations can simultaneously access data cache 870 and forward their operation to result buses 880. Load store section 860 handles both integer and floating point load and store operations.
As seen in FIG. 6A, microprocessor 800 includes a register file 855 which is coupled to a reorder buffer 885. Both register file 855 and reorder buffer 885 are coupled via operand steering circuit 890 to operand buses 875. Register file 855, reorder buffer 885 and operand steering circuit 890 cooperate to provide operands to the functional units. As results are obtained from the functional units, these results are transmitted to reorder buffer 885 and stored as entries therein.
In more detail, register file 855 and reorder buffer 885 provide storage for operands during program execution. Register file 855 contains the mapped X86 registers for both the integer and floating point instructions. The register file contains temporary integer and floating point registers as well for holding intermediate calculations. In this particular embodiment of the invention, all of the registers in register file 855 are implemented as eight read and four write latches. The four write ports thus provided allow up to two register file destinations to be written per clock. This can be either one integer value per port or one-half a floating point value per port if a floating point result is being written to the register file. The eight read ports allow four ROPS with two source read operations each to be issued per clock cycle.
Reorder buffer 885 is organized as a 16 entry circular FIFO which holds a queue of up to 16 speculative ROP's. Reorder buffer 885 is thus capable of allocating 16 entries, each of which can contain an integer result or one-half of a floating point result. Reorder buffer 885 can allocate four ROP's per clock cycle and can validate up to five ROP's per clock cycle and retire up to four ROP's into register file 855 per clock cycle. The current speculative state of microprocessor 800 is held in reorder buffer 885 for subsequent forwarding as necessary. Reorder buffer 885 also maintains a state with each entry that indicates the relative order of each ROP. Reorder buffer 885 also marks mispredictions and exceptions for handling by an interrupt or trap routine.
Reorder buffer 885 can drive the eight operand buses 875 with eight operands, respectively. Reorder buffer 885 can receive up to five results per clock cycle on the five result buses 880. It is noted that the operand buses are eight 41 bit shared integer/floating point buses. The eight operand buses correspond to the four ROP dispatch positions in ROP dispatch window 820 of decoder 805. Each of the four ROP dispatch positions can have a source A read operand and a source B read operand. Each of the four A and B read operand bus pairs thus formed are dedicated to a fixed ROP and source read location in ROP dispatch window 820.
Register file 855 and reorder buffer 885 are the devices in microprocessor 800 which drive read operand buses 875. If no speculative destination exists for a decoded ROP, that is if an operand requested by the ROP does not exist in the reorder buffer, then the register file supplies the operand. However, if a speculative destination does exist, that is if an operand requested by the decoded ROP does exist in the reorder buffer, then the newest entry in the reorder buffer for that operand is forwarded to a functional unit instead of the corresponding register. This reorder buffer result value can be a speculative result if it is present in the reorder buffer or a reorder buffer tag for a speculative destination that is still being completed in a functional unit.
The five result buses 880 are 41 bit buses. It is also noted that the read operand and result buses are inputs and outputs to all of the integer functional units. These same read operand and result buses are also inputs and outputs to the floating point reservation station 865R of the floating point functional unit 865. The floating point reservation station 865R converts the 41 bit operand and result buses to 80 bit extended precision buses that it routes to its constituent dedicated functional units as necessary.
The integer and floating point functional units of microprocessor 800 are provided with local buffering of ROP's via the reservation stations of those units. In most of these functional units, this local buffering takes the form of two entry reservation stations organized as FIFO's. The purpose of such reservation stations is to allow the dispatch logic of decoder 805 to send speculative ROP's to the functional units regardless of whether the source operands of such speculative ROP's are currently available. Thus, in this embodiment of the invention a large number of speculative ROP's can be issued (up to 16) without waiting for a long calculation or a load to complete. In this manner, much more of the instruction level parallelism is exposed and microprocessor 800 is permitted to operate closer to its peak performance.
Each entry of a reservation station can hold two source operands or tags plus information with respect to the destination and opcode associated with each of the entries. The reservation stations can also forward source operand results which the reorder buffer has marked as being pending (those operands for which the reorder buffer has marked by instead providing an operand tag rather than the operand itself) directly to other functional units which are waiting for such results. In this particular embodiment of the invention, reservation stations at the functional units typically accept one new entry per clock cycle and can forward one new entry per clock cycle to the functional unit.
An exception to this is the load/store section 860 which can accept and retire two entries per clock cycle from its reservation station. Load/store section 860 also has a deeper reservation station FIFO of four entries.
All reservation station entries can be deallocated within a clock cycle should an exception occur. If a branch misprediction occurs, intermediate results are flushed out of the functional units and are deallocated from the reorder buffer.
Microprocessor 800 includes an internal address data bus 895 which is coupled to instruction cache 810 via prefetch unit 830 and to bus interface unit 900. Bus interface unit 900 is coupled to a main memory or external memory (not shown) so that microprocessor 800 is provided with external memory access. IAD bus 895 is also coupled to load/store functional unit 860 as shown in FIG. 6.
A data cache 870 is coupled to load/store unit 860. In one particular embodiment of the invention, data cache 870 is an 8k byte, linearly addressed, two way set associative, dual access cache. Address and data lines couple data cache 870 to load/store functional unit 860 as shown. More specifically, data cache 870 includes two sets of address and data paths between cache 870 and load/store unit 860 to enable two concurrent accesses from load/store functional unit 860. These two accesses can be between 8 and 32 bit load or store accesses aligned to the 16 byte data cache line size. Data cache 870 is organized into 16 byte lines or blocks. In this particular embodiment, data cache 870 is linearly addressed or accessed from the segment based address, but not a page table based physical address. Data cache 870 includes four banks which are organized such that one line in the data cache has 4 bytes in each of the 4 banks. Thus, as long as the linear address of bits [3:2] of the two accesses are not identical, the two accesses can access the data array in cache 870 concurrently.
Data cache 870 is two-way associative. It takes the two linear addresses in phase PH1 of the clock and accesses its four banks. The resultant load operations complete in the following clock phase PH2, and can then drive one of the result buses. Requests by functional units for the result busses are arbitrated with requests from the other functional units that desire to write back a result.
Instruction cache 810 and data cache 870 include a respective instruction cache linear tag array and a data cache linear tag array corresponding to the addresses of those instructions and data entries which are stored in these cache's. As seen in FIG. 6B, microprocessor 800 also includes a physical tags I/D block 910 which is coupled to IAD bus 895 for the purpose of tracking the physical addresses of instructions and data in instruction cache 810 and data cache 870, respectively. More specifically, physical tags I/D block 910 includes physical instruction/data tag arrays which maintain the physical addresses of these caches. The physical instruction tag array of block 910 mirrors the organization for the corresponding linear instruction tag array of the instruction cache 810. Similarly, the organization of the physical data tag array within block 910 mirrors the organization of the corresponding linear data tag array within instruction cache 810.
The physical I/D tags have valid, shared, and modified bits, depending on whether they are instruction cache or data cache tags. If a data cache physical tag has a modified bit set, this indicates that the data element requested is at the equivalent location in the linear data cache. Microprocessor 800 will then start a back-off cycle to external memory and write the requested modified block back to memory where the requesting device can subsequently see it.
A translation lookaside buffer (TLB 915) is coupled between IAD bus 895 and physical tags I/D block 910 as shown. TLB 915 stores 128 linear to physical page translation addresses and page rights for up to 128 4K byte pages. This translation lookaside buffer array is organized as a four-way set associative structure with random replacement. TLB 915 handles the linear to physical address translation mechanism defined for the X86 architecture. This mechanism uses a cache of the most recent linear to physical address translations to prevent searching external page tables for a valid translation.
Bus interface unit 900 interfaces IAD bus 895 to external apparatus such as memory. IAD bus 895 is a global 64 bit shared address/data/control bus that is used to connect the different components of microprocessor 800. IAD bus 895 is employed for cache block refills, writing out modified blocks, as well as passing data and control information to such functional blocks as the special register unit 850, load/store functional unit 860, data cache 870, instruction cache 810, physical I/D tags block 910 and translation lookaside buffer 915 as well as bus interface unit 900.
V. Operational Overview of the Alternative Embodiment
When a CISC program is executed, the instructions and data of the CISC program are loaded into main memory from whatever storage media was employed to store those instructions and data. Once the program is loaded into the main memory which is coupled to bus interface unit 900, the instructions are fetched in program order into decoder 805 for dispatch and processing by the functional units. More particularly, four instructions are decoded at a time by decoder 805. Instructions flow from main memory to bus interface unit 900, across IAD bus 895, through prefetch unit 830, to instruction cache 810 and then to decoder 805. Instruction cache 810 serves as a depository of instructions which are to be decoded by decoder 805 and then dispatched for execution. Instruction cache 810 operates in conjunction with branch prediction unit 835 to provide decoder 805 with a four instruction-wide block of instructions which is the next predicted block of instructions to be speculatively executed.
More particularly, instruction cache 810 includes a store array designated ICSTORE which contains blocks of instructions fetched from main memory via bus interface unit 900. ICACHE 810 is a 16K byte effective linearly addressed instruction cache which is organized into 16 byte lines or blocks. Each cache line or block includes 16×86 bytes. Each line or block also includes a 5 bit predecode state for each byte. ICACHE 810 is responsible for fetching the next predicted X86 instruction bytes into instruction decoder 805.
ICACHE 810 maintains a speculative program counter designated FETCHPC (FPC). This speculative program counter FETCHPC is used to access the following three separate random access memory (RAM) arrays that maintain the cache information. In more detail, the three aforementioned RAM arrays which contain the cache information include 1) ICTAGV, an array which maintains the linear tags and the byte valid bits for the corresponding block in the store array ICSTORE. Each entry in the cache includes 16 byte valid bits and a 20 bit linear tag. In this particular embodiment, 256 tags are employed. 2) The array ICNXTBLK maintains branch prediction information for the corresponding block in the store array ICSTORE. The ICNXTBLK array is organized into four sets of 256 entries, each corresponding to a 16K byte effective X86 instruction. Each entry in this next block array is composed of a sequential bit, a last predicted byte, and a successor index. 3) The ICSTORE array contains the X86 instruction bytes plus 5 bits of predecode state. The predecode state is associated with every byte and indicates the number of ROP's to which a particular byte will be mapped. This predecode information speeds up the decoding of instructions once they are provided to decoder 805. The byte queue or ICBYTEQ 815 provides the current speculative state of an instruction prefetch stream provided to ICACHE 810 by prefetch unit 830. More information with respect an instruction cache which may be employed as ICACHE 810 is provided in the copending patent application entitled "Speculative Instruction Queue And Method Therefor Particularly Suitable For Variable Byte-Length Instructions" (Ser. No. 08/311,286) filed concurrently herewith and assigned to the instant assignee, the disclosure of which is incorporated herein by reference.
Decoder 805 (IDECODE) performs instruction decode and dispatch operations in microprocessor 800. More particularly, decoder 805 performs the two stages of the microprocessor pipeline referred to as Decode 1 and Decode 2. During the beginning of Decode 1, the bytes that are prefetched and predicted executed are driven to the byte queue at a designated fill position. These bytes are then merged with independent bytes in the byte queue 815. In the decode to a pipeline stage, reorder buffer entries are allocated for corresponding ROP's that may issue in the next clock phase.
Decoder 805 takes raw X86 instruction bytes and predecode information from byte queue 815 and allocates them to four ROP positions in ROP dispatch unit 820. Decoder 805 determines which particular functional unit each ROP should be transmitted to. A more detailed discussion of one decoder which may be employed as decoder 805 is found in the U.S. Patent Application entitled "Superscalar Instruction Decoder" by David B. Witt and Michael D. Goddard (Ser. No. 08/146,383), the disclosure of which is incorporated herein by reference. The ICACHE and decoder circuitry permits microprocessor 800 to decode and drive four ROP's per clock cycle into a RISC-like data path. The four ROP's are dispatched to the functional units which send results back to reorder buffer 385 and to other functional units which require these results.
Register file 855 and reorder buffer 885 work together to provide speculative execution to instructions in the program stream. A more detailed discussion of register file 855, reorder buffer 885 and the integer core of microprocessor 800 is now provided with reference to FIG. 7. The integer core of microprocessor 800 is designated as integer core 920 and includes the branch functional unit 835, ALU0, ALU1, and special register 860.
In this particular embodiment, register file 855 is organized as 12 32 bit registers (integer registers) and 24 41 bit registers (floating point registers). These registers are accessed for up to four ROP's in parallel from decoder 805. Register file pointers provided by decoder 805 determine which particular register or registers are requested as operand values in a particular ROP as well as the size of the access.
It is noted that register file 855 contains the architectural state of microprocessor 800 whereas reorder buffer 885 contains the speculative state of microprocessor 800. The timing of register file 855 is such that it is accessed in phase PH2 of the decode 2 pipeline stage with up to 8 parallel read pointers. In response to reception of these up to 8 read pointers, register file 855 then drives the operand values thus selected onto the corresponding operand buses in the following PH1 phase of the clock.
A disable bus is shown in FIG. 7 coupling reorder buffer 885 to register file 855. The disable bus is 8 lines wide and includes 8 override signals which indicate to register file 855 that the requested read value has been found as a speculative entry in reorder buffer 885. In this instance, register file 855 is subject to an override and is not permitted to place a requested read operand value on an operand bus. Rather, since a speculative entry is present in reorder buffer 885, reorder buffer 885 will then provide either the actual operand value requested or an operand tag for that value.
Reorder buffer 885 includes 16 entries in this particular embodiment and operates as a queue of speculative ROP result values. As seen in more detail in FIG. 8, reorder buffer 885 includes two pointers which correspond to the head and the tail of the queue, namely the head pointer and the tail pointer. Shifting an allocation of the queue to dispatched ROP's occurs by incrementing or decrementing these pointers.
The inputs provided to reorder buffer 885 include the number of ROP's that decoder 805 wants to attempt to allocate therein (up to 4 ROP's per block), source operand pointer values for these four ROP's, and the respective destination pointer values. Reorder buffer 885 then attempts to allocate these entries from its current speculative queue. Provided entry space is available for dispatched ROP's, entries are allocated after the tail pointer.
More particularly, when entries are requested from decoder 805, the next entries from the head of the queue are allocated. The number of a particular entry then becomes the destination tag for that particular ROP from decoder 805. The destination tag is driven at the corresponding ROP position to the functional unit along with the particular instruction to be executed. A dedicated destination tag bus designated "4 ROP destination tags" is shown in FIG. 7 as an output from reorder buffer 885 to the functional units of integer core 920 and the remaining functional units of microprocessor 800. The functional units are thus provided with destination information for each ROP to be executed such that the functional unit effectively knows where the result of an ROP is to be transmitted via the result buses.
From the above, it is seen that speculatively executed result values or operands are temporarily stored in reorder buffer 885 until such result operands are no longer speculative. A pool of potential operand values is thus provided by reorder buffer 885 for use by subsequent ROP's which are provided to and decoded by decoder 805.
When entries exist in reorder buffer 885, the original register number (i.e. EAX) is held in the reorder buffer entry that was allocated for a particular ROP result. FIG. 8 shows the entries that are in a speculative state between the tail and head pointers by dashed vertical lines in those entries. Each reorder buffer entry is referenced back to its original destination register number. When any of the 8 read pointer values from the 4 ROP positions of ROP dispatch unit 820 match the original register number associated with an entry, the result data of that entry is forwarded if valid or the tag is forwarded if the operation associated with that entry is still pending in a functional unit.
Reorder buffer 885 maintains the correct speculative state of new ROP's dispatched by decoder 805 by allocating these ROP's in program order. The 4 ROP's then scan from their present position down to the tail position of the reorder buffer queue looking for a match on either of their read operands. If a match occurs in a particular reorder buffer entry, then the corresponding read port in register file 855 is disabled and either the actual result operand or operand tag is presented to the operand bus for reception by the appropriate functional unit. This arrangement permits multiple updates of the same register to be present in the reorder buffer without affecting operation. Result forwarding is thus achieved.
As shown in FIG. 8, reorder buffer 885 includes retire logic 925 which controls the retirement of result operands stored in the reorder buffer queue or array 930. When a result operand stored in queue 930 is no longer speculative, such result operand is transferred under retire logic control to register file 855. To cause this to occur, the retire logic interfacing the retirement of ROP's, the writeback to the register file, and the state of the last 4 ROP entries are scanned. The retire logic 925 determines how many of the allocated ROP entries now have valid results. The retire logic also checks how many of these ROP entries have writeback results to the register file versus ROP's with no writeback. Moreover, the retire logic scans for taken branches, stores and load misses. If a complete instruction exists within the last 4 ROP's, then such ROP is retired into the register file. However, if during scanning an ROP entry, a status is found indicating an exception has occurred on a particular ROP, then all succeeding ROP's are invalidated, and a trap vector fetch request is formed with the exception status information stored in the ROP entry.
Moreover, if a branch misprediction status is encountered while scanning the ROP's in the reorder buffer, then the retire logic invalidates these ROP entries without any writeback or update of the EIP register until the first ROP is encountered that was not marked as being in the mispredicted path. It is noted that the EIP register (not shown) contained within retire logic 925 (see FIG. 8) holds the program counter or retire PC which represents the rolling demarcation point in the program under execution which divides those executed instructions which are nonspeculative from those instructions which have been executed upon speculation. The EIP or retire PC is continually updated upon retirement of result operands from reorder buffer 885 to register file 855 to reflect that such retired instructions are no longer speculative. It is noted that reorder buffer 885 readily tracks the speculative state and is capable of retiring multiple X86 instructions or ROP's per clock cycle. Microprocessor 800 can quickly invalidate and begin fetching a corrected instruction stream upon encountering an exception condition or branch misprediction.
The general organization of the functional units of microprocessor 800 is now described with reference to a generalized functional unit block diagram shown for purposes of example in FIG. 9. It should be recalled that ROP's containing an opcode, an A operand, a B operand, and a destination tag are being dispatched to the generalized functional unit of FIG. 9. In the leftmost portion of FIG. 9, it is seen that four A operand buses are provided to a (1:4) A operand multiplexer 932 which selects the particular A operand from the instructions dispatched thereto. In a similar manner, the four B operand buses are coupled to a (1:4) B operand multiplexer 935 which selects the particular B operand for the subject instruction which the functional unit of FIG. 9 is to execute. Four destination/opcode buses are coupled to a multiplexer 940 which selects the opcode and destination tag for the particular instruction being executed by this functional unit.
This functional unit monitors the type bus at the "find first FUNC type" input to multiplexer 940. More particularly, the functional unit looks for the first ROP that matches the type of the functional unit, and then enables the 1:4 multiplexers 932, 935, and 940 to drive the corresponding operands and tag information into reservation station 1 of the functional unit of FIG. 9. For example, assuming that execution unit 945 is Arithmetic Logic Unit 1 (ALU1) and that the instruction type being presented to the functional unit at the TYPE input of multiplexer 940 is an ADD instruction, then the destination tag, opcode, A operand and B operand of the dispatched instruction is driven into reservation station 1 via the selecting multiplexers 932, 935, and 940.
A second reservation station, namely reservation station 0 is seen between reservation station 1 and execution unit 945. The functional unit of FIG. 9 is thus said to include two reservation stations, or alternatively, a reservation station capable of holding two entries. This two entry reservation station is implemented as a FIFO with the oldest entry being shown as reservation 0. The reservation stations 0 and 1 can hold either operands or operand tags depending upon what was sent to the functional unit on the operand buses from either register file 855 or reorder buffer 885.
To achieve result forwarding of results from other functional units which provide their results on the five result buses, the functional unit includes A forwarding logic 950 and B forwarding logic 955. A forwarding logic 950 scans the five result buses for tags to match either the source A operand and when a match occurs, A forwarding logic 950 routes the corresponding result bus to the A data portion 960 of reservation station 1. It should be noted here that when an A operand tag is provided via multiplexer 930 instead of the actual A operand, then the A operand tag is stored at the location designated A tag 965. It is this A operand tag stored in A tag position 965 which is compared with the scanned result tags on the five result buses for a match. In a similar manner, B forward logic 955 scans the five result buses for any result tags which match the B operand tag stored in B operand tag position 970. Should a match be found, the corresponding result operand is retrieved from the result buses and stored in B data location 975. The destination tag and opcode of the ROP being executed by the functional unit are stored in tag and opcode location 980.
When all information necessary to execute an ROP instruction has been assembled in the functional unit, the ROP instruction is then issued to execution unit 945 for execution. More particularly, the A operand and the B operand are provided to execution unit 945 by the reservation station. The opcode and destination tag for that instruction are provided to execution unit 945 by the tag and opcode location 980. The execution unit executes the instruction and generates a result. The execution unit then arbitrates for access to the result bus by sending a result request signal to an arbitrator (not shown). When the execution unit 945 is granted access to the result bus, a result grant signal is received by execution unit 945 from the arbitrator. Execution unit 945 then places the result on the designated result bus.
The result is forwarded to other functional units with pending operands having the same tag as this result. The result is also provided to reorder buffer 885 for storage therein at the entry associated with the destination tag of the executed ROP.
In actual practice, the functional unit arbitrates for the result bus while the instruction is executing. More particularly, when a valid entry is present in the functional unit, namely when all operand, opcode and destination tag information necessary for execution have been assembled, the instruction is issued to execution unit 945 and the functional unit arbitrates for the result bus while execution unit 945 is actually executing the instruction. It is noted that each reservation station contains storage for the local opcode as well as the destination tag. This tag indicates the location that the ROP will eventually write back to during the result pipeline stage. This destination tag is also kept with each entry in the reservation station and pushed through the FIFO thereof.
While a generalized functional unit block diagram has been discussed with respect to FIG. 9, execution unit 945 may be any of branch functional unit 835, ALU0/Shifter 840, ALU1 845, load/store 860, floating point unit 865 and special register 850 with appropriate modification for those particular functions.
Upon a successful grant of the result bus to the particular functional unit, the result value is driven out on to the result bus and the corresponding entry in the reservation station is cleared. The result buses include a 41 bit result, a destination tag and also status indication information such as normal, valid and exception. In the pipelined operation of microprocessor 800, the timing of the functional unit activities just described occurs during the execute stage. During clock phase Ph1, the operands, destination tags and opcodes are driven as the ROP is dispatched and placed in a reservation station. During the Ph2 clock phase, the operation described by the OP code is executed if all operands are ready, and during execution the functional unit arbitrates for the result buses to drive the value back to the reorder buffer.
FIG. 10 is a more detailed representation of branch functional unit 835. Branch functional unit 835 handles all non-sequential fetches including jump instructions as well as more complicated call and return micro-routines. Branch unit 835 includes reservation station 835R, and a branch FIFO 980 for tracking predicted taken branches. Branch functional unit 835 also includes an adder 985, an incrementer 990, and a branch predict comparator 995 all for handling PC relative branches.
Branch functional unit 835 controls speculative branches by using the branch predicted taken FIFO 980 shown in FIG. 10. More specifically, every non-sequential fetch predicted by the instruction cache 810 is driven to branch predicted FIFO 980 and latched therein along with the PC (program counter) of that branch. This information is driven on to the target bus (XTARGET) and decode PC buses to the branch functional unit. When the corresponding branch is later decoded and issued, the PC of the branch, offset, and prediction information is calculated locally by branch functional unit 835. If a match occurs, the result is sent back correctly to reorder buffer 885 with the target PC and a status indicating a match. If a branch misprediction has occurred, the correct target is driven to both instruction cache 810 to begin fetching as well as reorder buffer 885 to cancel the succeeding ROPs contained in the missed predicted branch. In this manner, execution can be restarted at the correct target PC and corruption of the execution process is thus prevented. Whenever a missed prediction does occur, branch functional unit 835 sends both the new target address as well as the index to the block where the prediction information was to update this array. This means that the microprocessor begins fetching the new correct stream of instructions while simultaneously updating the prediction array information. It is noted that the microprocessor also accesses the prediction information with the new block to know which bytes are predicted executed. The ICNXTBLK array is dual ported so that the prediction information can be updated though a second port thereof. The prediction information from the block where the misprediction occurs is information such as sequential/non-sequential, branch position, and location of the first byte predicted executed within the cache array.
Adder 985 and incrementer 990 calculate locally the current PC+offset of the current branch instruction, as well as the PC+instruction length for the next PC if sequential. These values are compared by comparator 995 against the predicted taken branches in a local branch taken queue (FIFO 980) for predicting such branches.
The major internal buses of microprocessor 800 are now summarized as a prelude to discussing timing diagrams which depict the operation of microprocessor 800 throughout its pipeline stages. It is noted that a leading X on a bus line indicates a false bus that is dynamically precharged in one phase and conditionally asserted in the other phase. The microprocessor 800 internal buses include:
FPC (31:0)--Ph1, static. This fetch PC bus is used for speculative instruction prefetches from the instruction cache 810 into byte queue 815. The FPC bus is coupled to FPC block 813 within ICACHE 810 which performs substantially the same function as FPC block 207 of microprocessor 500 of FIG. 3.
XTARGET (41:0)--Ph1 dynamic. This bus communicates the target PC for redirection of mispredicted branches and exceptions to the instruction cache and branch prediction units (825/835).
XICBYTEnB (12:0) Ph1, dynamic. This bus is the output of the instruction cache store array ICSTORE of the currently requested prefetched X86 instruction plus corresponding predecode information. In this particular embodiment, a total of 16 bytes can be asserted per clock cycle aligned such that the next predicted executed byte fills the first open byte position in the byte queue.
BYTEQn (7:0) Ph1, static. This represents the queue of predicted executed X86 instruction bytes that have been prefetched from the instruction cache. In this particular embodiment, a total of 16 bytes are presented to the decode paths of decoder 805. Each byte contains predecode information from the instruction cache with respect to the location of instruction start and end positions, prefix bytes, and opcode location. The ROP size of each X86 instruction is also included in the predecode information. The predecode information added to each byte represents a total of 6 bits of storage per byte in the byte queue, namely 1 valid bit plus 5 predecode bits.
IAD (63,0)--Ph1 dynamic. IAD bus 895 is the general interconnect bus for major microprocessor 800 blocks. It is used for address, data, and control transfer between such blocks as well as to and from external memory all as illustrated in the block diagram of FIG. 6.
XRDnAB (40:0) Ph1, dynamic. This designation represents the source operand A bus for each ROP provided to the functional units and is included in operand buses 875. More specifically, it includes a total of four 41 bit buses for ROP 0 through ROP 3. A corresponding tag bus included in the operand buses indicates when a forwarded tag from reorder buffer 885 is present instead of actual operand data from reorder buffer 885.
XRDnBB (40:0)--Ph1, dynamic. This designation indicates the source operand B bus for each ROP sent to the functional units. This bus structure includes four 41 bit buses for ROP 0 through ROP 3 and is included in the eight read operand buses 875. It is again noted that a corresponding tag bus indicates when a forwarded operand tag is present on this bus instead of actual operand data from reorder buffer 885.
XRESnB (40:0)--Ph1, dynamic. This designation indicates result bus 880 for 8, 16, 32 bit integers, or 1/2 an 80 bit extended result. It is noted that corresponding tag and status buses 882 validate an entry on this result bus.
Microprocessor 800 includes a six stage pipeline including the stages of fetch, decode1, decode2, execute, result/ROB and retire/register file. For clarity, the decode stage has been divided into decode1 and decode2 in FIG. 11. FIG. 11 shows the microprocessor pipeline when sequential execution is being conducted. The successive pipeline stages are represented by vertical columns in FIG. 11. Selected signals in microprocessor 800 are presented in horizontal rows as they appear in the various stages of the pipeline.
The sequential execution pipeline diagram of FIG. 11 portrays the following selected signals:
"Ph1" which represents the leading edge of the system clocking signal. The system clocking signal includes both Ph1 and Ph2 components.
"FPC(31:0)" which denotes the fetch PC bus from byte queue 815.
"ICBYTEnB (12:0)" which is the ICBYTE bus from the ICSTORE array of instruction cache 810 which is coupled to byte queue 815.
"BYTEQn (7:0)" which is the byte queue bus.
"ROPmux (3:0)" which is a decoder signal which indicates the instruction block and predecode information being provided to the decoder.
"Source A/B pointers" which are the read/write pointers for the A and B operands provided by decoder 805 to reorder buffer 815. Although not shown explicitly in FIG. 6, the source pointers are the register file values that are inputs into both the register file and the reorder buffer from the decode block.
"REGF/ROB access" indicates access to the register file and reorder buffer for the purpose of obtaining operand values for transmission to functional units.
"Issue ROPs/dest tags" indicates the issuance of ROPs and destination tags by decoder 805 to the functional units.
"A/B read oper buses" indicates the reading of the A and B operand buses by the functional units to obtain A and B operands or tags therefore.
"Funct unit exec" indicates execution by the functional units. It is noted that in FIGS. 11 and 12, the designations a&b→c and c&d→e and c&g→ indicate arbitrary operations and are in the form "source 1 operand, source 2 operand→destination". More specifically, the designated source registers are registers, namely temporary or mapped X86 registers. In the a&b→c example, the "c" value represents the destination and shows local forwarding from both the result buses as well as the reorder buffer to subsequent references in the predicted executed stream.
"Result Bus arb" indicates the time during which a functional unit is arbitrating for access to result bus 880 for the purpose of transmission of the result to the reorder buffer and any other functional units which may need that result since that unit holds an operand tag corresponding to such result.
"Result bus forward" indicates the time during which results are forwarded from a functional unit to other functional units needing that result as a pending operand.
"ROB write result" indicates the time during which the result from a functional unit is written to the reorder buffer.
"ROB tag forward" indicates the time during which the reorder buffer forwards operand tags to functional units in place of operands for which it presently does not yet have results.
REGF write/retire" indicates the time during which a result is retired from the FIFO queue of the reorder buffer to the register file.
"EIP (31:0)" indicates the retire PC value. Since an interrupt return does not have delayed branches, the microprocessor can restart upon an interrupt return with only one PC. The retire PC value or EIP is contained in the retire logic 925 of reorder buffer 885. The EIP is similar to the retire PC already discussed with respect to microprocessor 500. Retire logic 925 performs a function similar to the retire logic 242 of microprocessor 500.
The timing diagram of FIG. 11 shows microprocessor 800 executing a sequential stream of X86 bytes. In this example, the predicted execution path is actually taken as well as being available directly from the instruction cache.
The first stage of instruction processing is the instruction fetch. As shown, this clock cycle is spent conducting instruction cache activities. Instruction cache 810 forms a new fetch PC (FPC) during Ph1 of the clock cycle and then accesses the cache arrays of the instruction cache in the second clock cycle. The fetch PC program counter (shown in the timing diagram as FPC (31:0)) accesses the linear instruction cache's tag arrays in parallel with the store arrays. Late in clock phase Ph2 of the fetch, a determination is made whether the linear tags match the fetch PC linear address. If a match occurs, the predicted executed bytes are forwarded to the byte queue 815.
In addition to accessing the tag and store arrays in instruction cache, the fetch PC also accesses the block prediction array, ICNXTBLK. This block prediction array identifies which of the X86 bytes are predicted executed and whether the next block predicted executed is sequential or nonsequential. This information, also accessed in Ph2, determines which of the bytes of the currently fetched block will be driven as valid bytes into byte queue 815.
Byte queue 815 may currently have X86 bytes stored therein that have been previously fetched and not yet issued to functional units. If this is the case, a byte filling position is indicated to instruction cache 810 to shift the first predicted byte over by this amount to fill behind the older X86 bytes.
It is noted that since the branch prediction information occurs in clock phase Ph2 of the fetch, the next block to be prefetched by prefetch unit 830 can be sequential or nonsequential since in either case there is one clock cycle in which to access the cache arrays again. Thus, the branch prediction arrays allow a branch out of the block to have the same relative performance as accessing the next sequential block thus providing performance enhancement.
The Decode1/Decode2 pipeline stages are now discussed. During the beginning of decode1, the bytes that were prefetched and predicted executed are driven into byte queue 815 at the designated fill position. This is shown in the timing diagram of FIG. 11 as ICBYTEnB (12:0) asserting in Ph1 of decode1. These bytes are then merged with any pending bytes in the byte queue. The byte queue contains the five bits of predecode state plus the raw X86 bytes to show where instruction boundaries are located. The head of the byte queue is at the beginning of the next predicted executed X86 instruction. In the middle of clock phase Ph1 of decode1, the next stream of bytes from the instruction cache is merged with the existing bytes in byte queue 815 and the merged stream is presented to decoder 805 for scanning. Decoder 805 determines the number of ROPs each instruction takes and the position of the opcode to enable alignment of these opcodes to the corresponding ROP issue positions D0, D1, D2, and D3 with the ROP at D0 being the next ROP to issue. Decoder 805 maintains a copy of the program counters PC's of each of the X86 instructions in byte queue 815 by counting the number of bytes between instruction boundaries, or detecting a branch within the instruction cache and attaching the target PC value to the first X86 byte fetched from that location.
Utilizing the OP code and ROP positioning information, as well as the immediate fields stored in byte queue 815, decoder 805 statically determines the following information during clock phase Ph2 of decode1 and clock phase Ph1 of decode2: 1) functional unit destination, 2) source A/B and destination operand pointer value, 3) size of source and destination operations, and 4) immediate address and data values if any. By the end of clock phase Ph1 of decode2 all the register read and write pointers are resolved and the operation is determined. This is indicated in the timing diagram of FIG. 11 by the assertion of the source A/B pointer values.
In the decode2 pipeline stage depicted in the timing diagram of FIG. 11, the reorder buffer entries are allocated for corresponding ROPs that may issue in the next clock phase. Thus, up to four additional ROPs are allocated entries in the 16 entry reorder buffer 885 during the Ph1 clock phase of decode 2. During the Ph2 clock phase of decode2, the source read pointers for all allocated ROPs are then read from the register file while simultaneously accessing the queue of speculative ROPs contained in the reorder buffer. This simultaneous access of both the register file and reorder buffer arrays permits microprocessor 800 to late select whether to use the actual register file value or to forward either the operand or operand tag from the reorder buffer. By first allocating the four ROP entries in the reorder buffer in Ph1 and then scanning the reorder buffer in Ph2, microprocessor 800 can simultaneously look for read dependencies with the current ROPs being dispatched as well as all previous ROPs that are still in the speculative state. This is indicated in the timing diagram of FIG. 11 by the REGF/ROB access and the check on the tags.
In the execute pipeline stage, ROPs are issued to the functional units by dedicated OP code buses as well as the read operand buses. The dedicated OP code buses communicate the OP code of an ROP to a functional unit whereas the read operand buses transmit operands or operand tags to such functional units. The time during which the operand buses communicate operands to the functional units is indicated in the timing diagram of FIG. 11 by the designation A/B read operand buses.
In the latter part of the Ph1 clock phase of the execute pipeline stage, the functional units determine which ROPs have been issued to such functional units and whether any pending ROPs are ready to issue from the local reservation stations in such functional units. It is noted that a FIFO is maintained in a functional unit's reservation station to ensure that the oldest instructions contained in the reservation stations execute first.
In the event that an instruction is ready to execute within a functional unit, it commences such execution in the late Ph1 of the execute pipeline stage and continues statically through Ph2 of that stage. At the end of Ph2, the functional unit arbitrates for one of the five result buses as indicated by the result bus ROB signal in FIG. 11. In other words, the result bus arbitration signal is asserted during this time. If a functional unit is granted access to the result bus, then it drives the allocated result bus in the following Ph1.
The result pipeline stage shown in the timing diagram of FIG. 11 portrays the forwarding of a result from one functional unit to another which is in need of such result. In clock phase Ph1 of the result pipeline stage, the location of the speculative ROP is written in the reorder buffer with the destination result as well as any status. This entry in the reorder buffer is then given an indication of being valid as well as allocated. Once an allocated entry is validated in this matter, the reorder buffer is capable of directly forwarding operand data as opposed to an operand tag upon receipt of a requested read access. In clock phase Ph2 of the result pipeline stage, the newly allocated tag can be detected by subsequent ROPs that require it to be one of its source operands. This is shown in the timing diagram of FIG. 11 as the direct forwarding of result C via "ROB tag forward" onto the source A/B operand buses.
The retire pipeline stage is the last stage of the pipeline in the timing diagram of FIG. 11. This stage is where the real program counter (retire PC) in the form of the EIP register is maintained and updated as indicated by the bus designation EIP (31:0). As seen in FIG. 11, the EIP (31:0) timing diagram shows where a new PC (or retire PC) is generated upon retirement of an instruction from the reorder buffer to the register file. The actual act of retirement of a result from the reorder buffer to the register file is indicated by the signal designated REGF write/retire in FIG. 11. It is seen in FIG. 11 that in the clock phase Ph1 of the retire pipeline stage, the result of an operation is written to the register file and the EIP register is updated to reflect that this instruction is now executed. The corresponding entry in the reorder buffer is deallocated in the same clock phase Ph1 that the value is written from the reorder buffer to the register file. Since this entry in the reorder buffer is now deallocated, subsequent references to the register C will result in a read from the register file instead of a speculative read from the reorder buffer. In this manner the architectural state of the microprocessor is truly reflected.
FIG. 12 depicts a timing diagram of processor 800 during a branch misprediction. The timing diagram of FIG. 12 shows the same signal types as the timing diagram of FIG. 11 with the following exceptions:
The BRN-- MISP signal indicates when a branch misprediction has occurred.
The XTARGET (31:0) signal denotes the time at which a predicted target branch instruction is communicated to branch unit 835.
The timing diagram of FIG. 12 shows the stages of the microprocessor 800 pipeline during a branch misprediction and recovery. This timing diagram assumes that the first cycle is the execute cycle of the branch and that the following cycles are involved in correcting the prediction and fetching the new instruction stream. It is noted that in this particular embodiment, a three cycle delay exists from the completion of execution of the branch instruction that was mispredicted to the beginning of execution of a corrected path.
The fetch stage of the pipeline depicted in FIG. 12 is similar to the normal fetch stage depicted in FIG. 11 with the exception that the XTARGET (31:0) bus is driven from branch functional unit 835 to instruction cache 810 in order to provide instruction cache 810 with information with respect to the predicted target. It is noted that the branch functional unit is the block of microprocessor 800 which determines that a branch mispredict has in fact occurred. The branch functional unit also calculates the correct target. This target is sent at the same time as a result is returned to the reorder buffer with a mispredicted status indication on result bus 880. The result bus also contains the correct PC value for updating the EIP register upon retiring the branch instruction if a real branch has occurred. The XTARGET bus is then driven on to the fetched PC bus and the instruction cache arrays are accessed. If a hit occurs, the bytes are driven to the byte queue as before.
When a missed prediction occurs, all bytes in byte queue 815 are automatically cleared in the first phase of fetch with the assertion of the signal BRN-- MISP. No additional ROPs are dispatched from decoder 805 until the corrected path has been fetched and decoded.
When the result status of a misprediction is returned in clock phase Ph1 of the fetch pipeline stage to the reorder buffer, the misprediction status indication is sent to all speculative ROPs after the misprediction so that they will not be allowed to write to the register file or to memory. When these instructions are next to retire, their entries in the reorder buffer are deallocated to allow additional ROPs to issue.
With respect to the decode1 pipeline stage during a branch misprediction, the rest of the path for decoding the corrected path is identical to the sequential fetch case with the exception of the updating of the prediction information in the ICNXTBLK array of instruction cache 810. The correct direction of the branch is now written to the prediction array ICNXTBLK to the cache block therein where the branch was mispredicted.
The pipeline stages decode2, execute, result, retire during a misprediction appear substantially similar to those discussed in FIG. 11.
VI. Conclusion--Superscalar High Performance Features.
High performance is achieved in the microprocessor of the invention by extracting substantial parallelism from the code which is executed by the microprocessor. Instruction tagging, reservation stations and result buses with forwarding prevent operand hazards from blocking the execution of unrelated instructions. The microprocessor's reorder buffer (ROB) achieves multiple benefits. The ROB employs a type of register renaming to distinguish between different uses of the same register as a destination, which would otherwise artificially inhibit parallelism. The data stored in the reorder buffer represents the predicted execution state of the microprocessor, whereas the data stored in the register file represents the current execution state of the microprocessor. Also, the reorder buffer preserves the sequential state of the program in the event of interrupts. Moreover, the reorder buffer enables more parallelism by allowing execution beyond unresolved conditional branches. Parallelism is further promoted by the on-board instruction cache (ICACHE) which provides high bandwidth instruction fetch, by branch prediction which minimizes the impact of branches, and by an on-board data cache (DCACHE) to minimize latency for load and store operations.
The superscalar microprocessor of the present invention achieves increased performance by efficiently utilizing die space through sharing of several components. More particularly, the integer unit and floating point unit of the microprocessor reside on a common, shared data processing bus. These functional units include multiple reservation stations also coupled to the same data processing bus. The integer and floating point functional units share a common branch unit on the data processing bus. Moreover, the integer and floating point functional units share a common decoder and a common load/store unit 530. An internal address data (IAD) bus provides local communications among several components of the microprocessor of the invention.
While only certain preferred features of the invention have been shown by way of illustration, many modifications and changes will occur. It is, therefore, to be understood that the present claims are intended to cover all such modifications and changes which fall within the true spirit of the invention.

Claims (28)

What is claimed is:
1. A superscalar microprocessor comprising:
an instruction supply;
a multiple instruction decoder, coupled to said instruction supply, for decoding multiple instructions in the same microprocessor cycle, said decoder decoding both integer and floating point instructions in the same microprocessor cycle, said decoder dispatching both decoded integer instructions and decoded floating point instructions in the same microprocessor cycle thus providing dispatched instructions;
a data processing bus coupled to said decoder;
an integer functional unit coupled to said data processing bus to receive dispatched instructions from the decoder;
a floating point functional unit coupled to said data processing bus to receive dispatched instructions from the decoder;
a branch prediction circuit coupled to said instruction supply for predicting the outcome of branch instructions thus determining predicted-taken branches including instructions which are then speculatively executed by the integer functional unit or the floating point functional unit to produce speculative results;
a branch functional unit, coupled to said data processing bus and the branch prediction circuit, for executing branch instructions and for determining if a branch is a mispredicted branch or a correctly predicted branch;
a common reorder buffer, coupled to said data processing bus, for use by both said integer functional unit and said floating point functional unit to store said speculative results in common storage elements, said common reorder buffer renaming registers, issuing multiple instructions in a single cycle, retiring multiple instructions in a single cycle, and retiring speculative results which become non-speculative results by virtue of being in a correctly predicted branch, said common reorder buffer not retiring speculative results in mispredicted branches; and
a common register file, coupled to said data processing bus and to said common reorder buffer, for storing non-speculative results which are retired from said common reorder buffer.
2. The microprocessor of claim 1 wherein said integer functional unit includes at least one reservation station.
3. The microprocessor of claim 1 wherein said integer functional unit includes two reservation stations.
4. The microprocessor of claim 1 wherein said floating point functional unit includes at least one reservation station.
5. The microprocessor of claim 1 wherein said floating point functional unit includes two reservation stations.
6. The microprocessor of claim 1 wherein said data processing bus includes:
a plurality of opcode buses;
a plurality of operand buses;
a plurality of instruction type buses;
a plurality of result buses; and
a plurality of result tag busses.
7. The microprocessor of claim 6 wherein said operand buses include operand tag buses.
8. The microprocessor of claim 1 wherein said data processing bus includes a plurality of operand buses and a plurality of result buses which each exhibit a predetermined first data width and wherein said common reorder buffer includes a memory for storing results exhibiting a width equal to the first data width and results exhibiting a width equal to a multiple of the first data width.
9. The microprocessor of claim 1 wherein said decoder further includes dispatching means for dispatching both integer and floating point instructions in program order.
10. The microprocessor of claim 1 wherein said floating point functional unit processes operands exhibiting multiple sizes.
11. The microprocessor of claim 1 wherein said floating point functional unit comprises a single precision/double precision floating point functional unit.
12. The microprocessor of claim 1 wherein said multiple instruction decoder is capable of decoding four instructions per microprocessor cycle.
13. The microprocessor of claim 1 further comprising:
a bus interface unit for interfacing said microprocessor an external memory in which instructions and data are stored;
an internal address data communications bus coupled to said bus interface unit;
a load/store functional unit coupled to said data processing bus to receive load and store instructions therefrom, said load/store functional unit further being coupled to said internal address data communications bus to provide said load/store functional unit access to said external memory;
an instruction cache coupled to said internal address data communications bus and said decoder to provide said decoder with a source of instructions, said instruction cache performing as the instruction supply;
a data cache coupled to said internal address data communications bus and said load/store functional unit,
said internal address data communications bus communicating address and data information among said external memory, said instruction cache and said data cache.
14. The microprocessor of claim 1 combined with an external memory for providing instructions and data to said microprocessor.
15. The microprocessor of claim 6 wherein said plurality of operand buses are buses on which both operands and operand tags are transmitted.
16. The microprocessor of claim 1 further comprising a plurality of writeback buses, coupled between the common reorder buffer and the common register file, for transferring results retired from the common reorder buffer to the common register file.
17. A superscalar microprocessor comprising:
an instruction cache for supplying instructions from a computer program including branch instructions, the instruction cache including a branch prediction unit for predicting the outcome of branch instructions thus determining predicted-taken branches which include speculative instructions to be speculatively executed;
a multiple instruction decoder, coupled to the instruction cache, for decoding multiple instructions in the same microprocessor cycle, said decoder decoding both integer and floating point instructions in the same microprocessor cycle, said decoder dispatching both decoded integer instructions and decoded floating point instructions in the same microprocessor cycle thus providing dispatched instructions;
a data processing bus coupled to said decoder;
an integer functional unit coupled to said data processing bus to receive dispatched instructions from the decoder as speculative instructions, said integer functional unit including a plurality of reservation stations for enabling out-of-order instruction execution by said microprocessor, said integer functional unit speculatively executing said speculative instructions when said speculative instructions are integer instructions thus producing speculative results;
a floating point functional unit coupled to said data processing bus to receive dispatched instructions from the decoder as speculative instructions, said floating point functional unit including a plurality of reservation stations for enabling out-of-order instruction execution by said microprocessor, said floating point functional unit speculatively executing said speculative instructions when said speculative instructions are floating point instructions thus producing speculative results;
a branch functional unit coupled to said data processing bus for executing branch instructions and for determining if a branch is a mispredicted branch or a correctly predicted branch;
a common reorder buffer, coupled to said data processing bus, for use by both said integer functional unit and said floating point functional unit to store said speculative results in common storage elements to enable instructions to be processed speculatively and out-of-order, said reorder buffer renaming registers, issuing multiple instructions in a single cycle, retiring multiple instructions in a single cycle, and deallocating speculative results when such speculative results are in a mispredicted branch, said reorder buffer retiring those results whose status changes from speculative to non-speculative as a consequence of being in a correctly predicted branch;
a common register file coupled to said data processing bus and to said common reorder buffer for storing results which are retired from said common reorder buffer;
retire logic, coupled to the common register file, for monitoring the status of results in the common reorder buffer to determine when the status of results in the common reorder buffer changes from speculative to non-speculative as a consequence of being in a correctly predicted branch; and
a load/store functional unit coupled to said data processing bus, for use by both said integer functional unit and said floating point functional unit to permit loading and storage of information.
18. The microprocessor of claim 17 wherein said data processing bus includes:
a plurality of opcode buses;
a plurality of operand buses;
a plurality of instruction type buses;
a plurality of result buses; and
a plurality of result tag busses.
19. The microprocessor of claim 17 wherein said operand buses include operand tag buses.
20. The microprocessor of claim 17 wherein said data processing bus includes a plurality of operand buses and a plurality of result buses which each exhibit a predetermined first data width and wherein said common reorder buffer includes a memory for storing results exhibiting a width equal to the first data width and results exhibiting a width equal to a multiple of the first data width.
21. The microprocessor of claim 17 wherein said decoder further includes dispatching means for dispatching both integer and floating point instructions in program order.
22. The microprocessor of claim 17 wherein said floating point functional unit processes operands exhibiting multiple sizes.
23. The microprocessor of claim 17 wherein said floating point functional unit comprises a single precision/double precision floating point functional unit.
24. The microprocessor of claim 17 wherein said multiple instruction decoder is capable of decoding four instructions per microprocessor cycle.
25. The microprocessor of claim 17 further comprising:
a bus interface unit for interfacing said microprocessor to an external memory in which instructions and data are stored;
an internal address data communications bus coupled to said bus interface unit;
said instruction cache being coupled to said internal address data communications bus and said decoder to provide said decoder with a source of instructions;
a data cache coupled to said internal address data communications bus and said load/store functional unit,
said internal address data communications bus communicating address and data information among said external memory, said instruction cache and said data cache.
26. The microprocessor of claim 17 combined with an external memory for providing instructions and data to said microprocessor.
27. The microprocessor of claim 18 wherein said plurality of operand buses are buses on which both operands and operand tags are transmitted.
28. The microprocessor of claim 17 further comprising a plurality of writeback buses, coupled between the common reorder buffer and the common register file, for transferring results retired from the common reorder buffer to the common register file.
US08/501,243 1993-10-29 1995-07-10 High performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations Expired - Fee Related US5651125A (en)

Priority Applications (7)

Application Number Priority Date Filing Date Title
US08/501,243 US5651125A (en) 1993-10-29 1995-07-10 High performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations
US08/599,697 US5655098A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a circuit for byte-aligning cisc instructions stored in a variable byte-length format
US08/599,698 US5655097A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including an instruction cache circuit for byte-aligning CISC instructions stored in a variable byte-length format
US08/599,700 US5664136A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a dual-pathway circuit for converting cisc instructions to risc operations
US08/599,699 US5751981A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a speculative instruction queue for byte-aligning CISC instructions stored in a variable byte-length format
US08/599,696 US5867682A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a circuit for converting CISC instructions to RISC operations
US08/845,978 US5867683A (en) 1993-10-29 1997-04-30 Method of operating a high performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US14638293A 1993-10-29 1993-10-29
US08/501,243 US5651125A (en) 1993-10-29 1995-07-10 High performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
US14638293A Continuation 1993-10-29 1993-10-29

Related Child Applications (6)

Application Number Title Priority Date Filing Date
US08/599,697 Division US5655098A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a circuit for byte-aligning cisc instructions stored in a variable byte-length format
US08/599,696 Division US5867682A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a circuit for converting CISC instructions to RISC operations
US08/599,699 Division US5751981A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a speculative instruction queue for byte-aligning CISC instructions stored in a variable byte-length format
US08/599,698 Division US5655097A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including an instruction cache circuit for byte-aligning CISC instructions stored in a variable byte-length format
US08/599,700 Division US5664136A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a dual-pathway circuit for converting cisc instructions to risc operations
US08/845,978 Continuation US5867683A (en) 1993-10-29 1997-04-30 Method of operating a high performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations

Publications (1)

Publication Number Publication Date
US5651125A true US5651125A (en) 1997-07-22

Family

ID=22517120

Family Applications (7)

Application Number Title Priority Date Filing Date
US08/501,243 Expired - Fee Related US5651125A (en) 1993-10-29 1995-07-10 High performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations
US08/599,700 Expired - Lifetime US5664136A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a dual-pathway circuit for converting cisc instructions to risc operations
US08/599,696 Expired - Fee Related US5867682A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a circuit for converting CISC instructions to RISC operations
US08/599,699 Expired - Fee Related US5751981A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a speculative instruction queue for byte-aligning CISC instructions stored in a variable byte-length format
US08/599,697 Expired - Fee Related US5655098A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a circuit for byte-aligning cisc instructions stored in a variable byte-length format
US08/599,698 Expired - Fee Related US5655097A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including an instruction cache circuit for byte-aligning CISC instructions stored in a variable byte-length format
US08/845,978 Expired - Lifetime US5867683A (en) 1993-10-29 1997-04-30 Method of operating a high performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations

Family Applications After (6)

Application Number Title Priority Date Filing Date
US08/599,700 Expired - Lifetime US5664136A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a dual-pathway circuit for converting cisc instructions to risc operations
US08/599,696 Expired - Fee Related US5867682A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a circuit for converting CISC instructions to RISC operations
US08/599,699 Expired - Fee Related US5751981A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a speculative instruction queue for byte-aligning CISC instructions stored in a variable byte-length format
US08/599,697 Expired - Fee Related US5655098A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including a circuit for byte-aligning cisc instructions stored in a variable byte-length format
US08/599,698 Expired - Fee Related US5655097A (en) 1993-10-29 1996-02-09 High performance superscalar microprocessor including an instruction cache circuit for byte-aligning CISC instructions stored in a variable byte-length format
US08/845,978 Expired - Lifetime US5867683A (en) 1993-10-29 1997-04-30 Method of operating a high performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations

Country Status (4)

Country Link
US (7) US5651125A (en)
EP (1) EP0651321B1 (en)
JP (1) JP3670039B2 (en)
DE (1) DE69429061T2 (en)

Cited By (166)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5721855A (en) * 1994-03-01 1998-02-24 Intel Corporation Method for pipeline processing of instructions by controlling access to a reorder buffer using a register file outside the reorder buffer
US5748516A (en) * 1995-09-26 1998-05-05 Advanced Micro Devices, Inc. Floating point processing unit with forced arithmetic results
US5761105A (en) * 1995-09-26 1998-06-02 Advanced Micro Devices, Inc. Reservation station including addressable constant store for a floating point processing unit
US5764938A (en) * 1994-06-01 1998-06-09 Advanced Micro Devices, Inc. Resynchronization of a superscalar processor
US5768554A (en) * 1995-02-02 1998-06-16 Ricoh Company, Ltd. Central processing unit
US5796973A (en) * 1993-10-29 1998-08-18 Advanced Micro Devices, Inc. Method and apparatus for decoding one or more complex instructions into concurrently dispatched simple instructions
US5799162A (en) * 1994-06-01 1998-08-25 Advanced Micro Devices, Inc. Program counter update mechanism
US5828873A (en) * 1997-03-19 1998-10-27 Advanced Micro Devices, Inc. Assembly queue for a floating point unit
US5845101A (en) * 1997-05-13 1998-12-01 Advanced Micro Devices, Inc. Prefetch buffer for storing instructions prior to placing the instructions in an instruction cache
US5852726A (en) * 1995-12-19 1998-12-22 Intel Corporation Method and apparatus for executing two types of instructions that specify registers of a shared logical register file in a stack and a non-stack referenced manner
US5857096A (en) * 1995-12-19 1999-01-05 Intel Corporation Microarchitecture for implementing an instruction to clear the tags of a stack reference register file
US5867684A (en) * 1995-09-11 1999-02-02 International Business Machines Corporation Method and processor that permit concurrent execution of a store multiple instruction and a dependent instruction
US5870578A (en) * 1997-12-09 1999-02-09 Advanced Micro Devices, Inc. Workload balancing in a microprocessor for reduced instruction dispatch stalling
US5878266A (en) * 1995-09-26 1999-03-02 Advanced Micro Devices, Inc. Reservation station for a floating point processing unit
US5881307A (en) * 1997-02-24 1999-03-09 Samsung Electronics Co., Ltd. Deferred store data read with simple anti-dependency pipeline inter-lock control in superscalar processor
US5881306A (en) * 1996-12-17 1999-03-09 International Business Machines Corporation Instruction fetch bandwidth analysis
US5881216A (en) * 1992-03-05 1999-03-09 Seiko Epson Corporation Register file backup queue
US5884070A (en) * 1997-06-25 1999-03-16 Sun Microsystems, Inc. Method for processing single precision arithmetic operations in system where two single precision registers are aliased to one double precision register
US5887185A (en) * 1997-03-19 1999-03-23 Advanced Micro Devices, Inc. Interface for coupling a floating point unit to a reorder buffer
US5887161A (en) * 1997-03-31 1999-03-23 International Business Machines Corporation Issuing instructions in a processor supporting out-of-order execution
US5896542A (en) * 1992-12-31 1999-04-20 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US5903740A (en) * 1996-07-24 1999-05-11 Advanced Micro Devices, Inc. Apparatus and method for retiring instructions in excess of the number of accessible write ports
US5915110A (en) * 1996-07-26 1999-06-22 Advanced Micro Devices, Inc. Branch misprediction recovery in a reorder buffer having a future file
US5933626A (en) * 1997-06-12 1999-08-03 Advanced Micro Devices, Inc. Apparatus and method for tracing microprocessor instructions
US5940602A (en) * 1997-06-11 1999-08-17 Advanced Micro Devices, Inc. Method and apparatus for predecoding variable byte length instructions for scanning of a number of RISC operations
US5940859A (en) * 1995-12-19 1999-08-17 Intel Corporation Emptying packed data state during execution of packed data instructions
US5946468A (en) * 1996-07-26 1999-08-31 Advanced Micro Devices, Inc. Reorder buffer having an improved future file for storing speculative instruction execution results
US5961629A (en) * 1991-07-08 1999-10-05 Seiko Epson Corporation High performance, superscalar-based computer system with out-of-order instruction execution
US5974535A (en) * 1997-05-09 1999-10-26 International Business Machines Corporation Method and system in data processing system of permitting concurrent processing of instructions of a particular type
US5974432A (en) * 1997-12-05 1999-10-26 Advanced Micro Devices, Inc. On-the-fly one-hot encoding of leading zero count
US5974542A (en) * 1997-10-30 1999-10-26 Advanced Micro Devices, Inc. Branch prediction unit which approximates a larger number of branch predictions using a smaller number of branch predictions and an alternate target indication
US5978901A (en) * 1997-08-21 1999-11-02 Advanced Micro Devices, Inc. Floating point and multimedia unit with data type reclassification capability
US5983334A (en) * 1992-03-31 1999-11-09 Seiko Epson Corporation Superscalar microprocessor for out-of-order and concurrently executing at least two RISC instructions translating from in-order CISC instructions
US5983321A (en) * 1997-03-12 1999-11-09 Advanced Micro Devices, Inc. Cache holding register for receiving instruction packets and for providing the instruction packets to a predecode unit and instruction cache
US5987235A (en) * 1997-04-04 1999-11-16 Advanced Micro Devices, Inc. Method and apparatus for predecoding variable byte length instructions for fast scanning of instructions
US5987259A (en) * 1997-06-30 1999-11-16 Sun Microsystems, Inc. Functional unit switching for the allocation of registers
US6012141A (en) * 1995-04-28 2000-01-04 Hyundai Electronics America Apparatus for detecting and executing traps in a superscalar processor
WO2000000878A2 (en) * 1998-06-26 2000-01-06 Chi Lan Wong Derek Methods for increasing instruction-level parallelism in microprocessors and digital systems
US6014739A (en) * 1997-10-27 2000-01-11 Advanced Micro Devices, Inc. Increasing general registers in X86 processors
US6016533A (en) * 1997-12-16 2000-01-18 Advanced Micro Devices, Inc. Way prediction logic for cache array
US6016545A (en) * 1997-12-16 2000-01-18 Advanced Micro Devices, Inc. Reduced size storage apparatus for storing cache-line-related data in a high frequency microprocessor
US6018798A (en) * 1997-12-18 2000-01-25 Advanced Micro Devices, Inc. Floating point unit using a central window for storing instructions capable of executing multiple instructions in a single clock cycle
US6032252A (en) * 1997-10-28 2000-02-29 Advanced Micro Devices, Inc. Apparatus and method for efficient loop control in a superscalar microprocessor
US6038654A (en) * 1991-07-08 2000-03-14 Seiko Epson Corporation High performance, superscalar-based computer system with out-of-order instruction execution
US6052775A (en) * 1997-06-25 2000-04-18 Sun Microsystems, Inc. Method for non-intrusive cache fills and handling of load misses
US6065110A (en) * 1998-02-09 2000-05-16 International Business Machines Corporation Method and apparatus for loading an instruction buffer of a processor capable of out-of-order instruction issue
US6094719A (en) * 1997-06-25 2000-07-25 Sun Microsystems, Inc. Reducing data dependent conflicts by converting single precision instructions into microinstructions using renamed phantom registers in a processor having double precision registers
US6108769A (en) * 1996-05-17 2000-08-22 Advanced Micro Devices, Inc. Dependency table for reducing dependency checking hardware
US6112018A (en) * 1997-12-18 2000-08-29 Advanced Micro Devices, Inc. Apparatus for exchanging two stack registers
US6112296A (en) * 1997-12-18 2000-08-29 Advanced Micro Devices, Inc. Floating point stack manipulation using a register map and speculative top of stack values
US6119223A (en) * 1998-07-31 2000-09-12 Advanced Micro Devices, Inc. Map unit having rapid misprediction recovery
US6122729A (en) * 1997-05-13 2000-09-19 Advanced Micro Devices, Inc. Prefetch buffer which stores a pointer indicating an initial predecode position
US6122656A (en) * 1998-07-31 2000-09-19 Advanced Micro Devices, Inc. Processor configured to map logical register numbers to physical register numbers using virtual register numbers
US6122727A (en) * 1998-08-24 2000-09-19 Advanced Micro Devices, Inc. Symmetrical instructions queue for high clock frequency scheduling
US6131157A (en) * 1992-05-01 2000-10-10 Seiko Epson Corporation System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US6141745A (en) * 1998-04-30 2000-10-31 Advanced Micro Devices, Inc. Functional bit identifying a prefix byte via a particular state regardless of type of instruction
US6157986A (en) * 1997-12-16 2000-12-05 Advanced Micro Devices, Inc. Fast linear tag validation unit for use in microprocessor
US6157996A (en) * 1997-11-13 2000-12-05 Advanced Micro Devices, Inc. Processor programably configurable to execute enhanced variable byte length instructions including predicated execution, three operand addressing, and increased register space
US6170997B1 (en) 1995-12-19 2001-01-09 Intel Corporation Method for executing instructions that operate on different data types stored in the same single logical register file
US6175908B1 (en) 1998-04-30 2001-01-16 Advanced Micro Devices, Inc. Variable byte-length instructions using state of function bit of second byte of plurality of instructions bytes as indicative of whether first byte is a prefix byte
US6175906B1 (en) 1996-12-06 2001-01-16 Advanced Micro Devices, Inc. Mechanism for fast revalidation of virtual tags
US6195745B1 (en) * 1994-11-15 2001-02-27 Advanced Micro Devices, Inc. Pipeline throughput via parallel out-of-order execution of adds and moves in a supplemental integer execution unit
US6199154B1 (en) 1997-11-17 2001-03-06 Advanced Micro Devices, Inc. Selecting cache to fetch in multi-level cache system based on fetch address source and pre-fetching additional data to the cache for future access
US6212622B1 (en) 1998-08-24 2001-04-03 Advanced Micro Devices, Inc. Mechanism for load block on store address generation
US6212623B1 (en) 1998-08-24 2001-04-03 Advanced Micro Devices, Inc. Universal dependency vector/queue entry
US6230254B1 (en) 1992-09-29 2001-05-08 Seiko Epson Corporation System and method for handling load and/or store operators in a superscalar microprocessor
US6230259B1 (en) 1997-10-31 2001-05-08 Advanced Micro Devices, Inc. Transparent extended state save
US6230262B1 (en) 1998-07-31 2001-05-08 Advanced Micro Devices, Inc. Processor configured to selectively free physical registers upon retirement of instructions
US6266763B1 (en) 1999-01-05 2001-07-24 Advanced Micro Devices, Inc. Physical rename register for efficiently storing floating point, integer, condition code, and multimedia values
US6289437B1 (en) * 1997-08-27 2001-09-11 International Business Machines Corporation Data processing system and method for implementing an efficient out-of-order issue mechanism
US6304953B1 (en) * 1998-07-31 2001-10-16 Intel Corporation Computer processor with instruction-specific schedulers
US6370623B1 (en) * 1988-12-28 2002-04-09 Philips Electronics North America Corporation Multiport register file to accommodate data of differing lengths
US6434693B1 (en) 1992-09-29 2002-08-13 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US6484241B2 (en) * 2000-12-28 2002-11-19 International Business Machines Corporation Multiprocessor computer system with sectored cache line system bus protocol mechanism
US20020174321A1 (en) * 1999-12-20 2002-11-21 John Lizy Kurian System, method and apparatus for allocating hardware resources using pseudorandom sequences
US20030018630A1 (en) * 2000-04-07 2003-01-23 Indeck Ronald S. Associative database scanning and information retrieval using FPGA devices
US6542984B1 (en) 2000-01-03 2003-04-01 Advanced Micro Devices, Inc. Scheduler capable of issuing and reissuing dependency chains
US6542986B1 (en) 1999-11-09 2003-04-01 Advanced Micro Devices, Inc. Resolving dependencies among concurrently dispatched instructions in a superscalar microprocessor
US6553462B2 (en) * 2000-12-28 2003-04-22 International Business Machines Corporation Multiprocessor computer system with sectored cache line mechanism for load and store operations
US20030088759A1 (en) * 2001-11-05 2003-05-08 Wilkerson Christopher B System and method to reduce execution of instructions involving unreliable data in a speculative processor
US6564315B1 (en) 2000-01-03 2003-05-13 Advanced Micro Devices, Inc. Scheduler which discovers non-speculative nature of an instruction after issuing and reissues the instruction
US6571322B2 (en) * 2000-12-28 2003-05-27 International Business Machines Corporation Multiprocessor computer system with sectored cache line mechanism for cache intervention
US20030131219A1 (en) * 1994-12-02 2003-07-10 Alexander Peleg Method and apparatus for unpacking packed data
US6622235B1 (en) 2000-01-03 2003-09-16 Advanced Micro Devices, Inc. Scheduler which retries load/store hit situations
US6622237B1 (en) 2000-01-03 2003-09-16 Advanced Micro Devices, Inc. Store to load forward predictor training using delta tag
US6651161B1 (en) 2000-01-03 2003-11-18 Advanced Micro Devices, Inc. Store load forward predictor untraining
US20030221013A1 (en) * 2002-05-21 2003-11-27 John Lockwood Methods, systems, and devices using reprogrammable hardware for high-speed processing of streaming data to find a redefinable pattern and respond thereto
US6694424B1 (en) 2000-01-03 2004-02-17 Advanced Micro Devices, Inc. Store load forward predictor training
US6711558B1 (en) 2000-04-07 2004-03-23 Washington University Associative database scanning and information retrieval
US6742111B2 (en) * 1998-08-31 2004-05-25 Stmicroelectronics, Inc. Reservation stations to increase instruction level parallelism
US20040128480A1 (en) * 2002-12-31 2004-07-01 Intel Corporation Register file read port to support uop fusion
US20040158695A1 (en) * 1999-05-03 2004-08-12 Laurent Ugen Method and apparatus for handling transfer of guarded instructions in a computer system
US6792523B1 (en) 1995-12-19 2004-09-14 Intel Corporation Processor with instructions that operate on different data types stored in the same single logical register file
US20050010744A1 (en) * 2003-07-08 2005-01-13 Advanced Micro Devices, Inc. Store-to-load forwarding buffer using indexed lookup
US20050050278A1 (en) * 2003-09-03 2005-03-03 Advanced Micro Devices, Inc. Low power way-predicted cache
US20050050277A1 (en) * 2003-09-03 2005-03-03 Advanced Micro Devices, Inc. MicroTLB and micro TAG for reducing power in a processor
US6877084B1 (en) 2000-08-09 2005-04-05 Advanced Micro Devices, Inc. Central processing unit (CPU) accessing an extended register set in an extended register mode
US20050154866A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Systems and methods for executing across at least one memory barrier employing speculative fills
US20050154833A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Coherent signal in a multi-processor system
US20050154805A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Systems and methods for employing speculative fills
US20050154831A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Source request arbitration
US20050154834A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Cache systems and methods for employing speculative fills
US20050154832A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Consistency evaluation of program execution across at least one memory barrier
US20050154835A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Register file systems and methods for employing speculative fills
US20050154865A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Multi-processor systems and methods for backup for non-coherent speculative fills
US20050154836A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Multi-processor system receiving input from a pre-fetch buffer
US20050204194A1 (en) * 2004-02-27 2005-09-15 Curry John W. Detecting floating point hardware failures
US6981132B2 (en) 2000-08-09 2005-12-27 Advanced Micro Devices, Inc. Uniform register addressing using prefix byte
US6988183B1 (en) 1998-06-26 2006-01-17 Derek Chi-Lan Wong Methods for increasing instruction-level parallelism in microprocessors and digital system
US20060095728A1 (en) * 2004-09-30 2006-05-04 Gary Hammond Method and apparatus to provide a source operand for an instruction in a processor
US7043626B1 (en) 2003-10-01 2006-05-09 Advanced Micro Devices, Inc. Retaining flag value associated with dead result data in freed rename physical register with an indicator to select set-aside register instead for renaming
US7107433B1 (en) * 2001-10-26 2006-09-12 Lsi Logic Corporation Mechanism for resource allocation in a digital signal processor based on instruction type information and functional priority and method of operation thereof
US20060294059A1 (en) * 2000-04-07 2006-12-28 Washington University, A Corporation Of The State Of Missouri Intelligent data storage and processing using fpga devices
US20070038846A1 (en) * 2005-08-10 2007-02-15 P.A. Semi, Inc. Partial load/store forward prediction
US20070074005A1 (en) * 2005-09-27 2007-03-29 Ibm Corporation Method and apparatus for issuing instructions from an issue queue in an information handling system
US20070083737A1 (en) * 2005-08-16 2007-04-12 Ibm Corporation Processor with efficient shift/rotate instruction execution
US20070083734A1 (en) * 2005-08-16 2007-04-12 Abernathy Christopher M Queue design supporting dependency checking and issue for simd instructions within a general purpose processor
US20070130140A1 (en) * 2005-12-02 2007-06-07 Cytron Ron K Method and device for high performance regular expression pattern matching
US7237095B1 (en) 2005-08-04 2007-06-26 Advanced Micro Devices, Inc. Optimum power efficient shifting algorithm for schedulers
US20070198812A1 (en) * 2005-09-27 2007-08-23 Ibm Corporation Method and apparatus for issuing instructions from an issue queue including a main issue queue array and an auxiliary issue queue array in an information handling system
US20070260602A1 (en) * 2006-05-02 2007-11-08 Exegy Incorporated Method and Apparatus for Approximate Pattern Matching
US20070277036A1 (en) * 2003-05-23 2007-11-29 Washington University, A Corporation Of The State Of Missouri Intelligent data storage and processing using fpga devices
US20090138659A1 (en) * 2007-11-26 2009-05-28 Gary Lauterbach Mechanism to accelerate removal of store operations from a queue
US7602785B2 (en) 2004-02-09 2009-10-13 Washington University Method and system for performing longest prefix matching for network address lookup using bloom filters
US20090287628A1 (en) * 2008-05-15 2009-11-19 Exegy Incorporated Method and System for Accelerated Stream Processing
US7660793B2 (en) 2006-11-13 2010-02-09 Exegy Incorporated Method and system for high performance integration, processing and searching of structured and unstructured data using coprocessors
US7685402B2 (en) 1991-07-08 2010-03-23 Sanjiv Garg RISC microprocessor architecture implementing multiple typed register sets
US7711844B2 (en) 2002-08-15 2010-05-04 Washington University Of St. Louis TCP-splitter: reliable packet monitoring methods and apparatus for high speed networks
US7716330B2 (en) 2001-10-19 2010-05-11 Global Velocity, Inc. System and method for controlling transmission of data packets over an information network
US7802074B2 (en) 1992-03-31 2010-09-21 Sanjiv Garg Superscalar RISC instruction scheduling
US7840482B2 (en) 2006-06-19 2010-11-23 Exegy Incorporated Method and system for high speed options pricing
US20100318772A1 (en) * 2009-06-11 2010-12-16 Ranganathan Sudhakar Superscalar register-renaming for a stack-addressed architecture
US7921046B2 (en) 2006-06-19 2011-04-05 Exegy Incorporated High speed processing of financial information using FPGA devices
US7954114B2 (en) 2006-01-26 2011-05-31 Exegy Incorporated Firmware socket module for FPGA-based pipeline processing
US7970722B1 (en) 1999-11-08 2011-06-28 Aloft Media, Llc System, method and computer program product for a collaborative decision platform
US7979678B2 (en) 1992-12-31 2011-07-12 Seiko Epson Corporation System and method for register renaming
US8326819B2 (en) 2006-11-13 2012-12-04 Exegy Incorporated Method and system for high performance data metatagging and data indexing using coprocessors
US20140006849A1 (en) * 2011-12-22 2014-01-02 Tanausu Ramirez Fault-aware mapping for shared last level cache (llc)
US20140040595A1 (en) * 2012-08-01 2014-02-06 Freescale Semiconductor, Inc. Space efficient checkpoint facility and technique for processor with integrally indexed register mapping and free-list arrays
US8762249B2 (en) 2008-12-15 2014-06-24 Ip Reservoir, Llc Method and apparatus for high-speed processing of financial market depth data
US20140188868A1 (en) * 2012-12-27 2014-07-03 Dropbox, Inc. Predictive models of file access patterns by application and file type
US20140281408A1 (en) * 2013-03-15 2014-09-18 Soft Machines, Inc. Method and apparatus for predicting forwarding of data from a store to a load
US9128725B2 (en) 2012-05-04 2015-09-08 Apple Inc. Load-store dependency predictor content management
US9600289B2 (en) 2012-05-30 2017-03-21 Apple Inc. Load-store dependency predictor PC hashing
US9633093B2 (en) 2012-10-23 2017-04-25 Ip Reservoir, Llc Method and apparatus for accelerated format translation of data in a delimited data format
US9633097B2 (en) 2012-10-23 2017-04-25 Ip Reservoir, Llc Method and apparatus for record pivoting to accelerate processing of data fields
US20170168539A1 (en) * 2015-12-15 2017-06-15 International Business Machines Corporation Reducing power consumption in a multi-slice computer processor
US9710268B2 (en) 2014-04-29 2017-07-18 Apple Inc. Reducing latency for pointer chasing loads
US9740494B2 (en) 2011-04-29 2017-08-22 Arizona Board Of Regents For And On Behalf Of Arizona State University Low complexity out-of-order issue logic using static circuits
US9990393B2 (en) 2012-03-27 2018-06-05 Ip Reservoir, Llc Intelligent feed switch
US10037568B2 (en) 2010-12-09 2018-07-31 Ip Reservoir, Llc Method and apparatus for managing orders in financial markets
US10121196B2 (en) 2012-03-27 2018-11-06 Ip Reservoir, Llc Offload processing of data packets containing financial market data
US10146845B2 (en) 2012-10-23 2018-12-04 Ip Reservoir, Llc Method and apparatus for accelerated format translation of data in a delimited data format
US10229453B2 (en) 2008-01-11 2019-03-12 Ip Reservoir, Llc Method and system for low latency basket calculation
US10437595B1 (en) 2016-03-15 2019-10-08 Apple Inc. Load/store dependency predictor optimization for replayed loads
US10467010B2 (en) 2013-03-15 2019-11-05 Intel Corporation Method and apparatus for nearest potential store tagging
US10514925B1 (en) 2016-01-28 2019-12-24 Apple Inc. Load speculation recovery
US10572824B2 (en) 2003-05-23 2020-02-25 Ip Reservoir, Llc System and method for low latency multi-functional pipeline with correlation logic and selectively activated/deactivated pipelined data processing engines
US10650452B2 (en) 2012-03-27 2020-05-12 Ip Reservoir, Llc Offload processing of data packets
US10846624B2 (en) 2016-12-22 2020-11-24 Ip Reservoir, Llc Method and apparatus for hardware-accelerated machine learning
US10902013B2 (en) 2014-04-23 2021-01-26 Ip Reservoir, Llc Method and apparatus for accelerated record layout detection
US10942943B2 (en) 2015-10-29 2021-03-09 Ip Reservoir, Llc Dynamic field data translation to support high performance stream data processing
CN114116533A (en) * 2021-11-29 2022-03-01 海光信息技术股份有限公司 Method for storing data by using shared memory
US11436672B2 (en) 2012-03-27 2022-09-06 Exegy Incorporated Intelligent switch for processing financial market data
US20220382714A1 (en) * 2021-06-01 2022-12-01 International Business Machines Corporation Receiving at a cache node notification of changes to files in a source file system served from a cache file system at the cache node
US11645238B2 (en) 2021-06-01 2023-05-09 International Business Machines Corporation Notifying a cache file system of changes to files in a source file system served from the cache file system

Families Citing this family (170)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CA2016068C (en) * 1989-05-24 2000-04-04 Robert W. Horst Multiple instruction issue computer architecture
US5630082A (en) * 1993-10-29 1997-05-13 Advanced Micro Devices, Inc. Apparatus and method for instruction queue scanning
TW353732B (en) * 1994-03-31 1999-03-01 Ibm Processing system and method of operation
US5559976A (en) * 1994-03-31 1996-09-24 International Business Machines Corporation System for instruction completion independent of result write-back responsive to both exception free completion of execution and completion of all logically prior instructions
US5632023A (en) * 1994-06-01 1997-05-20 Advanced Micro Devices, Inc. Superscalar microprocessor including flag operand renaming and forwarding apparatus
US5832297A (en) * 1995-04-12 1998-11-03 Advanced Micro Devices, Inc. Superscalar microprocessor load/store unit employing a unified buffer and separate pointers for load and store operations
US5867726A (en) * 1995-05-02 1999-02-02 Hitachi, Ltd. Microcomputer
US5968169A (en) * 1995-06-07 1999-10-19 Advanced Micro Devices, Inc. Superscalar microprocessor stack structure for judging validity of predicted subroutine return addresses
US6112019A (en) * 1995-06-12 2000-08-29 Georgia Tech Research Corp. Distributed instruction queue
US5742840A (en) 1995-08-16 1998-04-21 Microunity Systems Engineering, Inc. General purpose, multiple precision parallel operation, programmable media processor
US7301541B2 (en) 1995-08-16 2007-11-27 Microunity Systems Engineering, Inc. Programmable processor and method with wide operations
US6643765B1 (en) 1995-08-16 2003-11-04 Microunity Systems Engineering, Inc. Programmable processor with group floating point operations
US5845323A (en) * 1995-08-31 1998-12-01 Advanced Micro Devices, Inc. Way prediction structure for predicting the way of a cache in which an access hits, thereby speeding cache access time
US5987561A (en) * 1995-08-31 1999-11-16 Advanced Micro Devices, Inc. Superscalar microprocessor employing a data cache capable of performing store accesses in a single clock cycle
US5850563A (en) * 1995-09-11 1998-12-15 International Business Machines Corporation Processor and method for out-of-order completion of floating-point operations during load/store multiple operations
US5872947A (en) * 1995-10-24 1999-02-16 Advanced Micro Devices, Inc. Instruction classification circuit configured to classify instructions into a plurality of instruction types prior to decoding said instructions
US5881278A (en) * 1995-10-30 1999-03-09 Advanced Micro Devices, Inc. Return address prediction system which adjusts the contents of return stack storage to enable continued prediction after a mispredicted branch
US5864707A (en) * 1995-12-11 1999-01-26 Advanced Micro Devices, Inc. Superscalar microprocessor configured to predict return addresses from a return stack storage
US5911057A (en) * 1995-12-19 1999-06-08 Texas Instruments Incorporated Superscalar microprocessor having combined register and memory renaming circuits, systems, and methods
US5778246A (en) * 1995-12-27 1998-07-07 Intel Corporation Method and apparatus for efficient propagation of attribute bits in an instruction decode pipeline
US5930490A (en) * 1996-01-02 1999-07-27 Advanced Micro Devices, Inc. Microprocessor configured to switch instruction sets upon detection of a plurality of consecutive instructions
JP3658072B2 (en) * 1996-02-07 2005-06-08 株式会社ルネサステクノロジ Data processing apparatus and data processing method
SE509499C2 (en) * 1996-05-03 1999-02-01 Ericsson Telefon Ab L M Method and apparatus for handling conditional jumps in instructional processing in a pipeline architecture
EP1310864A2 (en) * 1996-05-30 2003-05-14 Matsushita Electric Industrial Co., Ltd. Method and circuit for conditional-flag rewriting control
US5784603A (en) * 1996-06-19 1998-07-21 Sun Microsystems, Inc. Fast handling of branch delay slots on mispredicted branches
US5652774A (en) * 1996-07-08 1997-07-29 International Business Machines Corporation Method and apparatus for decreasing the cycle times of a data processing system
US5802556A (en) * 1996-07-16 1998-09-01 International Business Machines Corporation Method and apparatus for correcting misaligned instruction data
US6049863A (en) * 1996-07-24 2000-04-11 Advanced Micro Devices, Inc. Predecoding technique for indicating locations of opcode bytes in variable byte-length instructions within a superscalar microprocessor
US5867680A (en) * 1996-07-24 1999-02-02 Advanced Micro Devices, Inc. Microprocessor configured to simultaneously dispatch microcode and directly-decoded instructions
US5882993A (en) 1996-08-19 1999-03-16 Advanced Micro Devices, Inc. Integrated circuit with differing gate oxide thickness and process for making same
US6058465A (en) * 1996-08-19 2000-05-02 Nguyen; Le Trong Single-instruction-multiple-data processing in a multimedia signal processor
US5884062A (en) * 1996-08-30 1999-03-16 Texas Instruments Incorporated Microprocessor with pipeline status integrity logic for handling multiple stage writeback exceptions
JP2933027B2 (en) * 1996-08-30 1999-08-09 日本電気株式会社 Multiple instruction parallel issue / execution management device
JP2933026B2 (en) * 1996-08-30 1999-08-09 日本電気株式会社 Multiple instruction parallel issue / execution management device
US6055598A (en) * 1996-09-26 2000-04-25 Vlsi Technology, Inc. Arrangement and method for allowing sequence-independent command responses across a computer bus bridge
US5991884A (en) * 1996-09-30 1999-11-23 Intel Corporation Method for reducing peak power in dispatching instructions to multiple execution units
US5754811A (en) * 1996-10-08 1998-05-19 Putrino; Michael Instruction dispatch queue for improved instruction cache to queue timing
WO1998020421A1 (en) * 1996-11-04 1998-05-14 Advanced Micro Devices, Inc. A way prediction structure
US6631454B1 (en) 1996-11-13 2003-10-07 Intel Corporation Processor and data cache with data storage unit and tag hit/miss logic operated at a first and second clock frequencies
US6256745B1 (en) 1998-06-05 2001-07-03 Intel Corporation Processor having execution core sections operating at different clock rates
US5887160A (en) * 1996-12-10 1999-03-23 Fujitsu Limited Method and apparatus for communicating integer and floating point data over a shared data path in a single instruction pipeline processor
US6088793A (en) * 1996-12-30 2000-07-11 Intel Corporation Method and apparatus for branch execution on a multiple-instruction-set-architecture microprocessor
US6542998B1 (en) 1997-02-08 2003-04-01 Pact Gmbh Method of self-synchronization of configurable elements of a programmable module
US5909567A (en) * 1997-02-28 1999-06-01 Advanced Micro Devices, Inc. Apparatus and method for native mode processing in a RISC-based CISC processor
US5923898A (en) * 1997-05-14 1999-07-13 International Business Machines Corporation System for executing I/O request when an I/O request queue entry matches a snoop table entry or executing snoop when not matched
JPH10333908A (en) * 1997-05-30 1998-12-18 Mitsubishi Electric Corp Branch prediction method
US6009511A (en) * 1997-06-11 1999-12-28 Advanced Micro Devices, Inc. Apparatus and method for tagging floating point operands and results for rapid detection of special floating point numbers
US5898851A (en) * 1997-06-11 1999-04-27 Advanced Micro Devices, Inc. Method and apparatus for five bit predecoding variable length instructions for scanning of a number of RISC operations
US5930491A (en) * 1997-06-18 1999-07-27 International Business Machines Corporation Identification of related instructions resulting from external to internal translation by use of common ID field for each group
US6044222A (en) * 1997-06-23 2000-03-28 International Business Machines Corporation System, method, and program product for loop instruction scheduling hardware lookahead
US6085305A (en) * 1997-06-25 2000-07-04 Sun Microsystems, Inc. Apparatus for precise architectural update in an out-of-order processor
US6035388A (en) 1997-06-27 2000-03-07 Sandcraft, Inc. Method and apparatus for dual issue of program instructions to symmetric multifunctional execution units
US6021489A (en) * 1997-06-30 2000-02-01 Intel Corporation Apparatus and method for sharing a branch prediction unit in a microprocessor implementing a two instruction set architecture
US5870575A (en) * 1997-09-22 1999-02-09 International Business Machines Corporation Indirect unconditional branches in data processing system emulation mode
US5864703A (en) * 1997-10-09 1999-01-26 Mips Technologies, Inc. Method for providing extended precision in SIMD vector arithmetic operations
US7197625B1 (en) 1997-10-09 2007-03-27 Mips Technologies, Inc. Alignment and ordering of vector elements for single instruction multiple data processing
US6029244A (en) * 1997-10-10 2000-02-22 Advanced Micro Devices, Inc. Microprocessor including an efficient implementation of extreme value instructions
US6237077B1 (en) 1997-10-13 2001-05-22 Idea Corporation Instruction template for efficient processing clustered branch instructions
WO1999026133A2 (en) * 1997-11-14 1999-05-27 Marathon Technologies Corporation Method for maintaining the synchronized execution in fault resilient/fault tolerant computer systems
US6112293A (en) * 1997-11-17 2000-08-29 Advanced Micro Devices, Inc. Processor configured to generate lookahead results from operand collapse unit and for inhibiting receipt/execution of the first instruction based on the lookahead result
US6134650A (en) * 1997-12-12 2000-10-17 Advanced Micro Devices, Inc. Apparatus and method for predicting a first scanned instruction as microcode instruction prior to scanning predecode data
US6061775A (en) * 1997-12-12 2000-05-09 Advanced Micro Devices, Inc. Apparatus and method for predicting a first microcode instruction of a cache line and using predecode instruction data to identify instruction boundaries and types
US5951671A (en) * 1997-12-18 1999-09-14 Advanced Micro Devices, Inc. Sharing instruction predecode information in a multiprocessor system
US6041405A (en) * 1997-12-18 2000-03-21 Advanced Micro Devices, Inc. Instruction length prediction using an instruction length pattern detector
US6125441A (en) * 1997-12-18 2000-09-26 Advanced Micro Devices, Inc. Predicting a sequence of variable instruction lengths from previously identified length pattern indexed by an instruction fetch address
US6012138A (en) * 1997-12-19 2000-01-04 Lsi Logic Corporation Dynamically variable length CPU pipeline for efficiently executing two instruction sets
US6047367A (en) * 1998-01-20 2000-04-04 International Business Machines Corporation Microprocessor with improved out of order support
US6009510A (en) * 1998-02-06 1999-12-28 Ip First Llc Method and apparatus for improved aligned/misaligned data load from cache
US5881260A (en) * 1998-02-09 1999-03-09 Hewlett-Packard Company Method and apparatus for sequencing and decoding variable length instructions with an instruction boundary marker within each instruction
US6105129A (en) * 1998-02-18 2000-08-15 Advanced Micro Devices, Inc. Converting register data from a first format type to a second format type if a second type instruction consumes data produced by a first type instruction
US6212621B1 (en) 1998-06-24 2001-04-03 Advanced Micro Devices Inc Method and system using tagged instructions to allow out-of-program-order instruction decoding
US6092182A (en) * 1998-06-24 2000-07-18 Advanced Micro Devices, Inc. Using ECC/parity bits to store predecode information
US6278838B1 (en) * 1998-06-26 2001-08-21 Lsi Logic Corporation Peak-ahead FIFO for DVD system stream parsing
US6240510B1 (en) * 1998-08-06 2001-05-29 Intel Corporation System for processing a cluster of instructions where the instructions are issued to the execution units having a priority order according to a template associated with the cluster of instructions
US6304960B1 (en) 1998-08-06 2001-10-16 Intel Corporation Validating prediction for branches in a cluster via comparison of predicted and condition selected tentative target addresses and validation of branch conditions
US6418527B1 (en) * 1998-10-13 2002-07-09 Motorola, Inc. Data processor instruction system for grouping instructions with or without a common prefix and data processing system that uses two or more instruction grouping methods
US6434689B2 (en) 1998-11-09 2002-08-13 Infineon Technologies North America Corp. Data processing unit with interface for sharing registers by a processor and a coprocessor
US6223254B1 (en) * 1998-12-04 2001-04-24 Stmicroelectronics, Inc. Parcel cache
SG81954A1 (en) * 1999-01-21 2001-07-24 Ibm Microprocessor with improved out of order support via register management with synchronization of multiple pipelines
US6260133B1 (en) * 1999-02-08 2001-07-10 Kabushiki Kaisha Toshiba Processor having operating instruction which uses operation units in different pipelines simultaneously
US7242414B1 (en) 1999-07-30 2007-07-10 Mips Technologies, Inc. Processor having a compare extension of an instruction set architecture
US6732259B1 (en) 1999-07-30 2004-05-04 Mips Technologies, Inc. Processor having a conditional branch extension of an instruction set architecture
US6178496B1 (en) * 1999-02-17 2001-01-23 Motorola, Inc. System for converting instructions, and method therefore
US6338133B1 (en) 1999-03-12 2002-01-08 International Business Machines Corporation Measured, allocation of speculative branch instructions to processor execution units
US7089404B1 (en) * 1999-06-14 2006-08-08 Transmeta Corporation Method and apparatus for enhancing scheduling in an advanced microprocessor
US6374345B1 (en) * 1999-07-22 2002-04-16 Advanced Micro Devices, Inc. Apparatus and method for handling tiny numbers using a super sticky bit in a microprocessor
US6697832B1 (en) 1999-07-30 2004-02-24 Mips Technologies, Inc. Floating-point processor with improved intermediate result handling
US6912559B1 (en) 1999-07-30 2005-06-28 Mips Technologies, Inc. System and method for improving the accuracy of reciprocal square root operations performed by a floating-point unit
US6714197B1 (en) 1999-07-30 2004-03-30 Mips Technologies, Inc. Processor having an arithmetic extension of an instruction set architecture
US6631392B1 (en) 1999-07-30 2003-10-07 Mips Technologies, Inc. Method and apparatus for predicting floating-point exceptions
US7346643B1 (en) 1999-07-30 2008-03-18 Mips Technologies, Inc. Processor with improved accuracy for multiply-add operations
US7089367B1 (en) * 1999-08-11 2006-08-08 Intel Corporation Reducing memory access latencies from a bus using pre-fetching and caching
US6438664B1 (en) 1999-10-27 2002-08-20 Advanced Micro Devices, Inc. Microcode patch device and method for patching microcode using match registers and patch routines
US6539467B1 (en) * 1999-11-15 2003-03-25 Texas Instruments Incorporated Microprocessor with non-aligned memory access
US6662361B1 (en) 2000-01-14 2003-12-09 International Business Machines Corporation Method, system, program, and data structures for transforming an instruction in a first bit architecture to an instruction in a second bit architecture
US6453405B1 (en) * 2000-02-18 2002-09-17 Texas Instruments Incorporated Microprocessor with non-aligned circular addressing
US6751724B1 (en) * 2000-04-19 2004-06-15 Motorola, Inc. Method and apparatus for instruction fetching
US6996596B1 (en) 2000-05-23 2006-02-07 Mips Technologies, Inc. Floating-point processor with operating mode having improved accuracy and high performance
US6735686B1 (en) * 2000-06-30 2004-05-11 Hitachi, Ltd. Data processing device including two instruction decoders for decoding branch instructions
US6633969B1 (en) 2000-08-11 2003-10-14 Lsi Logic Corporation Instruction translation system and method achieving single-cycle translation of variable-length MIPS16 instructions
US6804815B1 (en) * 2000-09-18 2004-10-12 Cisco Technology, Inc. Sequence control mechanism for enabling out of order context processing
US8058899B2 (en) 2000-10-06 2011-11-15 Martin Vorbach Logic cell array and bus system
US7149878B1 (en) 2000-10-30 2006-12-12 Mips Technologies, Inc. Changing instruction set architecture mode by comparison of current instruction execution address with boundary address register values
US6449431B1 (en) * 2001-07-16 2002-09-10 Non Typical Inc. Enclosure for wildlife surveillance system and security apparatus therefore
US7162621B2 (en) * 2001-02-21 2007-01-09 Mips Technologies, Inc. Virtual instruction expansion based on template and parameter selector information specifying sign-extension or concentration
US7711763B2 (en) 2001-02-21 2010-05-04 Mips Technologies, Inc. Microprocessor instructions for performing polynomial arithmetic operations
US7181484B2 (en) * 2001-02-21 2007-02-20 Mips Technologies, Inc. Extended-precision accumulation of multiplier output
US7599981B2 (en) * 2001-02-21 2009-10-06 Mips Technologies, Inc. Binary polynomial multiplier
US7444531B2 (en) 2001-03-05 2008-10-28 Pact Xpp Technologies Ag Methods and devices for treating and processing data
US9037807B2 (en) 2001-03-05 2015-05-19 Pact Xpp Technologies Ag Processor arrangement on a chip including data processing, memory, and interface elements
US7711926B2 (en) * 2001-04-18 2010-05-04 Mips Technologies, Inc. Mapping system and method for instruction set processing
US6804799B2 (en) * 2001-06-26 2004-10-12 Advanced Micro Devices, Inc. Using type bits to track storage of ECC and predecode bits in a level two cache
US7107439B2 (en) 2001-08-10 2006-09-12 Mips Technologies, Inc. System and method of controlling software decompression through exceptions
US7996827B2 (en) 2001-08-16 2011-08-09 Martin Vorbach Method for the translation of programs for reconfigurable architectures
US20030088758A1 (en) * 2001-11-08 2003-05-08 Matthew Becker Methods and systems for determining valid microprocessor instructions
CA2365375A1 (en) * 2001-12-18 2003-06-18 Ibm Canada Limited-Ibm Canada Limitee Optimizing source code for iterative execution
US8914590B2 (en) 2002-08-07 2014-12-16 Pact Xpp Technologies Ag Data processing method and device
JP3800533B2 (en) * 2002-06-28 2006-07-26 富士通株式会社 Program counter control method and processor
US7406587B1 (en) * 2002-07-31 2008-07-29 Silicon Graphics, Inc. Method and system for renaming registers in a microprocessor
US20040148497A1 (en) * 2003-01-27 2004-07-29 Ali Vahidsafa Method and apparatus for determining an early reifetch address of a mispredicted conditional branch instruction in an out of order multi-issue processor
US20040199749A1 (en) * 2003-04-03 2004-10-07 Robert Golla Method and apparatus to limit register file read ports in an out-of-order, multi-stranded processor
GB0320386D0 (en) * 2003-08-30 2003-10-01 Ibm A method, apparatus and computer program for executing a program
US7167989B2 (en) * 2003-10-14 2007-01-23 Intel Corporation Processor and methods to reduce power consumption of processor components
US7707389B2 (en) * 2003-10-31 2010-04-27 Mips Technologies, Inc. Multi-ISA instruction fetch unit for a processor, and applications thereof
US7246215B2 (en) * 2003-11-26 2007-07-17 Intel Corporation Systolic memory arrays
GB2410097B (en) * 2004-01-13 2006-11-01 Advanced Risc Mach Ltd A data processing apparatus and method for performing data processing operations on floating point data elements
JP2005276104A (en) * 2004-03-26 2005-10-06 Nec Electronics Corp Microcomputer
US7831642B1 (en) * 2004-09-30 2010-11-09 Symantec Operating Corporation Page cache management for a shared file
US7800620B2 (en) 2004-11-05 2010-09-21 Microsoft Corporation Optimizing automated shader program construction
US7733347B2 (en) * 2004-11-05 2010-06-08 Microsoft Corporation Automated construction of shader programs
JP2008530642A (en) * 2005-02-07 2008-08-07 ペーアーツェーテー イクスペーペー テクノロジーズ アクチエンゲゼルシャフト Low latency mass parallel data processor
WO2006114874A1 (en) * 2005-04-21 2006-11-02 Fujitsu Limited Processor device
JP4837305B2 (en) * 2005-05-10 2011-12-14 ルネサスエレクトロニクス株式会社 Microprocessor and control method of microprocessor
US8161252B1 (en) * 2005-08-01 2012-04-17 Nvidia Corporation Memory interface with dynamic selection among mirrored storage locations
US7373486B2 (en) * 2005-08-29 2008-05-13 P.A. Semi, Inc. Partially decoded register renamer
US7996662B2 (en) * 2005-11-17 2011-08-09 Apple Inc. Floating point status/control register encodings for speculative register field
US20080072015A1 (en) * 2006-09-18 2008-03-20 Julier Michael A Demand-based processing resource allocation
US7624251B2 (en) * 2006-11-01 2009-11-24 Apple Inc. Instructions for efficiently accessing unaligned partial vectors
US7620797B2 (en) * 2006-11-01 2009-11-17 Apple Inc. Instructions for efficiently accessing unaligned vectors
EP2106584A1 (en) * 2006-12-11 2009-10-07 Nxp B.V. Pipelined processor and compiler/scheduler for variable number branch delay slots
US7725690B2 (en) * 2007-02-13 2010-05-25 Advanced Micro Devices, Inc. Distributed dispatch with concurrent, out-of-order dispatch
JP5007860B2 (en) * 2007-04-17 2012-08-22 エヌイーシーコンピュータテクノ株式会社 Vector processing equipment
US7870350B1 (en) * 2007-06-07 2011-01-11 Nvidia Corporation Write buffer for read-write interlocks
US9710384B2 (en) * 2008-01-04 2017-07-18 Micron Technology, Inc. Microprocessor architecture having alternative memory access paths
US8561037B2 (en) * 2007-08-29 2013-10-15 Convey Computer Compiler for generating an executable comprising instructions for a plurality of different instruction sets
US8095735B2 (en) 2008-08-05 2012-01-10 Convey Computer Memory interleave for heterogeneous computing
US9015399B2 (en) 2007-08-20 2015-04-21 Convey Computer Multiple data channel memory module architecture
US7882325B2 (en) * 2007-12-21 2011-02-01 Intel Corporation Method and apparatus for a double width load using a single width load port
US7913067B2 (en) * 2008-02-20 2011-03-22 International Business Machines Corporation Method and system for overlapping execution of instructions through non-uniform execution pipelines in an in-order processor
US8806505B1 (en) * 2008-06-30 2014-08-12 Bank Of America Corporation Service and project request processing within a business enterprise
US8150902B2 (en) 2009-06-19 2012-04-03 Singular Computing Llc Processing with compact arithmetic processing element
US8423745B1 (en) 2009-11-16 2013-04-16 Convey Computer Systems and methods for mapping a neighborhood of data to general registers of a processing element
US10430190B2 (en) 2012-06-07 2019-10-01 Micron Technology, Inc. Systems and methods for selectively controlling multithreaded execution of executable code segments
US9336003B2 (en) * 2013-01-25 2016-05-10 Apple Inc. Multi-level dispatch for a superscalar processor
US9535744B2 (en) * 2013-06-29 2017-01-03 Intel Corporation Method and apparatus for continued retirement during commit of a speculative region of code
US9367317B2 (en) * 2013-07-03 2016-06-14 Intel Corporation Loop streaming detector for standard and complex instruction types
US10001993B2 (en) * 2013-08-08 2018-06-19 Linear Algebra Technologies Limited Variable-length instruction buffer management
US11768689B2 (en) 2013-08-08 2023-09-26 Movidius Limited Apparatus, systems, and methods for low power computational imaging
US9983990B1 (en) * 2013-11-21 2018-05-29 Altera Corporation Configurable storage circuits with embedded processing and control circuitry
US10616333B2 (en) * 2014-04-09 2020-04-07 Stmicroelectronics S.R.L. System for the management of out-of-order traffic in an interconnect network and corresponding method and integrated circuit
US9824058B2 (en) * 2014-11-14 2017-11-21 Cavium, Inc. Bypass FIFO for multiple virtual channels
US9658963B2 (en) * 2014-12-23 2017-05-23 Intel Corporation Speculative reads in buffered memory
US9858078B2 (en) 2015-06-02 2018-01-02 International Business Machines Corporation Speculative load data in byte-write capable register file and history buffer for a multi-slice microprocessor
US11275590B2 (en) * 2015-08-26 2022-03-15 Huawei Technologies Co., Ltd. Device and processing architecture for resolving execution pipeline dependencies without requiring no operation instructions in the instruction memory
US9825647B1 (en) * 2016-09-28 2017-11-21 Intel Corporation Method and apparatus for decompression acceleration in multi-cycle decoder based platforms
KR102636925B1 (en) 2017-05-19 2024-02-16 모비디어스 리미티드 Methods, systems, and apparatus for reducing memory latency when fetching pixel kernels
US11126663B2 (en) 2017-05-25 2021-09-21 Intel Corporation Method and apparatus for energy efficient decompression using ordered tokens
US11086625B2 (en) 2019-09-10 2021-08-10 Apple Inc. Compression assist instructions
CN111459549B (en) * 2020-04-07 2022-11-01 上海兆芯集成电路有限公司 Microprocessor with highly advanced branch predictor
CN117348933B (en) * 2023-12-05 2024-02-06 睿思芯科(深圳)技术有限公司 Processor and computer system

Citations (39)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US3781808A (en) * 1972-10-17 1973-12-25 Ibm Virtual memory system
US4044338A (en) * 1975-02-10 1977-08-23 Siemens Aktiengesellschaft Associative memory having separately associable zones
US4161784A (en) * 1978-01-05 1979-07-17 Honeywell Information Systems, Inc. Microprogrammable floating point arithmetic unit capable of performing arithmetic operations on long and short operands
US4736288A (en) * 1983-12-19 1988-04-05 Hitachi, Ltd. Data processing device
US4807115A (en) * 1983-10-07 1989-02-21 Cornell Research Foundation, Inc. Instruction issuing mechanism for processors with multiple functional units
US4926322A (en) * 1987-08-03 1990-05-15 Compag Computer Corporation Software emulation of bank-switched memory using a virtual DOS monitor and paged memory management
US4928223A (en) * 1982-10-06 1990-05-22 Fairchild Semiconductor Corporation Floating point microprocessor with directable two level microinstructions
US4940908A (en) * 1989-04-27 1990-07-10 Advanced Micro Devices, Inc. Method and apparatus for reducing critical speed path delays
EP0381471A2 (en) * 1989-02-03 1990-08-08 Digital Equipment Corporation Method and apparatus for preprocessing multiple instructions in a pipeline processor
US4992934A (en) * 1986-12-15 1991-02-12 United Technologies Corporation Reduced instruction set computing apparatus and methods
US5053631A (en) * 1990-04-02 1991-10-01 Advanced Micro Devices, Inc. Pipelined floating point processing unit
US5056006A (en) * 1988-09-12 1991-10-08 General Electric Company Parallel processor with single program storage and sequencer and simultaneous instruction processing
US5058048A (en) * 1990-04-02 1991-10-15 Advanced Micro Devices, Inc. Normalizing pipelined floating point processing unit
US5077692A (en) * 1990-03-05 1991-12-31 Advanced Micro Devices, Inc. Information storage device with batch select capability
US5095458A (en) * 1990-04-02 1992-03-10 Advanced Micro Devices, Inc. Radix 4 carry lookahead tree and redundant cell therefor
US5128888A (en) * 1990-04-02 1992-07-07 Advanced Micro Devices, Inc. Arithmetic unit having multiple accumulators
US5128891A (en) * 1990-04-02 1992-07-07 Advanced Micro Devices, Inc. High speed divider with square root capability
US5129067A (en) * 1989-06-06 1992-07-07 Advanced Micro Devices, Inc. Multiple instruction decoder for minimizing register port requirements
US5136697A (en) * 1989-06-06 1992-08-04 Advanced Micro Devices, Inc. System for reducing delay for execution subsequent to correctly predicted branch instruction using fetch information stored with each block of instructions in cache
US5155820A (en) * 1989-02-21 1992-10-13 Gibson Glenn A Instruction format with designations for operand lengths of byte, half word, word, or double word encoded in address bits
US5155816A (en) * 1989-02-10 1992-10-13 Intel Corporation Pipelined apparatus and method for controlled loading of floating point data in a microprocessor
US5155817A (en) * 1988-04-01 1992-10-13 Kabushiki Kaisha Toshiba Microprocessor
US5157780A (en) * 1990-06-12 1992-10-20 Advanced Micro Devices, Inc. Master-slave checking system
WO1993001546A1 (en) * 1991-07-08 1993-01-21 Seiko Epson Corporation Extensible risc microprocessor architecture
US5185868A (en) * 1990-01-16 1993-02-09 Advanced Micro Devices, Inc. Apparatus having hierarchically arranged decoders concurrently decoding instructions and shifting instructions not ready for execution to vacant decoders higher in the hierarchy
EP0533337A1 (en) * 1991-09-20 1993-03-24 Advanced Micro Devices, Inc. Apparatus and method for resolving dependencies among a plurality of instructions within a storage device
US5206828A (en) * 1990-04-02 1993-04-27 Advanced Micro Devices, Inc. Special carry save adder for high speed iterative division
US5222230A (en) * 1988-01-29 1993-06-22 Texas Instruments Incorporated Circuitry for transferring data from a data bus and temporary register into a plurality of input registers on clock edges
US5226126A (en) * 1989-02-24 1993-07-06 Nexgen Microsystems Processor having plurality of functional units for orderly retiring outstanding operations based upon its associated tags
US5226130A (en) * 1990-02-26 1993-07-06 Nexgen Microsystems Method and apparatus for store-into-instruction-stream detection and maintaining branch prediction cache consistency
US5237700A (en) * 1990-03-21 1993-08-17 Advanced Micro Devices, Inc. Exception handling processor for handling first and second level exceptions with reduced exception latency
US5247644A (en) * 1991-02-06 1993-09-21 Advanced Micro Devices, Inc. Processing system with improved sequential memory accessing
US5251306A (en) * 1990-01-16 1993-10-05 Advanced Micro Devices, Inc. Apparatus for controlling execution of a program in a computing device
US5390355A (en) * 1989-05-24 1995-02-14 Tandem Computers Incorporated Computer architecture capable of concurrent issuance and execution of general purpose multiple instructions
GB2281422A (en) * 1993-08-26 1995-03-01 Intel Corp Processor ordering consistency for a processor performing out-of-order instruction execution
US5454117A (en) * 1993-08-25 1995-09-26 Nexgen, Inc. Configurable branch prediction for a processor performing speculative execution
US5465373A (en) * 1993-01-08 1995-11-07 International Business Machines Corporation Method and system for single cycle dispatch of multiple instructions in a superscalar processor system
US5467473A (en) * 1993-01-08 1995-11-14 International Business Machines Corporation Out of order instruction load and store comparison
US5471593A (en) * 1989-12-11 1995-11-28 Branigin; Michael H. Computer processor with an efficient means of executing many instructions simultaneously

Family Cites Families (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4713750A (en) * 1983-03-31 1987-12-15 Fairchild Camera & Instrument Corporation Microprocessor with compact mapped programmable logic array
US5222244A (en) * 1990-12-20 1993-06-22 Intel Corporation Method of modifying a microinstruction with operands specified by an instruction held in an alias register
DE69231011T2 (en) * 1991-02-08 2000-09-28 Fujitsu Ltd Cache memory for processing command data and data processor with the same
US5438668A (en) * 1992-03-31 1995-08-01 Seiko Epson Corporation System and method for extraction, alignment and decoding of CISC instructions into a nano-instruction bucket for execution by a RISC computer
US5337415A (en) * 1992-12-04 1994-08-09 Hewlett-Packard Company Predecoding instructions for supercalar dependency indicating simultaneous execution for increased operating frequency
US5500943A (en) * 1993-11-02 1996-03-19 Motorola, Inc. Data processor with rename buffer and FIFO buffer for in-order instruction completion

Patent Citations (39)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US3781808A (en) * 1972-10-17 1973-12-25 Ibm Virtual memory system
US4044338A (en) * 1975-02-10 1977-08-23 Siemens Aktiengesellschaft Associative memory having separately associable zones
US4161784A (en) * 1978-01-05 1979-07-17 Honeywell Information Systems, Inc. Microprogrammable floating point arithmetic unit capable of performing arithmetic operations on long and short operands
US4928223A (en) * 1982-10-06 1990-05-22 Fairchild Semiconductor Corporation Floating point microprocessor with directable two level microinstructions
US4807115A (en) * 1983-10-07 1989-02-21 Cornell Research Foundation, Inc. Instruction issuing mechanism for processors with multiple functional units
US4736288A (en) * 1983-12-19 1988-04-05 Hitachi, Ltd. Data processing device
US4992934A (en) * 1986-12-15 1991-02-12 United Technologies Corporation Reduced instruction set computing apparatus and methods
US4926322A (en) * 1987-08-03 1990-05-15 Compag Computer Corporation Software emulation of bank-switched memory using a virtual DOS monitor and paged memory management
US5222230A (en) * 1988-01-29 1993-06-22 Texas Instruments Incorporated Circuitry for transferring data from a data bus and temporary register into a plurality of input registers on clock edges
US5155817A (en) * 1988-04-01 1992-10-13 Kabushiki Kaisha Toshiba Microprocessor
US5056006A (en) * 1988-09-12 1991-10-08 General Electric Company Parallel processor with single program storage and sequencer and simultaneous instruction processing
EP0381471A2 (en) * 1989-02-03 1990-08-08 Digital Equipment Corporation Method and apparatus for preprocessing multiple instructions in a pipeline processor
US5155816A (en) * 1989-02-10 1992-10-13 Intel Corporation Pipelined apparatus and method for controlled loading of floating point data in a microprocessor
US5155820A (en) * 1989-02-21 1992-10-13 Gibson Glenn A Instruction format with designations for operand lengths of byte, half word, word, or double word encoded in address bits
US5226126A (en) * 1989-02-24 1993-07-06 Nexgen Microsystems Processor having plurality of functional units for orderly retiring outstanding operations based upon its associated tags
US4940908A (en) * 1989-04-27 1990-07-10 Advanced Micro Devices, Inc. Method and apparatus for reducing critical speed path delays
US5390355A (en) * 1989-05-24 1995-02-14 Tandem Computers Incorporated Computer architecture capable of concurrent issuance and execution of general purpose multiple instructions
US5129067A (en) * 1989-06-06 1992-07-07 Advanced Micro Devices, Inc. Multiple instruction decoder for minimizing register port requirements
US5136697A (en) * 1989-06-06 1992-08-04 Advanced Micro Devices, Inc. System for reducing delay for execution subsequent to correctly predicted branch instruction using fetch information stored with each block of instructions in cache
US5471593A (en) * 1989-12-11 1995-11-28 Branigin; Michael H. Computer processor with an efficient means of executing many instructions simultaneously
US5251306A (en) * 1990-01-16 1993-10-05 Advanced Micro Devices, Inc. Apparatus for controlling execution of a program in a computing device
US5185868A (en) * 1990-01-16 1993-02-09 Advanced Micro Devices, Inc. Apparatus having hierarchically arranged decoders concurrently decoding instructions and shifting instructions not ready for execution to vacant decoders higher in the hierarchy
US5226130A (en) * 1990-02-26 1993-07-06 Nexgen Microsystems Method and apparatus for store-into-instruction-stream detection and maintaining branch prediction cache consistency
US5077692A (en) * 1990-03-05 1991-12-31 Advanced Micro Devices, Inc. Information storage device with batch select capability
US5237700A (en) * 1990-03-21 1993-08-17 Advanced Micro Devices, Inc. Exception handling processor for handling first and second level exceptions with reduced exception latency
US5128891A (en) * 1990-04-02 1992-07-07 Advanced Micro Devices, Inc. High speed divider with square root capability
US5095458A (en) * 1990-04-02 1992-03-10 Advanced Micro Devices, Inc. Radix 4 carry lookahead tree and redundant cell therefor
US5053631A (en) * 1990-04-02 1991-10-01 Advanced Micro Devices, Inc. Pipelined floating point processing unit
US5058048A (en) * 1990-04-02 1991-10-15 Advanced Micro Devices, Inc. Normalizing pipelined floating point processing unit
US5206828A (en) * 1990-04-02 1993-04-27 Advanced Micro Devices, Inc. Special carry save adder for high speed iterative division
US5128888A (en) * 1990-04-02 1992-07-07 Advanced Micro Devices, Inc. Arithmetic unit having multiple accumulators
US5157780A (en) * 1990-06-12 1992-10-20 Advanced Micro Devices, Inc. Master-slave checking system
US5247644A (en) * 1991-02-06 1993-09-21 Advanced Micro Devices, Inc. Processing system with improved sequential memory accessing
WO1993001546A1 (en) * 1991-07-08 1993-01-21 Seiko Epson Corporation Extensible risc microprocessor architecture
EP0533337A1 (en) * 1991-09-20 1993-03-24 Advanced Micro Devices, Inc. Apparatus and method for resolving dependencies among a plurality of instructions within a storage device
US5465373A (en) * 1993-01-08 1995-11-07 International Business Machines Corporation Method and system for single cycle dispatch of multiple instructions in a superscalar processor system
US5467473A (en) * 1993-01-08 1995-11-14 International Business Machines Corporation Out of order instruction load and store comparison
US5454117A (en) * 1993-08-25 1995-09-26 Nexgen, Inc. Configurable branch prediction for a processor performing speculative execution
GB2281422A (en) * 1993-08-26 1995-03-01 Intel Corp Processor ordering consistency for a processor performing out-of-order instruction execution

Non-Patent Citations (21)

* Cited by examiner, † Cited by third party
Title
Brian Case, "AMD Unveils First Superscalar 29K Core", Microprocessor Report, Oct. 24, 1994, pp. 23-26.
Brian Case, AMD Unveils First Superscalar 29K Core , Microprocessor Report, Oct. 24, 1994, pp. 23 26. *
Bruce D. Lightner and Gene Hill, "The Metaflow Lightning Chipset", IEEE Proceedings ConpCom Spring '91, Feb., 1991, pp. 13-18.
Bruce D. Lightner and Gene Hill, The Metaflow Lightning Chipset , IEEE Proceedings ConpCom Spring 91, Feb., 1991, pp. 13 18. *
D. W. Anderson, F. J. Sparacio, F. M. Tomasulo, "The IBM System/360 Model 91: Machine Philosophy and Instruction-handling1, Chapter 18, Part 2 Regions of Computer Space, Section 3 Concurrency: Single-Processor System", IBM Journal, vol. 11, Jan. 1967, pp. 276-292.
D. W. Anderson, F. J. Sparacio, F. M. Tomasulo, The IBM System/360 Model 91: Machine Philosophy and Instruction handling 1 , Chapter 18, Part 2 Regions of Computer Space, Section 3 Concurrency: Single Processor System , IBM Journal, vol. 11, Jan. 1967, pp. 276 292. *
Gurdindar S. Sohi, "Instruction Issue Logic for High-Performance Interruptible, Multiple Functional Unit, Pipelined Computers", IEEE Transactions on Computers, vol. 39, No. 3, 0©1990, pp. 349-359.
Gurdindar S. Sohi, Instruction Issue Logic for High Performance Interruptible, Multiple Functional Unit, Pipelined Computers , IEEE Transactions on Computers, vol. 39, No. 3, 0 1990, pp. 349 359. *
Johnson, Mike, Superscalar Microprocessor Design, Prentice Hall, 1991 (Group 2300 Library: TK 7895 .M5 J64 1991). *
Michael Slater, "AMD's K5 Designed to Outrun Pentium", Microprocessor Report, Oct. 24, 1994, pp. 1, 6-11.
Michael Slater, AMD s K5 Designed to Outrun Pentium , Microprocessor Report, Oct. 24, 1994, pp. 1, 6 11. *
R. M. Tomasulo, "An Efficient Algorithm for Exploiting Multiple Arithmetic Units1, Part 2 Regions of Computer Space, Section 3 Concurrency: Single-Processor System", IBM Journal, vol. 11, Jan. 1967, pp. 293-305.
R. M. Tomasulo, An Efficient Algorithm for Exploiting Multiple Arithmetic Units 1 , Part 2 Regions of Computer Space, Section 3 Concurrency: Single Processor System , IBM Journal, vol. 11, Jan. 1967, pp. 293 305. *
R.M. Tomasulo, "An Efficient Algorithm for Exploiting Multiple Arithmetic Units", IBM Journal, Jan. 1967, vol. 11, pp. 25-32.
R.M. Tomasulo, An Efficient Algorithm for Exploiting Multiple Arithmetic Units , IBM Journal, Jan. 1967, vol. 11, pp. 25 32. *
Toyohiko Yoshida, "The Approach to Multiple Instruction Execution in the GMICRO/400 Processor", ©1991, pp. 185-195.
Toyohiko Yoshida, The Approach to Multiple Instruction Execution in the GMICRO/400 Processor , 1991, pp. 185 195. *
U.S. Patent Application Serial No. 07/929,770 filed Apr. 12, 1992 entitled "Instruction Decoder And Superscalar Processor Utilizing Same"--David B. Witt and William M. Johnson.
U.S. Patent Application Serial No. 07/929,770 filed Apr. 12, 1992 entitled Instruction Decoder And Superscalar Processor Utilizing Same David B. Witt and William M. Johnson. *
Val Popescu, et al., "The Metaflow Architecture", IEEE Micro, Jun. 1991, vol. 11, No. 3, pp. 10-13, 63-73.
Val Popescu, et al., The Metaflow Architecture , IEEE Micro, Jun. 1991, vol. 11, No. 3, pp. 10 13, 63 73. *

Cited By (390)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6370623B1 (en) * 1988-12-28 2002-04-09 Philips Electronics North America Corporation Multiport register file to accommodate data of differing lengths
US7487333B2 (en) 1991-07-08 2009-02-03 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6948052B2 (en) 1991-07-08 2005-09-20 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US7941636B2 (en) 1991-07-08 2011-05-10 Intellectual Venture Funding Llc RISC microprocessor architecture implementing multiple typed register sets
US20040093483A1 (en) * 1991-07-08 2004-05-13 Seiko Epson Corporation High performance, superscalar-based computer system with out-of-order instruction execution
US20030056086A1 (en) * 1991-07-08 2003-03-20 Le Trong Nguyen High-performance, superscalar-based computer system with out-of-order instruction execution
US20030079113A1 (en) * 1991-07-08 2003-04-24 Nguyen Le Trong High-performance, superscalar-based computer system with out-of-order instruction execution
US6647485B2 (en) 1991-07-08 2003-11-11 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6959375B2 (en) 1991-07-08 2005-10-25 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6128723A (en) * 1991-07-08 2000-10-03 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US20040054872A1 (en) * 1991-07-08 2004-03-18 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order intstruction execution
US6934829B2 (en) 1991-07-08 2005-08-23 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6915412B2 (en) 1991-07-08 2005-07-05 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US5961629A (en) * 1991-07-08 1999-10-05 Seiko Epson Corporation High performance, superscalar-based computer system with out-of-order instruction execution
US6272619B1 (en) 1991-07-08 2001-08-07 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6941447B2 (en) 1991-07-08 2005-09-06 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US7162610B2 (en) 1991-07-08 2007-01-09 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6986024B2 (en) 1991-07-08 2006-01-10 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US7685402B2 (en) 1991-07-08 2010-03-23 Sanjiv Garg RISC microprocessor architecture implementing multiple typed register sets
US7721070B2 (en) 1991-07-08 2010-05-18 Le Trong Nguyen High-performance, superscalar-based computer system with out-of-order instruction execution
US7739482B2 (en) 1991-07-08 2010-06-15 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US20040093485A1 (en) * 1991-07-08 2004-05-13 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6256720B1 (en) 1991-07-08 2001-07-03 Seiko Epson Corporation High performance, superscalar-based computer system with out-of-order instruction execution
US6101594A (en) * 1991-07-08 2000-08-08 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6038654A (en) * 1991-07-08 2000-03-14 Seiko Epson Corporation High performance, superscalar-based computer system with out-of-order instruction execution
US6092181A (en) * 1991-07-08 2000-07-18 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US20040093482A1 (en) * 1991-07-08 2004-05-13 Seiko Epson Corporation High-performance, superscalar-based computer system with out-of-order instruction execution
US6697936B2 (en) 1992-03-05 2004-02-24 Seiko Epson Corporation Register file backup queue
US20050108510A1 (en) * 1992-03-05 2005-05-19 Seiko Epson Corporation Register file backup queue
US6839832B2 (en) 1992-03-05 2005-01-04 Seiko Epson Corporation Register file backup queue
US5881216A (en) * 1992-03-05 1999-03-09 Seiko Epson Corporation Register file backup queue
US7657728B2 (en) 1992-03-05 2010-02-02 Seiko Epson Corporation Register file backup queue
US20090024841A1 (en) * 1992-03-05 2009-01-22 Seiko Epson Corporation Register File Backup Queue
US6374347B1 (en) 1992-03-05 2002-04-16 Seiko Epson Corporation Register file backup queue
US7395417B2 (en) 1992-03-05 2008-07-01 Seiko Epson Corporation Register file backup queue
US7802074B2 (en) 1992-03-31 2010-09-21 Sanjiv Garg Superscalar RISC instruction scheduling
US7664935B2 (en) 1992-03-31 2010-02-16 Brett Coon System and method for translating non-native instructions to native instructions for processing on a host processor
US6954847B2 (en) 1992-03-31 2005-10-11 Transmeta Corporation System and method for translating non-native instructions to native instructions for processing on a host processor
US6263423B1 (en) 1992-03-31 2001-07-17 Seiko Epson Corporation System and method for translating non-native instructions to native instructions for processing on a host processor
US20080162880A1 (en) * 1992-03-31 2008-07-03 Transmeta Corporation System and Method for Translating Non-Native Instructions to Native Instructions for Processing on a Host Processor
US5983334A (en) * 1992-03-31 1999-11-09 Seiko Epson Corporation Superscalar microprocessor for out-of-order and concurrently executing at least two RISC instructions translating from in-order CISC instructions
US7343473B2 (en) 1992-03-31 2008-03-11 Transmeta Corporation System and method for translating non-native instructions to native instructions for processing on a host processor
US20030084270A1 (en) * 1992-03-31 2003-05-01 Transmeta Corp. System and method for translating non-native instructions to native instructions for processing on a host processor
US20020178347A1 (en) * 1992-05-01 2002-11-28 Johannes Wang System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US20040186983A1 (en) * 1992-05-01 2004-09-23 Seiko Epson Corporation System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US7958337B2 (en) 1992-05-01 2011-06-07 Seiko Epson Corporation System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US6412064B1 (en) 1992-05-01 2002-06-25 Seiko Epson Corporation System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US6920548B2 (en) 1992-05-01 2005-07-19 Seiko Epson Corporation System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US7934078B2 (en) 1992-05-01 2011-04-26 Seiko Epson Corporation System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US6131157A (en) * 1992-05-01 2000-10-10 Seiko Epson Corporation System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US20070106880A1 (en) * 1992-05-01 2007-05-10 Johannes Wang System and method for retiring approximately simultaneously a group of instructions in a superscalar microprocessor
US20050283591A1 (en) * 1992-09-29 2005-12-22 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US8019975B2 (en) 1992-09-29 2011-09-13 Seiko-Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US7844797B2 (en) 1992-09-29 2010-11-30 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US6965987B2 (en) 1992-09-29 2005-11-15 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US7000097B2 (en) 1992-09-29 2006-02-14 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US20040128487A1 (en) * 1992-09-29 2004-07-01 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US6230254B1 (en) 1992-09-29 2001-05-08 Seiko Epson Corporation System and method for handling load and/or store operators in a superscalar microprocessor
US7861069B2 (en) 1992-09-29 2010-12-28 Seiko-Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US6434693B1 (en) 1992-09-29 2002-08-13 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US20090217001A1 (en) * 1992-09-29 2009-08-27 Seiko Epson Corporation System and Method for Handling Load and/or Store Operations in a Superscalar Microprocessor
US6735685B1 (en) 1992-09-29 2004-05-11 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US20070101106A1 (en) * 1992-09-29 2007-05-03 Senter Cheryl D System and method for handling load and/or store operations in a superscalar microprocessor
US6957320B2 (en) 1992-09-29 2005-10-18 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US20030056089A1 (en) * 1992-09-29 2003-03-20 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US7447876B2 (en) 1992-09-29 2008-11-04 Seiko Epson Corporation System and method for handling load and/or store operations in a superscalar microprocessor
US6092176A (en) * 1992-12-31 2000-07-18 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US8074052B2 (en) 1992-12-31 2011-12-06 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US20040199746A1 (en) * 1992-12-31 2004-10-07 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US7043624B2 (en) 1992-12-31 2006-05-09 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US6757808B2 (en) 1992-12-31 2004-06-29 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US20060123218A1 (en) * 1992-12-31 2006-06-08 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US7979678B2 (en) 1992-12-31 2011-07-12 Seiko Epson Corporation System and method for register renaming
US5896542A (en) * 1992-12-31 1999-04-20 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US7430651B2 (en) 1992-12-31 2008-09-30 Seiko-Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US6360309B1 (en) 1992-12-31 2002-03-19 Seiko Epson Corporation System and method for assigning tags to control instruction processing in a superscalar processor
US5796973A (en) * 1993-10-29 1998-08-18 Advanced Micro Devices, Inc. Method and apparatus for decoding one or more complex instructions into concurrently dispatched simple instructions
US6189087B1 (en) 1993-10-29 2001-02-13 Advanced Micro Devices, Inc. Superscalar instruction decoder including an instruction queue
US5721855A (en) * 1994-03-01 1998-02-24 Intel Corporation Method for pipeline processing of instructions by controlling access to a reorder buffer using a register file outside the reorder buffer
US6035386A (en) * 1994-06-01 2000-03-07 Advanced Micro Devices, Inc. Program counter update mechanism
US5764938A (en) * 1994-06-01 1998-06-09 Advanced Micro Devices, Inc. Resynchronization of a superscalar processor
US6351801B1 (en) 1994-06-01 2002-02-26 Advanced Micro Devices, Inc. Program counter update mechanism
US5799162A (en) * 1994-06-01 1998-08-25 Advanced Micro Devices, Inc. Program counter update mechanism
US6195745B1 (en) * 1994-11-15 2001-02-27 Advanced Micro Devices, Inc. Pipeline throughput via parallel out-of-order execution of adds and moves in a supplemental integer execution unit
US9389858B2 (en) 1994-12-02 2016-07-12 Intel Corporation Orderly storing of corresponding packed bytes from first and second source registers in result register
US8601246B2 (en) 1994-12-02 2013-12-03 Intel Corporation Execution of instruction with element size control bit to interleavingly store half packed data elements of source registers in same size destination register
US9015453B2 (en) 1994-12-02 2015-04-21 Intel Corporation Packing odd bytes from two source registers of packed data
US20110093682A1 (en) * 1994-12-02 2011-04-21 Alexander Peleg Method and apparatus for packing data
US9116687B2 (en) 1994-12-02 2015-08-25 Intel Corporation Packing in destination register half of each element with saturation from two source packed data registers
US20110219214A1 (en) * 1994-12-02 2011-09-08 Alexander Peleg Microprocessor having novel operations
US8793475B2 (en) 1994-12-02 2014-07-29 Intel Corporation Method and apparatus for unpacking and moving packed data
US20030131219A1 (en) * 1994-12-02 2003-07-10 Alexander Peleg Method and apparatus for unpacking packed data
US7966482B2 (en) 1994-12-02 2011-06-21 Intel Corporation Interleaving saturated lower half of data elements from two source registers of packed data
US8190867B2 (en) 1994-12-02 2012-05-29 Intel Corporation Packing two packed signed data in registers with saturation
US9141387B2 (en) 1994-12-02 2015-09-22 Intel Corporation Processor executing unpack and pack instructions specifying two source packed data operands and saturation
US8495346B2 (en) 1994-12-02 2013-07-23 Intel Corporation Processor executing pack and unpack instructions
US20060236076A1 (en) * 1994-12-02 2006-10-19 Alexander Peleg Method and apparatus for packing data
US9182983B2 (en) 1994-12-02 2015-11-10 Intel Corporation Executing unpack instruction and pack instruction with saturation on packed data elements from two source operand registers
US9223572B2 (en) 1994-12-02 2015-12-29 Intel Corporation Interleaving half of packed data elements of size specified in instruction and stored in two source registers
US8639914B2 (en) 1994-12-02 2014-01-28 Intel Corporation Packing signed word elements from two source registers to saturated signed byte elements in destination register
US8838946B2 (en) 1994-12-02 2014-09-16 Intel Corporation Packing lower half bits of signed data elements in two source registers in a destination register with saturation
US9361100B2 (en) 1994-12-02 2016-06-07 Intel Corporation Packing saturated lower 8-bit elements from two source registers of packed 16-bit elements
US8521994B2 (en) 1994-12-02 2013-08-27 Intel Corporation Interleaving corresponding data elements from part of two source registers to destination register in processor operable to perform saturation
US5864691A (en) * 1995-02-02 1999-01-26 Ricoh Company, Ltd. Central processing unit with a selector that bypasses circuits where processing is not required
US5768554A (en) * 1995-02-02 1998-06-16 Ricoh Company, Ltd. Central processing unit
US6012141A (en) * 1995-04-28 2000-01-04 Hyundai Electronics America Apparatus for detecting and executing traps in a superscalar processor
US5867684A (en) * 1995-09-11 1999-02-02 International Business Machines Corporation Method and processor that permit concurrent execution of a store multiple instruction and a dependent instruction
US5748516A (en) * 1995-09-26 1998-05-05 Advanced Micro Devices, Inc. Floating point processing unit with forced arithmetic results
US5761105A (en) * 1995-09-26 1998-06-02 Advanced Micro Devices, Inc. Reservation station including addressable constant store for a floating point processing unit
US6122721A (en) * 1995-09-26 2000-09-19 Advanced Micro Devices, Inc. Reservation station for a floating point processing unit
US5878266A (en) * 1995-09-26 1999-03-02 Advanced Micro Devices, Inc. Reservation station for a floating point processing unit
US6792523B1 (en) 1995-12-19 2004-09-14 Intel Corporation Processor with instructions that operate on different data types stored in the same single logical register file
US20040181649A1 (en) * 1995-12-19 2004-09-16 David Bistry Emptying packed data state during execution of packed data instructions
US5857096A (en) * 1995-12-19 1999-01-05 Intel Corporation Microarchitecture for implementing an instruction to clear the tags of a stack reference register file
US5852726A (en) * 1995-12-19 1998-12-22 Intel Corporation Method and apparatus for executing two types of instructions that specify registers of a shared logical register file in a stack and a non-stack referenced manner
US6170997B1 (en) 1995-12-19 2001-01-09 Intel Corporation Method for executing instructions that operate on different data types stored in the same single logical register file
US6266686B1 (en) 1995-12-19 2001-07-24 Intel Corporation Emptying packed data state during execution of packed data instructions
US7373490B2 (en) 1995-12-19 2008-05-13 Intel Corporation Emptying packed data state during execution of packed data instructions
US5940859A (en) * 1995-12-19 1999-08-17 Intel Corporation Emptying packed data state during execution of packed data instructions
US20050038977A1 (en) * 1995-12-19 2005-02-17 Glew Andrew F. Processor with instructions that operate on different data types stored in the same single logical register file
US7149882B2 (en) 1995-12-19 2006-12-12 Intel Corporation Processor with instructions that operate on different data types stored in the same single logical register file
US6751725B2 (en) 1995-12-19 2004-06-15 Intel Corporation Methods and apparatuses to clear state for operation of a stack
US6249862B1 (en) 1996-05-17 2001-06-19 Advanced Micro Devices, Inc. Dependency table for reducing dependency checking hardware
US6209084B1 (en) 1996-05-17 2001-03-27 Advanced Micro Devices, Inc. Dependency table for reducing dependency checking hardware
US6108769A (en) * 1996-05-17 2000-08-22 Advanced Micro Devices, Inc. Dependency table for reducing dependency checking hardware
US6189089B1 (en) * 1996-07-24 2001-02-13 Advanced Micro Devices, Inc. Apparatus and method for retiring instructions in excess of the number of accessible write ports
US5903740A (en) * 1996-07-24 1999-05-11 Advanced Micro Devices, Inc. Apparatus and method for retiring instructions in excess of the number of accessible write ports
US5915110A (en) * 1996-07-26 1999-06-22 Advanced Micro Devices, Inc. Branch misprediction recovery in a reorder buffer having a future file
US5946468A (en) * 1996-07-26 1999-08-31 Advanced Micro Devices, Inc. Reorder buffer having an improved future file for storing speculative instruction execution results
US6175906B1 (en) 1996-12-06 2001-01-16 Advanced Micro Devices, Inc. Mechanism for fast revalidation of virtual tags
US5881306A (en) * 1996-12-17 1999-03-09 International Business Machines Corporation Instruction fetch bandwidth analysis
US5881307A (en) * 1997-02-24 1999-03-09 Samsung Electronics Co., Ltd. Deferred store data read with simple anti-dependency pipeline inter-lock control in superscalar processor
US6076146A (en) * 1997-03-12 2000-06-13 Advanced Micro Devices, Inc. Cache holding register for delayed update of a cache line into an instruction cache
US5983321A (en) * 1997-03-12 1999-11-09 Advanced Micro Devices, Inc. Cache holding register for receiving instruction packets and for providing the instruction packets to a predecode unit and instruction cache
US5887185A (en) * 1997-03-19 1999-03-23 Advanced Micro Devices, Inc. Interface for coupling a floating point unit to a reorder buffer
US5828873A (en) * 1997-03-19 1998-10-27 Advanced Micro Devices, Inc. Assembly queue for a floating point unit
US5887161A (en) * 1997-03-31 1999-03-23 International Business Machines Corporation Issuing instructions in a processor supporting out-of-order execution
US5987235A (en) * 1997-04-04 1999-11-16 Advanced Micro Devices, Inc. Method and apparatus for predecoding variable byte length instructions for fast scanning of instructions
US5974535A (en) * 1997-05-09 1999-10-26 International Business Machines Corporation Method and system in data processing system of permitting concurrent processing of instructions of a particular type
US5845101A (en) * 1997-05-13 1998-12-01 Advanced Micro Devices, Inc. Prefetch buffer for storing instructions prior to placing the instructions in an instruction cache
US6367006B1 (en) 1997-05-13 2002-04-02 Advanced Micro Devices, Inc. Predecode buffer including buffer pointer indicating another buffer for predecoding
US6122729A (en) * 1997-05-13 2000-09-19 Advanced Micro Devices, Inc. Prefetch buffer which stores a pointer indicating an initial predecode position
US5940602A (en) * 1997-06-11 1999-08-17 Advanced Micro Devices, Inc. Method and apparatus for predecoding variable byte length instructions for scanning of a number of RISC operations
US5933626A (en) * 1997-06-12 1999-08-03 Advanced Micro Devices, Inc. Apparatus and method for tracing microprocessor instructions
US5884070A (en) * 1997-06-25 1999-03-16 Sun Microsystems, Inc. Method for processing single precision arithmetic operations in system where two single precision registers are aliased to one double precision register
US6094719A (en) * 1997-06-25 2000-07-25 Sun Microsystems, Inc. Reducing data dependent conflicts by converting single precision instructions into microinstructions using renamed phantom registers in a processor having double precision registers
US6052775A (en) * 1997-06-25 2000-04-18 Sun Microsystems, Inc. Method for non-intrusive cache fills and handling of load misses
US5987259A (en) * 1997-06-30 1999-11-16 Sun Microsystems, Inc. Functional unit switching for the allocation of registers
US5978901A (en) * 1997-08-21 1999-11-02 Advanced Micro Devices, Inc. Floating point and multimedia unit with data type reclassification capability
US6289437B1 (en) * 1997-08-27 2001-09-11 International Business Machines Corporation Data processing system and method for implementing an efficient out-of-order issue mechanism
US6014739A (en) * 1997-10-27 2000-01-11 Advanced Micro Devices, Inc. Increasing general registers in X86 processors
US6032252A (en) * 1997-10-28 2000-02-29 Advanced Micro Devices, Inc. Apparatus and method for efficient loop control in a superscalar microprocessor
US5974542A (en) * 1997-10-30 1999-10-26 Advanced Micro Devices, Inc. Branch prediction unit which approximates a larger number of branch predictions using a smaller number of branch predictions and an alternate target indication
US6230259B1 (en) 1997-10-31 2001-05-08 Advanced Micro Devices, Inc. Transparent extended state save
US6157996A (en) * 1997-11-13 2000-12-05 Advanced Micro Devices, Inc. Processor programably configurable to execute enhanced variable byte length instructions including predicated execution, three operand addressing, and increased register space
US6367001B1 (en) 1997-11-17 2002-04-02 Advanced Micro Devices, Inc. Processor including efficient fetch mechanism for L0 and L1 caches
US6199154B1 (en) 1997-11-17 2001-03-06 Advanced Micro Devices, Inc. Selecting cache to fetch in multi-level cache system based on fetch address source and pre-fetching additional data to the cache for future access
US6505292B1 (en) 1997-11-17 2003-01-07 Advanced Micro Devices, Inc. Processor including efficient fetch mechanism for L0 and L1 caches
US5974432A (en) * 1997-12-05 1999-10-26 Advanced Micro Devices, Inc. On-the-fly one-hot encoding of leading zero count
US5870578A (en) * 1997-12-09 1999-02-09 Advanced Micro Devices, Inc. Workload balancing in a microprocessor for reduced instruction dispatch stalling
US6157986A (en) * 1997-12-16 2000-12-05 Advanced Micro Devices, Inc. Fast linear tag validation unit for use in microprocessor
US6115792A (en) * 1997-12-16 2000-09-05 Advanced Micro Devices, Inc. Way prediction logic for cache array
US6016545A (en) * 1997-12-16 2000-01-18 Advanced Micro Devices, Inc. Reduced size storage apparatus for storing cache-line-related data in a high frequency microprocessor
US6016533A (en) * 1997-12-16 2000-01-18 Advanced Micro Devices, Inc. Way prediction logic for cache array
US6205541B1 (en) 1997-12-18 2001-03-20 Advanced Micro Devices, Inc. System and method using selection logic units to define stack orders
US6112018A (en) * 1997-12-18 2000-08-29 Advanced Micro Devices, Inc. Apparatus for exchanging two stack registers
US6018798A (en) * 1997-12-18 2000-01-25 Advanced Micro Devices, Inc. Floating point unit using a central window for storing instructions capable of executing multiple instructions in a single clock cycle
US6112296A (en) * 1997-12-18 2000-08-29 Advanced Micro Devices, Inc. Floating point stack manipulation using a register map and speculative top of stack values
US6065110A (en) * 1998-02-09 2000-05-16 International Business Machines Corporation Method and apparatus for loading an instruction buffer of a processor capable of out-of-order instruction issue
US6141745A (en) * 1998-04-30 2000-10-31 Advanced Micro Devices, Inc. Functional bit identifying a prefix byte via a particular state regardless of type of instruction
US6175908B1 (en) 1998-04-30 2001-01-16 Advanced Micro Devices, Inc. Variable byte-length instructions using state of function bit of second byte of plurality of instructions bytes as indicative of whether first byte is a prefix byte
US6988183B1 (en) 1998-06-26 2006-01-17 Derek Chi-Lan Wong Methods for increasing instruction-level parallelism in microprocessors and digital system
WO2000000878A2 (en) * 1998-06-26 2000-01-06 Chi Lan Wong Derek Methods for increasing instruction-level parallelism in microprocessors and digital systems
WO2000000878A3 (en) * 1998-06-26 2000-04-20 Chi Lan Wong Derek Methods for increasing instruction-level parallelism in microprocessors and digital systems
US6122656A (en) * 1998-07-31 2000-09-19 Advanced Micro Devices, Inc. Processor configured to map logical register numbers to physical register numbers using virtual register numbers
US6119223A (en) * 1998-07-31 2000-09-12 Advanced Micro Devices, Inc. Map unit having rapid misprediction recovery
US6247106B1 (en) 1998-07-31 2001-06-12 Advanced Micro Devices, Inc. Processor configured to map logical register numbers to physical register numbers using virtual register numbers
US6304953B1 (en) * 1998-07-31 2001-10-16 Intel Corporation Computer processor with instruction-specific schedulers
US6230262B1 (en) 1998-07-31 2001-05-08 Advanced Micro Devices, Inc. Processor configured to selectively free physical registers upon retirement of instructions
US6122727A (en) * 1998-08-24 2000-09-19 Advanced Micro Devices, Inc. Symmetrical instructions queue for high clock frequency scheduling
US6212623B1 (en) 1998-08-24 2001-04-03 Advanced Micro Devices, Inc. Universal dependency vector/queue entry
US6212622B1 (en) 1998-08-24 2001-04-03 Advanced Micro Devices, Inc. Mechanism for load block on store address generation
US6553482B1 (en) 1998-08-24 2003-04-22 Advanced Micro Devices, Inc. Universal dependency vector/queue entry
US6742111B2 (en) * 1998-08-31 2004-05-25 Stmicroelectronics, Inc. Reservation stations to increase instruction level parallelism
US6393546B1 (en) 1999-01-05 2002-05-21 Advanced Micro Devices, Inc. Physical rename register for efficiently storing floating point, integer, condition code, and multimedia values
US6266763B1 (en) 1999-01-05 2001-07-24 Advanced Micro Devices, Inc. Physical rename register for efficiently storing floating point, integer, condition code, and multimedia values
US20040158695A1 (en) * 1999-05-03 2004-08-12 Laurent Ugen Method and apparatus for handling transfer of guarded instructions in a computer system
US7496737B2 (en) 1999-05-03 2009-02-24 Stmicroelectronics S.A. High priority guard transfer for execution control of dependent guarded instructions
US8160988B1 (en) 1999-11-08 2012-04-17 Aloft Media, Llc System, method and computer program product for a collaborative decision platform
US8005777B1 (en) 1999-11-08 2011-08-23 Aloft Media, Llc System, method and computer program product for a collaborative decision platform
US7970722B1 (en) 1999-11-08 2011-06-28 Aloft Media, Llc System, method and computer program product for a collaborative decision platform
US6542986B1 (en) 1999-11-09 2003-04-01 Advanced Micro Devices, Inc. Resolving dependencies among concurrently dispatched instructions in a superscalar microprocessor
US7107434B2 (en) 1999-12-20 2006-09-12 Board Of Regents, The University Of Texas System, method and apparatus for allocating hardware resources using pseudorandom sequences
US20020174321A1 (en) * 1999-12-20 2002-11-21 John Lizy Kurian System, method and apparatus for allocating hardware resources using pseudorandom sequences
US6564315B1 (en) 2000-01-03 2003-05-13 Advanced Micro Devices, Inc. Scheduler which discovers non-speculative nature of an instruction after issuing and reissues the instruction
US6622237B1 (en) 2000-01-03 2003-09-16 Advanced Micro Devices, Inc. Store to load forward predictor training using delta tag
US6622235B1 (en) 2000-01-03 2003-09-16 Advanced Micro Devices, Inc. Scheduler which retries load/store hit situations
US6651161B1 (en) 2000-01-03 2003-11-18 Advanced Micro Devices, Inc. Store load forward predictor untraining
US6694424B1 (en) 2000-01-03 2004-02-17 Advanced Micro Devices, Inc. Store load forward predictor training
US6542984B1 (en) 2000-01-03 2003-04-01 Advanced Micro Devices, Inc. Scheduler capable of issuing and reissuing dependency chains
US20070118500A1 (en) * 2000-04-07 2007-05-24 Washington University Associative Database Scanning and Information Retrieval
US7953743B2 (en) 2000-04-07 2011-05-31 Washington University Associative database scanning and information retrieval
US7680790B2 (en) 2000-04-07 2010-03-16 Washington University Method and apparatus for approximate matching of DNA sequences
US20040111392A1 (en) * 2000-04-07 2004-06-10 Indeck Ronald S. Associative database scanning and information retrieval
US6711558B1 (en) 2000-04-07 2004-03-23 Washington University Associative database scanning and information retrieval
US9020928B2 (en) 2000-04-07 2015-04-28 Ip Reservoir, Llc Method and apparatus for processing streaming data using programmable logic
US20080109413A1 (en) * 2000-04-07 2008-05-08 Indeck Ronald S Associative Database Scanning and Information Retrieval
US8549024B2 (en) 2000-04-07 2013-10-01 Ip Reservoir, Llc Method and apparatus for adjustable data matching
US20080114760A1 (en) * 2000-04-07 2008-05-15 Indeck Ronald S Method and Apparatus for Approximate Matching of Image Data
US7181437B2 (en) 2000-04-07 2007-02-20 Washington University Associative database scanning and information retrieval
US7552107B2 (en) 2000-04-07 2009-06-23 Washington University Associative database scanning and information retrieval
US20080126320A1 (en) * 2000-04-07 2008-05-29 Indeck Ronald S Method and Apparatus for Approximate Matching Where Programmable Logic Is Used to Process Data Being Written to a Mass Storage Medium and Process Data Being Read from a Mass Storage Medium
US7139743B2 (en) 2000-04-07 2006-11-21 Washington University Associative database scanning and information retrieval using FPGA devices
US20080133453A1 (en) * 2000-04-07 2008-06-05 Indeck Ronald S Associative Database Scanning and Information Retrieval
US20080133519A1 (en) * 2000-04-07 2008-06-05 Indeck Ronald S Method and Apparatus for Approximate Matching of DNA Sequences
US7949650B2 (en) 2000-04-07 2011-05-24 Washington University Associative database scanning and information retrieval
US20060294059A1 (en) * 2000-04-07 2006-12-28 Washington University, A Corporation Of The State Of Missouri Intelligent data storage and processing using fpga devices
US20030018630A1 (en) * 2000-04-07 2003-01-23 Indeck Ronald S. Associative database scanning and information retrieval using FPGA devices
US8095508B2 (en) 2000-04-07 2012-01-10 Washington University Intelligent data storage and processing using FPGA devices
US8131697B2 (en) 2000-04-07 2012-03-06 Washington University Method and apparatus for approximate matching where programmable logic is used to process data being written to a mass storage medium and process data being read from a mass storage medium
US6981132B2 (en) 2000-08-09 2005-12-27 Advanced Micro Devices, Inc. Uniform register addressing using prefix byte
US6877084B1 (en) 2000-08-09 2005-04-05 Advanced Micro Devices, Inc. Central processing unit (CPU) accessing an extended register set in an extended register mode
US6484241B2 (en) * 2000-12-28 2002-11-19 International Business Machines Corporation Multiprocessor computer system with sectored cache line system bus protocol mechanism
US6553462B2 (en) * 2000-12-28 2003-04-22 International Business Machines Corporation Multiprocessor computer system with sectored cache line mechanism for load and store operations
US6571322B2 (en) * 2000-12-28 2003-05-27 International Business Machines Corporation Multiprocessor computer system with sectored cache line mechanism for cache intervention
US7716330B2 (en) 2001-10-19 2010-05-11 Global Velocity, Inc. System and method for controlling transmission of data packets over an information network
US7107433B1 (en) * 2001-10-26 2006-09-12 Lsi Logic Corporation Mechanism for resource allocation in a digital signal processor based on instruction type information and functional priority and method of operation thereof
US7114059B2 (en) * 2001-11-05 2006-09-26 Intel Corporation System and method to bypass execution of instructions involving unreliable data during speculative execution
US20030088759A1 (en) * 2001-11-05 2003-05-08 Wilkerson Christopher B System and method to reduce execution of instructions involving unreliable data in a speculative processor
US20030221013A1 (en) * 2002-05-21 2003-11-27 John Lockwood Methods, systems, and devices using reprogrammable hardware for high-speed processing of streaming data to find a redefinable pattern and respond thereto
US20070078837A1 (en) * 2002-05-21 2007-04-05 Washington University Method and Apparatus for Processing Financial Information at Hardware Speeds Using FPGA Devices
US7093023B2 (en) 2002-05-21 2006-08-15 Washington University Methods, systems, and devices using reprogrammable hardware for high-speed processing of streaming data to find a redefinable pattern and respond thereto
US8069102B2 (en) 2002-05-21 2011-11-29 Washington University Method and apparatus for processing financial information at hardware speeds using FPGA devices
US10909623B2 (en) 2002-05-21 2021-02-02 Ip Reservoir, Llc Method and apparatus for processing financial information at hardware speeds using FPGA devices
US7711844B2 (en) 2002-08-15 2010-05-04 Washington University Of St. Louis TCP-splitter: reliable packet monitoring methods and apparatus for high speed networks
US20040128480A1 (en) * 2002-12-31 2004-07-01 Intel Corporation Register file read port to support uop fusion
US10719334B2 (en) 2003-05-23 2020-07-21 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US9176775B2 (en) 2003-05-23 2015-11-03 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US8768888B2 (en) 2003-05-23 2014-07-01 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US10929152B2 (en) 2003-05-23 2021-02-23 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US10346181B2 (en) 2003-05-23 2019-07-09 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US9898312B2 (en) 2003-05-23 2018-02-20 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US8620881B2 (en) 2003-05-23 2013-12-31 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US10572824B2 (en) 2003-05-23 2020-02-25 Ip Reservoir, Llc System and method for low latency multi-functional pipeline with correlation logic and selectively activated/deactivated pipelined data processing engines
US20070277036A1 (en) * 2003-05-23 2007-11-29 Washington University, A Corporation Of The State Of Missouri Intelligent data storage and processing using fpga devices
US11275594B2 (en) 2003-05-23 2022-03-15 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US8751452B2 (en) 2003-05-23 2014-06-10 Ip Reservoir, Llc Intelligent data storage and processing using FPGA devices
US7321964B2 (en) 2003-07-08 2008-01-22 Advanced Micro Devices, Inc. Store-to-load forwarding buffer using indexed lookup
US20050010744A1 (en) * 2003-07-08 2005-01-13 Advanced Micro Devices, Inc. Store-to-load forwarding buffer using indexed lookup
US20050050277A1 (en) * 2003-09-03 2005-03-03 Advanced Micro Devices, Inc. MicroTLB and micro TAG for reducing power in a processor
US7117290B2 (en) 2003-09-03 2006-10-03 Advanced Micro Devices, Inc. MicroTLB and micro tag for reducing power in a processor
US20050050278A1 (en) * 2003-09-03 2005-03-03 Advanced Micro Devices, Inc. Low power way-predicted cache
US7043626B1 (en) 2003-10-01 2006-05-09 Advanced Micro Devices, Inc. Retaining flag value associated with dead result data in freed rename physical register with an indicator to select set-aside register instead for renaming
US20050154832A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Consistency evaluation of program execution across at least one memory barrier
US20050154833A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Coherent signal in a multi-processor system
US7340565B2 (en) * 2004-01-13 2008-03-04 Hewlett-Packard Development Company, L.P. Source request arbitration
US7360069B2 (en) * 2004-01-13 2008-04-15 Hewlett-Packard Development Company, L.P. Systems and methods for executing across at least one memory barrier employing speculative fills
US7376794B2 (en) * 2004-01-13 2008-05-20 Hewlett-Packard Development Company, L.P. Coherent signal in a multi-processor system
US7383409B2 (en) * 2004-01-13 2008-06-03 Hewlett-Packard Development Company, L.P. Cache systems and methods for employing speculative fills
US8301844B2 (en) * 2004-01-13 2012-10-30 Hewlett-Packard Development Company, L.P. Consistency evaluation of program execution across at least one memory barrier
US8281079B2 (en) * 2004-01-13 2012-10-02 Hewlett-Packard Development Company, L.P. Multi-processor system receiving input from a pre-fetch buffer
US20050154866A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Systems and methods for executing across at least one memory barrier employing speculative fills
US20050154836A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Multi-processor system receiving input from a pre-fetch buffer
US20050154865A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Multi-processor systems and methods for backup for non-coherent speculative fills
US20050154835A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Register file systems and methods for employing speculative fills
US7406565B2 (en) * 2004-01-13 2008-07-29 Hewlett-Packard Development Company, L.P. Multi-processor systems and methods for backup for non-coherent speculative fills
US7409503B2 (en) * 2004-01-13 2008-08-05 Hewlett-Packard Development Company, L.P. Register file systems and methods for employing speculative fills
US20050154834A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Cache systems and methods for employing speculative fills
US20050154831A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Source request arbitration
US7409500B2 (en) * 2004-01-13 2008-08-05 Hewlett-Packard Development Company, L.P. Systems and methods for employing speculative fills
US20050154805A1 (en) * 2004-01-13 2005-07-14 Steely Simon C.Jr. Systems and methods for employing speculative fills
US7602785B2 (en) 2004-02-09 2009-10-13 Washington University Method and system for performing longest prefix matching for network address lookup using bloom filters
US7613950B2 (en) * 2004-02-27 2009-11-03 Hewlett-Packard Development Company, L.P. Detecting floating point hardware failures
US20050204194A1 (en) * 2004-02-27 2005-09-15 Curry John W. Detecting floating point hardware failures
US7395415B2 (en) * 2004-09-30 2008-07-01 Intel Corporation Method and apparatus to provide a source operand for an instruction in a processor
US20060095728A1 (en) * 2004-09-30 2006-05-04 Gary Hammond Method and apparatus to provide a source operand for an instruction in a processor
US7237095B1 (en) 2005-08-04 2007-06-26 Advanced Micro Devices, Inc. Optimum power efficient shifting algorithm for schedulers
US20090254734A1 (en) * 2005-08-10 2009-10-08 Sudarshan Kadambi Partial Load/Store Forward Prediction
US20070038846A1 (en) * 2005-08-10 2007-02-15 P.A. Semi, Inc. Partial load/store forward prediction
US7568087B2 (en) 2005-08-10 2009-07-28 Apple Inc. Partial load/store forward prediction
US7984274B2 (en) 2005-08-10 2011-07-19 Apple Inc. Partial load/store forward prediction
US7376817B2 (en) 2005-08-10 2008-05-20 P.A. Semi, Inc. Partial load/store forward prediction
US20080177988A1 (en) * 2005-08-10 2008-07-24 Sudarshan Kadambi Partial Load/Store Forward Prediction
US20070083734A1 (en) * 2005-08-16 2007-04-12 Abernathy Christopher M Queue design supporting dependency checking and issue for simd instructions within a general purpose processor
US7328330B2 (en) * 2005-08-16 2008-02-05 International Business Machines Corporation Queue design supporting dependency checking and issue for SIMD instructions within a general purpose processor
US20070083737A1 (en) * 2005-08-16 2007-04-12 Ibm Corporation Processor with efficient shift/rotate instruction execution
US20070074005A1 (en) * 2005-09-27 2007-03-29 Ibm Corporation Method and apparatus for issuing instructions from an issue queue in an information handling system
US20070198812A1 (en) * 2005-09-27 2007-08-23 Ibm Corporation Method and apparatus for issuing instructions from an issue queue including a main issue queue array and an auxiliary issue queue array in an information handling system
US7350056B2 (en) 2005-09-27 2008-03-25 International Business Machines Corporation Method and apparatus for issuing instructions from an issue queue in an information handling system
US7945528B2 (en) 2005-12-02 2011-05-17 Exegy Incorporated Method and device for high performance regular expression pattern matching
US7702629B2 (en) 2005-12-02 2010-04-20 Exegy Incorporated Method and device for high performance regular expression pattern matching
US20100198850A1 (en) * 2005-12-02 2010-08-05 Exegy Incorporated Method and Device for High Performance Regular Expression Pattern Matching
US20070130140A1 (en) * 2005-12-02 2007-06-07 Cytron Ron K Method and device for high performance regular expression pattern matching
US7954114B2 (en) 2006-01-26 2011-05-31 Exegy Incorporated Firmware socket module for FPGA-based pipeline processing
US7636703B2 (en) 2006-05-02 2009-12-22 Exegy Incorporated Method and apparatus for approximate pattern matching
US20070260602A1 (en) * 2006-05-02 2007-11-08 Exegy Incorporated Method and Apparatus for Approximate Pattern Matching
US8655764B2 (en) 2006-06-19 2014-02-18 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US8478680B2 (en) 2006-06-19 2013-07-02 Exegy Incorporated High speed processing of financial information using FPGA devices
US9672565B2 (en) 2006-06-19 2017-06-06 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US9916622B2 (en) 2006-06-19 2018-03-13 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US11182856B2 (en) 2006-06-19 2021-11-23 Exegy Incorporated System and method for routing of streaming data as between multiple compute resources
US8626624B2 (en) 2006-06-19 2014-01-07 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US10169814B2 (en) 2006-06-19 2019-01-01 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US10817945B2 (en) 2006-06-19 2020-10-27 Ip Reservoir, Llc System and method for routing of streaming data as between multiple compute resources
US7840482B2 (en) 2006-06-19 2010-11-23 Exegy Incorporated Method and system for high speed options pricing
US8843408B2 (en) 2006-06-19 2014-09-23 Ip Reservoir, Llc Method and system for high speed options pricing
US9582831B2 (en) 2006-06-19 2017-02-28 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US8600856B2 (en) 2006-06-19 2013-12-03 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US8595104B2 (en) 2006-06-19 2013-11-26 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US10504184B2 (en) 2006-06-19 2019-12-10 Ip Reservoir, Llc Fast track routing of streaming data as between multiple compute resources
US10467692B2 (en) 2006-06-19 2019-11-05 Ip Reservoir, Llc High speed processing of financial information using FPGA devices
US7921046B2 (en) 2006-06-19 2011-04-05 Exegy Incorporated High speed processing of financial information using FPGA devices
US8458081B2 (en) 2006-06-19 2013-06-04 Exegy Incorporated High speed processing of financial information using FPGA devices
US8407122B2 (en) 2006-06-19 2013-03-26 Exegy Incorporated High speed processing of financial information using FPGA devices
US10360632B2 (en) 2006-06-19 2019-07-23 Ip Reservoir, Llc Fast track routing of streaming data using FPGA devices
US9323794B2 (en) 2006-11-13 2016-04-26 Ip Reservoir, Llc Method and system for high performance pattern indexing
US8326819B2 (en) 2006-11-13 2012-12-04 Exegy Incorporated Method and system for high performance data metatagging and data indexing using coprocessors
US8156101B2 (en) 2006-11-13 2012-04-10 Exegy Incorporated Method and system for high performance integration, processing and searching of structured and unstructured data using coprocessors
US9396222B2 (en) 2006-11-13 2016-07-19 Ip Reservoir, Llc Method and system for high performance integration, processing and searching of structured and unstructured data using coprocessors
US8880501B2 (en) 2006-11-13 2014-11-04 Ip Reservoir, Llc Method and system for high performance integration, processing and searching of structured and unstructured data using coprocessors
US10191974B2 (en) 2006-11-13 2019-01-29 Ip Reservoir, Llc Method and system for high performance integration, processing and searching of structured and unstructured data
US7660793B2 (en) 2006-11-13 2010-02-09 Exegy Incorporated Method and system for high performance integration, processing and searching of structured and unstructured data using coprocessors
US11449538B2 (en) 2006-11-13 2022-09-20 Ip Reservoir, Llc Method and system for high performance integration, processing and searching of structured and unstructured data
US7877559B2 (en) 2007-11-26 2011-01-25 Globalfoundries Inc. Mechanism to accelerate removal of store operations from a queue
US20090138659A1 (en) * 2007-11-26 2009-05-28 Gary Lauterbach Mechanism to accelerate removal of store operations from a queue
US10229453B2 (en) 2008-01-11 2019-03-12 Ip Reservoir, Llc Method and system for low latency basket calculation
US10158377B2 (en) 2008-05-15 2018-12-18 Ip Reservoir, Llc Method and system for accelerated stream processing
US8374986B2 (en) 2008-05-15 2013-02-12 Exegy Incorporated Method and system for accelerated stream processing
US20090287628A1 (en) * 2008-05-15 2009-11-19 Exegy Incorporated Method and System for Accelerated Stream Processing
US10965317B2 (en) 2008-05-15 2021-03-30 Ip Reservoir, Llc Method and system for accelerated stream processing
US11677417B2 (en) 2008-05-15 2023-06-13 Ip Reservoir, Llc Method and system for accelerated stream processing
US9547824B2 (en) 2008-05-15 2017-01-17 Ip Reservoir, Llc Method and apparatus for accelerated data quality checking
US10411734B2 (en) 2008-05-15 2019-09-10 Ip Reservoir, Llc Method and system for accelerated stream processing
US11676206B2 (en) 2008-12-15 2023-06-13 Exegy Incorporated Method and apparatus for high-speed processing of financial market depth data
US8768805B2 (en) 2008-12-15 2014-07-01 Ip Reservoir, Llc Method and apparatus for high-speed processing of financial market depth data
US10062115B2 (en) 2008-12-15 2018-08-28 Ip Reservoir, Llc Method and apparatus for high-speed processing of financial market depth data
US8762249B2 (en) 2008-12-15 2014-06-24 Ip Reservoir, Llc Method and apparatus for high-speed processing of financial market depth data
US10929930B2 (en) 2008-12-15 2021-02-23 Ip Reservoir, Llc Method and apparatus for high-speed processing of financial market depth data
US20100318772A1 (en) * 2009-06-11 2010-12-16 Ranganathan Sudhakar Superscalar register-renaming for a stack-addressed architecture
US8539397B2 (en) 2009-06-11 2013-09-17 Advanced Micro Devices, Inc. Superscalar register-renaming for a stack-addressed architecture
US10037568B2 (en) 2010-12-09 2018-07-31 Ip Reservoir, Llc Method and apparatus for managing orders in financial markets
US11397985B2 (en) 2010-12-09 2022-07-26 Exegy Incorporated Method and apparatus for managing orders in financial markets
US11803912B2 (en) 2010-12-09 2023-10-31 Exegy Incorporated Method and apparatus for managing orders in financial markets
US9740494B2 (en) 2011-04-29 2017-08-22 Arizona Board Of Regents For And On Behalf Of Arizona State University Low complexity out-of-order issue logic using static circuits
US9286172B2 (en) * 2011-12-22 2016-03-15 Intel Corporation Fault-aware mapping for shared last level cache (LLC)
US20140006849A1 (en) * 2011-12-22 2014-01-02 Tanausu Ramirez Fault-aware mapping for shared last level cache (llc)
US11436672B2 (en) 2012-03-27 2022-09-06 Exegy Incorporated Intelligent switch for processing financial market data
US10963962B2 (en) 2012-03-27 2021-03-30 Ip Reservoir, Llc Offload processing of data packets containing financial market data
US10121196B2 (en) 2012-03-27 2018-11-06 Ip Reservoir, Llc Offload processing of data packets containing financial market data
US9990393B2 (en) 2012-03-27 2018-06-05 Ip Reservoir, Llc Intelligent feed switch
US10872078B2 (en) 2012-03-27 2020-12-22 Ip Reservoir, Llc Intelligent feed switch
US10650452B2 (en) 2012-03-27 2020-05-12 Ip Reservoir, Llc Offload processing of data packets
US9128725B2 (en) 2012-05-04 2015-09-08 Apple Inc. Load-store dependency predictor content management
US9600289B2 (en) 2012-05-30 2017-03-21 Apple Inc. Load-store dependency predictor PC hashing
US20140040595A1 (en) * 2012-08-01 2014-02-06 Freescale Semiconductor, Inc. Space efficient checkpoint facility and technique for processor with integrally indexed register mapping and free-list arrays
US9672044B2 (en) * 2012-08-01 2017-06-06 Nxp Usa, Inc. Space efficient checkpoint facility and technique for processor with integrally indexed register mapping and free-list arrays
US10949442B2 (en) 2012-10-23 2021-03-16 Ip Reservoir, Llc Method and apparatus for accelerated format translation of data in a delimited data format
US9633093B2 (en) 2012-10-23 2017-04-25 Ip Reservoir, Llc Method and apparatus for accelerated format translation of data in a delimited data format
US11789965B2 (en) 2012-10-23 2023-10-17 Ip Reservoir, Llc Method and apparatus for accelerated format translation of data in a delimited data format
US9633097B2 (en) 2012-10-23 2017-04-25 Ip Reservoir, Llc Method and apparatus for record pivoting to accelerate processing of data fields
US10621192B2 (en) 2012-10-23 2020-04-14 IP Resevoir, LLC Method and apparatus for accelerated format translation of data in a delimited data format
US10102260B2 (en) 2012-10-23 2018-10-16 Ip Reservoir, Llc Method and apparatus for accelerated data translation using record layout detection
US10133802B2 (en) 2012-10-23 2018-11-20 Ip Reservoir, Llc Method and apparatus for accelerated record layout detection
US10146845B2 (en) 2012-10-23 2018-12-04 Ip Reservoir, Llc Method and apparatus for accelerated format translation of data in a delimited data format
US9977596B2 (en) * 2012-12-27 2018-05-22 Dropbox, Inc. Predictive models of file access patterns by application and file type
US10803016B2 (en) 2012-12-27 2020-10-13 Dropbox, Inc. Predictive models of file access patterns by application and file type
US20140188868A1 (en) * 2012-12-27 2014-07-03 Dropbox, Inc. Predictive models of file access patterns by application and file type
US10152327B2 (en) * 2013-03-15 2018-12-11 Intel Corporation Apparatus for gating a load operation based on entries of a prediction table
US20140281408A1 (en) * 2013-03-15 2014-09-18 Soft Machines, Inc. Method and apparatus for predicting forwarding of data from a store to a load
US10198265B2 (en) * 2013-03-15 2019-02-05 Intel Corporation Microprocessor for gating a load operation based on entries of a prediction table
US10579386B2 (en) 2013-03-15 2020-03-03 Intel Corporation Microprocessor for gating a load operation based on entries of a prediction table
US10467010B2 (en) 2013-03-15 2019-11-05 Intel Corporation Method and apparatus for nearest potential store tagging
US20140281384A1 (en) * 2013-03-15 2014-09-18 Soft Machines, Inc. Method and apparatus for predicting forwarding of data from a store to a load
US10902013B2 (en) 2014-04-23 2021-01-26 Ip Reservoir, Llc Method and apparatus for accelerated record layout detection
US9710268B2 (en) 2014-04-29 2017-07-18 Apple Inc. Reducing latency for pointer chasing loads
US11526531B2 (en) 2015-10-29 2022-12-13 Ip Reservoir, Llc Dynamic field data translation to support high performance stream data processing
US10942943B2 (en) 2015-10-29 2021-03-09 Ip Reservoir, Llc Dynamic field data translation to support high performance stream data processing
US9870039B2 (en) * 2015-12-15 2018-01-16 International Business Machines Corporation Reducing power consumption in a multi-slice computer processor
US10564691B2 (en) 2015-12-15 2020-02-18 International Business Machines Corporation Reducing power consumption in a multi-slice computer processor
US20170168539A1 (en) * 2015-12-15 2017-06-15 International Business Machines Corporation Reducing power consumption in a multi-slice computer processor
US10209757B2 (en) 2015-12-15 2019-02-19 International Business Machines Corporation Reducing power consumption in a multi-slice computer processor
US9870045B2 (en) 2015-12-15 2018-01-16 International Business Machines Corporation Reducing power consumption in a multi-slice computer processor
US10514925B1 (en) 2016-01-28 2019-12-24 Apple Inc. Load speculation recovery
US10437595B1 (en) 2016-03-15 2019-10-08 Apple Inc. Load/store dependency predictor optimization for replayed loads
US10846624B2 (en) 2016-12-22 2020-11-24 Ip Reservoir, Llc Method and apparatus for hardware-accelerated machine learning
US11416778B2 (en) 2016-12-22 2022-08-16 Ip Reservoir, Llc Method and apparatus for hardware-accelerated machine learning
US20220382714A1 (en) * 2021-06-01 2022-12-01 International Business Machines Corporation Receiving at a cache node notification of changes to files in a source file system served from a cache file system at the cache node
US11650957B2 (en) * 2021-06-01 2023-05-16 International Business Machines Corporation Receiving at a cache node notification of changes to files in a source file system served from a cache file system at the cache node
US11645238B2 (en) 2021-06-01 2023-05-09 International Business Machines Corporation Notifying a cache file system of changes to files in a source file system served from the cache file system
CN114116533A (en) * 2021-11-29 2022-03-01 海光信息技术股份有限公司 Method for storing data by using shared memory

Also Published As

Publication number Publication date
JPH07182160A (en) 1995-07-21
DE69429061D1 (en) 2001-12-20
JP3670039B2 (en) 2005-07-13
US5655097A (en) 1997-08-05
US5664136A (en) 1997-09-02
DE69429061T2 (en) 2002-07-18
US5867683A (en) 1999-02-02
US5655098A (en) 1997-08-05
US5751981A (en) 1998-05-12
EP0651321B1 (en) 2001-11-14
EP0651321A1 (en) 1995-05-03
US5867682A (en) 1999-02-02

Similar Documents

Publication Publication Date Title
US5651125A (en) High performance superscalar microprocessor including a common reorder buffer and common register file for both integer and floating point operations
US5632023A (en) Superscalar microprocessor including flag operand renaming and forwarding apparatus
US5848433A (en) Way prediction unit and a method for operating the same
US5764938A (en) Resynchronization of a superscalar processor
US5887152A (en) Load/store unit with multiple oldest outstanding instruction pointers for completing store and load/store miss instructions
US6035386A (en) Program counter update mechanism
US5764946A (en) Superscalar microprocessor employing a way prediction unit to predict the way of an instruction fetch address and to concurrently provide a branch prediction address corresponding to the fetch address
US5832297A (en) Superscalar microprocessor load/store unit employing a unified buffer and separate pointers for load and store operations
US5721855A (en) Method for pipeline processing of instructions by controlling access to a reorder buffer using a register file outside the reorder buffer
US5734881A (en) Detecting short branches in a prefetch buffer using target location information in a branch target cache
US5968169A (en) Superscalar microprocessor stack structure for judging validity of predicted subroutine return addresses
US6604190B1 (en) Data address prediction structure and a method for operating the same
US5768610A (en) Lookahead register value generator and a superscalar microprocessor employing same
US5870599A (en) Computer system employing streaming buffer for instruction preetching
US6393549B1 (en) Instruction alignment unit for routing variable byte-length instructions
US5778210A (en) Method and apparatus for recovering the state of a speculatively scheduled operation in a processor which cannot be executed at the speculated time
US20060248319A1 (en) Validating branch resolution to avoid mis-steering instruction fetch
US5960467A (en) Apparatus for efficiently providing memory operands for instructions
US20020007450A1 (en) Line-oriented reorder buffer
JPH06103167A (en) Combination queue for invalidate and returned data in multiprocessor system
US5649137A (en) Method and apparatus for store-into-instruction-stream detection and maintaining branch prediction cache consistency
US5832249A (en) High performance superscalar alignment unit
US5822574A (en) Functional unit with a pointer for mispredicted resolution, and a superscalar microprocessor employing the same
CN111133413A (en) Load-store unit with partitioned reorder queue using a single CAM port
Goossens TiPi, the threads processor

Legal Events

Date Code Title Description
CC Certificate of correction
FPAY Fee payment

Year of fee payment: 4

FPAY Fee payment

Year of fee payment: 8

REMI Maintenance fee reminder mailed
LAPS Lapse for failure to pay maintenance fees
STCH Information on status: patent discontinuation

Free format text: PATENT EXPIRED DUE TO NONPAYMENT OF MAINTENANCE FEES UNDER 37 CFR 1.362

AS Assignment

Owner name: GLOBALFOUNDRIES INC., CAYMAN ISLANDS

Free format text: AFFIRMATION OF PATENT ASSIGNMENT;ASSIGNOR:ADVANCED MICRO DEVICES, INC.;REEL/FRAME:023119/0083

Effective date: 20090630

FP Lapsed due to failure to pay maintenance fee

Effective date: 20090722