here - Stefan-Marr.de

3.3. Common Problems for the Implementation of Concurrency Abstractions
when the benchmark uses pass-by-reference, which brings the runtime down
to ca. 17sec.
Approaches based on type systems or other forms of static verification enable
the safe passing of references, and thus, bring significant performance
advantages. However, a type system comes with additional implementation
complexity, its guarantees do not reach beyond language boundaries, and are
typically voided by the use of reflection.
Again, these problems are universal and apply to communicating isolate concepts,
e. g., CSP [Hoare, 1978] and APGAS [Saraswat et al., 2010] concepts as
well (cf. Sec. 2.4.4). For instance, JCSP [Welch et al., 2007] does not guarantee
safe messaging for reference types. The by-value semantics is only given
for primitive types, and channels that are based on network socket communication.
The main concerns are performance, similar to actor-oriented
frameworks on the JVM and frameworks like Retlang 19 on top of the CLI.
X10 [Charles et al., 2005] as one example for an APGAS language explicitly
specifies that deep copying is performed [Saraswat et al., 2012]. Similarly, the
application domains specified by the CLI rely on marshalling, i. e., either deep
copying or far references, to enforce safe messaging and state encapsulation.
Thus, the implementation of properties such as safe messaging can become a
performance issue when the VM does not provide mechanisms to support it,
which often leads to language and library implementers giving up on desirable
semantic properties.
Conclusion Following this discussion, the implementation of isolation on
today’s multi-language VMs is challenging and thus, it often remains unenforced
or only partially supported. Solutions for enforcing isolation imply
tradeoffs between performance and implementation complexity. Furthermore,
mechanisms to handle reflection and the interaction with other languages remain
uncommon.
Note that the notion of ownership is central for the definition of isolation.
Furthermore, a mechanism for ownership transfer between entities can simplify
the implementation of safe messaging greatly.
3.3.3. Scheduling Guarantees
The second issue identified by Karmani et al. is that the overall progress guarantee
of an actor systems assumes fair scheduling. In systems without fair
scheduling, actors can be starved of computation time and block the overall
19 http://code.google.com/p/retlang/
75