Hernán Melgratti joint work with Roberto Bruni and Ugo Montanari Dipartimento di Informatica - Università di Pisa Flat Committed Join in Join

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Join + primitives for negotiations Syntax: P,Q ::= 0 | x  ŷ  | def D in P | P|Q D,E ::= J  P | D  E J,K ::= x  ŷ  | J|K Processes Definitions Patterns

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Join + primitives for negotiations Syntax: M,N ::= 0 | x  ŷ  | M|N P,Q ::= 0 | x  ŷ  | def D in P | P|Q D,E ::= J  P | D  E J,K ::= x  ŷ  | J|K Processes Definitions Patterns Messages

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Join + primitives for negotiations Syntax: M,N ::= 0 | x  ŷ  | M|N P,Q ::= M | def D in P | P|Q D,E ::= J  P | D  E J,K ::= x  ŷ  | J|K Processes Definitions Patterns Messages

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Join + primitives for negotiations Syntax: M,N ::= 0 | x  ŷ  | M|N P,Q ::= M | def D in P | P|Q | abort | [P:Q] D,E ::= J  P | D  E | J  P J,K ::= x  ŷ  | J|K Processes Definitions Patterns Programmable abort Negotiation Compensation Merge definition Messages

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Operational Semantics (CHAM Style): 0  P|Q  P,Q DEDE  D,E def D in P  D  dn(D), P  dn(D) range(  ) fresh J  P, J   J  P, P  heating and cooling reaction

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Operational Semantics (CHAM Style): 0  P|Q  P,Q DEDE  D,E def D in P  D  dn(D), P  dn(D) range(  ) fresh J  P, J   J  P, P  [P:Q]  {[ P,   Q  ]} Contract P evolves in isolation Compensation Q is kept frozen

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Operational Semantics (CHAM Style): 0  P|Q  P,Q DEDE  D,E def D in P  D  dn(D), P  dn(D) range(  ) fresh J  P, J   J  P, P  [P:Q]  {[ P,   Q  ]} {[ M|def D in 0,   Q  ]}  M Global Resources Commit

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Operational Semantics (CHAM Style): 0  P|Q  P,Q DEDE  D,E def D in P  D  dn(D), P  dn(D) range(  ) fresh J  P, J   J  P, P  [P:Q]  {[ P,   Q  ]} {[ M|def D in 0,   Q  ]}  M {[ abort |P,   Q  ]}  Q Compensation on Abort

Workshop Finale Cometa – Dec, 2003 Committed Join (cJoin) Operational Semantics (CHAM Style): 0  P|Q  P,Q DEDE  D,E def D in P  D  dn(D), P  dn(D) range(  ) fresh J  P, J   J  P, P  [P:Q]  {[ P,   Q  ]} {[ M|def D in 0,   Q  ]}  M {[ abort |P,   Q  ]}  Q J 1 |…|J n  P,  i {[ J i , S i,   Q i  ]}  J 1 |…|J n  P, {[  i S i, P ,   i Q i  ]} Merge n ongoing contracts

Workshop Finale Cometa – Dec, 2003 Example: Mailing List ML  MailingList  k   MLDef

Workshop Finale Cometa – Dec, 2003 Example: Mailing List ML  MailingList  k   MLDef MLDef  def …  in k  add, tell, close  | lst  nil 

Workshop Finale Cometa – Dec, 2003 Example: Mailing List ML  MailingList  k   MLDef MLDef  def …  lst  y  | add  x   …  lst  y  | tell  v   …  lst  y  | close    … in k  add, tell, close  | lst  nil 

Workshop Finale Cometa – Dec, 2003 Example: Mailing List ML  MailingList  k   MLDef MLDef  def …  lst  y  | add  x   def z  v,w   x  v  | y  v,w  in lst  z   lst  y  | tell  v   …  lst  y  | close    … in k  add, tell, close  | lst  nil 

Workshop Finale Cometa – Dec, 2003 Example: Mailing List ML  MailingList  k   MLDef MLDef  def …  lst  y  | add  x   def z  v,w   x  v  | y  v,w  in lst  z   lst  y  | tell  v   [def w   0 in y  v,w  | lst  y  : lst  y  ]  lst  y  | close    … in k  add, tell, close  | lst  nil 

