Abstract:
An efficient streamlined coherent protocol for a multi-processor multi-cache computing system. Each subsystem includes at least one processor and an associated cache and directory. The subsystems are coupled to a global interconnect via global interfaces. In one embodiment, each global interface includes a request agent (RA), a directory agent (DA) and a slave agent (SA). The RA provides a subsystem with a mechanism for sending read and write request to the DA of another subsystem. The DA is responsible for accessing and updating its home directory. The SA is responsible for responding to requests from the DA of another subsystem. Each subsystem also includes a blocker coupled to a DA and associated with a home directory. All requests for a cache line are screened by the blocker associated with each home directory. Blockers are responsible for blocking new request(s) for a cache line until an outstanding request for that cache line has been serviced. A &#34;locked&#34; state managed by the blocker greatly reduces corner cases and simplifies solutions in the few remaining corner cases.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     This invention relates to caches. In particular, this invention relates to a cache coherency scheme for multiple caches in a multiprocessor system. 
     2. Description of the Related Art 
     With the shift of computing technology to the &#34;network is the computer&#34; paradigm, the need for a shared global memory address space and a coherent caching system in a networked computing system becomes increasingly important. FIG. 1A is a block diagram showing one such networked computer system 100 with a conventional non-uniform memory architecture (NUMA). System 100 includes a plurality of subsystems 110, 120, . . . 180, coupled to each other via a global interconnect 190. Each subsystem is assigned a unique network node address. Each subsystem includes one or more processors, a corresponding number of memory management units (MMUs) and caches, a main memory assigned with a portion of a global memory address space, a global interface and a local subsystem interconnect. For example, subsystem 110 includes processors 111a, 111b . . . 111i, MMUs 112a, 112b, . . . 112i, caches 113a, 113b, . . . 113i, main memory 114, global interface 115 and subsystem interconnect 119. 
     Data from main memories 114, 124, . . . 184 may be stored in one or more of caches 113a . . . 113i, 123a . . . 123i, and 183a . . . 183i. Thus, cache coherency among caches 113a . . . 113i, 123a . . . 123i, and 183a . . . 183i is maintained in order for system 100 to execute shared-memory programs correctly. 
     In order to support a conventional directory-based cache coherency scheme, subsystems 110, 120, . . . 180 also include directories 116, 126, . . . 186 coupled to global interfaces 115, 125, . . . 185, respectively. Referring now to FIG. 1B, each global interface, e.g., interface 115 includes a slave agent (&#34;SA&#34;), a request agent (&#34;RA&#34;) and a directory agent (&#34;DA&#34;), e.g, SA 115a, RA 115b and DA 115c. Each DA is responsible for updating its associated directory with the status of all cached copies of its (home) main memory, including copies cached in other subsystems. 
     The status of cached copies in each node are recorded in directories 116, 126, . . . 186 as one of four states per node. An invalid (&#34;I&#34;) state indicates that the node, i.e., subsystem, does not have a copy of the data line of interest. A shared (&#34;S&#34;) state indicates that the node has an S copy, and that possibly other nodes may have S copies. An owned (&#34;O&#34;) state indicates that the node has an O copy, and that possibly other nodes may have S copies. Note that the node with the O copy is required to perform a write-back upon replacement. Finally, a modified (&#34;M&#34;) state indicates that the node is the sole owner of the data line, i.e., there are no S copies in the other nodes. 
     A RA provides a subsystem with a mechanism for sending read and write requests to the other subsystems. A DA provides access to and is responsible for updating its associated home directory. An SA is responsible for responding to requests from the DA of another subsystem. 
     Requests for data and responses are exchanged by the respective agents between subsystems 110, 120, . . . 180 in the form of data/control packets, thereby enabling subsystems to keep track of the states of their caches 113a . . . 113i, 123a . . . 123i, and 183a . . . 183i in directories 116, 126, . . . 186, respectively. These data/control packets are transported between subsystems via global interconnect 190. Unfortunately, since global interconnect 190 may be based on any one of a number of conventional networking protocols, e.g., a collision sense multiple access (CSMA) protocol, from the timing viewpoint, subsystems 110, 120, . . . 180 may be loosely coupled to each other at the network layer of the protocol. As such, while the arrival of packets end-to-end is guaranteed, the order of arrival of the packets is not necessarily guaranteed. The out-of-order arrival of packets at subsystems 110, 120, . . . 180 is problematic because they can result in &#34;corner cases&#34; which, if not detected and resolved, can disrupt cache coherency. 
     One such corner case is illustrated by FIGS. 2A-2D in which a data packet associated with an earlier-in-time read-to-share request (RTS --  req) arrives after the cache line is prematurely invalidated as a result of the arrival of a later-in-time read-to-own request (RTO --  req) initiated by another subsystem. In this example, initially, subsystem 110, subsystem 120 and a fourth subsystem (not shown in FIG. 1A) have shared (&#34;S&#34;) copies of a data line from the memory space of subsystem 180. 
     Referring first to FIG. 2A, RA1 of global interface 115 of subsystem 110 sends a RTS --  req packet to DA8 of global interface 185 of subsystem 180. As shown in FIG. 2B, DA8 responds by initiating the transfer of a data packet to the requesting RA1. 
     Next, as shown in FIG. 2C, before the data packet arrives at RA1, RA2 of global interface 125 of subsystem 120 sends a read-to-own request (RTO --  req) packet to DA8. 
     FIG. 2D shows DA8 respond by initiating the transfer of a data packet to RA2. In addition, DA8 sends invalidate (Invld) packets to SA1 and SA4, the slave agents of subsystem 110 and the fourth subsystem, respectively. 
     Unfortunately, the later-in-time Invld packet arrives at SA1 before the earlier-in-time data packet arrives at RA1. As a result, SA1 receives the Invld packet first and proceeds to invalidate the old S copy of the data line of interest. Subsequently, RA1 receives the data packet, but is unable to update the value of its S copy because it has been erroneously and prematurely marked Invld. 
     Several conventional brute-force handshaking protocols for resolving corner cases do exist. FIGS. 3A-3F illustrate one prior art solution to the corner case described above. Again, using the same starting conditions as the example illustrated by FIGS. 2A-2D, subsystem 110, subsystem 120 and the fourth subsystem have S copies of a data line from the memory space of subsystem 180. 
     Referring first to FIG. 3A, RA1 of subsystem 110 sends a RTS --  req packet to DA8 of subsystem 180. 
     As shown in FIG. 3B, DA8 responds by initiating the transfer of a data packet to the requesting RA1. DA8 then idles while waiting for a read-acknowledgment (RTS --  ack) packet from RA1. 
     Next, as shown in FIG. 3C, RA2 sends a RTO --  req packet to DA8. However, DA8 is idle because it is waiting for a RTS --  ack packet from RA1 to arrive, and hence is unresponsive. 
     As shown in FIG. 3D, after receiving the RTS --  ack packet from RA1, DA8 is no longer idle and is now able to respond to the RTO --  req packet from RA2. 
     Accordingly, as shown in FIG. 3E, DA8 sends Invld packet(s) to any SAs of subsystems with S copies of the data line of interest. In this example, DA8 sends Invld packets to SA1 and SA4. DA8 is also responsible for sending a data packet together with the # --  Invld to RA2. 
     Subsequently, as shown in FIG. 3F, RA2 counts the number of incoming Invld --  ack from SA1 and SA4 thereby avoiding the corner case illustrated by FIGS. 2A-2D. 
     Unfortunately, the above-described brute-force hand-shaking solution for handling and/or reducing corner cases is inefficient because of the excessive number of handshaking control packets. These extra control packets substantially increase the network traffic. In other words, the &#34;cure&#34; for the infrequent but disastrous corner cases substantially degrade the efficiency of the network. 
     Hence, there is a need for a simple and streamlined cache coherency protocol which handles and/or reduces corner cases without substantially increasing network traffic. Advantages of the present invention include reduction of complicated race conditions resulting from the corner cases, ease of formal verification of the protocol due to the reduction of the race conditions, and increased reliability of the resulting cache coherent computer system. 
     SUMMARY OF THE INVENTION 
     The present invention provides an efficient streamlined cache coherent protocol for a multi-processor multi-cache computing system. Each subsystem includes at least one processor and an associated cache and directory. The subsystems are coupled to a global interconnect via global interfaces. 
     In one embodiment, each global interface includes a request agent (RA), a directory agent (DA) and a slave agent (SA). The RA provides a subsystem with a mechanism for sending read and write requests to the DA of another subsystem. The DA is responsible for accessing and updating its home directory. The SA is responsible for responding to requests from the DA of another subsystem. 
     Further, in accordance with the invention, each subsystem also includes a blocker. In this embodiment, each blocker is coupled to a DA and is associated with a home directory. All requests for a cache line are screened by the blocker associated with each home directory. Blockers are responsible for blocking new request(s) for a cache line until an outstanding request for that cache line has been serviced. Although counterintuitive, since blocking causes the new requests to be processed sequentially, a &#34;locked&#34; state managed by the blocker simplifies solutions by removing the few remaining comer cases. 
     In one embodiment, the blockers also include queues for storing pending requests. Variations and modifications to the blocker are also possible. For example, write-backs and read-to-own requests may be given priority for service over read-to-share requests. 
    
    
     DESCRIPTION OF THE DRAWINGS 
     The objects, features and advantages of the system of the present invention will be apparent from the following description in which: 
     FIG. 1A is a block diagram showing a networked computer system 100 with a conventional non-uniform memory architecture (NUMA). 
     FIG. 1B is a block diagram of the global interface of the computer system of FIG. 1A which includes a directory agent (&#34;DA&#34;), a request agent (&#34;RA&#34;) and a slave agent (&#34;SA&#34;). 
     FIGS. 2A-2D illustrate a corner case in which a data packet associated with an earlier-in-time read request arrives after the cache line is prematurely invalidated by a later-in-time read-to-own request. 
     FIGS. 3A-3F illustrate a conventional handshaking protocol for solving the corner case of FIGS. 2A-2D. 
     FIG. 4A is a block diagram showing an exemplary cache coherent networked computer system 400 of the present invention. 
     FIG. 4B is a block diagram of the global interface of the computer system of the present invention which includes a blocker, a directory agent (&#34;DA&#34;), a request agent (&#34;RA&#34;) and a slave agent (&#34;SA&#34;). 
     FIGS. 5A-5D illustrate an exemplary blocking of requests for the directory agent of FIG. 4B until an outstanding read-to-share (RTS) request has been serviced. 
     FIGS. 6A-6B and 6C-6D illustrate an exemplary blocking of requests for the directory agent of FIG. 4B until an outstanding read-to-own (RTO) request has been serviced. 
     FIGS. 6A-6B and 6E-6G illustrate an alternative way of blocking requests by the directory agent of FIG. 4B until an outstanding read-to-own (RTO) request has been serviced. 
     FIGS. 7A-7C illustrate an exemplary blocking of requests for the directory agent of FIG. 4B until an outstanding write-back (WB) request has been serviced. 
    
    
     NOTATIONS AND NOMENCLATURE 
     An invalid (&#34;I&#34;) state indicates that a node/subsystem does not have a (cached) copy of a data line of interest. 
     A shared (&#34;S&#34;) state indicates that the node/subsystem, and possibly other nodes, have a shared (cached) copy of the data line of interest. 
     An owned (&#34;O&#34;) state indicates that the node/subsystem is the owner, i.e. this node has a &#34;master copy&#34;. As such, this node must write the &#34;master copy&#34; to another node before the cache line can be reused. It is possible for other nodes to have a shared copy of the data line of interest. 
     A modified (&#34;M&#34;) state indicates that the node/subsystem has the only (cached) copy of the data line of interest. 
     A blocked (&#34;B&#34;) state indicates that a read/write request is outstanding for the data line of interest. 
     A request agent (&#34;RA&#34;) provides a subsystem with a mechanism for requesting access to a cached data line of interest from another subsystem. 
     A directory agent (&#34;DA&#34;) provides a subsystem with a mechanism for accessing its directory to track the status of copies of its main memory. 
     A slave agent (&#34;SA&#34;) provides a subsystem with a mechanism for responding to a data request from another subsystem. 
     DESCRIPTION OF THE PREFERRED EMBODIMENT 
     In the following description, numerous details provide a thorough understanding of the invention. These details include functional blocks and an exemplary cache directory to assist a designer in implementing a cost-effective cache coherent computer system. In addition, while the present invention is described with reference to a specific cache coherent scheme for an exemplary multi-cache multi-processor computer system, the invention is applicable to a wide range of caches and network architectures. In other instances, well-known circuits and structures are not described in detail so as not to obscure the invention unnecessarily. 
     FIG. 4A is a block diagram showing an exemplary cache coherent networked computer system 400 of the present invention. System 400 includes a plurality of subsystems 410, 420, . . . 480, coupled to each other via a global interconnect 490. Each subsystem includes one or more processors, a corresponding number of memory management units (MMUs) and caches, a main memory assigned with portion of a global memory address space, a global interface and a subsystem interconnect. For example, subsystem 410 includes processors 411a, 411b . . . 411i, MMUs 412a, 412b, . . . 412i, caches 413a, 413b, . . . 413i, main memory 414, global interface 415 and subsystem interconnect 419. subsystems 410, 420, . . . 480 also include directories 416, 426, . . . 486 coupled to global interfaces 415, 425, . . . 485, respectively. 
     In accordance with the cache coherency scheme of the present invention, as shown in FIG. 4B, each global interface, e.g., interface 415, includes a slave agent (&#34;SA&#34;), a request agent (&#34;RA&#34;), a directory agent (&#34;DA&#34;) and a blocker, e.g., SA 415a, RA 415b, DA 415c and blocker 415d. Thus there is a one-to-one correspondence between each DA and each directory. 
     Blockers, DAs, RAs and SAs can also be incorporated in circuits separate from the respective global interfaces. Each blocker is coupled to a DA and is responsible for holding pending request(s) for cache lines while outstanding request(s) are being serviced. Note that the &#34;blocking&#34; functionality can be provided by directories 416, 426, . . . 486 as described below or alternatively by adding dedicated blocking logic. The dedicated blocking logic is responsible for queuing outstanding transactions and storing a cache-line address for each of the outstanding transactions. Subsequently, the dedicated blocking logic compares the address of each outstanding transaction with all the old cache-line addresses before allowing transactions to pass to the corresponding DAs. In this alternative implementation, each completion signal only needs to clear its respective address. 
     DAs of each subsystem are responsible for updating its associated directory with the status of each cached-line sized portion of its (home) main memory. Accordingly, for each such portion of the main memory, the directory includes a status indicating which subsystem(s), if any, have cached copies of that particular portion. In this implementation, each directory is a home directory, i.e., local directory, for a subsystem. Thus, each directory includes entries for cached copies of data lines associated with the subsystem, describing the state of cached copies in all subsystems. DAs are also responsible for forwarding the appropriate request packets to the respective SAs. 
     FIGS. 5A-5D illustrate example I in which subsystem 410 needs read permission, i.e., a shared (S) copy, from a data line within the home address space of subsystem 480, but is &#34;owned&#34; by subsystem 420. 
     First, as shown in FIG. 5A, RA1 of global interface 415 of subsystem 410 sends a read-to-share request (RTS --  req) packet to blocker 485d of global interface 485 of subsystem 480. Blocker 485d responds by causing DA8 to enter a blocked (B) state (denoted by the &#34;dotted&#34; circle), thereby freezing new requests to DA8 for the data line of interest. 
     Next, as shown in FIG. 5B, DA8, now in the B state, marks its home directory 486 to reflect the requesting RA1&#39;s new status as a sharer, and forwards the RTS --  req packet to slave agent SA2 of global interface 425 of subsystem 420. 
     The blocked (&#34;B&#34;) state indicates that there is a write/read request outstanding and subsequent request(s) for the same data line are blocked until the pending request has been serviced. In this implementation, blocker 485d, associated with DA8, blocks new requests for the data line by temporarily storing the requests in a local first-in-first-out (FIFO) queue or by flow controlling new requests. 
     SA2 responds to the RTS --  req packet by sending a data packet to RA1 and remains the &#34;owner&#34; of the data line, as shown in FIG. 5C. 
     Finally, as shown in FIG. 5D, upon receipt of the data packet from SA2, RA1 sends a RTS-completion (RTS --  compt) packet to blocker 485d. Blocker 485d causes DA8 to leave the B state. DA8 is now able to service any queued request for the data line of interest. 
     In example II illustrated by FIGS. 6A-6B and 6C-6D, subsystem 410 needs write permission, i.e., an owned (O) copy, from a data line whose home address space is in subsystem 480 but is owned by subsystem 420. In addition, a third subsystem and fourth subsystem (both not shown in FIG. 4A) have S copies of the data line. 
     First, as shown in FIG. 6A, RA1 sends a read-to-own request (RTO --  req) packet to DA8 via blocker 485d. 
     Next, as shown in FIG. 6B, blocker 485d causes DA8 to enter the B state and freezes new transactions to the cache line. DA8 marks its home directory to reflect the requester RA1&#39;s new status as the owner of the data line of interest, i.e., RA1&#39;s new status is owned (O). DA8 retrieves the number of sharers (# --  sharers), two sharers in this example, of this data line from its directory, appends the # --  sharers to the RTO --  req packet and forwards the RTO --  req packet to SA2. DA8 is also responsible for sending invalidate request (Invld --  req) packets to SA3 and SA4 of the third and fourth subsystems, respectively. The Invld --  req packets also include the identity of requesting RA1. 
     FIG. 6C shows SA2 responding to arrival of the RTO --  req packet by invalidating its copy of the data line, and sending a data packet to RA1 together with the total number of sharers. Upon receipt of the respective Invld --  req packets from DA8, both SA3 and SA4 send invalid acknowledgment (Invld --  ack) packets to RA1 and also invalidate their respective S copies. 
     Finally, as shown in FIG. 6D, after the arrival of the data packet from SA2 and after the arrival of the correct number of Invld --  ack packets, i.e., the # --  sharers, from SA3 and SA4, RA1 sends a RTO-completion (RTO --  compt) packet to blocker 485d. The RTO --  compt packet completes a &#34;three-hop dirty reply&#34; sequence. DA8 responds to the RTO --  compt packet by leaving the B state and by releasing the data line of interest. 
     Note that the protocol illustrated by example II can be simplified by sending # --  sharers together with the Invld --  req packet(s). Accordingly, whenever no data is required by RA1 of the requesting subsystem, the SA2 does not need to send a packet to RA1 for the sole purpose of sending the # --  shares to RA1. In other words, RA1 can obtain the # --  sharers from either SA3 or DA4, thereby reducing the network traffic by one packet. 
     An alternative example III is illustrated by FIGS. 6A-6B and 6E-6G. Starting with FIGS. 6A-6B as in example II, instead of sending Invld --  ack packets to the requesting RA1 as shown in FIG. 6C of example II, sharers SA3, SA4 send the Invld --  ack packets to the blocker of the home DA, i.e., blocker 485d of home subsystem 480, as shown in FIG. 6E. Consequently, home DA8 is responsible for counting the correct number of Invld --  ack packets and also responsible for receiving the RTO-compt packet from RA1 before leaving the B state. In this example, DA8 no longer needs to send # --  sharers to other nodes since SA3 and SA4 send Invld --  ack packets to blocker 485d instead of RA1. 
     Next, as shown in FIG. 6F, RA1 sends the RTO --  compt packet to blocker 485d after receiving the data packet from SA2. Blocker 485d is responsible for counting the Invld --  acks packets and recognizing the arrival of the RTO --  compt packet. 
     Finally, as shown in FIG. 6G, Blocker 285d sends a Completion --  acknowledge (Compt --  ack) packet to RA1 upon receipt of all expected Invld --  ack(s), in this example, from both SA3 and SA4. The Compt --  ack packet completes the &#34;four-hop dirty reply&#34; sequence and DA8 can now leave the B state and release the data line of interest. 
     FIGS. 7A-7C illustrate example IV in which a remote owner writes back to the host directory, e.g., subsystem 410 is the &#34;owner&#34; and sends a write-back request (WB --  req) to subsystem 420. 
     First, as shown in FIG. 7A, RA1 of global interface 415 of subsystem 410 sends a WB --  req packet to DA8 of global interface 485 of subsystem 480. DA8 responds by entering the B state and freezing new transactions to the cache line. 
     Next, as shown in FIG. 7B, DA8 marks its home directory to reflect the requester RA1&#39;s new status as invalid, and sends a write-back-permission (WB --  permit) back to RA1. 
     Finally, RA1 sends the data to DA8 via a write-back-complete (WB --  compt) packet which includes data to be replaced, as shown in FIG. 7C. Upon receiving the WB --  compt packet at DA8, the write-back transaction is complete and blocker 485d releases the data line of interest by leaving the B state. Note that RA1 only leaves the &#34;O&#34; state after RA1 has received the WB --  permit packet. Waiting for the WB --  permit packet from blocker 485d eliminates the corner case in which a subsequent read request to RA1 fails because RA1 replaced the cache line (using a write back) before the subsequent read request reaches RA1. 
     Various optimizations of the above described cache coherent mechanism are possible. For example, instead of a single FIFO queue for storing all outstanding read and write requests, RTO requests are stored in a separate queue and given priority for processing so that RTO requests are serviced first. Prioritizing write-back requests improves processor performance because typically processors of subsystems protect their respective critical code sections using a shared &#34;key&#34;. A processor locks the key before executing its critical code section and releases the key upon completion. Thereafter, a second processor can lock the key to execute its critical code section. Hence, by giving RTO requests priority, the key can be released rapidly, allowing other processors to quickly gain access to the key. 
     In another embodiment, selective blocking is provided. For example, blocking is selectively activated when an RTS request or a write-back request is outstanding, but is deactivated when a RTO request is outstanding. 
     Subsystem 410, 420 . . . 480 of computer system 400 can be arranged in many configurations. For example, system 400 may be configured as a wide area network (WAN), such as the internet, a local area network (LAN) or a tightly coupled multiprocessor system. 
     Other modifications and additions are possible without departing from the spirit of the invention. For example, instead of blocking all read and write requests arriving at the DA, RTO requests whenever a request is outstanding, read-to-share requests are blocked only if there is a read-to-own or a write-back request outstanding. In addition, each subsystem may be equipped with additional circuitry to perform &#34;local data forwarding&#34; so that processors within a subsystem can provide data to each other without accessing the host directory of another subsystem. Hence, the scope of the invention should be determined by the following claims.