Editing Distributed shared memory (section)

== Overview ==
[[File:DSM FIGURE.jpg|330px|right]]

DSM can be achieved via software as well as hardware. Hardware examples include [[cache coherence]] circuits and [[network interface controller]]s. There are three ways of implementing DSM:
* [[Page (computer memory)|Page]]-based approach using virtual memory
* Shared-variable approach using routines to access shared variables
* Object-based approach, ideally accessing shared data through object-oriented discipline

===Advantages===
* Scales well with a large number of nodes
* Message passing is hidden 
* Can handle complex and large databases without replication or sending the data to processes
* Generally cheaper than using a multiprocessor system
* Provides large virtual memory space
* Programs are more portable due to common programming interfaces
* Shield programmers from sending or receiving primitives

===Disadvantages===
* Generally slower to access than non-distributed shared memory
* Must provide additional protection against simultaneous accesses to shared data
* May incur a performance penalty
* Little programmer control over actual messages being generated
* Programmers need to understand consistency models to write correct programs

===Comparison with message passing ===
{| class="wikitable"
|-
! Message passing
! Distributed shared memory
|-
| Variables have to be marshalled
| Variables are shared directly
|-
| Cost of communication is obvious
| Cost of communication is invisible
|-
| Processes are protected by having private address space
| Processes could cause error by altering data
|-
| Processes should execute at the same time
| Executing the processes may happen with non-overlapping lifetimes
|}

Software DSM systems also have the flexibility to organize the shared memory region in different ways. The page based approach organizes shared memory into pages of fixed size. In contrast, the object based approach organizes the shared memory region as an abstract space for storing shareable objects of variable sizes. Another commonly seen implementation uses a [[tuple space]], in which the unit of sharing is a [[tuple]].

[[Shared memory architecture]] may involve separating memory into shared parts distributed amongst nodes and main memory; or distributing all memory between nodes. A [[coherence protocol]], chosen in accordance with a [[consistency model]], maintains [[memory coherence]].