What Is the Difference Between SMP UMA and NUMA?

Symmetric Multiprocessing with Uniform Memory Access and Non-Uniform Memory Access are two foundational shared-memory architectures used in multi-processor classical computing. While both allow multiple processors to share a single physical address space, they differ in how memory is physically organized, how processors connect to it, and how access latency scales as core counts grow.

Symmetric Multiprocessing with Uniform Memory Access

In a Symmetric Multiprocessing (SMP) system with Uniform Memory Access (UMA), all processors are treated equally and share a single, centralized pool of physical memory. Every processor core connects to the memory controller through a shared bus or crossbar interconnect.

Because every core is equidistant from main memory, the time required to read or write any memory address is identical regardless of which processor issues the request. If \(t_{\text{mem}}\) denotes the memory access latency, then for any processor \(P_i\) and any memory address \(A\):

\[t(P_i, A) = t_{\text{mem}}\]

This uniformity simplifies operating system scheduling and application development, since thread placement does not affect memory latency. However, the shared interconnect becomes a bottleneck as more processors are added, limiting scalability due to bus contention and cache-coherency traffic.

Non-Uniform Memory Access

Non-Uniform Memory Access (NUMA) addresses the scalability limits of UMA by dividing physical memory into distinct local nodes, each directly attached to a subset of processors (typically a socket). Processors are still able to access the entire global address space, but memory attached to another socket must be reached over an inter-socket interconnect.

As a result, memory access latency depends on the physical location of the data relative to the requesting processor:

\[t_{\text{local}} < t_{\text{remote}}\]

Local memory accesses are fast because they stay within the processor's own memory controller, whereas remote accesses incur additional latency and bandwidth overhead across the interconnect.

Key Architectural Differences

• Memory Topology: UMA uses a single centralized memory pool, while NUMA distributes memory across multiple local nodes.
• Access Latency: UMA provides constant latency for all addresses; NUMA exhibits lower latency for local memory and higher latency for remote memory.
• Scalability: UMA is constrained by shared-bus or crossbar contention at higher core counts, whereas NUMA scales to many sockets and hundreds of cores by keeping most traffic local.
• Software Complexity: UMA requires minimal locality awareness from the operating system. NUMA relies on NUMA-aware schedulers and memory allocators (such as first-touch policies) to keep threads and their data on the same node.
• Cache Coherency: Both architectures maintain cache coherency across all cores, though NUMA systems typically use directory-based protocols to avoid broadcasting snoop requests across every interconnect link.

Choosing Between UMA and NUMA

UMA remains the standard for single-socket systems and small-scale workstations where core counts are low enough that a single memory controller can saturate demand without excessive contention. NUMA is the dominant architecture for multi-socket servers and high-performance computing systems, where distributing memory bandwidth across sockets is essential for scaling performance.