Loading...

PPT – Algorithms for Precomputing Constrained Widest Paths and Multicast Trees PowerPoint presentation | free to download - id: 15f812-ZDc1Z

The Adobe Flash plugin is needed to view this content

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 - Adding on a widest-bandwidth path
- Paths with QoS constraints

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

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

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

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)

Network Model

Network Model

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) gt W(p) for all paths

Pu(d)

Dominated Pairs

- Pair (D(p1), W(p1)) dominates pair (D(p2), W(p2))

or path p1 dominates path p2 iff - W(p1) gt W(p2) and D(p1) lt D(p2)
- OR
- W(p1) gt W(p2) and D(p1) lt D(p2)

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)

Algorithm 1

- Take the discontinuity in the minimum

lexicographic order off of the queue. - If the current discontinuity pair isnt 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

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

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 Au,k where 1 lt k lt K, K lt M
- Instead of storing possible discontinuities by

node u, on queues D(u), store on K heaps H(k)

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

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

Algorithm 3

- The widest-shortest paths in step 1 are found by

a version of Dijkstras algorithm - Static-Heap Dijkstras algorithm has been shown

to be the most efficient implementation.

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)

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

Computation of Constrained Trees

- Obtain a multicast tree from the discontinuities

previously calculated, with the following QoS

constraints - Path width W(p) will be gt Wmin
- Path delay D(p) will be lt d

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) lt QoS constraint d
- And W(T) is the width of the narrowest link in T

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

Algorithm 4

- Assuming that D(u) is an array
- For each node u in U, determine W(pu)
- Determine Wmin of pu
- For each (d, W, u) in U determine the

discontinuity having property 1 - Construct G using the predecessor node

information stored in D(u)

Algorithm 4 Performance

- Running Time O(maxUlogN, N)

Simulation Results

- Simulations were run on two different networks
- Power Law Networks a network with N nodes and M

links, where M?N, ? gt 1 - Real Internet Networks observed internet

topologies from 9/20/1998, 1/1/2000, and 2/1/2000

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

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

Simulation Results

Simulation Results

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

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

Au, k

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.

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.