Re-fetching data to evict L3 cache data to the last level cache

By sending only the address of clean victim data from intermediate caches to the LLC, the method reduces resource and power consumption, improving caching efficiency and speed by refetching data from system memory, addressing inefficiencies in existing cache eviction methods.

JP2024544259APending Publication Date: 2024-11-28ADVANCED MICRO DEVICES INC
View PDF 4 Cites 0 Cited by

Patent Information

Application Number
JP2024534779
Authority / Receiving Office
JP · JP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2021-12-16
Filing Date
2022-12-15
Publication Date
2024-11-28

AI Technical Summary

Technical Problem

The eviction of clean data from intermediate cache levels to the last level cache (LLC) in processing systems results in significant traffic and power consumption due to the need to propagate the entire data across caches, which is inefficient and resource-intensive.

Method used

A method where only the address of clean victim data is sent from the intermediate cache to the LLC, bypassing the direct propagation of the data itself, allowing the LLC to refetch the data from system memory, thereby reducing traffic and power consumption.

Benefits of technology

This approach significantly reduces system resource usage and power consumption by minimizing inter-cache data transfer, enhancing caching efficiency and speed by refetching clean data from system memory directly to the LLC.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 2024544259000001_ABST
    Figure 2024544259000001_ABST
Patent Text Reader

Abstract

In response to the eviction of the first clean data block from the mid-level cache [140] in the multiple cache hierarchy [104] of the processing system [100], the cache controller [150] accesses the address [205] of the first clean data block. The controller uses the accessed address to initiate a fetch of the first clean data block from the system memory [116] to the last level cache [144].
Need to check novelty before this filing date? Find Prior Art

Description

[Background technology]

[0001] To support the execution of instructions, a processing system typically implements one or more compute complexes, each having one or more processor cores and a memory hierarchy having memory modules for storing data accessed by executable instructions. Each processor core is associated with one or more levels of cache local to the corresponding processor core and a main memory that stores a large amount of data that can be accessed by executable instructions at the corresponding processor core. For example, many processing systems with multiple processor cores use a hierarchy of multiple cache levels, including level 1 (L1), level 2 (L2), and level 3 (L3) caches with various storage capacities and proximity to the associated processor core. In some processing systems, each processor core has a separate instruction-specific cache and a data-specific cache at level 1. In the cache hierarchy, each processor core is associated with one or more levels of cache that are private to the corresponding core (hereinafter, "private cache"). At another level of the cache hierarchy, the processing system also implements a shared cache, commonly referred to as an L3 cache, which is shared between the processor cores of the computing complex (hereinafter, the "shared cache"). In some processing systems, a lowest level cache (Last Cache, LLC), separate from the L3 cache, is also shared between the processor cores of the computing complex.

[0002] Traditionally, data is transferred between memory and cache in fixed-size blocks. Such blocks contain data and other information stored in the cache, referred to herein as cache lines. Furthermore, such blocks may contain data stored in multiple cache lines. When one or more cache lines are copied from memory to a cache, a cache entry is generated. The cache entry typically contains the copied data and the requested memory location. To ensure memory coherency, cache hierarchies are typically configured to implement a coherency protocol, where caches in the hierarchy maintain coherency status information about their respective cache lines and communicate cache probes to other caches in the hierarchy to ensure that the rules of the coherency protocol are followed.

[0003] When a processor core reads from or writes to a location in memory, it first checks the corresponding entry in the cache. The cache checks the contents of the requested memory location in any cache line that may contain that address. If the processor finds the memory location in the cache, a cache hit has occurred. However, if the processor does not find the memory location in the cache, a cache miss has occurred. In the case of a cache hit, the processor immediately reads or writes the data in the cache line. In the case of a cache miss, the cache allocates a new entry and copies the data from main memory to the newly allocated entry in the cache (i.e., the cache "fetches" the data from main memory at that memory location into the cache), and the request is satisfied from the contents of the cache. To make room for the new entry on a cache miss, the cache may need to evict one of its existing entries.

