Download presentation

Presentation is loading. Please wait.

Published byDakota Deakin Modified over 2 years ago

1
Competitive fault tolerant Distance Oracles and Routing Schemes Weizmann Open U Weizmann Bar Ilan Shiri Chechik Michael Langberg David Peleg Liam Roditty

2
Formal framework A network G A service S(G) Desired properties represented by requirement predicate P(S,G) cost(S) of constructing / maintaining S Optimization problem: Select cheapest service S satisfying P(S,G)

3
Example: Connectivity oracle S = database maintained over graph G Requirement predicate P conn on S: For every two vertices u,w in G: in response to a query Q conn (u,w), answer whether u and w are connected in G. Costs: cost 1 (S) = total / max memory for S cost 2 (S) = query time of S

4
Connectivity oracles The graph G Centralized connectivity oracle for G u u0 w v w v 1 S1S1.............

5
Connectivity oracles The graph G Distributed connectivity oracle for G 〈 w,3 〉 1 2 3 〈 u,1 〉 〈 v,3 〉 Assign each vertex v in connected component G i a label L(v) = 〈 v,i 〉 On query Q conn (L(u),L(w)): check labels 0 1

6
Cost of distributed connectivity oracle Memory = O(log n) per vertex Query time = O(1)

7
Fault Tolerance Assumption: vertices / edges may occasionally fail or malfunction Failure event: set F of failed vertices/edges

8
Fault Tolerance As a result of a failure event: G and S(G) are partially destroyed Surviving network: G' = G \ F Surviving service: S' = S \ F Requirement predicate P might no longer hold

9
Coping with failures in services Goal: Make S(G) competitive fault tolerant, i.e., ensure that the requirement predicate P(S’,G’) still holds subsequent to a failure event. Relaxed variant of problem: Construct service S(G) that can guarantee a weakened form of desired properties (i.e., some relaxed predicate P‘(S’,G’))

10
Rigid vs. competitive fault tolerance Rigid fault tolerance: Ensure that S(G) satisfies the requirement predicate w.r.t. the original G, i.e., that P(S’,G) still holds after a failure event. Competitive fault tolerance: S(G) satisfies the requirement predicate w.r.t. the surviving G’, i.e., P(S’,G’) must hold after a failure event. ⇨ Useful for structures (subgraphs,…) ⇨ Useful for services (oracles, routing,…)

11
Back to connectivity example Goal: Construct a competitive fault-tolerant connectivity oracle S capable of withstanding f edge failures (|F|≤f) (a.k.a. f-sensitivity connectivity oracle) Connectivity oracle: receives query Q conn (s,t) for vertices s, t answers whether s and t are connected

12
Dynamic connectivity oracle [Patrascu-Thorup- 07] Maintain a dynamic data structure Update after each edge deletion / failure Space O(|E(G)|) Query time O(f log 2 n loglogn) (following a batch of f edge deletions)

13
F-T connectivity oracles Note: Unlike dynamic connectivity oracles, in an F-T connectivity oracle, the faulty sets F for two consecutive queries could be very different. receive a query Q conn (s,t,F) for vertices s,t, and failure event F ⊆ E (for |F|≤f) answer whether s and t are connected in G’ = G \ F

14
F-T connectivity oracles Dynamic connectivity oracle: failures come one by one

15
F-T connectivity oracles F-T connectivity oracle: failure events F 1, F 2, … are separate F1F1 F2F2 F3F3 Q(s 1,t 1 )? s3s3 t3t3 t1t1 s1s1 t2t2 s2s2 Q(s 2,t 2 )? Q(s 3,t 3 )?

16
F-T connectivity oracles Claim: The dynamic connectivity oracle of [PT-07] can be modified into F-T connectivity oracle against f edge failures.

17
F-T connectivity oracles Given query Q conn (s,t,F) (with vertices s,t and failure event F ⊆ E) : Update the data structure, deleting all the edges of F While updating, record the changes made Answer the connectivity query Q conn (s,t) Undo all changes to the data structure Operation of the F-T connectivity oracle:

18
F-T connectivity oracles Claim: The resulting F-T connectivity oracle has: Space O(|E(G)|) Query time O(f log 2 n loglogn)

19
F-T connectivity oracles The connectivity oracle of [CLPR-10] : Space O(fkn 1+1/k log(nW)) Query time O(f log 2 n loglogn) (using the sparse spanner construction of [Chechik-Langberg-P-Roditty-10] )

20
(Approximate) Distance Oracle: Data-structure that can answer (approximate) distance queries Q dist (s,t) for any two vertices s, t (with a stretch of at most k) Distance oracles

21
Distance Oracles Thm [Thorup-Zwick-05]: For every weighted undirected graph G it is possible to construct a data structure of size O(n 1+1/k ) that is capable of answering distance queries Q dist (s,t) in O(k) time, with multiplicative approximation factor ≤ 2k-1 (returns a distance estimate đ such that dist(s,t,G) đ (2k-1)dist(s,t,G) )

22
Distributed distance oracles – Distance labeling schemes [P-99] Data structure stored in pieces at the graph vertices (as vertex labels) To answer distance query Q dist (s,t), it suffices to consult the labels L(s), L(T)

23
Distributed distance oracles – Distance labeling schemes [P-99] Thm [P-99]: For every weighted undirected graph G it is possible to construct an approximate distance labeling scheme of size Õ (n 1/k ) capable of answering distance queries Q dist (s,t) with multiplicative approximation factor O(k)

24
F-T distance oracle: Data structure capable of answering distance queries Q dist (s,t,F) between vertex pairs s,t, on the surviving graph G\F, subsequent to a failure event F F-T distance oracles

25
Related work [Demetrescu et al-08]: It is possible to preprocess a weighted graph in time Õ(mn 2 ) to produce a data structure of size O(n 2 logn) for answering 1-failure distance queries Q dist in O(1) time F-T distance oracles

26
Related work [Karger-Bernstein-09] improved preprocessing time for 1-failure queries, to O(n 2 √m), then to Õ(mn), with same size and query time. [Duan-Pettie-09] oracle for 2-failure queries, of size O(n 2 log 3 n) and query time in O(log n) F-T distance oracles

27
Thm [CLPR-10] There exists a polynomial-time constructible data structure of size O(kn 1+8(f+1)/(k+2(f+1)) log(nW)), that given a set of edges F of size |F|≤f and two vertices s,t, returns in time O(f log 2 n loglogn loglogd) a distance estimate đ such that dist(s,t,G\F) đ (2k-1)dist(s,t,G\F) F-T distance oracles

28
Neighborhoods B ρ (v) = ρ -neighborhood of v = vertices at distance ρ or less from v B 0 (v) B 1 (v) B 2 (v)

29
Tree covers Basic notion: A tree T covering the ρ -neighborhood of v v B 2 (v) covering T

30
G = weighted undirected graph A tree cover TC( ,k) : collection of trees {T 1,…,T l } such that 1. For every v there exists a tree T i such that B (v) T i 2. For every T i and every v T i, dist(v,r i,T i ) (2k-1) 3. For every v, the number of trees that contain v is O(kn 1/k ). Tree Covers TiTi B (v) (2k-1) v O(kn 1/k )

31
Lemma [Awerbuch-Kutten-P-91, Cohen-93] A tree cover TC( ,k) can be constructed in time Õ(mn 1/k ) Tree Covers

32
Lemma (F-T connectivity oracle [CLPR-10]) There exists a poly time constructible data structure of size O(fkn 1+1/k log(nW)), that given a set of failed edges F of size f and two vertices s,t, replies in time O(f log 2 n loglogn) whether s and t are connected in G\F Connectivity Oracle (reminder)

33
Construction The algorithm has log(nW) iterations Iteration i handles distances ≤ 2 i G i = graph obtained by removing from G all edges of weight > 2 i f-Sensitivity Distance Oracles

34
Iteration i: Construct a tree cover TC i with ρ= 2 i and k G i | T = subgraph of G i induced by T vertices For each T TC i, construct connectivity oracle Conn_Or T on G i | T For each vertex v store pointer to tree T i (v) TC i containing B ρ (v) f-Sensitivity Distance Oracles

35
Lemma The size of the data structure is O(fkn 1+1/k log(nW)) f-Sensitivity Distance Oracles

36
Q dist (s,t,F) For i 1 to log(nW) if Conn_Or Ti(s) (s,t,F) = true, then return đ=(8k-2)(f+1)2 i-1 Return Answering Queries

37
Lemma Consider vertices s,t and failure set F. Let d=dist(s,t,G\F). The estimated distance đ returned by Q dist (s,t,F) satisfies d đ (8k-2)(f+1)d f-Sensitivity Distance Oracles

