US20060106993A1 - Mechanism for handling explicit writeback in a cache coherent multi-node architecture - Google Patents

Mechanism for handling explicit writeback in a cache coherent multi-node architecture Download PDF

Info

Publication number
US20060106993A1
US20060106993A1 US11/321,632 US32163205A US2006106993A1 US 20060106993 A1 US20060106993 A1 US 20060106993A1 US 32163205 A US32163205 A US 32163205A US 2006106993 A1 US2006106993 A1 US 2006106993A1
Authority
US
United States
Prior art keywords
request buffer
requests
read
outgoing
request
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US11/321,632
Inventor
Manoj Khare
Lily Looi
Akhilesh Kumar
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Individual
Original Assignee
Individual
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Individual filed Critical Individual
Priority to US11/321,632 priority Critical patent/US20060106993A1/en
Publication of US20060106993A1 publication Critical patent/US20060106993A1/en
Abandoned legal-status Critical Current

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02Addressing or allocation; Relocation
    • G06F12/08Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0806Multiuser, multiprocessor or multiprocessing cache systems
    • G06F12/0815Cache consistency protocols
    • G06F12/0831Cache consistency protocols using a bus scheme, e.g. with bus monitoring or watching means
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02Addressing or allocation; Relocation
    • G06F12/08Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0806Multiuser, multiprocessor or multiprocessing cache systems
    • G06F12/0815Cache consistency protocols
    • G06F12/0817Cache consistency protocols using directory methods
    • G06F12/0828Cache consistency protocols using directory methods with concurrent directory accessing, i.e. handling multiple concurrent coherency transactions
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02Addressing or allocation; Relocation
    • G06F12/08Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0804Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches with main memory updating

