Maximal Antichain Lattice Algorithms for Distributed Computatio

Transcription

1 Maximal Antichain Lattice Algorithms for Distributed Computations Vijay K. Garg Parallel and Distributed Systems Lab, Department of Electrical and Computer Engineering, The University of Texas at Austin, Austin, TX garg

2 Model of a Distributed Computation: Poset distributed computation = poset (partially ordered set) (E, ) where E = is the set of events, and is (happened-before) relation. P1 a d P1 (1,0,0) (2,1,0) P2 b f P2 (0,1,0) (0,2,1) P3 c e P3 (0,0,1) (1,0,2) (i) Events can be timestamped in an online fashion using Vector Clocks such that e f V (e) < V (f ). (ii)

3 Computing Meet and Join d e f a b c Meet of a subset of events meet of {d, e} meet of {a,b} meet of {e,f} Join of a subset of events Lattice: a poset in which all finite subsets have meets and joins.

4 Consistent Cuts of a Distributed System G 1 G 2 P 1 P 2 P 3 m 1 m 2 m 3 Consistent cut = set of events executed so far A subset G of E is a consistent cut (consistent global state) if e, f E : (f G) (e f ) (e G) Same as the order ideal of the partial order (E, ).

5 Motivation: Detecting Global Conditions in Distributed Systems {a,b,c,d,e,f} {a,b,c,d,e} {a,b,c,d,f} {a,b,c,e,f} {a,b,c,d} {a,b,c,e} {a,b,c,f} {a,b,d} {a,c,e} {a,b,c} {b,c,f} {a,b} {a,c} {b,c} {d,e,f} d e f {a} {b} {c} {a,f} {c,d} {b,e} a b c {} {a,b,c} Traversing a significantly smaller lattice of maximal antichains rather than consistent cuts for certain predicates

6 Outline of the Talk Motivation Incremental Lattice Algorithms Lattice Enumeration Algorithms Applications to Global Predicate Detection Conclusions and Future Work

7 Ideals and Antichains d e f a b c Poset P = (X, ) Ideal: Q X is an ideal if f is in Q and e f, then e is also in Q. Antichain: Y X is called an antichain, if every distinct pair of elements from Y are incomparable.

8 Maximal Antichains {a,b,c,d,e,f} {d,e,f} d e f {a,b,c,f} {a,b,c,d} {a,b,c,e} {a,f} {c,d} {b,e} a b c {a,b,c} {a,b,c} Maximal Antichain: An antichain A is maximal if every element not in A is comparable to some element in A. {d, e} is an antichain but not a maximal antichain {d, e, f } is a maximal antichain Maximal Ideal: An ideal Q is maximal antichain ideal if its maximal elements forms a maximal antichain. {a, b, c, d} and {a, b, c, e} are maximal ideals {a, b, c, d, e} is not a maximal ideal

9 Important Lattices Associated with a Poset Lattice of Interpretation in DC References Ideals consistent global states [Mattern88, CM91,..] Normal Cuts Smallest lattice containing P [Garg OPODIS12] Maximal Ideals State for maximal antichain [JRJ94, this paper] Table: Summary of Lattices for Distributed Computations modeled as a poset P

10 Related Work: Incremental Algorithms Elements of the computation arrive in a sorted order Input: poset P, its lattice of maximal antichains L, element x Output: L := lattice of maximal antichains of P {x} Incremental Algorithms Time Complexity Space Complexity [Jourdan, Rampon, Jard 94] O(w 3 m) O(mn log n) [Nourine and Raynaud 99, 02] O(mn) O(mn log n) Algorithm ILMA [this paper] O(wm log m) O(mw log n) Algorithm OLMA [this paper] O(m x w 2 log w L )) O(w L w log n) Symbol Definition Symbol Definition n size of the poset P m size of the lattice L w width of the poset P m x # (strict ideals D(x)) w L width of the lattice L

