Using the π-calculus. Evolution. Values As Names 3/24/2004

Transcription

1 3/4/004 Using the π-calculus Overview Evolution Values as names Boolean values as processes Executor, a simple object model, lists The polyadic π-calculus Mobile telephones Processes as parameters A concurrent programming language References Robin Milner, Communicating and Mobil Systems Robin Milner, Joachim Parrow, David Walker, A Calculus of Mobile Processes, Part I+II 7 Evolution x y x(u).u x can evolve to y x or x y z ν x(x y x(u).u ) x can evolve to y x x y!x(u).u x can evolve to x y!x(u).u z or y!x(u).u x and y!x(u).u z 7 Values As Names If the values with which we wish to compute are drawn from a finite set, say V {v,, v n}, then we can simply designate n names to denote these values as constants (e.g. v to stand for v,, v n to stand for v n). For example, consider the case V {t, f}, the truth values. We set t T and f F. The match operator can be used to control computation. For example, the following process can be thought of as a C# switch-statement: x(y).([y v ]π.p + [y v ]π.p + [y v 3]π 3.P 3) 73

2 3/4/004 Abbreviations Sometimes a communication does not need to carry a parameter. To model this we presuppose a special name, say ε, which is never bound. Then we write x.p in place of xε.p x.p in place of x(y).p if y fn(p) We often omit.0 in a process, and write for example xy in place of x y Boolean Values As Processes We can represent Boolean values by the processes True a and False a emitting Boolean values along channel a, and a process Case a(p, Q), receiving a Boolean along channel a and enacting P or Q depending on the value of the Boolean. Truea Falsea Case (P, Q) a a(x).a(y).x a(x).a(y).y ( ν x y)ax.ay.(x.p y.q) Now Case (P, Q) True evolves to (ν x y)(x.p y.q x), which in a a turn evolves to P (up-to structural congruence). 75 Executor Consider the following process definition Exec(x) x(y).y Exec(x) may be called an executor. It receives via channel x a link, called y, and then activates that link. We can think of y as a trigger of a process. Now for any process P, we obtain the same behavior in each of the following cases: We run P directly, We prefix a trigger z to P, and pass z along the channel x to the executor Exec(x) assuming that x, z fn(p): ν z (xz z.p) 76

3 3/4/004 Exec Example ν x ( ν z (xz z.p) Exec(x)) ν x ( ν z (xz z.p) x(y).y) ν x z (xz z.p x(y).y) τ.ν x z (0 z.p z) τ.τ.ν x z (0 P 0) τ.τ. P 77 An Simple Object Model A concurrent system can be thought of as a process community that appears to be an unstructured collection of autonomous agent. In practice, however, we can identify a structure. In particular, we can identify process group boundaries and communications across group boundaries. ReferenceCell is a process group that represents an object with one private instance variable and two public methods to set and to access the object s state. ReferenceCell ( ν v) ( v0!s(n).s(r).v(_).(vn r)!g(r).v(i).(vi ri) ) 78 A List A list is either Nil or Cons of value and a list. v h Node l The constant Nil, the construction Cons( V, L), and a list of n values are defined as follows: Nil h Cons(V, L) [V,...V ] n h!h(n).h(c).n ( ν v l)(!h(n).h(c).cv.cl V L l ) Cons(V, Cons(..., Cons(V, Nil)...)) n 79 3