[0004] The evicted data is referred to herein as "victim data" or "victim data." Writes to the cache that are not immediately mirrored to main memory are marked as "dirty data" and the cache tracks which locations have been overwritten (e.g., via write or modify instructions). Thus, victim data that is no longer up-to-date in main memory (i.e., data that has been modified in the cache but not modified in main memory) is referred to herein as "dirty data," and data that is up-to-date (i.e., not modified in the cache) is referred to herein as "clean data." Furthermore, traditional exclusive caches require clean victim data to be evicted (e.g., from L3) to maintain coherency and cache exclusivity, which increases data movement in the structure and consumes additional power and bandwidth. Summary of the Invention [Means for solving the problem]

[0005] In one example, the method includes accessing an address of the first clean data block in response to evicting the first clean data block from the Mid Level Cache, and further including initiating a fetch of the first clean data block from a system memory to a Last-Level Cache (LLC) using the address.

[0006] In another example, the method further includes propagating an address of the first clean data block from the mid level cache to the LLC. The method may further include propagating the first dirty data block from the mid level cache to the LLC in response to evicting the first dirty data block from the mid level cache. In some examples, the first dirty data block includes data that has been written to one or more caches of a cache hierarchy via one or more of a write instruction or a modify instruction.

[0007] In some examples, in response to evicting the second clean data block from the mid level cache, the method includes bypassing storing the second clean data block in the LLC based on a determination that a hit rate of the LLC is below a predetermined threshold or a determination that an interface between the system memory and the LLC currently has a storage capacity below a predetermined threshold for fetching data. In some examples, the method includes propagating the second clean data block from the mid level cache to the LLC based on a determination that a coherent interconnect between the mid level cache and the LLC currently has a storage capacity above a predetermined threshold for propagating data or a determination that a current power usage level is below a predetermined threshold level of power usage.

[0008] In some examples, the method includes initiating a fetch of the first clean data block from a system memory including accessing a memory controller. The method, in some examples, further includes bypassing propagating the first clean data block from the Mid Level Cache to the LLC.

[0009] In another example, a processing system includes a processor, a system memory, multiple cache hierarchies, and a cache controller that, in response to an eviction of a first clean data block from a mid-level cache in the multiple cache hierarchies, accesses an address of the first clean data block and uses the address to initiate a fetch of the first clean data block from the system memory to a last level cache (LLC). In some examples, the cache controller further propagates the address of the first clean data block from the mid-level cache to the LLC.

[0010] In some examples, the cache controller is further configured to propagate the first dirty data block from the mid level cache to the LLC in response to evicting the first dirty data block from the mid level cache, In some examples, the first dirty data block includes data written to one or more caches of the multiple cache hierarchies via one or more of a write instruction or a modify instruction.

[0011] In some examples, the cache controller is further responsive to the eviction of the second clean data block from the mid level cache to bypass storing the second clean data block in the LLC based on a determination that a hit rate of the LLC is below a predetermined threshold or a determination that an interface between the system memory and the LLC currently has a storage capacity below a predetermined threshold for fetching data. In some examples, the cache controller is further responsive to the eviction of the second clean data block from the mid level cache to propagate the second clean data block from the mid level cache to the LLC based on a determination that a coherent interconnect between the mid level cache and the LLC currently has a storage capacity above a predetermined threshold for propagating data or a determination that a current power usage level is below a predetermined threshold level of power usage.

[0012] In some examples, initiating a read of the first clean data block from the system memory includes accessing a memory controller, In some examples, the cache controller is further configured to bypass propagating the first clean data block from the Mid Level Cache to the LLC.

[0013] In another example, the method includes, in response to a request to store first cache data in a mid level cache in a multiple cache hierarchy of a processing system, determining that a storage capacity limit of the mid level cache has been exceeded. The method further includes initiating an eviction of the first clean data block from the mid level cache, the eviction including sending an address of the first clean data block to a last level cache (LLC) and, in response to receiving the address at the LLC, caching the evicted first clean data block in the LLC by fetching the first clean data block from a system memory using the address sent from the mid level cache.

[0014] In some examples, the method further includes transmitting the first dirty data block from the Mid Level Cache to the LLC in response to evicting the first dirty data block from the Mid Level Cache. In some examples, the method includes bypassing transmitting the first clean data block from the Mid Level Cache to the LLC. In some examples, the method includes obtaining an address of the first clean data block from system probe information stored in the Mid Level Cache.

[0015] The present disclosure may be better understood, and its numerous features and advantages made apparent to those skilled in the art by referencing the accompanying drawings, in which: The use of the same reference numbers in different drawings indicates similar or identical items. [Brief description of the drawings]

