Difference between revisions of "Actor Model"

Revision as of 17:45, 2 October 2014 (view source) Miranda ricardo (talk | contribs) (→‎Notes on the Actor Model) ← Older edit		Revision as of 18:00, 2 October 2014 (view source) Miranda ricardo (talk | contribs) Newer edit →
Line 28:		Line 28:
	<li>designating how it should handle the next message it receives (changing state).</li>		<li>designating how it should handle the next message it receives (changing state).</li>
	</ul>		</ul>
		+
		+	Here a [[Fortran implementation of the Actor Model]] is discussed.
	== Relevance of the Actor Model for the Mohid system ==		== Relevance of the Actor Model for the Mohid system ==

---

Revision as of 18:00, 2 October 2014

According to the Wikipedia[1] "the actor model in computer science is a mathematical model of concurrent computation that treats "actors" as the universal primitives of concurrent digital computation: in response to a message that it receives, an actor can make local decisions, create more actors, send more messages, and determine how to respond to the next message received" (changing state).

There are several resources in the Internet explaining the Actor Model and Reactive Programing. Some videos and interesting interviews:

• Hewitt, Meijer and Szyperski: The Actor Model (everything you wanted to know, but were afraid to ask)[2];
• Francesco Cesarini and Viktor Klang on the Reactive Manifesto[3]; and
• Up And Out Scaling Software With Akka - Jonas Bonér[4]

To read on-line:

• The Reactive Manifesto[5]; and
• Learn You Some Erlang for great good![6];

The actor model makes it easier to reason about distributed programming. All MPI directives will be packed up in a set of well defined modules. Communication among actors takes place through clear and standard interfaces with well defined behaviors. This software architecture is proven to provide scalability, resilience and responsiveness. There is no central management and no points of synchronism so actors just react to events; this is a simpler way of reasoning about concurrency and parallelism.

According to Carl Hewitts' definition (Carl Hewitt; Peter Bishop; Richard Steiger (1973). A Universal Modular Actor Formalism for Artificial Intelligence. IJCAI) an actor is the fundamental unit of computation that embodies:

• processing (the behavior, the executable code);
• storage (its the state, the stuff on the heap, memory); and
• communication.

When an actor recieves a message it reacts:

• sending messages to actors it knows (finite number);
• creating new actors (finite number); and
• designating how it should handle the next message it receives (changing state).

Here a Fortran implementation of the Actor Model is discussed.

Relevance of the Actor Model for the Mohid system

Mohid is a large system with complex memory management. With the comodization of multi-core machines and access to fast local networks MPI is becoming the de facto way of running Mohid. MPI (Message Passing Interface) is a very powerfull, standardized and portable message-passing system.

The way MPI is currently used in Mohid is difficult to implement, hard to understand and complex to maintain. It is essential to use MPI in such a way that it becomes easier to reason about:

• standardizing MPI's implementation in Mohid, embedding it in the programming framework;
• making explicit conventions on MPI usage of Mohid, for instance banning the use of semaphores and barriers;
• there will be a very limited number of modules where MPI directives are allowed; and
• MPI will be used to create explicit APIs (Application Programming Interface) that can be easily expanded and refactored according to Mohid's needs.

Actor Model in Mohid

Suppose a domain is decomposed in 3 sub-domains according to the first image. Each sub-dmain is an actor that sends messages to other actors and reacts to messages it receives. Each model has a Main Loop that progresses in time-steps. Each model sends messages with information (for example border conditions) to actors that need it.

Lets take a look at the system in a moment all actors are computing the next time-step. Is is non-determined which actor will terminate first (even if we know each one work load, it is impossible to know when they will terminate their computations). Even while computing they are checking their mailboxes because there are messages they can react to (for instance if they are asked if their run has ended or not). Messages they can not process stay in the queue. Messages are not processed in the order of arrival.

There is no need for a centralized controller, each actor has a state and reacts to the environment as a living organism. Inconsistencies or partial failures should be resolved in another layer, for instance with the help of supervisors (this is Erlang/OTP strategy).

Suppose Actor MW3 is the first actor to terminate its timestep. It sends messages to other actors with border conditions. MW3 has no messages in its mailbox so it is idle. Actor MW2 has a message in its mailbox but it can not process it yet so the message stays there.

MW3 will react when a message arrives to its mailbox. When it gathers enough information to strat a new time-step it will react triggering some computations. There is no central authority ordering it to start, stay idle, etc.

Now actor MW2 has terminated time-step computations. It now sends 2 different messages to MW1 and MW3 respectively. MW2 is checking its message box's queue but it has not enough information to start a new time-step so it stays idle.

MW1 received a message form MW2 and will react accordingly.

MW1 terminated the time-step. Meanwhile MW3 processed message M3 and is already computing the next time-step.

MW1 sends a message to MW2 and both actors have enough information to proceed (reacting to messages).

All actors are computing a new timestep

Notes on the Actor Model

There are some remarks to be done:

• each message is sent only once;
• the sender does not verify if the message reaches its destination;
• the order of arrival is independent of the order of sending;
• each message is processed separately;
• there is no central point of control; and
• messages in mailbox are not processed in the order of arrival, there is a loop over the queue checking which messages the actor can react upon.