here - Stefan-Marr.de

5. An Ownership-based MOP for Expressing Concurrency Abstractions
have an impact on the execution. This typically includes lexical globals and
primitive operations of a VM. The corresponding meta interface is sketched in
the second compartment of the Domain class. In addition to these operations,
the VM-specific part can also include an unenforced bit for each method. If
this unenforced bit is set, the corresponding method is always executed in
the unenforced execution mode. If the bit is not set, the method will execute
either enforced or unenforced depending on the current execution mode of
the thread. In general, the bit is used to mark operations that should execute
always at the meta level. This includes for instance the intercession handlers
of a domain themselves to guarantee that their execution is performed unenforced.
Other examples are methods that implement general language behavior,
for instance in Sec. 5.3.2, it is used in the agent example to mark the #read
method unenforced to represent the notion that the agent’s state is readable
without any restrictions.
Helper Methods The third compartment of the Domain class in Fig. 5.1 contains
a set of helper methods. These methods sketch functionality that is
merely convenient to have, but is not a fundamental part of the OMOP. Thus,
the operations offered here are not strictly orthogonal to the other mechanisms
offered by the OMOP. For instance, in the theoretical model depicted
by Fig. 5.1, the owner of an object is represented directly by the owned by relation,
and thus, can be modified directly. The helper methods offer the #adopt:
method which requests a domain to take over ownership for the given object.
This abstracts from the low-level details of how the owned by relation
is realized. For instance, it could be just another object field, or it could be
represented by arranging the objects of different domains in separate heaps.
The #evaluateEnforced: method also provides a high-level interface to the
execution mode by evaluating a block of code in the enforced execution mode.
This is convenient for the implementation of concurrency policies, as is the
spawning of new threads in a given domain via #spawnHere:.
Elements of the OMOP The remainder of this section gives a brief brief
summary of the elements of the OMOP and relates them to the requirements.
Domains own objects, and every object has one owner. They define the concurrency
semantics for owned objects by refining field read, field write,
method execution, and thread resumption. Newly created objects belong
to the domain specified by #initialDomainForNewObjects. With
#adopt:, the owner of an object can be changed during execution. This
116