Definitions

  • the invention relates to communications between integrated circuits and more specifically to data transfer and coherency in a multi-node or multi-processor system.
  • processors and caches have existed since shortly after the advent of the computer. However, the move to using multiple processors has posed new challenges. Previously, data existed in one place (memory for example) and might be copied into one other place (a cache for example). Keeping data coherent between the two possible locations for the data was a relatively simple problem. Utilizing multiple processors, multiple caches may exist, and each may have a copy of a piece of data. Alternatively, a single processor may have a copy of a piece of data which it needs to use exclusively.
  • a first processor with exclusive use of a piece of data may modify that data, and subsequently a second processor may request a copy of the piece of data from memory.
  • a second processor may request a copy of the piece of data from memory.
  • stale data may be read from memory, or corrupted data may be read from the write.
  • the stale data results when the write should have completed before the read completed (but did not), thus allowing the read instruction to cause retrieval of the updated data.
  • the corrupted data may result when the read retrieval of the updated data.
  • the corrupted data may result when the read should have completed before the write completed (but did not), thus allowing the read instruction to cause retrieval of the data prior to the update.
  • FIG. 1 illustrates a block diagram of an embodiment of a system having multiple processors.
  • FIG. 2 illustrates a block diagram of an alternate embodiment of a system having multiple processors.
  • FIG. 3 illustrates a block diagram of an embodiment of an I/O (input/output) subsystem.
  • FIG. 4 illustrates a block diagram of an embodiment of a scalability port.
  • FIG. 5 illustrates a flow diagram of an embodiment of a read-write conflict.
  • FIG. 6A illustrates a flow diagram of an embodiment of a process of handling a read-write conflict.
  • FIG. 6B illustrates a flow diagram of an embodiment of a process of handling a read-write conflict.
  • FIG. 7 illustrates a flow diagram of an embodiment of a process including a read-write conflict.
  • FIG. 8A illustrates a flow diagram of an embodiment of a process suitable for resolving a read-write conflict.
  • FIG. 8B illustrates a flow diagram of an alternate embodiment of a process suitable for resolving a read-write conflict.
  • FIG. 9 illustrates a block diagram of an embodiment of a processor having portions of a scalability port integrated therein.
  • FIG. 10 illustrates a block diagram of an alternate embodiment of a processor having portions of a scalability port integrated therein.
  • a coherent data architecture should reduce conflicts between nodes within the architecture which need to read and write data at about the same time.
  • processor (or node) A may be reading a first data line for purposes of a calculation at the same time the processor B may be writing the first data line.
  • these conflicts will resolve themselves, but attempting to let the conflicts resolve themselves randomly might lead to a non-deterministic system. Therefore, it is preferable to resolve read-write conflicts such as these in a manner which is predictable.
  • Read-write conflicts may be resolved by sending reads and writes through some sort of controller or port, such as a scalability port. Within the port, addresses of reads and writes may be compared, such that conflicts may be detected. When a conflict is detected, a decision may be made as to whether to stall the read or the write. Such a decision may be made based on a variety of factors, depending on the design of the system, and may consider such things as when the requests were received by the port, the priority of the requests, the nature of the requests, and other considerations. Once a decision is made, one of the conflicting operations will complete, and then the other will complete. Since the decision making will be hardwired, any given situation will have a predictable result, and users of the system (such as system designers and programmers) may adapt their use to the predictable result.
  • FIG. 1 illustrates a block diagram of an embodiment of a system having multiple processors.
  • a first processor 110 and a second processor 120 are coupled to a node controller 130 , and the first processor 110 may be coupled directly to the second processor 120 as well.
  • Memory 150 is also coupled to node controller 130 .
  • scalability ports 135 are used to couple node controller 130 to I/O (input/output) hub 140 , which in turn may be coupled to various I/O devices (not shown). In such an embodiment, the scalability ports 135 may be used to control accesses to secondary and higher level storage devices, as well as maintain cache coherency within the system.
  • each of the processor 110 , processor 120 and node controller 130 have an associated onboard cache.
  • Processors typically have caches incorporated within or associated with them, such that a processor may be viewed as including a cache. In multi-processor systems, it is not uncommon to have caches associated with each processor which maintain data lines in one of four states, those states being exclusive, shared, modified, or invalid. Exclusive state is for data lines in use by that processor and locked or otherwise allowed for use by that processor only within the system. Shared state is for data lines which are in use by the processor but may be used by other processors. Modified state is for data lines in use by the processor which have a data value the processor has modified from its original value. Invalid state is for data lines which have been invalidated within the cache. Invalidation may occur when a processor writes a line to memory or when another processor takes a shared line for exclusive use, thus calling into question the validity of the data in the copy of the line the first processor has.
  • FIG. 2 illustrates a block diagram of an alternate embodiment of a system having multiple processors.
  • a first processor 210 and a second processor 220 are coupled to a first node controller 230 .
  • Also coupled to the first node controller 230 is a first memory 250 .
  • a third processor 210 and a fourth processor 220 are coupled to a second node controller 230 .
  • Also coupled to the second node controller 230 is a second memory 250 .
  • a first and second scalability port switch and snoop filter 260 are coupled separately to the first node controller 230 and the second node controller 230 .
  • a first and second scalability port switch and snoop filter 260 are coupled to each of the first and second scalability port switches 260 .
  • coupled to each of the first and second scalability port switches 260 are a first and second I/O hub 240 .
  • FIG. 3 illustrates a block diagram of an embodiment of an I/O (input/output) subsystem.
  • I/O hub 310 is coupled to a PCI bus 320 which in turn is coupled to a PCI device or devices 330 .
  • I/O hub 310 is also coupled to an AGP (accelerated graphics port) 340 , which in turn is coupled to an AGP device or devices 350 .
  • AGP accelerated graphics port
  • FIG. 4 illustrates a block diagram of an embodiment of a scalability port.
  • the scalability port includes a first and second node controller 405 and a switch and snoop filter 450 .
  • Each node controller 405 includes a memory control block 410 , a bus logic block 415 , an IRB (incoming request buffer) block 420 and an ORB (outgoing request buffer) block 425 , each of which is coupled to the three other components.
  • the node controller 405 includes a port 430 which is coupled to the IRB 420 and the ORB 425 .
  • the memory control block 410 may be coupled to a memory for interfacing therewith and the bus logic block 415 may be coupled to a first and second processor for interfacing therewith for example.
  • the switch 450 includes a first and second port 455 , each of which are coupled to a switch 460 , and a snoop pending table and snoop filter block 465 .
  • incoming requests and outgoing requests are generated and responded to by devices outside the scalability port.
  • Each request is routed through the appropriate node controller 405 , such that incoming requests (to the port 430 ) are placed in the IRB 420 and outgoing requests (to the port 430 ) are placed in the ORB 425 .
  • each port 455 receives incoming and outgoing requests which are routed through the switch 460 .
  • These requests may be targeted at another node coupled to the switch 450 , or may be targeted at a node coupled to another switch 450 , in which case the request may either be routed to the appropriate node or ignored respectively. Determining whether the target of the request is coupled to the switch 450 is the function of the snoop filter and table 465 , which may be expected to maintain information on what data (by address for example) is being utilized by the nodes coupled to the switch 450 .
  • the scalability port may be utilized to minimize the problem of read-write conflicts, as described below.
  • reads and writes focuses on reading and writing lines, which typically refer to lines of data such as those stored in a cache (either onboard or associated with a processor for example). It will be appreciated that lines of data may refer to various amounts of data, depending on how a system is implemented to transfer data.
  • FIG. 5 illustrates a flow diagram of an embodiment of a read-write conflict.
  • a first line is read by a first node, while at block 520 , at about the same time, the first line is written by a second node.
  • speculative reads of the first line occur.
  • the write of the first line completes, while at block 550 , at about the same time, the read of the first line completes.
  • FIG. 6A illustrates a flow diagram of an embodiment of a process of handling a read-write conflict.
  • a read operation on a first line is commenced by a first node.
  • a write operation on the first line is commenced by a second node, at about the same time that the read operation is commenced.
  • the conflict between the read and write is detected, such as by comparing the addresses of the read and write requests for example.
  • the write is allowed to complete, and the read is delayed so that it will receive or use the data which is written.
  • the read operation is allowed to complete, using the data written to the first line by the write operation.
  • FIG. 6B illustrates a flow diagram of an embodiment of a process of handling a read-write conflict.
  • a read operation on a first line is commenced by a first node.
  • a write operation on the first line is commenced by a second node, at about the same time that the read operation is commenced.
  • the conflict between the read and write is detected, such as by comparing the addresses of the read and write requests for example.
  • the write operation is stalled.
  • the read operation is completed, with the read operation receiving the data to be written from the write operation.
  • the written data is invalidated at the second node.
  • the read operation completes the write operation without the involvement of the second node, such as through the scalability port.
  • the read operation need not complete the write operation, because in some situations the first node will eventually have to write the data it has read, and that will effectively complete the write operation. As will be appreciated, this has the potential to save some of the effort of writing the data back twice, once for the write operation from the second node and once for the write operation the first node will eventually complete with the data it reads.
  • a particular protocol is implemented including the method or by the apparatus in question.
  • the coherent requests supported on the scalability port are listed in the following table. The table lists all the requests that are used by the coherence protocol, and those requests are then discussed in the following text. In the discussion in this section, a line indicates the length of a coherence unit.
  • the Port Read Line (PRLC, PRLD and PRC) requests are used to read a cache line. They are used to both read form from memory and snoop the cache line in the caching agent(s) at the target node.
  • the Port Read requests are always targeted to the coherence controller or the home node of a memory block. A node that is not the home if the block addressed by the transaction never receives a Port Read request.
  • the code and data read and read current requests are different to facilitate different cache state transitions.
  • the Port Read Current (PRC) request is used to fetch the most current copy of a cache line without changing the ownership of the cache line from the caching agent (typically used by an I/O node).
  • the Port Read and Invalidate Line (PRIL and PRILO) requests are used to fetch an exclusive copy of a memory block. They are used to both read from memory and snoop invalidate a cache line in the caching agent(s) at the node.
  • the Port Read and Invalidate requests are always targeted to the coherence controller or the home node of a memory block. A node that is not home of the block addressed by the transactions never receives these requests.
  • the data is supplied to the requesting node and the home memory is updated, whereas for a PRILO request, the data is supplied only to the source node, the home memory is not updated (the requesting node must cache the line in “M” state for PRILO).
  • the Port Invalidate Line (PIL) request is a special case of the PRIL request with zero length. This request is used by the requesting node to obtain exclusive ownership of a memory block already cached at the requesting node (for example when writing to a cache line in Shared state). Data can never be returned as a response to a PIL request on the scalability port. Due to concurrent invalidation requests, if the line is found modified at a remote caching node, then this condition must be detected either by the requesting node controller or the coherence controller and the PIL request must be converted to a PRIL request. The PIL request is always targeted to the coherence controller or the home node of the requested memory block. A node that is not home of the block addressed by the transaction never receives this request.
  • the Port Flush Cache Line (PFCL) request is a special case of the PIL request used to flush a memory block from all the caching agents in the system and update the home memory if the block is modified at a caching agent.
  • the final state of all the nodes, including the requesting node, is Invalid and home memory has the latest data.
  • This request is used to support the IA64 flush cache instruction. This request is always targeted to the coherence controller or the home node of the memory block. A node that is not home of the block addressed by the transaction never receives this request.
  • the Port Invalidate Line No Data (PILND) request is used by the requesting node to obtain exclusive ownership of a memory block without requesting data.
  • the memory block may or may not be present at the requesting node.
  • the memory block is invalidated in all other nodes in the system. If the line is modified at a remote caching node, then the home memory is updated but data is not returned to the requesting node.
  • This request is intended to be used for efficient handling of full line writes which the requesting node does not intend to keep in its cache (for example I/O DMA writes). This request is always targeted to the coherence controller of the home node of the requested memory block. A node that is not home of the block addressed by the transaction never receives this request.
  • the Port Memory Write (PMWI_D, PMWE_D, PMWS_D) requests with Data are used to update the content of home memory and the state of the line in the coherence controller.
  • Corresponding Port Memory Write (PMWI, PMWE, PMWS) requests without data are used to update the state of the line in the coherence controller.
  • a PMW[IIE/S] request with or without data does not snoop the caching agent(s) at the node. These requests are very similar in nature except for the state of the line at the originating node.
  • the PMWI request indicates that the memory block is no longer cached at the originating node
  • the PMWS request indicates that the line is in a shared state at the originating node
  • the PMWE request indicates that the line is in exclusive state at the originating node.
  • the PMW[I/E/S] requests are always targeted to the coherence controller or the home node of the memory block.
  • PCLR Port Cache Line Replacement
  • PCLRC Port Cache Line Replacement
  • the protocol supports two versions of this request to facilitate implementation optimization depending on the type of network implemented.
  • the PCLR request does not expect any response back from the receiving agent and the requesting agent can stop tracking this request in its outbound queue as soon as it is sent on the scalability port.
  • the PCLRC request expects a completion response back from the receiving agent and is tracked in the requesting agent till this response is received.
  • Implementation should use the PCLRC request if it cannot guarantee sequential ordering between requests from the requesting node to the coherence controller over the network in order to properly handle race conditions between this request and subsequent reads to the same line. If the implementation can guarantee sequential ordering between requests over the network between two nodes, it can use the PCLR request to save network bandwidth (no completion response) and for reduced buffer requirements in the outbound queue at the requesting node.
  • the Port Snoop (PSLC, PSLD and PSC) requests are used to initiate a snoop request at a caching node.
  • the snoops caused by the code or data snoop request and the read current request are different to facilitate different cache state transitions.
  • the Port Snoop requests could be targeted to any caching node. These requests do not have any effect on the home memory blocks, they only affect the state of a memory block in the caching agents at the target node.
  • the Port Snoop (PSLC, PSLD and PSC) requests are used to initiate a snoop request at a caching node.
  • the snoops caused by the code or data snoop request and the read current request are different to facilitate different cache state transitions.
  • the Port Snoop requests could be targeted to any caching node. These requests do not have any effect on the home memory blocks, they only affect the state of a memory block in the caching agents at the target node.
  • PSIL Port Snoop and Invalidate
  • PSILO PSILO
  • PSILND Port Snoop and Invalidate
  • the Port Snoop Flush Cache Line (PSFCL) request is used to flush a memory block from all the caching agents and update the home memory if the block is modified at a caching agent. This request is used to support the IA64 flush cache instruction and to facilitate backward invalidates due to snoop filter evictions at the coherence controller.
  • the PSFCL request could be targeted to any caching node.
  • the Port Memory Read (PMR) and Port Memory Read Speculative (PMRS) requests are used to read a home memory block. These requests are used to read memory and do not cause a snoop of caching agent(s) at the home node. They are always targeted to the home node of a memory block.
  • the PMRS request is a speculative request whereas PMR is a non-speculative request.
  • the Port Memory Read Speculative Cancel (PMRSX) request is used to cancel a speculative read request (PMRS) to a cache line.
  • a PMRS request depends on a non-speculative request for the same cache line for confirmation.
  • the confirmation request may or may not be due to the same transaction that caused the PMRS request.
  • the PMRS request is cancelled by a PMW[I/E/S] or a PMRSX request for the same cache line.
  • the cancellation request may or may not be due to the same transaction that caused the PMRS request.
  • the PMRS request can be dropped by the responding agent without any functional issue.
  • PCMP Port Completion Response PRETRY Port Retry Response PDATA Port Normal Data Response PSNR[I/S/M/MS]_CMP Combined response for PSNR[I/S/M/MS] + PCMP PSNR[I/S/M/MS]_D Combined response for PSNR[I/S/M/MS] + PDATA PCMP_D Combined response for PCMP + PDATA PSNR[I/S/M/MS]_CMP_D Combined response for PSNR[I/S/M/MS] + PCMP + PDATA
  • PSNR response is used to convey the result of snoop back to the requesting node.
  • PSNR response indicates if the line was found in Modified state and the final state of the line at the snooped agent.
  • the state of the line could be Invalid (except for PRC or PSC) at the snooped caching agent(s) (PSNRI), Shared (except for PRC or PSC) at the snooped caching agent(s) (PSNRS), Modified transitioning to Invalid (except for PRC or PSC) at the snooped caching agent (PSNRM) or Modified transitioning to Shared at the snooped caching agent (PSNRMS).
  • the cache line state at node is E, S, or I then either a PSNRI or PSNRS response is allowed; if the cache line state is M then either a PSNRM of PSNRMS response if allowed.
  • PCMP Port Completion
  • the Port Retry (PRETRY) response is the protocol level retry response.
  • the corresponding request is retried from the requesting node. This response is used to resolve conflict cases associated with multiple transactions to the same memory block.
  • the requesting agent receives the PRETRY response to a PMWx request, it retries the PMWx request if no conflict has been detected. If the requesting agent has already seen the conflict before it receives the PRETRY response, the PMWx request is converted into a response to the incoming request.
  • the Port Normal Data (PDATA) response is used to return the data requested by the corresponding read request. It does not have any other protocol level state information apart from the source node identifier and the transaction identifier of the request to associate it with the proper request.
  • the protocol also supports certain combined responses which could be used by the responding node to optimize use of bandwidth on SP.
  • the PSNR[I/S/M/MS]_CMP response is same as PSNR[I/S/M/MS]+PCMP
  • the PSNR[I/S/M/MS]D response is same as PSNR[I/S/M/MS]+PDATA
  • the PCMP_D response is same as PCMP+PDATA
  • the PSNR[I/S/M/MS]_CMP_D response is same as PSNR[I/S/MS]+PCMP+PDATA.
  • FIG. 7 illustrates a flow diagram or timing diagram 700 of an embodiment of a process including a read-write conflict.
  • Node A initiates a PRL (read operation) and at about the same time, Node B initiates a PMWI (write operation).
  • the write operation in question will invalidate the line in the Node B cache.
  • the read operation does a PMRS (speculative read) to the home node and a PSL (snoop line) to check status of the line in the Node B cache.
  • the resulting PSNRI indicates that the line in the Node B cache is invalid (due to the PMWI) and the PMR reads the unwritten line from the Home Node.
  • the PDATA completes the read by sending the data back to Node A.
  • the PMWI from the SPS to the Home Node writes the data and the PCMP signals that the write completed successfully, ignoring the incorrect data sent to Node A.
  • FIG. 8A illustrates a flow diagram or timing diagram 800 of an embodiment of a process suitable for resolving a read-write conflict.
  • the PRL from Node A initiates the read operation and the PMWI from Node B initiates the write operation at about the same time, with the SPS (scalability port) receiving the PRL first.
  • the PMRS and PSL are set up to trigger the SPS to detect any conflict, and the PMWI is sent back to Node B with a PRETRY, causing the PSL to meet the returning PRETRY and read the data which is about to be written to the Home Node of the line.
  • the read operation completes with the PSNRM_D completion, and the write is completed as a result of the read operation with the PMWI operation, resulting in completion with the PCMP completions.
  • FIG. 8B illustrates a flow diagram or timing diagram 850 of an alternate embodiment of a process suitable for resolving a read-write conflict.
  • a PMWI (write operation) and PRL (read operation) are initiated, with the SPS receiving the PMWI first.
  • the PMWI proceeds to the Home Node, and the write completes with the PCMP operations.
  • the read operation is retried with the PRETRY and subsequent PRL operations, leading to the PSNRI (snoop invalidate), PMRS (speculative read) and PMR (read) operations, of which the PMR operation results in a PDATA completion with the newly written data.
  • the determining factor in whether to complete the read or write first is which operation occurs at the SPS first.
  • FIG. 9 illustrates a block diagram of an embodiment of a processor having portions of a scalability port integrated therein. Such an embodiment need not implement the protocol addressed in the previous section.
  • processor 900 includes scalability port node controller 910 and scalability port switch 920 .
  • Scalability port node controller 910 is suitable for coupling to a memory such as memory 930 .
  • Scalability port switch 920 is suitable for coupling to an I/O hub or interface such as I/O hub 940 .
  • Scalability port node controller 910 and scalability port switch 920 may collectively include an incoming request buffer, outgoing request buffer, memory control logic, snoop pending table and snoop filter.
  • scalability port node controller 910 includes an incoming request buffer, outgoing request buffer and memory control logic suitable for interfacing with memory 930 .
  • scalability port switch 920 may also include a snoop pending table, snoop filter and i/o interface logic suitable for interfacing with I/O hub 940 .
  • scalability port switch 920 may couple to the incoming request buffer and outgoing request buffer of scalability port node controller 910 , and include i/o interface logic suitable for coupling to the I/O hub 940 .
  • FIG. 10 illustrates a block diagram of an alternate embodiment of a processor having portions of a scalability port integrated therein.
  • each instance of processor 1000 includes a scalability port node controller 1010 and scalability port switch 1020 .
  • Scalability port switch 1020 is part of scalability port node controller 1010 , and collectively the two components ( 1010 , 1020 ) include an incoming request buffer, outgoing request buffer, and control logic.
  • Scalability port switch 1020 includes a snoop pending table, snoop filter, and i/o interface logic suitable for coupling to an I/O hub or other i/o device, such as I/O hub 1040 .
  • Scalability port node controller 1010 includes memory control logic suitable for interfacing with memory 1030 . Note that memory 1030 may be separate for each processor 1000 or shared between two (or more) processors 1000 .
  • 6A or 7 represent portions of a method which, in some embodiments, may be reordered or may be organized in parallel rather than in a linear or step-wise fashion.
  • the present specification and figures are accordingly to be regarded as illustrative rather than restrictive.

