QoS-Based Multicast Routing for Distributing Layered Video to

Heterogeneous Receivers in Rate-based Networks

Bin Wang and Jennifer C.Hou

Goal:• QoS requirements of heterogeneous receivers,

including bandwidth and delay;• Highest receiving quality for receivers• Minimize the total network resource consumptionSolution:• 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

Global stateLink state:• Available bandwidth: b(l), b:ER+,the link

bandwidth function,• Constant delay: dl,which depends on the

capacity,the propagation delay, and the maximum packet size

• Link costNode 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

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

• dh=sum(dl): end-end constant delay

*every node maintains a T

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(dl)

Traffic Model for Layered Video

• Each layer: leaky bucket(R,Sigma)

• Video signal: (Ri,sigmai), i:1~m (#of layers)

• Layer k: (Rk,sigmak),

Rk=sumj=1k(Rj)

sigmak=sumj=1k(sigmaj)

• Layers are selectively forwarded on links

Problem FormulationThe one-to-many multicast video distribution

session:

s:source

d={j|j=1~n}: receivers

{Dj|j=1~n}:delay requirements

{Rjr|j=1~n}:maximum acceptable rates,

layer-k receiver j: Rk<=Rjr<Rk+1

How to construct a tree?

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

The RECEVIER data structureRECEIVER.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 ri for delay

• cost: |P|*r, the total bandwidth due to receiver i(only for new branch)

• Rr: maximum acceptable rate Rri

• level: # of layers

• tag: on-tree or off-tree

Path Selection from T• Calculate the minimum bandwidth ri

according to deley requirement:

ri>=(sigmak+|p|*c)/(Di-sum(dl))

• Select the least-hop path with T(i,h).bw>=max(ri,Rk)

• No loop

• Reserved bandwidth: max(ri,Rk)

• if no path exists,or ri>Rri, degrading layer

(Lower cost? Best path?)

Next Off-Tree Receiver Selection Higher layer & Smaller cost node first:• Gk+1=…=Gm=0, Gk<>0 • Select the receiver i from Gk with min(|P|

*ri)• 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

Path UpdateIntermediate nodes update D&RECEIVER:

• Delay requirement (D:cumulative delay) Di>=D+(sigmak+|p|*c)/ri+sum(dl)

• Select the minimum-hop path P from T(first entry T(i,h))

• Smaller cost(total bandwidth): |P|*ri

• Update RECEIVER for every receiver i if smaller cost

Dynamic Receiver Join/LeaveGoal: 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

Dynamic Receiver Join/Leave(cond.)

Join:• Join request to s with di&Ri

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?)

Auxiliary Routing Table T UpdateCompute 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

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(H2*|V|2)

Simulation• Topology: vBNS , switch cluster,random network(Waxman

method, which can obtain “real world” networks)• Simulator: NetSimQ

• 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

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

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

Simulation results

Simulation results(cond)

Simulation results(cond)

Simulation results(cond)

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!