Hubbry Logo
search
logo
Uniform memory access avatar
Uniform memory access
Uniform memory access
current hub
U

Uniform memory access

logo
Community Hub0 Subscribers
Read side by side
Uniform memory access
View on Wikipedia
from Wikipedia

Uniform memory access (UMA) is a shared-memory architecture used in parallel computers. All processors in the UMA model share their physical memory uniformly. In an UMA architecture, access time to a memory location is independent of which processor makes the request, or which memory chip contains the transferred data. Uniform memory access computer architectures are often contrasted with non-uniform memory access (NUMA) architectures. In the NUMA architecture, each processor may use a private cache. Peripherals are also shared in some fashion. The UMA model is suitable for general purpose and time sharing applications by multiple users. It can be used to speed up the execution of a single large program in time-critical applications.[1]

Types of architectures

[edit]

There are three types of UMA architectures:

hUMA

[edit]

In April 2013, the term hUMA (heterogeneous uniform memory access) began to appear in AMD promotional material to refer to CPU and GPU sharing the same system memory via cache coherent views. Advantages include an easier programming model and less copying of data between separate memory pools.[2]

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Uniform memory access

View on Grokipedia
from Grokipedia
Uniform memory access (UMA) is a shared-memory architecture in parallel computing systems where all processors have equal and uniform access times to any location in the central main memory, regardless of the specific processor making the request or the memory module involved.[1] This model, also known as symmetric multiprocessing (SMP), relies on a single shared physical memory space that is accessible symmetrically by all processors, typically interconnected via a common bus or a crossbar switch to ensure consistent latency.[2] UMA architectures are designed for tightly coupled systems, where changes to memory made by one processor are immediately visible to all others, facilitating straightforward data sharing without the need for explicit message passing.[3] Key characteristics of UMA include its use of a centralized memory hierarchy, often supplemented by private caches per processor to reduce contention on the shared bus, while maintaining uniform access costs in the absence of heavy traffic.[4] Scalability is inherently limited by the bandwidth of the interconnecting bus or switch, typically supporting 2 to 64 processors depending on the implementation and workload, beyond which performance degrades due to increased memory contention.[1] This architecture simplifies programming and resource management compared to distributed models, as developers do not need to account for varying access latencies, making it suitable for applications requiring frequent inter-processor communication.[5] In contrast to non-uniform memory access (NUMA) architectures, where processors have faster access to local memory and slower access to remote modules, UMA provides a flat, contention-free view of memory that was foundational in early multiprocessor designs.[6] Emerging as one of the earliest multi-CPU paradigms in the late 20th century, UMA systems powered initial symmetric multiprocessors in servers and workstations, offering cost-effective scalability for small-scale parallel processing before the rise of more distributed alternatives.[7] Despite its limitations in large-scale environments, UMA remains relevant in modern embedded and midrange systems where uniform access simplifies administration and boosts efficiency for symmetric workloads.[1]

Fundamentals

Definition

Uniform memory access (UMA) is a shared-memory architecture employed in parallel computing systems, wherein every processor experiences the same access time to all memory locations, irrespective of the processor's physical position or the particular memory module involved.[4] This uniformity ensures that no memory address is inherently faster or slower to reach from any processing unit, providing a flat memory model that simplifies programming by eliminating location-dependent performance variations.[8] In the UMA shared memory model, all processors operate within a single, common physical address space, allowing any processor to directly reference and modify data in the global memory pool with consistent latency across the system.[5] This design contrasts with distributed memory models, where data must be explicitly transferred between separate processor-local memories, often incurring variable communication overheads.[9] UMA facilitates symmetric access in multiprocessor configurations, such as symmetric multiprocessing (SMP) systems, where identical processors share resources equitably without hierarchical distinctions in memory access privileges.[8] Conceptually, UMA can be visualized as multiple processors interconnected via a centralized switching fabric or bus to a unified memory pool, enabling each processor to issue read or write requests that traverse equivalent paths to any memory bank, thereby maintaining uniform response times under low contention.[4]

Key Characteristics

