The Sub-NUMA Clustering Mode: How One Socket Pretends to Be Two

2026-09-13

Modern server CPUs pack so many cores onto a single die that the on-chip interconnect starts to behave like a small NUMA network. A core on one side of the mesh reaches its "nearby" L3 slice and memory controller in maybe 50 cycles, but a slice or controller on the far side takes 90+. The socket looks uniform to software, but the silicon isn't. Sub-NUMA Clustering (SNC) — Intel's name; AMD calls its version NPS (Nodes Per Socket) — is the CPU's way of admitting this to the operating system.

When you enable SNC in BIOS, the socket is partitioned into 2 or 4 logical NUMA domains. Each domain owns:

The OS sees these as separate NUMA nodes and schedules memory allocations accordingly. A thread pinned to domain 0 gets memory from controllers on the same side of the mesh — cutting the round-trip through the interconnect.

Real-world example: A Sapphire Rapids Xeon with 4 memory controllers and 60 cores in SNC-2 mode splits into two 30-core domains. On a Redis benchmark hitting a 200GB dataset, enabling SNC-2 and pinning shards to local domains dropped p99 latency from ~180µs to ~120µs — roughly a 33% improvement — purely from shorter mesh hops. No code changed.

The catch: SNC only helps if your workload has locality. Cross-domain access is slower than uniform mode because the interconnect now has to route through explicit NUMA boundaries with coherence bookkeeping. A poorly-partitioned workload — say, a database with random shard-to-core mapping — will thrash across domains and lose 10-20% vs. flat mode. The OS scheduler and memory allocator need to actually respect the topology (numactl, cgroups with cpuset).

Rule of thumb: Estimate the ratio of local-to-remote memory access. If your workload does >70% local access when properly partitioned, SNC wins. Below 50%, keep the socket flat. You can measure this with perf stat -e uncore_cha/event=0x35/ or check LLC miss latency histograms — bimodal distributions are the signature of NUMA effects inside a single socket.

The deeper lesson: as core counts grow, "one socket" stops being a meaningful abstraction. The mesh is a network, latency is non-uniform, and pretending otherwise leaves 30% of your performance on the table.

See it in action: Check out The Mathematician Who Won’t Call the Universe a Computer by Curt Jaimungal to see this theory applied.
Key Takeaway: Sub-NUMA Clustering exposes the fact that a modern many-core socket is already a small NUMA system internally, and telling the OS about it lets locality-aware workloads shave a third off their memory latency.

All newsletters