Distributed shared memory¶
A shared-data programming view maintained across physically separate computer memories by a distributed implementation.
Core Idea¶
Distributed shared memory (DSM) presents logically shared data to processes whose physical memories are separate. Its implementation coordinates remote operations so the shared-data interface has stated access and visibility rules. What is shared is the programming view and coordinated state, not one physical memory device.[^ref-35765f8d8edb]
DSM does not require one flat address space. Levelt and colleagues compare page-based shared virtual memory (SVM) with Orca's typed shared data objects, calling both DSM. In one case processes load and store through a common virtual address space; in the other they use programmer-defined operations on objects shared across machines.[ref-35765f8d8edb][ref-8e908f0849fe]
Use Within the Domain¶
The term helps compare distributed parallel-programming systems that promise common data while storing it across private memories. Describe the programmer-visible access unit, the allowed operations, and the guarantee governing what other processes can observe. Then identify the remote mechanisms that implement that promise. A particular page protocol, broadcast scheme, or consistency model belongs to its implementation and should not silently be imposed on every DSM.[ref-35765f8d8edb][ref-8e908f0849fe]
The shared-data interface is an internal Interface Prime constituent of DSM. Both SVM and Orca expose bounded operations and results while hiding remote placement and communication; their implementations can differ behind the promised contract. DSM adds physically separate memory and remote maintenance, so the whole model is not merely an interface.
Clarity¶
Three roles distinguish DSM: separate physical memories, a logical shared-data interface, and distributed maintenance of declared operation visibility. Private memories alone make a system distributed but do not make its programming model shared-memory. Conversely, physical shared memory needs no distributed imitation to be shared.[^ref-35765f8d8edb]
The access unit explains the two inspected forms. SVM uses pages in a flat address space, with the paper's implementation coordinating coherent reads and writes. Orca uses typed objects and indivisible operations; its cited runtime can replicate objects and broadcast writes in a common order. Those details identify the cases, not universal DSM membership tests.[ref-35765f8d8edb][ref-8e908f0849fe]
Manages Complexity¶
DSM lets application code use common logical data without explicitly describing each interprocessor message. The runtime still has to coordinate remote access, copies, updates, and visibility. Comparing the programmer's simpler view with that hidden work exposes where costs and guarantees come from.[ref-35765f8d8edb][ref-8e908f0849fe]
In the studied SVM, page placement can cause contention when unrelated variables share a page. Orca's object unit changes that tradeoff: operations and sharing are defined at the object level. The concept groups both under a shared-data question without erasing their different costs.[^ref-35765f8d8edb]
Abstract Reasoning¶
To assess a system, ask whether data is physically split among memories, whether processes operate on logically common data rather than only exchange explicit copies, and what rule controls the visibility of those operations. Removing the shared-data interface turns the model into explicit messaging or remote storage; removing the cross-node visibility rule leaves the shared-memory promise unspecified.[^ref-35765f8d8edb]
Changing pages to typed objects can preserve DSM because the three roles remain. It does not preserve every SVM-specific claim about flat addresses, page faults, or false sharing. The distinction supports careful transfer of an idea across implementations.
Knowledge Transfer¶
The useful transferable reasoning within computing is to separate a stable shared-data operation surface from its changing distributed machinery. Both SVM and Orca hide implementation details behind declared operations, but their contract details differ. The broader bounded-exchange pattern belongs to the Interface Prime; the DSM name remains specific to computer memory and distributed runtime semantics.[ref-35765f8d8edb][ref-8e908f0849fe]
Example¶
In shared virtual memory, processes on loosely coupled processors use one virtual address space divided into pages. The studied system coordinates page placement, rights and coherent reads and writes. The physical memories are separate, the common address space is the logical interface, and page maintenance provides the visibility rule.[^ref-35765f8d8edb]
In Orca, processes on different machines share typed data objects. They invoke each object's declared operations rather than load or store arbitrary flat-address words. The cited implementation keeps local replicas and broadcasts writes in an agreed order. The same three DSM roles are present, while the access unit and maintenance mechanism differ from SVM.[ref-35765f8d8edb][ref-8e908f0849fe]
Relationships to Other Abstractions¶
Current abstraction Distributed shared memory Domain-specific
Parents (1) — more general patterns this builds on
-
Distributed shared memory is part of Interface Prime
Every DSM programming model contains a bounded shared-data access interface that hides its distributed implementation behind declared operation and visibility rules.
Neighborhood in Abstraction Space¶
Distributed shared memory sits in a sparse region of the domain-specific corpus (87th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.
Family — Concurrency & Parallel Computation (35 abstractions)
Nearest neighbors
- Live distributed object — 0.82
- Parallel computing — 0.81
- Shared memory — 0.81
- Inter-process communication — 0.80
- Internet socket — 0.80
Computed from structural-signature embeddings · 2026-10-17
Not to Be Confused With¶
Physical shared memory lets processors directly access a common memory carrier; DSM maintains a logical view across physically separate ones. Shared virtual memory is one page-based DSM approach, not the full class. Non-uniform memory access names locality-dependent hardware access costs. Distributed data storage need not offer a shared-memory programming interface. Orca's checkpoint and rollback machinery is described in one cited paper but is not a defining DSM requirement.[ref-35765f8d8edb][ref-8e908f0849fe]
References¶
[^ref-35765f8d8edb]: Willem G. Levelt, M. Frans Kaashoek, Henri E. Bal, and Andrew S. Tanenbaum, “A Comparison of Two Paradigms for Distributed Shared Memory,” Software: Practice and Experience 22, no. 11 (1992): 985–1010, doi:10.1002/spe.4380221105. Abstract and sections 1–2, author-hosted PDF pp. 1–4. https://www.cs.vu.nl/~ast/Publications/Papers/spe-1992.pdf [^ref-8e908f0849fe]: M. Frans Kaashoek, Raymond Michiels, Henri E. Bal, and Andrew S. Tanenbaum, “Transparent Fault-Tolerance in Parallel Orca Programs,” Proceedings of the Symposium on Experiences with Distributed and Multiprocessor Systems III (1992), 297–312. Sections 2.1–2.2, author-hosted PDF pp. 3–4. The paper's fault-tolerance design is not treated as part of the DSM identity. https://www.cs.vu.nl/~ast/Publications/Papers/sedms-1992.pdf