In uniform memory access (UMA) architectures, every processor experiences identical latency when accessing any memory word, regardless of its physical location in the shared memory system. This uniform access time, which eliminates variations based on proximity, typically falls in the range of tens to hundreds of nanoseconds, enabling predictable performance for small-scale multiprocessor configurations. Unlike hierarchical memory systems, UMA features no distinction between local and remote memory, as all memory modules are equally distant from every processor in terms of access delay.[10][11] To support shared address spaces across multiple processors, UMA systems rely on cache coherence protocols that ensure data consistency in private caches. Hardware mechanisms, such as the MESI (Modified, Exclusive, Shared, Invalid) protocol, or software-based approaches monitor and synchronize cache states, invalidating or updating copies as needed to prevent stale data issues. These protocols are essential because processors can cache the same memory blocks independently, requiring coordinated invalidation or write-back operations to maintain a unified view of memory.[12][13] UMA architectures support memory consistency models like sequential consistency, under which all memory operations from multiple processors appear to execute in a single, atomic serial order visible to every processor. This model guarantees that if a processor writes to memory, subsequent reads by any processor will reflect the updated value without intermediate inconsistencies. However, the shared interconnect and centralized memory resources in UMA lead to scalability limits that vary by implementation; traditional bus-based systems typically support up to 16-32 processors before contention significantly degrades performance, while modern on-chip multi-core UMA designs can scale to hundreds of cores (e.g., up to 192 as of 2025) using advanced interconnects.[14][15][12][16] UMA is frequently realized through symmetric multiprocessing (SMP) designs, where processors are interchangeable and share the same memory access paths.[8]

Architectural Types

Bus-Based UMA

In bus-based uniform memory access (UMA) architecture, all processors and memory modules connect to a single shared bus, providing a common medium for communication and enabling uniform access times to any memory location across the system. This topology relies on broadcast mechanisms, where memory requests and responses are transmitted to all connected components, ensuring that every processor experiences the same latency for memory operations regardless of the target module. The simplicity of this design makes it cost-effective for small-scale multiprocessor systems, as it avoids complex interconnects while maintaining shared memory visibility.[17][15] When multiple processors attempt to access the bus simultaneously, contention arises, necessitating arbitration to serialize requests and prevent conflicts. Common arbitration methods include daisy-chaining, where devices are serially connected and pass a grant signal along the chain until an idle device claims it, or centralized controllers that prioritize requests based on fixed or rotating schemes like round-robin. These mechanisms ensure fair or priority-based access but introduce additional latency proportional to the number of contenders, as only one transaction can proceed at a time on the shared medium. In practice, the bus operates in a time-multiplexed fashion, with separate lines for addresses, data, and control signals to facilitate efficient request handling.[18][19] Scalability in bus-based UMA is inherently limited by the finite bandwidth of the shared bus, which becomes a bottleneck as the number of processors increases beyond 4 to 8 units. Under high load, frequent contention for bus access elevates average memory latency, as arbitration delays and serialization of transactions reduce effective throughput, often leading to performance degradation rather than linear speedup with additional processors. This constraint arises because all memory traffic—reads, writes, and coherence messages—must traverse the same bus, saturating its capacity in demanding workloads.[20][11] Early implementations of bus-based UMA include the experimental dual-processor VAX 11/780 developed at Purdue University in 1981 and DEC's commercial VAX-11/782 introduced in 1982, with system performance directly tied to bus width (typically 32 bits) and clock speed (around 5 MHz), which determined peak data transfer rates and overall multiprocessor efficiency. In such systems, expanding beyond a few processors required careful tuning of bus parameters to mitigate bottlenecks, highlighting the architecture's suitability for modest parallelism.[21] To support caching in multiprocessor environments, bus-based UMA often incorporates snooping protocols for cache coherence, where each processor's cache controller passively monitors all bus transactions to detect modifications or invalidations affecting shared data blocks. This broadcast nature of the bus naturally facilitates snooping, as every cache can observe and react to relevant events—such as a write from another processor—without dedicated point-to-point links, though it adds overhead from continuous monitoring and potential bus traffic for coherence actions.[22][23]

Crossbar-Based UMA

