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 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 - 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) for each u in P Note: (d, W, u) is generally stored as (d, W, u, prev_node)

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

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 discontinuity links Note: P is implemented as a heap in this algorithm

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

Precomputing Multicast Trees - CS 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 - 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 tree-calculation protocols do not solely optimize resources Problem aggravated by the need to satisfy QoS restraints

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

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 d 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 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

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

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

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

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.