Actor Languages

Download Actor Languages

Post on 21-Jan-2016




0 download

Embed Size (px)


Actor Languages. Maher Motivation Actor Actor system Bill Communication mechanism Structure of Actor languages Act s syntax and examples Actor-based languages Jack SALSA Mobile Agent Conclusion. Actor Languages. Maher Shinouda Objectives. Motivation - PowerPoint PPT Presentation


  • Actor Languages

    MaherMotivationActorActor systemBillCommunication mechanismStructure of Actor languagesActs syntax and examplesActor-based languagesJackSALSAMobile AgentConclusion

  • Actor Languages


  • ObjectivesMotivationBrief historyWhat are actorsCharacteristics of actor-based languagesActor communicationEvents in actor languagesActor systemActors behaviorSimple ExampleActors VS Linda

  • MotivationDevelop language for concurrency Parallel Execution of actions.

    Concurrency in distributed systems exhibits:

    DivergenceDeadlockMutual Exclusion

  • Brief HistoryA number of individuals have contributed to the development of the actor model.

    Actor model was first described by Carl Hewitt (70s)The model was object-oriented: every object was a computationally active entity capable of receiving and reacting to messages. The Objects were called Actors.

    Gul Agha, later develop the actor model and develop a mathematical theory of actors.

    Actor languages can all trace its ancestor either directly or indirectly to Lisp.

  • What are Actors

    Actors are independent concurrent objects that interact by sending asynchronous messages; each actor has its mail address and a behavior.

    An actor can do the following: Send communication to other actors.Create new actors. Define a new behaviour for itself, which may be the same or different to its previous behaviour.

  • Three actions an actor may perform

  • What are ActorsAnatomy of Actor

  • Characteristics of Actor-based languageEncapsulation

    All procedures and declarative information are encapsulated into a single entity Actor.

    Actors share the main characteristics of objects in Simula and Smalltalk.

    Actors considered to be Autonomous objects.

  • Characteristics of Actor-based language (Cont.)Inheritance

    In OOP, Each object is related to a class and further more the class may be an object belonging to meta-class.

    The notion of class is not integral to the actor model.

    Inheritance in actors provide a conceptual organization of the system which is dynamically reconfigurable.

  • Characteristics of Actor-based language (Cont.)Delegation

    Sub-computation can be passed on by an actor to another actor which continue the processing.Delegation promote modularity of the code.


    Actor language allow actors to specify a replacement which has 2 implications:

    Capture history-sensitive information.Allow for concurrent execution of expressions that dont involve data dependency.

  • Actor Communication

    Actor communicate using message passing only.All communication is asynchronous.Each Actor has mail address with mail queue.

    An actor may know the mail address because:

    It has always know the address.It received the address within a communication from another actor.It created the address as part of creating another actor.

  • Actor communication (cont.)A message (Task) is represented as 3 tuples:

    1- A tag which distinguish it from other tasks in the system.

    2- A target which is the mail address to which the communication is to be delivered.

    3- A communication which contain information which made available to the actor at the target.

  • ActorActor = ComponentAn actor is a special type of object that: Communicates with other actors by sending and receiving data via the mail address.No shared state between actors.

    An actor may be described by specifying:

    Its mail address with sufficiently large mail queue.Behavior, which is a function of the communication accepted.

  • EventWhat is event?

    An event cause a communication to be sent; or represent the processing of the communication.

    Arrival order of events is nondeterministic.

    Actor computation may be represented by event diagram.

  • Event Diagram

  • Actor SystemGroup of actors within it and the set of tasks to be carried out.Two types of special actors needed:

    A receptionist: An actor which mayreceive communication from outsidethe system.

    An external actor: Is one which is not in the system but its address is known to one or more actors within the system, allowing them to send communication.

  • The basic constructs

    A program in an actor language consists of:

    behavior definitions: which simply associate a behavior schema with an identifier.

    new expressions: which create actors.

    Send commands: which create tasks.

  • The basic constructs (cont.)

    A receptionist declaration: which lists actors that may receive communications from the outside.

    An external declaration: which lists actors that are not part of the system but to whom communications may be sent from the system.

  • Actors behaviorThe behavior of actor consists of three kind of actions:

    Create actors with specified behavior.::= new ({expr{, expr}*})

    Send message asynchronously to specified actor. ::= send to

    Become a new actor, assuming a new behavior to respond to the next message.become

  • Actor System (cont.)Two important facts about mail system in the actor system:

    Mail arrives in random, non deterministic order (asynchronous).Ensures concurrent execution.

    The mail delivery is guaranteed.The system guarantee to execute all tasks eventually.

  • Simple Example

    actor AdderAndMutlipy (Double k) Double A, Double B ==> Double C:

    action [a], [b] ==> [c] with Double c: c:=k*(a+b): endaction endactor

  • Another Exampleactor AdderAndMutlipy2[T] (T k) T A, T B ==> T C:

    action [a], [b] ==> [k*(a+b)]: endaction action [a], [] ==> [k*a]: endaction action [], [b] ==> [k*b]: endaction endactor

  • Actors VS LindaProvide point-to-point communication and object-style encapsulation.

    The locality property in actor: there is no way for an actor to contact other actors whose name hasnt received in a previous communication.

    Actors are components.Provide pattern directed invocation

    Decoupled in both space and time: Information may be available so that any one can potentially access it.

    Linda doesnt include the notion of component directly; nevertheless, the Tuple Space that it defines can be viewed as a generic connection component.

  • ManifoldInter-process communication in MANIFOLD is asynchronous, using broadcast of events and a dynamic data-flow.

  • Actor LanguagesCommunication mechanismsStructure of Actor LanguagesKernel language Act Actor-based languages

    Lehui (Bill) Nie @ UW

  • Communication mechanismsActors are active objects which communicate by message passing Asynchronous buffered communication It's hard to imagine a reasonable system built on asynchronous, unbuffered communication. Too much would get lost.

  • Communication mechanisms Communication is asynchronous, without any guaranteed arrival order. Message order: if actor A sends a sequence of communications to actor B, then B may not receive them in the same order that A sent them.

    It is possible for A to tag each message with a sequence number, so that B may rearrange messages into the correct order.

  • Communication mechanisms Shared variables are not allowed in the actor model. Shared variables means that they provide data transfer without any coordination mechanism or concurrency control. Variables sharing further complicates distribution and synchronization.

    Latency and timing issues make it awkward to use shared variables in an asynchronous environment.

  • The Structure of Actor Languages

  • Control structure: recursive factorial computationWhen actor factorial receives 3 and mail address c, it creates anew actor m, and sends itself therequest to evaluate the factorial of 2

    When actor m receives a result, m multiplies 3 and the resultand send to c

    There is nothing inherently concurrent in the recursive algorithmto evaluate a factorial.

  • ComparisonSequential languageUsing a stack of activations.No mechanism for distributing the work of computing a factorial or concurrently processing more than one request.

    Actor-based languageCreating actors which waits for the appropriate communications. They are free to concurrently process the next communication.Delegating most of the processing to a large number of actors.Given a network of processors, an actor-based language could process a large number of requests much faster by simply distributing the actors it creates among these processors.

  • Join continuations: tree product Divide and conquer concurrency can often be naturally expressed by using a functional form which evaluates its arguments concurrently. Join continuation is used to synchronize the evaluation of the different arguments.

  • Tree product event diagram

  • Language Act Act is a sufficient kernel for Act3Syntax ::= * (*) ::= (define (id {(with identifier )}*) *) ::= (Is-communication do *)

  • Language Act ::= | | | ::= (let (*) do *) ::= (if (then do *) (else do *)) ::= (send ) ::= (become )

  • Example: Factorialc

  • Actor-based languages

  • Actor-based languages

  • Actor-Based Concurrent Language(ABCL)Message sending order from one object to another is preserved in ABCL.Three types of message passing mechanismsPastNon-blocking messages without a replyNowBlocking messages with sender waiting for a replyFutureNon-blocking messages with a reply expected in the future

  • Concurrent Aggregates (C