Workshop Finale Cometa – Dec, 2003 Example: Mailing List ML  MailingList  k   MLDef MLDef  def nil  v, w   0  lst  y  | add  x   def z  v,w   x  v  | y  v,w  in lst  z   lst  y  | tell  v   [def w   0 in y  v,w  | lst  y  : lst  y  ]  lst  y  | close    … in k  add, tell, close  | lst  nil 

Workshop Finale Cometa – Dec, 2003 Example: Mailing List ML  MailingList  k   MLDef MLDef  def nil  v, w   0  lst  y  | add  x   def z  v,w   x  v  | y  v,w  in lst  z   lst  y  | tell  v   [def w   0 in y  v,w  | lst  y  : lst  y  ]  lst  y  | close    0 in k  add, tell, close  | lst  nil 

Workshop Finale Cometa – Dec, 2003 Implementing flat cJoin Goal To implement cJoin in Join Key Points Distributed commit of interacting negotiations as a global decision Participants can join dynamically (participants statically unknown) First step Consider flat negotiations Use canonical form of processes Encode canonical flat cJoin processes as Join processes

Workshop Finale Cometa – Dec, 2003 Flat cJoin Negotiations cannot be nested Type system for cJoin Processes: P: 0, P does not contain [_:_] at all P: 1, P may contain [_:_] in the definitions P: 2, P may have and generate flat negotiations Join Processes have type 0 Subject Reduction holds for 0 and 2 Flat cJoin: The sub-calculus of all P: 2

Workshop Finale Cometa – Dec, 2003 Canonical Flat cJoin Inspired by the basic shapes of ZS nets Few elementary definition patterns Any flat process can be written in canonical form Open xŷ Pxŷ P & P: 2 & count(P) = 1 Ord-Mov xŷ Pxŷ P & P: 1 & count(P)  2 Merge-Mov xŷ  Pxŷ  P & P: 0 & count(P)  2 Ord-Join x  ŷ 1  | x  ŷ 2   P & P: 1 & count(P) = 1 Merge-Join x  ŷ 1  |…|x  ŷ n   P & P: 0 & count(P) = 1

Workshop Finale Cometa – Dec, 2003 Has type 2 Has count = 2 Canonical Form: Example def nil  v, w   0  lst  y  | add  x   def z  v,w   x  v  | y  v,w  in lst  z   lst  y  | tell  v   [def w   0 in y  v,w  | lst  y  : lst  y  ]  lst  y  | close    0 in k  add, tell, close  | lst  nil   lst  y  | tell  x   a  y,x   a  y,x   [def w   0 in y  v,w  | lst  y  : lst  y  ]  a  y,x   [def w   0 in def b  v,w,l,y   y  v,w  | l  y  in b  v,w,lst,y  : lst  y  ]

Workshop Finale Cometa – Dec, 2003 Encoding: Main Idea Any message in a negotiation runs in a thread, which is managed by a coordinator Coordinators perform a D2PC protocol [BLM2002]. A variant of the decentralized 2PC with a finite but unknown number of participants When a participant P is ready to commit it has only a partial knowledge of the whole set of participants Only those who directly cooperated with P To commit P must contact all its neighbors and learn the identity of other participants from them

Workshop Finale Cometa – Dec, 2003 Encoding: D2PC Every participant P acts as coordinator During the transaction P builds its own synchronization set L P of cooperating agents When P is ready to commit, P asks readiness to processes in L P (if empty P was isolated and can commit) In doing so, P sends them the set L P Other participants will send to P either a successful reply with their own synchronization sets or a failure message (in this case, failure is then propagated) Successful replies are added to L P The protocol terminates when L P is transitively closed

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0]

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] A negotiation with one thread

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D A negotiation with one thread A coordinator D to manage z  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation Compensation

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D  cmp   0 in state  {cmp}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation Compensation Set initial compensation

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D  cmp   0 in state  {cmp}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation z runs in a managed thread

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D  cmp   0 in state  {cmp}  | | def … p  l, ,  in z  put, abt, {lock}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation z carries the ports of its coordinator z runs in a managed thread

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D  cmp   0 in state  {cmp}  | | def … in z  put, abt, {lock}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation It consumes managed msgs

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D  cmp   0 in state  {cmp}  | | def z  p, a, l   … in z  put, abt, {lock}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation It consumes managed msgs z carries the ports of its coordinator

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D  cmp   0 in state  {cmp}  | | def z  p, a, l   … in z  put, abt, {lock}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation The thread ends