In crossbar-based uniform memory access (UMA) architectures, an N × M crossbar switch serves as the interconnection network, linking N processors directly to M memory modules through a grid of crosspoint switches. Each crosspoint represents a potential dedicated path, enabling any processor to connect to any memory module without sharing pathways, provided the target memory is not simultaneously accessed by another processor. This topology supports parallel memory operations, distinguishing it from more serialized bus-based designs by allowing multiple independent transactions in a single cycle when no conflicts arise.[15][24] The access mechanism relies on the crossbar's role as a single-stage permutation network, where control logic configures the crosspoints to route processor requests—consisting of module identifiers, addresses, opcodes, and data values—directly to the appropriate memory banks. Conflicts, such as multiple processors targeting the same memory module, are resolved inherently through the network's non-blocking property, as the switch can establish a unique permutation of connections without rerouting or buffering at this stage. This setup ensures low-latency, contention-free access for permitted operations, maintaining the uniform memory access time characteristic of all UMA systems.[15][24] Scalability in crossbar-based UMA is constrained by the quadratic growth in hardware complexity, requiring O(N × M) crosspoint switches, which becomes prohibitive beyond medium-scale systems; for instance, a 64 × 64 configuration demands over 4,000 switches, escalating costs and limiting practical deployments to up to 64 processors. While this supports higher parallelism than bus-based UMA, the increased hardware density raises challenges in fault tolerance, as failures in individual crosspoints can disrupt multiple paths, and elevates power consumption due to the extensive switching fabric.[24][15][25] A representative example is the Sun Enterprise 10000 server, which utilized a crossbar router to interconnect up to 64 UltraSPARC processors with shared memory banks, providing non-blocking access and enabling scalable UMA performance in enterprise computing environments during the late 1990s. This design emphasized high throughput for scientific and database workloads, though its complexity contributed to higher manufacturing and maintenance overheads compared to simpler alternatives.[26]

Multistage Interconnection-Based UMA

Multistage interconnection-based uniform memory access (UMA) architectures employ a series of switching stages to connect multiple processors to shared memory modules, enabling scalable access while maintaining uniform latency across all memory locations. These networks, such as omega or Clos topologies, consist of multiple layers of small crossbar switches arranged in a logarithmic number of stages, providing multiple disjoint paths between any processor and memory module to reduce contention and support concurrent requests. The omega network, for instance, uses perfect shuffle and exchange permutations between stages to route messages deterministically, while Clos networks offer rearrangeable non-blocking connectivity through a three-stage design of input, middle, and output switches. Access in these systems relies on routing algorithms that direct memory requests through the network stages, with self-routing mechanisms in topologies like Beneš networks allowing packets to determine their path based on destination addresses without centralized control. Buffering at switch nodes manages conflicts when multiple requests target the same output, often using input or output queuing to prevent head-of-line blocking and ensure fair access. These mechanisms support the UMA model's equal access times by balancing load across paths, though minor variations can occur due to queuing delays.[27][28] The scalability of multistage UMA designs stems from their O(N log N) complexity in terms of switches and wires for N processors, allowing systems with hundreds of nodes by trading a modest increase in latency—proportional to the number of stages—for significantly lower cost compared to fully connected alternatives. The logarithmic depth ensures that path lengths remain balanced, preserving uniform access times even as the system grows. However, for large-scale implementations, directory-based cache coherence protocols are essential to track shared data locations across distributed memory modules connected via the network. Prominent examples include the NYU Ultracomputer, which utilized a multi-stage combining network based on omega-like routing to support thousands of processors with fetch-and-add operations for synchronization, demonstrating effective scaling in shared-memory MIMD systems. Cache coherence in these systems often adapts directory protocols to the distributed switch fabric for maintaining consistency.[29]

History and Development

Early Concepts and Implementations

The concept of uniform memory access (UMA) originated in early multiprocessor designs during the 1960s, where shared-memory architectures allowed multiple processors to access a common memory pool with equal latency, laying the groundwork for parallel computing.[30] These initial systems addressed the growing demand for concurrent processing in scientific and business applications, evolving from single-processor mainframes to configurations that supported multiprogramming and basic parallelism. By the 1970s, the shared-memory model was formalized as processors interconnected via buses or switches provided uniform access to centralized memory, enabling symmetric operation without location-dependent delays.[31] A key milestone in the 1960s was the IBM System/360, which served as a proto-UMA system through its multiprocessor variants, such as the Model 65MP introduced in 1965, featuring shared core memory accessible equally by up to two CPUs in an asymmetric multiprocessing configuration for fault-tolerant and high-availability computing in large-scale environments.[32] In the 1970s and early 1980s, the Cray X-MP, announced in 1982, advanced bus-based UMA for vector supercomputing with up to four processors sharing a centralized MOS memory of up to 16 million 64-bit words, achieving peak speeds of 941 MFLOPS through uniform access and tight coupling.[33] Implementations in the 1980s highlighted UMA's adoption in minicomputers and workstations, such as the dual-processor VAX 11/780 developed at Purdue University in 1982, which modified the standard single-CPU design to share memory via a common bus, supporting symmetric multiprocessing (SMP) for up to two processors in academic and engineering workloads.[21] The SGI Challenge series, launched in 1992, further popularized UMA in high-end workstations with up to 36 MIPS R4400 processors connected via a scalable bus hierarchy, preserving uniform access through cache-coherency protocols and enabling shared-memory programming for graphics and simulation tasks. The theoretical foundations of UMA in parallel architectures were articulated in Kai Hwang's 1984 book on computer architecture and parallel processing, which analyzed shared-memory models for scalability and uniformity in emerging vector and array processors.[34] By the 1990s, UMA shifted toward mainstream adoption in personal computing, with Intel's introduction of MP-capable 80486 chips in systems like the Sequent Symmetry in 1990, allowing dual-processor configurations in PCs via bus-based SMP, marking the transition from specialized hardware to commodity multiprocessing.[35] Technically, early UMA systems relied on centralized memory controllers connected by a single bus, limiting scalability to a few processors due to contention; evolution in the 1980s–1990s incorporated private caches with snooping protocols to maintain uniformity while distributing memory access burdens, as seen in the Cray X-MP's vector pipelines and SGI Challenge's hierarchical buses.[30] This progression balanced bandwidth and latency, supporting up to dozens of processors before the onset of NUMA for larger scales.[31]

Modern Extensions

Heterogeneous Uniform Memory Access (hUMA) represents a significant evolution in UMA architectures, enabling seamless sharing of system memory between CPUs and GPUs while maintaining cache coherence. Announced by AMD in April 2013 for its Kaveri Accelerated Processing Units (APUs), hUMA allows processors and graphics cores to access a unified physical address space, eliminating the need for explicit data copying between CPU and GPU memory domains.[36] Key features of hUMA include a unified address space that minimizes data transfer overheads, potentially reducing latency in heterogeneous workloads by up to 50% compared to traditional discrete GPU setups, and support for programming models such as OpenCL 2.0 and the Heterogeneous System Architecture (HSA) framework. This coherence is achieved through hardware mechanisms that propagate cache updates across CPU and GPU domains without software intervention, simplifying development for compute-intensive applications.[37][38] Recent implementations build on this foundation with AMD's Ryzen APUs, introduced post-2017, which integrate Zen CPU cores with Radeon graphics and leverage hUMA principles for shared memory in laptops and desktops, enabling efficient hybrid computing in power-constrained environments. Similarly, Intel's oneAPI initiative, launched in 2019, provides a unified programming model for heterogeneous systems, supporting shared memory access across CPUs, integrated GPUs, and FPGAs to facilitate CPU-GPU collaboration akin to hUMA.[39][40][41] Another notable modern extension is Apple's unified memory architecture in its M-series system-on-chips (SoCs), introduced with the M1 in 2020. This design provides a single high-bandwidth, low-latency memory pool shared uniformly by the CPU, GPU, Neural Engine, and other accelerators, improving efficiency for integrated heterogeneous computing in consumer devices such as MacBooks and iPads as of 2025.[42] A foundational AMD whitepaper from 2013 outlined hUMA's integration with HSA, emphasizing its role in reducing programming complexity for multi-core heterogeneous systems. In the 2020s, these extensions have seen adoption in AI accelerators, where uniform access supports hybrid CPU-GPU workloads for tasks like inference, improving efficiency in resource-limited setups.[43] hUMA and similar modern UMA variants address gaps in traditional architectures by evolving to support embedded systems and edge computing, where uniform memory simplifies multiprocessing in IoT devices by providing low-latency shared access without complex NUMA partitioning. This is particularly beneficial for real-time AI at the edge, reducing overhead in battery-powered or space-constrained IoT multiprocessing scenarios.[44][45]

Comparison with NUMA

Architectural Differences

Uniform Memory Access (UMA) and Non-Uniform Memory Access (NUMA) represent two fundamental approaches to shared memory organization in multiprocessor systems, differing primarily in how memory is structured and accessed at the hardware level. In UMA architectures, all processors share a single, flat memory pool where access paths are uniform, ensuring that the time to read or write any memory location is consistent regardless of the processor initiating the request.[46] This uniformity arises from a centralized design that avoids hierarchical distinctions in memory placement. In contrast, NUMA architectures distribute memory across nodes, each associated with local processors, resulting in faster access to local memory and slower access to remote memory located on other nodes.[47] These organizational differences fundamentally shape the scalability and efficiency of each model in multi-core and multi-socket environments. The interconnection networks further highlight these architectural contrasts. UMA systems typically employ centralized mechanisms such as shared buses or crossbar switches to connect all processors to the unified memory, which simplifies design but introduces bottlenecks as the number of processors increases due to contention on the common pathway.[48] NUMA, however, utilizes scalable interconnection fabrics, such as Intel's Ultra Path Interconnect (UPI) or AMD's Infinity Fabric, to link nodes and enable remote memory access, allowing for distributed control and higher aggregate bandwidth without a single point of failure.[49] Emerging standards like Compute Express Link (CXL) further extend NUMA by enabling memory pooling across systems, potentially reducing non-uniformity in disaggregated environments as of 2025.[50] This node-based interconnection in NUMA supports clustering of multiple processing units, each with its own memory controller, which enhances parallelism but requires careful management of inter-node communication latency. Both architectures incorporate multi-level cache hierarchies to reduce memory access times, but their coherence mechanisms diverge to accommodate their memory models. UMA relies on global cache coherence protocols, such as snooping (where caches monitor bus traffic) or directory-based schemes, to maintain consistency across all processors' caches in the shared address space, ensuring uniform visibility of data updates.[47] In NUMA, coherence is similarly hardware-managed in cache-coherent variants, but the design optimizes for local cache hits within nodes, minimizing expensive remote accesses and using directories to track data locations across the distributed system.[46] This local optimization in NUMA reduces coherence overhead for intra-node operations while handling inter-node sharing through the scalable fabric. UMA's design imposes scalability limits, typically supporting fewer than 32 processors before interconnection contention degrades performance, as the centralized structure struggles with growing traffic.[48] NUMA overcomes this by clustering nodes, enabling systems to scale to thousands of processors through hierarchical organization, where each cluster operates semi-independently.[49] A notable hybrid variant, cache-coherent NUMA (cc-NUMA), extends NUMA by enforcing full cache coherence across nodes, blending UMA's programming model with NUMA's scalability to blur the boundaries between the two.[47]

Performance Implications

