Computer system including a prefetch cache

Abstract: A computer system including a main memory prefetch cache which enhances the retrieval of instructions (code and data) stored in the main memory of a computer. The computer system includes a processor and a processor cache coupled thereto. A memory controller is coupled to the processor and includes a main memory prefetch cache. The memory controller also includes control circuitry which determines if a first line of instructions requested by the processor is stored in the prefetch cache, and if so, the memory controller retrieves the first line of instructions from the prefetch cache and provides the first line of instructions to the processor. The next line of instructions is then retrieved from the main memory and is overwritten over the first line of instructions in the prefetch cache. Otherwise, if the memory controller determines that the prefetch cache does not contain the first line of instructions requested by the processor, then the first line of instructions is retrieved from the main memory and is provided to the processor. The next line of instructions is then retrieved from the main memory and is stored in the prefetch cache at a register location which was occupied by the least recently used line in the cache. The invention also includes circuitry and methodology for determining the least recently used line stored within the prefetch cache.

Description: This invention relates in general to a memory means for computers and, more particularly, to cache memories for computers and methods of operation thereof. Modern computers typically include one or more processors for performing the calculations and logical operations generally associated with such machines. Instructions which are to be executed by the processor are stored in a main memory. When a program is run or executed on a computer, its instructions are called out of the main memory and sent to the processor where they are executed. This process takes valuable time. It is known that providing a processor cache memory for use by such processors is one effective way to accelerate the pace at which instructions are executed by the processor. Such a cache memory is a relatively small memory when compared with the size of the main memory. However, a cache memory exhibits a much faster access time than the access time associated with the main memory. The cache memory thus provides relatively quick access to the most frequently used instructions and data. For example, in a typical personal computer application, the main memory may consists of 1-64 Mbytes or more of relatively slow (80 nsec access time) dynamic random access memory (DRAM). However, the cache memory associated with a microprocessor may consist of typically 8 Kbytes to 256 Kbytes or more of fast (20 nsec access time) static random access memory (SRAM). Computers are not designed with a main memory consisting entirely of fast SRAM because SRAM is extremely expensive when compared with DRAM. When instructions and data are called up from the main memory by the microprocessor for execution, they are also stored in the relatively small high speed cache. Thus, the microprocessor has ready access to the most recently executed instructions and data should these instructions and data be needed again by the microprocessor. When the microprocessor needs to use an instruction or data a second time, rather than initiating a relatively slow memory cycle to the slow main memory to retrieve that information, instead the microprocessor quickly accesses the information from the high speed processor cache. Some microprocessors such as the Intel 80386 are designed to use a local processor cache closely coupled to the local bus of the 80386 microprocessor by a cache controller such as the Intel 82385 cache controller. Other microprocessors such as the Intel 80486 employ a small 8K cache integrated within the microprocessor chip itself. Still other microprocessors such as the Motorola 68040 include dual caches within the microprocessor, one cache being used for code caching and the other cache being used for data caching. For simplicity in the remainder of this document both lines of code and lines of data will be referred to as instructions. Clearly, it is important to keep track of precisely which lines of code and data are stored in the cache. One technique is to use a cache which includes so-called TAGS to help identify a request for an instruction or data which is presently located within the cache. The cache includes memory locations for storing TAG addresses which correspond to addresses of the particular information presently stored in the cache. The microprocessor generates a request for an instruction or data in the form of an address. This information is stored in main memory but might also be stored in the cache due to recent prior use. The TAGS are used to determine if the address generated by the microprocessor is one for which the cache contains the needed information. To accomplish this, the address generated by the microprocessor is compared to the TAG addresses. If the address generated in the request from the microprocessor matches a TAG address, then the cache contains the requested information, a TAG hit occurs, and the microprocessor obtains the requested information directly from the local processor cache. However, if the address generated by the microprocessor fails to match any TAG address, then a TAG miss occur. In this case, the requested information is not contained in the local processor cache and a memory cycle to the main memory must be generated to obtain the requested information therefrom. The memory cycle takes valuable time. As the microprocessor processes instructions and data over time, the contents of the cache change. The most frequently used address may also change. For this reason, the situation arises where the cache may be full of information which is recently used and valid; however, that information may not correspond to the information which is being frequently used. To address this problem, least recently used (LRU) logic has been created to help keep the information in the cache current as well as being valid. To do this, LRU logic keeps track of those cache address locations which are least recently used. When a cache miss occurs (no TAG address match was found), a main memory access results. The main memory then provides the'requested information to the microprocessor at which time the cache also stores this information and the corresponding TAG address at one of the TAG locations in the cache. The LRU logic determines which particular TAG location in the cache should be overwritten with the most recent address requested and which resulted from the cache miss. The TAG location where the replacement occurs is the TAG location which the LRU logic determined contained the least recently used TAG address. At one extreme, a cache may have fixed addresses. In the case where the cache addresses are so fixed, then there is no necessity for keeping track of which TAG address is least frequently used. The information itself which corresponds to the fixed TAG address is the only thing which can be updated. In this situation, testing to determine whether or not a cache hit occurs for a particular TAG address is straightforward because the TAG addresses are hard-wired. At the other end of the spectrum is a cache arrangement wherein any TAG location can have any address generated by the microprocessor. In this situation, the determination of a TAG address hit requires reading all of the TAG addresses stored in the cache and testing each TAG address to see if a match occurs between the stored TAG address and the particular address requested by the microprocessor. The later type of cache is referred to a "fully associative cache". It is helpful at this point to review how microprocessors execute instructions stored in main memory. In a computing system, the processor obtains its instructions from a sequence of instruction words which are located in main memory. The sequence of instructions are placed in memory in an orderly fashion one after another at respective sequential addresses. The sequence of instructions is executed by the processor in a serial mode, taking one instruction after another in address order, until either a branch instruction jumps to a new section of code stored elsewhere in main memory or until a "call" or "interrupt" instruction temporarily jumps to a new section of code. Later process flow continues back to the point in the code from which the call or interrupt occurred and execution of subsequent instructions continues. When a branch or call is executed, processing must stop until the new instructions are fetched from memory. Any time spent by the microprocessor waiting during this time period is critical to the effective execution speed of the microprocessor. Modern microprocessors include a memory prefetch for the next line of code. In this manner, the instruction buffer of the microprocessor is kept full. However, this does not reduce the system overhead time spent accessing main memory during branch and call return instructions, namely, the problem discussed earlier. Unfortunately, increasing the prefetch line size can overload the data bus and cause delays for other work. More specifically, the instruction queue for the microprocessor can be viewed as a pipe. As the pipe starts to become empty, the microprocessor performs a code pre-fetch to the next sequential code execution address in main memory to refill the pipe. When a branch instruction is encountered, an out of sequence memory access is requested as the place from which to start filling the pipe. The microprocessor's prefetch ability is mainly used to prevent stalls during which the microprocessor would have to wait in the idle state until new code is available. A code/data cache between the main memory and the microprocessor as in the processor cache discussed above helps ameliorate the problems discussed above to some degree. However, difficulty still exists in filling the processor cache quickly enough with new code and code returns without overloading the bus by gathering many extra code sequences that will not be used. The document IBM Technical Disclosure Bulletin, Vol 31, No. 3, August 1988, NEW YORK, USA, pages 303-306, "High Performance Microprocessor System" discloses a memory system provided with additional pre-fetch queue caches functioning along side with a Conventional State of the art local processor cache memory so as to overcome the additional delay of cache updating in the event of a cache miss. Accordingly, an object of the present invention is to provide a computer system with a cache memory which enhances effective microprocessor execution speed with respect to branch and code return instructions. According to a first aspect of the present invention there is provided a computer system as set out in Claim 1. According to a second aspect of the present invention there is provided a method of accessing a memory means in a computer system as set out in Claim 8. As stated above, the prefetch cache employed in the computer system includes x prefetch cache registers for storing instructions prefetched from the main memory, wherein x is a finite integer. The computer system further includes x Least Recently Used (LRU) counters, each LRU counter corresponding to a respective one of the prefetch cache registers, each counter containing a count value indicating how recently the contents of the corresponding prefetch cache register have been used. Preferably, the system also includes a clearing circuit for clearing a count value designated HIT COUNT in an LRU counter corresponding to a prefetch cash register in which a cache hit has occurred. A first incrementing circuit is coupled to the LRU counters for incrementing all LRU counters whose count value is less than the HIT COUNT value when a cache hit occurs, the count value of the remaining LRU counters remaining unchanged when a cache hit occurs. The system further includes a purging circuit, coupled to the prefetch cache, for purging the prefetch cache of the least recently used line when a cache miss occurs by writing the next line to the particular cache register corresponding to the LRU counter exhibiting a maximum count value. The system also includes a second incrementing circuit, coupled to the LRU counters, for incrementing those LRU counters other than the LRU counter corresponding to the particular cache register into which the next line is written when a cache miss occurs. Embodiments of the present invention will now be described, by way of example, with reference to the accompanying drawings in which:- Figure. 1 is a block diagram of a computer system employing a main memory prefetch cache in accordance with the present invention. Figure 2 is a block diagram of the memory address control circuit portion of the memory controller in the computer system of Figure 1. Figure 3 is a block diagram of the prefetch cache memory circuit portion of the computer system of Figure 1. Figure 4 is a detailed schematic diagram of one of the 16 tag registers employed in the memory address control circuit portion of Figure 2. Figure 5 is a detailed schematic diagram of one of the 16 Least Recently Used (LRU) counters employed in the memory address control circuit portion of Figure 2. Figure 6 is a flowchart which shows an overview of the step by step operation of a method of fetching instructions in accordance with the invention. I. MAIN MEMORY PREFETCH CACHE HARDWARE AND LEAST RECENTLY USED (LRU) LINE SELECTION HARDWARE A computer system in accordance with the present invention is depicted in Figure 1 as system 10. System 10 includes a microprocessor 15 which, in one embodiment, includes a cache 20 integrated in the chip on which microprocessor 15 is fabricated. For example, an INTEL 80486 which includes an 8K internal cache is suitable for use as microprocessor 15. In this configuration, cache 20 is referred to as a "first level" cache. In this particular embodiment, computer system 10 includes another cache memory 25 which is externally coupled to microprocessor 15 as shown. Cache memory 25 is a "second level" cache memory that works in conjunction with first level cache memory 20 to supplement cache memory 20. First level cache memory 20 is relatively small in comparison with the size of second level cache memory 25. Second level cache memory 25 is'an external cache which exhibits a size typically within the range of 32K - 512K bytes or larger of high speed, static read only memory (SRAM). The invention can be also be practiced with a microprocessor 15 which has only an internal cache without an external, second level cache such as cache memory 25. Alternatively, the invention can be practiced with a microprocessor which does not have an integrated cache such as cache 20, provided an external processor cache memory such as cache memory 25 is used in conjunction with the microprocessor. It should be understood that first level cache memory 20 and second level cache memory 25 are both "processor" cache memories in that they are both local to processor 15. Second level cache memory 25 is coupled to a system bus 30 to enable microprocessor 15 to communicate with other components of computer system 10. For example, a disk controller 35 is coupled to system bus 30 to interface one or more hard disk drives 40 to computer system 10. A communication controller card 45 is coupled to system bus 30 to provide system 10 with serial and parallel ports. A memory controller 50 is coupled to system bus 30 as shown. Memory controller 50 includes a prefetch cache memory circuit 55 which is coupled to a main memory 60 via data lines 65. Main memory 60 includes a plurality of memory elements 70, for example dynamic random access memory (DRAM) surface in-line memory modules (SIMMs) or the like. The access time associated with the memory contained in prefetch cache memory circuit 55 is significantly faster than that of memory elements 70. Memory controller 50 also includes a memory address control circuit 75 for controlling requests for access to main memory 60 from microprocessor 15. Memory address control circuit 75 is coupled to system bus 30 and prefetch cache memory circuit 55. Memory address control circuit 75 is also coupled to main memory 60 by address, row address strobe (RAS), column address strobe (CAS), read enable and write enable lines which are shown collectively as lines 80 in Figure 1. Figure 2 shows a more detailed block diagram of the memory address control circuit 75 portion of memory controller 50. Memory address control circuit 75 includes an address tag register and comparator block 85 having 16 sets of address tag registers and comparators, This constitutes one address tag register and comparator combination per each of the 16 registers in prefetch cache 198 (see Figure 3), as discussed later. Memory address control circuit 75 is coupled to system bus 30 as shown to receive address requests therefrom. The tag registers in register/comparator block 85 are used to store the addresses of the instructions which are currently stored in prefetch cache memory circuit 55. The comparators in register/comparator block 85 are used to determine if there is a match (a hit) between a requested address and an address currently stored in prefetch memory 55. Register/comparator block 85 includes two groups of 16 outputs, namely HIT 0 through HIT 15 and HIT+1 0 through HIT+1 15 . When a request is made to memory controller 50 for an instruction at a particular address, one of outputs HIT 0 through HIT 15 corresponding to the register location of that: address in the prefetch cache goes true if there is a cache hit. The operation and configuration of register/comparator block 85 will be discussed in more detail later. Memory address control circuit 75 further includes least recently used (LRU) counter block 90 which contains a set of 16 LRU counters. The LRU counters act to assure that the most often used instructions are contained in prefetch cache memory 55. In other words, the least recently used instruction is selected for replacement when prefetch cache 55 is full. A respective LRU counter is thus provided for each of the address tag registers in address tag register/comparator block 85. More particularly, the first LRU counter in LRU counter block 90 corresponds to and is coupled to the first address tag register/comparator in block 85 via hit output line HIT0, and the second LRU counter in LRU counter block 90 corresponds to and is coupled to the second address tag register/comparator in block 85 via hit output line HIT 1 , and so forth. LRU counter block 90 includes 16 REGx outputs, designated REG 0 , REG 1 , .. REG 15 , which are coupled to a 16 to 4 encoder 95 and back to address tag register/comparator block 85. Encoder 95 converts the 1 of 16 lines into a 4 bit REG POINTER value signal at its output. LRU counter block 90 also includes 16 CNT x outputs, designated CNT 0 CNT 1 , ... CNT 15 , which are coupled to a 16 to 1 multiplexer 100 such that a HIT COUNT signal is generated at the output thereof. The HIT COUNT signal is fed back to LRU counter block 90. A /HIT signal is supplied to multiplexer 100. The nature and function of the REG x ,CNT x , HIT COUNT and /HIT signals will be discussed in a later example. Memory address control circuit 75 also incorporates an address+1 adder 105 which is coupled to system bus 30. Address+1 adder 105 takes an address request received from system bus 30 and advances that address to the next sequential address in main memory. Adder 105 includes an ADDRESS+1 output which is coupled to register/comparator block 85 and to a multiplexer 110 as shown in Figure 2. System bus 30 is also coupled to an input of multiplexer 110. The output of multiplexer 110 is coupled to main memory 70 such that either the requested current address or the current address plus 1 can be passed to and accessed from main memory 70. Figure 3 is a block diagram of prefetch cache memory circuit 55 including read path of main memory controller 50. Prefetch circuit 55 includes a prefetch cache memory 198 having 16 sets of cache registers designated as register sets 200, 201, ... 215. Prefetch cache memory 198 is coupled to main memory 60 such that memory 198 can store instructions (code and data) retrieved from main memory 60. The output of each of cache register sets 200-215 is coupled to a respective input of a 16 to 1 multiplexer 220. The REG POINTER output of memory address control circuit 50 of Figure 2 is coupled to multiplexer 220 as shown in FIG. 3 to select a particular cache register from which data is to be obtained. Main memory 60 is also coupled via an input register 225 to an input of a 2 to 1 multiplexer 230. The output of 16 to 1 multiplexer 220 is coupled to another input of 2 to 1 multiplexer 230 as shown in Figure 3. Multiplexer 230 includes an output which is coupled via an output register 235 to a 4 to 1 multiplexer 240. Multiplexer 230 also includes a /HIT input to select whether data for the processor comes from main memory or from the data cache. The output of 4 to 1 multiplexer 240 is coupled to system bus 30 such that lines or instructions (code and data) at requested addresses can be provided to microprocessor 15 at the bus width needed by microprocessor 15. A detailed schematic diagram of one of the 16 tag registers 85 used in memory address control circuit 75 is shown in Figure 4 as tag register circuit 85(0). The sample tag register 85(0) includes ADDR+1, LOAD, ADDR, REG x , INVALIDATE and RESET inputs. The function of the ADDR signal received from system bus 30 is to communicate to memory controller 50 the particular address corresponding to an instruction which microprocessor 15 wants to retrieve from main memory 60. The ADDR+1 input of tag register 85(0) is coupled to the ADDR+1 output of ADDRESS+1 adder 105. It will be recalled that whereas ADDR is the address which microprocessor is currently attempting to retrieve from main memory 60, ADDR+1 is the next sequential address in main memory 60 following address ADDR. In other words, ADDR+1 is the address of the next sequential line or instruction following ADDR. The ADDR+1 comparator is needed to prevent loading a second ADDR+1 line into the cache if a first ADDR+1 line is already present therein. The ADDR+1 input of tag register 85(0) is coupled to the D input of a D flip flop 245 as shown in Figure 4. The LOAD input of tag register 85(0) is coupled to one input of a two input AND gate 250, the remaining input of which is coupled to the REG x input and one input of another two input AND gate 255. The derivation of the REG x signal on the REG x input will be discussed later. The INVALIDATE line is coupled to the remaining input of AND gate 255. The INVALIDATE pulse is used to clear the "VALID" bit of a cache line if processor 15 is writing to main memory and the main memory location was previously stored in the cache. The output of AND gate 250 is coupled to the clock input of D flip flop 245 and to the S input of an RS flip flop 260. The output of AND gate 255 is coupled to the R input of RS flip flop 260. The output of RS flip flop 260 is designated as the VALID output and is coupled to one input of multi-input AND gate 265 and to one input of multi-input AND gate 270. The ADDR+1 input of tag register 85(0) is coupled to one input of two input EX OR gate 285, the remaining input of which is coupled to the Q output of D flip flop 245 and to one input of a two input EX OR gate 290. The remaining input of EX OR gate 290 is coupled to the ADDR input of tag register 85(0). Flip flop 245 and EX OR gates 285 and 290 form a block 292 which is repeated in tag address register/comparator block 85(0) as many times as there are address bits in main memory 60. For example, wherein computer system 10 is a 32 bit system, block 292 is repeated 32 times, namely, once per each bit of the address. The outputs of EX OR gates 285 and 290 in such repeated blocks 292 are coupled to respective inputs on AND gates 265 and 270. To reflect this connection, AND gates 265 and 270 are illustrated with multiple inputs in Figure 4 although to conserve space the specific connection of each of such multiple inputs is not shown. Accordingly, a HIT x signal is generated at the output of AND gate 270 and a HIT+1 x signal is generated at the output of AND gate 265. If the HIT x signal is true, this indicates that a match to the current processor access request can be supplied from the prefetch cache at register location x therein. It will be recalled that the 16 data registers of prefetch cache 198 are labelled 200-215 which corresponds to values of x from 0-15. In other words, if HIT 3 goes true, there is a hit in prefetch register 203, and so forth. If the HIT x +1 signal is true, then the next sequential memory line is already in the prefetch cache and it is not necessary to do a memory prefetch for this line. One of the 16 least recently used (LRU) counters employed in the memory address control circuit 75 is shown in Figure 5 as LRU counter 90(0). LRU counter 90(0) includes inputs HIT COUNT, /HIT, PRESET, PRESET VALUE x , LOAD and HIT x to which HIT COUNT, /HIT, PRESET, PRESET VALUE x , LOAD and HIT x signals are respectively provided . The LOAD input of LRU counter 90(0) is coupled to one input of a two input AND gate 300 and to one input of a two input NAND gate 305. The /HIT input of LRU counter 90(0) is coupled to one input of a two input AND gate 310, the output of which is coupled to one input of a two input OR gate 315. The remaining input of OR gate 315 is coupled to the HIT x input. The output of OR gate 315 is coupled to the remaining input of NAND gate 305 and forms the REG x output of LRU counter 90(0) at which the REG x output signal is generated. The output of AND gate 300 is coupled to the INC input of a counter 320. The output of NAND gate 305 is coupled to an inverting clear input CLR of counter 320. The PRESET and PRESET VALUE x signals are provided to counter 320 as shown in Figure 5. The PRESET VALUE x signal provides 16 different initial count values to the 16 respective LRU counters 320 at a time indicated by the PRESET command signal. The output of counter 320 is designated CNT x and is coupled to the B input of a comparator'325 having inputs A and B. The HIT COUNT input value is provided to the remaining A input of comparator 325 as shown. Comparator 325 checks to see if the CNT x value is equal to the HIT COUNT value and if so the B=A output of comparator 235 goes true. Comparator 325 also checks to see if the CNTx value is greater than the HIT COUNT value and if so the B<A output of comparator 235 goes true. The B=A output of comparator 325 is coupled to the remaining input of AND gate 310. The B<A output of comparator 325 is coupled to the remaining input of AND gate 300. LRU counter block 90 operates in the following manner. The LRU mechanism employed in counter block 90 consists of a 4 bit LRU counter 320 associated with each of the 16 cache tag entry/lines. Thus in this particular embodiment, counter 320 has 16 possible count values, namely 0,1,2,...15. If a cache hit on line x occurs, then line x's counter will be cleared and all counters for lines having a count value lower than x's previous count value are incremented by 1 when the LOAD pulse occurs. If a cache miss occurs, then the tag register and cache line corresponding to the counter that has a count value 1111 (or decimal 15) are cleared and used for the new tag/data and all other counters are incremented by 1. Counters 320 do not overflow, but rather are all initialized to an incrementing value from 0000 to 1111. II. PREFETCH CACHE OPERATIONAL OVERVIEW A general overview of the operation of the main memory prefetch cache mechanism in computer system 10 is now provided. Main memory prefetch cache 55 may be viewed as assisting a processing unit 15 which already has a processor cache such as internal cache 20 and/or external cache 25. It is helpful at this point to consider the operation of computer system 10 from the time of start-up or initialization. Upon system startup, the contents of external cache 25 and/or internal cache 20 are all invalid, because they essentially have no contents. The contents of prefetch cache 55 are likewise invalid for the same reason. Each of these caches have invalid bits associated with them so that it can be determined whether or not a particular location in the respective caches contain valid instructions. In the present discussion, the term "line" includes instructions, whether they be code or data. A line may include a block of information such as an 8 or 16 byte block, for example. Such lines are stored in main memory in sequential address order, one after the other. When microprocessor 15 attempts to access a current line (a first instruction which is either code or data) it sees that the contents of all caches are invalid and therefore an access directly to main memory 60 (DRAM) is made. Memory controller 50 locates the current line in main memory 60 and sends the current line to output register 235 where it is later transferred to microprocessor 15 for processing. The current line is stored in one or both of internal cache 20 and external cache 25, and the current line+1 is prefetched and stored in prefetch cache 55. The current line+1 is defined as the instruction stored at the next sequential instruction address in main memory 60 after the current instruction. More particularly, the current line+1 is accessed and stored in prefetch memory simultaneously with the transfer of the current line to the processor so as not to contribute to system overhead. The microprocessor then proceeds to the next line (next instruction) in the particular program that it is executing, this new line now being designated as the new current line. Microprocessor 15 sends a request for the new current line to memory controller 50, such request consisting of the address of the new current line. Memory controller 50 starts a main memory cycle (DRAM cycle) and simultaneously looks to see if the requested new current line is stored in prefetch cache memory 55. If the new current line is stored in prefetch cache 55 as per a cache hit, it is accessed, sent to microprocessor 15 for processing and the main memory cycle (DRAM cycle) is modified to retrieve the new current line+1. Once retrieved, the new current line+1 is stored in prefetch cache 55. In this manner, the prefetch mechanism employed in prefetch cache 55 stays one step ahead of line requests to memory controller 50 without contributing any extra system bus cycle overhead. In actual practice, when a cache hit occurs. the new current line is retrieved from prefetch cache 55 and temporarily stored in output register 235 for later transfer to microprocessor 15. When the current line+1 comes in from main memory, it is stored back into the same location in the prefetch cache that the current line was in. Because of this, a small set of cache registers can track multiple processing threads. If the microprocessor's line request to memory controller 50 is the result of a branch instruction in the program which is being executed, then the lookup in prefetch cache memory 55 will fail and a cache miss occurs. In the event of a cache miss, the main memory cycle (DRAM cycle) is not modified, but rather continues. In other words, the address sought in the memory cycle which results from the memory request is not changed and the memory cycle proceeds forward. The instruction (code or data) at the requested address in main memory 60 is obtained and stored in output register 235 for later transfer to microprocessor 15. A DRAM page mode access continues and retrieves the next line after the new current line (ie. the new current line+1). The new current line+1 is then stored in prefetch cache 55 so that prefetch cache 55 is prepared if microprocessor 15 continues executing instructions along the same sequential instruction path. This fetch from main memory 60 is at page mode access speed and is faster than a normal main memory access. The cache miss scenario described immediately above is in contrast to the cache hit scenario described earlier wherein the new current line corresponding to the requested address was found to be stored in prefetch cache 55. It will be recalled that in the event of such a cache hit, the address sought from main memory in the main memory cycle was modified from the address of the new current line to the address of the new current line+1. The new current line+1 retrieved from main memory is then used to overwrite the new current line which was found to be stored in the prefetch cache. III. LEAST RECENTLY USED (LRU) LINE SELECTION OPERATIONAL OVERVIEW The purpose of LRU counters, encoder 95 and multiplexer 100 is to select the particular line in prefetch cache memory 55 which has been least recently used. More particularly, in a cache miss situation, this least recently used line is replaced with new data from the main memory when the cache becomes full. It is helpful at this point to consider the REG POINTER signal depicted in Figure 2 at the output of encoder 95. Considering FIG. 2 in conjunction with FIG. 3, the main purpose of the REG POINTER signal is to select from which of prefetch data cache registers 198 that data is going to be obtained. It is also noted that in Figure 2, the REG POINTER signal is fed back to multiplexer 100 to select which of the 16 CNT x count values provided to multiplexer 100 gets fed back to LRU counters 90 as HIT COUNT. A respective LRU counter 320 is provided for each of the 16 lines stored in the 16 prefetch cache registers 200-215 in prefetch memory 55. Each of the LRU counters 320 in LRU counter block 90 maintains a count number, CNT x , which indicates how recently the corresponding line in cache 55 has been accessed or used, wherein x varies from 0 through 15 according to which of the 16 counters or corresponding lines in the prefetch cache memory is being referenced. If in a cache hit situation a particular LRU counter 320 contains a count of 0, then the corresponding register in prefetch memory register block 198 has just had a line of data written to it. This action causes the count value in that LRU counter 320 to be reset to 0 indicating that the corresponding prefetch data register has been most recently used. If in the next memory cycle, no data is needed from that same line or location in that particular register, then the corresponding LRU counter is incremented from a value of 0 to a value of 1. Selected ones of the remaining 15 LRU counters are also incremented by 1 as described later. When the count CNT x of a particular LRU counter reaches 15, then the data in the prefetch memory location corresponding to that LRU counter is selected for replacement should a cache miss occur. Returning now momentarily to Figure 2, it is again noted that a respective address tag register/comparator 85 block is provided for each of prefetch cache data registers 200-215. That is, tag register circuit 85(0) is provided for cache register 200, tag register circuit 85(1) is provided for cache register 201 and tag register 85(15) is provided for cache register 215. When the microprocessor attempts to access a particular main memory location, the memory controller first looks to the prefetch cache to see if the requested instruction is contained in a line stored therein. Block 85 checks to see if there is a cache hit in prefetch cache 55. More particularly, block 85 checks to see if any of the 16 prefetch cache registers 200-215 in prefetch cache 55 contain the requested line, the address of which is provided to each of the 16 ADDR inputs of the 16 blocks 85 (see Figure 4). This is accomplished by checking the address of the requested line with the addresses stored in the 16 tag registers within block 85. If there is a match, then there is a cache hit. Blocks 85 also conduct a check to determine if the ADDR+1 line is already stored in prefetch cache memory. This is done to make sure that the same line is not stored in the prefetch cache at two different locations. When a match occurs between the current line requested by microprocessor 15 and a tag address in one of the 16 tag register circuits 85(0) 85(15), then under these cache hit conditions the particular HIT output of block 85 corresponding to that tag address goes true (see Figure 2). For example purposes, in the subsequent discussion it is assumed that a cache hit has occurred wherein the requested line matches the tag address in the third tag register circuit 85(3). Thus, the HIT 3 output of address tag register/comparator block 85 is true. The HIT outputs HIT 0 , HIT 1 , HIT 2 and HIT 4 - HIT 15 are all false in this case. It is arbitrarily assumed that LRU counter 320 in LRU counter circuit 90(3) has a CNT 3 count value of 8. It will be recalled that the CNT value indicates how fresh or stale a particular tag address and its line are with respect to the other tag addresses and lines. A CNT value of 0 indicates the freshest or most recently used line and a CNT value of 15 indicates the most stale or least recently used line. The true HIT 3 value is fed to OR gate 315 as seen in the LRU counter of Figure 5 and appears at the output thereof as REG x which in this example is REG 3 . In this case, REG 3 is true while all other REG x values other than REG 3 are false. The REG 3 value is provided to encoder 95 (Figure 2) which supplies a value of 3 at its 4 bit REG POINTER output so that the line stored in prefetch cache data register 203 (Figure 3) of prefetch cache 198 can be selected. (Note the numerical correspondence of the REG POINTER value of 3 and the prefetch data register number 203 which it selects. A REG POINTER value of 4 would be used to select the contents of prefetch register 204, and so forth.) Returning again to Figure 2, the REG POINTER value of 3 is also supplied to multiplexer 100 such that the particular count CNT 3 (ie. CNT x wherein x=3) of the LRU counter circuit 90(3) is fed back to LRU counters 90 as HIT COUNT. Thus, in this particular example wherein CNT 3 is assumed to have a value of 8, a HIT COUNT value of 8 is fed back to LRU counters 90. It will be recalled that each of the 16 LRU counters is associated with a respective corresponding tag address register and prefetch cache data register. The CNT values in the LRU counter circuits 90 are changed (incremented or cleared) according to the recentness of use of the corresponding data lines in the prefetch cache data registers. Whenever a cache hit occurs, the LRU counter 90(x) corresponding to the data line for which the hit occurred is set back to 0 indicating that such data line is most recently used. Also when such a cache hit occurs, the current line requested by the microprocessor is moved from the appropriate prefetch cache data register 200 to output register or buffer 235 for subsequent transmittal to the microprocessor. The current line is overwritten with the next line from main memory and the tag register 85(x) corresponding to the overwritten line is updated with the new address information of the next line for prefetch cache content tracking purposes. The operation of LRU counter circuit 90 is now discussed in more detail with reference to LRU counter circuit 90(0) of Figure 5. Upon initialization of computer system 10, a different unique CNT x value from 0 to 15 is stored in the respective LRU counters 320 of counter circuits 90(0), 90(1),... 90(15). For purposes of discussion, an LRU counter circuit 90(3) which is identical to LRU counter circuit 90(0) is now considered. It was earlier noted that LRU counter circuit 90(3) is the LRU counter corresponding to the prefetch cache register 203 for which a cache hit was observed. It was arbitrarily assumed for purposes of example that the CNT 3 value in counter 90(3) is 8. Thus a CNT 3 value of 8 is provided to the B input of comparator 325. A HIT COUNT value of 8 is also provided to the A input of comparator 325 in this case. Comparator 325 conducts a comparison test and finds that in the present case A=B and thus the A=B output of comparator 325 goes true. Since A=B, it is known that a hit has occurred. Thus AND gate 310 is blocked and a false appears at the output of AND gate 310. The B<A output of comparator 325 is also false. In this situation, register 320 will not be incremented when a LOAD pulse appears at the LOAD input to AND gate 300. During the time at which the prefetch cache is being loaded with data from main memory 60, the LOAD pulse is issued. When the LOAD pulse is issued, the values stored in the LRU counters 320 change in the manner now described. In the present example, when the LOAD pulse is issued, it is blocked by AND gate 300 and the output of AND gate 300 is false. However, under these conditions the LOAD pulse drops down and feeds through NAND gate 305 to cause LRU counter 320 to be cleared or reset to a count value of 0. That is, the CNT 3 count in LRU counter 320 of counter circuit 90(3) goes from a value of 8 to a value of 0. This indicates that a cache hit has occurred and that the contents of the corresponding prefetch cache data register 203 are "most recently used" or fresh. As will be seen in the subsequent discussion, the contents of the LRU counters 320 in selected ones of the remaining counter circuits 90(0), 90(1), 90(2) and 90(4) through 90(15) are incremented by one to reflect that their respective contents have become less recently used by a quantity of one. For example purposes, LRU counter 320 in remaining counter circuit 90(0) is now considered in the present case where the cache hit occurred in prefetch data register 203 (to which counter circuit 90(3) corresponds). Since the cache hit occurred in prefetch data register 203 and not in register 200 (which corresponds to counter circuit 90(0)), it is observed that HIT(0) is false, but HIT COUNT is still 8. It is assumed that the count value CNT 0 stored in LRU counter 320 in counter circuit 90(0) is a 5, an arbitrary value selected for purposes of this example. Since HIT COUNT is 8, then A is 8 at comparator 325. Also since CNT 0 is 5 in our example, B is 5 at comparator 325. Thus, the B<A output of comparator is true and when the LOAD pulse is issued, the output of AND gate 300 goes true causing counter 320 of counter circuit 90(0) to be incremented by one. The CNT 0 count value stored in counter 90(0) thus moves from a value of 5 to a value of 6. Moreover, all of the LRU counters which contain a value less than 8 will be incremented. However, any LRU counters containing a value greater than HIT COUNT, or 8 in this case, keep the same contents. For example, if the LRU counter 320 in counter circuit 90(7) has a CNT 7 value of 9, then A=8 and B=9 at comparator 325. Neither B=A nor B<A are true at comparator 325. Since there is no HIT to turn AND gate 310 on, the contents of LRU counter 320 in counter 90(7) are not cleared or reset to zero on the issuance of the LOAD pulse, but rather remain the same as before, namely a CNT 7 value of 9. Similarly, the contents of any other LRU counters which contain a CNT x value of 9 or more (ie. greater than HIT COUNT) will remain the same. To summarize the operation of the LRU mechanism in conjunction with the prefetch cache mechanism of the present invention, the case of a cache hit is first considered. In a cache hit, the current line requested by the microprocessor is contained in prefetch cache 55. The current line is retrieved and sent to output register 235 for transfer to the microprocessor. The next line subsequent to the current line is retrieved from main memory and is used to overwrite the current line in the prefetch cache. Moreover, when a cache hit occurs on a line in a particular prefetch data register 200-215, then the particular LRU counter 90(0)-90(15) corresponding to that prefetch data register is cleared (reset to zero) and all remaining LRU counters 90 having a count value less than the count value in that particular counter are incremented by one. The count value in the remaining LRU counters 90 is unchanged when there is a cache hit. However, if a cache miss occurs, then the current line requested by the microprocessor is not contained within the prefetch cache. In this case, the particular tag register 85 and particular prefetch cache register 200-215 corresponding to the LRU counter 90 whose count value equals the maximum count of 1111 (decimal 15) are selected. When the LOAD pulse occurs, this particular tag register and prefetch cache register are then used to store the new tag address and new data line (current line) from main memory, respectively, and this LRU count is cleared from a count of 15 to zero. All remaining counters 90 are incremented by 1 in the case of a cache miss. IV. METHODOLOGY - STEP BY STEP PROCESS FLOW A flowchart depicting an overview of the step by step operation of the invention is shown in Figure 6. Computer system is 10 initialized at block 400 and starts executing instructions at block 405 at which microprocessor 15 requests a current line. Since computer system 10 was just initialized, cache misses occur in the internal cache 20, the external cache 25 and the main memory prefetch cache 55. In that event, memory controller 50 locates the current line in main memory 60 as a result of a main memory cycle as per block 410. The current line is sent from main memory 60 to output register 235 at block 415 and is later transmitted to microprocessor 15 as per block 420. Simultaneously with block 420 wherein the current line is sent to microprocessor 15, the current line+1 is prefetched from main memory 60 and is stored in prefetch cache memory 55 as per block 425. Microprocessor 15 continues executing its program and then requests a new current line as per block 430. In response, memory controller 50 starts a main memory cycle at block 435 to retrieve the new current line. Memory controller 50 then determines if the new current line is in prefetch cache 55 as per block 440. This determination is made at the beginning of the main memory cycle initiate at block 435. If it is determined that the new current line is stored in prefetch cache 55, then the new current line in the cache is accessed and stored in output register 235 as per block 445. The new current line is then sent from output register 235 to microprocessor 15 as per block 450. The main memory cycle commenced at block 435 is the modified at block 455 to retrieve the new current line+1 from main memory 60 instead of the new current line. This retrieval of the new current line+1 in block 455 occurs simultaneously with transmission of the new current line to microprocessor 15 at block 450. The new current line+1 which was retrieved from main memory 60 is then stored in prefetch cache 55 by overwriting the current line with the new current line+1 as per block 460. In block 461, the particular LRU counter 90(x) which corresponds to the particular prefetch cache data register in which the hit occurred is then cleared or reset to zero to indicate that this particular prefetch data register's contents are the most recently used. This particular prefetch data register's contents are the most recently used because the new current line+1 has just overwritten the current line which previously occupied this location. The LRU counters which have a count value less than HIT COUNT are incremented by one as per block 462. The count value in the remaining LRU counters is left unchanged as per block 463. Flow then continues back to block 430 at which microprocessor 15 executes the next instruction in the program and requests another new current line from memory controller 55. If however it is determined in decision block 440 that the new current line is not stored in prefetch cache 55 (ie. a cache miss), then the main memory cycle initiated at block 435 is continued at block 465 to retrieve that new current line from main memory 60. Once retrieved, the new current line is stored in output register 235 as per block 470 for later transfer to microprocessor 15 as per block 475. The main memory page mode access continues so as to retrieve the new current line+1 at block 480 simultaneously with the new current line being sent to microprocessor 15 at block 475. The new current line+1 is then stored in prefetch cache 55 at the register location corresponding to the particular LRU counter circuit 90(x) exhibiting a maximum count value as per block 485. The least frequently used line was stored in that register location and is purged by this action. The remaining LRU counter circuits 90 are then incremented by one as per block 490. Flow then continues back to block 430 at which microprocessor 15 executes the next instruction in the program and requests yet another new current line from memory controller 55. While the above description sets forth a computer system, it is clear that a method of operating the computer system is also disclosed. More particularly, a method of accessing the main memory of a computer is disclosed which includes the step of providing a main memory prefetch cache situated in a memory controller and coupled to the main memory. The method includes the step of initiating a main memory cycle to retrieve a current line from the main memory. The method further includes the step of determining, by the memory controller, if the current line is stored in the prefetch cache. If the current line is determined to be stored in the prefetch cache, then the method includes retrieving the current line from the prefetch cache and providing the current line to the processor, and retrieving the next line from the main memory and overwriting the current line in the prefetch cache with the next line. If however the current line is determined not to be stored in the prefetch cache, then the method includes retrieving the current line from the main memory and providing the current line to the processor, and retrieving the next line from the main memory and storing the next line in the prefetch cache. In an implementation of the method wherein the prefetch cache includes X registers (X is a number), the method further includes the steps of providing a respective least recently used (LRU) counter corresponding to each of the registers in the prefetch cache and initializing each of the LRU counters at a unique predetermined count value between 0 and X inclusive. If in the determining step the current line is determined to be stored in the prefetch cache as per a cache hit, then the method includes clearing the count value stored in the particular LRU counter corresponding to the register in the prefetch cache for which the cache hit occurred and further includes incrementing the LRU counters whose count values are less than the count value of the particular LRU counter prior to the clearing step. If in the determining step the current line is determined not to be stored in the prefetch cache as per a cache miss, then the method includes storing the next line in the register in the prefetch cache corresponding to the LRU counter having a maximum count X, and further includes incrementing the remaining counters. The foregoing has described a computer system including a cache memory which enhances effective microprocessor execution speed with respect to branch and code return instructions. The disclosed computer system employs a prefetch cache memory which is integrated in the memory controller of the main memory to enhance performance significantly. The computer system of the present invention includes a main memory prefetch cache which achieves prefetching without contributing extra system overhead. Moreover, the disclosed main memory prefetch cache can also enhance the performance of multiprocessor computer systems. In view of the foregoing it will be clear to a person skilled in the art that modification may be incorporated without departing from the present invention.

