here - Stefan-Marr.de

2.4. Common Approaches to Concurrent and Parallel Programming
task-oriented, while HPC applications are mostly data-oriented, which leads
to different tradeoffs in the design and implementation of algorithms.
Actors The actor model is a formalism to describe computational systems.
Hewitt et al. [1973] distilled it from the many ideas of that time in the field
of artificial intelligence to provide a “coherent manageable formalism”. This formalism
is based on a single kind of object, an actor. These actors are computational
units that respond to messages by sending messages to other actors,
create new actors, or designate how to handle the next message they receive.
Communication is done via addresses of other actors. An actor has to be introduced
explicitly to another actor or it has to create the actor to know its
address. Later, Hewitt [2012] clarified that the actor model assumes that messages
are processed concurrently, and more importantly, that actors do not
require any notion of threads, mailboxes, message queues, or even operating
system processes.
The benefit of the actor model is that it provides a concise formalism to
describe systems. By using the simplest possible notion of the actor model
in the way Hewitt [2012] proposes, the actor model achieves desirable theoretical
properties such as locality, safety of communication, and unbounded
nondeterminism.
However, the minimalism of the model comes with a significant engineering
tradeoff. Similarly to the discussion of the right object granularity for
code reuse, which component-based software engineering tries to address,
the granularity of actors becomes important when actors are used to build
software systems. The idea of event-loop concurrency tries to address these
granularity issues.
Event-Loop Concurrency E and AmbientTalk propose the idea of actors integrated
with object-oriented programming languages [Miller et al., 2005; Van
Cutsem et al., 2007]. E uses the term vat to denote a container of objects, which
in AmbientTalk corresponds to an actor, that holds an object graph. Inside a
vat, objects can refer to each other with near references. References between
different vats are only possible via far references. While near references allow
synchronous access to objects, far references only allow asynchronous interaction.
The semantics of far references is that of asynchronous message sends.
Every vat executes an infinite loop that processes incoming messages. Based
on these ideas, Van Cutsem describes the three main properties of the eventloop
concurrency model as follows: Serial execution is guaranteed inside a vat.
31