here - Stefan-Marr.de

6.2. Case Studies
ing actor. Upon creation, #initialize is invoked, which starts the actor’s
thread, i. e., Smalltalk process, to execute inside itself by using #spawnHere.
The implementation realizes safe messaging by adapting the semantics of
method executions. All requests from outside the domain, i. e., from outside
the actor, are served asynchronously (line 32). The result of such asynchronous
sends is represented by a Promise (line 23). In this simple implementation,
the sending actor blocks on the promise if it requires the result of
the message, and continues once the promise is resolved, i. e., once the result
is delivered when the event-loop processes the message (line 7).
All requests inside the actor are performed directly (line 29). Note that
this listing does not include definitions for field accesses, because Smalltalk
offers object-based encapsulation (cf. Sec. 4.2.1). This object-based encapsulation
guarantees that object fields can be accessed synchronously from within
an actor only. In languages like Java, we would also need to take care of fields,
since Java’s encapsulation is class-based. Thus, we would need to customize
#readField:of: and #write:toField:of as well.
Wrapping of the objects sent via messages is unnecessary, because the ownership
notion and the corresponding domain of an object guarantee the actor
properties implicitly. The OMOP’s #adopt: method can also be used to
change the owner of an object as part of the message send, if desired. By
changing the owner, it becomes unnecessary to scan the full heap to ensure
that other references to the object are no longer valid, because isolation is
ensured by the new owner domain, i. e., actor. For the moment, ownership
transfer needs to be used manually by asking the receiver domain to #adopt:
the received object, and therefore it is in the application code but not part of
the definition in Lst. 6.7.
Note that Lst. 6.7 contains only a sketch and does not take care of state
encapsulation in terms of global state, however, the ATActor domain can customize
#readGlobal: and #write:toGlobal: to make sure that full isolation
is guaranteed between actors. Thus, global state of classes could be replaced
with domain local copies by customizing these two intercession handlers. This
would be very similar to the working copies used in the STM implementation
(cf. Sec. 6.2.2).
While Sec. 3.3.3 discussed the issue of scheduling guarantees, Lst. 6.7 does
not include a corresponding solution. As summarized in Tab. 6.1, the main
issue is the missing control over the execution of code. Specifically, custom
schedulers built on top of a VM typically do not have the ability to reschedule
an actor when it is executing computationally expensive code or primitives.
With the OMOP, the reification of method invocations and primitives pro-
155