Method and System for Back-End Gathering of Store Instructions Within a Data-Processing System

1. Technical Field

The present invention relates to a method and system for data processing in general and, in particular, to a method and system for storing data to a memory within a data-processing system. Still more particularly, the present invention relates to a method and system for back-end gathering of store instructions within a data-processing system.

2. Description of the Prior Art

A typical superscalar processor comprises multiple execution units, and each is optimized to execute a corresponding type of instructions. For example, the processor may contain a fixed-point unit (FXU) for executing fixed-point instructions, a floating-point unit (FPU) for executing floating-point instructions, a branch-processing unit (BPU) for executing branch instructions, and a load-store unit (LSU) for executing load and store instructions.

When an instruction is retrieved from a system memory for execution by the processor, the instruction is first decoded in order to determine an execution unit to which the instruction should be dispatched. In the case of a store instruction, it will be dispatched to the LSU for execution. Execution of a store instruction begins with calculating the effective address (EA) of the memory location to which the data associated with the store instruction is to be written. After the EA of the store instruction has been calculated, the execution of the store instruction is completed by committing the data associated with the store instruction to a store queue from which the data will be written to a specified memory location.

Generally speaking, with an on-chip data cache, only a small performance inefficiency may result from multiple consecutive store instructions to the system memory. In most cases, such on-chip data caches permit data accesses to be performed in as little as a single cycle. When store instructions are write-throughs or cache-inhibited, however, multiple consecutive store instructions will cause performance inefficiency to rise due to the additional latency of bus accesses.

When a page is designated as cache-allowed, the processor utilizes the cache to perform load and store operations to either the cache or the system memory, depending on the other memory/cache access attributes for the page. When a page is designated as cache-inhibited, the processor must bypass the cache and performs load and store operations directly to the system main memory in a sequential manner. In data-processing systems that utilize a store queue for the temporally holding of store instructions, it is very typical for the store queue to be implemented with a collection of registers that are organized in a First-In-First-Out (FIFO) manner. Further, the store queue may be divided into a front-end queue and a back-end queue. Store instructions are added to the entries of the front-end queue while they are removed from the entries of the back-end queue. Each entry of the store queue holds an address, a byte count, and data of a store instruction. The total number of entries for the store queue is usually small because of the size constraints of the chip, even though the overall performance may suffer because the execution of store instructions will halt when the store queue becomes full.

Consequently, it would be desirable to provide an efficient method and system for gathering these store instructions in the back-end of the store queue such that the number of instructions transferred to the data cache or the system memory via a system bus can be effectively reduced.

In view of the foregoing, it is therefore an object of the present invention to provide an improved method and system for data processing.

It is another object of the present invention to provide an improved method and system for storing data to a memory within a data-processing system.

It is yet another object of the present invention to provide an improved method and system for back-end gathering of store instructions within a data-processing system.

In accordance with the method and system of the present invention, the store queue within a data-processing system includes a front-end queue and a back-end queue. Multiple entries are provided in the back-end queue, and each entry includes an address field, a byte-count field, and a data field. A determination is first made as to whether or not a data field of a last entry of the back-end queue is completely filled. In response to a determination that the data field of the last entry of the back-end queue is not completely filled, another determination is made as to whether or not an address for a store instruction in a subsequent entry is equal to an address for a store instruction in the last entry plus a byte count in the last entry. In response to a determination that the address for a store instruction in a subsequent entry is equal to the address for a store instruction in the last entry plus the byte count in the last entry, the two store instructions are combined into one bus transfer.

All objects, features, and advantages of the present invention will become apparent in the following detailed written description.

The invention itself, as well as a preferred mode of use, further objects, and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, wherein:

FIG. 1 is a block diagram of a processor in which the present invention may be implemented;

FIG. 2 is a detailed block diagram of the load-store unit of FIG. 1;

FIG. 3 is a block diagram of the stored queue and other components for back-end gathering of store instructions, in accordance with a preferred embodiment of the present invention; and

FIG. 4 is a high-level logic flow diagram illustrating a method for back-end gathering of store instructions within a store queue of a processor, in accordance with a preferred embodiment of the present invention.

An illustrative embodiment under the present disclosure may be implemented on a variety of cache-based processors and/or data-processing systems. For the purpose of illustration, a PowerPC.TM. processor manufactured by International Business Machines Corporation, which operates according to reduced instruction-set-computing (RISC) techniques, is utilized to demonstrate a preferred embodiment of the present invention.

