Distributed systems vs compositionality

Click here to load reader

  • date post

    14-Jan-2017
  • Category

    Technology

  • view

    1.220
  • download

    0

Embed Size (px)

Transcript of Distributed systems vs compositionality

  • Distributed Systems vs.

    CompositionalityDr. Roland Kuhn

    @rolandkuhn CTO of Actyx

  • Caveat:

    This presentation shows unreleased APIs!

  • Weird starting point:

    calculus

  • What is a calculus?

    syntax for writing down a computation

    reduction rules for evaluating the syntax

    4

  • calculus: the syntax

    5

    Robin Milner et al, 1992

    ::=

    8>:

    x(y) receive y along x

    xhyi send y along x unobservable action

    (1)

    P ::=

    X

    i2Ii.Pi

    P1|P2 new aP

    !P 0 (2)

  • calculus: the reductions

    6

    TAU : .P +M ! P (3)

    REACT :

    x(y).P +M

    xhzi.Q+N

    !

    z/y P

    Q (4)

    PAR :

    P ! P 0

    P |Q! P 0|Q (5)

    RES :

    P ! P 0

    newxP ! newxP 0 (6)

    STRUCT :

    P ! P 0

    Q! Q0 if P Q ^ P0 Q0 (7)

    2

    Robin Milner et al, 1992

  • An example reduction

    7

    P = new z

    (xhyi.0 + z(w).whyi.0)

    x(u).uhvi.0 xhzi.0

    possibility1

    possibility2

  • An example reduction

    8

    P = new z

    0

    yhvi.0 xhzi.0

  • An example reduction

    9

    P = new z

    (xhyi.0 + z(w).whyi.0)

    x(u).uhvi.0 xhzi.0

    possibility2

  • An example reduction

    10

    P = new z

    (xhyi.0 + z(w).whyi.0)

    zhvi.0 0

    onlyonepossibility

  • An example reduction

    11

    P = new z

    vhyi.0

    0 0

  • An example reduction

    12

    P = vhyi.0

  • Theres more!

    structural congruence allows symbolic manipulation rename, reorder sums, expand recursion,

    bi-simulation describes functional equivalence

    13

  • So, what is a calculus?

    a way to write down computations

    a means to reason about computations

    a tool to compose computations

    14

  • Composition

  • Composition in the calculus

    you can run computations sequentially

    run computations concurrently

    synchronize concurrent computations

    16

  • Composing processes

    17

    new cA

    Pclient

    PserviceA

    channelwhereserviceAisreachable

    willsendtocAandeventuallyreactto

    response

    willreacttocAandeventuallysendbackaresponse

  • We need protocols!

  • What is a protocol?

    defines a communication discipline: who can send what kind of message, and when

    which kinds of message to expect, and when

    each distributed process must adhere to the common protocol

    a global protocol can be checked for safety

    19

  • Session types

    Session: a unit of conversation

    Session Type: the structure of a conversation,a sequence of interactions in acommunication-centric program model

    originally only binary sessions,multiparty session types introduced 2008

    primitives aresending, receiving, sequence, choice, recursion

    20

    http://groups.inf.ed.ac.uk/abcd/

    http://groups.inf.ed.ac.uk/abcd/

  • Session types example

    21

    Sreqresp = !Request(params) . ?Response(result) (8)

    Sreqresp = ?Request(params) . !Response(result) (9)

  • But is it safe? Does it compose?

    22

    Pclient PserviceA PbackendA

    PserviceB PbackendB

  • Protocols dont compose!

    at least not in general, as far as we know

    some cases are (mostly?) okay non-cyclic

    non-interacting

    what a bummer! lets find a smaller problem to solve

    23

  • Composing Actor Behavior

  • Behavior composition

    25

    new cinternal

    PserviceA

    PclientB

  • 26

    case class DoStuff(stuff: Stuff) case class DoIt(it: It) case class DoneSuccessfully(result: Result)

    class MyActor(receptionist: ActorRef) extends Actor {

    override def preStart(): Unit = receptionist ! Register def receive = initializing

    def initializing: Receive = { case Registered => // do stuff context.become(running) }

    def running: Receive = { case DoStuff(stuff) => context.actorOf(Props[Child]) ! DoIt(???) context.become(waitingForResult(stuff)) }

    def waitingForResult(stuff: Stuff): Receive = { case DoneSuccessfully(result) => // do stuff, e.g. replying context.become(running) } }

  • We need reusable composable behavior snippets!

  • Radical idea: calculus within!

    idea sparked while listening to Alex Prokopec

    create DSL inspired by calculus lifted representation of asynchronous actions

    combinators for sequential & parallel composition

    28

  • What does it look like?

    29

    calculus Akka Typed Sessions

    new c P val serverChannel = channel[Command](128)

    P initialize: Process[ActorRef[Request]]

    .P for { backend initialize server register(backend)} yield run(server, backend)

    P|Q fork(task): Process[Unit]read(serverChannel) race timeout(1.second)getThingA join getThingB

    x(y) read(serverChannel): Process[Command]

    xy serverChannel.ref ! msg(synchronous send operation not there, yet)

  • Example of a Server Process

    30

    def run(server: Channel[ServerCommand], backend: ActorRef[BackendCommand]) : Process[Nothing] = for { cmd read(server) } yield cmd match { case GetIt(which, replyTo) => val spinOff = talkWithBackend(which, backend) .foreach(thing => replyTo ! GotIt(thing.weird)) fork(spinOff race timeout(5.seconds)) .then(run(server, backend)) }

  • Example of a Server Process

    31

    def talkWithBackend(which: String, backend: ActorRef[BackendCommand]) : Process[TheThing] = { val code = channel[Code](1) val thing = channel[TheThing](1) backend ! GetThingCode(0xdeadbeefcafeL, code.ref) for { c readAndSeal(code) } yield { c.magicChest ! GetTheThing(which, thing.ref) readAndSeal(thing) }}

  • What does this have to do with Akka?

    Akka Typed Behavior to interpret Process

    channel reference is a lean child ActorRef

    this closes the gap between the Actor Model and CSP/ Actors have stable identity but only one channel

    anonymous Processes have multiple channels(with identity)

    32

  • Outlook

  • Tracking effects

    lifted representation of Process allows tracking of effects

    embedding of session type in calculus exists

    verify Process against a session type

    34

  • Irresponsible Speculation

    35

    // Effects is similar to HList (but a tree) trait Process[T, E

  • Current State

    behaviors can be composed both sequentially and concurrently

    effects are not yet tracked

    Scribble generator for Scala not yet there

    theoretical work at Imperial College, London(Prof. Nobuko Yoshida & Alceste Scalas)

    36

  • Actyx AG 2016 All Rights Reserved