1 / 34

Algorithms for Precomputing Constrained Widest Paths and Multicast Trees

Algorithms for Precomputing Constrained Widest Paths and Multicast Trees. Paper by Stavroula Siachalou and Leonidas Georgiadis Presented by Jeremy Witmer CS 622 Fall 2007. Multicast Trees. Large Multicast Trees. In large networks, adding nodes becomes inefficient

hdelgado
Download Presentation

Algorithms for Precomputing Constrained Widest Paths and Multicast Trees

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Algorithms for Precomputing Constrained Widest Paths and Multicast Trees Paper by Stavroula Siachalou and Leonidas Georgiadis Presented by Jeremy Witmer CS 622 Fall 2007

  2. Multicast Trees Precomputing Multicast Trees - CS622

  3. Large Multicast Trees • In large networks, adding nodes becomes inefficient • Adding on a widest-bandwidth path • Paths with QoS constraints Precomputing Multicast Trees - CS622

  4. Proposed Solution • Precompute as much of the tree as possible • When a node is added, choose the path with the highest available bandwidth while obeying QoS delay constraints Precomputing Multicast Trees - CS622

  5. Proposed Solution • Solution defined as solutions to two separate problems • First, the precomputation of the links in the tree • Second, selection of a new path when a new node subscribes to the multicast tree • The paper proposes three algorithms to accomplish the first goal Precomputing Multicast Trees - CS622

  6. Network Model • Given a directed graph G = (V, E) • V is the set of nodes in the graph • E is the set of edges in the graph • N = |V| • M = |E| Precomputing Multicast Trees - CS622

  7. Network Model • Each edge in E has a corresponding delay and width, (d,W) • A path from source node s to another node in the network u is with delay no greater than d represented as Pu(d) • The optimal path is represented as Pu*(d) Precomputing Multicast Trees - CS622

  8. Network Model Precomputing Multicast Trees - CS622

  9. Network Model Precomputing Multicast Trees - CS622

  10. Problem 1 Definition • Find the path Pu*(d) that has the greatest width of all the paths from s to u, meeting the bandwidth requirement W(pu*) > W(p) for all paths Pu(d) Precomputing Multicast Trees - CS622

  11. Dominated Pairs • Pair (D(p1), W(p1)) dominates pair (D(p2), W(p2)) or path p1 dominates path p2iff • W(p1) > W(p2) and D(p1) < D(p2) • OR • W(p1) > W(p2) and D(p1) < D(p2) Precomputing Multicast Trees - CS622

  12. Algorithm 1 • Create a heap P to store all possible discontinuities • For each node u in G, except for the source node s: • Initialize queue D’(u) • Create all possible successor discontinuities to u • Store the discontinuities (d, W, u) for each u in P • Note: (d, W, u) is generally stored as (d, W, u, prev_node) Precomputing Multicast Trees - CS622

  13. Algorithm 1 • Take the discontinuity in the minimum lexicographic order off of the queue. • If the current discontinuity pair isn’t dominated by any pair currently on D’(u), add the current pair to D’(u), otherwise, discard the pair. • Do this for all discontinuities in P Precomputing Multicast Trees - CS622

  14. Algorithm 1 • This will result in a set of queues D’(u), one for each node u in G. • Each queue is then sorted in lexicographical order, so the optimal discontinuity for each node u is at the head of the queue • Because each discontinuity except for the source s has a predecessor discontinuity (d, W, v), the path can be found by keeping track of these discontinuity links • Note: P is implemented as a heap in this algorithm Precomputing Multicast Trees - CS622

  15. Algorithm 2 • Operation is similar to Algorithm 1 • Instead of the heap/queue data structures, discontinuities are stored in arrays indexed by a function of the link width w • P is an array A[u,k] where 1 < k < K, K < M • Instead of storing possible discontinuities by node u, on queues D’(u), store on K heaps H(k) Precomputing Multicast Trees - CS622

  16. Algorithm 2 • Algorithm execution is identical to Algorithm 1 except that the heaps H(k) only need to contain one possible discontinuity at a time • When a new discontinuity (d, k, u) is found, it can replace the current discontinuity on heap H(k), instead of being added to the queue Precomputing Multicast Trees - CS622

  17. Algorithm 3 • Given the same graph G = (V, E) • Find the widest-shortest path from s to all nodes in G • Let W* be the minimum among the widths of the paths pu • For all nodes u in V if W(pu) = W* then add (D(u), W(pu)) to the appropriate queue D’(u) • Remove from G all links with width at most W* • If s has no more outgoing links, then stop, else repeat Precomputing Multicast Trees - CS622

  18. Algorithm 3 • The widest-shortest paths in step 1 are found by a version of Dijkstra’s algorithm • Static-Heap Dijkstra’s algorithm has been shown to be the most efficient implementation. Precomputing Multicast Trees - CS622

  19. Time and Space Requirements Precomputing Multicast Trees - CS622

  20. Current Multicast Tree Design • The optimization problem to conserve resources is known to be NP complete. • Existing tree-calculation protocols do not solely optimize resources • Problem aggravated by the need to satisfy QoS restraints Precomputing Multicast Trees - CS622

  21. Computation of Constrained Trees • Obtain a multicast tree from the discontinuities previously calculated, with the following QoS constraints • Path width W(p) will be >Wmin • Path delay D(p) will be <d Precomputing Multicast Trees - CS622

  22. Computation of Constrained Trees • Assume that we need to create a multicast tree T • T is a subset U of the nodes V in G • Where D(T) < QoS constraint d • And W(T) is the width of the narrowest link in T Precomputing Multicast Trees - CS622

  23. Computation of Constrained Trees • Any calculated tree T must satisfy Property 1: • The delay duof discontinuity (du, Wu) is the smallest one among the delays of the discontinuities in D’(u) whose width is larger than or equal to Wmin Precomputing Multicast Trees - CS622

  24. Algorithm 4 • Assuming that D’(u) is an array • For each node u in U, determine W(p*u) • Determine Wmin of p*u • For each (d, W, u) in U determine the discontinuity having property 1 • Construct G’ using the predecessor node information stored in D’(u) Precomputing Multicast Trees - CS622

  25. Algorithm 4 Performance • Running Time: O(max{|U|logN, N}) Precomputing Multicast Trees - CS622

  26. Simulation Results • Simulations were run on two different networks • Power Law Networks: a network with N nodes and M links, where M=άN, ά > 1 • Real Internet Networks: observed internet topologies from 9/20/1998, 1/1/2000, and 2/1/2000 Precomputing Multicast Trees - CS622

  27. Simulation Results • The delays of the links in both network types were picked randomly. • Width 1 networks: width of each link chosen at random from the interval [1,100] • Width 2 networks: link width is a function of link delay, based on w = β(101 – d), where β is random from the interval [1,10] Precomputing Multicast Trees - CS622

  28. Simulation Results • Power Law networks generated with 400, 800, and 1200 nodes and ratios ά = 4, 8, 16 • Real networks selected with M = 9360, 16568, 27792 and N = 2107, 4120, 6474 Precomputing Multicast Trees - CS622

  29. Simulation Results Precomputing Multicast Trees - CS622

  30. Simulation Results Precomputing Multicast Trees - CS622

  31. Simulation Results • Running times are increased using Width 2 method, as there are more available discontinuities • Algorithm 2 has the best running time, Algorithm 3 the worst • Algorithm 1 takes up to 1.6 times as long as Algorithm 2 • Algorithm 3 takes up to 14 times as long as Algorithm 2 • Algorithm 2 performs the best, especially on larger networks Precomputing Multicast Trees - CS622

  32. Simulation Results • Algorithm 3 has the smallest memory requirements, followed closely by Algorithm 1. • Algorithm 2 requires significantly more space than either of Algorithms 1 and 3, due to the memory requirements of the two-dimensional array A[u, k] Precomputing Multicast Trees - CS622

  33. Conclusions • The performance of all algorithms decreases rapidly as u increases • Algorithm 1 presents the best trade-off between time and space requirements for precomputing tree paths. Precomputing Multicast Trees - CS622

  34. References • [1] S. Siachalou and L. Georgiadis. “Algorithms for Precomputing Constrained Widest Paths and Multicast Trees”. IEEE/ACM Transactions on Networking. Vol. 13, No. 5. pp 1174-1187. October 2005. • [2] S. Siachalou and L. Georgiadis. “Efficient QoS Routing”. INFOCOM 2003. 22nd Annual Joint Conference of the IEEE Computer and Communications Societies. Vol. 2. pp 938-947. 30 March-3 April 2003. Precomputing Multicast Trees - CS622

More Related