Referring now to the drawings and, in particular, to FIG. 1, there is illustrated a block diagram of a processor 10 in which the present invention may be implemented. In a preferred embodiment of the present invention, processor 10 is a single integrated-circuit superscalar processor, comprising various registers, buffers, execution units, and functional units. As depicted in FIG. 1, processor 10 is coupled to system bus 11 via a bus interface unit (BIU) 12 within processor 10. BIU 12 controls the transfer of information between processor 10 and other devices, such as a main memory (not shown), that are coupled to system bus 11. Processor 10, system bus 11, and the other devices coupled to system bus 11 together form a host data-processing system.

Within processor 10, BIU 12 is connected to instruction cache 14 and data cache 16. Both instruction cache 14 and data cache 16 are high-speed caches which enable processor 10 to achieve a relatively fast access time to a subset of instructions or data previously transferred from the main memory to caches 14 and 16, thus improving the speed of operation of the host data-processing system. Instruction cache 14 is further coupled to sequential fetcher 17 which fetches instructions from instruction cache 14 during each execution cycle. Sequential fetcher 17 transmits branch instructions fetched from instruction cache 14 to branch processing unit (BPU) 18 for execution, but temporarily stores sequential instructions within instruction queue 19 for later execution by other execution circuitry within processor 10.

In addition to BPU 18, the execution circuitry of processor 10 includes three execution units, namely integer unit (IU) 22, load/store unit (LSU) 28 and floating-point unit (FPU) 32. Each of these three execution units may execute one or more classes of instructions, and all execution units operate concurrently during each processor cycle. IU 22 performs fixed-point mathematical operations such as addition, subtraction, ANDing, ORing, and XORing, utilizing source operands received from specified general purpose registers (GPR) 24 or GPR rename registers 25. Conversely, FPU 32 performs floating-point operations, such as floating-point multiplication and division, on source operands received from floating-point registers (FPR) 34 or FPR rename registers 35. As its name implies, LSU 28 executes floating-point and fixed-point instructions which load data from either data cache 16 or the main memory into selected GPRs 24 or FPRs 34 or which store data from a selected one of GPRs 24, GPR rename registers 25, FPRs 34, or FPR rename registers 35.

Processor 10 employs both pipelining and out-of-order execution of instructions to further improve the performance of its superscalar architecture. Accordingly, instructions can be executed by IU 22, LSU 28, and FPU 32 in any order as long as data dependencies are observed.

Referring now to FIG. 2, there is depicted a more detailed block diagram of load-store unit (LSU) 28 of FIG. 1. As depicted, LSU 28 includes execution control unit 50 which controls the execution of load and store instructions dispatched to LSU 28 by the dispatch unit. Execution control unit 50 includes logic for decoding load and store instruction opcodes and for comparing store instruction addresses and attributes to determine whether to merge store instructions. LSU 28 further includes address calculation unit 52 which receives the 32-bit address operands associated with each load and store instruction. Utilizing adder 70, address calculation unit 52 sums the address operands to generate a 32-bit effective address (EA) for the associated instruction. LSU 28 also includes store queue 54 and load queue 55, which manage the EA, data, and additional instruction information associated with store and load instructions dispatched to LSU 28.

As a preferred embodiment of the present invention, store queue 54 includes a front-end queue (FEQ) 58 and a back-end queue (BEQ) 60. As shown, each of FEQ 58 and BEQ 60 comprises a multiple-entry First-In-First-Out (FIFO) register. Each entry within FEQ 58 and BEQ 60 preferably has a 32-bit EA field that stores the EA generated by address calculation unit 52, a data source field that specifies which GPR(s) or FPR(s) store(s) the data associated with the store instruction, and a 64-bit data field that contains the data to be stored. The validity of the EA and data fields of each entry of FEQ 58 and BEQ 60 is indicated individually by the state of valid bits within a valid field. Each entry within FEQ 58 and BEQ 60 further includes several attribute fields, including a data-size field that indicates the byte size of the data, a byte enable (BE) field that specifies which of the data bytes contain valid data, a byte count field that contains the byte count associated with the data, and an MMU attribute field that indicates the MMU attributes of the data.

In addition to being stored within the EA field of an entry of FEQ 58, the EA generated by address calculation unit 52 for each store instruction is also passed to execution control unit 50, which utilizes the EA to determine if the associated store instruction can be merged with another store instruction in order to enhance processor efficiency. As illustrated at reference numeral 61, execution control unit 50 is further coupled to BEQ 60 such that execution control unit 50 can read in the bottom entry of BEQ 60 for comparison of the EA and attributes of the store instruction in the bottom entry with those of another store instruction to determine if the two store instructions can be merged. While a store instruction is stored in BEQ 60, the EA of the store instruction is passed to address translation unit 80 in order to translate the EA of the store instruction into a physical address and to determine if the store instruction generated an exception. The physical address bits (bits 0-20) returned to FEQ 58 by address translation unit 80 are stored into the EA field of the appropriate entry in BEQ 60.

