here - Stefan-Marr.de

3. Which Concepts for Concurrent and Parallel Progr. does a VM need to Support?
STM based on mutable TVars [Harris et al., 2005]. TVars, i. e., transaction variables,
are shared memory locations that support atomic memory transactions.
It is implemented as part of the GHC runtime system, i. e., it is supported
directly by the VM. One of the provided STM-implementation strategies uses
fine-grained locking of TVars to minimize serialization of execution during
commits.
Independently from the STM system, GHC supports explicit spawning of
parallel executing sparks, which are lightweight threads. Haskell’s par eventually
results in a call to the corresponding newSpark primitive in the runtime.
With the support for MVars, GHC enables additional communication patterns,
for instance channel-based communication, building on the ideas of M-
Structures [Barth et al., 1991; Peyton Jones et al., 1996]. MVars are synchronization
variables that can store values. Their basic operations are takeMVar and
putMVar. When an MVar is empty, a takeMVar will block. Similarly, putMVar
will block when it is full. MVars are implemented in the runtime (StgMVar).
The standard library provides a semaphore construct on top of MVars. Furthermore,
the library includes proper channels and various abstractions to
perform map/reduce and data parallel operations.
Mozart The data-flow variables of Oz, and their direct support in the Mozart
VM enable algorithm designs that are significantly different from algorithms
based on threads and locks. An OzVariable represents these data-flow variables
inside the VM and for instance keeps track of all threads that are
suspended on unresolved data dependencies. The directly exposed VM support
for channels (OzPort) enriches the choice for programmers even further.
Therefore, we conclude that the Mozart VM provides abstractions for Communicating
Threads in addition to the Threads and Locks-based ones.
3.1.2.3. Communicating Isolates (ComI)
As defined in Sec. 2.4.1, the main concept introduced by communicating isolates
is the strong state encapsulation between concurrent entities. This breaks
with the typical shared memory model and enforces clear separation between
components. Communication has to be performed either via value-based messaging
or by using explicitly introduced and constrained shared memory data
structures.
Common Language Infrastructure In addition to Threads and Locks-based
abstractions, the CLI specifies so-called application domains that provide a no-
50