11 Strict Ideals D(A) = the set of elements strictly smaller than A Strict Ideal: A set Y is a strict ideal if there exists an antichain A such that D(A) = Y. d e f a b c Example: {a, b} is a strict ideal. {a, b, c, d} is not.

12 Equivalence of maximal ideals and strict ideals d e f a b c {a,b,c,d,e,f} {d,e,f} {a,b,c} {a,b,c,f} {a,b,c,d} {a,b,c,e} {a,f} {c,d} {b,e} {b,c} {a,b} {a,c} {a,b,c} {a,b,c} {} Lattices of maximal ideals, maximal antichains, and strict ideals are isomorphic. Mapping from strict ideals to maximal antichains: S is mapped to the minimal elements of the complement of S.

13 Incremental Algorithm 1 Input: P: a finite poset as a list of vector clocks L: lattice of maximal antichains of vector clocks x: new element Output: L := Lattice of maximal antichains of P {x} initially L // Step 1: Compute the set D(x) Let V be the vector clock for x on process P i ; S := V ; S[i] := S[i] 1; // Step 2: if S L then L := L {S}; forall vectors W L: if max(w, S) L then L := L max(w, S);

14 Example Poset and its lattice of maximal antichains (3,2,2) (3,2,1) (2,1,2) (3,0,0) (2,2,0) (1,1,2) (3,1,1) (2,0,0) (1,1,0) (1,0,1) (2,1,1) (1,0,0) (1,0,0)

15 Example Step 1: D[x] = (1, 0, 0) D(x) = (0, 0, 0), strict ideals added: (0, 0, 0) Set of Maximal Antichains = {(1, 0, 0)} (3,0,0) (2,2,0) (1,1,2) (2,0,0) (1,1,0) (1,0,1) (1,0,0) (1,0,0)

16 Example Step 2: D[x] = (2, 0, 0) D(x) = (1, 0, 0), strict ideals added: (1, 0, 0) Set of Maximal Antichains = {(1, 0, 0), (2, 1, 1)} (3,0,0) (2,2,0) (1,1,2) (2,0,0) (1,1,0) (1,0,1) (2,1,1) (1,0,0) (1,0,0)

17 Example Step 3: D[x] = (1, 1, 0) D(x) = (1, 0, 0), strict ideals added: φ Set of Maximal Antichains = {(1, 0, 0), (2, 1, 1)} (3,0,0) (2,2,0) (1,1,2) (2,0,0) (1,1,0) (1,0,1) (2,1,1) (1,0,0) (1,0,0)

18 Example Step 4: D[x] = (1, 0, 1) D(x) = (1, 0, 0), strict ideals added: φ (3,0,0) (2,2,0) (1,1,2) (2,0,0) (1,1,0) (1,0,1) (2,1,1) (1,0,0) (1,0,0)

19 Example Step 5: D[x] = (3, 0, 0) D(x) = (2, 0, 0), strict ideals added: (2, 0, 0) Maximal antichain added: (3, 1, 1) (3,0,0) (2,2,0) (1,1,2) (3,1,1) (2,0,0) (1,1,0) (1,0,1) (2,1,1) (1,0,0) (1,0,0)

20 Example Step 6: D[x] = (2, 2, 0) D(x) = (2, 1, 0), strict ideals added: (2, 1, 0) Maximal antichain added: (3, 2, 1) (3,2,1) (3,0,0) (2,2,0) (1,1,2) (3,1,1) (2,0,0) (1,1,0) (1,0,1) (2,1,1) (1,0,0) (1,0,0)

21 Example Step 6: D[x] = (1, 1, 2) D(x) = (1, 1, 1), strict ideals added: (1, 1, 1), (2, 1, 1) Maximal antichains added: {(2, 1, 2), (3, 2, 2)} (3,2,2) (3,2,1) (2,1,2) (3,0,0) (2,2,0) (1,1,2) (3,1,1) (2,0,0) (1,1,0) (1,0,1) (2,1,1) (1,0,0) (1,0,0)

22 Analysis of the Incremental Algorithm 1 1 Simple Algorithm 2 To check if max(s, W ) L, maintain L as a binary search tree 3 Requires storage of the the entire lattice (exponential in size of the poset in the worst case)

23 Space Efficient Incremental Algorithm Input: a finite poset P, x maximal element in P = P {x} Output: enumerate M such that L MA (P ) = L MA (P) M (1) S := the vector clock for x on process P i ; (2) S[i] := S[i] 1; (3) if S is not a strict ideal of P then (4) // BFS(S): Do Breadth-First-Search traversal of M (5) T := set of vectors initially {S}; (6) while T is nonempty do (7) H := delete the smallest vector from T ; (8) enumerate H; (9) foreach process k with next event e do (10) explore H using e; (11) endfor; (12) endwhile; (13) endif;

24 Outline of the Talk Motivation Incremental Lattice Algorithms Lattice Enumeration Algorithms Applications to Global Predicate Detection Conclusions and Future Work

25 Motivation for Enumeration of Maximal Antichains Global predicate detection requires enumeration not construction of the lattice Lattice of maximal antichains may be exponential in the number of processes

26 Related Work: Enumeration Algorithms Input: a nonempty finite poset P Output: enumerate all elements of L := DM-completion of P Algorithm Time Space [Jourdan, Rampon, Jard 94] O((n + w 2 )wm) O(mn log n) [Nourine and Raynaud 99, 02] O(mn 2 ) O(mn log n) Algorithm ILMA [this paper] O(nwm log m) O(mw log n) BFS-MA [this paper] O(mw 2 log m) O(w L w log n) DFS-MA [this paper] O(mw 4 ) O(nw log n) Lexical by [Ganter84] O(mn 3 ) O(n log n) The parameters are: n: size of the poset P, m: size of the lattice L of normal cuts of P, w: width of the poset P, w L : width of the lattice L.

27 Enumeration using Closed Sets closure(y ) = smallest maximal antichain ideal that contains Y. The operator closure(y ) is monotone, extensive and idempotent. Idea: View the lattice of maximal antichains as a directed graph and enumerate the nodes of the graph using the closure operator. Difficulty: Usual DFS on graph cannot be employed as the graph cannot be stored. Cannot mark which nodes have been visited before.

28 Depth First Search Enumeration of Maximal Antichain Ideals Input: a finite poset P, starting state G Output: DFS Enumeration of Maximal Antichain Ideals of P (1) output(g); (2) foreach event e enabled in G do (3) K := closure(g {e}); (4) if (K covers G) and (not visited before) then (5) DFS(K);

29 How to avoid revisiting cuts? Visit a state only from the maximum predecessor. (4) if K does not cover G then go to the next event; (5) M := get-max-predecessor(k) ; (6) if M = G then (7) DFS-MaximalIdeals(K); To check whether K covers G: use the efficient characterization provided by [Reuter 91]. To choose the maximum predecessor Expand the nodes of the dual poset and choose the biggest predecessor

30 Outline of the Talk Motivation Incremental Lattice Algorithms Lattice Enumeration Algorithms Applications to Global Predicate Detection Conclusions and Future Work

31 Application to Global Predicate Detection Definition (Antichain-Consistent Predicate) A global predicate is an antichain-consistent predicate if 1 its evaluation depends only on maximal events of a consistent global state and 2 if it is true on a subset of processes, then presence of additional processes does not falsify the predicate. Examples of antichain-consistent predicates Violation of mutual exclusion: there is more than one process in the critical section. Violation of resource usage: there are more than k concurrent activation of certain service, Global Control Point: The predicate, B, Process P 1 is at line 35 and P 2 is at line 23 concurrently,

32 Equivalence in Global Predicate Detection Theorem There exists a consistent global state that satisfies an antichain-consistent predicate B iff there exists a maximal ideal that satisfies B.

33 Conclusions and Future Work An Incremental Algorithm to generate the lattice of maximal antichains BFS and DFS enumeration of maximal antichains Applications to global predicate detection Question: Is there a space-efficient algorithm with time complexity O(mw log n)?