When a store operation is to be performed, the physical address within the EA field of the bottom entry of BEQ 60 is passed to data cache 16 in conjunction with the data stored in the bottom entry of BEQ 60, if the store is cacheable. A cache controller within data cache 16 then manages the storage of the data in data cache 16. If data associated with the physical address is not resident within data cache 16 or if the store is cache-inhibited, the physical address and data are passed to BIU 12, which stores the data to main memory 64 or an I/O adapter 66 via system bus 11. Such I/O adapter may be utilized to communicate with an external computer network such as an intranet or internet.

Referring now to FIG. 3, there is depicted a block diagram of the stored queue and other components for back-end gathering of store instructions, in accordance with a preferred embodiment of the present invention. As shown, each entry within FEQ 58 is coupled to combination logic 62, while each entry within BEQ 60 is coupled to BIU 12. Each entry within BEQ 60 includes an Address field 60a, a Byte Count field 60b, and a Byte data field 60c.

As a preferred embodiment of the present invention, if Address Y equals to Address Z plus Byte Count Z, then BIU 12 can combine the store instruction to Address Y with the store instruction to Address Z into one single System Bus transfer. This is performed by altering Byte Count Z to Byte Count Z plus Byte Count Y, and placing the data for Address Y into the byte lane for Address Z. In this manner, as shown in FIG. 3, as many as four one-byte store instructions may be issued as one four-byte store instruction to the System Bus via BIU 12, if Address Y equals to Address Z plus Byte Count Z, Address X equals to Address Y plus Byte Count Y, and Address W equals to Address X plus Byte Count X, with each of Byte Counts W, X, Y, and Z equal to one.

Thus, under the PowerPC.TM. architecture, as many as four store instructions, each up to four bytes long, can be combined into a single sixteen-byte System Bus transfer. By the same token, any combination of sequential addresses up to a sixteen-byte boundary can be gathered out of the four back-end store queue entries.

With reference now to FIG. 4, there is depicted a high-level logic flow diagram illustrating a method for back-end gathering of store instructions within a store queue of a processor, in accordance with a preferred embodiment of the present invention. Starting at block 70, a determination is made as to whether or not a data field of a last entry in the back-end queue of the store queue is completely filled, as shown in block 71. If the data field of the last entry in the back-end queue of the store queue is completely filled, the process proceeds to block 74.

However, if the data field of the last entry in the back-end queue of the store queue is not completely filled, another determination is made as to whether or not the address for a store instruction in a subsequent entry is equal to the address for a store instruction in the last entry plus a byte count in the last entry, as depicted in block 72. If yes, then the process proceeds to block 74; otherwise, both store instructions are combined into one single System Bus transfer, as illustrated in block 73. Finally, a request is made to the System Bus for data-sending, as shown in block 74, and the process exits at block 75.

As an alternative embodiment, the Byte Count fields W, X, Y, and Z may be utilized to index the exact location(s) of Byte data field 60c in which data are stored. In this embodiment, if Address Y equals to or is greater than Address Z plus Byte count Z, but is still within the byte lane for Address Z, then BIU 12 can combine the store instruction to Address Y with the store instruction to Address Z into one single System Bus transfer.

As has been described, the present invention provides an improved method for back-end gathering of store instructions within a data-processing system. Under a preferred embodiment of the present invention, the sequential store instructions in the back-end of the store queue are combined into one system bus transfer, if possible. This allows the store queue to be emptied in a more efficient manner and prevents the processor from stopping its execution because the store queue is full.

Although a method of back-end gathering has been described with reference to an exemplary back-end gathering operation in which two single-precision stores were gathered, it will be appreciated from the foregoing description that both single- and double-precision stores can be gathered utilizing the illustrative embodiment described above. Furthermore, it will be appreciated that back-end gathering provides maximum enhancement of processor performance for write-through and cache-inhibited store instructions due to the decrease in system-bus latency. For example, without back-end gathering, if two store instructions require bus access of 14 cycles, then, with back-end gathering, the same two store instructions only require a single seven-cycle bus access, thereby substantially reducing the bus latency incurred.

While the invention has been particularly shown and described with reference to a preferred embodiment, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention.