AMBA CHI · Module 22 · CHI Misconceptions Engineers Have

“Snooping Scales Forever”

The AXI mental model carries a hidden assumption: that you can always just snoop everyone. At small scale it nearly is free — snooping a handful of agents is simple and correct, the kernel of truth behind the ACE shared-bus design. But it does not scale. Every access asks every cache, so snoop traffic grows with agent count per access, and with its square system-wide. At dozens of cores it becomes the snoop storm — the fabric saturates on snoops, not data. CHI's directory tracks which caches hold each line, so an access snoops only the real sharers, letting CHI reach dozens of agents. The trap is assuming broadcast is cheap, or that CHI broadcasts when it is directory-targeted.

Foundation14 min readAMBA CHIMisconceptionSnoopingDirectoryScalability

Module 22 · Chapter 22.2 · CHI Misconceptions Engineers Have

Project thread — 22.1 refuted the AXI conflation. 22.2 refutes broadcast snooping; 22.3 corrects the over-correction (directories still snoop).

1. The Misconception

The belief: "snooping scales forever — you can always just snoop everyone." It follows naturally from the shared-bus, broadcast model (and the AXI/ACE frame of Chapter 22.1): coherence means asking other caches, and asking all of them is the obvious way. It is a Foundation-level misconception because it hides the single biggest reason CHI exists — and the belief works just well enough at small scale to feel confirmed.

2. Why It's Tempting

The belief is tempting because at small scale broadcast snooping genuinely works well.

It's simple and correct. Broadcast a snoop to every cache; whoever has the line responds. No directory, no tracking — easy to build and reason about.
It's low-latency at small N. With a few agents, snooping all of them is cheap and fast — no directory lookup in the path.
Early systems did exactly this. The shared-bus and ACE coherent designs were broadcast-snoop — so it has a track record at the scale it fits.

The seed is real: for a handful of cores, broadcast snooping is the right design. The error is extrapolating "works at 4" to "works at 40".

3. Key Terms

4. Previous Chapter Connection

This chapter attacks the assumption left standing by Chapter 22.1's AXI model. Broadcast snooping is the ACE/shared-bus mechanism; the directory (Chapter 15.3) and targeted snoops (Chapter 15.6) are CHI's replacements. The snoop storm is the wall Module 3 documented, here named as a belief.

Where 22.1 said "don't reason about CHI as AXI", 22.2 shows the first concrete casualty of that AXI model: assuming broadcast. It is the direct setup for 22.3, which corrects the over-correction (directories do not eliminate snoops), and it grounds the scalability case studies (Chapter 20.3, 20.6) — every large CHI system rests on not broadcasting.

5. The Claim, Precisely

State the myth falsifiably.

Claim: "Broadcast snooping scales indefinitely — adding coherent agents does not fundamentally limit it; you can always just snoop everyone."

Testable. If true, snoop traffic would grow manageably with agent count. But count it: each coherent access must snoop every other agent, so snoop messages per access grow as O(N), and with all N agents issuing accesses, system-wide snoop traffic grows as O(N-squared). That is not indefinite scaling — it is a quadratic wall. The claim fails the moment you count the messages.

6. Why It's Wrong — The Core

Broadcast snooping's cost grows with the system, not with the work.

Every access snoops everyone. A coherent access has no idea who holds the line, so it must ask all N agents — O(N) snoops per access.
System-wide it's quadratic. N agents each issuing accesses that each snoop N agents → O(N-squared) total snoop traffic.
The fabric fills with snoops, not data. As N grows, snoop messages crowd out the actual data traffic — the snoop storm.
Adding cores makes it worse. Past a point, each new core adds more snoop load than useful throughput — negative scaling.

The cost is tied to how many agents exist, not how many actually share the line — which is almost always far fewer. That mismatch is the whole problem.

7. Engineering Diagram — the broadcast snoop fan-out

Figure 1 — why broadcast snooping does not scale. A single coherent access forces the interconnect to snoop every caching agent, because broadcast has no record of who holds the line. With N agents that is N snoops per access, and system-wide the snoop traffic grows with the square of N — the snoop storm. CHI's directory at the Home records the actual sharers, so the same access snoops only those (often none or one) instead of all.

