Speeding up Dynamic Shortest Path Algorithms

Transcription

1 Speeding up Dynamic Shortest Path Algorithms Luciana S. Buriol Ph.D. Student, UNICAMP Brazil Visitor, AT&T Labs Research Joint work with Mauricio Resende and Mikkel Thorup AT&T Labs Research

2 Problem definition; Applications; Current algorithms: Using reduced heaps; Computational results; Conclusions. Outline

3 Objectives To compare current dynamic shortest paths algorithms with respect to arc weight increase and decrease; To propose a new idea for reducing heap size to save computational time;

4 Dynamic Shortest Path problem Given a graph G = (V, E), a shortest path graph G SP = (V, E ), and a vector W with a weight w i associated with each link i. Update G SP considering a weight change without recomputing it from scratch. 4 4 Destination Node 7 7

5 Destination Node Destination Node Original Graph Updated Graph Weight Increase

6 Destination Node Destination Node Original Graph Updated Graph Weight Decrease

7 Applications Transportation network, when weights are associated with traffic/distance; Databases: maintaining distances between objects in a large data base; Data flow analysis and compilers; Document formatting; Local search procedure in packet routing.

8 Packet routing When packet arrives at router, router must decide where to send it next. router Packet s final destination. router router router D D D D 4 R R R R 4 Routing table router

9 Updating algorithms Specialized for weight increase and decrease; An arc deletion can be considered an increase of w i to ; The shortest paths can be a tree or a graph, depending on the application;

10 Graph and tree representations OSPF routing: Traffic flow is routed along shortest paths, splitting flow at nodes with more than one outgoing link. Transportation: If the load cannot be split, only one shortest path is needed.

11 Algorithms Trees: King & Thorup increase; Demetrescu increase; Frigioni et al. decrease; Graphs: R&R increase; R&R decrease; The above algorithms have two versions: the standard implementation and one avoiding use of heaps. Dijkstra s algorithm: recomputes shortest path graph from scratch only when at least one node distance changes. Otherwise, update the local change without Dijkstra.

12 Ramalingan & Reps arc weight increase 4 4 Destination Node 7

13 Ramalingan & Reps arc weigh increase 4 Destination Node 7 Q Find set Q of affected nodes. Q will contain all nodes which have all shortest paths traversing the changed arc.

14 Determining set Q 7 4 Destination Node Find set Q of affected nodes. Set Q will contain all nodes which have all shortest paths crossing the changed arc.

15 Determining set Q 7 4 Destination Node Find set Q of affected nodes. Set Q will contain all nodes which have all shortest paths crossing the changed arc.

16 Determining set Q 7 4 Destination Node Find set Q of affected nodes. Set Q will contain all nodes which have all shortest paths crossing the changed arc.

17 Determining set Q 4 Destination Node Find set Q of affected nodes. Set Q will contain all nodes which have all shortest paths crossing the changed arc.

18 Determining set Q 4 Destination Node Q All arcs s u incoming into nodes s Q are removed from G SP. If u has no outgoing links in G SP, u is an affected node. If u is an affected node, it is added to Q and dist u =.

19 Updating Q-node distances Update distances to nodes in Q considering arcs linking nodes outside Q Destination Node Check all outgoing links from nodes u є Q and update dist u if possible. Insert all nodes u in a heap H considering their distances to the destination H = {,, 9, 9, }

20 Updating Q-node distances Destination Node Remove nodes u H, one by one. For each node u, traverse all incoming links u s and update dist s if possible.

21 Determine the new SP graph Destination Node Traverse each outgoing link e = u v from nodes u Q. If dist u =dist v +w e then arc e G SP.

22 Original Graph Updated Graph R&R weight increase

23 #arcs: [, 49404] # nodes e+0 Ramalingam & Reps vs Dijkstra on dense graphs Dijkstra from scratch 0000 Time (secs) Ramalingam & Reps

24 #arcs: [7, 49404] # nodes Ramalingam & Reps vs Dijkstra on sparse graphs e Dijkstra from scratch Time (secs) Ramalingam & Reps e+0.e+0

25 R&R: determining set Q Q Non affected part of the graph + Destination node - Find set Q; remove all links from nodes u Q and set dist u =.

26 R&R: updating Q-node distances e Q b a c + d Destination node Update distances of nodes u Q considering arcs linking nodes Q.

27 R&R: updating Q-node distances e Q b a c + f e d Destination node Update distances of nodes u Q considering arcs linking nodes Q.