Workshop Finale Cometa – Dec, 2003 Encoding a negotiation [def z   0 in z  : 0] def D  cmp   0 in state  {cmp}  | | def z  p, a, l   p  l, ,  in z  put, abt, {lock}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation The thread ends D can commit

Workshop Finale Cometa – Dec, 2003 Encoding an abort [def z   abort in z  : 0] def D  cmp   0 in state  {cmp}  | | def z  p, a, l   … in z  put, abt, {lock}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation The thread aborts

Workshop Finale Cometa – Dec, 2003 Encoding an abort [def z   abort in z  : 0] def D  cmp   0 in state  {cmp}  | | def z  p, a, l   a  in z  put, abt, {lock}  put : to notify thread completion abt: to notify thread abortion lock: to receive partners’ confirmations state: to set the initial compensation The thread aborts D aborts

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x   y  |z 

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 x   y  |z 

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 in y  put 1, abt 1, l  {lock 1,lock 2 }  | z  put 2, abt 2, l  {lock 1,lock 2 }  x   y  |z 

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 in y  put 1, abt 1, l  {lock 1,lock 2 }  | z  put 2, abt 2, l  {lock 1,lock 2 }  | p  l  {lock 1,lock 2 }, {abt 1,abt 2 },  x   y  |z 

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 in y  put 1, abt 1, l  {lock 1,lock 2 }  | z  put 2, abt 2, l  {lock 1,lock 2 }  | p  l  {lock 1,lock 2 }, {abt 1,abt 2 },  | state 1  {a,abt 2 }  | state 2  {a,abt 1 }  x   y  |z 

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 in y  put 1, abt 1, l  {lock 1,lock 2 }  | z  put 2, abt 2, l  {lock 1,lock 2 }  | p  l  {lock 1,lock 2 }, {abt 1,abt 2 },  | state 1  {a,abt 2 }  | state 2  {a,abt 1 }  x   y  |z  x  |y   z 

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 in y  put 1, abt 1, l  {lock 1,lock 2 }  | z  put 2, abt 2, l  {lock 1,lock 2 }  | p  l  {lock 1,lock 2 }, {abt 1,abt 2 },  | state 1  {a,abt 2 }  | state 2  {a,abt 1 }  x   y  |z  y  p 2,a 2,l 2   def D x  |y   z  x  p 1,a 1,l 1  |

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 in y  put 1, abt 1, l  {lock 1,lock 2 }  | z  put 2, abt 2, l  {lock 1,lock 2 }  | p  l  {lock 1,lock 2 }, {abt 1,abt 2 },  | state 1  {a,abt 2 }  | state 2  {a,abt 1 }  x   y  |z  y  p 2,a 2,l 2   def D in z  put, abt 1, l 1  l 2  {lock}  x  |y   z  x  p 1,a 1,l 1  |

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 in y  put 1, abt 1, l  {lock 1,lock 2 }  | z  put 2, abt 2, l  {lock 1,lock 2 }  | p  l  {lock 1,lock 2 }, {abt 1,abt 2 },  | state 1  {a,abt 2 }  | state 2  {a,abt 1 }  x   y  |z  y  p 2,a 2,l 2   def D in z  put, abt 1, l 1  l 2  {lock}  | p 1  l 1  l 2  {lock}, {abt,a 2 },  | p 2  l 1  l 2  {lock}, {abt,a 1 },  x  |y   z  x  p 1,a 1,l 1  |

