Algorithms for Precomputing Constrained Widest Paths and Multicast Trees Paper by Stavroula...
-
date post
20-Dec-2015 -
Category
Documents
-
view
217 -
download
0
Transcript of Algorithms for Precomputing Constrained Widest Paths and Multicast Trees Paper by Stavroula...
Algorithms for Precomputing Constrained Widest Paths and Multicast Trees
Paper by Stavroula Siachalou and Leonidas Georgiadis
Presented by Jeremy Witmer
CS 622
Fall 2007
10.22.2007 Precomputing Multicast Trees - CS622
2
Multicast Trees
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
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
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
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|
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)
10.22.2007 Precomputing Multicast Trees - CS622
8
Network Model
10.22.2007 Precomputing Multicast Trees - CS622
9
Network Model
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)
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)
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)
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
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
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)
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
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
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.
10.22.2007 Precomputing Multicast Trees - CS622
19
Time and Space Requirements
Worst Case Requirements
Running Time Space Requirements
Algorithm 1 O(MNlogN + M2logN) Space: O(MN)
Algorithm 2 O(KNlogN + K2) Space: O(KN)
Algorithm 3 O(MNlogN + M2) Space: O(MN)
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
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
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
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
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)
10.22.2007 Precomputing Multicast Trees - CS622
25
Algorithm 4 Performance
Running Time: O(max{|U|logN, N})
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
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]
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
10.22.2007 Precomputing Multicast Trees - CS622
29
Simulation Results
10.22.2007 Precomputing Multicast Trees - CS622
30
Simulation Results
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
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]
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.
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. 22nd Annual Joint Conference of the IEEE Computer and Communications Societies. Vol. 2. pp 938-947. 30 March-3 April 2003.