• date post

14-Jan-2017
• Category

## Technology

• view

1.220

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>:

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!

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)

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