A technique for improving access times when accessing memory, such as when accessing data from cache. By a unique manipulation and usage of a specified memory address in combination with the cache's internal organization, the address range required by the requested data can be covered by one odd and one even segment of the cache, where the odd segment is always at the base address created by the summation of the source operands and set to the odd segment, and the even address is created by summation of the source operands plus an offset value equivalent to the size of the cache line. This structural regularity is used to efficiently generate both the even and odd addresses in parallel to retrieve the desired data.
|
1. A system for accessing data from a memory, comprising:
a first circuit comprising (i) a first input for receiving a first operand, (ii) a second input for receiving a second operand, (iii) a first output for outputting a summation of the first operand and the second operand, and (iv) a second output for outputting a summation of the first operand, the second operand and an offset value; and
a cache memory comprising a first segment portion having an input and output, and a second segment portion having an input and output, wherein the input of the first segment portion is coupled to the first output of the first circuit, and wherein the input of the second segment portion is coupled to the second output of the first circuit.
2. The system of
3. The system of
|
1. Technical Field
The present invention is directed to techniques for efficiently accessing memory, and in particular to improved techniques for efficiently accessing both aligned and unaligned data from such memory. Still more particularly, the present invention provides address and cache organization that increases the efficiency of handling unaligned data, while minimizing the physical resources needed to support it.
2. Description of Related Art
In some computer architectures, memory operand length can be defined as eight (8) bytes or less. An operand is considered aligned if it falls on an address with the least significant bit equal to a single “0” bit for a half-word (i.e. 2 bytes), the two least significant bits equal to double “00” bits for a word (4 bytes), or the three least significant bits equal to triple “000” bits for a double word (8 bytes). An operand is considered unaligned if it violates the definition of alignment. If all operands are aligned in an architecture, then only 8 bytes (the size of the cache line in such an architecture) would be required from the memory subsystem. For systems that support unaligned data, more than 8 bytes are necessary as retrieval of a single cache line will not satisfy the request. Often, unaligned data requires additional logic or circuit resources to efficiently support it.
Memory structures, like caches, provide discrete quantities of data when accessed, such discrete quantities of data sometimes being referred to as a cache line or cache block. Often, the amount of data that is provided is dictated by physical design constraints such as silicon area or wireability. The smaller the amount of data retrieved, the faster the access time for that data. Similarly, the simpler the access mechanism, the faster the access time can be. So, while complex algorithms for data retrieval are possible, they often preclude high frequency access to such data.
It would thus be desirable to provide a technique of address and cache organization that increases the efficiency of handling unaligned data, while minimizing the physical resources (transistors, wires, etc.) needed to support it.
The present invention is directed to a technique for improving access times when accessing memory, such as when accessing data from cache. For aligned data, the specified base address can be directly used when accessing the cache as the retrieved cache line will fully contain the requested data. If a specified address is in an even segment of the cache, the data is not aligned and the length of the requested data extends beyond the current segment's boundary, then part of the data fetched from the next sequential odd segment which has the same base address is subsequently used. If a specified address is in an odd segment, the data is not aligned and the length of the requested data extends beyond the current segment's boundary, then part of the data fetched from the next sequential segment which has a base address equal to the odd segment plus an offset value equivalent to the size of the cache line is subsequently used. In all cases, the address range required by the requested data can be covered by one odd and one even segment, where the odd segment is at the base address created by the summation of the source operands and set to the odd segment, and the even segment is at the base address created by summation of the source operands plus an offset value equivalent to the size of the cache line. This structural regularity is used to efficiently generate both the even and odd segment addresses in parallel to retrieve the desired data.
The novel features believed characteristic of the invention are set forth in the appended claims. The invention itself, however, as well as a preferred mode of use, further objectives and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, wherein:
The present invention is directed to a technique for improving access times when accessing memory, such as when accessing data from a data cache or instructions from an instruction cache. As used herein, the term ‘data’ is meant to cover any type of data such as instructions to be executed, or the more traditional data values used in conjunction with instruction execution. The preferred embodiment of the present invention uses 64 bits to address the memory, with bit 0 being the most significant bit and bit 63 being the least significant bit. The address space of the memory, in the preferred embodiment a cache memory, is logically and physically separated into even and odd segments based on bit number 60 of these segments, where when bit 60=0 it specifies an even segment of the cache memory is to be accessed and when bit 60=1 it specifies an odd segment of the cache memory is to be accessed. A specified memory address is determined by adding two source operands of an instruction together. The base address of such specified address is specified in bits 0 to 59 (also represented herein as bits 0:59), and naturally identifies locations within one of these even or odd segments. Various rules, as will now be described, are used to manipulate or otherwise determine addresses to be used when accessing these various segments of the cache memory, and to select associated data read from such segments, based upon the specified memory address.
If a specified memory address of data to be accessed is in an even segment (i.e. bit 60=0), the data is not aligned and the length of the requested data extends beyond the current segment's boundary, then part of the data fetched from the next sequential odd segment which has the same base address (bits 0:59) as the specified memory address, with bit 60 set=1 to specify the odd segment, is selected for use, as will be further exemplified below with respect to
If a specified memory address of data to be accessed is in an odd segment (i.e. bit 60=1), the data is not aligned and the length of the requested data extends beyond the current segment's boundary, then part of the data fetched from the next sequential segment which has a base address plus 0x8 (i.e. base address+0x8) is selected for use, as will be further exemplified below with respect to
If the desired data to be accessed is aligned, or the desired data is fully contained within the specified segment, then the segment location specified by the base address fully contains the data and the value of any computed second address for data fetching is extraneous, as will be further exemplified below with respect to
In all cases, the address range required by the requested data can be covered by one odd and one even segment, where the odd segment is at the base address (bits 0:59) created by the summation of the two source operands (A+B) and augmented by bit 60 being set=1, and the even segment is at the base address created by summation of the two source operands (A+B) plus 0x8 (base address+0x8) and augmented by bit 60 being set=0.
This structural regularity is used to generate both the even and odd segment addresses in parallel. The L1 data cache is organized to hold data quantized to 8-byte amounts equivalent to the even and odd addresses. Each generated segment address retrieves 8 bytes from the L1 cache, resulting in 16 total bytes available. The necessary 8 or less bytes are then chosen from the available 16 bytes via a multiplexer.
Referring now to the figures and initially with respect to
Turning now to
Turning now to
Turning now to
Turning now to
Turning now to
Multiplexer 620 is controlled by data select control circuit 630, which has two inputs—memory address (A+B) 632 and the requested data length 634. The data select control circuit 630 generates two sets of 8 bits that are coupled to control inputs of the multiplexer 620 (these two sets of 8 bits can also be considered as a single 16 bit value, but are depicted herein as two sets to logically show the even and odd segment selection). Output 636 is an 8-bit value used to select certain of the 8 bytes that were output from the even segment portion of the cache, and output 638 is an 8-bit value used to select certain of the 8 bytes that were output from the odd segment portion of the cache. A sixteen-bit vector Sv (0:15) is maintained internal to the data select control circuit 630, and the original bit values within this vector are dependent on the value of requested data length 634. There are four possible initial values for this vector, depending upon whether the requested data length is a byte, half-word, word or double-word. The initial values for this vector Sv (0:15) are shown below:
REQUESTED DATA LENGTH
INITIAL VALUE OF VECTOR
Byte:
Sv (0:15) = 0b1000000000000000
Half-word:
Sv (0:15) = 0b1100000000000000
Word:
Sv (0:15) = 0b1111000000000000
Double-word:
Sv (0:15) = 0b1111111100000000
This Sv (0:15) vector is then rotated right by the amount specified by bits (60:63) of the memory address A+B. For example, if bits (60:63)=0b0110, we rotate the vector 6 places. If bits (60:63)=0b1010, we rotate the vector 10 places. In all cases, since this is a rotate operation, data going out of bit 15 is input back into bit 0. The bits within this vector are then used to control multiplexor 620. The first eight bits of the vector, Sv (0:7) (shown as output 636), are used to select bytes that were output from the even segment portion of the cache memory. Similarly, the last eight bits of the vector, Sv (8:15) (shown as output 638), are used to select bytes that were output from the odd segment portion of the cache memory. In the preferred embodiment, a bit being a logical one (‘1’) means that a corresponding byte should be output at 622 as a part of the requested data. Thus, if the requested data length is a byte, there is 1 bit initially set to a logical one (‘1’) as shown above with the initial Sv (0:15) settings, and one byte will be output at requested data 622. The particular byte that is output will depend upon the bit rotation within Sv (0:15) based upon address bits (60:63) as described above. Similarly, if the requested data length is a half-word, there are 2 bits initially set to a logical one (‘1’) as shown above with the initial Sv (0:15) settings, and two bytes will be output at requested data 622. The particular bytes that are output will depend upon the bit rotation within Sv (0:15) based upon address bits (60:63) as described above. Similarly, if the requested data length is a word, there are 4 bits initially set to a logical one (‘1’) as shown above with the initial Sv (0:15) settings, and four bytes will be output at requested data 622. The particular bytes that are output will depend upon the bit rotation within Sv (0:15) based upon address bits (60:63) as described above. Finally, if the requested data length is a double-word, there are 8 bits initially set to a logical one (‘1’) as shown above with the initial Sv (0:15) settings, and eight bytes will be output at requested data 622. The particular bytes that are output will depend upon the bit rotation within Sv (0:15) based upon address bits (60:63) as described above. The rotated Sv (0:15) vector and resulting even select bits 636 and odd select bits 638 are also included in the various examples depicted in
Thus, it has been shown how the present invention improves access to a memory such as a cache memory by providing a structural regularity that is used to efficiently generate both the even and odd addresses in parallel to efficiently retrieve the desired data.
The description of the present invention has been presented for purposes of illustration and description, and is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art. The embodiment was chosen and described in order to best explain the principles of the invention, the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.
Levenstein, Sheldon B., Fluhr, Eric Jason
Patent | Priority | Assignee | Title |
Patent | Priority | Assignee | Title |
5606520, | Nov 17 1989 | Texas Instruments Incorporated | Address generator with controllable modulo power of two addressing capability |
20020116567, |
Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
Feb 10 2005 | FLUHR, ERIC JASON | International Business Machines Corporation | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 015825 | /0587 | |
Feb 10 2005 | LEVENSTEIN, SHELDON B | International Business Machines Corporation | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 015825 | /0587 | |
Feb 11 2005 | International Business Machines Corporation | (assignment on the face of the patent) | / |
Date | Maintenance Fee Events |
Oct 29 2007 | ASPN: Payor Number Assigned. |
Jul 04 2011 | REM: Maintenance Fee Reminder Mailed. |
Nov 27 2011 | EXP: Patent Expired for Failure to Pay Maintenance Fees. |
Date | Maintenance Schedule |
Nov 27 2010 | 4 years fee payment window open |
May 27 2011 | 6 months grace period start (w surcharge) |
Nov 27 2011 | patent expiry (for year 4) |
Nov 27 2013 | 2 years to revive unintentionally abandoned end. (for year 4) |
Nov 27 2014 | 8 years fee payment window open |
May 27 2015 | 6 months grace period start (w surcharge) |
Nov 27 2015 | patent expiry (for year 8) |
Nov 27 2017 | 2 years to revive unintentionally abandoned end. (for year 8) |
Nov 27 2018 | 12 years fee payment window open |
May 27 2019 | 6 months grace period start (w surcharge) |
Nov 27 2019 | patent expiry (for year 12) |
Nov 27 2021 | 2 years to revive unintentionally abandoned end. (for year 12) |