Abstract

A method and apparatus for a mechanism for handling explicit writeback in a cache coherent multi-node architecture is described. In one embodiment, the invention is a method. The method includes receiving a read request relating to a first line of data in a coherent memory system. The method further includes receiving a write request relating to the first line of data at about the same time as the read request is received. The method further includes detecting that the read request and the write request both relate to the first line. The method also includes determining which request of the read and write request should proceed first. Additionally, the method includes completing the request of the read and write request which should proceed first.

Description

    RELATED APPLICATIONS
  • This application is a continuation of U.S. application Ser. No. 10/896,151 filed on Jul. 20, 2004, which is a continuation of U.S. application Ser. No. 09/823,791, filed on Mar. 31, 2001, entitled “Mechanism for Handling Explicit Writeback in a Cache Coherent Multi-Node Architecture.”
  • BACKGROUND OF THE INVENTION
  • 1. Field of the Invention
  • The invention relates to communications between integrated circuits and more specifically to data transfer and coherency in a multi-node or multi-processor system.
  • 2. Description of the Related Art
  • Processors and caches have existed since shortly after the advent of the computer. However, the move to using multiple processors has posed new challenges. Previously, data existed in one place (memory for example) and might be copied into one other place (a cache for example). Keeping data coherent between the two possible locations for the data was a relatively simple problem. Utilizing multiple processors, multiple caches may exist, and each may have a copy of a piece of data. Alternatively, a single processor may have a copy of a piece of data which it needs to use exclusively.
  • If two copies of the data exist, or one copy exists aside from the original, some potential for a conflict in data exists in a multi-processor system. For example, a first processor with exclusive use of a piece of data may modify that data, and subsequently a second processor may request a copy of the piece of data from memory. If the first processor is about to write the piece of data back to memory when the second processor requests the piece of data, stale data may be read from memory, or corrupted data may be read from the write. The stale data results when the write should have completed before the read completed (but did not), thus allowing the read instruction to cause retrieval of the updated data. The corrupted data may result when the read retrieval of the updated data. The corrupted data may result when the read should have completed before the write completed (but did not), thus allowing the read instruction to cause retrieval of the data prior to the update.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • The present invention is illustrated by way of example and not limitation in the accompanying figures.
  • FIG. 1 illustrates a block diagram of an embodiment of a system having multiple processors.
  • FIG. 2 illustrates a block diagram of an alternate embodiment of a system having multiple processors.
  • FIG. 3 illustrates a block diagram of an embodiment of an I/O (input/output) subsystem.
  • FIG. 4 illustrates a block diagram of an embodiment of a scalability port.
  • FIG. 5 illustrates a flow diagram of an embodiment of a read-write conflict.
  • FIG. 6A illustrates a flow diagram of an embodiment of a process of handling a read-write conflict.
  • FIG. 6B illustrates a flow diagram of an embodiment of a process of handling a read-write conflict.
  • FIG. 7 illustrates a flow diagram of an embodiment of a process including a read-write conflict.
  • FIG. 8A illustrates a flow diagram of an embodiment of a process suitable for resolving a read-write conflict.
  • FIG. 8B illustrates a flow diagram of an alternate embodiment of a process suitable for resolving a read-write conflict.
  • FIG. 9 illustrates a block diagram of an embodiment of a processor having portions of a scalability port integrated therein.
  • FIG. 10 illustrates a block diagram of an alternate embodiment of a processor having portions of a scalability port integrated therein.
  • DETAILED DESCRIPTION
  • A method and apparatus for a mechanism for handling explicit writeback in a cache coherent multi-node architecture is described. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the invention. It will be apparent, however, to one skilled in the art that the invention can be practiced without these specific details. In other instances, structures and devices are shown in block diagram form in order to avoid obscuring the invention.
  • Reference in the specification to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the invention. The appearances of the phrase “in one embodiment” in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments.
  • A coherent data architecture should reduce conflicts between nodes within the architecture which need to read and write data at about the same time. For example, processor (or node) A may be reading a first data line for purposes of a calculation at the same time the processor B may be writing the first data line. In some instances, these conflicts will resolve themselves, but attempting to let the conflicts resolve themselves randomly might lead to a non-deterministic system. Therefore, it is preferable to resolve read-write conflicts such as these in a manner which is predictable.
  • Read-write conflicts may be resolved by sending reads and writes through some sort of controller or port, such as a scalability port. Within the port, addresses of reads and writes may be compared, such that conflicts may be detected. When a conflict is detected, a decision may be made as to whether to stall the read or the write. Such a decision may be made based on a variety of factors, depending on the design of the system, and may consider such things as when the requests were received by the port, the priority of the requests, the nature of the requests, and other considerations. Once a decision is made, one of the conflicting operations will complete, and then the other will complete. Since the decision making will be hardwired, any given situation will have a predictable result, and users of the system (such as system designers and programmers) may adapt their use to the predictable result.
  • FIG. 1 illustrates a block diagram of an embodiment of a system having multiple processors. A first processor 110 and a second processor 120 are coupled to a node controller 130, and the first processor 110 may be coupled directly to the second processor 120 as well. Memory 150 is also coupled to node controller 130. Furthermore, scalability ports 135 are used to couple node controller 130 to I/O (input/output) hub 140, which in turn may be coupled to various I/O devices (not shown). In such an embodiment, the scalability ports 135 may be used to control accesses to secondary and higher level storage devices, as well as maintain cache coherency within the system. In one embodiment, each of the processor 110, processor 120 and node controller 130 have an associated onboard cache.
  • Processors typically have caches incorporated within or associated with them, such that a processor may be viewed as including a cache. In multi-processor systems, it is not uncommon to have caches associated with each processor which maintain data lines in one of four states, those states being exclusive, shared, modified, or invalid. Exclusive state is for data lines in use by that processor and locked or otherwise allowed for use by that processor only within the system. Shared state is for data lines which are in use by the processor but may be used by other processors. Modified state is for data lines in use by the processor which have a data value the processor has modified from its original value. Invalid state is for data lines which have been invalidated within the cache. Invalidation may occur when a processor writes a line to memory or when another processor takes a shared line for exclusive use, thus calling into question the validity of the data in the copy of the line the first processor has.
  • FIG. 2 illustrates a block diagram of an alternate embodiment of a system having multiple processors. A first processor 210 and a second processor 220 are coupled to a first node controller 230. Also coupled to the first node controller 230 is a first memory 250. A third processor 210 and a fourth processor 220 are coupled to a second node controller 230. Also coupled to the second node controller 230 is a second memory 250. Additionally, coupled separately to the first node controller 230 and the second node controller 230 are a first and second scalability port switch and snoop filter 260. Furthermore, coupled to each of the first and second scalability port switches 260 are a first and second I/O hub 240. In one embodiment, each of the processors 210, processors 220, node controllers 230 and I/O hubs 240 have an associated onboard cache.
  • FIG. 3 illustrates a block diagram of an embodiment of an I/O (input/output) subsystem. I/O hub 310 is coupled to a PCI bus 320 which in turn is coupled to a PCI device or devices 330. I/O hub 310 is also coupled to an AGP (accelerated graphics port) 340, which in turn is coupled to an AGP device or devices 350. It will be appreciated that numerous implementations of the PCI bus and the AGP exist, any of which may work with various I/O hubs such as I/O hub 310.
  • FIG. 4 illustrates a block diagram of an embodiment of a scalability port. The scalability port, in one embodiment, includes a first and second node controller 405 and a switch and snoop filter 450. Each node controller 405 includes a memory control block 410, a bus logic block 415, an IRB (incoming request buffer) block 420 and an ORB (outgoing request buffer) block 425, each of which is coupled to the three other components. Furthermore, the node controller 405 includes a port 430 which is coupled to the IRB 420 and the ORB 425. Also, the memory control block 410 may be coupled to a memory for interfacing therewith and the bus logic block 415 may be coupled to a first and second processor for interfacing therewith for example. The switch 450 includes a first and second port 455, each of which are coupled to a switch 460, and a snoop pending table and snoop filter block 465.
  • In one embodiment, incoming requests and outgoing requests are generated and responded to by devices outside the scalability port. Each request is routed through the appropriate node controller 405, such that incoming requests (to the port 430) are placed in the IRB 420 and outgoing requests (to the port 430) are placed in the ORB 425. Additionally, within the switch 450, each port 455 receives incoming and outgoing requests which are routed through the switch 460. These requests may be targeted at another node coupled to the switch 450, or may be targeted at a node coupled to another switch 450, in which case the request may either be routed to the appropriate node or ignored respectively. Determining whether the target of the request is coupled to the switch 450 is the function of the snoop filter and table 465, which may be expected to maintain information on what data (by address for example) is being utilized by the nodes coupled to the switch 450.
  • The scalability port may be utilized to minimize the problem of read-write conflicts, as described below. Note that the discussion of reads and writes focuses on reading and writing lines, which typically refer to lines of data such as those stored in a cache (either onboard or associated with a processor for example). It will be appreciated that lines of data may refer to various amounts of data, depending on how a system is implemented to transfer data.
  • FIG. 5 illustrates a flow diagram of an embodiment of a read-write conflict. At block 510, a first line is read by a first node, while at block 520, at about the same time, the first line is written by a second node. At block 530, speculative reads of the first line occur. At block 540, the write of the first line completes, while at block 550, at about the same time, the read of the first line completes. With two disconnected processes for the read and write of the same line, it is not clear whether the read and write resulted in proper data being read or written. For example, in some situations, the data should be read before it is written, whereas in other situations, the data should be written before it is read. However, typically it is important that the read receive the most up-to-date data possible.
  • FIG. 6A illustrates a flow diagram of an embodiment of a process of handling a read-write conflict. At block 610, a read operation on a first line is commenced by a first node. At block 620, a write operation on the first line is commenced by a second node, at about the same time that the read operation is commenced. At block 630, the conflict between the read and write is detected, such as by comparing the addresses of the read and write requests for example. At block 640, the write is allowed to complete, and the read is delayed so that it will receive or use the data which is written. At block 650, once the write operation has completed, the read operation is allowed to complete, using the data written to the first line by the write operation.
  • FIG. 6B illustrates a flow diagram of an embodiment of a process of handling a read-write conflict. At block 610, a read operation on a first line is commenced by a first node. At block 620, a write operation on the first line is commenced by a second node, at about the same time that the read operation is commenced. At block 670, the conflict between the read and write is detected, such as by comparing the addresses of the read and write requests for example. At block 675, the write operation is stalled. At block 680, the read operation is completed, with the read operation receiving the data to be written from the write operation. At block 685, the written data is invalidated at the second node. At block 690, if appropriate, the read operation completes the write operation without the involvement of the second node, such as through the scalability port. Note that in some instances, the read operation need not complete the write operation, because in some situations the first node will eventually have to write the data it has read, and that will effectively complete the write operation. As will be appreciated, this has the potential to save some of the effort of writing the data back twice, once for the write operation from the second node and once for the write operation the first node will eventually complete with the data it reads.
  • It will be appreciated that a variety of methods may be used to determine which of the two processes of FIGS. 6A and 6B should be implemented. In most systems, it will be appreciated that there will be times when the process of FIG. 6A should be used and other times when the process of FIG. 6B should be used. However, the exact details for determining which process should be used will necessarily depend on implementation details. In general, it will be appreciated that such a system will determine which of the two processes to use by examining or comparing when and where the two conflicting instructions (read and write) originated and what priorities or properties are assigned to the instructions, such as exclusive or shared use of the subject data for example. Moreover, in some embodiments, an arbitration device independent of the nodes may determine whether to delay the read or write operation.
  • The embodiment described in the following section is implemented using a specific protocol. It will be appreciated that such a protocol may be implemented in a variety of ways which will be apparent to one skilled in the art. Furthermore, it will be appreciated that variations on such a protocol may be implemented within the spirit and scope of the invention.
  • Coherent Request Types
  • In some embodiments, a particular protocol is implemented including the method or by the apparatus in question. In these embodiments, the coherent requests supported on the scalability port are listed in the following table. The table lists all the requests that are used by the coherence protocol, and those requests are then discussed in the following text. In the discussion in this section, a line indicates the length of a coherence unit.
    TABLE 1
    Coherent Request Types
    Allowed
    Request Type Name Description Targets
    Read PRLC Port Read Line Code Home
    PRLD Port Read Line Data Node,
    PRC Port Read Current Coherence
    Read PRIL Port Read and Invalidate Line Con-troller
    Invalidate PRILO Port Read and Invalidate Line with
    OWN# set
    PIL Port Invalidate Line
    PFCL Port Flush Cache Line
    PILND Port Invalidate Line No Data
    Memory PMWI, Port Memory Write. I/E/S indicates
    Update PMWE, state of line at the requesting node.
    PMWS When data is sent along with
    memory updates, it is indicated with
    PMW[I/E/S]_D.
    Cache Line PCLR Port Cache Line Replacement Coherence
    Replacement (Completion not required) Controller
    PCLRC Port Cache Line Replacement,
    Completion Required
    Snoop PSLC/PSLD Port Snoop Line Code/Data Coherence
    PSC Port Snoop Current Controller,
    Snoop PSIL Port Snoop Invalidate Line Any
    Invalidate PSILO Port Snoop Invalidate Line with Caching
    OWN# set Node
    PSFCL Port Snoop Flush Cache Line
    PSILND Port Snoop Invalidate Line No Data
    Memory Read PMR Port Memory Read Home
    Request PMRS Port Memory Read Speculative Node
    PMRSX Port Memory Read Speculative
    Cancel
  • The Port Read Line (PRLC, PRLD and PRC) requests are used to read a cache line. They are used to both read form from memory and snoop the cache line in the caching agent(s) at the target node. The Port Read requests are always targeted to the coherence controller or the home node of a memory block. A node that is not the home if the block addressed by the transaction never receives a Port Read request. The code and data read and read current requests are different to facilitate different cache state transitions. The Port Read Current (PRC) request is used to fetch the most current copy of a cache line without changing the ownership of the cache line from the caching agent (typically used by an I/O node).
  • The Port Read and Invalidate Line (PRIL and PRILO) requests are used to fetch an exclusive copy of a memory block. They are used to both read from memory and snoop invalidate a cache line in the caching agent(s) at the node. The Port Read and Invalidate requests are always targeted to the coherence controller or the home node of a memory block. A node that is not home of the block addressed by the transactions never receives these requests. These two request types differ in their behavior when the memory block is found in the modified state at the snooped node. For a PRIL request, the data is supplied to the requesting node and the home memory is updated, whereas for a PRILO request, the data is supplied only to the source node, the home memory is not updated (the requesting node must cache the line in “M” state for PRILO).
  • The Port Invalidate Line (PIL) request is a special case of the PRIL request with zero length. This request is used by the requesting node to obtain exclusive ownership of a memory block already cached at the requesting node (for example when writing to a cache line in Shared state). Data can never be returned as a response to a PIL request on the scalability port. Due to concurrent invalidation requests, if the line is found modified at a remote caching node, then this condition must be detected either by the requesting node controller or the coherence controller and the PIL request must be converted to a PRIL request. The PIL request is always targeted to the coherence controller or the home node of the requested memory block. A node that is not home of the block addressed by the transaction never receives this request.
  • The Port Flush Cache Line (PFCL) request is a special case of the PIL request used to flush a memory block from all the caching agents in the system and update the home memory if the block is modified at a caching agent. The final state of all the nodes, including the requesting node, is Invalid and home memory has the latest data. This request is used to support the IA64 flush cache instruction. This request is always targeted to the coherence controller or the home node of the memory block. A node that is not home of the block addressed by the transaction never receives this request.
  • The Port Invalidate Line No Data (PILND) request is used by the requesting node to obtain exclusive ownership of a memory block without requesting data. The memory block may or may not be present at the requesting node. The memory block is invalidated in all other nodes in the system. If the line is modified at a remote caching node, then the home memory is updated but data is not returned to the requesting node. This request is intended to be used for efficient handling of full line writes which the requesting node does not intend to keep in its cache (for example I/O DMA writes). This request is always targeted to the coherence controller of the home node of the requested memory block. A node that is not home of the block addressed by the transaction never receives this request.
  • The Port Memory Write (PMWI_D, PMWE_D, PMWS_D) requests with Data are used to update the content of home memory and the state of the line in the coherence controller. Corresponding Port Memory Write (PMWI, PMWE, PMWS) requests without data are used to update the state of the line in the coherence controller. A PMW[IIE/S] request with or without data does not snoop the caching agent(s) at the node. These requests are very similar in nature except for the state of the line at the originating node. The PMWI request indicates that the memory block is no longer cached at the originating node, the PMWS request indicates that the line is in a shared state at the originating node and the PMWE request indicates that the line is in exclusive state at the originating node. The PMW[I/E/S] requests are always targeted to the coherence controller or the home node of the memory block.
  • The Port Cache Line Replacement (PCLR, PCLRC) requests are used to indicate to the coherence controller that the node no longer has a copy of the memory block in the caching agents at that node. They are intended to be used only by the originating node of the transaction. These requests are always targeted to the coherence controller to facilitate better tracking of the cache state by the coherence controller. A node can generate a PCLR or PCLRC request only when the state of the cache line at the node changes from S or E to I, generation of these requests when the cache line state at a node is I is not allowed to avoid starvation or livelock on accesses from other nodes. A PCLR or PCLRC request could be dropped or processed by the receiving agent without affecting its final state. The protocol supports two versions of this request to facilitate implementation optimization depending on the type of network implemented. The PCLR request does not expect any response back from the receiving agent and the requesting agent can stop tracking this request in its outbound queue as soon as it is sent on the scalability port. The PCLRC request expects a completion response back from the receiving agent and is tracked in the requesting agent till this response is received. Implementation should use the PCLRC request if it cannot guarantee sequential ordering between requests from the requesting node to the coherence controller over the network in order to properly handle race conditions between this request and subsequent reads to the same line. If the implementation can guarantee sequential ordering between requests over the network between two nodes, it can use the PCLR request to save network bandwidth (no completion response) and for reduced buffer requirements in the outbound queue at the requesting node.
  • The Port Snoop (PSLC, PSLD and PSC) requests are used to initiate a snoop request at a caching node. The snoops caused by the code or data snoop request and the read current request are different to facilitate different cache state transitions. The Port Snoop requests could be targeted to any caching node. These requests do not have any effect on the home memory blocks, they only affect the state of a memory block in the caching agents at the target node.
  • The Port Snoop (PSLC, PSLD and PSC) requests are used to initiate a snoop request at a caching node. The snoops caused by the code or data snoop request and the read current request are different to facilitate different cache state transitions. The Port Snoop requests could be targeted to any caching node. These requests do not have any effect on the home memory blocks, they only affect the state of a memory block in the caching agents at the target node.
  • The Port Snoop and Invalidate (PSIL, PSILO and PSILND) requests are used to snoop and invalidate a memory block at a caching node. These requests could be targeted to any caching node. These three request types differ in their behavior when the memory block is found in the modified state at the snooped node. For PSIL request, data is supplied to both the source node and the home memory is updated. For PSILO request, the data is supplied only to the source node, the home memory is not updated. For PSILND request, only the home memory is updated, the data is not supplied to the requesting node.
  • The Port Snoop Flush Cache Line (PSFCL) request is used to flush a memory block from all the caching agents and update the home memory if the block is modified at a caching agent. This request is used to support the IA64 flush cache instruction and to facilitate backward invalidates due to snoop filter evictions at the coherence controller. The PSFCL request could be targeted to any caching node.
  • The Port Memory Read (PMR) and Port Memory Read Speculative (PMRS) requests are used to read a home memory block. These requests are used to read memory and do not cause a snoop of caching agent(s) at the home node. They are always targeted to the home node of a memory block. The PMRS request is a speculative request whereas PMR is a non-speculative request. The Port Memory Read Speculative Cancel (PMRSX) request is used to cancel a speculative read request (PMRS) to a cache line. A PMRS request depends on a non-speculative request for the same cache line for confirmation. It is confirmed by a PMR, PRLC, PRLD, PRC, PRIL, or PRILO request for the same cache line. The confirmation request may or may not be due to the same transaction that caused the PMRS request. The PMRS request is cancelled by a PMW[I/E/S] or a PMRSX request for the same cache line. The cancellation request may or may not be due to the same transaction that caused the PMRS request. The PMRS request can be dropped by the responding agent without any functional issue.
  • Response Types for Coherent Requests
  • Response types for coherent request transactions on the scalability port are listed in Table 2. These responses are used under normal circumstances or could be combined with special circumstances with proper response status to indicate failed, unsupported or aborted requests.
    TABLE 2
    Responses for Coherent Requests
    Responses Description
    PSNR[I/S/M/MS] Port Snoop Result. I/S/M/MS indicates
    state of the line in remote nodes (I =
    Invalid, S = Shared, M = Modified
    transitioned to Invalid, MS = Modified
    transitioned to Shared)
    PCMP Port Completion Response
    PRETRY Port Retry Response
    PDATA Port Normal Data Response
    PSNR[I/S/M/MS]_CMP Combined response for
    PSNR[I/S/M/MS] + PCMP
    PSNR[I/S/M/MS]_D Combined response for
    PSNR[I/S/M/MS] + PDATA
    PCMP_D Combined response for PCMP +
    PDATA
    PSNR[I/S/M/MS]_CMP_D Combined response for
    PSNR[I/S/M/MS] + PCMP + PDATA
  • The Port Snoop Result (PSNR) response is used to convey the result of snoop back to the requesting node. PSNR response indicates if the line was found in Modified state and the final state of the line at the snooped agent. The state of the line could be Invalid (except for PRC or PSC) at the snooped caching agent(s) (PSNRI), Shared (except for PRC or PSC) at the snooped caching agent(s) (PSNRS), Modified transitioning to Invalid (except for PRC or PSC) at the snooped caching agent (PSNRM) or Modified transitioning to Shared at the snooped caching agent (PSNRMS). For a PRC or PSC transaction, if the cache line state at node is E, S, or I then either a PSNRI or PSNRS response is allowed; if the cache line state is M then either a PSNRM of PSNRMS response if allowed.
  • The Port Completion (PCMP) response is used in determining the completion of a transaction under certain protocol conditions. This response can be generated only by the home node of the memory block or by the coherence controller for some transactions such as PRC, PSC. PRILO and PSILO.
  • The Port Retry (PRETRY) response is the protocol level retry response. The corresponding request is retried from the requesting node. This response is used to resolve conflict cases associated with multiple transactions to the same memory block. When the requesting agent receives the PRETRY response to a PMWx request, it retries the PMWx request if no conflict has been detected. If the requesting agent has already seen the conflict before it receives the PRETRY response, the PMWx request is converted into a response to the incoming request.
  • The Port Normal Data (PDATA) response is used to return the data requested by the corresponding read request. It does not have any other protocol level state information apart from the source node identifier and the transaction identifier of the request to associate it with the proper request.
  • The protocol also supports certain combined responses which could be used by the responding node to optimize use of bandwidth on SP. The PSNR[I/S/M/MS]_CMP response is same as PSNR[I/S/M/MS]+PCMP, the PSNR[I/S/M/MS]D response is same as PSNR[I/S/M/MS]+PDATA, the PCMP_D response is same as PCMP+PDATA and the PSNR[I/S/M/MS]_CMP_D response is same as PSNR[I/S/M/MS]+PCMP+PDATA.
  • FIG. 7 illustrates a flow diagram or timing diagram 700 of an embodiment of a process including a read-write conflict. Initially, Node A initiates a PRL (read operation) and at about the same time, Node B initiates a PMWI (write operation). The write operation in question will invalidate the line in the Node B cache. However, due to the simultaneous nature of the operations, the read operation does a PMRS (speculative read) to the home node and a PSL (snoop line) to check status of the line in the Node B cache. The resulting PSNRI indicates that the line in the Node B cache is invalid (due to the PMWI) and the PMR reads the unwritten line from the Home Node. The PDATA completes the read by sending the data back to Node A. Then, the PMWI from the SPS to the Home Node writes the data and the PCMP signals that the write completed successfully, ignoring the incorrect data sent to Node A.
  • FIG. 8A illustrates a flow diagram or timing diagram 800 of an embodiment of a process suitable for resolving a read-write conflict. The PRL from Node A initiates the read operation and the PMWI from Node B initiates the write operation at about the same time, with the SPS (scalability port) receiving the PRL first. This time, the PMRS and PSL are set up to trigger the SPS to detect any conflict, and the PMWI is sent back to Node B with a PRETRY, causing the PSL to meet the returning PRETRY and read the data which is about to be written to the Home Node of the line. The read operation completes with the PSNRM_D completion, and the write is completed as a result of the read operation with the PMWI operation, resulting in completion with the PCMP completions.
  • FIG. 8B illustrates a flow diagram or timing diagram 850 of an alternate embodiment of a process suitable for resolving a read-write conflict. A PMWI (write operation) and PRL (read operation) are initiated, with the SPS receiving the PMWI first. The PMWI proceeds to the Home Node, and the write completes with the PCMP operations. In the meantime, the read operation is retried with the PRETRY and subsequent PRL operations, leading to the PSNRI (snoop invalidate), PMRS (speculative read) and PMR (read) operations, of which the PMR operation results in a PDATA completion with the newly written data. As will be appreciated, the determining factor in whether to complete the read or write first is which operation occurs at the SPS first.
  • Alternative Scalability Port Implementations
  • The following section addresses some of the alternative scalability port implementations which may be utilized within the spirit and scope of the invention. It will be appreciated that these are exemplary in nature rather than limiting. Other alternative embodiments will be apparent to those skilled in the art.
  • FIG. 9 illustrates a block diagram of an embodiment of a processor having portions of a scalability port integrated therein. Such an embodiment need not implement the protocol addressed in the previous section. In one embodiment, processor 900 includes scalability port node controller 910 and scalability port switch 920. Scalability port node controller 910 is suitable for coupling to a memory such as memory 930. Scalability port switch 920 is suitable for coupling to an I/O hub or interface such as I/O hub 940. Scalability port node controller 910 and scalability port switch 920 may collectively include an incoming request buffer, outgoing request buffer, memory control logic, snoop pending table and snoop filter. In one embodiment, scalability port node controller 910 includes an incoming request buffer, outgoing request buffer and memory control logic suitable for interfacing with memory 930. In such an embodiment, scalability port switch 920 may also include a snoop pending table, snoop filter and i/o interface logic suitable for interfacing with I/O hub 940. In such an embodiment, scalability port switch 920 may couple to the incoming request buffer and outgoing request buffer of scalability port node controller 910, and include i/o interface logic suitable for coupling to the I/O hub 940.
  • FIG. 10 illustrates a block diagram of an alternate embodiment of a processor having portions of a scalability port integrated therein. In one embodiment, each instance of processor 1000 includes a scalability port node controller 1010 and scalability port switch 1020. Scalability port switch 1020 is part of scalability port node controller 1010, and collectively the two components (1010, 1020) include an incoming request buffer, outgoing request buffer, and control logic. Scalability port switch 1020 includes a snoop pending table, snoop filter, and i/o interface logic suitable for coupling to an I/O hub or other i/o device, such as I/O hub 1040. Scalability port node controller 1010 includes memory control logic suitable for interfacing with memory 1030. Note that memory 1030 may be separate for each processor 1000 or shared between two (or more) processors 1000.
  • In the foregoing detailed description, the method and apparatus of the present invention has been described with reference to specific exemplary embodiments thereof. It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the present invention. In particular, the separate blocks of the various block diagrams represent functional blocks of methods or apparatuses and are not necessarily indicative of physical or logical separations or of an order of operation inherent in the spirit and scope of the present invention. For example, the various blocks of FIGS. 1 or 2 (among others) may be integrated into components, or may be subdivided into components. Similarly, the blocks of FIGS. 6A or 7 (among others) represent portions of a method which, in some embodiments, may be reordered or may be organized in parallel rather than in a linear or step-wise fashion. The present specification and figures are accordingly to be regarded as illustrative rather than restrictive.