One access, N snoops — and with every agent doing this, the fabric carries O(N-squared) snoop traffic. The requester has no idea who actually holds the line, so it asks everyone. CHI's directory removes that blindness — snoop only the real sharers.

8. The Mechanism

Broadcast vs directory-targeted snooping, side by side.

Aspect	Broadcast snoop (ACE / shared-bus)	Directory-targeted (CHI)
Who is snooped	every agent	only actual sharers
Snoops per access	O(N)	O(sharers) — often 0 or 1
System-wide traffic	O(N-squared)	scales with sharing, not N
State needed	none	a directory at the Home
Scaling	collapses (snoop storm)	scales to dozens of agents

The rule to carry: broadcast snooping's cost scales with the number of agents; directory snooping's cost scales with actual sharing. Since real sharing is usually tiny compared to agent count, the directory turns a quadratic problem into a near-constant one — which is exactly why CHI has a Home node with a directory (Chapter 8).

9. The Kernel of Truth

Steelman the belief.

At small N, broadcast is the right choice. For a few agents, the O(N) cost is negligible, and skipping the directory saves area and latency. Broadcast wins at small scale.
Broadcast is simpler and directory-free. No sharer tracking, no directory storage, no lookup — genuinely less to build and less to get wrong.
"Scales" — up to a point. The belief is right until the agent count crosses the knee; it is the extrapolation past that knee that fails.

The truth: broadcast snooping does scale — within a small range. The myth is the word "forever"; drop it, and the belief becomes a correct statement about small systems.

10. A Concrete Counterexample

Watch broadcast snooping cross its knee.

4 agents. Each access snoops 3 others. Snoop traffic is trivial; broadcast is great. The belief looks true.
16 agents. Each access snoops 15 others; system-wide snoop traffic is ~16× higher than the 4-agent case per unit work. Still tolerable, but the fabric is noticeably busier.
64 agents. Each access snoops 63 others; system-wide snoop traffic is now ~256× the 4-agent figure (O(N-squared)). The interconnect is saturating on snoops — the snoop storm.
Add a 65th core. Throughput goes down — the new core's snoop load exceeds its useful work. Negative scaling.
The directory alternative. At 64 agents, a line shared by 2 caches costs 2 snoops with a directory, not 63. The same workload scales because snoop cost tracks sharing (2), not agents (64).

The counterexample is arithmetic: 4→16→64 agents multiplies snoop traffic quadratically, and the 65th core makes things worse — the definition of not scaling forever.

11. What's Actually True

The correct model.

Broadcast snooping scales only to small agent counts — then hits the snoop storm.
Per-access snoop cost is O(N); system-wide is O(N-squared) for broadcast.
CHI uses a directory at the Home to snoop only actual sharers — cost scales with sharing.
This is why CHI scales to dozens of coherent agents where broadcast cannot.
Broadcast is still right at small scale — the choice depends on N.

12. Why The Distinction Matters

Believing "snooping scales forever" has concrete costs.

You design a many-agent system on broadcast. It passes at small test scale and saturates in the real, large configuration — a structural failure (Chapter 21.4).
You misjudge fabric sizing. Provisioning for data traffic while snoops dominate leaves the fabric undersized for the real load.
You miss why the Home exists. Not seeing the directory as the scaling mechanism makes CHI's node model seem arbitrary (Chapter 8).
You conflate CHI with broadcast. Assuming CHI broadcasts (an AXI/ACE hangover, Chapter 22.1) makes you mis-predict its traffic and scaling entirely.

13. Design Implications

What to do once the myth is dropped.

Pick the mechanism by scale — broadcast for a few agents, directory for many.
Budget snoop traffic, not just data — at scale, snoops can be the dominant fabric load.
Rely on the directory to target snoops — design so cost tracks sharing, not agent count (Chapter 15.6).
Size the directory / snoop filter — the directory is what buys scale; size it right (Chapter 15.5, and Chapter 22.7).
Never assume CHI broadcasts — it is directory-targeted by design.

14. The Trap

Trap: designing at scale on the assumption that broadcast snooping is free

