1. QoS-Based Multicast Routing for Distributing Layered Video to Heterogeneous Receivers in Rate- based Networks Bin Wang and Jennifer C.Hou

2. Goal: QoS requirements of heterogeneous receivers, including bandwidth and delay; Highest receiving quality for receivers Minimize the total network resource consumption Solution: Source:Layered encoding(cummulative) Receivers: tradeoff between video quality and available bandwidth Scheduling: rate-based link scheduling Tree construction on weighted digraph G=(V,E) using the global state and an auxiliary routing table

3. Global state Link state: Available bandwidth: b(l), b:E  R +,the link bandwidth function, Constant delay: d l,which depends on the capacity,the propagation delay, and the maximum packet size Link cost Node state: available buffer… Global state: The collection of the local node/link state of all the nodes in the network Maintained by every node in the network

4. The Auxiliary Routing Table T is a |V| X H matrix, recording a h-hop maximum bandwidth path : P: path bw:maximum bandwidth on P Neighbour:next hop d h =sum(d l ): end-end constant delay *every node maintains a T

5. Rate-based Scheduling Algorithms Algorithms: Generalized Processor Sharing,Weighted Fair Queuing,Virtual Clock… Traffic model: leaky bucket (R,sigma) End-end delay bound on P: D(r,P)=(sigma+|P|*c)/r+sum(d l )

6. Traffic Model for Layered Video Each layer: leaky bucket(R,Sigma) Video signal: (R i,sigma i ), i:1~m (#of layers) Layer k: (R k,sigma k ), R k =sum j=1 k (R j ) sigma k =sum j=1 k (sigma j ) Layers are selectively forwarded on links

7. Problem Formulation The one-to-many multicast video distribution session: s:source d={j|j=1~n}: receivers {D j |j=1~n}:delay requirements {R j r |j=1~n}:maximum acceptable rates, layer-k receiver j: R k <=R j r <R k+1 How to construct a tree?

8. Algorithm Overview Starting from a tree with only s Higher-layer receiver i first Select the most appropriate path P from T A setup message is sent to i along P, carrying the data structure RECEIVER and D(delay) RECEIVER is updated by intermediate nodes, if better path is available Next off-tree receiver j is selected by i A fork message is sent from i A finish message is sent to s if no off-tree node

9. The RECEVIER data structure RECEIVER.RECEIVER[i] records the least- hop appropriate path P for receiver i: OnTreeNode: initialized to s path: P, with sufficient bandwidth r: the minimum bandwidth r i for delay cost: |P|*r, the total bandwidth due to receiver i(only for new branch) R r : maximum acceptable rate R r i level: # of layers tag: on-tree or off-tree

10. Path Selection from T Calculate the minimum bandwidth r i according to deley requirement: r i >=(sigma k +|p|*c)/(D i -sum(d l )) Select the least-hop path with T(i,h).bw>=max(r i,R k ) No loop Reserved bandwidth: max(r i,R k ) if no path exists,or r i >R r i, degrading layer (Lower cost? Best path?)

11. Next Off-Tree Receiver Selection Higher layer & Smaller cost node first: G k+1 =…=G m =0, G k <>0 Select the receiver i from G k with min(|P|*r i ) RECEIVER[i].tag=true A setup message is sent to i i will select next receiver j i sends a fork message to RECEIVER[j].OnTreeNode

12. Path Update Intermediate nodes update D&RECEIVER: Delay requirement (D:cumulative delay) D i >=D+(sigma k +|p|*c)/r i +sum(d l ) Select the minimum-hop path P from T(first entry T(i,h)) Smaller cost(total bandwidth): |P|*r i Update RECEIVER for every receiver i if smaller cost

13. Dynamic Receiver Join/Leave Goal: seamless transition via incremental changing Leave: Leaf node: leave message is sent upstream,and resource is released by a fork node Non-leaf node: just relay incoming downstream messages

14. Dynamic Receiver Join/Leave(cond.) Join: Join request to s with d i &R i r S multicasts a join message with RECEIVER[i]&D to all(?) on-tree receivers Intermediate nodes updates D,and RECEIVER if smaller cost path available The leaf receivers send back RECEIVER S select a fork node with least cost fork message (Why not use updated T? Least cost?)

15. Auxiliary Routing Table T Update Compute the h-hop maximum bandwidth paths from the current node to all the other nodes:iterate H times, h=1~H Update T(j,h)(j=1~|V): for every neighbour u of j, if no loop T(j,h).bw=max(T(j,h).bw,min(T(u,h-1).bw,b(u,j))) If loop exists(j in T(u,h-1).P), recursively calculate a new T(u,h-1) excluding j For complexity, excluding u if loop or limit the scope of recursion Run off-line and infrequently

16. Complexity # of messages: O(2*|d|) T update: exponential in the worst case If bapassing the loop: Check every neighbour u of j: O(|V|) Check loop and bw: O(H)+1 Run H times for every receiver: O(H)*O(|V|) So O(H 2 *|V| 2 )

17. Simulation Topology: vBNS, switch cluster,random network(Waxman method, which can obtain “real world” networks) Simulator: NetSim Q Comparing: maximum bandwidth tree algorithm Maxemchuk’s algorithm Varing parameters: lambda(session arrival rate),|d|,Dj Performance metrics: total bandwidth required, percentage of receivers attaining QoS

18. Maxemchuk’s Algorithm Minimize bandwidth consumption without considering QoS requirement Use modified T-M heuristic A variant of steiner tree problem: construct a minimum cost tree for a subset of nodes, with link cost fixed in the network Link cost: basic cost *highest reserved rate Construct from higher-rate receivers and then add lower-rate of receivers No explicit QoS consideration Centralization

19. Max Bandwidth Tree Algorithm For Layered-encoded data (cumulative) Compute the maximum available bandwidth tree to connect all receivers,receivers are classified by receiving capabilities Minimize the sum of satisfaction level For shorter path:select the node nearest to source (not guarantee shortest path) For bandwidth saving: reduce bandwidth from the receivers

20. Simulation results

21. Simulation results(cond)

24. Issues: The original Goal is achieved Shortest path? Smallest total cost?The best path? Complexity (scalability?): Global state T update Link state update Complexity! A good attemption!