Workshop Finale Cometa – Dec, 2003 Encoding: Fork and Join x  p,a,l   def D 1  D 2 in y  put 1, abt 1, l  {lock 1,lock 2 }  | z  put 2, abt 2, l  {lock 1,lock 2 }  | p  l  {lock 1,lock 2 }, {abt 1,abt 2 },  | state 1  {a,abt 2 }  | state 2  {a,abt 1 }  x   y  |z  y  p 2,a 2,l 2   def D in z  put, abt 1, l 1  l 2  {lock}  | p 1  l 1  l 2  {lock}, {abt,a 2 },  | p 2  l 1  l 2  {lock}, {abt,a 1 },  | state  {a 1,a 2 }  x  |y   z  x  p 1,a 1,l 1  |

Workshop Finale Cometa – Dec, 2003 Encoding: Names [def z  x   x  x  in z  y  : 0]

Workshop Finale Cometa – Dec, 2003 Encoding: Names [def z  x   x  x  in z  y  : 0][def z  x   x  x  in y  y  : 0] 

Workshop Finale Cometa – Dec, 2003 Encoding: Names [def z  x   x  x  in z  y  : 0][def z  x   x  x  in y  y  : 0] **  [y  y  | def z  x   x  x  in 0: 0]

Workshop Finale Cometa – Dec, 2003 Encoding: Names [def z  x   x  x  in z  y  : 0][def z  x   x  x  in y  y  : 0] **  [y  y  | def z  x   x  x  in 0: 0]  yyyy

Workshop Finale Cometa – Dec, 2003 Encoding: Names [def z  x   x  x  in z  y  : 0][def z  x   x  x  in y  y  : 0] **  [y  y  | def z  x   x  x  in 0: 0]  yyyy [def z  x   x  x  in z  z  : 0]

Workshop Finale Cometa – Dec, 2003 Encoding: Names [def z  x   x  x  in z  y  : 0][def z  x   x  x  in y  y  : 0] **  [y  y  | def z  x   x  x  in 0: 0]  yyyy [def z  x   x  x  in z  z  : 0] 

Workshop Finale Cometa – Dec, 2003 Encoding: Names [def z  x   x  x  in z  y  : 0][def z  x   x  x  in y  y  : 0] **  [y  y  | def z  x   x  x  in 0: 0]  yyyy [def z  x   x  x  in z  z  : 0]    …

Workshop Finale Cometa – Dec, 2003 Encoding: Names [def z  x   x  x  in z  y  : 0][def z  x   x  x  in y  y  : 0] **  [y  y  | def z  x   x  x  in 0: 0]  yyyy Definitions have different behaviours depending on received names [def z  x   x  x  in z  z  : 0]    …

Workshop Finale Cometa – Dec, 2003 Encoding: Names A definition is encoded as several definitions: z  x   x  x  z s  x, p, a,l   p  l, , {x  x  }  z z  x, p, a,l   x  x, p, a, l 

Workshop Finale Cometa – Dec, 2003 Encoding: Names A definition is encoded as several definitions: The encoding function takes into account the scope of names: [[ _ ]] S,B z  x   x  x  z s  x, p, a,l   p  l, , {x  x  }  z z  x, p, a,l   x  x, p, a, l 

Workshop Finale Cometa – Dec, 2003 Encoding: Merge Names def b   … in [b  : 0] has two different behaviors: It can commit It can compute with the global reaction rule for b  Merge definitions are encoded with two rules One encoding the commit of the thread The other, the application of the rule inside a negotiation Moreover, the commit behavior is allowed only when parameters are global names

Workshop Finale Cometa – Dec, 2003 Correctness and Completeness Correctness P: 1 and canonical. If P  cJ * P’ with P: 1, then  Q s.t. [[P]] fn(P),   j * Q, and norm(Q)  [[P’]] fn(P’),  Completeness P: 1 and canonical. If [[P]] fn(P),   j * Q and norm(Q) is well-defined, then  P’ s.t. P  cJ P’, and norm(Q)  [[P’]] fn(P’), 

Workshop Finale Cometa – Dec, 2003 Concluding remarks Flat cJoin can be implemented in Join Commit is fully distributed This suggest that full cJoin can be modeled back in Join At commit, a sub-negotiation can generate its parent: new threads, and messages to be delivered at commit On abort, sub-negotiations should finish but not compensate Extension of running implementations of join (Jocaml, Comega, Join-Java)