[0016] [Figure 1] 1 is a block diagram of a multi-core processing system including a data eviction module for refetching clean data from system memory into a last level cache that has been evicted from another level of the cache hierarchy, in accordance with some embodiments. [Diagram 2]1 is a block diagram of a portion of a processing system illustrating a data eviction module that refetches clean victim data from system memory to an LLC in accordance with some embodiments. [Diagram 3] 1 is a flow diagram illustrating a method for evicting cache data from an L3 cache to an LLC using a refetch of clean victim cache data from system memory in the LLC in accordance with some embodiments. [Figure 4] 4 is a flow diagram illustrating a continuation of the method of FIG. 3 according to some embodiments. [Diagram 5] 1 is a flow diagram illustrating a method for refetching eviction of clean data to a last level cache (LLC) according to some embodiments. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0017] In some processing environments, a last level cache (LLC) of a multiple cache hierarchy may be substantially smaller than the L3 cache for a central processing unit (CPU), thus making it impractical to replicate all data in the L3 cache to the LLC. Conventionally, when L3 cache data is evicted from the L3 cache, the processor caches the evicted cache data in the LLC by sending (e.g., propagating) the evicted cache data from the L3 cache to the LLC. Thus, these evictions cause a significant amount of traffic between caches, consuming significant system resources and power.

[0018] 1-5 illustrate a technique for caching clean victim data evicted from an intermediate level of a cache hierarchy by refetching the evicted data from system memory (e.g., from dynamic random access memory (DRAM)) to the LLC based on the clean victim address, thereby bypassing sending the evicted clean data from the L3 cache to the LLC. As used herein, an "intermediate" level of a cache hierarchy refers to any level of the cache hierarchy other than the LLC (i.e., any level of the cache hierarchy higher than the lowest level in the cache hierarchy). In some embodiments, when the clean victim data is evicted from a cache, one or more processor cores update a system probe filter, which tracks the cache line in the processing system to maintain coherency between caches in the cache hierarchy. The data eviction module transmits the address (not the entirety of the evicted clean data) to the LLC and then utilizes the address of the clean victim data in the system probe filter to refetch the victim data from the system memory (e.g., DRAM) to the LLC. Because sending only the address (as opposed to the evicted clean data) consumes relatively less system resources and power, the caching technique reduces traffic between caches, consumes substantially less system resources and power, and increases the speed of caching from the L3 cache to the LLC.

[0019] 1 illustrates a processing system 100 including a data eviction module 145 for refetching clean cache victim data from a system memory 116 to a last level cache (LLC) 144, according to at least some embodiments. In the illustrated example, the processing system 100 includes a computing complex 102, a cache hierarchy 104, a last level cache (LLC) 144, a memory controller 106, and a system memory 116. In some embodiments, the LLC 144 is implemented as part of the cache hierarchy 104. In some embodiments, the LLC 144 is implemented as a memory-side cache structure, while the cache hierarchy is implemented as a processor-side cache structure. In some embodiments, the LLC 144 and the memory controller 106 are implemented as multiple LLCs and memory controllers, with each LLC coupled to a respective memory controller.

[0020] The computational complex 102 includes multiple processor cores, such as four processor cores 111, 112, 113, and 114. The processor cores may include, for example, a central processing unit (CPU) core, a graphics processing unit (GPU) core, a digital signal processor (DSP) core, or a combination thereof. It should be understood that the number of processor cores in the computational complex 102 may be less than or greater than four.

[0021] The memory controller 106 acts as an interface between the cache hierarchy 104, the LLC 144, and the system memory 116. As such, data cached in the cache hierarchy 104 is typically manipulated as blocks of data, referred to as "cache lines," and is addressed or otherwise located in the memory hierarchy using physical addresses in the system memory 116. In some embodiments, a "block" of data may include multiple cache lines and / or other information. Cache lines are accessed from the system memory 116 by the memory controller 106 in response to memory requests from the cache hierarchy 104 and the LLC 114. Similarly, when a cache line containing modified data (i.e., "dirty data" or a "dirty data block") needs to be evicted from the cache hierarchy 104 and therefore updated in the system memory 116, the memory controller 106 manages this write-back process.

