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. 10.22.2007 Precomputing Multicast Trees - CS622 2 Multicast Trees

3. 10.22.2007 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

4. 10.22.2007 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

5. 10.22.2007 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

6. 10.22.2007 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|

7. 10.22.2007 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)

8. 10.22.2007 Precomputing Multicast Trees - CS622 8 Network Model

9. 10.22.2007 Precomputing Multicast Trees - CS622 9 Network Model

10. 10.22.2007 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)

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

12. 10.22.2007 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: 1.Initialize queue D’(u) 2.Create all possible successor discontinuities to u 3.Store the discontinuities (d, W, u) for each u in P Note: (d, W, u) is generally stored as (d, W, u, prev_node)

13. 10.22.2007 Precomputing Multicast Trees - CS622 13 Algorithm 1 4.Take the discontinuity in the minimum lexicographic order off of the queue. 5.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. 6.Do this for all discontinuities in P

14. 10.22.2007 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

15. 10.22.2007 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)

16. 10.22.2007 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

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

18. 10.22.2007 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.

19. 10.22.2007 Precomputing Multicast Trees - CS622 19 Time and Space Requirements Worst Case Requirements Running TimeSpace Requirements Algorithm 1O(MNlogN + M 2 logN)Space: O(MN) Algorithm 2O(KNlogN + K 2 )Space: O(KN) Algorithm 3O(MNlogN + M 2 )Space: O(MN)

20. 10.22.2007 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

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

22. 10.22.2007 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

23. 10.22.2007 Precomputing Multicast Trees - CS622 23 Computation of Constrained Trees Any calculated tree T must satisfy Property 1: The delay du of 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

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

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

26. 10.22.2007 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

27. 10.22.2007 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]

28. 10.22.2007 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

29. 10.22.2007 Precomputing Multicast Trees - CS622 29 Simulation Results

30. 10.22.2007 Precomputing Multicast Trees - CS622 30 Simulation Results

31. 10.22.2007 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

32. 10.22.2007 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]

33. 10.22.2007 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.

34. 10.22.2007 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. 22 nd Annual Joint Conference of the IEEE Computer and Communications Societies. Vol. 2. pp 938-947. 30 March-3 April 2003.