The damage of "snooping scales forever" lands when you design a large system on it. Broadcast snooping is cheap at small scale, so it validates on a small testbench, a small emulation, a small first configuration — and every early signal says "fine". Then the real system ships at dozens of coherent agents, and the fabric saturates on snoop traffic — the snoop storm — carrying O(N-squared) snoops instead of data, so throughput stalls or even drops as cores are added. The failure is structural and late: it did not show at the scale you tested, only at the scale you shipped, and by then the coherence architecture is fixed. The mirror-image trap is just as costly: assuming CHI itself broadcasts (a leftover from the AXI/ACE model of Chapter 22.1), so you fear a snoop storm CHI's directory actually prevents, or you provision for broadcast traffic CHI never generates — mis-sizing the fabric in the other direction. Both come from the same root: treating snoop cost as independent of scale, when for broadcast it is quadratic in it and for CHI it tracks sharing.

The fix: treat snoop cost as a first-class, scale-dependent quantity. For a few agents, broadcast is fine. For many, you need the directory so snoops are targeted — and remember that CHI already does this: it snoops sharers, not everyone. Count the snoops at target scale, never at the small scale that flatters broadcast.

CHI broadcasts snoops. No — CHI is directory-targeted; it snoops actual sharers (setup for the mirror-trap).
Directory means zero snoops. No — the over-correction, refuted next in Chapter 22.3; directories still snoop, just fewer.
Snoops are free. No — each snoop is fabric traffic; at scale they can dominate (Chapter 15.6).
More cores always means more throughput. No — past the broadcast knee, more cores can mean less throughput.
Broadcast is always wrong. No — the kernel of truth: broadcast is right at small agent counts.

16. Answering It In An Interview

If asked "does snooping scale?" — the strong answer:

Give the growth. "Broadcast snooping is O(N) per access and O(N-squared) system-wide — it does not scale; it hits the snoop storm."
Name the fix. "CHI uses a directory at the Home to snoop only actual sharers, so cost scales with sharing, not agent count."
Concede the kernel. "At a few agents, broadcast is simpler and fine — the directory earns its keep at scale."
Anticipate 22.3. "But a directory does not eliminate snoops — it targets them; there are still snoops, just far fewer."

That shows you know the growth, the fix, the kernel, and the next nuance — reasoning, not recital (Chapter 21.6).

17. Key Takeaways

Broadcast snooping does not scale — O(N) per access, O(N-squared) system-wide.
Past a knee it becomes the snoop storm; adding cores can reduce throughput.
CHI uses a directory to snoop only actual sharers — cost tracks sharing, not N.
That directory is why CHI scales to dozens of coherent agents.
Kernel of truth: broadcast is simpler and right at small scale.
The trap: designing at scale on broadcast, or assuming CHI broadcasts (it does not).

18. Quick Revision

"Snooping Scales Forever" — refuted. Broadcast snooping — the shared-bus / ACE model where every coherent access snoops every caching agent — does not scale. Per access it costs O(N) snoops (ask all N agents), and system-wide, with all agents issuing accesses, snoop traffic grows as O(N-squared). At a handful of cores this is invisible and broadcast is genuinely the right, simplest choice (the kernel of truth). But past a knee it becomes the snoop storm: the interconnect saturates carrying snoops, not data, and adding cores can make throughput worse — negative scaling. The root cause is that broadcast cost scales with how many agents exist, not how many actually share the line, which is almost always far fewer. CHI's fix is the directory: the Home node tracks which caches hold each line, so a coherent access snoops only the actual sharers — often none or one — turning a system-wide cost into a sharing-sized one. That is why CHI scales to dozens of coherent agents where broadcast cannot, and why the Home has a directory. The trap is treating snoop cost as scale-independent: designing a large system on broadcast (it validates small, then saturates at ship scale), or, the mirror image, assuming CHI broadcasts (an AXI/ACE hangover) and mis-sizing the fabric. Count snoops at target scale; use broadcast only where N is small; rely on the directory at scale. But a directory does not eliminate snoops — the next chapter refutes that over-correction.

Coming Next

Chapter 22.3 — "Directory Means No Snoops". Fixing one myth breeds its opposite: if the directory solves the snoop storm, surely it removes snoops entirely? Chapter 22.3 refutes "directory means no snoops" — why a directory targets snoops rather than eliminating them, why shared lines still require snoops to invalidate or fetch, and how the directory's job is to make snoops few and precise, not absent — the exact over-correction this chapter's fix invites.