here - Stefan-Marr.de

5. An Ownership-based MOP for Expressing Concurrency Abstractions
is applied to all objects the domain owns. A domain is similar to a meta-group
in group-based MOPs (cf. Sec. 5.1) and the notion of object ownership realizes
the meta relation in this MOP. However, compared to group-based MOPs, the
OMOP requires every object to be owned by exactly one domain. Therefore the
MOP proposed here is called an ownership-based metaobject protocol (OMOP). A
visual representation of the OMOP is given in Fig. 5.1.
0..*
Object
1
owned by
Domain
readField:of:(idx, obj)
: Object
write:toField:of:(val, idx, obj)
: Object
requestExecOf:on:with:lkup:(sel, obj, args, cls): Object
requestThreadResume:(thread)
: Thread
initialDomainForNewObjects()
: Domain
primCopy:(obj)
: Object
prim*(...) : Object
readGlobal:(global)
: Object
write:toGlobal:(val, global)
: Object
adopt:(obj)
: Object
evaluateEnforced:(block)
: Object
spawnHere:(block)
: Thread
1
runs in
0..*
Thread
enforced : bool
Method
unenforced : bool
Basic Interface VM specific Helper
Figure 5.1.: Ownership-based Metaobject Protocol. The domain is the metaobject
providing the intercession handlers that can be customized to adapt the language’s
behavior. Each object is owned by exactly one domain. Every thread executes
in one domain. Execution is either enforced, i. e., operations on an object
trigger intercession handlers, or it is unenforced and intercession handlers are
not triggered. The handlers enable the customization of field reads and writes,
method invocation, thread resumption, and initial owner of an object. If the VM
offers primitives and globals, they are reified as well, but these handlers are VMspecific.
Methods can be marked as unenforced to execute them always without
triggering the intercession handlers.
Fig. 5.2 depicts a simple object configuration during the execution of an
application that uses the OMOP. The example consists of two domains, represented
by the dashed circles at the meta level, with interconnected object
graphs on the base level. Note that the pointers between domains do not
need special semantics. Instead, the concurrency properties of a base-level object
are defined by the domain object that owns the base-level object. Thus,
the owned-by relation is the meta relation of the OMOP.
The remainder of this section discusses in more detail the semantics associated
with the OMOP and establishes the connection of its elements to the
requirements.
Basic Interface The first compartment of the Domain class depicted in Fig. 5.1
contains the basic intercession handlers provided by the OMOP. This basic
114