Data processing system with cache linefill buffer and method of operation

When data in first and second requests from a processor does not reside in cache memory, a first data element responsive to the second request is received by a cache controller from an external memory module after a first data element responsive to the first request and before the second data element responsive to the first request. Ownership of a linefill buffer is assigned to the first request when the first data element responsive to the first request is received. Ownership of the linefill buffer is re-assigned to the second request when the first data element responsive to the second request is received after the first data element responsive to the first request is received.

BACKGROUND

This disclosure relates generally to data processing systems, and more specifically, to a data processing system with a cache linefill buffer.

2. Related Art

Cache memories are typically used within data processing systems in order to reduce memory access times. Caches are smaller, faster memories used to store copies of data which reside in the slower memory. Since caches are typically much faster to access than the memory, it is desirable to store data which resides at more frequently accessed memory locations within the cache. If a read memory access request (i.e. a load access request) is made to a cache, and the access address of the read access request is stored in the cache, a cache hit occurs and the read data can be provided from the cache rather than having to access the slower memory. This prevents the extra latency introduced from having to access the slower memory to respond to the access request. However, if the read memory access request is not stored in the cache, a cache miss occurs and the read request is made to the memory to retrieve the read data. The read data can also be stored into the cache so that, if subsequently accessed, a cache hit will occur. Furthermore, in an attempt to improve the rate of cache hits, the read request to the memory can be provided as a burst request in order to obtain a full cache line of data rather than just the specifically requested data. A linefill buffer may be used to collect the data received in response to the burst request prior to updating the cache with the data. In this manner, a full cache line can be collected prior to updating the cache.

In many data processing systems, external memories are capable of handling multiple outstanding access requests and can provide read data in response to these access requests out of order. While additional linefill buffers may be used to collect cache line data for different cache lines, additional linefill buffers result in increased circuit area which is undesirable. Therefore, a need exists for a cache controller which is capable of handling multiple outstanding access requests, with either in or out of order return data, without expanding the number of linefill buffers.

DETAILED DESCRIPTION

In one embodiment, in response to multiple read requests from a central processing unit (CPU) which result in cache misses in the cache, multiple burst requests are provided by the cache controller to external memory. The burst requests can be generated to either allow in order or out of order data returns. Furthermore, only a single linefill buffer having a size necessary to store a single cache line of the cache is available for collecting data received from the burst request. Therefore, in one embodiment, the cache controller, in addition to providing the CPU the requested data in response to its multiple read requests (which corresponds to the critical beats returned for each burst request), also assigns ownership of the single linefill buffer to the collection of data corresponding to a single cache line corresponding to the burst request which returned its critical beat latest. In doing so, the cache controller may abort a cache line fill which was in progress for a previous incomplete burst access.

FIG. 1illustrates, in block diagram form, a data processing system10in accordance with one embodiment of the present inventions. System10includes a central processing unit (CPU)12(which may also be referred to as a processor), a cache20, a cache controller14, a bus interface unit (BIU)22, a system interconnect14, and a memory26. Note that additional elements may be present in system10, such as other caches, other memories, input/output (I/O) devices, or other peripherals. CPU12can be any type of processor and is bidirectionally coupled to cache controller14. Cache controller14includes a linefill buffer16and a critical access buffer18. Cache controller14is bidirectionally coupled to cache20and BIU22. BIU22and memory26are each bidirectionally coupled to system interconnect24.

In the illustrated embodiment, linefill buffer16is storage circuitry that is configured to hold, at most, only a single cache line of data. For example, each cache line of cache20may correspond to 4 doublewords, such that each cache line is 32 bytes. In this case, linefill buffer16is a single 32-byte buffer. Alternatively, the cache lines of cache20may be of a different size. In one embodiment, each cache line may be 8 doublewords, such that each cache line is 64 bytes. In this case, linefill buffer16is a single 64-byte buffer. Critical access buffer18is storage circuitry that is configured to hold a requested data element that has been requested by CPU12. For example, in one embodiment, for a read request by CPU12, a doubleword of data is returned. In this case, critical access buffer18may be a 8-byte buffer (i.e. 64-bit buffer).

In one embodiment, system interconnect24is a bus which operates in accordance with the AXI protocol. The AXI protocol is capable of accepting multiple outstanding burst requests from cache controller14and can return the data out of order. Memory26can be any type of memory and is typically slower to access as compared to cache20. Memory26may also be referred to as an external memory or an external memory module. Furthermore, there may be other masters in system10(such as other peripherals) which may access memory26by way of bus24.

