here - Stefan-Marr.de

3. Which Concepts for Concurrent and Parallel Progr. does a VM need to Support?
concept relevant for concurrency abstractions is hardly enforceable on any
of the surveyed platforms today. The main reason for weak enforceability is
the ubiquitous availability and use of reflection. Since immutability and other
concurrency properties are essential for correctness of code, reflection needs
to be flexible and allow developers to circumvent only the necessary subset
of language guarantees for a given use case.
In conclusion, a unifying substrate needs to support some form of managed
state and managed execution. This is necessary to enable custom
semantics for execution and state access and a powerful VM interface. This dissertation
refers to managed state as the notion of reifying access to state, i. e.,
reading and writing of object fields or global variables. Managed execution
is the notion of reifying execution of methods and primitives.
A mechanism satisfying these two notions is supposed to enable at least
the implementation of asynchronous invocation, isolation, scheduling policies, immutability,
ownership, and interception of primitives.
The discussion of for instance active objects, CSP, and actors, showed that
concurrency policies, i. e., for instance access restrictions can be based on the
notion of ownership of objects. To support such concurrency policies, a unifying
substrate needs to complement managed state and managed execution
with ownership. A mechanism satisfying this requirement enables
the implementation of isolation and supports concepts such as Clojure actors
which allow reads from arbitrary entities but restrict write access to the owning
entity.
To enforce scheduling policies, this dissertation requires a VM to support
some form of preemptive scheduling that will enable a higher prior thread to
execute when necessary to ensure fairness. Blocking primitives remain problematic
however, because they can block the scheduling logic from executing.
Thus, primitives have to be manageable as we required it for execution in
general. This aspect is covered by managed execution.
The required enforcement of guarantees against reflection needs to be flexible.
As explained with the example of an ORM system, reflection needs to
be enabled to obey concurrency semantics (cf. Sec. 3.3.5), while the ORM still
needs to be able to circumvent access restrictions like private modifiers for
fields to fulfill its purpose. Thus, such an implementation needs to be able
to specify whether an operation is supposed to be executed with enforcement
enabled or disabled. To conclude, a VM needs to provide the notion of
controlled enforcement. A mechanism that satisfies this notion has to
enable for instance reflection over private fields of an objects while its concurrency
properties are maintained. In the context of an STM system, this would
84