Extend cache snooping mode for coherency protection of certain requests
By extending the protection window and snooping logic of cache lines in a multiprocessor system, the delay problem caused by refresh or cleanup operations due to new replica creation is solved, and the success rate and efficiency of the operation is improved.
Patent Information
- Application Number
- CN202080083171.9
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2019-12-03
- Filing Date
- 2020-11-25
- Publication Date
- 2024-11-15
- Estimated Expiration
- 2040-11-25
AI Technical Summary
In a multiprocessor computer system, the delay in refresh or cleanup operations due to the creation of new replicas by other consistency participants affects the successful completion of the cache consistency protocol.
By extending the protection window of the target cache line, using snoop logic to respond to refresh or clean operation requests on the system structure and enter referee mode to protect memory blocks from conflicting access from multiple processor cores and ensure consistent ownership transfer.
It effectively prevents other consistent participants from competing access to the target cache line, reduces the number of retrys of refresh or clean operations, and improves the speed of successful completion of operations.
Smart Images

Figure CN114761932B_ABST
Abstract
Description
Background Art
[0001] The present invention relates generally to data processing, and more particularly to a cache snooping mode that extends coherency protection for flush / clean memory access requests that update system memory.
[0002] A conventional multiprocessor (MP) computer system, such as a server computer system, includes multiple processing units, all of which are coupled to a system interconnect, which typically includes one or more address, data, and control buses. Coupled to the system interconnect is a system memory, which represents the lowest level of shared memory in a multiprocessor computer system and is typically accessible for read and write by all processing units. To reduce access latency to instructions and data residing in the system memory, each processing unit is also typically supported by a corresponding multi-level cache hierarchy, the lower levels of which may be shared by one or more processor cores.
[0003] Cache memory is typically used to temporarily buffer memory blocks that may be accessed by a processor in order to speed up processing by reducing access delays introduced by having to load required data and instructions from system memory. In some MP systems, the cache hierarchy includes at least two levels. Level 1 (L1) or higher level caches are typically dedicated caches associated with a specific processor core and cannot be accessed by other cores in the MP system. Typically, in response to memory access instructions such as load or store instructions, the processor core first accesses the directory of the higher level cache. If the requested memory block is not found in the higher level cache, the processor core accesses a lower level cache (e.g., level 2 (L2) or level 3 (L3) cache) for the requested memory block. The lowest level cache (e.g., L2 or L3) can be shared by multiple processor cores.
[0004] Because multiple processor cores can request write access to the same cache line of data, and because modified cache lines are not immediately synchronized with system memory, the cache hierarchy of a multiprocessor computer system typically implements a cache coherence protocol to ensure at least a minimum level of coherence between the various processor cores of the contents of system memory. In particular, cache coherence requires, at a minimum, that after a hardware thread accesses a copy of a memory block and subsequently accesses an updated copy of the memory block, the hardware thread cannot access the old copy of the memory block again.
[0005] Some MP systems support refresh and clean operations, which cause modified cache lines associated with the target address of a refresh or clean operation to be copied back to system memory from a unique cache hierarchy that contains cache lines in a consistency state indicating write permission (sometimes referred to herein as "HPC" state), if any. For a clean operation, the target cache line is also transitioned to an unmodified HPC consistency state. For a refresh operation, the target cache line in the HPC state, whether modified or not, if any, is transitioned to an invalid consistency state. A refresh operation also requires that any other one or more copies of the target cache line in a non-HPC state be invalidated in all cache hierarchies of the MP system. This invalidation may not be completed when the cache (if any) that holds the target cache line in the HPC state has completed its processing.
[0006] In an MP system that maintains consistency through a snoop-based consistency protocol, a refresh or clean operation is typically broadcast over the system interconnect of the MP system and receives a retry consistency response as long as the cache holding the target cache line in the HPC state has not completed processing of the refresh or clean operation. Therefore, the consistency participant initiating the refresh or clean operation may need to reissue the refresh or clean operation multiple times before the cache holding the target cache line in the HPC state (if any) has completed its processing of the refresh or clean operation. When the cache holding the target cache line in the HPC state has completed processing of the refresh or clean operation, and if a new copy of the target cache line in the HPC state has not been created (in the modified HPC state for the clean operation, in the modified or unmodified HPC state for the refresh operation), a subsequent issuance of the clean operation will receive a consistency response indicating success, and a subsequent issuance of the refresh operation will receive a consistency response indicating success (if no cache copy of the line exists) or receive a consistency response that transfers the responsibility for invalidating any remaining non-FIPC cache copies of the target cache line to the initiating consistency participant. In any of these cases for a refresh operation, a refresh operation may be considered to have "succeeded" in the sense that the refresh operation has been fully completed or will be completed once the remaining non-HPC copies of the target cache line have been invalidated by the initiating coherence participant (e.g., by issuing a kill operation). However, if, prior to a subsequent issuance of a clean or refresh operation, another coherence participant creates a new copy of the target cache line in a relevant HPC state (i.e., in a modified HPC state for a clean operation, and in either a modified or unmodified HPC state for a refresh operation), then a subsequent re-issuance of the refresh or clean operation will again be retried and will have to process the new copy of the target cache line in the HPC state, thereby delaying the successful completion of the refresh or clean operation. This delay may be further exacerbated by the continued creation of new HPC copies of the target cache line of the refresh or clean operation. Summary of the invention
[0007] In at least one embodiment, a target cache line of a flush or clean operation is protected from competing accesses from other coherence participants by extending a protection window of the target cache line by a designated coherence participant.
[0008] According to one aspect of the present invention, a cache memory is provided, which includes a data array, a directory of the contents of the data array specifying consistency state information, and snooping logic for processing operations snooped from a system structure by referring to the data array and the directory. The snooping logic responds to a request to snoop on a refresh or clean memory access operation of a processor core of a specified target address among multiple processor cores on the system structure, serves the request, and then enters a referee mode. When in referee mode, the snooping logic protects a memory block identified by the target address from conflicting memory access requests from multiple processor cores, so that other consistency participants are not allowed to assume consistency ownership of the memory block. BRIEF DESCRIPTION OF THE DRAWINGS
[0009] Figure 1 is a high-level block diagram of an exemplary data processing system according to one embodiment
[0010] Figure 2 is a more detailed block diagram of an exemplary processing unit according to one embodiment;
[0011] Figure 3 is a detailed block diagram of a lower level cache according to one embodiment;
[0012] Figure 4 is an exemplary timing diagram of a processor memory access operation according to one embodiment;
[0013] Figure 5 is a high-level logic flow diagram of an exemplary process for a processing unit to perform a refresh / clean memory access operation according to one embodiment;
[0014] Figure 6 is a high-level logic flow diagram of an exemplary process by which a cache having coherent ownership of a target cache line of a snoop refresh or clean type request processes the request, according to one embodiment;
[0015] Figure 7 is a timing diagram of an exemplary refresh / scrub memory access operation according to one embodiment;
[0016] Figure 8 is a high-level logic flow diagram of an exemplary process by which a cache maintaining a non-HPC shared copy of a target cache of a snoop refresh type request processes the request, according to one embodiment;
[0017] Fig. 9 is a data flow diagram showing the design process. DETAILED DESCRIPTION
[0018] Referring now to the drawings, wherein like reference numerals designate like and corresponding parts throughout, and particularly to Figure 1 , a high-level block diagram depicting an exemplary data processing system 100 according to one embodiment is shown. In the depicted embodiment, data processing system 100 is a cache-coherent multiprocessor (MP) data processing system that includes a plurality of processing nodes 102 for processing data and instructions. Processing nodes 102 are coupled to a system interconnect 110 for communicating address, data, and control information. System interconnect 110 may be implemented, for example, as a bus interconnect, a switch interconnect, or a hybrid interconnect.
[0019] In the depicted embodiment, each processing node 102 is implemented as a multi-chip module (MCM) containing four processing units 104, each of which is preferably implemented as a respective integrated circuit. The processing units 104 within each processing node 102 are coupled to communicate with each other and with the system interconnect 110 via a local interconnect 114, which is similar to the system interconnect 110 and may be implemented, for example, using one or more buses and / or switches. The system interconnect 110 and the local interconnect 114 together form a system structure.
[0020] As the following reference Figure 2 As described in more detail, processing units 104 each include a memory controller 106 coupled to a local interconnect 114 to provide an interface to a respective system memory 108. Data and instructions residing in system memory 108 may generally be accessed, cached, and modified by a processor core in any processing unit 104 of any processing node 102 within data processing system 100. System memory 108 thus forms the lowest level of memory storage in the distributed shared memory system of data processing system 100. In alternative embodiments, one or more memory controllers 106 (and system memory 108) may be coupled to system interconnect 110 instead of local interconnect 114.
[0021] Those skilled in the art will understand that Figure 1 The MP data processing system 100 may include many additional components that are not shown, such as interconnect bridges, non-volatile memory, ports for connecting to a network, or attached devices, etc. Because these additional components are not necessary for understanding the described embodiments, they are not described in detail. Figure 1 However, it should also be understood that the enhancements described herein are applicable to data processing systems of different architectures and are by no means limited to Figure 1 The generalized data processing system architecture shown in .
[0022] Reference now Figure 2, describes a more detailed block diagram of an exemplary processing unit 104 according to one embodiment. In the described embodiment, each processing unit 104 is an integrated circuit including multiple processor cores 200 for processing instructions and data. Each processor core 200 includes one or more execution units for executing instructions, including an LSU 202 that executes memory access instructions that request access to a memory block or cause a request to access a memory block to be generated. In at least some embodiments, each processor core 200 is capable of independently executing multiple hardware execution threads simultaneously.
[0023] The operation of each processor core 200 is supported by a multi-level memory hierarchy having at its lowest level a shared system memory 108 accessed via an integrated memory controller 106. At its higher levels, the memory hierarchy includes one or more levels of cache memory, which in the illustrative embodiment includes a store-through level one (L1) cache 226 within and dedicated to each processor core 200, and a corresponding store-in level two (L2) cache 230 for each processor core 200. In order to efficiently handle multiple concurrent memory access requests to cacheable addresses, in some embodiments, each L2 cache 230 may be implemented with multiple L2 cache slices, each cache slice handling memory access requests to a corresponding set of real memory addresses.
[0024] Although the cache hierarchy shown includes only two levels of cache, those skilled in the art will appreciate that alternative embodiments may include additional levels (e.g., L3, L4, etc.) of on-chip or off-chip inline or look-aside caches that may fully, partially, or not include the contents of higher level caches.
[0025] Still reference Figure 2 Each processing unit 104 also includes an integrated and distributed fabric controller 216 responsible for controlling the flow of operations on the local interconnect 114 and the system interconnect 110, and response logic 218 for determining coherent responses to memory access requests used in a selected cache coherence protocol.
[0026] In operation, when a hardware thread executed by processor core 200 includes a memory access instruction requesting execution of a specified memory access operation, LSU 202 executes the memory access instruction to determine a target real address to be accessed. If the requested memory access cannot be fully executed by referencing L1 cache 226 of the executing processor core 200, processor core 200 generates a memory access request including, for example, at least a request type and a target real address, and sends the memory access request to its associated L2 cache 230 for processing.
[0027] Reference now Figure 3 , shows a more detailed block diagram of an example embodiment of L2 cache 230 according to one embodiment. Figure 3 As shown, L2 cache 230 includes a cache array 302 and a directory 308 for the contents of cache array 302. Assuming that cache array 302 and directory 308 are conventional set associative, memory locations in system memory 108 are mapped to specific congruence classes within cache array 302 using predetermined index bits within the system memory (real) address. The specific memory blocks stored within the cache lines of cache array 302 are recorded in cache directory 308, which contains one directory entry for each cache line. Although in Figure 3 Although not explicitly shown in the figure, those skilled in the art will understand that each directory entry in the cache directory 308 includes various fields, such as a tag field identifying the real address of the memory block held in the corresponding cache line of the cache array 302, a status field indicating the coherency status of the cache line, an LRU (least recently used) field indicating the replacement order of the cache line relative to other cache lines in the same congruence class, and an inclusive field indicating whether the memory block is held in the associated L1 cache 226.
[0028] The L2 cache 230 includes a plurality of (e.g., 16) Read-Claim (RC) machines 312a-312n for independently and concurrently servicing memory access requests received from the associated processor core 200. In order to service remote memory access requests originating from a processor core 200 other than the associated processor core 200, the L2 cache 230 also includes a plurality of Snoop (SN) machines 311a-311m. Each SN machine 311 can independently and concurrently process remote memory access requests "snooped" from the local interconnect 114. As will be appreciated, the servicing of memory access requests by the RC machine 312 may require replacement or invalidation of memory blocks within the cache array 302. Therefore, the L2 cache 230 includes a CO (castout) machine 310 that manages the removal and write-back of memory blocks from the cache array 302.
[0029] The L2 cache 230 also includes an arbiter 305 that controls the multiplexers M1-M2 to order the processing of local memory access requests received from the associated processor core 200 and remote requests snooped on the local interconnect 114. According to the arbitration policy implemented by the arbiter 305, the memory access request is forwarded to the dispatch logic 306, which processes the memory access request with respect to the directory 308 and the cache array 302 over a given number of cycles.
[0030] The L2 cache 230 also includes an RC queue (RCQ) 320 and a castout push intervention (CPI) queue 318, which buffer data inserted into and removed from the cache array 302, respectively. The RCQ 320 includes a plurality of buffer entries, each individually corresponding to a specific one of the RC machines 312, so that each RC machine 312 that is dispatched retrieves data only from the specified buffer entry. Similarly, the CPI queue 318 includes a plurality of buffer entries, each buffer entry individually corresponding to a corresponding one of the CO machine 310 and the SN machine 311, so that each snooper 311 that is dispatched and each CO machine 310 retrieves data only from the corresponding specified CPI buffer entry.
[0031] Each RC engine 312 also has assigned to it a respective one of a plurality of RC data (RCDAT) buffers 322 for buffering memory blocks read from the cache array 302 and / or received from the local interconnect 114 via a reload bus 323. The RCDAT buffer 322 assigned to each RC engine 312 is preferably configured with connections and functions corresponding to memory access requests that can be serviced by the associated RC engine 312. The RCDAT buffer 322 has an associated memory data multiplexer M4 that selects data bytes from among its inputs for buffering in the RCDAT buffer 322 in response to a select signal, not shown, generated by the arbiter 305.
[0032] In operation, a processor store request including a request type (ttype), a target real address, and store data is received from an associated processor core 200 within a store queue (STQ) 304. The store data is transmitted from the STQ 304 to the store data multiplexer M4 via a data path 324, and the store type and target address are passed to the multiplexer M1. The multiplexer M1 also receives as input a processor load request from the processor core 200 and a directory write request from the RC machine 312. In response to a select signal generated by an arbiter 305, not shown, the multiplexer M1 selects one of its input requests to forward to the multiplexer M2, which additionally receives as input a remote request received from the local interconnect 114 via a remote request path 326. The arbiter 305 schedules local and remote memory access requests for processing, and based on the schedule, generates a sequence of select signals 328. In response to the select signal 328 generated by the arbiter 305, the multiplexer M2 selects the local request received from the multiplexer M1 or the remote request snooped from the local interconnect 114 as the next memory access request to be processed.
[0033] Reference now Figure 4 , which depicts Figure 1 1. The time-space diagram of exemplary operations on the system architecture of data processing system 100 is shown, it being understood that at any given time, there will be many such operations in progress on the system architecture, and in some operational scenarios, multiple of these concurrent operations may specify conflicting target addresses.
[0034] Operation begins at the request stage 450, where the host 400, such as the RC engine 312 of the L2 cache 230, issues a request 402 on the system architecture. The request 402 preferably includes at least a request type indicating the type of access desired and a resource identifier (e.g., a real address) to be accessed by the request. The request preferably includes those set forth in Table I below.
[0035] Table I
[0036]
[0037]
[0038] Request 402 is received by snoopers 404a-404n distributed in data processing system 100, such as SN engines 311a-311m of L2 cache 230 and not shown snoopers in memory controller 106. For read-type requests, SN engine 311 in the same L2 cache 230 as host 400 of request 402 does not snoop request 402 (i.e., there is usually no self-snoop), because request 402 is transmitted on the system structure only when read-type request 402 cannot be serviced internally by processing unit 104. However, for other types of requests 402, such as refresh / clean requests (e.g., DCBF, DCBST, AMO requests listed in Table I), SN engine 311 in the same L2 cache 230 as host 400 of request 402 performs self-snoop on request 402.
[0039] Operation continues to a partial response phase 455. During the partial response phase 455, the snoopers 404 that received and processed the request 402 each provide a respective partial response ("Presp") 406 that represents at least the snooper's 404 response to the request 402. The snooper 404 within the integrated memory controller 106 determines the partial response 406 to provide based on, for example, whether the snooper 404 is responsible for the request address and whether it has resources currently available to service the request. The snooper 404 of the L2 cache 230 may determine its partial response 406 based on, for example, the availability of its L2 cache directory 308, the availability of the snoop logic instance 311 within the snooper 404 that processes the request, and the coherency state (if any) associated with the request address in the L2 cache directory 308.
[0040] Operation continues to the combine response stage 460. During the combine response stage 460, the partial responses 406 of the snooper 404 are logically combined in stages or all at once by one or more instances of the response logic 218 to determine a system-wide combined response ("Cresp") 410 to the request 402. In a preferred embodiment, which will be assumed hereinafter, the instance of the response logic 218 responsible for generating the combined response 410 is located in the processing unit 104 containing the host 400 that issued the request 402. The response logic 218 provides the combined response 410 to the host 400 and the snooper 404 via the system structure to indicate the system-wide response to the request 402 (e.g., success, retry, etc.). If Cresp 410 indicates success of request 402, Cresp 410 may indicate, for example, the data source of the requested memory block (if applicable), the coherency state of the requested memory block to be cached by the host 400 (if applicable), and whether a "cleanup" operation is required to invalidate the cached copy of the requested memory block in one or more L2 caches 230 (if applicable).
[0041] In response to receiving the combined response 410, one or more of the host 400 and the snooper 404 typically performs one or more operations to service the request 402. These operations may include providing data to the host 400, invalidating or otherwise updating the coherency state of data cached in one or more L2 caches 230, performing a throw operation, writing data back to the system memory 108, etc. If required by the request 402, the requested or target memory block may be sent to or from one of the host 400 or the snooper 404 before or after the response logic 218 generates the combined response 410.
[0042] In the following description, a partial response 406 of the snooper 404 to the request 402 and operations and / or a combined response 410 thereof performed by the snooper 404 in response to the request 402 will be described with reference to whether the request address specified by the snooper 404 relative to the request 402 is the highest point of consistency (HPC), the lowest point of consistency (LPC), or neither. The LPC is defined herein as a memory device or I / O device that serves as a final repository for a memory block. In the absence of a cache participant that maintains a copy of the memory block, the LPC maintains a unique image of the memory block. In the absence of an HPC cache participant for the memory block, the LPC has the sole authority to grant or deny a request to modify the memory block. In addition, when the LPC data is current data and there is no cache participant that can provide the data, the LPC provides the data to the request to read or modify the memory block. If a cache participant has a more current copy of the data but cannot provide it to the request, the LPC does not provide the expired data and the request is retried. For Figures 1 to 3 In a typical request in the embodiment of data processing system 100 given in FIG. 1 , the LPC would be the memory controller 106 of system memory 108 that holds the referenced memory block.
[0043] The HPC is defined herein as a uniquely identified device that caches the true image of a memory block (which may or may not be consistent with the corresponding memory block at the LPC) and has authorization to grant or deny requests to modify the memory block. Descriptively, the HPC (even if its copy is consistent with main memory behind the LPC) provides a copy of the memory block to the requester in response to any request to read or modify the memory block (cache-to-cache transfers are faster than LPC-to-cache transfers). Thus, for a typical request in a data processing system embodiment, the HPC (if any) will be the L2 cache 230. Although other indicators may be used to specify the HPC of a memory block, if any, the preferred embodiment uses the selected cache coherency state within the L2 cache directory 308 of the L2 cache 230 to specify the HPC of the memory block. In a preferred embodiment, the coherence state within the coherence protocol indicates, in addition to providing (1) an indication of whether the cache is the HPC for the memory block, (2) whether the cache copy is unique (i.e., is the only cache copy at the system level), (3) whether and when the cache can provide a copy of the memory block to a host requesting the memory block relative to the stage of operation, and (4) whether the cached image of the memory block is consistent with the corresponding memory block at the LPC (system memory). These four properties can be expressed, for example, in an exemplary variation of the well-known MESI (Modified, Exclusive, Shared, Invalid) protocol summarized below in Table II. Further information on coherence protocols can be found, for example, in U.S. Patent 7,389,388, which is incorporated herein by reference.
[0044] Table II
[0045]
[0046]
[0047] It is worth noting in Table II above that T, Te, S Land S states, which are all "shared" coherence states in that a cache memory can simultaneously maintain a copy of a cache line maintained by another cache memory in any of these states. The T or Te state identifies an HPC cache memory that previously maintained an associated cache line in one of the M or Me states, respectively, and initiated a query-only copy of the associated cache line to another cache memory. As an HPC, a cache memory maintaining a cache line in the T or Te coherence state has permission to modify the cache line or to grant such permission to another cache memory. A cache memory maintaining a cache line in the Tx state (e.g., T or Te) serves as the cache data source of last resort (after Cresp) for a query-only copy of that cache line because it would not be possible to obtain a query-only copy of the cache line if no cache memory maintaining a cache line in the S L If a cache memory of a cache line of state is available to serve as a data source (before Cresp), then the cache memory will only provide a query-only copy to another cache memory.
[0048] S L The S state is formed at a cache memory in response to the cache memory receiving a lookup-only copy of a cache line from a cache memory in a T coherency state. L The state is not an HPC coherent state, but the cache memory holding the cache line in the SL state has the ability to provide a query-only copy of the cache line to another cache memory, and may do so before receiving Cresp. In response to providing the query-only copy of the cache line as a source to another cache memory (which assumes S L state), the cache memory that is the source of the query-only copy of the cache line changes its coherence state for the cache line from S L Updated to S.
[0049] Reference again Figure 4 The HPC for the memory block referenced in request 402, if any, or the LPC for the memory block if no HPC exists, preferably has responsibility for protecting the transfer of coherent ownership of the memory block when necessary in response to request 402. Figure 4In the exemplary scenario shown, a snooper 404n at the HPC (or, in the absence of an HPC, the LPC) of a memory block specified by a request address of a request 402 protects the transfer of coherent ownership of the requested memory block to a host 400 during a protection window 412a that extends from the time the snooper 404n determines its partial response 406 until the snooper 304n receives a combined response 410, and during a subsequent window extension 412b that extends the programmable time beyond the time the snooper 404n receives the combined response. During the protection window 412a and the window extension 412b, the snooper 404n protects the transfer of ownership by providing a partial response 406 to other requests specifying the same request address, the partial response 406 preventing other hosts from obtaining ownership (e.g., retrying the partial response) until ownership has been successfully transferred to the host 400. Host 400 may similarly initiate protection window 413 to protect its coherent ownership of the memory block requested in request 402 after receiving combined response 410 .
[0050] Because snooper 404 has limited resources for processing the above-mentioned CPU and I / O requests, several different levels of Presp and corresponding Cresp are possible. For example, if the snooper in the memory controller 106 responsible for the requested memory block has a queue that can be used to process the request, the snooper can respond with a partial response indicating that it can be used as the LPC of the request. On the other hand, if the snooper does not have a queue that can be used to process the request, the snooper can respond with a partial response indicating that it is the LPC of the memory block but cannot currently serve the request. Similarly, the snooper 311 in the L2 cache 230 may need to snoop the available instance of logic and access the L2 cache directory 406 to process the request. Lack of access to any one (or both) of these resources causes a partial response (and corresponding Cresp) signaling notification that the request cannot be served due to lack of required resources.
[0051] As described above, in systems implementing snoop-based coherence protocols, refresh operations (e.g., DCBF and AMO) and cleanup operations (e.g., DCBST) may be subject to forward progress in the vulnerability window between the completion of the refresh / cleanup operation in the cache hierarchy containing the target cache line of HPC state (if any) and the host that initiated the final successful refresh / cleanup request. Figures 5 to 8 As described in detail, these forward progress issues may be addressed by having the coherence participant (ie, the HPC) with coherence ownership of the target cache line extend its protection window for the target cache line.
[0052] Now go to Figure 5, shows a high-level logic flow diagram of an exemplary process for a master 400 in a processing unit 104 (e.g., RC machine 312) to perform a refresh or clean-up type memory access operation according to one embodiment. As indicated above, any number of masters may concurrently perform their own respective refresh / clean-up memory access operations on potentially conflicting target addresses. Thus, multiple masters may be executed in a temporally overlapping manner within the data processing system 100. Figure 5 Multiple instances of the process are given in .
[0053] Figure 5 The process begins at block 500 and then proceeds to block 502, which shows that the host 400 issues a request 402 for a memory access operation on the system structure of the data processing system 100. In at least some embodiments, the host 400, such as the RC machine 312 of the L2 cache 230, issues the request 402 in response to receiving a memory access request from the associated processor core 200 based on the execution of the corresponding instruction by the LSU 202. In the described embodiment, the request 402 initiates a memory access operation belonging to one of several classes or types of operations, which are collectively referred to herein as refresh / clean (FC) operations. These FC operations include the DCBF, DCBST, and AMO operations referenced in Table I, which are all store-modify operations that require any modified cached copies of the target memory block to be written back to the associated system memory 108.
[0054] As in Figure 4 As is apparent from the foregoing discussion, the FC request 402 of the host 400 is received by the L2 cache 230 and the memory controller 106 distributed within the data processing system 100 in a system architecture. In response to the acceptance of the FC request 402, these various snoopers 404 generate their respective partial responses 406 and transmit the partial responses 406 to the relevant instance of the response logic 218. In the exemplary embodiment, the L2 cache 230 responds to the snoop FC request 402 with one of three Presps: (1) heavyweight retry, (2) lightweight retry, or (3) null. The heavyweight retry Presp is provided by the L2 cache 230 that currently cannot access the coherence state of the target address of the FC request 402 in its directory 308. In addition, the heavyweight retry Presp is also provided by the L2 cache 230 that is specified by the coherence state in its directory 308 as the HPC of the target address, but cannot respond to the FC request 402 at this time, or is currently busy processing a request for the target cache line.
[0055] The L2 cache 230 provides a lightweight retry Prep whose directory 308 is accessible and indicates the S of the target address. Land S states, and (1) another conflicting request for the target address is currently being processed, or (2) the SN engine 311 cannot be dispatched and the SN engine 311 is not currently active for the target address, or (3) the SN engine 311 has been dispatched to process the FC request 402.
[0056] It should be understood that for the entire interval, the L2 cache 230 has the SN engine 311 active to process requests for a given target address, and when the request is first snooped, the L2 cache 230 will provide a heavyweight retry Presp or a lightweight retry Presp based on the coherency state associated with the target address. Figure 6 The specific actions performed by the L2 cache 230 that holds the target address of the FC request 402 in a dirty (eg, M or T) HPC coherency state are described in detail below with reference to Figure 8 A detailed description is provided by keeping a shared (e.g., Te, S L or S) an action performed by the L2 cache 230 of the target address of the refresh request of the coherence state.
[0057] In response to the snoop FC request 402, the memory controller 106 that is not responsible for the target address (i.e., not responsible for the LPC) will not provide a Presp (or a null Presp). If the memory controller 106 cannot service the FC request 402 due to resource limitations or because the memory controller 106 is already servicing another memory access request that specifies the same address, the memory controller 106 that is the LPC memory controller of the target address of the FC request 402 provides a Retry_LPC Presp. If the LPC memory controller 106 is able to service the FC request 402, the LPC memory controller 106 protects the target address of the FC request 402 by providing an LPC_Retry Presp for any subsequent FC operations (or other operations) until it receives a successful Cresp for the originally snooped FC request 402.
[0058] Reference again Figure 5 , the process proceeds from block 502 to blocks 504-506, which illustrate that the host 400 of the request 402 for the FC operation issued at block 502 waits to receive the corresponding Cresp 410 from the response logic 218. In at least one embodiment, the response logic 218 may generate the Cresp 410 for the FC operation based on the received Presp of the snooper 404 as shown in Table III below. It should be noted that in at least some embodiments, the DCBST request does not receive the lightweight retry Presp (as shown in rows 1, 2, and 4 of Table III) because the DCBST request is held S L A cache ignore of the target cache line in any of the A and S states.
[0059] Table III
[0060]
[0061] In response to the acceptance of Cresp 410, the host 400 determines whether Cresp 410 indicates a retry, as shown in the first three rows of Table III (block 504). If so, the process returns to block 502, which shows the host 400 reissuing the request 402 for the FC operation on the system structure. If the host 400 determines at block 504 that the Cresp 410 of the request 402 is not a retry, then in the embodiment of Table III, the consistency result is Success_with_cleanup (Success_CU) (the fourth row of Table III) or Success (the fifth row of Table III). If Cresp 410 is successful (as indicated by a negative determination at block 506), the refresh or cleanup operation is successfully completed, and Figure 5 The process ends at 520 .
[0062] However, if Cresp 410 indicates Success_CU, the host 400 opens the protection window 413 and begins protecting the target address by causing any conflicting snooped requests to receive heavyweight retries (block 508). In addition, the host 400 issues a flush command on the system architecture to cause any modified cached copies of the target memory block residing at the HPC cache to be written back to the system memory 108 (block 510). Depending on the type of request 402, the flush command may additionally invalidate one or more other cached copies of the target memory block, as with the BK and BK_Flush commands included in Table II. After block 510, Figure 5 The process proceeds to block 512, which shows a determination of whether Cresp 410 for the clear command indicates success. If not, the process returns to block 510, which indicates that the host 400 reissues the clear command. Once Cresp 410 indicating success is received for the clear command issued at block 510, the host 400 closes the protection window 413 and thus ends protection of the target address (block 514), after which, Figure 5 The processing ends at box 520.
[0063] Reference now Figure 6 , which is a high-level logical flow chart of an exemplary process by which an HPC cache processes a snoop request for an FC memory access operation according to one embodiment. Figure 7 The timing diagram 700 is used to describe Figure 6 Flowchart of the process.
[0064] Figure 6 The process described in FIG. 6 starts at block 600 and then proceeds to block 602, which shows the L2 cache memory 230, which holds the target cache line of the FC memory access operation in a dirty HPC coherence state (e.g., M or T coherence state), snooping a request for the FC memory access operation from the local interconnect 114. The FC memory access operation may be, for example, a DCBF, DCBST, or AMO operation as described above, or any other storage modification FC operation that requires the modified cached data to be written back to the system memory 108. In response to the request to snoop the FC memory access operation, the L2 cache memory 230 allocates the SN engine 311 to service the FC memory access operation and sets the SN engine 311 to a busy state so that the SN engine 311 begins protecting the target real address specified by the request. Figure 7 The transition of the SN engine 311 at reference numeral 702 from the idle state to the busy state is shown, and the SN engine is assigned to service the request of the FC memory access operation. In addition, the L2 cache memory 230 provides a heavyweight retry Presp to the request of the FC memory access operation because the modified data from the target cache line has not been written to the system memory 108.
[0065] When the SN engine 311 is in the busy state, the SN engine 311 performs normal processing for the snooped request (block 604). The normal processing includes writing the modified data of the target cache line back to the associated system memory 108 via the system structure, and when the update of the system memory 108 is completed, invalidating the target cache line in the local directory 308 if required by the FC request 402. In addition, as further shown in block 604, when the SN engine 311 is in the busy state, the L2 cache 230 provides a heavyweight retry partial response to any snooped request requesting access to the target cache line, such as Figure 7 As shown at reference numeral 704, the heavyweight retry partial response causes the associated instance of the response logic 218 to form a RetryCresp 410, which forces the host of the conflicting request to reissue its request.
[0066] In some embodiments, the SN engine 311 assigned to the request for the FC memory access operation automatically sets a REF (referee) mode indicator (eg, Figure 6 Box 608 and Figure 7 706). Figure 6In other embodiments represented by optional block 606 of FIG. 1 , the SN engine 311 conditionally sets the REF mode indicator at block 608 only when a conflicting request for a non-FC operation is snooped by the L2 cache 230 while the SN engine 311 is busy processing a request for an FC memory access operation. After block 608, or if optional block 606 is implemented, after determining that no conflicting non-FC requests have been snooped, a determination is made at block 610 as to whether the processing of the snooped FC request by the SN engine 311 is complete. If not, then Figure 6 The process returns to the already described block 604. However, if it is determined that the processing of the snooped FC request by the SN machine 311 is complete, such as Figure 7 As shown in the figure mark 708, then Figure 6 The process proceeds from box 610 to box 612.
[0067] Block 612 shows that after completing the processing of its FC operation, the SN engine 311 determines whether the REF mode indicator is set. If not, the SN engine 311 returns to the idle state, such as Figure 6 Box 614 and Figure 7 As shown in the reference numeral 710 in FIG. After the frame 614, Figure 6 The process ends at block 616. Returning to block 612, if the SN engine 311 determines that the REF mode indicator is set, the SN engine 311 does not return to the idle state when the processing of the request for the FC operation is completed, but enters the REF (referee) mode to extend its protection of the target cache line, such as Figure 6 The frame 620 and Figure 7 As shown in the figure mark 712, in one embodiment, in conjunction with entering the REF mode, the SN machine 311 also starts a REF mode timer.
[0068] After block 620, processing by the SN engine 311 enters a processing loop in which the SN engine 311 monitors the expiration of the REF mode timer and the first occurrence of the acceptance of a REF mode termination request of the FC operation class, as shown in blocks 640 and 642, respectively. In this processing loop, the SN engine 311 monitors the system architecture for any conflicting non-FC operations that target the same cache line as the snooped FC request, such as Figure 6 Box 622 and Figure 7 In response to detecting any such conflicting non-FC request, the SN engine 311 provides a heavyweight retry Presp to the conflicting non-FC request, such as Figure 6 As shown in block 624 of FIG. 1 , this heavyweight retry Presp will cause the relevant instance of the response logic 218 to issue a retry Cresp, as described above with reference to FIG. Figure 5 As discussed in Table III of and block 504, the process then passes to block 640, which will be described below.
[0069] During the processing cycle, the SN engine 311 also monitors the system structure for any conflicting FC operations that target the same cache line as the earlier snooped FC request, such as Figure 6 Box 630 and Figure 7 In response to detecting any such conflicting FC request, the SN engine 311 provides a lightweight retry partial response to the conflicting FC request, such as Figure 6 As shown in block 632 of the embodiment, such a lightweight retry partial response will cause the associated instance of the response logic 218 to determine which of the multiple conflicting, temporally overlapping FC requests will be selected to update the system memory 108 first, for example based on the order implied by the partial responses provided by the associated memory controller 106. After block 632 or in response to a negative determination at both blocks 622 and 630, Figure 6 The process is passed to box 640.
[0070] Block 640 depicts the SN engine 311 determining whether a timeout for REF mode has occurred by referencing the REF mode timer. In various embodiments, the timeout may occur at a static predetermined timer value, or alternatively, at a dynamic value determined based on, for example, the number of conflicting FC and / or non-FC operations received during REF mode. In response to determining at block 640 that the REF mode has timed out, processing proceeds to block 650, which illustrates the SN engine 311 exiting the REF mode, as shown. Figure 7 As shown in the reference number 718, the SN engine 311 thus ends its protection of the target cache line and returns to the idle state ( Figure 6 Box 614 and Figure 7 720). Figure 6 The process then ends at box 616.
[0071] However, if the SN engine 311 determines at block 640 that the REF mode has not timed out, the SN engine 311 further determines at block 642 whether a termination request of the FC operation class (e.g., CLEAN_ACK, BK, BK_FLUSH) has been received on the system structure, such as Figure 7 As shown in the reference numeral 722, the termination request, although different for various embodiments and / or different types of FC memory access requests, provides an indication that the original FC request has been successfully selected to be processed by the memory controller 106 for the target memory block. If the SN engine 311 detects a termination request for the FC operation at block 642, then Figure 6 The process goes to block 650 and subsequent blocks, which have been described. However, if the SN engine 311 does not detect a termination request for the FC operation class on the system structure, the process returns from block 642 to block 622, which has been described.
[0072] Those skilled in the art will understand that Figure 6 A technique is disclosed in which an HPC snooper temporarily enters a REF mode, wherein the HPC snooper extends coherency protection of a memory block that is a target of a request for an FC memory access operation during an interval between the end of a refresh / scrub activity performed by the HPC snooper and the end of a request for processing at an LPC. This extended protection of the target cache line ensures that no other HPCs are formed for the target cache line before the FC memory access operation is guaranteed to succeed.
[0073] Reference now Figure 8 , describes a high-level logic flow diagram of an exemplary process by which a cache that maintains a non-HPC shared copy of a target cache of a snooped flush-type request (e.g., DCBF or AMO) processes the request. It should be noted that a cache that maintains a shared copy of a target cache of a clean (e.g., DCBST) request ignores the clean request.
[0074] Figure 8 The process starts at block 800 and then proceeds to block 802, which shows the L2 cache 230 that holds the target cache line of the initial request of the snoop refresh type operation (e.g., DCBF or AMO) or the refresh type request of the associated flush command (e.g., BK or BK_FLUSH). In response to the snoop initial request or the flush command, the L2 cache 230 provides a light retry response. In addition, in response to the initial request, the L2 cache 230 allocates the SN machine 311 to process the initial request. The allocated SN machine 311 transitions from the idle state to the busy state and begins to protect the target cache line.
[0075] At block 804, the SN engine 311 assigned to process the request snooped at block 802 performs normal processing of the initial request or flush command by invalidating the target cache line in the local directory 308. As further shown at block 804, while the SN engine 311 is busy, the L2 cache 230 provides a lightweight retry partial response to any snooped request requesting access to the target cache line. At block 806, it is determined whether the processing of the snooped request by the SN engine 311 is complete. If not, then Figure 8 The process returns to the already described block 804. However, if it is determined that the processing of the snooped request by the SN machine 311 is complete, the SN machine 311 returns to the idle state (block 808), and Figure 8 The processing ends at box 810.
[0076] Reference now Fig. 9, depicts a block diagram of an exemplary design flow 900 used, for example, in semiconductor IC logic design, simulation, testing, layout, and manufacturing. The design flow 900 includes a method for processing a design structure or device to generate the above and Figures 1 to 3 The process, machine and / or mechanism for a logically or other functionally equivalent representation of the design structure and / or device shown in the design flow 900, the design structure processed and / or generated by the design flow 900 can be encoded on a machine-readable transmission or storage medium to include data and / or instructions, which when executed or otherwise processed on a data processing system, generate a logically, structurally, mechanically or other functionally equivalent representation of a hardware component, circuit, device or system. Machines include, but are not limited to, any machine used in the IC design process, such as designing, manufacturing or simulating circuits, components, devices or systems. For example, machines may include: a photolithography machine, a machine and / or device for generating masks (such as an electron beam writer), a computer or device for simulating design structures, any device for manufacturing or testing processes, or any machine for programming a functionally equivalent representation of a design structure into any medium (such as a machine for programming a programmable gate array).
[0077] The design flow 900 may vary depending on the type of representation being designed. For example, the design flow 900 for building an application specific IC (ASIC) may be different from the design flow 900 for designing a standard component or different from the design flow 900 for instantiating a design into a programmable array, such as a programmable gate array (PGA) or a field programmable gate array (FPGA) provided by Altera Corporation or Xilinx Corporation.
[0078] Fig. 9 A plurality of such design structures are shown, including an input design structure 920 that is preferably processed by the design process 900. The design structure 920 may be a logic simulation design structure that is generated and processed by the design process 900 to produce a logically equivalent functional representation of a hardware device. The design structure 920 may also or alternatively include data and / or program instructions that, when processed by the design process 900, generate a functional representation of the physical structure of the hardware device. Whether representing functional and / or structural design features, the design structure 920 may be generated using electronic computer-aided design (ECAD), such as implemented by a core developer / designer. When encoded on a machine-readable data transmission, gate array, or storage medium, the design structure 920 may be accessed and processed by one or more hardware and / or software modules within the design process 900 to simulate or otherwise functionally represent a device such as a hardware device. Figures 1 to 3920. Thus, design structure 920 may include files or other data structures, including human and / or machine readable source code, compiled structures, and computer executable code structures, which, when processed by a design or simulation data processing system, functionally simulate or otherwise represent a circuit or other level of hardware logic design. Such data structures may include hardware description language (HDL) design entities or other data structures that conform to and / or are compatible with low-level HDL design languages such as Verilog and VHDL and / or high-level design languages such as C or C++.
[0079] The design process 900 preferably employs and incorporates hardware and / or software modules for synthesizing, converting, or otherwise processing data related to Figures 1 to 3 , circuits, devices, or logic structures shown in the embodiment of the present invention are equivalent to the design / simulation function to generate a netlist 980, which may contain a design structure such as design structure 920. Netlist 980 may include, for example, a compiled or otherwise processed data structure, which represents a list of wires, discrete components, logic gates, control circuits, I / O devices, models, etc. that describe connections to other elements and circuits in the integrated circuit design. Netlist 980 may be synthesized using an iterative process, wherein netlist 980 is resynthesized once or multiple times, depending on the design specifications and parameters of the device. As with other design structure types described herein, netlist 980 may be recorded on a machine-readable storage medium or programmed into a programmable gate array. The medium may be a non-volatile storage medium, such as a disk or optical drive, a programmable gate array, a compact flash memory, or other flash memory. In addition, or alternatively, the medium may be a system or cache memory, or a buffer space.
[0080] The design process 900 may include hardware and software modules for processing various input data structure types including a netlist 980. Such data structure types may reside, for example, within a library element 930 and include a set of commonly used elements, circuits, and devices, including models, layouts, and symbolic representations for a given manufacturing technology (e.g., different technology nodes, 32nm, 45nm, 90nm, etc.). The data structure types may also include design specifications 940, feature data 950, verification data 960, design rules 970, and test data files 985, which may include input test patterns, output test results, and other test information. The design process 900 may also include, for example, standard mechanical design processes, such as stress analysis, thermal analysis, mechanical event simulation, process simulation for operations such as casting, molding, and compression molding, etc. The design process 900 may also include modules for performing standard circuit design processes, such as timing analysis, verification, design rule checking, layout and routing operations, etc.
[0081] Design process 900 employs and combines logical and physical design tools, such as HDL compilers and simulation model building tools, to process design structure 920 and some or all of the supporting data structures depicted along with any additional mechanical design or data, if applicable, to generate a second design structure 990. Design structure 990 resides on a storage medium or programmable gate array in a data format for data exchange of mechanical devices and structures (e.g., information stored in IGES, DXF, Parastoll XT, JT, DRG, or any other suitable format for storing or presenting such mechanical design structures). Similar to design structure 920, design structure 990 preferably includes one or more files, data structures, or other computer-encoded data or instructions that reside on a transmission or data storage medium and, when processed by the ECAD system, generate a form of the design that is logically or otherwise functionally equivalent. Figures 1 to 3 One or more embodiments of the invention are shown in FIG.
[0082] Design structure 990 may also be in a data format for exchanging layout data of integrated circuits and / or a symbol data format (e.g., information stored in GDSII (GDS2), GL1, OASIS, a map file, or any other suitable format for storing such a design data structure). Design structure 990 may include information such as symbol data, drawing files, test data files, design content files, manufacturing data, layout parameters, wiring, metal layers, vias, shapes, data for routing through a production line, and information for a manufacturer or other designer / developer to produce the integrated circuits as described above and as described above. Figures 1 to 3 Any other data required for the device or structure shown, design structure 990 can then proceed to stage 995, where, for example, design structure 990 is: taped out, shipped to manufacturing, shipped to a mask shop, sent to another design house, sent back to a customer, etc.
[0083] As described above, in at least one embodiment, the cache memory includes a data array, a directory of contents of the data array specifying consistency state information, and snoop logic that handles operations snooped from a system structure by referring to the data array and the directory. The snoop logic responds to a request to snoop an FC memory access operation of one processor core of a specified target address among multiple processor cores on the system structure, services the request, and thereafter enters a referee mode. When in referee mode, the snoop logic protects a memory block identified by the target address from conflicting memory access requests of multiple processor cores so that a memory controller of the system memory selects the request for processing.
[0084] While various embodiments have been specifically shown and described, those skilled in the art will understand that various changes in form and details may be made therein without departing from the scope of the appended claims, and all such alternative implementations are within the scope of the appended claims.
[0085] Flowchart and block diagram in the accompanying drawings show the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present invention.In this regard, each frame in flow chart or block diagram can represent the module, segment or part of instruction, and it comprises one or more executable instructions for realizing the logical function of appointment.In some alternative embodiments, the function mentioned in the frame may not occur in the order mentioned in the figure.For example, two frames shown continuously can actually be performed substantially concurrently, or these frames can sometimes be performed in reverse order, depending on the function involved.It will also be noted that the combination of the frame in each frame of block diagram and / or flow chart illustration and block diagram and / or flow chart illustration can be realized by the dedicated hardware-based system of performing a specified function or action or performing a combination of special hardware and computer instruction.
[0086] Although various aspects have been described with respect to a computer system executing program code directing the functions of the present invention, it should be understood that the present invention may alternatively be implemented as a program product including a computer-readable storage device storing program code that can be processed by a processor of a data processing system to cause the data processing system to perform the described functions. The computer-readable storage device may include volatile or non-volatile memory, optical or magnetic disks, etc., but excludes non-statutory subject matter such as propagating signals themselves, transmission media themselves, and energy forms themselves.
[0087] As an example, a program product may include data and / or instructions that, when executed or otherwise processed on a data processing system, generate a logically, structurally, or otherwise functionally equivalent representation (including a simulation model) of a hardware component, circuit, device, or system disclosed herein. Such data and / or instructions may include hardware description language (HDL) design entities or other data structures that conform to and / or are compatible with low-level HDL design languages such as Verilog and VHDL and / or high-level design languages such as C or C++. In addition, the data and / or instructions may also be in a data format and / or symbolic data format for exchanging layout data of integrated circuits (e.g., information stored in GDSII (GDS2), GL1, OASIS, a mapping file, or any other suitable format for storing such design data structures).
Claims
1. A cache memory of an associated processor core among a plurality of processor cores in a multiprocessor data processing system, the multiprocessor data processing system comprising a system structure, the system structure communicatively coupling the cache memory and a memory controller of the system memory to receive operations on the system structure, the cache memory comprising: Data array; a directory of contents of the data array, wherein the directory includes consistency state information; as well as Snoop logic, the snoop logic snoops operations from the system structure by referencing the data array and the directory process, wherein the snoop logic responds to a request to snoop on the system structure to flush or clean memory access operations of one of the multiple processor cores to a specified target address, services the request and thereafter enters an arbitration mode, wherein the snoop logic, when in the arbitration mode, protects a memory block identified by the target address from conflicting memory access requests from the multiple processor cores such that other consistency participants are not allowed to assume consistency ownership of the memory block.
2. The cache memory according to claim 1, wherein: The request for the flush or clean operation is the first request; and The snoop logic is configured to enter the arbitration mode based on snooping a conflicting second request after snooping the first request and before the snoop logic completes processing of the first request. 3 . The cache memory of claim 1 , wherein the snoop logic is configured to protect the memory block from conflicting memory access requests by issuing a retry coherence response to the conflicting memory access requests.
4. The cache memory according to claim 1, wherein: When in the referee mode, the snoop logic is configured to provide a first coherent response to conflicting flush or clean requests and to provide a different second coherent response to other types of conflicting requests.
5. The cache memory of claim 1, wherein the snoop logic detects a timeout condition while in the referee mode and exits the referee mode in response to detecting the timeout condition.
6. The cache memory of claim 1, wherein the snoop logic exits the arbitration mode in response to a snoop termination request on the system architecture while in the arbitration mode.
7. The cache memory of claim 1, wherein the cache memory enters the arbitration mode based solely on coherence state information in the directory, the coherence state information indicating coherence ownership of the modified cache line associated with the target address.
8. A processing unit, comprising: A cache memory according to any one of the preceding claims; as well as At least one satellite processor core is coupled to the cache memory.
9. A data processing system comprising: System structure; as well as The plurality of processing units of claim 8, all coupled to a system architecture.
10. A method of data processing in a multi-processor data processing system, the multi-processor data processing system comprising a cache memory of an associated processor core among a plurality of processor cores in the multi-processor data processing system, the multi-processor data processing system comprising a system structure, the system structure communicatively coupling the cache memory and a memory controller of the system memory to receive an operation on the system structure, the method comprising: The cache memory snoops a request for a flush or clean memory access operation of a processor core of a plurality of processor cores at a specified target address on a system structure; Based on snooping the request, the cache memory services the request and thereafter enters a referee mode; as well as When in arbitration mode, the cache memory protects a memory block identified by a target address from conflicting memory access requests by multiple processor cores such that other coherence participants are not allowed to assume coherence ownership of the memory block.
11. The method according to claim 10, wherein: The request for the flush or clean operation is the first request; and Entering the arbitration mode includes entering the arbitration mode based on snooping a conflicting second request after snooping the first request and before the snoop logic completes processing of the first request.
12. The method of claim 10, wherein the protecting comprises the cache memory protecting the memory block from conflicting memory access requests by issuing a retry coherence response to the conflicting memory access requests.
13. The method of claim 10, wherein the protecting comprises the cache memory providing a first coherent response to conflicting flush or clean requests when in arbitration mode, and providing a different second coherent response to other types of conflicting requests.
14. The method of claim 10, further comprising, while in the referee mode, the cache memory detecting a timeout condition, and exiting the referee mode in response to detecting the timeout condition.
15. The method of claim 10, further comprising the cache memory exiting the arbitration mode in response to snooping a termination request on the system architecture while in the arbitration mode.
16. The method of claim 10, wherein entering the umpire mode comprises the cache memory entering the umpire mode based solely on coherence state information in the directory, the coherence state information indicating coherence ownership of the modified cache line associated with the target address.
17. A design structure tangibly embodied in a machine-readable storage device for use in designing, manufacturing, or testing an integrated circuit, the design structure comprising: Processing unit, comprising: Processor core; Cache memory, including: Data array; a directory of contents of the data array, wherein the directory includes coherence state information; and Snoop logic, the snoop logic snooping operations from a system fabric of a multiprocessor data processing system by referencing a data array and a directory process, wherein the snoop logic responds to a request to snoop on the system fabric to flush or clean memory access operations of one of the plurality of processor cores to a specified target address, services the request and thereafter enters an arbitration mode, wherein the snoop logic, while in the arbitration mode, protects a memory block identified by the target address from conflicting memory access requests of the plurality of processor cores such that a memory controller of the system memory selects the request for processing.
18. The design structure according to claim 17, wherein: The request for the flush or clean operation is the first request; and The snoop logic is configured to enter the arbitration mode based on snooping a conflicting second request after snooping the first request and before the snoop logic completes processing of the first request.
19. The design structure of claim 17, wherein the snoop logic is configured to protect the memory block from conflicting memory access requests by issuing a retry coherency response to the conflicting memory access requests.
20. The design structure of claim 17, wherein: When in the referee mode, the snoop logic is configured to provide a first coherent response to conflicting flush or clean requests and to provide a different second coherent response to other types of conflicting requests.
