Download Presentation

Loading in 3 Seconds

This presentation is the property of its rightful owner.

X

Sponsored Links

- 76 Views
- Uploaded on
- Presentation posted in: General

Routing and Congestion Problems in General Networks

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Routing and Congestion Problems in General Networks

Presented by Jun Zou

CAS 744

- 1. Introduction to Routing and Congestion
- 2. Network Model and Objective
- 3. Construction of Tree
- 4. Simulation Graph on Tree
- 5. Simulation Tree on Graph
- 6. Conclusion and Application
- 7. References: its full paper and improved one

- The function of routing is to find a ‘best’ path from source to destination for each incoming packet.
- What is ‘best’? : Minimum hop count, minimum delay, security, etc
- In this paper, our goal is to minimize the congestion of the whole network links.

- Network: a weighted graph G=(V, E)
- |V|=n nodes and |E|=m edges
- Bandwidth: a function b(e): E→ R+
- Absolute load: amount of data transmitted on a edge e
- Relative load L(e): Absolute load/bandwidth
- Congestion C: Maximum over the relative load of all links in the network

- Traffic modeling and simulation: Simplify the traffic model (such as M/M/1 model), simulate the routing protocols and analyze results by using queuing theory

- Simulation graph on a tree: Combine a tree solution of an online problem and tree representation of the network

- Oblivious routing algorithm: path selection for the i-th request σi does not depend on routing decisions made for other requests σj
- Oblivious adversary: The request sequence {σ} is not allowed to depend on the selection of online algorithms

- Assumption: There is a ct-competitive online algorithm for the tree TG=(Vt, Et)associated with a graph G=(V,E):
(1)

- Target: For the same algorithm, find a small factor c for the graph G=(V,E) , satisfying
(2)

- 1st step: Find a method to construct an associated tree which satisfies the following conditions:
- 2nd step: A tree TG can simulate the network G, i.e. for any request sequence σ, an algorithm which produces congestion C when it is processed on graph G,, also produces congestion when it is processed on the tree TG.
- 3rd step: Prove that for any request sequence σ, an online algorithm which produces congestion Ctwhen it is processed on TG,, also produces congestion when it is processed on G.

→

A graph G=(V,E): Associated tree TG=(Vt, Et)

- Vt: a node inTG
- SVt: the cluster in G corresponding to Vt
- Bandwidth between two sets

- Bandwidth of edges leaving set X:
- The height of TG: h(TG)
- Set of all level nodes:

- Weight function:
For a subset X, the bandwidth of all edges that are adjacent to nodes in X and that do not connect nodes of the same cluster to .

One important property: Additive

Example

- Bandwidth-ratio:

- weight-ratio:

- A node is simulated by a node vt in TG corresponding to cluster Svt = {v}.
- So, a message sent between node u and v in G is sent along one unique path connecting the respective counterparts in TG.
- Example
- Our goal is to states that this simulation does not increase the congestion.

- Theorem 1: For any request σ for an routing problem on network G that can be processed with congestion C, its simulation on TG yields congestion

- Proof:

- A level node vt of TG is simulated by a random node of the corresponding cluster Svt with the probability:

- Example

- Theorem 2: The expectation of the relative load L(e) of an edge in graph G, due to the simulation of a tree strategy on G is bounded by

where Ctis the congestion on TG, h=h(TG),

- Concurrent Multi-commodity Flow Problem (CMCF): Each commodity fu,vhas a flow size q.du,v, where q is the maximized minimal throughput fraction over all commodities, and

- Expected number of messages have to be routed between u and v is

- The minimum capacity of edge is q.du,v,, so the expected relative load at level l is at mostCt/q,
- Its expected relative load at all levels is

- q has a lower bound：

- Therefore, the expected relative load on G has a upper bound:

- So far, we show that a path of tree can be simulated by a path in graph such that the expected relative load of this path on the graph has a upper bound.
- Our goal is to show that the congestion in graph also has a upper bound compared to that in tree, i.e, to satisfy the lemma 2. So we should extend the expected value to ‘true’ value, that means show:
L(e)=O(L(e))

- Theorem 3: Give a graph G and an associated tree, there exists an oblivious online routing algorithm, which is
-competitive with respect to the congestion.

- Let X1, X2,…Xn be independent 0-1random variables, i.e.
Pr (Xi=1)=pi,

m=p1+p2+…+pn,

S=X1+X2+…+Xn,then

- Theorem 4: Give a graph G, there exists a associated tree that has height h(TG)=O(log n), maximum bandwidth ratio λ(TG)= O(log n), and maximum weight ratio δ(TG)=O(log n).
- The online routing algorithm is -competitive.

- The paper proposes a method to construct a associated tree regarding to a general network and proves that the congestion on the network is only a small factor c= larger than the congestion on the tree.
- Since the tree topology is much simpler than graph, we can study the routing algorithm on a tree and also can get a ‘good’ competitive algorithm on the general network. It is a very useful tool for research on routing problems on general networks.

- Full paper: The paper published in the conference IEEE FOCS’02 skips some proofs due to space limitation. I contacted the author and got the full paper. It is available to everyone If you are interested.
- Improved paper: The author improve the results in the following paper:
“A Practical Algorithm for Constructing Oblivious Routing Schemes”, published at fifteenth annual ACM symposium on Parallel algorithms and architectures.