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

Precomputing Multicast Trees - CS622 2 Overview 1.Large Multicast Trees 2.Proposed Solution for adding nodes 3.Network Model 4.Precomputation Algorithms 5.Time and Space Requirements 6.Multicast Tree Algorithm 7.Simulated Results 8.Conclusion

Precomputing Multicast Trees - CS622 3 Multicast Trees

Precomputing Multicast Trees - CS622 4 Large Multicast Trees In large networks, adding nodes becomes inefficient Wish to add nodes on a widest-bandwidth path Wish to add nodes with QoS constraints

Precomputing Multicast Trees - CS622 5 Definitions Constrained Widest Path: the path that provides the most leftover bandwidth, after bandwidth requirements are satisfied and delay constraints are guaranteed to be met

Precomputing Multicast Trees - CS622 6 Proposed Solution Precompute as many of the links in the tree as possible When adding a node, calculate delay and bandwidth for the links it has to other nodes in the network When a node is added to the multicast tree, choose the path with the highest available bandwidth while obeying QoS delay constraints

Precomputing Multicast Trees - CS622 7 Proposed Solution Solution defined as solutions to two separate problems First, compute the delay and width data for the links in the network, and when nodes are added to the network Second, selection of a new path from the precomputed data when a new node subscribes to the multicast tree

Precomputing Multicast Trees - CS622 8 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 9 Network Model Each edge in E has a corresponding delay and width, (d,W), where width is the available bandwidth in a link A path from source node s to another node u in the network with delay no greater than d is represented as Pu(d) The optimal path is represented as Pu*(d) A path is defined in terms of the overall delay D(p) and minimum width W(p)

Precomputing Multicast Trees - CS Network Model

Precomputing Multicast Trees - CS Network Model

Precomputing Multicast Trees - CS 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 - CS 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)

Precomputing Multicast Trees - CS 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) in P for each u in V Note: (d, W, u) is actually stored as (d, W, u, prev_link)

Precomputing Multicast Trees - CS Algorithm 1 4.Take the discontinuity in the minimum lexicographic order off of P, in the form (d, W, u). 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

Precomputing Multicast Trees - CS Algorithm 1

Precomputing Multicast Trees - CS 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 predecessor discontinuities

Precomputing Multicast Trees - CS Algorithm 2 P is an array A[u,k] where 1 < k < K, K < M where k is a function of the width w of a link Initialize H[k] heaps, one for each k Initialize D’(u) queues, one for each node u

Precomputing Multicast Trees - CS Algorithm 2 1.For each node u, generate all discontinuities (d, k, u) 2.Add or replace the discontinuity at A[u,k] only if d is < the discontinuity at A[u,k], and add the discontinuity to H[k] 3.Starting at the last column in A (largest width discontinuities), find the first non-empty heap H[k] 4.Find the lexicographically smallest discontinuity (d, k, u) in H[k]. 5.If d is < the smallest discontinuity (dmin, kmin, u) currently on D’(u), add (d, k, u) to D’(u) 6.Set A[u,k] to null 7.Repeat until all entries in A[u,k] are null or all H[k] are empty

Precomputing Multicast Trees - CS Algorithm 2

Precomputing Multicast Trees - CS Algorithm 2 Since the algorithm works from largest to smallest widths k in A, and only adds links that have delay < the current delay on D’(u), D’(u) is guaranteed to have the best possible links

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

Precomputing Multicast Trees - CS Algorithm 3 The widest-shortest paths in step 1 are found by Dijkstra’s Algorithm

Precomputing Multicast Trees - CS 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)

Precomputing Multicast Trees - CS Current Multicast Tree Design The optimization problem to conserve resources is known to be NP complete. Existing multicast tree-calculation protocols do not rely on trees that solely optimize resources Problem aggravated by the need to satisfy QoS restraints

Precomputing Multicast Trees - CS Problem 2 Given a source node s, a destination node set U, and delay requirement dmax, find a multicast tree T that satisfies a width requirement Wmin 1.Path width W(p) will be > Wmin 2.Path delay D(p) will be < dmax

Precomputing Multicast Trees - CS 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 dmax And W(T) is the width of the narrowest link in T

Precomputing Multicast Trees - CS Computation of Constrained Trees Any calculated tree T must satisfy Property 1: The delay d of discontinuity (d, W, u) 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 - CS Algorithm 4 Assuming that D’(u) is an array 1.For all nodes in U, determine the minimum width Wmin that has a delay still less than dmin 2.For each (d, W, u) in each of the arrays D’, determine the discontinuity having property 1, and mark that discontinuity as belonging to the tree 3.Construct T using the predecessor node information stored in D’(u)

Precomputing Multicast Trees - CS Algorithm 4 Performance Running Time: O(max{|U|logN, N}) Space Requirements: O(U)

Precomputing Multicast Trees - CS 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 - CS Simulation Results The delays of the links in both network types were picked randomly in the interval [1,100]. 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 - CS Simulation Results Power Law networks generated with 400, 800, and 1200 nodes and ratios ά = 4, 8, 16 Real networks selected with M = 9360, 16568, and N = 2107, 4120, 6474

Precomputing Multicast Trees - CS Simulation Results

Precomputing Multicast Trees - CS Simulation Results

Precomputing Multicast Trees - CS Simulation Results

Precomputing Multicast Trees - CS Simulation Results

Precomputing Multicast Trees - CS 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 - CS 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 - CS 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. Algorithm 4 is simple by comparison, picking the multicast tree T is fairly quick, no matter the number of subscriber nodes

Precomputing Multicast Trees - CS 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 October [2] S. Siachalou and L. Georgiadis. “Efficient QoS Routing”. INFOCOM nd Annual Joint Conference of the IEEE Computer and Communications Societies. Vol. 2. pp March-3 April 2003.