In operation, CPU12is capable of making load or store (i.e. read or write) memory access requests to memory26. For each memory access request, CPU12may provide an access address and control information to cache controller14. Cache controller14then determines whether the access request hits or misses in cache20. Note that in making the hit or miss determination, cache controller14also looks to linefill buffer16to determine if the current access request is within linefill buffer16. If so, then a cache hit is still considered to occur. In the case of a cache miss, such as for a read access request, cache controller14provides a read access request, via BIU22, to bus24. Memory26can then process the access request and provide return data onto bus24. In one embodiment, cache controller14provides the read access request as a burst read request to bus14, in which each burst read request indicates a burst size. In one embodiment, the burst size corresponds to the number of burst elements corresponding to a cache line. Therefore, in the case of a cache line of cache20being 4 doublewords, cache controller can provide a burst read request of 4 doublewords, in which data is returned in 4 beats, each beat being one double word. Each burst access returns a critical beat (which corresponds to the data element requested by the CPU's original read request which resulted in the cache miss) and additional non-critical beats which are used to complete a full cache line for use in updating cache20. Cache controller20receives the return beats and stores the data into linefill buffer16. Once linefill buffer16completes a full cache line of data, cache controller14can update cache20with the entry stored in linefill buffer16.

In the illustrated embodiment, bus24operates in accordance with a protocol, such as the AXI protocol, which supports two outstanding burst requests in which the data can be returned out of order. Note that the AXI protocol, in other implementations, may support more than two outstanding burst requests. For example, CPU12may make a read request for data stored at address A0, and, before receiving the read data, may make another read request for data stored at address B0. This example will be described in more detail in reference toFIG. 2.FIG. 2illustrates a method50for processing CPU read requests in accordance with one embodiment of the present invention. In block52, CPU provides read requests for data at A0 and for data at B0 to cache controller14. Cache controller14determines whether address A0 and address B0 result in a hit or miss in cache20. If cache controller14determines that A0 results in a cache miss and B0 results in a cache miss, then cache controller14provides a burst access request with a burst size of 4 beats for each of A0 and B0. Therefore, for A0, the burst access request is for data elements stored at A0, A1, A2, and A3, in which the data element returned for A0 corresponds to the critical beat of the burst access and the data elements returned for A1-A3 correspond to the non-critical beats of the burst access. That is, the critical beat corresponds to the access address of the original read request made by CPU12. Similarly, for B0, the burst access request is for data elements stored at B0, B1, B2, and B3, in which the data element returned for B0 corresponds to the critical beat of the burst access and the data elements returned for B1-B3 corresponds to the non-critical beats of the burst access.

In this example, each data element returned for a beat of the burst is a doubleword. Also, note that the burst access requests provided by cache controller14allows for either in order or out of order data returns. Furthermore, bus24supports multiple outstanding burst requests, therefore, burst requests for each of A0 and B0 can be placed onto bus24and the 4 returned data beats for each of these burst requests can be returned out of order. As used herein, out of order indicates that the data beats of different burst requests can be interleaved with each other; however, the data beats of each burst request are received in order. Furthermore, the burst protocol used by bus24, such as the AXI protocol, returns the critical beat of each burst access first. The burst protocol used by bus24may also provide additional parameters for each burst access request. For example, it may define the size of each data element of a burst, which, in the current example, is a doubleword. Also, as used herein, A0-A3 refer to the 4 doublewords (i.e. the 4 data elements) of the cache line which includes critical beat A0 and thus referred to as cache line A, and B0-B3 refer to the 4 doublewords (i.e. the 4 data elements) of the cache line which includes critical beat B0 and thus referred to as cache line B.

Referring toFIG. 2, in block56, memory26provides 4 data beats in response to each burst access request via bus24to cache controller14. In block58, cache controller14provides the data of the critical beats to CPU12since these correspond to the read requests made by CPU12and should therefore be returned as quickly as possible to CPU12. Note one of the returned critical beats may be stored in critical access buffer18. In the illustrated embodiment, CPU12can only receive critical beats in order. Therefore, a critical beat that is received out of order can be stored in critical access buffer18until CPU12can accept it. Cache controller14also collects the returned data beats in linefill buffer16. However, linefill buffer16is only sufficiently large to store one cache line of data, therefore, cache controller is unable to store all 4 returned beats of both burst access requests. In one embodiment, cache controller14assigns ownership of linefill buffer16to the cache line having the latest returned critical beat. Therefore, if the critical beat corresponding to B0 comes in after the critical beat corresponding to A0, then ownership of linefill buffer16is assigned to the burst access for B0, such that B0-B3 get stored into linefill buffer16. Note that upon receiving a first critical beat, such as for A0 in this example, cache controller16may assign ownership to the burst access for A0 and thus store the data corresponding to A0 to linefill buffer16. However, if subsequent to receiving the data for A0, the data for B0 is received, cache controller14aborts the cache line fill in progress for the burst access for A0 in favor of the burst access for B0.

After block58, method50proceeds to block60in which cache20is updated with linefill buffer16after the last beat of the cache line which owns the linefill buffer is received. Therefore, in the case of ownership belonging to the burst access for B0, once B3 is received, linefill buffer16is written to cache20and linefill buffer16is once again available. Therefore, note that if each of A0-A3 is received prior to receiving B0, then the cache line with A0-A3 will be written to cache20prior to filling linefill buffer16with the burst access for B0.

FIGS. 3-5illustrate various examples of handling read requests. Note that for each ofFIGS. 3-5, actions are provided at different times, T0-T4, in which these times may occur in sequential order, but may overlap with previous or subsequent times.

FIG. 3illustrates an example in which CPU12requests 2 critical access of 2 different cache lines with an in order return of data elements. Therefore, at time T0, CPU12provides a read request to cache controller20for data stored at each of A0 and B0. At time T1, cache controller14generates a burst read access request for each of A0 and B0. Therefore, in the illustrated example, the burst read access request for A0 requests A0-A3, and the burst read access request for B0 requests B0-B3. Since bus24is capable of handling two outstanding read access requests, both burst read access requests are provided to bus24by way of BIU22. Memory26receives the burst read access requests to obtain the return data beats.

At time T2, memory26begins placing the return data beats onto bus24to be returned to cache controller14by way of BIU22. Therefore, memory26can place the data beat for A0 (i.e. the data elements stored at A0) onto bus24. Since the burst access requests are indicated as in order requests, all of the data beats for burst access A are placed onto bus24prior to any of the data beats for burst access B. Therefore, the data beats for A1, A2, and A3 follow A0 on bus24. Bus24provides these return data beats to cache controller14by way of BIU22. After the last data beat of the burst access for A is provided to bus24, memory26can begin providing the data beats for the burst access for B. However, note that a stall may be incurred between the last data beat of the burst access for A and the first data beat of the burst access for B. Memory26then places each of B0, B1, B2, and B3 onto bus24, which communicates these return beats to cache controller14by way of BIU22.

At time T3, cache controller14, upon receiving the data element for A0 provides this data element to CPU12, and stores the data element for A0 into linefill buffer16. Each subsequent data element for the burst access for A is also collected into linefill buffer16, and, upon receiving the last element, A3, cache controller14updates cache20with the cache line of linefill buffer16. Also, upon receiving the data element for B0, cache controller14provides this data element to CPU12, and stores the data element for B0 into linefill buffer16. Each subsequent data element for the burst access for B is also collected into linefill buffer16, and upon receiving the last element, B3, cache controller14updates cache20with the cache line of linefill buffer16. Therefore, inFIG. 3, time T4 corresponds to the time at which the resulting cache operations are performed for each burst access. That is, after collecting all data elements for the burst access for A into linefill buffer16, the cache line for this access (denoted as cache line A) can be stored to cache20, and after collecting all data elements for the burst access for B into linefill buffer16, the cache line for this access (denoted as cache line B) can be stored to cache20.

FIG. 4illustrates an example in which CPU12requests 2 critical access of 2 different cache lines with an out of order return of data elements. Therefore, at time T0, CPU12provides a read request to cache controller20for data stored at each of A0 and B0. At time T1, cache controller14generates a burst read access request for each of A0 and B0. Therefore, in the illustrated example, the burst read access request for A0 requests A0-A3, and the burst read access request for B0 requests B0-B3. Since bus24is capable of handling two outstanding read access requests, both burst read access requests are provided to bus24by way of BIU22. Furthermore, each burst read access request is indicated as an out-of-order request in which the data beats of the two burst requests can be returned in an interleaved manner. Memory26receives the burst read access requests to obtain the return data beats.

At time T2, memory26begins placing the return data beats onto bus24to be returned to cache controller14by way of BIU22. Therefore, memory26can place the data beat for A0 (i.e. the data element stored at A0) onto bus24. Since the burst access requests may be returned out of order, memory26may place the data beat for B0 onto bus24prior to the data beat for A1. In the illustrated embodiment, the data beats are placed onto bus24in the following order: A0, B0, A1, A2, A3, B1, B2, and B3. Bus24provides these return data beats to cache controller14by way of BIU22.

At time T3, cache controller14, upon receiving the data element for A0 provides this data element to CPU12, and stores the data element for A0 into linefill buffer16. That is, cache controller14initially assigns linefill buffer16to the burst access for A. Since B0, which is also a critical beat, is received after A0, cache controller14, upon receiving the data element for B0, provides this data element to CPU12, and stores the data element for B0 into linefill buffer16, replacing the data element for A0. Therefore, cache controller14re-assigns the ownership of linefill buffer16from the burst access for A to the burst access for B. The linefill in progress for the burst access for A is thus aborted and the cache line corresponding to burst access A will not be completed. As cache controller14receives B1, B2, and B3, cache controller14stores these into linefill buffer16, and upon storing the final data element of the burst, B3, the cache line for this burst access (denoted as cache line B) will be stored to cache20. Note that data elements A1, A2, and A3 are not stored in linefill buffer16since ownership of linefill buffer16was assigned to the burst access for B. Therefore, inFIG. 4, time T4 corresponds to the time at which the resulting cache operations are performed for each burst access. Since ownership was changed from the cacheline for A to the cacheline for B, the cache line for A is aborted and thus cache20is not updated with the burst access for A. However, after collecting all data elements for the burst access for B into linefill buffer16, the cache line for this access is stored to cache20.

Therefore, note that as seen in the example ofFIG. 3, ownership of linefill buffer16is assigned to the first burst request (the burst access for A) when this first burst request is fulfilled before any data elements for the second burst request (the burst access for B) are received. That is, in the example ofFIG. 3, ownership of linefill buffer16need not be re-assigned to a different burst request while a previous burst request is in progress. Therefore, if all data elements of the first burst access for A0 are received from memory26before any of the data elements of the second burst access for B0 are received, the data elements of the first burst access for A0 (e.g. A0-A3) can all be stored in linefill buffer16and then stored to cache20. However, as seen in the example ofFIG. 4, ownership of linefill buffer16is assigned to the second burst request when a data element of the second burst request (e.g. B0) is received after the first data element (e.g. A0) is received but before all the data elements for the first burst request (e.g. A0-A3) are received. In this example, ownership of linefill buffer16is re-assigned while a cache line fill of the previous burst access is in progress, resulting in aborted this cache line fill of the previous burst access. Therefore, if any of the data elements of the second burst access for B0 are received after at least one of A0, A1, or A2 but before the last element, A3, then the data elements of the second burst access for B0 (e.g. B0-B3) are stored in linefill buffer16rather than the data elements of the first access for A0.

FIG. 5illustrates an example in which CPU12requests 2 critical access of 2 different cache lines with an out of order return of data elements. Therefore, at time T0, CPU12provides a read request to cache controller20for data stored at each of A0 and B0. At time T1, cache controller14generates a burst read access request for each of A0 and B0. Therefore, in the illustrated example, the burst read access request for A0 requests A0-A3, and the burst read access request for B0 requests B0-B3. Since bus24is capable of handling two outstanding read access requests, both burst read access requests are provided to bus24by way of BIU22. Furthermore, each burst read access request is indicated as an out-of-order request in which the data beats of the two burst requests can be returned in an interleaved manner. Memory26receives the burst read access requests to obtain the return data beats.

At time T2, memory26begins placing the return data beats onto bus24to be returned to cache controller14by way of BIU22. In the current example, since the data beats may be returned out of order, memory26places the data beat for B0 (i.e. the data element stored at B0) onto bus24prior to the data beat for A1. In the illustrated embodiment, the data beats are placed onto bus24in the following order: B0, B1, B2, B3, A0, A1, A2, and A3. Bus24provides these return data beats to cache controller14by way of BIU22. Note that each of A0 and B0 correspond to the critical beats and thus may be stored by cache controller14into critical access buffer18. In this manner, although the critical beats are received out of order with respect to the requests, cache controller14may still provide the critical beats in correct order to CPU12. When cache controller14receives B0, cache controller14stores B0 into linefill buffer16as well as critical access buffer18. Therefore, ownership of linefill buffer16is provided to the burst access for B. Upon receiving each of B1, B2, and B3, each is stored into linefill buffer16, and after receiving the last element, B3, the cache line in linefill buffer16, corresponding to the burst access for B, is stored to cache20. Upon cache controller14receiving A0, cache controller14stores A0 into linefill buffer16(which is no longer being used for the burst access for B) and provides A0 to CPU12. Note that after A0 is accepted by CPU12, B0 can be provided to CPU12from critical access buffer18. In this manner, A0 and B0 are provided in order to CPU12. Ownership of linefill buffer16is therefore now provided to the burst access for A. However, no cache line fill of linefill buffer16had to be aborted in this example since all of B0-B3 was received into linefill buffer16before a new critical beat, A0, was received. Each subsequently received data element A1, A2, and A3 are stored to linefill buffer16, and upon cache controller14receiving the last element, A3, the cache line in linefill buffer16, corresponding to the burst access for A, is stored to cache20.

At time T3, cache controller14can first provide A0 to CPU12and then subsequently provide B0 to CPU12. In this manner, A0 and B0 are still provided in the correct order to CPU12. They may be provided from critical access buffer18. Also, inFIG. 5, time T4 corresponds to the time at which the resulting cache operations are performed for each burst access. That is, after collecting all data elements for the burst access for B into linefill buffer16, the cache line for this access (denoted as cache line B) can be stored to cache20, and after collecting all data elements for the burst access for A into linefill buffer16, the cache line for this access (denoted as cache line A) can be stored to cache20.

Therefore, by now it can be appreciated how a cache controller and a single linefill buffer capable of storing only a single cache line of data can be used with a bus which is capable of handling more than one outstanding request, which may be in or out of order. Upon receiving a first critical beat, ownership of the linefill buffer can be assigned to the cache line fill for the first critical beat. However, if a subsequent critical beat for another burst access is received prior to completing the previous cache line fill of the linefill buffer, ownership of the linefill buffer can be changed to the subsequent cache line (i.e. the cache line having the latest returned critical beat), thus aborting the cache line fill that was in progress. In this manner, multiple access requests can be returned out of order while still making use of the linefill buffer to collect data for one cache line at a time.

Also for example, in one embodiment, the illustrated elements of system10are circuitry located on a single integrated circuit or within a same device. Alternatively, system10may include any number of separate integrated circuits or separate devices interconnected with each other.

Item 1 includes a data processing system having a central processing unit (CPU); an external memory module; a cache controller coupled to communicate with the CPU and the external memory unit, the cache controller including a linefill buffer; and a cache memory module coupled to the cache controller. The cache controller is configured to: when data in a first request and in a second request from the CPU does not reside in the cache memory module: request first and second data elements from the external memory module in response to the first request from the CPU; request first and second data elements from the external memory module in response to the second request from the CPU, wherein the first data element responsive to the second request is received by the cache controller from the external memory module after the first data element responsive to the first request and before the second data element responsive to the first request; assign ownership of the linefill buffer to the first request when the first data element responsive to the first request is received; re-assign ownership of the linefill buffer to the second request when the first data element responsive to the second request is received after the first data element responsive to the first request is received. Item 2 includes the processing system of item 1, wherein the cache controller is further configured to: fill the linefill buffer with the first and second data elements responsive to the first request when the ownership of the linefill buffer is assigned to the first request; fill the linefill buffer with the first and second data elements responsive to the second request when the ownership of the linefill buffer is assigned to the second request; and update the cache memory module with contents of the linefill buffer. Item 3 includes the processing system of item 1, wherein the cache controller is further configured to: when the first and second data elements for the first request are received before the first data element for the second request and the first request is complete, retain the ownership of the linefill buffer with the first request. Item 4 includes the processing system of item 1, wherein the cache controller is further configured to: when the first and second data elements for the second request are received before the first data element for the first request and the second request is complete, assign the ownership of the linefill buffer to the second request. Item 5 includes the processing system of item 1, wherein the cache controller is further configured to: issue a first burst request for at least the first and second data elements for the first request; and issue a second burst request for at least the first and second data elements for the second request. Item 6 includes the processing system of item 5, wherein the cache controller is further configured to: assign the ownership of the linefill buffer to the first request when the first burst request is fulfilled before any data elements for the second burst request are received. Item 7 includes the processing system of item 5, wherein the cache controller is further configured to: assign the ownership of the linefill buffer to the second request when any data element responsive to the second request is received after the first data element for the first request is received and before all data elements for the first request are received. Item 8 includes the processing system of item 1, wherein the cache memory module includes a plurality of cache lines; and the linefill buffer stores only one cache line.

Item 9 includes a processing system having: a central processing unit (CPU); an external memory module; a cache memory module; and a cache controller coupled to communicate with the CPU, the external memory module and the cache memory module. The cache controller is configured to: in response to determining that a first data element responsive to a first request from the CPU and a second data element responsive to a second request from the CPU are not in the cache memory module and the first and second data elements are not in a same cache line: issue a first burst access request to the external memory for the first request; issue a second burst access request to the external memory for the second request; receive at least one of a plurality of first data elements from the external memory in response to the first burst access request; receive at least one of a plurality of second data elements from the external memory in response to the second burst access request; store the plurality of first data elements in a linefill buffer if all of the plurality of first data elements are received from the external memory before the at least one of the plurality of second data elements are received from the external memory; store the plurality of second data elements in the linefill buffer if any of the plurality of second data elements are received after the at least one of the plurality of first data elements is received and before all of the plurality of first data elements are received. Item 10 includes the processing system of item 9, wherein: the cache memory module includes a plurality of cache lines; the linefill buffer can store only one cache line; the plurality of first data elements fill the one cache line; the plurality of second data elements fill the one cache line. Item 11 includes the processing system of item 9, wherein the cache controller is further configured to: update the cache memory module with contents of the linefill buffer. Item 12 includes the processing system of item 9 wherein the cache controller is further configured to: abort the update of the cache memory module with the plurality of first data elements when any of the plurality of second data elements are received after the at least one of the plurality of first data elements is received and before all of the plurality of first data elements are received. Item 13 includes the processing system of item 12 wherein the cache controller is further configured to: complete processing the first and second request when all of the plurality of first data elements are received before any of the plurality of second data elements. Item 14 includes the processing system of item 12 wherein the cache controller is further configured to: complete processing the first and second request when all of the plurality of second data elements are received before any of the plurality of first data elements. Item 15 includes the processing system of item 12 wherein the cache controller is further configured to: provide the at least one of the first of the first plurality of data elements to the CPU; and update the cache memory module with the first plurality of data elements when the first request has not been aborted. Item 16 includes the processing system of item 9 and further includes a critical access buffer accessible by the cache controller; wherein the cache controller is further configured to: store a critical one of the second plurality of data elements in the critical access buffer when a critical one of the first plurality of data elements is received after the critical one of the second plurality of data elements and before all of the plurality of second date elements are received. Item 17 includes the processing system of item 16 wherein the cache controller is further configured to: store the critical one of the second plurality of data elements in the critical access buffer in the linefill buffer along with remaining ones of the second plurality of data elements after the first plurality of data elements are provided to the cache memory module.

Item 18 includes a method including receiving a first request for data from a central processing unit; receiving a second request for data from a central processing unit; when neither of the data of the first request and the data of the second request reside in cache memory: issuing a first burst access request for a first plurality of data elements that includes the data of the first request, issuing a second burst access request for a second plurality of data elements that includes the data of the second request, the first and second burst access requests being sent from a cache controller to an external memory unit; receiving a critical one of the first plurality of data elements in the cache controller; storing the critical one of the first plurality of data elements in a linefill buffer; receiving a critical one of the second plurality of data elements in the cache controller after receiving the critical one of the first plurality of data elements; replacing the critical one of the first plurality of data elements in the linefill buffer with the critical one of the second plurality of data elements; filling remaining space in the linefill buffer with remaining ones of the second plurality of data elements; providing contents of the linefill buffer to the cache memory module when the linefill buffer is filled. Item 19 includes the method of item 18 and further includes providing the critical one of the first plurality of data elements to the CPU; and providing the critical one of the second plurality of data elements to the CPU. Item 20 includes the method of item 18 and further includes storing the critical one of the second plurality of data elements in a critical access buffer when a critical one of the first plurality of data elements is received after the critical one of the second plurality of data elements and before all of the plurality of second date elements are received.