Claims: A computer system (10) comprising: a processor (15); a processor cache (20) coupled to said processor (15); a memory controller (50) coupled to said processor (15); and a main memory (60) coupled to said memory controller (50); said memory controller (30) including: a main memory prefetch cache (55) comprising x prefetch cache registers (198) for storing information prefetched from said main memory (60), wherein x is a finite integer, and a control means (75) coupled to said prefetch cache for determining if a cache hit has occurred wherein a current line requested by said processor (15) is stored in one of said prefetch cache registers (198) and, if so, then retrieving said current line from said prefetch cache register (198) for use by said processor (15) and overwriting said current line in said prefetch cache register (198) with a next line from said main memory (60), or otherwise when none of said prefetch cache registers (198) contain said current line requested by said processor (15) thus signifying a cache miss, then retrieving said current line from said main memory (60) for use by said processor (15) and retrieving said next line from said main memory (60) and storing said next line in said prefetch cache (55) such that said next line is transferred to said prefetch cache (55) prior to a request for said next line from said processor (15); characterised in that the computer system (10) further comprises x Least Recently Used (LRU) counters (90), each LRU counter (90) corresponding to a respective one of said prefetch cache registers (198), each counter (90) containing a count value indicating how recently the contents of the corresponding prefetch cache register (198) have been used, and in that the control means (75) is arranged to determine, on the basis of the count values, the least recently used line in said prefetch cache registers (198) which is to be overwritten with the next line, thereby enabling the prefetch cache (55) to operate as a fully associative memory cache. A computer system (10) as claimed in Claim 1, further comprising clearing means (100) for clearing a count value designated HIT COUNT in an LRU counter (90) corresponding to a prefetch cache register (198) containing a requested line of information wherein a cache hit is said to have occurred. A computer system (10) as claimed in Claim 2, further comprising first incrementing means (85), coupled to said LRU counters (90), for incrementing all LRU counters (90) whose count value is less than said HIT COUNT value when a cache hit occurs, the count value of the remaining LRU counters (90) remaining unchanged when a cache hit occurs. A computer system (10) as claimed in Claim 3, further comprising purging means, coupled to said prefetch cache (20) for purging said prefetch cache (20) of the least recently used line when a cache miss occurs by writing said next line to the particular cache register (198) corresponding to the LRU counter (90) exhibiting a maximum count value. A computer system (10) as claimed in Claim 4, further comprising second incrementing means, coupled to said LRU counters (90), for incrementing those LRU counters (90) other than the LRU counter (90) corresponding to said particular cache register (198) into which said next line is written when a cache miss occurs. A computer system (10) as claimed in any previous claim, characterised in that said processor cache (20) comprises an internal processor cache integrated in said processor (15). A computer system (10) as claimed in any previous claim characterised in that said processor cache (20) comprises an external processor cache externally coupled to said processor (15). A method of accessing memory in a computer system (10) including a processor (15), a processor cache (20) coupled to the processor (15), a memory controller (50) coupled to the processor (15), a main memory (60) coupled to the memory controller, a main memory prefetch cache (55) comprising x prefetch cache registers (198) for storing information prefetched from the main memory (60), wherein x is a finite integer; and control means (75) coupled to the prefetch cache (55); the method comprising: initiating a main memory cycle to retrieve a first line of information from said main memory (60); determining, by said control means (75), if said first line of information is stored in one of said prefetch cache registers (198) and, if so, then retrieving said first line of information from said prefetch cache register (198) and providing said first line of information to said processor (15), retrieving the next line of information from said main memory (60) and overwriting said first line of information in said prefetch cache register (198) with said next line of information from said main memory (60) and, if said first line of information is determined not to be stored in any of said prefetch cache registers (198), then retrieving said first line of information from said main memory (60) and providing said first line of information to said processor (15), and retrieving said next line of information from said main memory (60) and storing said next line of information in said prefetch cache (55) prior to a request for said next line from said processor (15), characterised in that the method further comprises: determining by use of x Least Recently Used (LRU) counters (90), which each correspond to one of the prefetch cache registers (198) and each contain a count value indicating how recently the contents of the corresponding prefetch cache register (198) have been used, the least recently used line in said prefetch cache registers (198) on the basis of the count values, if said first line of information is not located in said prefetch cache registers (198) and a cache miss is said to have occurred; retrieving said first line of information from said main memory (60); and storing the next line of information from said main memory (60), subsequent to said first line of information, in the particular prefetch cache register (198) occupied by said least recently used line of information, thereby enabling implementation of the method in a manner suitable for a fully associated memory cache. A method as claimed in Claim 8, characterised by modifying said main memory cycle to retrieve the next line of information from said main memory (60) rather than said first line of information when in said determining step it is determined that the first line of information is stored in said prefetch cache (55). A method as claimed in Claim 8 or 9, further comprising: providing a respective least recently used (LRU) counter (90) corresponding to each of the x registers (198) in said prefetch cache (55); initializing each of said LRU counters (90) at a unique predetermined count value between 0 and X inclusive; if in said determining step said first line of information is determined to be stored in said prefetched cache (55) as per a cache hit, then clearing the count value stored in the particular LRU counter (90) corresponding to the register (198) in said prefetch cache (55) for which said cache hit occurred; incrementing said LRU counters (90) whose count values are less than the count value of said particular LRU counter (90) prior to said clearing step; if in said determining step said first line of information is determined not to be stored in said prefetch cache (55) as per a cache miss, then storing said next line of information in the register (198) in said prefetch cache (55) corresponding to the LRU counter (90) having a maximum count X, and incrementing the remaining LRU counters (90).

Inventors: KASS WILLIAM J, KASS, WILLIAM J.
Applicants: NCR INT INC, NCR INTERNATIONAL, INC.
Application year: 1993
Main classification: G06F12
IPC codes: G06F12, G06F9