Efficient Incremental Optimal Chain Partition of Distributed Program Traces

1
Efficient Incremental Optimal Chain Partition of
Distributed Program Traces

• Selma Ikiz
• Vijay K. Garg

Parallel and Distributed Systems Laboratory
2
Outline

• Introduction and Motivation
• Problem definition
• Outline two previous algorithms
• Offline vs Incremental -gt Experimental Results
• New Incremental algorithm
• Experimental Results
• Concluding Remarks

3
Software testing and debugging

• Commercial software has large number of
  components
• Verification
• Formal proof of correctness is not feasible
• Predicate detection (Runtime verification)
• simulation formal methods
• Debugging
• Large number of states
• Abstraction or grouping of states/processes

4
Distributed Computation as Partial order set

• Partial-order models
• Poset (X,P)
• X is a set
• P is antisymmetric, reflexive, and transitive
  binary relation on X
• Lamport 1978 happened-before relation
• f1 ? e3 ? c(f1) lt c(e3)
• Fidge 1991 Mattern 1989 vector-clocks
• f1 ? e3 ? c(f1) lt c(e3)

(1,0,0)
(2,2,0)
(3,2,0)
P1
e1
e2
e3
(0,1,0)
(0,2,0)
(0,3,0)
P2
f1
f2
f3
(0,2,1)
(3,2,2)
P3
g1
g2
5
Optimal chain partition of a poset

• Width
• the size of the largest antichain (a subset of
  poset whose every distinct pair is mutually
  incomparable)
• A poset cannot be partition into k chains if k lt
  width(P) R.P. Dilworth
• Debugging
• Visualization
• Testing Analyzing
• Bounded sum predicates (x1 x2 x3 lt k)
• Mutual exclusion violation

6
Mutual exclusion violation example
C1
C2
C3
(1,0,0)
(2,2,0)
(3,2,0)
P1
(1,0,0)
(0,2,0)
(3,2,2)
(0,1,0)
(0,3,0)
(0,2,0)
(3,2,0)
(0,3,0)
P2
(3,2,2)
(0,2,1)
P3
Critical event
7
Problem definition Previous algorithms

• Problem definition
• Given a chain partition of P, C C1, . . . ,CN
  into N disjoint chains, rearrange these chains
  into a chain partition with the fewest number of
  chains.
• Previous algorithms that answer the question
  given k chains whether it is possible to
  partition it into k-1 chains.
• Bogart and Magagnosc
• BM
• Tomlinson and Garg
• TG

8
Bogart Magagnosc

• A sequence of elements a0,b0,a1,b1,,as,bs is a
  reducing sequence if
• a0 is the least element of some chain,
• bi is the immediate predecessor of ai1 in some
  chain,
• all bis are distinct,
• for all i ai gt bi in the partial order,
• bs is the greatest element of its chain.

C1
C3
C2
(0,0,1)
(1,0,0)
(0,1,0)
(0,0,2)
(2,0,0)
(0,2,0)
(0,0,3)
(3,0,0)
(0,3,0)
C4
(0,3,7)
(3,4,0)
(0,0,4)
(0,3,8)
(3,5,0)
(0,0,5)
(0,0,6)
9
Tomlinson and Garg
Output Chains
-
-
-
(0,0,1)
(0,0,1)
(1,0,0)
(0,1,0)
(0,0,4)
Input Chains
(0,0,2)
(2,0,0)
(0,2,0)
(0,0,5)
(0,0,3)
(3,0,0)
(0,3,0)
(0,0,6)
(0,3,7)
(3,4,0)
(0,3,8)
(3,5,0)
10
Tomlinson and Garg
(0,0,1)
Output Chains
(0,0,1)
(0,0,2)
-
-
(0,0,2)
(0,0,3)
(0,1,0)
(1,0,0)
(0,1,0)
(0,0,3)
(0,0,4)
(0,3,7)
(0,2,0)
Input Chains
(2,0,0)
(0,2,0)
(0,3,7)
(0,0,5)
(0,3,8)
(0,3,0)
(3,0,0)
(0,3,0)
(0,3,8)
(0,0,6)
(3,4,0)
(3,4,0)
(3,5,0)
(3,5,0)
11
Tomlinson and Garg
(0,0,1)
(0,1,0)
Output Chains
(0,0,2)
(0,1,0)
(0,2,0)
-
-
(0,0,3)
(0,2,0)
-
(0,3,0)
(1,0,0)
(0,0,4)
(0,3,7)
(0,3,0)
(3,4,0)
Input Chains
(2,0,0)
(0,0,5)
(0,3,8)
(3,4,0)
(3,5,0)
(3,0,0)
(0,0,6)
(3,5,0)
12
Tomlinson and Garg
(0,0,1)
(0,1,0)
Output Chains
(0,0,2)
(0,2,0)
(1,0,0)
(0,0,3)
(0,3,0)
(1,0,0)
(2,0,0)
(2,0,0)
(0,0,4)
(0,3,7)
(3,4,0)
(3,0,0)
Input Chains
(3,0,0)
(0,0,5)
(0,3,8)
(3,5,0)
(0,0,6)
13
Tomlinson and Garg
(0,0,1)
(0,1,0)
(1,0,0)
Output Chains
(0,0,2)
(0,2,0)
(2,0,0)
(0,0,3)
(0,3,0)
(3,0,0)
(0,0,4)
(0,3,7)
(3,4,0)
-
Input Chains
(0,0,5)
(0,3,8)
(3,5,0)
(0,0,6)
14
Tomlinson and Garg
(0,0,1)
(0,1,0)
(1,0,0)
Output Chains
(0,0,2)
(0,2,0)
(2,0,0)
(0,0,3)
(0,3,0)
(3,0,0)
(0,0,4)
(0,3,7)
(3,4,0)
(0,0,5)
(0,3,8)
(3,5,0)
(0,0,6)
Input Chains
-
-
-
15
Offline vs Incremental

• Offline
• Call BM or TG algorithm until there is no further
  reduction in the number of chains

• Incremental (Naïve)
• Place the new element into a new chain, and call
  the BM or TG algorithm

16
Linear extension hypothesis Bouchitte Rampon

• Let f be the new event, then we assume that all
  the events happed before f are already arrived
  and processed.

f
17
Memory Usage
18
Running times
19
Idea behind Chain Partitioner
Maximum antichain

• New element
• No effect
• Updates the maximum antichain
• Expands the maximum antichain
• ?
• Given the maximum antichain, its sufficient to
  compare the new element with the maximum
  antichain

20
CP example
Linearization
21
CP example
(1,2,1)
(1,2,3)
(1,2,0)
(2,3,0)
(2,4,1)
(0,1,0)
(2,0,0)
(3,0,0)
4,3,0)
(1,0,0)
Merge
CP

• H0
• W0

H O Q
k 3
(1,0,0)
(0,1,0)
(2,0,0)
(1,0,0)
(0,1,0)
(2,0,0)
(1,2,0)
(1,2,0)
22
CP example
(1,2,1)
(1,2,3)
(1,2,0)
(2,3,0)
(2,4,1)
(0,1,0)
(2,0,0)
(3,0,0)
4,3,0)
(1,0,0)
Merge
CP

• H4
• W4

H O Q
-
-
(1,0,0)
-
-
k 3
(1,0,0)
(0,1,0)
(2,0,0)
(1,0,0)
(0,1,0)
(2,0,0)
(1,2,0)
(1,2,0)
(1,2,0)
23
CP example
(1,2,1)
(1,2,3)
(1,2,0)
(2,3,0)
(2,4,1)
(0,1,0)
(2,0,0)
(3,0,0)
4,3,0)
(1,0,0)
Merge
CP

• H4
• W4

H O Q
-
(1,0,0)
(0,1,0)
-
-
k 3
(1,0,0)
(0,1,0)
(2,0,0)
(0,1,0)
(2,0,0)
(1,2,0)
(1,2,0)
24
CP example
(1,2,1)
(1,2,3)
(1,2,0)
(2,3,0)
(2,4,1)
(0,1,0)
(2,0,0)
(3,0,0)
4,3,0)
(1,0,0)
Merge
CP

• H4
• W4

H O Q
(1,0,0)
(0,1,0)
(2,0,0)
(1,2,0)
k 3
(1,0,0)
(0,1,0)
(2,0,0)
(1,2,0)
25
CP example
(1,2,1)
(1,2,3)
(1,2,0)
(2,3,0)
(2,4,1)
(0,1,0)
(2,0,0)
(3,0,0)
4,3,0)
(1,0,0)
Merge
CP

• H4
• W4

H O Q
(1,0,0)
(0,1,0)
-
-
-
-
k 3
(2,0,0)
(1,2,0)
(3,0,0)
(2,0,0)
(1,2,0)
(3,0,0)
(1,2,1)
(2,3,0)
(1,2,1)
(2,3,0)
26
CP example
(1,2,1)
(1,2,3)
(1,2,0)
(2,3,0)
(2,4,1)
(0,1,0)
(2,0,0)
(3,0,0)
4,3,0)
(1,0,0)
Merge
CP

• H4
• W4

H O Q
(1,0,0)
(0,1,0)
-
-
(2,0,0)
-
-
k 3
(2,0,0)
(1,2,0)
(3,0,0)
(2,0,0)
(1,2,0)
(3,0,0)
(2,3,0)
(1,2,1)
(2,3,0)
(1,2,1)
(2,3,0)
27
CP example
(1,2,1)
(1,2,3)
(1,2,0)
(2,3,0)
(2,4,1)
(0,1,0)
(2,0,0)
(3,0,0)
4,3,0)
(1,0,0)
Merge
CP

• H0
• W0

H O Q
(1,0,0)
(0,1,0)
-
(2,0,0)
(1,2,0)
-
-
k 3
(2,0,0)
(1,2,0)
(3,0,0)
(1,2,0)
(3,0,0)
(2,3,0)
(1,2,1)
(1,2,1)
(2,3,0)
(1,2,1)
28
CP example
(1,2,1)
(1,2,3)
(1,2,0)
(2,3,0)
(2,4,1)
(0,1,0)
(2,0,0)
(3,0,0)
4,3,0)
(1,0,0)
Merge
CP

• H7
• W7

H O Q
(1,0,0)
(0,1,0)
(2,0,0)
(1,2,0)
k 3
(1,2,1)
(3,0,0)
(2,3,0)
(1,2,3)
(2,4,1)
4,3,0)
29
Running times
30
Test suites

• 7 new test suites are created.
• Each test suite contains 18 different test cases
  
• initial partition vary from 10 to 450 chains,
• size vary from 100 to 70,000
• We used a fixed vectorclock size (10)
• Reducing factor (N-w)/N
• where N is the size of the initial partition, and
  w is the width of the poset.
• Posets are randomly created according to a given
  width and size.
• Test suites differ in their reducing factor.

31
Reducing factor effect
32
Average run time per event
33
Comparison with related work
34
Concluding Remarks

• Partitioning a distributed computation
• Under the linear extension hypothesis pruning the
  work space (without any significant extra cost )
  improves the performance of the incremental
  algorithm
• Main limitation
• x1 x2 x3 lt k (efficient only for small k)
• A decentralized algorithm
• Integrating with computation slicing

35
Questions ?
36
Problem definition Previous algorithms

• Problem definition
• Given a chain partition of P, C C1, . . . ,CN
  into N disjoint chains, rearrange these chains
  into a chain partition with the fewest number of
  chains.
• Previous algorithms that answer the question
  given k chains whether it is possible to
  partition it into k-1 chains.
• Bogart and Magagnosc
• BM
• Tomlinson and Garg
• TG

37
Trace Model Total Order vs Partial Order

• Total order interleaving of events in a trace
• relevant tools Temporal Rover Drusinsky 00,
  Java-MaC Kim, Kannan, Lee, Sokolsky, and
  Viswanathan 01, jPaX Havelund and Rosu 01
• Partial order Lamports happened-before model
• e.g., jMPaX Sen, Rosu, and Agha 03
• Total order
• low computational complexity
• Partial order
• suitable for concurrent and distributed
  programs
• encodes exponential number of total
  orders ) captures bugs that may not be found with
  a total order