Claims (13)

1. An apparatus comprising:
an incoming request buffer to store requests relating to read and write operations, the requests including addresses to be read or written, an assigned priority, and a property comprising that the operation involves data that is for exclusive use, shared use, modified use, or is invalidated;
an outgoing request buffer to store requests relating to read and write operations coupled to the incoming request buffer;
bus logic configured to interface with a bus, the bus logic coupled to the incoming request buffer and the outgoing request buffer;
a snoop pending table to contain entries related to cache lines coupled to the incoming request buffer and the outgoing request buffer;
a snoop filter coupled to the snoop pending table;
control logic to interface with and coupled to the incoming request buffer, the outgoing request buffer, and the bus logic, the control logic to compare addresses of requests of the incoming request buffer and outgoing request buffer and detect identical addresses among requests of the incoming request buffer and the outgoing request buffer, the control logic to stall a second request of the incoming request buffer and outgoing request buffer pending completion of a first request of the incoming request buffer and outgoing request buffer when the second request and the first request include identical addresses; and
an arbitration device to determine which request should proceed first based on the property of the requests.
2. The apparatus of claim 1 wherein:
the outgoing request buffer to receive read requests and write requests from a bus through the bus logic.
3. The apparatus of claim 2 wherein:
the control logic to pass requests to the outgoing request buffer and incoming request buffer to read data from or write data to a cache associated with a processor.
4. The apparatus of claim 2 further comprising:
a memory controller to interface with and control a memory, the memory controller coupled to the incoming request buffer, the outgoing request buffer, the bus logic, and the control logic; and wherein:
the control logic to pass requests to the memory controller to read data from or write data to the memory.
5. The apparatus of claim 1 wherein:
the arbitration device determines requests relating to a read operation should proceed first based on the property of the requests.
6. The apparatus of claim 1 wherein:
the arbitration device determines requests relating to a write operation should proceed first based on the property of the requests.
7. A system comprising:
a first processor;
a second processor;
a scalability port coupled through a bus to the first processor and coupled through the bus to the second processor, the scalability port including:
an incoming request buffer to store requests relating to read and write operations, the requests including addresses to be read or written, an assigned priority, and a property comprising that the operation involves data that is for exclusive use, shared use, modified use, or is invalidated;
an outgoing request buffer to store requests relating to read and write operations, the requests including addresses to be read or written, coupled to the incoming request buffer;
bus logic to interface with the bus, the bus logic coupled to the incoming request buffer and the outgoing request buffer;
a snoop pending table to contain entries related to cache lines coupled to the incoming request buffer and the outgoing request buffer;
a snoop filter coupled to the snoop pending table;
control logic to interface with and coupled to the incoming request buffer, the outgoing request buffer, and the bus logic, the control logic to compare addresses of requests of the incoming request buffer and outgoing request buffer and detect identical addresses among requests of the incoming request buffer and the outgoing request buffer, the control logic to stall a second request of the incoming request buffer and the outgoing request buffer pending completion of a first request of the incoming request buffer and the outgoing request buffer when the second request and the first request include identical addresses; and
an arbitration device to determine which request should proceed first depending on the property of the requests.
8. The system of claim 7 further comprising:
a memory coupled to the scalability port; and wherein the scalability port further includes:
a memory controller to interface with and control the memory, the memory controller coupled to the incoming request buffer, the outgoing request buffer, the bus logic, and the control logic; and wherein:
the control logic to pass requests to the memory controller to read from or write data to the memory.
9. The system of claim 7 wherein:
the outgoing request buffer and incoming request buffer to receive read requests and write requests from the bus through the bus logic, the read requests and write requests each individually originating from one of the first processor or the second processor.
10. The system of claim 7 wherein:
the control logic to pass requests to the outgoing request buffer and to the incoming request buffer to write data to or read data from a cache associated with the first processor.
11. The system of claim 10 wherein:
the control logic further to pass requests to the outgoing request buffer and to the incoming request buffer to write data to or read data from a cache associated with the second processor.
12. The system of claim 7 wherein:
the arbitration device determines requests relating to a read operation should proceed first based on the property of the requests.
13. The system of claim 7 wherein:
the arbitration device determines requests relating to a write operation should proceed first based on the property of the requests.
US11/321,632 2001-03-31 2005-12-28 Mechanism for handling explicit writeback in a cache coherent multi-node architecture Abandoned US20060106993A1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US11/321,632 US20060106993A1 (en) 2001-03-31 2005-12-28 Mechanism for handling explicit writeback in a cache coherent multi-node architecture

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
US09/823,791 US6842830B2 (en) 2001-03-31 2001-03-31 Mechanism for handling explicit writeback in a cache coherent multi-node architecture
US10/896,151 US7167957B2 (en) 2001-03-31 2004-07-20 Mechanism for handling explicit writeback in a cache coherent multi-node architecture
US11/321,632 US20060106993A1 (en) 2001-03-31 2005-12-28 Mechanism for handling explicit writeback in a cache coherent multi-node architecture

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
US10/896,151 Continuation US7167957B2 (en) 2001-03-31 2004-07-20 Mechanism for handling explicit writeback in a cache coherent multi-node architecture

