Embodiments according to the present invention generally relate to microprocessor architecture and more particularly to the architecture for out-of-order microprocessors.
A cache in a central processing unit is a data storage structure that is used by the central processing unit of a computer to reduce the average time that it takes to access memory. It is a memory which stores copies of data that is located in frequently used main memory locations. Moreover, cache memory (“cache”) is memory that is smaller than and that may be accessed more quickly than main memory. There are several different types of caches. These include physically indexed physically tagged (MT), virtually indexed virtually tagged (VIVT) and virtually indexed physically tagged (VIPT).
Caches that can accommodate multiple accesses in a single cycle provide performance advantages. In particular, such caches feature reduced access latencies. Conventional approaches to accommodating multiple accesses in a single cycle include the use of multi-ported caches and the provision of caches that include a plurality of tag and data banks.
A multi-ported cache is a cache Which can serve more than one request at a time. In accessing some conventional caches a single memory address is requested, whereas in a multi-ported cache, N memory addresses can be requested at a time, where N is the number of ports that is possessed by the multi-ported cache. An advantage of a multi ported cache is that greater throughput (e.g., a greater number of load and store requests) may be accommodated. However, the number of cache ports that are needed to accommodate increasingly high levels of throughput may not be practical.
Caches that include a plurality of tag and data banks can serve more than one request at a time as each tag and data bank can serve at least one request. However, when more than one request attempts to coincidentally access the same bank, the request that will be allowed to access the bank must be determined. In one conventional approach, arbitration is used to determine which request will be allowed to access a given tag and data bank. In such conventional approaches, the time that it takes to execute the arbitration can delay access to the tag bank and thus delay the triggering of the critical Load Hit signal, typically found in the Level 1 cache of processors.
Further, in a conventional system which supports a plurality of load accesses of a cache in a single cycle, if multiple accesses are accessing the same block within the same cache line, the arbitration scheme selects one access per block and signals a Load Hit (if there is a tag hit) only for the selected access while penalizing the other accesses. This is problematic because only one of the accesses signals a Load Hit while the other same-cycle accesses that are attempting to access the same data return a Load Miss. Further, if conventional systems supporting multiple load accesses in a single cycle encounter a load access that is unaligned, the access request is split into two components before sending it to the Level-1 cache. Because these two components cannot be sent to the Level-1 cache at the same time, such accesses never result in a Level-1 cache hit and are penalized.
Accordingly, a need exists for method and apparatus to sustain throughput in a microprocessor architecture supporting a plurality of load accesses of a data cache that addresses the aforementioned shortcomings of conventional approaches.
In one embodiment, the present invention provides a method wherein a plurality of requests to access the data cache is accessed, and in response, a tag memory is accessed that maintains a plurality of copies of tags for each entry in the tag cache. Tags are identified that correspond to individual requests. The data cache is divided into many banks or “blocks.” The data cache is accessed based on the identified tags. A plurality of requests to access the same block of the plurality of blocks of the data cache results in an access arbitration with respect to that block. This block access arbitration is executed in parallel with the access of tags that correspond to individual access requests. Consequently, the penalty to the timing of Load Hit signals that is exacted by arbitration to access tag and data banks found in conventional approaches is avoided.
More specifically, in one embodiment of the present invention, if multiple accesses are accessing the same block, the arbitration scheme can use the upper bits, e.g., virtual tag bits or physical tag bits of the request address to determine if the requests are to the same cache-line in memory. If it is determined that the requests are for the same block and to the same cache-line in memory, then one request is allowed to access the data from the block in memory while the remaining same-cycle requests are provided the data via bypass paths. Accordingly, the other accesses do not need to be penalized and can also signal a Load Hit.
In another embodiment of the present invention, if a load access is unaligned, instead of splitting the request into two components, embodiments of the present invention allow unaligned accesses that do not cross cache-lines to be sent to the L1-cache without splitting into two components. Instead, the request is allowed to access multiple blocks. By allowing a request to access more than one block, unaligned accesses can generate a Level-1 cache hit and get data at pipeline speed.
In one embodiment, a method for supporting a plurality of requests for access to a data cache memory is presented. The method comprises accessing a first plurality of requests to access the data cache memory, wherein the data cache memory comprises a plurality of blocks. Further, responsive to the first plurality of requests to access the data cache memory, the method comprises accessing a tag memory that maintains a plurality of copies of tags for each entry in the data cache memory and identifying tags that correspond to individual requests of the first plurality of requests. The method also comprises performing arbitration in a same clock cycle as the accessing the tag memory and the identifying tags, wherein the arbitration comprises: (a) identifying a second plurality of requests to access the data cache memory from the first plurality of requests, wherein the second plurality of requests accesses a same block within the data cache memory; and (b) selecting each request from the second plurality of requests to receive data from the same block.
In another embodiment, a processor unit configured to perform a method for supporting a plurality of requests for access to a data cache memory is presented. The method comprises accessing a first plurality of requests to access the data cache memory, herein the data cache memory comprises a plurality of blocks. Further, responsive to the first plurality of requests to access the data cache memory, the method comprises accessing a tag memory that maintains a plurality of copies of tags for each entry in the data cache memory and identifying tags that correspond to individual requests of the first plurality of requests. The method also comprises performing arbitration in a same clock cycle as the accessing the tag memory and the identifying tags, wherein the arbitration comprises: (a) identifying a second plurality of requests to access the data cache memory from the first plurality of requests, wherein the second plurality of requests accesses a same block within the data cache memory; and (b) selecting each request from the second plurality of requests to receive data from the same block.
In a different embodiment, a computer system is presented, wherein the computer system comprises a memory and a processor communicatively coupled to the memory, and wherein the processor is configured to process instructions out of order. The system further comprises a cache system. The cache system comprises a data cache memory configured to store blocks of data, a tag memory configured to stored tags that correspond to the blocks of data and a cache controller operable to implement a method for supporting a plurality of requests for access to a data cache memory. The method comprises accessing a first plurality of requests to access the data cache memory, wherein the data cache memory comprises a plurality of blocks. Further responsive to the first plurality of requests to access the data cache memory, the method comprises accessing the tag memory that maintains a plurality of copies of tags for each entry in the data cache memory and identifying tags that correspond to individual requests of the first plurality of requests. The method also comprises performing arbitration in a same clock cycle as the accessing the tag memory and the identifying tags, wherein the arbitration comprises: (a) identifying a second plurality of requests to access the data cache memory from the first plurality of requests, wherein the second plurality of requests accesses a same block within the data cache memory; and (b) selecting each request from the second plurality of requests to receive data from the same block.
The following detailed description together with the accompanying drawings will provide a better understanding of the nature and advantages of the present invention.
Embodiments of the present invention are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements.
Reference will now be made in detail to the various embodiments of the present disclosure, examples of which are illustrated in the accompanying drawings. While described in conjunction with these embodiments, it will be understood that they are not intended to limit the disclosure to these embodiments. On the contrary, the disclosure is intended to cover alternatives, modifications and equivalents, which may be included within the spirit and scope of the disclosure as defined by the appended claims. Furthermore, in the following detailed description of the present disclosure, numerous specific details are set forth in order to provide a thorough understanding of the present disclosure. However, it will be understood that the present disclosure may be practiced without these specific details. In other instances, well-known methods, procedures, components, and circuits have not been described in detail so as not to unnecessarily obscure aspects of the present disclosure.
Some portions of the detailed descriptions that follow are presented in terms of procedures, logic blocks, processing, and other symbolic representations of operations on data bits within a computer memory. These descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. In the present application, a procedure, logic block, process, or the like, is conceived to be a self-consistent sequence of steps or instructions leading to a desired result. The steps are those utilizing physical manipulations of physical quantities. Usually, although not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated in a computer system. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as transactions, bits, values, elements, symbols, characters, samples, pixels, or the like.
It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the following discussions, it is appreciated that throughout the present disclosure, discussions utilizing terms such as “accessing,” “identifying,” “selecting,” “performing,” “determining,” (e.g., flowchart 700 of
Embodiments described herein may be discussed in the general context of computer-executable instructions residing on some form of computer-readable storage medium, such as program modules, executed by one or more computers or other devices. By way of example, and not limitation, computer-readable storage media may comprise non-transitory computer-readable storage media and communication media; non-transitory computer-readable media include all computer-readable media except for a transitory, propagating signal. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform particular tasks or implement particular abstract data types. The functionality of the program modules may be combined or distributed as desired in various embodiments.
Computer storage media includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, random access memory (RAM), read only memory (ROM), electrically erasable programmable ROM (EEPROM), flash memory or other memory technology, compact disk ROM (CD-ROM), digital versatile disks (DVDs) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store the desired information and that can accessed to retrieve that information.
Communication media can embody computer-executable instructions, data structures, and program modules, and includes any information delivery media. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, radio frequency (RF), infrared, and other wireless media. Combinations of any of the above can also be included within the scope of computer-readable media.
Processor 111 incorporates embodiments of the present invention generally represents any type or form of processing unit capable of processing data or interpreting and executing instructions. In certain embodiments, processor 114 may receive instructions from a software application or modulo. These instructions may cause processor 114 to perform the functions of one or more of the example embodiments described and/or illustrated herein. In one embodiment, processor 114 may be an out of order microprocessor. In a different embodiment, processor 114 may be a superscalar processor. In yet another embodiment, processor 114 may comprise multiple processors operating in parallel.
System memory 116 generally represents any type or form of volatile or non-volatile storage device or medium capable of storing data and/or other computer-readable instructions. Examples of system memory 116 include, without limitation, RAM, ROM, flash memory, or any other suitable memory device. Although not required, in certain embodiments computing system 110 may include both a volatile memory unit (such as, for example, system memory 116) and a non-volatile storage device (such as, for example, primary storage device 132).
Computing system 110 may also include one or more components or elements in addition to processor 114 and system memory 116. For example, in the embodiment of
Memory controller 118 generally represents any type or form of device capable of handling memory or data or controlling communication between one or more components of computing system 110. For example, memory controller 118 may control communication between processor 114, system memory 116, and I/O controller 120 via communication infrastructure 112.
I/O controller 120 generally represents any type or form of module capable of coordinating and/or controlling the input and output functions of a computing device. For example, I/O controller 120 may control or facilitate transfer of data between one or more elements of computing system 110, such as processor 114, system memory 116, communication interface 122, display adapter 126, input interface 130, and storage interface 134.
Communication interface 122 broadly represents any type or form of communication device or adapter capable of facilitating communication between example computing system 110 and one or more additional devices. For example, communication interface 122 may facilitate communication between computing system 110 and a private or public network including additional computing systems. Examples of communication interface 122 include, without limitation, a wired network interface (such as a network interface card), a wireless network interface (such as a wireless network interface card), a modem, and any other suitable interface. In one embodiment, communication interface 122 provides a direct connection to a remote server via a direct link to a network, such as the Internet. Communication interface 122 may also indirectly provide such a connection through any other suitable connection.
Communication interface 122 may also represent a host adapter configured to facilitate communication between computing system 110 and one or more additional network or storage devices via an external bus or communications channel. Examples of host adapters include, without limitation, Small Computer System Interface (SCSI) host adapters, Universal Serial Bus (USB) host adapters, IEEE (Institute of Electrical and Electronics Engineers) 1394 host adapters, Serial Advanced Technology Attachment (SATA) and External SATA (eSATA) host adapters, Advanced Technology Attachment (ATA) and Parallel ATA (PATA) host adapters, Fibre Channel interface adapters, Ethernet adapters, or the like. Communication interface 122 may also allow computing system 110 to engage in distributed or remote computing. For example, communication interface 122 may receive instructions from a remote device or send instructions to a remote device for execution.
As illustrated in
As illustrated in
As illustrated in
In one example, databases 140 may be stored in primary storage device 132. Databases 140 may represent portions of a single database or computing device or it may represent multiple databases or computing devices. For example, databases 140 may represent (be stored on) a portion of computing system 110. Alternatively, databases 140 may represent (be stored on) one or more physically separate devices capable of being accessed by a computing device, such as computing system 110.
Continuing with reference to
Many other devices or subsystems may be connected to computing system 110. Conversely, all of the components and devices illustrated in
The computer-readable medium containing the computer program may be loaded into computing system 110. All or a portion of the computer program stored on the computer-readable medium may then be stored in system memory 116 and/or various portions of storage devices 132 and 133. When executed by processor 114, a computer program loaded into computing system 110 may cause processor 114 to perform and/or be a means for performing the functions of the example embodiments described and/or illustrated herein. Additionally or alternatively, the example embodiments described and/or illustrated herein may be implemented in firmware and/or hardware.
Method and Apparatus for Supporting a Plurality of Load Accesses of a Cache in a Single Cycle to Maintain Throughput
Embodiments of the present invention provide a system and method for supporting a plurality of load accesses of a data cache addressing the shortcomings of conventional approaches. In one embodiment, the present invention provides a method wherein a plurality of requests to access the data cache is accessed, and in response, a tag memory is accessed that maintains a plurality of copies of tags for each entry in the tag cache. Tags are identified that correspond to individual requests. The data cache is divided into many banks or “blocks.” The data cache is accessed based on the identified tags. A plurality of requests to access the same block of the plurality of blocks of the data cache results in an access arbitration with respect to that block. This block access arbitration is executed in parallel with the access of tags that correspond to individual access requests. Consequently, the penalty to the timing of Load Hit signals that is exacted by arbitration to access tag and data banks found in conventional approaches is avoided.
In one embodiment of the present invention, if multiple accesses are accessing the same block, the arbitration scheme can use the upper bits, e.g., virtual tag bits or physical tag bits of the request address to determine if the requests are to the same cache-line in memory. If it is determined that the requests are for the same block and cache-line in memory, then one request is allowed to access the data from the block in memory while the remaining same-cycle requests are provided the data via bypass paths. Accordingly, the other accesses do not need to be penalized and can also signal Load Hit. It should be noted that the data is only provided to the remaining same-cycle requests via the bypass path if the requests are to the same cache-line and block as the request receiving the data directly from the accessed block. If the additional requests are to the same block in a different cache-line, for example, a Load Miss would be signaled for the requests.
In another embodiment of the present invention, if a load access is unaligned, instead of splitting the request into two components, the present invention allows unaligned accesses that do not cross cache-lines to be sent to the L1-cache without splitting into two components. Instead, the request is allowed to access multiple blocks. By allowing a request to access more than one block, unaligned accesses can generate a Level-1 cache hit and get data at pipeline speed.
Instructions are fetched at the fetch stage 202 and placed in the instruction fetch queue (IFQ) (not shown) within fetch stage 202. The instructions are generally the original assembly instructions found in the executable program. These instructions reference the architectural registers which are stored in register file 210. If the first fetched instruction was to be interrupted or raise an exception, the architectural register file 210 stores the results of all instructions until that point. Stated differently, the architectural register file stores the state that needs to be saved and restored in order to return back to the program during debugging or otherwise.
In an OOO microprocessor, the instructions execute out-of-order while still preserving data dependence constraints. Because instructions may finish in an arbitrary order, the architectural register file 210 cannot be modified by the results of instructions as they finish because it would make it difficult to restore their values accurately in the event of an exception or an interrupt. Hence, every instruction that enters the pipeline is provided a temporary register where it can save its result. The temporary registers are eventually written into the architectural register file in program order when the associated instruction retires. Thus, even though instructions are being executed out of order, the contents of the architectural register files change as though they were being executed in program order.
The ROB 208 facilitates the process of instruction retirement. After the instructions are dispatched from the fetch unit 202, they are decoded by decode module 204 and are placed in the ROB 208 and issue queue 206 (IQ). The ROB 208 and IQ 206 may be part of a scheduler module 272. As instructions are issued out of IQ 206 out of order, they are executed by execute module 212.
In one embodiment, the write back module 214 will write the resulting values from those instructions back to the temporary registers in ROB 208 and rely on the ROB 208 to facilitate committing or “retiring” the instructions in order. However, in a different embodiment, write back module 214 writes the values resulting from instruction execution directly into register file 210 without sorting them. The unordered elements are added in physical memory to the register file 210 in an unordered fashion and are then retired to the architectural files in order at the retirement stage using a ROB initiated protocol.
The instructions issued out of order from the IQ 206 may also comprise loads and stores. As explained above, when loads and stores are issued out of order from the IQ 206, there are memory dependencies between them that need to be resolved before those instructions can be committed. Accordingly, the store instructions are stored in order in a Load Store Queue (LSQ) 216 while the dependencies between the loads and stores are resolved with the help of ROB 208.
A load instruction, for example, uses registers in the register file 210 to compute an effective address and, subsequently, sends a request to memory to access data associated with the address. The memory stage typically comprises a Level-1 cache 260, a Level-2 cache 262 and main memory 218. In one embodiment, the Level-1 cache 260 supports multiple load accesses of a data cache in a single clock cycle as will be explained further in connection with
Referring to
Data cache tag memory 316 is configured to maintain tag entries for each of the cache line entries stored in L1 data cache 315. In one embodiment, as part of the aforementioned configuration, and as discussed in parent application U.S. patent application Ser. No. 13/561,528, “Systems and Methods for Supporting a Plurality of Load Accesses of a Cache in a Single Cycle,” Karthikeyan Avudaiyappan, filed Jul. 30, 2012, data cache tag memory 316 maintains a plurality of copies of the tags that correspond to the entries of L1 data cache 315. In particular, each request to access L1 data cache 315 is accorded a dedicated copy of tags corresponding to the entries of L1 data cache 315. This manner of maintaining tag entries facilitates the identification of tags that are associated with the cache line entries within a single clock cycle. In one embodiment, an identification of a tag can be completed in the same clock cycle in which an arbitration involving an access request (e.g., load request) to L1 data cache 315 for data associated with the tag is executed. In one embodiment, access requests (e.g., load requests) to L1 data cache 315 trigger a search of data cache tag memory 316 for the tag that corresponds to the data that is sought by the load request.
In one embodiment, access requests to the same block are resolved using an arbiter 406, wherein the upper bits of the request address are used to disambiguate cases where the same block in the same cache line are being accessed. Multiple requests cannot access the same block at the same time because each block only has a single read and write port. A request accessing L1 cache searches tag memory 416 and participates in arbitration for data-blocks simultaneously in the same cycle as discussed above. If two access requests, e.g., R0 and R2 access requests to the same block, arbiter 406 uses the upper bits of the request address, e.g., virtual tag in a VIVT cache system to recognize the access request as being to the identical cache-line and allows one of the requests to access the block directly while the other requests receive the data from the block through a bypass path. For example,
In one embodiment, unaligned load access requests that do not cross the cache-line may be sent to the L1-cache without splitting into two components. As mentioned above, in the prior art, an extra cycle was utilized to split the request into two components. Embodiments of the present invention, however, allow a request to access more than one block. For example, if R1 in
In one embodiment, system 101 can be located in cache controller 317. In other embodiments, system 101 can be separate from cache controller 317, but operate cooperatively therewith.
Referring again to
Operation
Referring to
In one embodiment, the first step comprises performing e tag read operation. The plurality of requests, R0-R3, access data cache tag memory 506 at B to determine a tag hit or miss. In other words, the tag memory 506 is searched and tags residing therein that are associated with the data sought by the plurality of requests to access L1 data cache 315 are identified.
At the same time as the tag memory is searched, in the same cycle, the arbiter 406 marks the loads accessing the same block and same cache line. The arbiter 406, for example, may comprise comparators 507 to compare the addresses of the requests, R0 to R3 to determine if they access the same block. In one embodiment, the arbitration process may compare the block bits e.g., Virtual Address bits 6:3 and the virtual tag bits, e.g., Virtual address bits 31:6 of the requests to determine which requests are accessing the same block and cache line respectively to select the true winner and bypass winner(s) per accessed block. In the example of
After arbitration, the true-winner and bypass-winner(s) are selected. A request is identified as a winner if all the blocks it is accessing are satisfied either directly or via bypass. Accordingly, both R0 and R2 are identified as winners in the same cycle, wherein R0 is the true-winner and accesses block b0 directly, and R2 is a bypass winner and accesses data from block b0 through bypass path 515. By comparison, conventional cache systems would need to signal a L1-miss for the R2 access in the same cycle because it would either not analyze the upper bits of the request access address at all or would not analyze the upper bits till subsequent cycles.
A final hit or miss signal can be generated, in one embodiment, by using AND gates 508, wherein the AND gates are used to AND a tag hit or tag miss signal from the data cache tag memory with the result from the arbitration to generate a final Load Hit or a Load Miss signal. The result of AND gates 508, in other words, is the logical conjunction of a tag hit or miss signal from the data cache tag memory with the result from the arbitration. If, for example, arbitration indicates that R0 is a winner and a tag hit is obtained from data cache tag memory, then a Load Hit is generated using the AND gate associated with request R0.
Requests that result in a tag hit and are true or bypass winners signal a “load hit” and access data either directly or via a bypass path, e.g., requests R0, R1 and R2. By comparison, other requests signal a “load miss” and access the L2 cache, e.g., request R3. As shown in
At D, the data that is sought by the access requests are identified in the L1 data cache 315 and read (e.g., loaded). The data read is typically performed in the cycle following the arbitration.
In a different embodiment, instead of a VIVT cache, a VIPT or a PIPT cache may be used. In this embodiment, instead of using virtual tag bits and block bits, the physical tag bits and block bits are used to determine the true winner and bypass winner per access block. For caches that use physical tags, the first step of the arbitration process involves performing a tag-compare in parallel with marking requests accessing the same block using block bits. In the second step of the arbitration process, after getting the physical address from the Translation Lookaside Buffer (TLB), the physical tag bits 39:6 are compared in parallel to tag compare of tag memory to select winner and bypass winners per accessed block. The result of this step is to signal a L1-cache hit for the true winner and bypass winner(s) and a L1-cache miss for losers.
In one embodiment, if any of the requests are unaligned load accesses, which do not cross a cache-line, they are sent to the L1-cache without splitting the request into two components. Instead, the unaligned load access is allowed to access multiple blocks at the same time. In other words, the unaligned load access is allowed to access all the blocks over which the unaligned load request spans. By allowing a request to access more than one block, unaligned accesses can generate a L1-cache hit and get data at pipeline speed. In order for the unaligned access request to return data that is the same size as a regular block, e.g., b0, b1, b2 etc., a multiplexer can be used, in one embodiment, to filter and arrange the data from the multiple blocks into a regular sized access block. For example, if R1 in
In one embodiment, as discussed herein, L1 data cache 315 can be organized into a plurality of blocks and the tags that correspond to data that is maintained in L1 data cache 315 can be duplicated and stored in data cache tag memory 316. Moreover, as discussed herein, the organization of data cache 315 into blocks enable several loads to be supported in a single cycle even if they access the same data block within the same cache line (e.g., have the same address) and even if they are unaligned load accesses.
Components of System for Supporting a Plurality of Load Accesses of a Cache in a Single Cycle to Maintain Throughput According to One Embodiment
Load request accessor 615 accesses a plurality of load requests that seek to access data stored in an L1 data cache (e.g., 315 in
Tag memory accessor 616, in response to the receipt of a plurality of load requests, searches in parallel, respective copies of the tags of a data cache tag memory (e.g., 316 in
Cache accessor 617 accesses a plurality of data blocks of the L1 data cache using the tags that are identified by tag memory accessor 616. In one embodiment, the plurality of data blocks facilitates the accessing of the L1 data cache by multiple access requesters in the same clock cycle. In one embodiment, conflicting requests for access that seek to access the same block of the L1 data cache at the same time can be resolved using arbiter module 620. The arbiter module, for example, can use the virtual tag (upper bits) and block bits (lower bits) as discussed above to determine if the access requests are to the same block and the same cache line. If the access requests are to the same block and same cache line, then a Load Hit signal is returned for the true winner and any bypass winners. If the requests are to the same block but different cache lines, a Load Hit signal is returned only for the winner while a Load Miss is returned for the losers. Further, one embodiment, if the load request is to an unaligned load, arbiter module 620 allows the request to return a Load Hit signal and access multiple blocks at the same time.
Method for Supporting a Plurality of Load Accesses of a Cache in a Single Cycle to Maintain Throughput According to One Embodiment
Referring to
At step 704, a tag memory is accessed that maintains a plurality of copies of the tags that correspond to the entries of the data cache.
At step 706, in the same cycle as the access to the tag memory, as part of an arbitration process, the plurality of load requests seeking accessing to the same block within the same cache line are identified.
At step 708, tags are compared and identified as corresponding to individual load requests of the plurality of load requests received by the L1 cache. In one embodiment, the tags are compared and identified in the same cycle as the access to tag memory. In one embodiment, each load request is accorded a dedicated copy of the set of tags that correspond to the entries located in the data cache.
At step 710, of the plurality of load requests identified as accessing the same block within the same cache line, a true winner and at least one bypass winner are selected to conclude the arbitration process. In one embodiment, a Load Hit signal is returned for the true winner and any bypass winners.
At step 712, the blocks of data cache are accessed based on the tag that are identified as corresponding to the individual requests. In one embodiment, for the plurality of load requests that are identified as accessing the same block, a true winner accesses the data block identified by the associated tag directly while the bypass winners) access the data through a bypass path.
While the foregoing disclosure sets forth various embodiments using specific block diagrams, flowcharts, and examples, each block diagram component, flowchart step, operation, and/or component described and/or illustrated herein may be implemented, individually and/or collectively, using a wide range of hardware, software, or firmware (or any combination thereof) configurations. In addition, any disclosure of components contained within other components should be considered as examples because many other architectures can be implemented to achieve the same functionality.
The process parameters and sequence of steps described and/or illustrated herein are given by way of example only. For example, while the steps illustrated and/or described herein may be shown or discussed in a particular order, these steps do not necessarily need to be performed in the order illustrated or discussed. The various example methods described and/or illustrated herein may also omit one or mote of the steps described or illustrated herein or include additional steps in addition to those disclosed.
While various embodiments have been described and/or illustrated herein in the context of fully functional computing systems, one or more of these example embodiments may be distributed as a program product in a variety of forms, regardless of the particular type of computer-readable media used to actually carry out the distribution. The embodiments disclosed herein may also be implemented using software modules that perform certain tasks. These software modules may include script, batch, or other executable files that may be stored on a computer-readable storage medium or in a computing system. These software modules may configure a computing system to perform one or more of the example embodiments disclosed herein.
The foregoing description, for purpose of explanation, has been described with reference to specific embodiments. However, the illustrative discussions above are not intended to be exhaustive or to limit the invention to the precise forms disclosed. Many modifications and variations are possible in view of the above teachings. The embodiments were chosen and described in order to best explain the principles of the invention and its practical applications, to thereby enable others skilled in the art to best utilize the invention and various embodiments with various modifications as may be suited to the particular use contemplated.
Embodiments according to the invention are thus described. While the present disclosure has been described in particular embodiments, it should be appreciated that the invention should not be construed as limited by such embodiments, but rather construed according to the below claims.
This application is a continuation of U.S. patent application Ser. No. 14/173,602, filed Feb. 5, 2014, which application is a conversion of and claims priority to and the benefit of Provisional Patent Application No. 61/800,498, entitled “SYSTEMS AND METHODS FOR SUPPORTING A PLURALITY OF LOAD ACCESSES OF A CACHE IN A SINGLE CYCLE TO MAINTAIN THROUGHPUT,” having a filing Date of Mar. 15, 2013, which is herein incorporated by reference in its entirety. This application claims priority from and is a continuation-in-part of U.S. patent application Ser. No. 13/561,528, “Systems and Methods for Supporting a Plurality of Load Accesses of a Cache in a Single Cycle,” Karthikeyan Avudaiyappan, filed Jul. 30, 2012, now U.S. Pat. No. 9,430,410, the entire disclosure of which is incorporated herein by reference.
Number | Name | Date | Kind |
---|---|---|---|
4075704 | O'Leary | Feb 1978 | A |
4245344 | Richter | Jan 1981 | A |
4356550 | Katzman et al. | Oct 1982 | A |
4414624 | Summer, Jr. et al. | Nov 1983 | A |
4524415 | Mills, Jr. et al. | Jun 1985 | A |
4527237 | Frieder et al. | Jul 1985 | A |
4577273 | Hopper et al. | Mar 1986 | A |
4597061 | Cline et al. | Jun 1986 | A |
4600986 | Scheuneman et al. | Jul 1986 | A |
4633434 | Scheuneman | Dec 1986 | A |
4682281 | Woffinden et al. | Jul 1987 | A |
4816991 | Watanabe et al. | Mar 1989 | A |
4920477 | Colwell et al. | Apr 1990 | A |
5294897 | Notani et al. | Mar 1994 | A |
5317705 | Gannon et al. | May 1994 | A |
5317754 | Blandy et al. | May 1994 | A |
5548742 | Wang et al. | Aug 1996 | A |
5559986 | Alpert et al. | Sep 1996 | A |
5574878 | Onodera et al. | Nov 1996 | A |
5581725 | Nakayama | Dec 1996 | A |
5634068 | Nishtala et al. | May 1997 | A |
5752260 | Liu | May 1998 | A |
5754818 | Mohamed | May 1998 | A |
5787494 | Delano et al. | Jul 1998 | A |
5793941 | Pencis et al. | Aug 1998 | A |
5802602 | Rahman et al. | Sep 1998 | A |
5806085 | Berliner | Sep 1998 | A |
5813031 | Chou et al. | Sep 1998 | A |
5835951 | McMahan | Nov 1998 | A |
5852738 | Bealkowski et al. | Dec 1998 | A |
5860146 | Vishin et al. | Jan 1999 | A |
5864657 | Stiffler | Jan 1999 | A |
5872985 | Kimura | Feb 1999 | A |
5881277 | Bondi et al. | Mar 1999 | A |
5903750 | Yeh et al. | May 1999 | A |
5905509 | Jones et al. | May 1999 | A |
5918251 | Yamada et al. | Jun 1999 | A |
5956753 | Glew et al. | Sep 1999 | A |
5974506 | Sicola et al. | Oct 1999 | A |
6016533 | Tran | Jan 2000 | A |
6073230 | Pickett et al. | Jun 2000 | A |
6075938 | Bugnion et al. | Jun 2000 | A |
6088780 | Yamada et al. | Jul 2000 | A |
6092172 | Nishimoto et al. | Jul 2000 | A |
6101577 | Tran | Aug 2000 | A |
6115809 | Mattson, Jr. et al. | Sep 2000 | A |
6134634 | Marshall, Jr. et al. | Oct 2000 | A |
6138226 | Yoshioka et al. | Oct 2000 | A |
6157998 | Rupley, II et al. | Dec 2000 | A |
6167490 | Levy et al. | Dec 2000 | A |
6205545 | Shah et al. | Mar 2001 | B1 |
6212613 | Belair | Apr 2001 | B1 |
6226732 | Pei et al. | May 2001 | B1 |
6247097 | Sinharoy | Jun 2001 | B1 |
6253316 | Tran et al. | Jun 2001 | B1 |
6256727 | McDonald | Jul 2001 | B1 |
6256728 | Witt et al. | Jul 2001 | B1 |
6260131 | Kikuta et al. | Jul 2001 | B1 |
6260138 | Harris | Jul 2001 | B1 |
6272662 | Jadav et al. | Aug 2001 | B1 |
6275917 | Okada | Aug 2001 | B1 |
6321298 | Hubis | Nov 2001 | B1 |
6332189 | Baweja et al. | Dec 2001 | B1 |
6341324 | Caulk, Jr. et al. | Jan 2002 | B1 |
6437789 | Tidwell et al. | Aug 2002 | B1 |
6449671 | Patkar et al. | Sep 2002 | B1 |
6457120 | Sinharoy | Sep 2002 | B1 |
6557083 | Sperber et al. | Apr 2003 | B1 |
6594755 | Nuechterlein et al. | Jul 2003 | B1 |
6604187 | McGrath et al. | Aug 2003 | B1 |
6609189 | Kuszmaul et al. | Aug 2003 | B1 |
6658549 | Wilson et al. | Dec 2003 | B2 |
6681395 | Nishi | Jan 2004 | B1 |
6907600 | Neiger et al. | Jun 2005 | B2 |
6912644 | O'Connor et al. | Jun 2005 | B1 |
7007108 | Emerson et al. | Feb 2006 | B2 |
7111145 | Chen et al. | Sep 2006 | B1 |
7143273 | Miller et al. | Nov 2006 | B2 |
7149872 | Rozas et al. | Dec 2006 | B2 |
7213106 | Koster et | May 2007 | B1 |
7278030 | Chen et al. | Oct 2007 | B1 |
7380096 | Rozas et al. | May 2008 | B1 |
7383390 | Maessen | Jun 2008 | B1 |
7406581 | Southwell et al. | Jul 2008 | B2 |
7546420 | Shar et al. | Jun 2009 | B1 |
7680988 | Nickolls | Mar 2010 | B1 |
7783868 | Ukai | Aug 2010 | B2 |
7856530 | Mu | Dec 2010 | B1 |
7913058 | Rozas et al. | Mar 2011 | B2 |
8145844 | Bruce | Mar 2012 | B2 |
8239656 | Rozas et al. | Aug 2012 | B2 |
8301847 | Dantzig et al. | Oct 2012 | B2 |
8522253 | Rozas et al. | Aug 2013 | B1 |
8868838 | Glasco et al. | Oct 2014 | B1 |
8930674 | Avudaiyappan et al. | Jan 2015 | B2 |
9047178 | Talagala et al. | Jun 2015 | B2 |
20010049782 | Hsu et al. | Dec 2001 | A1 |
20020069326 | Richardson et al. | Jun 2002 | A1 |
20020082824 | Neiger et al. | Jun 2002 | A1 |
20020099913 | Steely et al. | Jul 2002 | A1 |
20030065887 | Maiyuran et al. | Apr 2003 | A1 |
20030088752 | Harman | May 2003 | A1 |
20040034762 | Kacevas | Feb 2004 | A1 |
20040044850 | George et al. | Mar 2004 | A1 |
20040064668 | Kjos et al. | Apr 2004 | A1 |
20040093483 | Nguyen et al. | May 2004 | A1 |
20040103251 | Alsup | May 2004 | A1 |
20040117593 | Uhlig et al. | Jun 2004 | A1 |
20040117594 | Vanderspek | Jun 2004 | A1 |
20040143727 | McDonald | Jul 2004 | A1 |
20040193857 | Miller et al. | Sep 2004 | A1 |
20040205296 | Bearden | Oct 2004 | A1 |
20040215886 | Cargnoni et al. | Oct 2004 | A1 |
20040225872 | Bonanno et al. | Nov 2004 | A1 |
20050005085 | Miyanaga | Jan 2005 | A1 |
20050027961 | Zhang | Feb 2005 | A1 |
20050060457 | Olukotun | Mar 2005 | A1 |
20050108480 | Correale, Jr. et al. | May 2005 | A1 |
20050154867 | Dewitt et al. | Jul 2005 | A1 |
20060004964 | Conti et al. | Jan 2006 | A1 |
20060026381 | Doi et al. | Feb 2006 | A1 |
20060190707 | McIlvaine et al. | Aug 2006 | A1 |
20060236074 | Williamson et al. | Oct 2006 | A1 |
20060277365 | Pong | Dec 2006 | A1 |
20080077813 | Keller et al. | Mar 2008 | A1 |
20080091880 | Vishin | Apr 2008 | A1 |
20080126771 | Chen et al. | May 2008 | A1 |
20080195844 | Shen et al. | Aug 2008 | A1 |
20080215865 | Hino et al. | Sep 2008 | A1 |
20080235500 | Davis et al. | Sep 2008 | A1 |
20080270758 | Ozer et al. | Oct 2008 | A1 |
20080270774 | Singh et al. | Oct 2008 | A1 |
20080282037 | Kusachi et al. | Nov 2008 | A1 |
20090138659 | Lauterbach | May 2009 | A1 |
20090157980 | Bruce | Jun 2009 | A1 |
20090158017 | Mutlu et al. | Jun 2009 | A1 |
20090164733 | Kim et al. | Jun 2009 | A1 |
20090172344 | Grochowski et al. | Jul 2009 | A1 |
20090287912 | Sendag | Nov 2009 | A1 |
20100138607 | Hughes et al. | Jun 2010 | A1 |
20100169578 | Nychka | Jul 2010 | A1 |
20100169611 | Chou et al. | Jul 2010 | A1 |
20100211746 | Tsukishiro | Aug 2010 | A1 |
20110010521 | Wang et al. | Jan 2011 | A1 |
20110082980 | Gschwind et al. | Apr 2011 | A1 |
20110082983 | Koktan | Apr 2011 | A1 |
20110153955 | Herrenschmidt et al. | Jun 2011 | A1 |
20120005462 | Hall et al. | Jan 2012 | A1 |
20120042126 | Krick et al. | Feb 2012 | A1 |
20130019047 | Podvalny et al. | Jan 2013 | A1 |
20130046934 | Nychka et al. | Feb 2013 | A1 |
20130086417 | Sivaramakrishnan et al. | Apr 2013 | A1 |
20130097369 | Talagala et al. | Apr 2013 | A1 |
20130238874 | Avudaiyappan et al. | Sep 2013 | A1 |
20130304991 | Bottcher | Nov 2013 | A1 |
20130311759 | Abdallah et al. | Nov 2013 | A1 |
20130346699 | Walker | Dec 2013 | A1 |
20140032844 | Avudaiyappan et al. | Jan 2014 | A1 |
20140032845 | Avudaiyappan et al. | Jan 2014 | A1 |
20140032856 | Avudaiyappan et al. | Jan 2014 | A1 |
20140075168 | Abdallah | Mar 2014 | A1 |
20140108730 | Avudaiyappan et al. | Apr 2014 | A1 |
20140156947 | Avudaiyappan et al. | Jun 2014 | A1 |
20140281242 | Abdallah et al. | Sep 2014 | A1 |
20160041908 | Avudaiyappan et al. | Feb 2016 | A1 |
20160041913 | Avudaiyappan et al. | Feb 2016 | A1 |
20160041930 | Avudaiyappan et al. | Feb 2016 | A1 |
Number | Date | Country |
---|---|---|
1305150 | Jul 2001 | CN |
0596636 | May 1994 | EP |
0706133 | Apr 1996 | EP |
2343270 | May 2000 | GB |
200707284 | Mar 1995 | TW |
539996 | Jul 2003 | TW |
200401187 | Jan 2004 | TW |
591530 | Jun 2004 | TW |
I233545 | Jun 2005 | TW |
I281121 | May 2007 | TW |
0125921 | Apr 2001 | WO |
Entry |
---|
Abandonment from U.S. Appl. No. 14/922,053, dated Dec. 1, 2017, 2 pages. |
Barham P., et al., “Xen and the Art of Virtualization,” Proceedings of the ACM Symposium on Operating Systems Principles, XP002298786, Oct. 2003, pp. 164-177. |
Cooperman, “Cache Basics,” Winter 2003, downloaded from http://www.ccs.neu.edu/course/com3200/parent/NOTES/cache-basics.html on Sep. 24, 2015, 3 pages. (no publication month available). |
Final Office Action from U.S. Appl. No. 13/561,441, dated Oct. 14, 2016, 14 pages. |
Final Office Action from U.S. Appl. No. 13/561,441, dated Sep. 26, 2014, 16 pages. |
Final Office Action from U.S. Appl. No. 13/561,491, dated Jan. 14, 2015, 14 pages. |
Final Office Action from U.S. Appl. No. 13/561,491, dated Nov. 12, 2014, 14 pages. |
Final Office Action from U.S. Appl. No. 13/561,491, dated Oct. 13, 2015, 16 pages. |
Final Office Action from U.S. Appl. No. 13/561,528, dated Nov. 10, 2014, 19 pages. |
Final Office Action from U.S. Appl. No. 14/173,602, dated Apr. 13, 2017, 26 pages. |
Final Office Action from U.S. Appl. No. 14/173,602, dated Jan. 8, 2016, 32 pages. |
Final Office Action from U.S. Appl. No. 14/173,602, dated Jan. 9, 2017, 18 pages. |
Final Office Action from U.S. Appl. No. 14/922,035, dated Oct. 14, 2016, 29 pages. |
Final Office Action from U.S. Appl. No. 14/922,042, dated Oct. 14, 2016, 15 pages. |
Final Office Action from U.S. Appl. No. 14/922,053, dated May 23, 2017, 43 pages. |
Final Office Action from U.S. Appl. No. 14/922,053, dated Oct. 14, 2016, 16 pages. |
Final Office Action from U.S. Appl. No. 15/353,053, dated Jun. 16, 2017, 45 pages. |
Final Office action from U.S. Appl. No. 15/654,481, dated Dec. 14, 2017, 45 pages. |
Garmany J., “The Power of Indexing: Oracle Tips by Burleson Consulting,” Burleson Enterprises, Inc., archived on Mar. 9, 2009, retrieved Sep. 17, 2015 via Internet: web.archive.org/web/20090309201136/http://dba-oracle.com/t_indexing_power.htm, 7 pages. |
International Preliminary Report on Patentability for Application No. PCT/US2013/051128, dated Feb. 12, 2015, 8 pages. |
International Search Report and Written Opinion for Application No. PCT/US2013/051128, dated Oct. 30, 2013, 9 pages. |
Jacobson, et al., “Path-based Next Trace Prediction,” MICRO—Proceedings of the 30th Annual IEEE/ACM International Symposium on Microarchitecture, Dec. 1-3, 1997, IEEE Computer Society, Washington, D.C., 1997, pp. 14-23. |
Nanda, et al., “The Misprediction Recovery Cache,” International Journal of Parallel Programming—Special issue: MICRO-29, 29th annual IEEE/ACM international symposium on microarchitecture, Plenum Press, New York, NY, Aug. 1998, vol. 26 (4), pp. 383-415. |
Non-Final Office Action from U.S. Appl. No. 13/561,441, dated Dec. 22, 2014, 13 pages. |
Non-Final Office Action from U.S. Appl. No. 13/561,441, dated Jan. 39, 2017, 17 pages. |
Non-Final Office Action from U.S. Appl. No. 13/561,441, dated Jun. 4, 2014, 12 pages. |
Non-Final Office Action from U.S. Appl. No. 13/561,441, dated May 17, 2016, 17 pages. |
Non-Final Office Action from U.S. Appl. No. 13/561,491, dated Feb. 8, 2016, 16 pages. |
Non-Final Office Action from U.S. Appl. No. 13/561,491, dated Jun. 16, 2014, 13 pages. |
Non-Final Office Action from U.S. Appl. No. 13/561,491, dated May 5, 2015, 15 pages. |
Non-Final Office Action from U.S. Appl. No. 13/561,528, dated Dec. 19, 2014, 13 pages. |
Non-Final Office Action from U.S. Appl. No. 13/561,528, dated Jun. 17, 2014 , 11 pages. |
Non-Final Office Action from U.S. Appl. No. 14/173,602, dated Jul. 29, 2016, 19 pages. |
Non-Final Office Action from U.S. Appl. No. 14/173,602, dated Sep. 8, 2015, 32 pages. |
Non-Final Office Action from U.S. Appl. No. 14/922,035, dated Jun. 21, 2016, 13 pages. |
Non-Final Office Action from U.S. Appl. No. 14/922,042, dated Apr. 7, 2016, 16 pages. |
Non-Final Office Action from U.S. Appl. No. 14/922,042, dated Dec. 14, 2016, 20 pages. |
Non-Final Office Action from U.S. Appl. No. 14/922,053, dated Apr. 7, 2016, 15 pages. |
Non-Final Office Action from U.S. Appl. No. 14/922,053, dated Dec. 15, 2016, 16 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,441, dated Apr. 21, 2017, 20 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,441, dated Feb. 2, 2016, 10 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,441, dated Jun. 23, 2015, 14 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,441, dated Mar. 18, 2015, 8 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,441, dated Oct. 21, 2015, 10 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,491, dated Dec. 19, 2016, 13 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,491, dated Jun. 8, 2016, 12 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,491, dated Mar. 31, 2017, 12 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,491, dated Sep. 14, 2016, 18 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,528, dated Aug. 3, 2016, 6 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,528, dated Feb. 8, 2016, 15 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,528, dated Jul. 13, 2015, 14 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,528, dated Mar. 31, 2015, 5 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,528, dated May 2, 2016, 10 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,528, dated Oct. 21, 2015, 9 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,570, dated Aug. 27, 2015, 9 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,570, dated Dec. 7, 2015, 7 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,570, dated Jan. 29, 2015, 9 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,570, dated Jun. 20, 2014, 8 pages. |
Notice of Allowance from U.S. Appl. No. 13/561,570, dated May 20, 2015, pages. |
Notice of Allowance from U.S. Appl. No. 13/561,570, dated Oct. 22, 2014, 16 pages. |
Notice of Allowance from U.S. Appl. No. 14/173,602, dated Nov. 9, 2017, 39 pages. |
Notice of Allowance from U.S. Appl. No. 14/922,035, dated Apr. 10, 2017, 21 pages. |
Notice of Allowance from U.S. Appl. No. 14/922,035, dated Jan. 27, 2017, 5 pages. |
Notice of Allowance from U.S. Appl. No. 14/922,042, dated Mar. 30, 2017, 35 pages. |
Notice of Allowance from U.S. Appl. No. 15/353,053, dated Dec. 37, 2017, 6 pages. |
Notice of Allowance from U.S. Appl. No. 15/353,053, dated Sep. 37, 2017, 11 pages. |
Rotenberg E., et al., “Trace Cache: a Low Latency Approach to High Bandwidth Instruction Fetching,” MICRO 29—Proceedings of the 29th annual ACM/IEEE international symposium on Microarchitecture, IEEE Computer Society, Apr. 11, 1996, 48 pages. |
Techopedia, Cache Memory Definition, www.techopedia.com/definition/6307/cache-memory, 1 page. |
Wallace S., et al.,“Multiple Branch and Block Prediction,” Third International symposium on High-Performance Computer Architecture, IEEE, Feb. 1997, pp. 94-103. |
Ye, et al., “A New Recovery Mechanism in Superscalar Microprocessors by Recovering Critical Misprediction,” IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences, The Institute of Electronics, Information and Communication Engineers, Dec. 1, 2011, vol. E94-A (12), pp. 2639-2648. |
Yeh, et al., “Increasing the Instruction Fetch Rate Via Multiple Branch Prediction and a Branch Address Cache,” ICS 93, Proceedings of the 7th International Conference on Supercomputing, ACM, New York, NY, Jul. 19-23, 1993, pp. 67-76. |
Non-Final Office Action from U.S. Appl. No. 15/823,432, dated Jun. 15, 2018, 38 pages. |
Notice of Allowance from U.S. Appl. No. 15/823,432, dated Oct. 22, 2018, 7 pages. |
Number | Date | Country | |
---|---|---|---|
20180150403 A1 | May 2018 | US |
Number | Date | Country | |
---|---|---|---|
61800498 | Mar 2013 | US |
Number | Date | Country | |
---|---|---|---|
Parent | 14173602 | Feb 2014 | US |
Child | 15881515 | US |
Number | Date | Country | |
---|---|---|---|
Parent | 13561528 | Jul 2012 | US |
Child | 14173602 | US |