Four commercial directory protocols, spanning two eras and two motivations: the Origin wanted scale (1024 cores, mid-1990s); the three modern ones want point-to-point links — even at small scale.
8.8.1 SGI Origin 2000
Up to 512 nodes, each with two MIPS R10000 processors on a bus that — unusually — does no coherent snooping: it merely connects the processors to the node’s Hub, a specialized ASIC that runs the coherence protocol, interfaces to the network, and fronts the node’s slice of the distributed memory and directory. The protocol descends directly from the Stanford DASH machine (overlapping architecture teams). The network guarantees no ordering whatsoever — not even point-to-point.
One Origin node (×512)
R10000
R10000
coherence + network interface
Directory (1/N)
Six features worth remembering:
- Adaptive entry format. Each directory entry is too small to name every possible sharer, so the directory chooses per entry between a coarse bit vector and a limited pointer format.
- Unordered network ⇒ real races. The §8.7.3 races are not hypothetical here; the protocol handles all of them.
- Non-ownership E. E (and S) blocks are silently evicted silent eviction Evicting a block without sending any message; permitted for non-owned states (S, sometimes E) in some protocols. defined in Chapter 6 — open in glossary .
- The Upgrade upgrade A coherence request that asks for S-to-M permission without data transfer (the requestor already holds a valid copy). Vulnerable to a race: if a rival GetM is serialized first, the upgrader's copy is invalidated and it needs data after all (Origin: NACK + retry as GetM; ch08 baseline MOSI: OM^AC demotion to IM^AD). defined in Chapter 8 — open in glossary request + NACK. S→M without pointlessly moving data — but with a window of vulnerability: if a rival GetM/Upgrade is serialized first, P1 is already I when its Upgrade lands. The directory answers with a NACK nack Negative acknowledgment forcing a requestor to re-issue its request; risks livelock (section 9.3.2), so this book's protocols avoid it (the SGI Origin's Upgrade race uses one). defined in Chapter 8 — open in glossary , and P1 falls back to a full GetM.
- Dual responses for E blocks. P1 in E might have silently evicted, might hold a clean copy, or might have upgraded to M. On P2’s GetS the directory therefore sends memory’s data and forwards to P1, who sends either fresh data (if M) or an ack. P2 waits for both before it knows which data to trust.
- Two networks, not three. Request + response only. When forwarding could deadlock, the directory sends a backoff backoff SGI Origin mechanism for running a directory protocol on two networks instead of three: when forwarding could deadlock, the directory sends the requestor a backoff message (on the response network) listing the nodes to contact, and the requestor re-sends to them on the request network. defined in Chapter 8 — open in glossary message to the requestor on the response network, listing the nodes to contact — the requestor re-sends to them itself on the request network.
8.8.2 Coherent HyperTransport
Directories were born for scalability — but AMD adopted one for systems of at most eight chips. The prize is different: point-to-point links with no totally ordered broadcast network. Eight chips, three links each, at most three hops apart; with 6 cores per chip, a respectable 48-core system, glueless.
The protocol is a Dir₀B / null directory cache null directory cache No directory state at all (Dir0B): every forwarded request is a broadcast, but the directory controller survives as the LLC controller and the protocol's ordering point. defined in Chapter 8 — open in glossary (§8.5.2, §8.6.3): no stable directory state at all. Step through one transaction:
1 / 4Unicast the request to the home
C1 sends its GetM to the directory controller at the block's home node — exactly like any directory protocol so far.
Judge it either way: optimistically, point-to-point links, zero directory storage or complexity, scalable enough for its goal. Pessimistically, directory-style 3-hop latency (4 counting the off-critical-path completion) plus snooping-style broadcast traffic — in fact more bandwidth than snooping, because every broadcast forward generates a response.
8.8.3 HyperTransport Assist
For the 12-core “Magny Cours” Opteron systems, AMD stopped broadcasting: HT Assist adds an inclusive directory cache at each home chip, covering every block that (a) has this chip as home and (b) is cached anywhere. There is still no DRAM directory — a miss means “not cached anywhere,” and full sets are handled by Recalls recall A directory-initiated eviction of a block from all caches, used when a limited-associativity directory-cache set fills; kept rare by sizing (at least 2x aggregate cache capacity) and non-silent PutS. defined in Chapter 8 — open in glossary . Three distinguishing choices:
Deliberately coarse state
Entries only distinguish satisfy-from-memory vs. forward to ONE core vs. forward to ALL — two states separate “one sharer” from “more than one.” Two sharers and all sharers look identical; the saved bits were worth the extra Invalidations.
Recall discipline, no PutS
Sizing rule: at least 2× as many directory entries as cached blocks, keeping Recalls rare. Interestingly AMD sends no explicit PutS — their experiments said the PutS traffic wasn’t worth the modest further reduction in Recalls (contrast §8.7.4).
The LLC donates the storage
The BIOS statically partitions the LLC at boot — by default 1 MB directory, 5 MB cache. Each 64-byte LLC block reinterprets as 16 four-byte directory entries, organized as four 4-way set-associative sets.
8.8.4 Intel QPI
Intel’s QuickPath Interconnect (2008, first in the Core i7-9xx) replaced the electrically bottlenecked shared-wire Front-Side Bus with point-to-point links, specifying everything from the physical layer up. The protocol layer brings two novelties.
MESIF. The usual MESI states plus F(orward) forward (f) A non-MOESI stable state like Owned except clean (the LLC/memory copy is up-to-date). defined in Chapter 6 — open in glossary : a clean, read-only state whose single holder may respond with data to read requests. Compare the neighboring states:
| State | Dirty? | May source data? | Eviction |
|---|---|---|---|
| S | No | No | Silent |
| F | No | Yes (sole F holder) | Silent — clean, so just drop it |
| O | Yes | Yes | Must write back (PutO+data) |
The point of F: read-only data gets sourced from a cache rather than from memory — usually faster, since memory typically answers when a block is read-only.
Two protocol modes. QPI scales its protocol to the system:
Home Snoop home snoop QPI's scalable protocol mode: a directory protocol despite the name. Requests go to the home's directory, which forwards to exactly the nodes that need them; racing requests are ordered by arrival at the directory. defined in Chapter 8 — open in glossary — big systems
A scalable directory protocol (ignore the word “snoop”†). C1 requests at the home C2; the directory forwards to exactly who needs it (say C3, owner in M); C3 sends data to C1 and notifies C2; C2 then sends C1 a completion — only then may C1 use the data. Races resolve the classic way: ordered on arrival at the directory.
Source Snoop source snoop QPI's low-latency protocol mode for small systems: the REQUESTOR broadcasts to all nodes; each node sends the home a snoop response; a request is ordered only when all of its snoop responses have reached the home. Lower common-case latency than home snoop, more bandwidth, more complex races. defined in Chapter 8 — open in glossary — small systems
The requestor broadcasts to all nodes. Each core sends the home a snoop response naming its state (an M owner also ships data straight to the requestor). A request is ordered when ALL its snoop responses have reached the home — not when it arrives. Lower common-case latency, more bandwidth, and hairier races: in a C1-vs-C2 GetM race, the home crowns whichever request completed its snoop responses first, then instructs the winner to complete AND forward the block to the loser.
† Intel uses “snoop” for what a core does when it receives a coherence request from another node.
Source Snoop is Coherent HT’s close cousin with one key inversion: in Coherent HT the home broadcasts (so the home still orders every request); in Source Snoop the requestor broadcasts — there is no single arrival point, which is precisely what makes its race handling more complex.
Check yourself
1.P1 sends an Upgrade (S→M, no data) on the SGI Origin, but another core's GetM is serialized at the directory first. What happens?
2.On the Origin, P1 holds a block in (non-ownership) E and P2 sends a GetS. Why does P2 receive TWO responses?
3.Directory protocols nominally need three networks; the Origin has two. How does it avoid deadlock?
4.Why did AMD build Coherent HyperTransport as a directory protocol if it broadcasts everything anyway?
5.Which of these accurately describes HT Assist's directory cache?
6.How do QPI's two modes order racing requests?