[0022] The cache hierarchy 104 includes two or more levels of cache. In the illustrated example, the cache hierarchy 104 includes three cache levels: Level 1 (L1), Level 2 (L2), and Level 3 (L3). For L1, the computing complex 102 implements a small private cache for each processing core, shown as L1 caches 121, 122, 123, 124, each associated with a corresponding one of the processor cores 111, 112, 113, 114. As mentioned above, in some embodiments, the cache hierarchy 104 further includes an LLC 144.

[0023] For L2, the computing complex 102 implements a larger private cache for each processor core, shown as L2 caches 131, 132, 133, 134 corresponding to the processor cores 111, 112, 113, 114, respectively. Each of the L2 caches 131-134 is private to its corresponding processor core, but the cache hierarchy 104 operates to maintain coherency between the L2 caches 131-134. The L2 caches 131-134 may be direct mapped caches or n-way set associative caches in some embodiments.

[0024] For the L3 caching level, the cache hierarchy 104 implements an L3 cache 140 that is shared by the processor cores of the computing complex 102, and therefore shared by at least the L2 caches 131-134. The L3 cache 140 implements an L3 controller 142 and a data eviction module 145 to control the eviction of data from the L3 cache 140.

[0025] L3 cache 140 further includes a memory (not shown) that stores probe information 148 for storing address and status information for cache lines in L2 caches 131-134. To this end, the memory that stores probe information 148 may be implemented as a cache, array, table, latch, flop, or other storage structure. Probe information 148 tracks information about corresponding cache lines that reside in any of L2 caches 131-134. Information stored as probe information 148 for a corresponding cache line may include, for example, the physical address (or a portion thereof) of the cache line and the state of the cache line in the L2 cache.

[0026] Probe information 148 is generally used by L3 cache 140 to respond to cache probes (not shown) generated by caches in cache hierarchy 104. In particular, L1 caches 121-124 and L2 caches 131-134, together with L3 cache 140, implement a memory coherency protocol (referred to herein simply as the "coherency protocol"). Each cache line is associated with corresponding coherency information managed by the coherency protocol to indicate the coherency state of the cache line and how the cache line may be treated under the rules of the coherency protocol. For example, the coherency protocol may establish coherency states such as "modified," indicating that the cache line may be modified in the corresponding cache, "exclusive," indicating that the corresponding cache line may not be modified in caches associated with other processor cores, and "shared," indicating that the cache line is shared by multiple caches in cache hierarchy 104 and therefore should not be modified. For a particular event, as defined by the particular coherency protocol implemented by the processing system, a cache in the cache hierarchy 104 may issue a cache probe to identify the coherency status of a given cacheline in other caches. For example, before changing the coherency status of a cacheline from shared to exclusive, a cache may issue a cache probe to identify whether the cacheline is stored in any other caches, and if so, the coherency status of the cacheline in the cache that stores the cacheline. Based on the response to the probe, the cache that issued the probe may take appropriate action as required under the rules of the coherency protocol. For example, if no other caches store the cacheline, the cache may change the state of the cacheline from "shared" to "exclusive."

[0027] As described above, the memory storing probe information 148 stores information indicative of the cache lines stored in each of the private caches of cache hierarchy 104. In some embodiments, the memory storing probe information 148 or an associated memory structure may store coherency information for the cache line on behalf of the corresponding cache. In response to a cache probe, L3 controller 142 accesses the memory storing probe information 148 to determine whether any of the caches of cache hierarchy 104 store the cache line, and if so, the corresponding coherency information. L3 controller 142 responds to the cache probe based on probe information 148.

[0028] In some embodiments, L1 caches 121, 122, 123, 124, L2 caches 131, 132, 133, 134, and L3 cache 140 are inclusive; that is, the outer level caches hold the contents of the inner level caches. All fills to the inner level caches (i.e., cache writes to cache data) are also written to the outer level. Thus, fills to L1 121 are written to L2 131 and L3 cache 140. However, LLC 144 is exclusive to L3 cache 140. To maintain exclusivity, fills to L3 cache 140 are not written to LLC 144. Instead, only L3 cache 140 victim data is written to LLC 144, thus ensuring that the data in L3 cache 140 and LLC 144 are exclusive.

[0029] During execution, the execution pipeline for one or more of processor cores 111, 112, 113, or 114 performs a load or store that accesses the L1 121 data cache. If the data is not present in the L1 121 data cache (i.e., a miss in L1 121), the miss goes to the L2 cache 131. If the data is not present in the L2 cache 131 either, the miss goes to the L3 cache 140. When the L3 controller 142 determines that the L3 cache 140 also does not have the data, it sends an indication of the miss over the coherent interconnect 160 to the LLC 144. When the LLC controller 150 determines a miss in the LLC 144, it sends a request to the memory controller 106 to fetch the data from the system memory 116 (e.g., DRAM).

[0030] Data from the memory controller 106 is sent directly to the L3 cache 140, bypassing the LLC 144. This causes the L3 cache 140, the L2 cache 131, and the L1 data cache 121 to be filled with data.

[0031] When data is filled into the L1 121 data cache, the add may displace (i.e., evict) another cache line in the L1 121 data cache. If the evicted cache line is dirty, the cache line is sent to the L2 131 cache. Similarly, when data is filled into the L2 131 cache, it may cause an eviction of a dirty L2 131 cache that is written to the L3 cache 140. An L3 cache 140 fill may also cause a data eviction module 145 to handle the L3 cache 140 eviction. Conventionally, both clean and dirty victim data evicted from the L3 cache 140 are propagated to the LLC 144 via the coherent interconnect 160. This write occurs because the LLC 144 is exclusive and caches all data evicted from the L3 cache 140. However, propagating L3 cache 140 victim data from L3 cache 140 to LLC 144 across coherent interconnect 160 may consume significant system resources and power.

[0032] To reduce data traffic across coherent interconnect 160, data eviction module 145 evicts only dirty victim data from L3 cache 140 by propagating cache lines with dirty victim data to LLC 144 via coherent interconnect 160. To facilitate caching clean data evicted from L3 cache 140 in LLC 144 without stressing coherent interconnect 160, data eviction module 145 sends only the victim address of the clean victim data (i.e., the address of the original data in system memory 116) to LLC 144, not the clean data itself, because the clean data is a copy of the original data in system memory 116. Thus, data eviction module 145 initiates refetching the clean data directly from system memory 116 to LLC 144, bypassing propagating the clean data from L3 cache 140 to LLC 144 via coherent interconnect 160.

[0033] In some embodiments, the L3 controller 142 sends the L3 cache 140 victim address to the system probe filter regardless of whether the LLC 144 is an inclusive LLC or an exclusive LLC. The L3 cache 140 victim address is typically sent to the system probe filter to maintain cache coherence across the processing system. Thus, the data eviction module 145 accesses the probe information 148 to determine the L3 cache 140 victim address of the clean victim data and sends the L3 cache 140 victim address of the clean victim data to the LLC 144. Propagating the L3 cache 140 victim address to the LLC 144 consumes relatively less bandwidth and power compared to propagating the clean victim data itself. In response to receiving the L3 cache 140 victim address at LLC 144, LLC controller 150 translates the L3 cache 140 victim address into a system memory 116 read request to re-fetch the data associated with the victim address. Memory controller 106 returns the requested data from system memory 116 and caches the returned data in LLC 144. When LLC 144 is filled, LLC controller 150 evicts any dirty victim data from LLC 144 by writing the dirty victim data back to system memory 116 via memory controller 106. In this manner, data eviction module 145 reduces communication traffic between caches and consumes substantially less system resources and power because it propagates only the address(es) of the clean victim data to LLC 144, rather than propagating the clean victim data from L3 cache 140 to LLC 144 for eviction of the clean data.

[0034] 2 is a diagram illustrating a portion 200 of the processing system 100 of FIG. 1 illustrating the data eviction module 145 initiating a refetch of the clean victim data 210 from the system memory 116 to the LLC 144, according to some embodiments. In the illustrated example, the data eviction module 145 illustrates the eviction of the clean data from the L3 cache 140 by obtaining an address 205 of the clean eviction data from the probe information 148, as described above. The data eviction module 145 transmits the address 205 of the clean eviction data to the LLC 144. In some embodiments, the data eviction module 145 transmits the address 205 of the clean eviction data to the LLC 144 by propagating the address 205 to the LLC 144 via the coherent interconnect 160. The LLC 144 then generates a read request (not shown) to read the clean victim data 210, requesting the LLC 144 to read the clean victim data 210 from the system memory 116 via the memory controller 106. In response to a read request, the clean victim data 210 is returned to the LLC 144 for storage as cache data. In this manner, the LLC 144 bypasses the propagation of the clean victim data 210 from the L3 cache 140 and re-fetches the clean victim data 210 directly from the system memory 116 (e.g., DRAM).

[0035] In some embodiments, if the memory interface is determined to be busy or if the hit rate of LLC 144 is determined to be low, clean victim data 210 is not inserted into LLC 144. In such a case, in response to evicting a clean data block from L3 cache 140, data eviction module 145 bypasses storing the clean data block in LLC 144 based on a determination that the hit rate of LLC 144 is below a predetermined threshold or a determination that the interface between system memory 116 and LLC 144 currently has a storage capacity below a predetermined threshold for fetching data.

[0036] In some embodiments, in response to evicting the clean data block from L3 cache 140, data eviction module 145 initiates propagation of the clean data block from L3 cache 140 to LLC 144 based on a determination that the coherent interconnect 160 between L3 cache 140 and LLC 144 currently has storage capacity above a predetermined threshold for propagating data or a determination that the current power usage level is below a predetermined threshold level of power usage.

[0037] 3 and 4 illustrate a method 300 for evicting cache data from the L3 cache according to some embodiments. In step 302, the L3 controller 142 of FIG. 1 receives a request to store the first cache data. In step 304, the L3 controller 142 determines whether there is a need to evict the second cache data. In some embodiments, the L3 controller 142 determines whether a cache storage capacity threshold for the L3 cache 140 has exceeded a limit. If the second cache data needs to be evicted, in step 306, the data eviction module 145 determines whether the second cache data is clean cache data, and if not, the L3 controller 142 proceeds to step 312. In some embodiments, the data eviction module 145 accesses the probe information 148 to determine whether the cache line of the second cache data has been modified since it was originally cached. If the second cached data is clean (e.g., the second cached data has not been modified since it was initially cached), then in step 308, data eviction module 145 indicates eviction of the second clean cached data from L3 cache 140 by sending a system memory address of the second cached data to LLC 144; otherwise, data eviction module 145 proceeds to step 314 of Figure 4. In some embodiments, data eviction module 145 accesses probe information 148 to obtain the system memory address of the second cached data and propagates the system memory address of the second cached data to LLC 144 via coherent interconnect 160. In step 310, the LLC controller 150 fetches the second cache data from the system memory 116 using the system memory address of the second cache data received from the data eviction module 145 (i.e., the LLC controller 150 refetches the second clean cache data from the system memory 116) and stores the fetched second cache data in the LLC 144.In step 312 , the L3 controller stores the first cache data in the L3 cache 140 .

[0038] 4, data eviction module 145 determines that the second cache data is dirty and signals an error if not. In step 316, data eviction module 145 evicts the second dirty cache data from L3 cache 140 by sending a cache line of the second dirty cache data to LLC 144. In some embodiments, data eviction module 145 propagates the cache line of the second dirty cache data to LLC 144 via coherent interface 160. In step 318, the LLC controller receives the propagated second dirty cache data and initiates storage of the second dirty cache data in LLC 144.

[0039] Thus, the data eviction module 145 sends only the system memory addresses (i.e., not the entirety of the evicted clean cache data) to the LLC 144 for the clean cache data to be evicted from the L3 cache 140. In this manner, the data eviction module 145 advantageously saves significant system resources, time, and power.

[0040] 5 is a flow diagram illustrating a method for eviction and refetching of clean data to a last level cache (LLC) according to some embodiments. At block 502, a clean data block is evicted from a mid-level cache in a multiple cache hierarchy of a processing system. For example, the data eviction module 145 evicts a clean data portion of data stored in the L3 cache 140 and initiates caching of the evicted portion in the LLC 144. The data eviction module 145 sends an address of the clean data portion to the LLC 144.

[0041] In block 504, the LLC bypasses propagating the evicted clean data block to the LLC 144. In block 506, the LLC 144 accesses the address of the evicted clean data block. For example, the LLC 144 receives the address from the data eviction module 145.

[0042] In block 508, the LLC initiates fetching the evicted clean data block from system memory based on the accessed address. For example, LLC 144 initiates reading the clean data block from system memory 116. In this manner, data eviction module 145 advantageously reduces inter-cache traffic, consuming substantially less system resources and power, and increasing speed when caching evicted cache data from L3 cache 140 to LLC 144.

[0043] In some embodiments, the above apparatus and techniques are implemented in a system that includes one or more integrated circuit (IC) devices (also referred to as integrated circuit packages or microchips), such as the processing systems described above with reference to Figures 1-5. Electronic design automation (EDA) and computer aided design (CAD) software tools can be used in the design and manufacture of these IC devices. These design tools are typically represented as one or more software programs. The one or more software programs include code executable by a computer system for operating the computer system to operate on code representing circuits of one or more IC devices to perform at least a portion of a process for designing or adapting a manufacturing system for manufacturing the circuits. This code may include instructions, data, or a combination of instructions and data. The software instructions representing the design tool or manufacturing tool are typically stored in a computer readable storage medium accessible to the computing system. Similarly, code representing one or more stages of the design or manufacture of the IC device is stored in and accessed from the same computer readable storage medium or a different computer readable storage medium.

[0044] A computer-readable storage medium includes any non-transitory storage medium or combination of non-transitory storage media that can be accessed by a computer system during use to provide instructions and / or data to the computer system. Such storage media may include, but are not limited to, optical media (e.g., compact discs (CDs), digital versatile discs (DVDs), Blu-ray discs), magnetic media (e.g., floppy disks, magnetic tape, magnetic hard drives), volatile memory (e.g., random access memory (RAM) or cache), non-volatile memory (e.g., read-only memory (ROM) or flash memory), or micro-electromechanical systems (MEMS) based storage media. The computer-readable storage medium (e.g., system RAM or ROM) may be internal to the computing system, the computer-readable storage medium (e.g., a magnetic hard drive) may be permanently attached to the computing system, the computer-readable storage medium (e.g., an optical disk or Universal Serial Bus (USB)-based flash memory) may be removably attached to the computing system, or the computer-readable storage medium (e.g., network-accessible storage (NAS)) may be coupled to the computer system via a wired or wireless network.

[0045] In some embodiments, certain aspects of the techniques described above are implemented by one or more processors of a processing system executing software. The software includes one or more sets of executable instructions stored or otherwise tangibly embodied in a non-transitory computer-readable storage medium. The software may include instructions and specific data that, when executed by the one or more processors, operate the one or more processors to perform one or more aspects of the techniques described above. The non-transitory computer-readable storage medium may include, for example, a magnetic or optical disk storage device, a solid-state storage device such as a flash memory, a cache, a random access memory (RAM), or other non-volatile memory device(s), etc. The executable instructions stored in the non-transitory computer-readable storage medium may be implemented as source code, assembly language code, object code, or other form of instructions that can be interpreted or otherwise executed by one or more processors.

[0046] In addition to the above, it should be noted that not all activities or elements described in the summary description are required, some of the specific activities or devices may not be required, one or more additional activities may be performed, and one or more additional elements may be included. Furthermore, the order in which the activities are listed is not necessarily the order in which they are performed. Also, the concepts have been described with reference to specific embodiments. However, those skilled in the art will appreciate that various changes and modifications can be made without departing from the scope of the invention as set forth in the claims. Thus, the specification and drawings should be regarded in an illustrative rather than a restrictive sense, and all such modifications are intended to be included within the scope of the invention.

[0047] Benefits, other advantages, and solutions to problems have been described above with respect to specific embodiments. However, the benefits, advantages, solutions to problems, and features by which any benefit, advantage, or solution may occur or be manifested are not to be construed as critical, essential, or essential features of any or all claims. Moreover, the specific embodiments described above are illustrative only, as the disclosed invention may be modified and practiced in different but similar manners apparent to those skilled in the art having the benefit of the teachings herein. No limitations are intended to the details of construction or design herein shown, other than as set forth in the appended claims. It is therefore apparent that the specific embodiments described above may be altered or modified, and all such variations are considered to be within the scope of the disclosed invention. Accordingly, the protection sought herein is set forth in the appended claims.

Claims

1. accessing an address of the first clean data block in response to evicting the first clean data block from the Mid Level Cache; and initiating a fetch of the first clean data block from a system memory to a last level cache (LLC) using the address. method.

2. propagating the address of the first clean data block from the Mid Level Cache to the LLC.

2. The method of claim 1.

3. in response to an eviction of a first dirty data block from the Mid Level Cache, propagating the first dirty data block from the Mid Level Cache to the LLC. The method of claim 1 or 2.

4. the first dirty data block comprises data that has been written to one or more caches of the cache hierarchy via one or more of a write instruction or a modify instruction; 2. The method of claim 1.

5. and upon eviction of the second clean data block from the Mid Level Cache, based on a determination that a hit ratio of the LLC is below a predetermined threshold or a determination that an interface between the system memory and the LLC currently has a storage capacity for fetching data below a predetermined threshold, bypassing storing the second clean data block in the LLC.

2. The method of claim 1.

6. in response to the eviction of the second clean data block from the Mid Level Cache, propagating the second clean data block from the Mid Level Cache to the LLC based on a determination that a coherent interconnect between the Mid Level Cache and the LLC currently has storage capacity above a predetermined threshold for propagating data or a determination that a current power usage level is below a predetermined threshold level of power usage.

2. The method of claim 1.

7. initiating the fetch of the first clean data block from the system memory includes accessing a memory controller.

2. The method of claim 1.

8. bypassing propagation of the first clean data block from the Mid Level Cache to the LLC.

2. The method of claim 1.

9. A processor; System memory; Multiple cache hierarchies; A cache controller, The cache controller accessing an address of the first clean data block in response to an eviction of the first clean data block from a mid-level cache in the multiple cache hierarchy; Initiating a fetch of the first clean data block from the system memory to a last level cache (LLC) using the address. Processing system.

10. The cache controller propagating the address of the first clean data block from the Mid Level Cache to the LLC; The processing system of claim 9.

11. The cache controller in response to an eviction of a first dirty data block from the Mid Level Cache, propagating the first dirty data block from the Mid Level Cache to the LLC; 11. The processing system according to claim 9 or 10.

12. the first dirty data block includes data that has been written to one or more caches of the multiple cache hierarchies via one or more of a write instruction or a modify instruction; The processing system of claim 11.

13. The cache controller in response to evicting the second clean data block from the Mid Level Cache, bypassing storing the second clean data block in the LLC based on a determination that a hit ratio of the LLC is below a predetermined threshold or a determination that an interface between the system memory and the LLC currently has a storage capacity for fetching data below a predetermined threshold. The processing system of claim 11.

14. The cache controller in response to the eviction of a second clean data block from the Mid Level Cache, propagating the second clean data block from the Mid Level Cache to the LLC based on a determination that a coherent interconnect between the Mid Level Cache and the LLC currently has storage capacity above a predetermined threshold for propagating data or a determination that a current power usage level is below a predetermined threshold level of power usage; The processing system of claim 11.

15. initiating a read of the first clean data block from the system memory includes accessing a memory controller. The processing system of claim 9.

16. The cache controller bypassing propagation of the first clean data block from the Mid Level Cache to the LLC; The processing system of claim 9.

17. In response to a request to store first cached data in a mid level cache within a multiple cache hierarchy of a processing system, determining that a storage capacity of the mid level cache has been exceeded; initiating an eviction of a first clean data block from the Mid Level Cache, the eviction including sending an address of the first clean data block to a Last Level Cache (LLC); in response to receiving the address at the LLC, caching the evicted first clean data block in the LLC by fetching the first clean data block from a system memory using the address transmitted from the mid level cache. method.

18. in response to an eviction of a first dirty data block from the Mid Level Cache, transmitting the first dirty data block from the Mid Level Cache to the LLC.

20. The method of claim 17.

19. bypassing transmission of the first clean data block from the Mid Level Cache to the LLC.

19. The method of claim 17 or 18.

20. obtaining the address of the first clean data block from system probe information stored in the mid level cache; 20. The method of claim 17.

Citation Information

Patent Citations

  • Data transfer system

    JP1984033689A

  • Reducing traffic in hierarchical cache interconnects

    US10402329B1

  • Dynamic Inclusive Policy in a Hybrid Cache Hierarchy Using Bandwidth

    US20130151778A1

  • Selective victimization in a multi-level cache hierarchy

    US20150149721A1