4 3/4/004 [, ] [, ] Cons(, Cons(, Nil)) Cons(, Nil) ( ν v l)(!h(n).h(c).cv.cl Nil l ) ( ν v l)(!h(n).h(c).cv.cl (!l(n).l(c).n)) Cons(, []) ( ν v' l')(!h(n).h(c).cv'.cl' v' [] l' ) ( ν v' l')(!h(n).h(c).cv'.cl' v' (( ν v l)!l'(n).l'(c).cv.cl (!l(n).l(c).n))) with V!v(r).rV 80 Head, Tail, and IsEmpty Nil h Cons(V, L) h [V,...V ] n!h(n).h(c).n ( ν v l)(!h(n).h(c).cv.cl V L l ) Cons(V, Cons(..., Cons(V, Nil)...)) n Head(r) (ν n, c)(hn.hc.c(v).c(l).vr) Tail(r) (ν n, c)(hn.hc.c(v).c(l).lr) IsEmpty ( ν n, c)(hn.hc.n."yes" + c."no") 8 List Experiments IsEmpty(r) Nil h ( ν n, c)(hn.hc.n."yes" + c."no") h(n).h(c).n evolves to ( ν n, c)(n."yes" + c."no" n) which evolves to "Yes" Head(r) [, ] ( ν v l)(hn.hc.c(v)c(l).vr) ( ν v' l')(!h(n).h(c).cv'.cl' v' [ '] l' ) Evolves to( ν v l v')(v' r) [, ] h!v'(r).r) which evolves to r 8 4

5 3/4/004 The Polyadic π-calculus In the monadic π-calculus, an interaction involves the transmission of a single name from one process process to another, A natural and convenient extension is to admit processes that pass tuples of names. The processes of the polyadic π-calculus are defined in the same way as the processes of the monadic π-calculus, except that the prefixes are given by π :: x y x(z) τ [x y] π where no name occurs more than once in the tuple z in an input prefix. We write x for the length of the tuple x. If the length of the corresponding tuple is zero then we write x for x( z) and x for x y. 83 Polyadic Interaction The intended interpretations of the new polyadic prefixes are that x y.p can send the tuple y via x and continue as P, and that x( z).q can receive a tuple y via x and continue as { y/z }Q. The reaction relation over P πp contains exactly those transition that can be inferred from the rules in the following table: TAU : τ.p + M P P z y -INTER : (x( z ).P + M) (x y.q + N) {y/ z }P Q P P' PAR : P Q P' Q P P' RES : ν a P ν a P' P STRUCT : Q P P' P' Q' Q Q' 84 Church s Encoding of Booleans We can represent a Boolean value as a channel along we send/receive two other channels for the next true and false interaction. We define two processes True and False that serve as a process representation of their corresponding Boolean values. Both processes create a new channel b that serves as the location of the Boolean value and return b along the result channel r. True(b) False(b) Not(b, c) b(t, f).t b(t, f).f b(t, f).c(f, t) 85 5

6 3/4/004 Mobile Telephones CAR(talk, switch ) talk switch BASE IDLEBASE alert alert give PROVIDER give 86 System Equation CAR(talk, switch) talk switch BASE IDLEBASE alert alert give PROVIDER give SYSTEM (ν talk i, switch i, give i, alert i : i,) (CAR(talk, switch ) BASE IDLEBASE PROVIDER ) 87 Car A car is parametric upon a talk channel and a switch channel. On the talk channel it can repeatedly talk, but at any time it may receive along the switch channel two new channels, which the car must then start to use (new base station): CAR(talk, switch) talk.car(talk, switch) + switch(talk, switch ).CAR(talk, switch ) 88 6

7 3/4/004 Base A BASE can repeatedly talk with the CAR; but at any time it can receive along its give channel two new channels, which it should communicate to the CAR, and then become idle itself: BASE(t, s, g, a) t.base(t, s, g, a) + g(t', s').s t', s'.idlebase(t, s, g, a) An IDLEBASE may be told along its alert channel to become active: IDLEBASE(t, s, g, a) a.base(t, s, g, a) 89 Provider The PROVIDER knows initially that the CAR is in contact with BASE. It can decide (according to a provider-specific protocol) to transmit the channel talk and switch to the CAR via BASE, and alert IDLEBASE of this fact: PROVIDER give. talk, switch.alert.provider PROVIDER give. talk, switch.alert.provider 90 Evolving System SYSTEM CAR(talk, switch ) BASE IDLEBASE PROVIDER CAR(talk, switch ) switch talk, switch.ildebase IDLEBASE alert.provider CAR(talk, switch ) ILDEBASE ILDEBASE alert.provider CAR(talk, switch ) ILDEBASE BASE PROVIDER SYSTEM 9 7

8 3/4/004 New System CAR(talk, switch ) talk switch IDLEBASE BASE alert alert give PROVIDER give 9 Passing Processes As Parameters Passing processes as parameters is not represented directly in the π-calculus. In a direct representation we would write something like ν x(xp x(p).p) where p is a variable over processes, and P is a process expression. 93 Scope Suppose a direct representation of process parameters is given. We can extend our example as follows: The sender, after sending P, whishes to run Q; The receiver (or executor), after receiving P, whishes to run it in parallel with R. We would write ν x(xp.q x(p).(p R)) where we assume that x fn(p, Q, R). A suitable generalized expansion law would equate this to τ.(q (P R)) 94 8

9 3/4/004 Shared Private Name We can further extend our example by assuming that prior to the transmission of P there exists a restricted channel w between P and Q. ν x(ν w(xp.q) x(p).(p R)) We have two alternatives for how the transmission of P should treat the private channel w : Dynamic binding: τ.(ν w Q (P R)) That is, the private link between P and Q is broken and the meaning of w is defined with respect to its current scope. Static binding: τ.ν w'({w' /w}q ({w'/w}p R)) We use a form a scope extrusion where w is a fresh name, that is w fn(p, Q, R). 95 Modeling Process Parameters We start with the following process expression and replace it with ν x(ν w(xp.q) x(p).(p R)) ν x(ν z w(xz.(z.p Q)) x(y).y.r) where y, z fn(r), which by expansion, is equal to τ.ν z ( ν w(z.p Q)) z.r) Now we change to bound name w to w fn(r) and obtain τ.ν z w'({w'/w}z.p {w'/w}q z.r) which, by expansion and then the discard of the restriction becomes τ.τ.(ν w'({w'/w}p {w'/w}q R) 96 A Concurrent Language V :: X Y Variable F :: Function symbols C :: V E Assignment C ; C Sequential Composition if E then C else C Conditional Statement while E do C While Statement let D in C end Declaration C par C Parallel Composition input V Input output E Output skip D :: var V Variable Declaration E :: V Variable Expression F( E,, E n ) Function Call 97 9

10 3/4/004 Ambiguous Meaning X 0; X X + par X X + What is the value of X at the end of the second statement? 98 Basic Elements We assume that each element of the source language is assigned a process expression. Variables: X(init) ( ν v, setx, getx) ( v init!setx(n, r).v.(v n r)!getx(r).v(i).(v i r i ) ) Skip: C ; C : done ν c({c/done} C c.c ) C par C : ( ν l, r, t)( true {l/done}c {r/done}c t (l.t(b).( if b then r. skip else l t false ) (r.t(b).( if b then l. skip else r t false )) 99 Expressions [X] F(E,,E n ) (ν ack)(getx(ack) ack(v).res(v)) arg (x )...arg (x ).F(x,..., xn, res) n n [F(E,,E n )] (ν arg,,arg n )( {arg /res}[e ]{arg /res} {arg n /res}[e n ] [F] ) 00 0

11 3/4/004 Operation Sequence X 0; X X + par X X + What is the value of X at the end of the second statement? According to the former definitions the value of X is either,, or 3. The three values are possible since every atomic action can occur in an arbitrary and meshed order. To guarantee a specific result (e.g., or ), we need to employ semaphores. 0