here - Stefan-Marr.de

5. An Ownership-based MOP for Expressing Concurrency Abstractions
1 AgentDomain = Domain (
2 | agent |
3 " Use # agent : to set the agent that is protected by this domain "
4 agent : anAgent = ( agent := self adopt : anAgent )
5
6 requestExecOf : selector on: obj with : args = unenforced (
7 " Semantics are only enforced on the agent itself ,
8 not on other objects created in its scope ."
9 obj = agent ifFalse : [^ obj perform : selector with : args ].
10
11 " Only allow execution of white - listed selectors "
12 (# read = selector or: [# send : = selector ]) ifTrue : [
13 ^ agent perform : selector with : args ].
14
15 Error signal : ’Exec . of method ’ + selector + ’ is denied .’ ))
Listing 5.3: Domain definition for an Agent, enforcing the expected guarantees.
5.4. Semantics of the MOP
Sec. 4.2 introduced the SOM language and the interpreter’s execution model.
Building on that foundation, this section describes the semantics of the OMOP
by discussing its implementation in the SOM interpreter.
Derived from Fig. 5.1, Lst. 5.4 shows how the basic elements of the OMOP
map onto the SOM interpreter. Every SOMObject has a field to refer to the
owner domain. The domain field is initialized in the #postAllocate method
after allocation is completed. The initial value, i. e., the owner domain is determined
by the domain the thread is currently executing in. Since SOM is
implemented as a stack-based interpreter, the current domain is derived from
the current stack frame. The enforcement flag is realized as part of the interpreter’s
stack frames as well. Thus, every frame maintains an enforced flag
and the current domain.
SOMInvokable, the superclass for methods and primitives, maintains the
attribute that indicates to the interpreter that execution has to continue unenforced.
Methods are annotated with unenforced instead of enforced, because
applications and libraries need to execute in the enforced mode most of
the time to benefit from the OMOP. Only the domain’s intercession handlers
and methods implementing language behavior require unenforced execution.
Thus, it is a pragmatic decision to annotate the smaller set of methods that
require unenforced execution.
124