Publications (1)

Publication Number Publication Date
US20060106993A1 true US20060106993A1 (en) 2006-05-18

Family

ID=25239731

Family Applications (3)

Application Number Title Priority Date Filing Date
US09/823,791 Expired - Lifetime US6842830B2 (en) 2001-03-31 2001-03-31 Mechanism for handling explicit writeback in a cache coherent multi-node architecture
US10/896,151 Expired - Lifetime US7167957B2 (en) 2001-03-31 2004-07-20 Mechanism for handling explicit writeback in a cache coherent multi-node architecture
US11/321,632 Abandoned US20060106993A1 (en) 2001-03-31 2005-12-28 Mechanism for handling explicit writeback in a cache coherent multi-node architecture

Family Applications Before (2)

Application Number Title Priority Date Filing Date
US09/823,791 Expired - Lifetime US6842830B2 (en) 2001-03-31 2001-03-31 Mechanism for handling explicit writeback in a cache coherent multi-node architecture
US10/896,151 Expired - Lifetime US7167957B2 (en) 2001-03-31 2004-07-20 Mechanism for handling explicit writeback in a cache coherent multi-node architecture

Country Status (1)

Country Link
US (3) US6842830B2 (en)

Cited By (9)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20080114944A1 (en) * 2006-10-05 2008-05-15 Holt John M Contention detection
US20080127213A1 (en) * 2006-10-05 2008-05-29 Holt John M Contention resolution with counter rollover
US20080126721A1 (en) * 2006-10-05 2008-05-29 Holt John M Contention detection and resolution
US20080130631A1 (en) * 2006-10-05 2008-06-05 Holt John M Contention detection with modified message format
US20080133691A1 (en) * 2006-10-05 2008-06-05 Holt John M Contention resolution with echo cancellation
US20080133711A1 (en) * 2006-10-05 2008-06-05 Holt John M Advanced contention detection
US20080141767A1 (en) * 2006-12-19 2008-06-19 Schlumberger Technology Corporation Enhanced downhole fluid analysis
US20080250221A1 (en) * 2006-10-09 2008-10-09 Holt John M Contention detection with data consolidation
WO2014039701A2 (en) * 2012-09-07 2014-03-13 International Business Machines Corporation Selective delaying of write requests in hardware transactional memory systems