28 R&R: determining the new G SP e Q b a c + f e d Destination node Traverse each outgoing link from nodes u Q to compute G SP.

29 Avoiding use of heaps: Determining set Q & updating Q-node distances + u Q + u + u + u + u + u + u a + v Destination node Instead of attributing to the distances of all nodes Q, add to their original distances the value u, where u is the amount that dist u will increase by considering the cheapest outgoing link from u.

30 Avoiding use of heaps: updating Q- node distances + u Q + u + u + u + u + u + u a + v Destination node Insert in H only nodes that have an alternative cheapest path linking a node Q

31 Avoiding use of heaps: determining the new G SP + u Q + u + u + u + u + u + u a + v Destination node Remove nodes from H, one by one, and insert/update in H new nodes which can have their distances decreased.

32 Effect of weight increment on heap size R & R 000 Heap size R & R reduced Weight increment

33 0. Effect of weight increment on time Time (secs) R&R R&R reduced weight increment

34 Time vs #nodes on random weight increment Demetrescu Demetrescu reduced Demetrescu 00 Time (secs) Demetrescu reduced e+0 e+07 # nodes

35 Time vs #nodes on random weight increment R & R R & R reduced Demetrescu Demetrescu reduced Tree Tree reduced Tree R&R Tree reduced Time (secs) R&R reduced Demetrescu Demetrescu reduced # nodes e+0 e+07

36 Time vs #nodes on random weight decrement R & R R & R reduced Tree Tree reduced R&R Time (secs) Tree reduced Tree R&R reduced e+0 e+07 # nodes

37 Avoiding heaps: Unit increase Q Destination node Increment by all distances from nodes u Q..

38 Avoiding heaps: Unit increase + Q Destination node Traverse each outgoing link from nodes u Q to compute G SP.

39 Avoiding use of heaps in unit weight decrease Q C Destination node Considering unit decrement, the sets A and B are empty.

40 Computational results 0 classes of graphs: Real data from AT&T; Small instances used in OSPF studies by Fortz & Thorup (000); Sparse graphs, dense graphs, square/long/large shape, hard graphs, etc. by A. Goldberg from DIMACS Challenge; Instance sizes from 0 to million nodes; 00 to million arcs. Weight setting range: [,0000]; For each instance, we applied 000 weight increases and 000 decreases. We force the changes to always alter G SP.

41 R&R vs avoiding heaps for weight increase on 0 classes of instances 0000 R&R R&R reduced 000 Time (secs.) 00 0 Average reduction in CPU time: % Instance class

42 Demetrescu vs avoiding heaps for weight increase on 0 classes of instances 0000 Demetrescu Demetrescu reduced 000 Time (secs.) 00 0 Average reduction in CPU time: 0% Instance class

43 K&T vs avoiding heaps for weight increase on 0 classes of instances 0000 King & Thorup King & Thorup reduced 000 Time (secs.) 00 0 Average reduction in CPU time: % Instance class

44 Dijkstra vs K&T avoiding heaps for weight increase on 0 classes of instances e Time (secs.) Average speedup varied from to 4,000 0 Dijkstra King & Thorup reduced Instance class

45 R&R and avoiding heaps for weight decrease on 0 classes of instances Time (secs.) 00 0 Average reduction in CPU time: % R&R R&R reduced Instance class

46 Frigioni and avoiding heaps for weight decrease on 0 classes of instances Instance class Time (secs.) 00 0 Average increase in CPU time: % Frigioni Frigioni reduced

47 Dijkstra & Frigioni for weight decrease on 0 classes of instances Instance class e Time (secs.) Average speedup varied from to 7,000 0 Dijkstra Frigioni

48 Conclusions Ramalingan & Reps on graphs: avoiding use of heaps reduced CPU time by % for weight increase and by % for weight decrease; Demetrescu weight increase on trees: avoiding use of heaps reduced CPU time by 0%; King & Thorup weight increase on trees: avoiding use of heaps reduced CPU time by %; Frigioni et al. weight decrease on trees: avoiding use of heaps increased CPU time by %;

49 Conclusions Considering unit weight changes, the standard algorithms are times faster if they avoid using heaps; The incremental algorithm is 0% faster then the decremental algorithm; On average, King & Thorup algorithm is 4% faster then Demetrescu algorithm; Updating trees is % faster than updating graphs for weight increase and % faster for weight decrease.

50 Local search for OSPF routing For unit increment/decrement the idea of avoiding heaps reduced the computational time by a factor of.