In uniform memory access (UMA) systems, all processors experience consistent memory access latency, approximately 100 ns under light load but varying up to 200 ns or more under contention due to the centralized memory architecture.[51] However, this uniformity can lead to contention spikes when multiple processors compete for the shared memory bus or controller, increasing effective latency under high contention. In contrast, non-uniform memory access (NUMA) systems exhibit variable latency, with local memory accesses averaging 90-100 ns and remote accesses ranging from 150-300 ns or more, reflecting the distributed nature of memory nodes connected via interconnects.[52][53][51] Regarding bandwidth and throughput, UMA architectures often encounter bottlenecks at the single shared memory controller, limiting aggregate bandwidth as the number of processors increases and leading to reduced overall system throughput in contention-heavy scenarios. NUMA mitigates this by providing dedicated memory controllers per node, enabling parallel access and higher total bandwidth, though remote accesses suffer from lower per-access bandwidth due to interconnect limitations, such as 6 GB/s remote versus 44 GB/s local in typical multi-socket systems.[54] This parallelization in NUMA supports better throughput scaling for distributed workloads, while UMA's shared resources constrain performance in larger configurations.[54] UMA architectures are particularly suited to fine-grained, shared-data workloads where frequent inter-processor communication benefits from uniform low-latency access, such as in database management systems or small-scale symmetric multiprocessing (SMP) applications. NUMA, however, excels in large-scale, partitioned applications like high-performance computing (HPC) simulations, where data can be localized to nodes to minimize remote accesses and leverage scalability beyond dozens of cores. Benchmarks indicate that UMA performs well in small-scale setups due to its uniformity, while NUMA provides better scalability for larger systems by sustaining performance gains with increasing core counts.[55][56] To address NUMA's latency variability and approximate UMA-like uniformity, software optimizations such as page migration in operating systems like Linux relocate memory pages to the accessing node's local memory, improving locality and reducing remote access frequency. This technique, part of NUMA-aware memory management, can significantly enhance performance in dynamic workloads by dynamically balancing data placement, though it incurs overhead from migration costs.[57][58]

Advantages and Disadvantages

Advantages

Uniform Memory Access (UMA) architectures offer significant programming simplicity due to their single, shared address space, which allows developers to parallelize code without the need for explicit data placement strategies or inter-processor messaging protocols. This uniformity enables straightforward implementation of shared memory programming models, reducing complexity in multi-threaded applications and facilitating easier debugging and portability across processors.[31] The low-latency access to shared memory in UMA systems makes them particularly suitable for workloads involving frequent inter-processor communication, where rapid data sharing between cores minimizes synchronization delays and enhances overall throughput. In these environments, the equal access times to all memory locations ensure predictable performance without the variability introduced by remote access penalties.[59] Hardware uniformity in UMA simplifies operating system scheduling and load balancing in symmetric multiprocessing (SMP) setups, as processors are indistinguishable in terms of memory access, allowing the kernel to distribute tasks evenly across cores using a single ready-to-run queue without locality-aware optimizations. This automatic load balancing reduces overhead in task migration and improves resource utilization in multi-core environments.[15] In heterogeneous UMA (hUMA) implementations, such as those in AMD's Heterogeneous System Architecture (HSA), CPU-GPU data copy overhead is significantly reduced in graphics workloads by enabling direct access to a unified memory pool, eliminating explicit transfers and leveraging cache coherence for seamless data sharing between processors.[60] For small-scale systems with 2-16 cores, UMA provides cost-effectiveness through lower hardware complexity compared to more scalable alternatives, as it relies on a simple shared bus or crossbar without distributed memory controllers, making it ideal for entry-level SMP servers and workstations.[61]

Disadvantages

One major limitation of uniform memory access (UMA) architectures is their scalability ceiling, stemming from shared interconnects that lead to contention among processors vying for memory access. This bottleneck typically restricts UMA systems to a small number of processors (e.g., up to 64), beyond which performance degrades exponentially due to increased bus traffic and arbitration delays.[8][3] Bandwidth saturation represents another critical drawback, as all memory requests funnel through common paths like a shared bus, creating hotspots and throttling throughput in memory-intensive applications. In such scenarios, the centralized interconnect becomes overwhelmed, limiting overall system bandwidth and causing delays that disproportionately affect parallel workloads.[31][55] Implementing UMA for larger configurations incurs high costs, particularly with crossbar switches, whose complexity and expense scale quadratically with the number of processors and memory modules, making them impractical for systems beyond small scales.[62] Benchmarks demonstrate that UMA systems exhibit significant slowdowns in bandwidth-bound high-performance computing (HPC) tasks compared to NUMA equivalents, with memory contention leading to substantial performance degradation in scenarios involving heavy data sharing.[55] Finally, UMA designs introduce maintenance challenges through single points of failure in the shared bus or interconnect, elevating downtime risks during faults or repairs compared to more distributed architectures. Multistage interconnection networks offer partial mitigation by distributing traffic paths, though they do not fully resolve the inherent scalability constraints.[31]