Families Citing this family (62)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6636949B2 (en) * 2000-06-10 2003-10-21 Hewlett-Packard Development Company, L.P. System for handling coherence protocol races in a scalable shared memory system based on chip multiprocessing
US6799217B2 (en) * 2001-06-04 2004-09-28 Fujitsu Limited Shared memory multiprocessor expansion port for multi-node systems
US6842827B2 (en) 2002-01-02 2005-01-11 Intel Corporation Cache coherency arrangement to enhance inbound bandwidth
US7111125B2 (en) * 2002-04-02 2006-09-19 Ip-First, Llc Apparatus and method for renaming a data block within a cache
US7133972B2 (en) 2002-06-07 2006-11-07 Micron Technology, Inc. Memory hub with internal cache and/or memory access prediction
US7117316B2 (en) 2002-08-05 2006-10-03 Micron Technology, Inc. Memory hub and access method having internal row caching
US6820181B2 (en) 2002-08-29 2004-11-16 Micron Technology, Inc. Method and system for controlling memory accesses to memory modules having a memory hub architecture
US6976129B2 (en) * 2002-09-30 2005-12-13 Intel Corporation Mechanism for handling I/O transactions with known transaction length to coherent memory in a cache coherent multi-node architecture
US8185602B2 (en) 2002-11-05 2012-05-22 Newisys, Inc. Transaction processing using multiple protocol engines in systems having multiple multi-processor clusters
EP1426866A1 (en) * 2002-12-06 2004-06-09 Sun Microsystems, Inc. A method to reduce memory latencies by performing two levels of speculation
US7111128B2 (en) * 2002-12-19 2006-09-19 Intel Corporation Hierarchical virtual model of a cache hierarchy in a multiprocessor system
US7917646B2 (en) * 2002-12-19 2011-03-29 Intel Corporation Speculative distributed conflict resolution for a cache coherency protocol
US6954829B2 (en) * 2002-12-19 2005-10-11 Intel Corporation Non-speculative distributed conflict resolution for a cache coherency protocol
EP1465059B1 (en) * 2003-04-02 2018-05-09 IP-First, LLC. Apparatus and method for renaming a cache line
US7120727B2 (en) 2003-06-19 2006-10-10 Micron Technology, Inc. Reconfigurable memory module and method
US7260685B2 (en) 2003-06-20 2007-08-21 Micron Technology, Inc. Memory hub and access method having internal prefetch buffers
US7120743B2 (en) 2003-10-20 2006-10-10 Micron Technology, Inc. Arbitration system and method for memory responses in a hub-based memory system
US7330992B2 (en) 2003-12-29 2008-02-12 Micron Technology, Inc. System and method for read synchronization of memory modules
US7188219B2 (en) * 2004-01-30 2007-03-06 Micron Technology, Inc. Buffer control system and method for a memory system having outstanding read and write request buffers
US7213082B2 (en) * 2004-03-29 2007-05-01 Micron Technology, Inc. Memory hub and method for providing memory sequencing hints
US7822929B2 (en) * 2004-04-27 2010-10-26 Intel Corporation Two-hop cache coherency protocol
US20050240734A1 (en) * 2004-04-27 2005-10-27 Batson Brannon J Cache coherence protocol
US20050262250A1 (en) * 2004-04-27 2005-11-24 Batson Brannon J Messaging protocol
US7725643B1 (en) * 2004-05-04 2010-05-25 Oracle America, Inc. Methods and systems for detecting and avoiding an address dependency between tasks
US7519788B2 (en) * 2004-06-04 2009-04-14 Micron Technology, Inc. System and method for an asynchronous data buffer having buffer write and read pointers
US7756594B2 (en) 2004-06-14 2010-07-13 Microsoft Corporation Systems and methods for parsing flexible audio codec topologies
US7590065B2 (en) * 2004-08-04 2009-09-15 Microsoft Corporation Equal-opportunity bandwidth regulation
US20060041895A1 (en) * 2004-08-04 2006-02-23 Microsoft Corporation Systems and methods for interfacing with codecs across an architecture optimized for audio
US20060031607A1 (en) * 2004-08-05 2006-02-09 Microsoft Corporation Systems and methods for managing input ring buffer
US20060041724A1 (en) * 2004-08-17 2006-02-23 Steely Simon C Jr Locked cache line sharing
US7706901B2 (en) * 2004-10-01 2010-04-27 Microsoft Corporation Low latency real-time audio streaming
US7243194B2 (en) * 2005-02-09 2007-07-10 International Business Machines Corporation Method to preserve ordering of read and write operations in a DMA system by delaying read access
US7395381B2 (en) * 2005-03-18 2008-07-01 Intel Corporation Method and an apparatus to reduce network utilization in a multiprocessor system
US10031848B2 (en) * 2005-06-14 2018-07-24 Intel Corporation Method and apparatus for improving snooping performance in a multi-core multi-processor
US7797495B1 (en) * 2005-08-04 2010-09-14 Advanced Micro Devices, Inc. Distributed directory cache
US20080082755A1 (en) * 2006-09-29 2008-04-03 Kornegay Marcus L Administering An Access Conflict In A Computer Memory Cache
US20080201531A1 (en) * 2006-09-29 2008-08-21 Kornegay Marcus L Structure for administering an access conflict in a computer memory cache
US8244825B2 (en) * 2006-11-06 2012-08-14 Hewlett-Packard Development Company, L.P. Remote direct memory access (RDMA) completion
US7996626B2 (en) * 2007-12-13 2011-08-09 Dell Products L.P. Snoop filter optimization
US8667226B2 (en) * 2008-03-24 2014-03-04 Freescale Semiconductor, Inc. Selective interconnect transaction control for cache coherency maintenance
US8015365B2 (en) * 2008-05-30 2011-09-06 Intel Corporation Reducing back invalidation transactions from a snoop filter
US8250331B2 (en) 2009-06-26 2012-08-21 Microsoft Corporation Operating system virtual memory management for hardware transactional memory
US8356166B2 (en) * 2009-06-26 2013-01-15 Microsoft Corporation Minimizing code duplication in an unbounded transactional memory system by using mode agnostic transactional read and write barriers
US8370577B2 (en) 2009-06-26 2013-02-05 Microsoft Corporation Metaphysically addressed cache metadata
US20100332768A1 (en) * 2009-06-26 2010-12-30 Microsoft Corporation Flexible read- and write-monitored and buffered memory blocks
US8161247B2 (en) * 2009-06-26 2012-04-17 Microsoft Corporation Wait loss synchronization
US8812796B2 (en) * 2009-06-26 2014-08-19 Microsoft Corporation Private memory regions and coherence optimizations
US8489864B2 (en) 2009-06-26 2013-07-16 Microsoft Corporation Performing escape actions in transactions
US8229907B2 (en) * 2009-06-30 2012-07-24 Microsoft Corporation Hardware accelerated transactional memory system with open nested transactions
US8402218B2 (en) 2009-12-15 2013-03-19 Microsoft Corporation Efficient garbage collection and exception handling in a hardware accelerated transactional memory system
US9092253B2 (en) * 2009-12-15 2015-07-28 Microsoft Technology Licensing, Llc Instrumentation of hardware assisted transactional memory system
US8539465B2 (en) 2009-12-15 2013-09-17 Microsoft Corporation Accelerating unbounded memory transactions using nested cache resident transactions
US8533440B2 (en) * 2009-12-15 2013-09-10 Microsoft Corporation Accelerating parallel transactions using cache resident transactions
US8489822B2 (en) 2010-11-23 2013-07-16 Intel Corporation Providing a directory cache for peripheral devices
US8493810B2 (en) * 2011-05-09 2013-07-23 Arm Limited Memory circuitry with write boost and write assist
US9348675B2 (en) * 2013-02-26 2016-05-24 Information Builders, Inc. Active service bus
US11029997B2 (en) * 2013-07-15 2021-06-08 Texas Instruments Incorporated Entering protected pipeline mode without annulling pending instructions
CN105404546A (en) * 2015-11-10 2016-03-16 上海交通大学 RDMA and HTM based distributed concurrency control method
US11119926B2 (en) 2017-12-18 2021-09-14 Advanced Micro Devices, Inc. Region based directory scheme to adapt to large cache sizes
US10705959B2 (en) 2018-08-31 2020-07-07 Advanced Micro Devices, Inc. Region based split-directory scheme to adapt to large cache sizes
US10922237B2 (en) 2018-09-12 2021-02-16 Advanced Micro Devices, Inc. Accelerating accesses to private regions in a region-based cache directory scheme
US10936496B2 (en) * 2019-06-07 2021-03-02 Micron Technology, Inc. Managing collisions in a non-volatile memory system with a coherency checker