38
Lemma The f-sensitivity distance query (s,t,F) can be implemented to return a distance estimate in time O(f log 2 n loglogn loglogd) f-Sensitivity Distance Oracles

39
Main result [CLPR-10] 2-sensitive compact routing scheme: Given a message M at a source vertex s and a destination t, in the presence of failed edges F={e 1,e 2 }, routes M from s to t over a path of length O(k ⋅ dist(s,t,G\{e 1,e 2 }). Total information stored in vertices: O(kn 1+1/k log(nW)logn). 2-sensitivity routing

40
Use hierarchy of tree covers as in distance oracle. To route from s to t, try increasingly higher levels Suppose dist(s,t,G) ≤ 2 i There is a tree T TC i that contains B (s) for =2 i ⇨ T contains also the destination t 2-sensitivity routing T B (s) t

41
T is of depth ≤ (2k-1) ⋅ 2 i The route from s to t is at most k ⋅ 2 i+2 = O(k ⋅ dist(s,t,G)) Only remaining problem: handle edge disconnections… 2-sensitivity routing T B (s) t

42
Consider this tree T u v 2-sensitivity routing Each edge e=(u,v) T – if failed - T u (e) T v (e) disconnects T into two connected components, T u (e) and T v (e)

43
A recovery edge of e is any edge e’ of G that connects T u (e) and T v (e). Define for each edge e T a recovery edge rec(e). u v rec(e) 2-sensitivity routing T u (e) T v (e)

44
Slight simplification for analysis: Assume the graph edges are sorted - e 1,…, e m , and choose rec(e) for every e to be the first recovery edge e i of e 2-sensitivity routing

45
Consider the recovery edge rec(e) = (u',v‘) of the edge e. Denote by P(u,u‘) (resp., P(v,v‘)) the path connecting u and u’ (resp., v and v’) in the tree T u (e) (resp., T v (e)) Denote the entire alternative path for e=(u,v) by P(e) = P(u,u‘) ∙ (u',v') ∙ P(v',v). rec(e) P(u,u’) P(v,v’) e 2-sensitivity routing

46
Failed edges: e 1 = ( u 1, v 1 ) and e 2 = ( u 2, v 2 ) Simplest case: e 1 and e 2 are not in T : just route on T. 2-sensitivity routing

47
Still simple case: e 1 T, e 2 T. 2-sensitivity routing ⇨ T ⋃ rec(e 1 ) \ { e 1, e 2 } is broken into two connected components only when rec(e 1 ) = e 2 To overcome this, it suffices to store, for each edge e T, one additional recovery edge.

48
Hard case: both e 1, e 2 T. Subcase 1 (not too hard): e 2 does not appear on the alternative path P(e 1 ) via rec(e 1 ) (and s,t are connected in G i | T \{e 1,e 2 }): 2-sensitivity routing ⇨ rec(e 1 ), rec(e 2 ) suffice for routing from s to t

49
Subcase 2 (hardest): both e 1 is on P(e 2 ) and e 2 is on P(e 1 ). 2-sensitivity routing ⇨ rec(e 1 ) = rec(e 2 )

50
Store for e 1 (similarly, for each edge e T) two additional recovery edges rec u1 (e 1 ) and rec v1 (e 1 ). Choose rec u1 (e 1 ) to be the edge that “bypasses” as many edges on P(u 1,u 1 ‘) as possible. 2-sensitivity routing

51
Specifically: Consider the path P’ from u 1 to any other recovery edge e’ ≠ rec(e 1 ) P’ has some common prefix with P(u 1,u 1 ‘). rec u1 (e 1 ) ← recovery edge e’ of e 1 that minimizes the length of the common prefix rec v1 (e 1 ) chosen analogously w.r.t P(v 1,v 1 ‘) 2-sensitivity routing

52
These choices ensure successful routing (requires detailed case analysis) The routing process

53
T1T1 T2T2 T3T3

54
T1T1 T2T2 T3T3 First subcase: The routing process

55
T1T1 T2T2 T3T3 Second subcase: The routing process

56
Thm [CLPR-10] There exists a 2-sensitive compact routing scheme that given a message M at a source vertex s and a destination t, in the presence of failed edges e 1 and e 2, routes M from s to t in a distributed manner over a path of length at most O(k ⋅ dist(s,t,G\{e 1,e 2 }). The total amount of information stored in vertices of G is O(kn 1+1/k log(nW)logn). The routing process

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google