References

  1. 2 Parallel Hardware Architecture
  2. Introduction to Multiprocessors – Computer Architecture
  3. [PDF] Introduction to Parallel Computing
  4. CSE 160 (Spring 2015) Notes on NUMA and Shared Memory
  5. Shared Memory Architectures
  6. B424 Shared memory
  7. Midrange systems architecture - SjaakLaan.nl
  8. Parallel & Distributed Computing - UAF CS
  9. [PDF] Shared Memory - CMSC 611: Advanced Computer Architecture
  10. Memory Access Latency - an overview | ScienceDirect Topics
  11. NUMA Deep Dive Part 1: From UMA to NUMA - frankdenneman.nl
  12. [PDF] EE 457 Cache Coherence
  13. [PDF] Cache Coherence - Edward Bosworth
  14. [PDF] Lecture 26: Multiprocessors
  15. [PDF] Shared Memory Multiprocessors - Prof. Marco Ferretti
  16. Architecture of bus-based shared-memory multiprocessors. Most ...
  17. [PDF] Arbitration Schemes for Multiprocessor Shared Bus - IntechOpen
  18. [PDF] On the Performance of a Bus-based Multiprocessor Cluster ... - Dada
  19. [PDF] Multiprocessors
  20. (PDF) A dual processor VAX 11/780 - ResearchGate
  21. [PDF] Coherence & Snooping - Duke University
  22. [PDF] Introduction, SMP and Snooping Cache Coherence Protocol
  23. [PDF] 8.1 MULTIPROCESSORS
  24. [PDF] Energy-Efficient Interconnection Networks for High-Performance ...
  25. [PDF] Sun EnterpriseTM 10000 Server Just the Facts - Doge Microsystems
  26. A self routing Benes network - ACM Digital Library
  27. https://ieeexplore.ieee.org/document/569657
  28. The network architecture of the Connection Machine CM-5 ...
  29. NUMA Deep Dive Part 1: From UMA to NUMA
  30. Uniform Memory Access - an overview | ScienceDirect Topics
  31. The IBM System/360
  32. [PDF] The Cray X-MP Series of Computer Systems, 1985
  33. Computer architecture and parallel processing : Hwang, Kai
  34. ibm pc - What was the first multiprocessor x86 motherboard?
  35. AMD's “heterogeneous Uniform Memory Access” coming this year in ...
  36. AMD Announces hUMA, Heterogeneous Uniform Memory Access ...
  37. AMD introduces heterogeneous Uniform Memory Access
  38. AMD Unveils New 7000 Series APUs and New Radeon(TM ...
  39. oneAPI: A New Era of Heterogeneous Computing - Intel
  40. Intel Announces New GPU Architecture and oneAPI for Unified ...
  41. AMD Details hUMA: HSA in Action! - PC Perspective
  42. Uniform Memory Architecture for GPU-CPU Resource Sharing in ...
  43. Uniform Memory Architecture for GPU-CPU Resource Sharing in ...
  44. [PDF] Optimizing Applications for NUMA - Intel
  45. [PDF] Lecture #33 - Texas Computer Science
  46. [PDF] A Taxonomy of Parallel Computers UMA Uniform Memory Access ...
  47. [PDF] Non-uniform memory access (NUMA)
  48. https://osg.tuhh.de/Lehre/V_MSC/03-vm-numa.html
  49. Latency of memory accesses via interconnectors - Server Fault
  50. Latency Numbers Every Programmer Should Know - GitHub
  51. Memory bandwidth on a NUMA system - Intel Community
  52. [PDF] Performance Analysis of UMA and NUMA Models - ijcset
  53. Scaling Up Performance of Managed Applications on NUMA Systems
  54. Page migration - The Linux Kernel documentation
  55. MAO: Machine learning approach for NUMA optimization in ... - arXiv
  56. [PDF] Smoothing non-uniform communication latencies for OLTP
  57. https://www.amd.com/en/technologies/hsa
  58. Symmetric Multi-Processor - an overview | ScienceDirect Topics
  59. Crossbar Network - an overview | ScienceDirect Topics
User Avatar
No comments yet.