Citations (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4933901A (en) * 1988-01-11 1990-06-12 Texas Instruments Incorporated Method for assigning priority to read and write requests received closely in time
US5432918A (en) * 1990-06-29 1995-07-11 Digital Equipment Corporation Method and apparatus for ordering read and write operations using conflict bits in a write queue
US5875472A (en) * 1997-01-29 1999-02-23 Unisys Corporation Address conflict detection system employing address indirection for use in a high-speed multi-processor system
US5987571A (en) * 1996-04-24 1999-11-16 Hitachi, Ltd. Cache coherency control method and multi-processor system using the same
US6029219A (en) * 1997-08-29 2000-02-22 Fujitsu Limited Arbitration circuit for arbitrating requests from multiple processors
US6256713B1 (en) * 1999-04-29 2001-07-03 International Business Machines Corporation Bus optimization with read/write coherence including ordering responsive to collisions
US20020038407A1 (en) * 1999-01-05 2002-03-28 Farnaz Mounes-Toussi Circuit arrangement and method with state-based transaction scheduling
US6430641B1 (en) * 1999-05-04 2002-08-06 International Business Machines Corporation Methods, arbiters, and computer program products that can improve the performance of a pipelined dual bus data processing system
US6678773B2 (en) * 2000-01-13 2004-01-13 Motorola, Inc. Bus protocol independent method and structure for managing transaction priority, ordering and deadlocks in a multi-processing system
US6961781B1 (en) * 2000-08-31 2005-11-01 Hewlett-Packard Development Company, L.P. Priority rules for reducing network message routing latency

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6122714A (en) * 1997-10-24 2000-09-19 Compaq Computer Corp. Order supporting mechanisms for use in a switch-based multi-processor system
US6145062A (en) * 1998-01-26 2000-11-07 Intel Corporation Selective conflict write flush
US6636949B2 (en) * 2000-06-10 2003-10-21 Hewlett-Packard Development Company, L.P. System for handling coherence protocol races in a scalable shared memory system based on chip multiprocessing

Patent Citations (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4933901A (en) * 1988-01-11 1990-06-12 Texas Instruments Incorporated Method for assigning priority to read and write requests received closely in time
US5432918A (en) * 1990-06-29 1995-07-11 Digital Equipment Corporation Method and apparatus for ordering read and write operations using conflict bits in a write queue
US5987571A (en) * 1996-04-24 1999-11-16 Hitachi, Ltd. Cache coherency control method and multi-processor system using the same
US5875472A (en) * 1997-01-29 1999-02-23 Unisys Corporation Address conflict detection system employing address indirection for use in a high-speed multi-processor system
US6029219A (en) * 1997-08-29 2000-02-22 Fujitsu Limited Arbitration circuit for arbitrating requests from multiple processors
US20020038407A1 (en) * 1999-01-05 2002-03-28 Farnaz Mounes-Toussi Circuit arrangement and method with state-based transaction scheduling
US6256713B1 (en) * 1999-04-29 2001-07-03 International Business Machines Corporation Bus optimization with read/write coherence including ordering responsive to collisions
US6430641B1 (en) * 1999-05-04 2002-08-06 International Business Machines Corporation Methods, arbiters, and computer program products that can improve the performance of a pipelined dual bus data processing system
US6678773B2 (en) * 2000-01-13 2004-01-13 Motorola, Inc. Bus protocol independent method and structure for managing transaction priority, ordering and deadlocks in a multi-processing system
US6961781B1 (en) * 2000-08-31 2005-11-01 Hewlett-Packard Development Company, L.P. Priority rules for reducing network message routing latency

Cited By (22)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7962697B2 (en) 2006-10-05 2011-06-14 Waratek Pty Limited Contention detection
US20080126504A1 (en) * 2006-10-05 2008-05-29 Holt John M Contention detection
US8473564B2 (en) 2006-10-05 2013-06-25 Waratek Pty Ltd. Contention detection and resolution
US20080127214A1 (en) * 2006-10-05 2008-05-29 Holt John M Contention detection with counter rollover
US20080126721A1 (en) * 2006-10-05 2008-05-29 Holt John M Contention detection and resolution
US20080130631A1 (en) * 2006-10-05 2008-06-05 Holt John M Contention detection with modified message format
US20080133691A1 (en) * 2006-10-05 2008-06-05 Holt John M Contention resolution with echo cancellation
US20080133711A1 (en) * 2006-10-05 2008-06-05 Holt John M Advanced contention detection
US8095616B2 (en) 2006-10-05 2012-01-10 Waratek Pty Ltd. Contention detection
US20080140799A1 (en) * 2006-10-05 2008-06-12 Holt John M Contention detection and resolution
US8086805B2 (en) 2006-10-05 2011-12-27 Waratek Pty Ltd. Advanced contention detection
US20080127213A1 (en) * 2006-10-05 2008-05-29 Holt John M Contention resolution with counter rollover
US20080140976A1 (en) * 2006-10-05 2008-06-12 Holt John M Advanced contention detection
US7831779B2 (en) * 2006-10-05 2010-11-09 Waratek Pty Ltd. Advanced contention detection
US7949837B2 (en) 2006-10-05 2011-05-24 Waratek Pty Ltd. Contention detection and resolution
US20080114944A1 (en) * 2006-10-05 2008-05-15 Holt John M Contention detection
US7971005B2 (en) 2006-10-05 2011-06-28 Waratek Pty Ltd. Advanced contention detection
US20080250221A1 (en) * 2006-10-09 2008-10-09 Holt John M Contention detection with data consolidation
US7637151B2 (en) 2006-12-19 2009-12-29 Schlumberger Technology Corporation Enhanced downhole fluid analysis
US20080141767A1 (en) * 2006-12-19 2008-06-19 Schlumberger Technology Corporation Enhanced downhole fluid analysis
WO2014039701A3 (en) * 2012-09-07 2014-05-22 International Business Machines Corporation Selective delaying of write requests in hardware transactional memory systems
WO2014039701A2 (en) * 2012-09-07 2014-03-13 International Business Machines Corporation Selective delaying of write requests in hardware transactional memory systems

Also Published As

Publication number Publication date
US20040268061A1 (en) 2004-12-30
US20020178210A1 (en) 2002-11-28
US7167957B2 (en) 2007-01-23
US6842830B2 (en) 2005-01-11

Similar Documents

Publication Publication Date Title
US7167957B2 (en) Mechanism for handling explicit writeback in a cache coherent multi-node architecture
US7996625B2 (en) Method and apparatus for reducing memory latency in a cache coherent multi-node architecture
US6990559B2 (en) Mechanism for resolving ambiguous invalidates in a computer system
JP5431525B2 (en) A low-cost cache coherency system for accelerators
US6519685B1 (en) Cache states for multiprocessor cache coherency protocols
US6330643B1 (en) Cache coherency protocols with global and local posted operations
KR100318104B1 (en) Non-uniform memory access (numa) data processing system having shared intervention support
JP3269967B2 (en) Cache coherency control method and multiprocessor system using the same
US6145059A (en) Cache coherency protocols with posted operations and tagged coherency states
JP3714617B2 (en) Method, computer system, and processing unit for maintaining consistency in a cache hierarchy
US20050188159A1 (en) Computer system supporting both dirty-shared and non dirty-shared data processing entities
US6418514B1 (en) Removal of posted operations from cache operations queue
US7024520B2 (en) System and method enabling efficient cache line reuse in a computer system
JP4577729B2 (en) System and method for canceling write back processing when snoop push processing and snoop kill processing occur simultaneously in write back cache
JP3550092B2 (en) Cache device and control method
US7000080B2 (en) Channel-based late race resolution mechanism for a computer system
US7818391B2 (en) System and method to facilitate ordering point migration
US6347361B1 (en) Cache coherency protocols with posted operations
US6345340B1 (en) Cache coherency protocol with ambiguous state for posted operations
US20070073979A1 (en) Snoop processing for multi-processor computing system
JP2007505407A (en) Method and apparatus for joint coherency state in multi-interface cache
CN115858420A (en) System cache architecture and chip for supporting multiprocessor architecture
US20050160233A1 (en) System and method to facilitate ordering point migration to memory
US6895476B2 (en) Retry-based late race resolution mechanism for a computer system
JPH10105461A (en) Improved device and method for snooping processor and look-aside cache

Legal Events

Date Code Title Description
STCB Information on status: application discontinuation

Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION