MECHANISM FOR REDUCING COHERENCE DIRECTORY CONTROLLER OVERHEAD OF NEAR MEMORY COMPUTE ELEMENTS - Patent application
A PP-level coherence directory, or PimPF, addresses the lookup bottlenecks in coherence directory controllers by maintaining a separate directory for PIM commands, improving performance through reduced lookups and maintaining coherence states, thus optimizing PIM command processing.
Patent Information
- Application Number
- JP2024535346
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2021-12-23
- Filing Date
- 2022-12-01
- Publication Date
- 2024-12-05
AI Technical Summary
The overhead on coherence directory controllers is significant due to the need for multiple lookups in the system-level directory for each memory address affected by broadcast PIM commands, especially in workloads with large numbers of such commands, leading to processing bottlenecks.
Implementing a Parallel Processing (PP) level coherence directory, known as a Processing In-Memory Probe Filter (PimPF), which maintains a separate directory to track memory addresses affected by broadcast PIM commands, reducing the number of system-level lookups by using address signatures and maintaining coherence states at a finer granularity.
This approach significantly reduces the overhead on coherence directory controllers by minimizing unnecessary lookups, thereby enhancing the performance of PIM commands without requiring substantial architectural changes.
Smart Images

Figure 2024545214000001_ABST
Abstract
Description
[Background technology]
[0001] The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Thus, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section. Moreover, it should not be assumed that any of the approaches described in this section are well understood, conventional, or conventional by virtue of their inclusion in this section.
[0002] Since computational throughput scales faster than memory bandwidth, various techniques have been developed to keep data supplied to the growing computational capacity. Processing In Memory (PIM) embeds processing power in memory modules so that tasks can be processed directly in the memory modules. Similarly, Processing Near Memory (PNM) technology embeds processing power close to memory modules so that tasks can be processed without costly round-trip transmission to a host processor or other remote computing unit. As used herein, the term near memory compute element or processing near memory (PNM) may also refer to in-memory compute element or processing in memory (PIM) and vice versa.
[0003] In the context of Dynamic Random-Access Memory (DRAM), an example of a PIM configuration includes vector compute elements and local registers that allow some calculations, such as arithmetic calculations, to be performed locally in memory. This allows a memory controller to trigger local calculations in parallel on multiple memory modules without having to move data across memory module interfaces, which can significantly improve performance, especially for data-intensive workloads.
[0004] One technical problem with offloading computation to memory using PIM techniques is that, for example, while reducing data bus traffic and computational load on the processor, additional steps must be taken to ensure functional correctness. These additional steps include performing an address check in the coherence directory controller to determine if any processor-side caches store data at an address corresponding to a near memory-centric command, and then flushing and / or invalidating any identified data. More specifically, if a cache stores dirty data at an address accessed by a near memory-centric command, the dirty data must be flushed from the cache to memory to ensure that the near memory-centric operation operates on the latest version of the data. If a cache stores clean data for a near memory-centric command that updated this data, the clean data must be invalidated to ensure that a subsequent processor-side compute-centric operation retrieves the results of the near memory-centric operation from memory instead of using stale data from the cache.
[0005] To optimize the performance benefits of using PIM techniques, a memory controller may issue broadcast PIM commands in parallel to multiple target banks of a memory channel to cause those target banks to perform the same operation on the same individual memory cells (row, column). However, due to the functional correctness requirements discussed above, a lookup query may be required in the coherence directory controller for each memory address that is the target of the broadcast PIM command before the broadcast PIM command can proceed. Furthermore, due to memory channel address interleaving and the requirements of hardware-based PIM implementations, each memory address may be referenced in a separate directory entry that requires an individual lookup. These lookups may create a significant processing bottleneck, especially when servicing workstation and data center workloads that may generate a large number of broadcast PIM commands.
[0006] Therefore, there is a need for a solution to the technical problem of how to reduce the overhead of a coherence directory controller when processing broadcast PIM or PNM commands.
[0007] Embodiments are illustrated by way of example, and not by way of limitation, in the accompanying figures, in which like references refer to similar elements and in which: FIG. [Brief description of the drawings]
[0008] [Figure 1A] FIG. 2 is a block diagram illustrating an example of a system architecture for implementing a PIM Probe Filter (PimPF) in a coherence directory controller. [Figure 1B] FIG. 1B is a block diagram illustrating an example memory module according to FIG. 1A. [Diagram 2] FIG. 2 is a block diagram illustrating an exemplary data structure for a PimPF directory. [Figure 3A]1 is a flow diagram illustrating an approach for implementing PimPF in a coherence directory controller to service broadcast PIM requests with reduced overhead. [Figure 3B] 1 is a flow diagram illustrating an approach for implementing PimPF in a coherence directory controller to service broadcast PIM requests with reduced overhead. [Figure 3C] 1 is a flow diagram illustrating an approach for implementing PimPF in a coherence directory controller to service broadcast PIM requests with reduced overhead. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0009] In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the embodiments. However, it will be apparent to those skilled in the art that the embodiments may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the embodiments. I. Overview II. Architecture III. Broadcast PIM Commands IV. PimPF Coherence Directory Data Structure V. Using PimPF in a Coherence Directory Controller to Reduce Overhead A. Exemplary Process of Using PimPF for PIM Loading B. An exemplary process for using PimPF for PIM store C. Maintaining the PimPF Coherence Directory
[0010] (I. Overview) An approach is provided for reducing coherence directory controller overhead for near-memory compute elements. According to this approach, a parallel processing (PP) level coherence directory, also called a Processing In-Memory Probe Filter (PimPF), is added to the coherence directory controller. When the coherence directory controller receives a broadcast PIM command from a host or a PIM command directed in parallel to multiple memory banks, the PimPF accelerates the processing of the PIM command by maintaining a directory for cache coherence in the coherence directory controller that is separate from the existing system-level directory. The PimPF maintains the directory according to an address signature that defines the memory addresses affected by the broadcast PIM command. The PimPF can be used with one or more system-level directories. Two embodiments of the PimPF are described: a lightweight implementation that accelerates PIM loads to registers, and a heavyweight implementation that accelerates both PIM loads to registers and PIM stores to memory. This technical solution reduces the number of system level coherence directory lookups for broadcast PIM commands using near memory computing elements.
[0011] This approach has broad applicability to a variety of situations. For example, when dealing with workloads that primarily issue PIM loads, a lightweight implementation has the advantages of simplified implementation and reduced memory footprint. When dealing with workloads that also include significant PIM store activity, a heavyweight implementation may be preferred. Furthermore, the memory consumption of that individual directory can be controlled by defining a maximum number of entries and evicting entries according to least recently used (LRU) entries or other eviction rules. By implementing PimPF within an existing coherence directory controller, performance improvements can be brought to PIM while avoiding significant changes to the architecture.
[0012] (II. Architecture) 1A is a block diagram illustrating an exemplary system architecture 100 for implementing a PIM Probe Filter (PimPF) or PP level coherence directory 160 in a coherence directory controller 150. Computing device 110 may be implemented by any workstation or server having one or more processing units, such as a general purpose multi-core processor and a graphics processing unit (GPU). Processor 120A and processor 120B are shown in FIG. 1A, each having a corresponding cache 130A and 130B. The caches may include multiple levels of cache, such as three levels of cache, L1, L2, and L3, respectively. The multiple processing units may be collectively referred to as host 115.
[0013] Host 115 may send PIM commands over data bus 140 for eventual execution on PIM compute units 190A and 190B. Before that, components of memory subsystem 145 may perform various tasks to ensure functional correctness and to route the PIM commands to the correct memory modules 180A and 180B. For example, coherence directory controller 150 may perform a lookup on system level directory 155 to ensure that PIM compute units 190A and 190B operate on the latest correct data. If system level directory 155 indicates that any cache lines in cache 130A or cache 130B are dirty, the dirty data should be flushed to memory banks 185A and 185B, such as by a PIM load command, before the read operation. Similarly, if system level directory 155 indicates that the data residing in cache 130A or cache 130B is clean and the corresponding data in memory banks 185A and 185B has been updated, for example by a PIM store command, then the cache entry should be invalidated in caches 130A and 130B to prevent host 115 from operating using stale data.
[0014] As mentioned above, a PIM command may affect multiple memory addresses in parallel, so a corresponding number of lookups may still be required in the system-level directory 155 for each PIM command. To reduce the number of lookups, a PP-level coherence directory 160 is introduced into the coherence directory controller 150. The PP-level coherence directory 160 maintains a separate directory that tracks cache coherence state at the granularity of a PIM command, which may target, for example, one or more memory banks of a memory channel. When a future PIM command is received that targets the same range of addresses as a previously recorded PIM command, the coherence state can be retrieved directly from the separate directory, rather than querying the system-level directory 155 for all addresses of all PIM commands. After the coherence directory controller 150 can ensure functional correctness, the PIM command can be passed to the memory controller 170 for delivery to the PIM compute units 190A and 190B. For example, a PIM load may retrieve data from memory banks 185A and 185B into registers 195A and 195B, and a PIM store may store data from registers 195A and 195B into memory banks 185A and 185B.
[0015] (III. Broadcast PIM Commands) FIG 1B is a block diagram illustrating memory module 180A according to FIG 1A. Memory module 185A includes 16 memory banks, each including 2048 memory cells, and each memory cell can accommodate 32 bytes of data. For simplicity, only 16 memory cells are shown for each memory bank. The specific amount and size of memory banks, memory cells, memory modules, memory channels, etc. are exemplary and can be set according to application and hardware requirements.
[0016] When a PIM command is issued, the same command may be applied in parallel to the same cell in one or more banks of memory bank 185A. For example, when a PIM load is issued, the contents of the same shaded memory cell #4 may be retrieved in parallel from memory banks 01-16 and placed in corresponding register sets 01-16 in registers 195A. While this example operates on all available memory banks, some PIM commands may operate selectively on selected memory banks, which may be specified using a bit mask, lookup table, or other method. A PIM store operation may store data from register sets 01-16 into banks 01-16 of memory bank 185A. Thus, both PIM loads and PIM stores may require action by coherence directory controller 150 to ensure functional correctness. On the other hand, PIM arithmetic and logic operations may use processing units 01-16 to perform various arithmetic and logic operations using register sets 01-16 without accessing memory bank 185A. Therefore, these arithmetic and logical operations may bypass any action by the coherence directory controller 150 to ensure functional correctness.
[0017] (IV.PimPF Coherence Directory Data Structure) 2 is a block diagram illustrating an exemplary data structure for the PimPF directory. Memory address configuration 250 defines the address space of memory subsystem 145. For example, bit 0 defines the memory channel, i.e., channel 0 / memory module 180A or channel 1 / memory module 180B. Bits 1-4 define the memory bank within the selected memory channel, i.e., banks 01-16. Bits 5-15 define the memory cells, i.e., cells #0-2047, each of which contains 32 bytes of data.
[0018] As discussed above, a PIM command may be applied across multiple or all memory banks of a selected memory channel. Thus, the specific memory addresses to which a PIM command is applied may be identified using a signature, which may be the bits of memory address configuration 250 excluding the memory channel bits and the memory bank bits. Thus, bits 0-4 may be removed from the signature, resulting in bits 5-15. For example, 16 memory addresses may be derived from the signature by setting bit 0 (memory channel) to 0, repeating bits 1-4 (memory bank) from 0000, 0001 to 1111, and appending bits 5-15 (memory cells) from the signature to each memory address. If a PIM command is applied to a subset of memory banks, the repetition may include only the subset, rather than all memory banks.
[0019] The memory address to which a PIM command applies can be derived from the signature, so that the directories in the PP level coherence directories 260A-B contain entries that are identified using the signature. When a lookup query is made in the PP level coherence directories 260A-B, an entry either matches or does not match according to the signature sequence. The PP level coherence directory 260A represents a lightweight implementation in which a signature clean bit is specified for all memory addresses of the signature, while the PP level coherence directory 260B represents a heavy-duty implementation that specifies a coherence indicator for each of the 16 memory banks specified by the signature, i.e., 0 / Not Cached, 1 / Clean, and 2 / Dirty, as shown by the coherence indicator symbols 270. This data structure may be represented, for example, using a 2-bit value for each memory bank. Additional bits may be reserved, for example, to indicate whether the memory address is referenced in one or more of system level directories 155, which may help avoid unnecessary lookups if the result turns out to be a miss. As described in more detail below, the increased granularity of PP level coherence directory 260B also allows the PIM store to benefit from reduced lookups to system level directory 155.
[0020] V. Using PimPF in a Coherence Directory Controller to Reduce Overhead A. Exemplary Process of Using PimPF for PIM Loading 3A is a flow diagram illustrating a process 300 for implementing a PP level coherence directory 160 in a coherence directory controller 150 to service broadcast PIM requests while reducing overhead. At step 310, referring to FIG. 1A, the PP level coherence directory 160 receives a parallel processing (PP) command for multiple memory addresses identified by a signature. For example, a program executing on processor 120A or 120B of host 115 may send a PIM command for memory channel 0 over data bus 140 along with a signature. As described above in FIG. 2, the signature may identify multiple memory banks for applying the PIM command in parallel.
[0021] At step 312, the PP level coherence directory 160 determines whether the PP command is a PIM load or a PIM store. In this example, the PP command may correspond to a PIM load, and thus the process 300 proceeds to step 314. The PIM load may, for example, read a value from a memory bank 185A-185B for loading into a register 195A-195B. In some embodiments, a PIM command may be issued for the PIM compute units 190A-190B to load and process data directly from the memory banks 185A-185B without storing the data in a register 195A-195B.
[0022] In step 314, the PP level coherence directory 160 uses the signature to issue a first query to itself. As discussed above, the PP level coherence directory 160 may maintain a separate coherence directory from the existing system level directory 155, which may appear similar in structure to the PP level coherence directory 260A or 260B. To avoid excessive lookups, the PP level coherence directory 160 is first queried for available coherence information before querying the system level directory 155.
[0023] In step 316, the PP level coherence directory 160 determines whether the result of the first query is a hit or a miss. If the result is a hit, this indicates that a matching entry was found in the PP level coherence directory 160, and further processing steps may be performed, as shown in Figure 3B. If the result is a miss, this indicates that a matching entry was not found in the PP level coherence directory 160, and steps 318, 320, and 322 are performed to create a new entry for the signature in the PP level coherence directory 160.
[0024] In step 318, PP level coherence directory 160 issues one or more second queries to system level directory 155 using the multiple memory addresses. As mentioned above, due to memory interleaving and hardware implementation, the multiple memory addresses may require multiple individual lookups, or 16 lookups when using the example of 16 memory banks in the memory channel. Based on the response from system level directory 155, the coherence state of each memory address is known, e.g., clean, dirty, or not cached. Additionally, the associated cache lines in cache 130A and / or cache 130B may also be identified.
[0025] At step 320, PP level coherence directory 160 flushes the first dirty data from at least one of caches 130A and 130B to the multiple memory addresses based on the results of the second query. For example, for each memory address marked as dirty at step 318, PP level coherence directory 160 may instruct host 115 to flush the corresponding dirty cache lines in cache 130A and / or cache 130B. The flush may result in a memory write command that updates memory banks 185A and / or 185B with the latest data from caches 130A and 130B.
[0026] In step 322, the PP level coherence directory 160 allocates within itself a first entry that indicates whether the memory addresses are clean. As described in FIG. 2, this indicator may be lightweight by using a signature clean bit as shown in the PP level coherence directory 260A, or the indicator may be heavyweight by using a coherence indicator for each memory bank as shown in the PP level coherence directory 260B. The signature clean bit indicates whether the entire signature is clean (set) or not cached (not set), and the coherence indicator indicates whether each of the memory banks in the signature is clean, dirty, or not cached. After the first entry is allocated, any future PIM command using the same signature will result in a hit in step 316, thereby advantageously avoiding step 318 or a query to the system level directory 155.
[0027] In step 324, PP level coherence directory 160 sends a PP command or PIM load to memory controller 170 for parallel execution on PIM compute unit 190A. Because this PP command is a PIM load, this corresponds to loading data from the memory address identified by the signature from memory bank 185A into register 195A. Because the steps prior to step 324 of process 300 ensured functional correctness, step 324 can proceed to read the latest correct data from memory bank 185A.
[0028] Assume that the host 115 sends a new PP command for the same signature as the one already recorded in step 322. If the process 300 is repeated, this time the result of step 316 may be a hit instead of a miss. Referring to process 330 of FIG. 3B, in step 340, the PP level coherence directory 160 determines whether the signature clean bit is set in the result of the first query. If this bit is set, this indicates that all memory addresses for the signature are marked as clean, and therefore the process 330 can proceed directly to step 324 since there is no need to flush dirty data. Thus, advantageously, step 318 can be avoided. The signature clean bit may also be inferred by checking whether the coherence indicators for a signature are all set to "clean" or "uncached". Otherwise, if the signature clean bit is not set or at least one coherence indicator is not clean, this indicates that a dirty set of addresses exists and process 330 proceeds to step 341 .
[0029] In step 341, the PP level coherence directory 160 issues one or more fifth queries to the system level directory 155 using the dirty set of memory addresses. For example, if the signature clean bit is not set, the coherence state of all addresses is unknown, and therefore the dirty set is indicated by all 16 addresses of the signature. In another example, the results of the first query may include a coherence indicator as shown in the PP level coherence directory 260B. In this case, the dirty set may be indicated from the results of the first query or by including memory addresses of the signature marked with coherence indicator 2, which indicates dirty. The dirty set may be queried to the system level directory 155 to determine cache lines to flush, but queries to the system level directory 155 may be omitted for other addresses that are marked as clean or are not cached. Thus, note that the additional metadata provided by PP level coherence directory 260B may reduce the number of lookups to system level directory 155 since only the dirty set is queried. If the dirty set is a subset of the addresses in the signature, then correspondingly fewer queries will be issued to system level directory 155. For example, if one memory address is marked as dirty in the metadata of a signature associated with 16 memory addresses, then the fifth query will issue one query, thereby avoiding 15 queries to other addresses.
[0030] At step 342, PP level coherence directory 160 flushes the second dirty data from at least one of caches 130A and 130B based on the results of the fifth query. For example, the results of the fifth query may include cache lines that require flushing, and such action may be taken.
[0031] In step 344, the PP level coherence directory 160 updates the first entry in itself based on the flush of the second dirty data. For example, if a signature clean bit is used, it may be set to clean. If a coherence indicator for the memory bank is used, the coherence indicator may be updated so that the flushed address is clean. Process 330 may then proceed to step 324.
[0032] B. An Exemplary Process for Using PimPF for PIM Store In an example where the PP command sent from the host 115 is a PIM store command, step 312 may instead proceed to Figure 3C. Referring to process 350 of Figure 3C, in step 360, the PP level coherence directory 160 issues a third query to itself using the signature. Step 360 may be performed similarly to step 316 described above. If a lightweight implementation is used, step 360 may be skipped since there may be insufficient information in the PP level coherence directory 160 to determine whether there is cached data to invalidate, and thus, of course, a query to the system level directory 155 may occur.
[0033] In step 362, the PP level coherence directory 160 issues a fourth query to the system level directory 155 using the multiple memory addresses based on the results of the third query. If step 360 is skipped and no results from the third query are available, a fourth query is issued for each of the multiple memory addresses. Similarly, if the third query is a miss, each memory address is looked up since there is no information available. If the third query is a hit and using a heavyweight implementation, a "non-cached" memory address does not trigger a coherence issue and does not need to be looked up. This reduces lookups for the PIM store at the expense of additional metadata storage required for a heavyweight implementation. Thus, memory addresses that are "clean" or "dirty" can be looked up using the system level directory 155 to determine the specific cache lines to flush or invalidate.
[0034] At step 364, PP level coherence directory 160 flushes the third dirty data from at least one of caches 130A and 130B to the multiple memory addresses based on the results of the fourth query. Thus, the cache lines identified as dirty may be flushed from caches 130A and 130B.
[0035] In step 366, PP level coherence directory 160 invalidates clean data from at least one of caches 130A and 130B based on the results of the fourth query. Thus, cache lines identified as clean may be invalidated in caches 130A and 130B.
[0036] In step 368, the PP level coherence directory 160 allocates within itself the second entry indexed by the signature if the second entry does not already exist. If the second entry already exists, step 368 is skipped.
[0037] In step 370, the PP level coherence directory 160 updates the second entry to indicate that the multiple memory addresses are not cached. Because the PIM store command overwrites data in the multiple memory addresses, the cache will have outdated data and is therefore marked as "not cached." If a lightweight implementation is used, the signature clean bit may be set instead. Process 350 may then proceed to step 324.
[0038] (Maintaining the C.PimPF coherence directory) Coherence directory controller 150 may also receive standard memory load / read and store / write commands, so the impact of these commands should also be considered when maintaining a separate coherence directory in PP level coherence directory 160. For example, when using a lightweight implementation, if a standard memory store operation is received and a PimPF entry exists for the associated memory address, this entry should be updated, for example, by evicting the entry, by resetting the associated signature clean bit, or by adjusting the coherence indicator for the associated memory address. Standard memory load operations can be ignored with respect to the PimPF, since data in memory is not modified. Furthermore, standard memory read / write operations may evict cache lines, but do not necessarily update any cache lines tracked in the PimPF in response to the eviction.
[0039] When using a heavyweight implementation, a load instruction on the host may fetch a cache line that is tracked by the PimPF. Thus, the load instruction may trigger a query to the PimPF to determine if the cache line is tracked, and if so, the corresponding metadata or coherence indicator is set to "clean". Similarly, a store instruction on the host modifies data in a memory address, and thus the store instruction may trigger a query to the PimPF to determine if there is an entry tracking the memory address, and the corresponding metadata or coherence indicator is set to "dirty". Furthermore, standard memory read / write operations may evict cache lines, but may not necessarily update any cache lines tracked in the PimPF in response to the eviction.
Claims
1. Receiving a parallel processing (PP) command for a plurality of memory addresses identified by a signature; In response to the PP command being a load from the memory addresses to a plurality of near-memory compute elements, issuing a first query to a PP level coherence directory using the signature; In response to the first query result being a miss, issuing a second query to a system level coherence directory using the plurality of memory addresses; flushing first dirty data from at least one cache to the plurality of memory addresses based on results of the second query; allocating a first entry in the PP-level coherence directory indexed by the signature, the first entry indicating whether the plurality of memory addresses is clean; sending the PP command to a memory controller for parallel execution on the plurality of near-memory compute elements. method.
2. responsive to the first query result being a hit; inhibiting issuance of the second query in response to a signature clean bit being set in a result of the first query.
2. The method of claim 1.
3. in response to the first query result being a hit and indicating a dirty set of the plurality of memory addresses, issuing a fifth query to the system level coherence directory using the dirty set of memory addresses; flushing second dirty data from the at least one cache to the plurality of memory addresses based on results of the fifth query; and updating the first entry in the PP-level coherence directory based on flushing the second dirty data.
2. The method of claim 1.
4. in response to determining that the PP command is a store from the plurality of near memory compute elements to the plurality of memory addresses, issuing a third query to the PP level coherence directory using the signature; issuing a fourth query to the system level coherence directory using the plurality of memory addresses based on results of the third query; and flushing third dirty data from the at least one cache to the plurality of memory addresses based on results of the fourth query; and invalidating clean data from the at least one cache based on results of the fourth query; and assigning the second entry indexed by the signature to the PP level coherence directory in response to a second entry not already existing; updating the second entry to indicate that the plurality of memory addresses are not cached.
2. The method of claim 1.
5. issuing the fourth query to the system level coherence directory for each of the plurality of memory addresses that are indicated as clean or dirty in the PP level coherence directory; The method of claim 4.
6. each entry in the PP-level coherence directory includes a signature clean bit that indicates whether an associated memory address in the each entry is (1) clean or (2) dirty; 2. The method of claim 1.
7. each entry in the PP-level coherence directory includes a data structure that indicates whether an associated memory address in the entry is (1) uncached, (2) clean, or (3) dirty; 2. The method of claim 1.
8. the data structure indicates whether each of the associated memory addresses has a corresponding entry at one or more levels of granularity of the system level coherence directory. The method of claim 7.
9. the plurality of near-memory compute elements are in-memory compute elements or near-memory compute elements; 2. The method of claim 1.
10. the plurality of memory addresses correspond to the same memory cells in a plurality of memory banks of a selected memory channel; 2. The method of claim 1.
11. the plurality of memory banks corresponds to all memory banks of the selected memory channel; The method of claim 10.
12. the dirty set being a subset of the plurality of memory addresses. The method of claim 3.
13. comprising processing logic configured to perform the method of any one of claims 1 to 12, Coherence Directory Controller.
14. comprising instructions executable by a processor to perform the method of any one of claims 1 to 12, A computer-readable storage medium.
Citation Information
Patent Citations
Cache coherence for processes in memory
JP2019517687A
Method and apparatus for processing instructions using processing-in-memory
US20180336035A1
