here - Stefan-Marr.de

5. An Ownership-based MOP for Expressing Concurrency Abstractions
The main() procedure of the program executes in the context of the current
domain, which can be assumed to be a default that does not enforce any
specific semantics. Furthermore, note that main() starts executing without
enforcement enabled.
The first action of the program is the creation of a new cell object. To determine
the initial owner of the new object, the VM queries the current domain
via a call to #initialDomainForNewObject. Thus, the owner of a newly
created object is determined by the domain in which the current thread is executing.
Afterwards, still in the unenforced execution mode, the cell is set to
the value #foo and then adopted by the immutable domain. After adopting
the cell object, the intercession handlers of the domain define the semantics
for all operations on the cell. They will be triggered during the enforced execution
mode, which is enabled by requesting the domain to evaluate a block:
current evaluateEnforced: [cell set: #bar].
When the VM reaches the point of executing cell set: #bar during enforced
execution, it will not apply the method directly, but it will request
the execution of the method by using the OMOP. The owner of the cell
is identified and the intercession handler #requestExecOf:on:with: is triggered
on it. The intercession handler itself executes in unenforced mode to
avoid meta recursion. In this example, #requestExecOf:on:with: implements
standard semantics of method execution, since immutability does not require
any changes to it. Hence, the method #set: is executed with the enforcement
enabled. At some point, the implementation of #set: tries to perform
a write to the object field of the cell. Here, the VM triggers the OMOP’s
#write:toField:of: intercession handler of the owner of the cell, instead of
performing the write directly. Thereby, the immutable domain is able to signal
a violation of the requested immutability by throwing the corresponding
exception.
To cover other reflective capabilities properly as well, an implementation
of the OMOP requires that for instance reflective writes to fields obey the
enforcement flag. For example, in case the setter would have used Java’s
reflect.Field.set() to write the value, the implementation of Field.set()
would be required to determine the owner domain of the cell, and use the
MOP to request the actual memory write.
After demonstrating how a program would execute in the presence of
enforcement, Lst. 5.1 sketches of how such an immutability enforcing domain
can be implemented. Note that the example uses the SOM syntax (cf.
Sec. 4.2.1). The given ImmutableDomain overrides all intercession handlers that
are related to state mutation. These are the intercession handlers for han-
120