Programming Paradigms for Concurrency

1. Programming Paradigms for Concurrency Lecture 11 Part III – Message Passing Concurrency TexPoint fonts used in EMF. Read the TexPoint manual before you delete this box.: AAAAAAAAAAAAA

2. Formal Semantics for MP Programs:The ¼-Calculus

3. The ¼-Calculus • developed by Milner, Parrow, and Walker in the early 1990’s as a generalization of value-passing CCS. • provides computational model for concurrent and mobile systems • many applications: formal models for • Message passing programs • Web services • Business Processes • Security protocols • Biological systems

4. Reading Material Introductory Reading: • Communication and Mobile Systems: the ¼-calculus. Milner, Cambridge University Press, 1999 Advanced Reading: • The ¼-calculus: a Theory of Mobile Processes. Sangiorigi and Walker, Cambridge University Press, 2003. • A Calculus of Mobile Processes, Parts I and II. Milner, Parrow, and Walker, Information and Computation 100:1, 1992.

5. Ping Pong Actors Pong Ping Msg sender

6. Ping Pong Actors Pong Ping Msg Msg sender

7. Ping Pong Actors sender Pong Ping Msg

8. Ping Pong Actors in Scala valpingTd = actor { loop { react { caseMsg(sender) => sender ! Msg(self) } } } valpongTd = actor { loop { react { caseMsg(sender) => sender ! Msg(self) } } } valinitTd = actor { pongTd ! Msg(pingTd) } pingTd.start; pongTd.start; initTd.start

9. Ping Pong Actors in CML datatypemsg = MSG of msgchan funpongTd (pong : msgchan) = case recv pong of MSG(sender) => send (sender, MSG(pong)); pongTd (pong) end funpingTd (ping : msgchan) = case recv ping of MSG(sender) => send (sender, MSG(ping)); pongTd (ping) end fun initTd (ping, pong) = send(pong, MSG(ping))

10. Ping Pong Actors in CML let val ping = channel () valpong = channel () in spawn (fn () => initTd(ping, pong)); spawn (fn () => pingTd(ping)); spawn (fn () => pongTd(pong)) end

11. Ping Pong Actors in the ¼-calculus behavior of threads is defined by parametric equations of process IDs and process terms equations can be (mutually) recursive system is given by a process term referring to the defined process IDs

12. Ping Pong Actors in the ¼-calculus funpongTd (pong : msgchan) = case recv pong of MSG(sender) => send (sender, MSG(pong)); pongTd (pong) end receive channel on pong and bind it to sender

13. Ping Pong Actors in the ¼-calculus funpongTd (pong : msgchan) = case recv pong of MSG(sender) => send (sender, MSG(pong)); pongTd (pong) end send pong back on sender

14. Ping Pong Actors in the ¼-calculus funpongTd (pong : msgchan) = case recv pong of MSG(sender) => send (sender, MSG(pong)); pongTd (pong) end and recurse

15. Ping Pong Actors in the ¼-calculus let val ping = channel () valpong = channel () in spawn (fn () => initTd(ping, pong)); spawn (fn () => pongTd(pong)); spawn (fn () => pingTd(ping)) end create two fresh private channels and bind them to ping and pong pronounced “new”

16. Ping Pong Actors in the ¼-calculus let val ping = channel () valpong = channel () in spawn (fn () => initTd(ping, pong)); spawn (fn () => pongTd(pong)); spawn (fn () => pingTd(ping)) end spawn all threads

17. Ping Pong Actors in the ¼-calculus

18. The ¼-Calculus • There exist many different variants of the ¼-calculus using different notations and slightly different semantics. • We use one particular variant and stick to it.

19. Names In the ¼-calculus channels are called names. Names serve both as communication channels and as the data that is sent when threads synchronize. We assume an infinite set of names:

20. Syntax of Process Terms nil process (termination) parallel composition of P and Q nondeterministic choice between P and Q generation of fresh name x with scope P reception of y on x with continuation P sending of y on x with continuation P replication of P restriction input prefix output prefix Notational conventions:

21. Bound and Free Names Restriction and input prefix bind names in a process term. Occurrences of names in a process term that are not bound are called free. The function fn returns the set of free names of a process term: If fn(P ) = ; then P is called closed.

22. ®-Equivalence We consider process terms P and Q equivalent if they are equal up to consistent renaming of bound names (denoted by P´®Q) For example: Can we replace x with z? But we have

23. Name Substitution We write P [y/x] for the process obtained from P by replacing all free occurrences of name x by name y. We call [y/x] a name substitution. Substitutions use implicit ®-renaming to avoid capturing of free occurrences of names. For instance: We write [y1,…,yn/x1,…,xn] for [y1/x1]…[yn/xn]

24. Labeled Transition System A labeled transition system (LTS) is a tupleM =hS, L, !, Iiwith S a nonempty set of states L a nonempty set of labels I µS the set of initial states !µS£L£S the transition relation For a transition we write

25. Executions and Traces An execution± of an LTS M =hS, L, !, Ii is a sequence of consecutive transitions starting in an initial state s02I If ± is finite then its final state sf has no outgoing transitions. A trace¾ is the projection of an execution to its labels We denote by Traces(M) the set of all traces of M.

26. Semantics of Process Terms The semantics of a process term P is defined operationally by associating a labeled transition system MP with P. • MP captures the behavior of P in all possible process contexts. • the initial state of MP is P itself • the states of MP are process terms describing the continuations of partial executions • the transition relation is defined in terms of transition rules that capture synchronization between threads • the labels of MP are actions that encode whether a process synchronizes internally or with the environment

27. Structural Congruence The behavior of two ®-equivalent processes P and Q should be indistinguishable, i.e., ´® should be a congruence for the transition relation: There are other such structural equivalences. For instance, one would expect that the following processes behave equally: P | Q and Q | P We capture all these cases in a structural congruence relation´.

28. Structural Congruence Rules

29. Structural Congruence Rules (cont’d)

30. Structural Congruence Example

31. Actions Transitions of process terms are labeled with actions. Actions describe what kind of synchronization the process term performed. Actions:

32. Silent Action means P synchronizes internally resulting in Q Example:

33. Input Action means P can receive a w over x resulting in Q[w/y] Example:

34. Free Output Action means P can send the free (i.e., publicly known) name y over x to the environment, resulting in Q Example: note that there is also a silent action possible:

35. Bound Output Action means P can send the bound name y over x to the environment, resulting in Q (i.e., y is leaked to the environment and no longer private to P) Example: again there is an alternative silent action possible:

36. Free and Bound Names of Actions We denote by n(®), fn(®), and bn(®) the names, free names, and bound names of action ®:

37. Transition Rules

38. Transition Rules (cont’d)

39. Example Execution

40. Ping Pong Actors in the ¼-calculus Can we express recursive equations in our calculus?

41. Polyadic¼-Calculus Multiple names can be communicated in one step

42. Monadic Encoding of Polyadic Calculus We can encode the polyadic calculus in the monadic one using serialization: for some fresh name z Why is the following encoding incorrect?

43. Encoding Recursive Equations Given a recursive definition of a process identifier A and a process term P that uses this definition. We can encode the behavior of A in P as follows: • choose a fresh name y not occuring in P or Q • let Py and Qy be P and Q, where each occurrence of process identifier A is replaced by • replace P by

44. Monadic Ping Pong Actors

45. Outlook: Behavioral Equivalence PongTd(x) and PingTd(x) are ®-equivalent for all names x, so we can safely replace one by the other in any context. Next week: In general, when can we safely replace one process term by another one? They should surely have the same set of traces, but is that enough?