Loading in 5 sec....

A Heuristic Ant Algorithm for Solving QoS Multicast Routing ProblemPowerPoint Presentation

A Heuristic Ant Algorithm for Solving QoS Multicast Routing Problem

Download Presentation

A Heuristic Ant Algorithm for Solving QoS Multicast Routing Problem

Loading in 2 Seconds...

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

A Heuristic Ant Algorithm for Solving QoS Multicast Routing Problem

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

A Heuristic Ant Algorithm for Solving QoS Multicast Routing Problem

Chao-Hsien Chu; JunHua Gu; Xiang Dan Hou; Qijun Gu

Congress on Evolutionary Computation

Proceedings of the 2002

- Introduction
- Ant Colony Behaviors
- QoS Multicast Routing Model
- Ant Algorithm
- Result and Analysis
- Conclusions

- QoS Multicasting Routing(QMR) Problem：
- Concerns the search of optimal routing trees while meeting all QoS requirements;
- Is NP-complete;
- Can be solved by：
- Dijkstra algorithm to find the shortest path,
- Steiner tree routing algorithm to seek minimum networking cost,
- Finding multicast tree that paths cost is minimized.

- When an obstacle appears on the moving path of an ant population, ants can find a new optimal path quickly. Because：
- An ant can excrete a material, called pheromone, along the path on which it moves.
- Ants can sense this material and detect its intensity.
- They can then use pheromone intensity as a guide to move and tend to move toward the direction of higher intensity, thus the ants can find the food by this kind of information exchange.

- The key features of an ant algorithm include：
- Distributed computation,
- Positive feedback,
- And constructive greedy heuristic.

- The network is considered as a connected, undirected and weighted graph.
- N<V,E>：
- V denotes the set of network nodes,
- E denotes the set of bi-directional links,
- sєV is the source node in multicast,
- is the set of destination node in multicast.

- For any link eєE：
- Delay function, delay(e)：E→R,
- Delay jitter function, delay_jitter(e)：E→R,
- Cost function, cost(e)：E→R,
- Bandwidth function, bandwidth(e)：E→R.

- For each node nєV：
- Delay function, delay(n)：V→R,
- Delay jitter function, delay_jitter(e)：V→R,
- Cost function, cost(e)：V→R,
- Packet lost rate function, packet_loss(e)：V→R.

- Relationships exist in the multicast tree T(s,M)：
- Delay(PT(s,t))=
- Cost(T(s,M))=
- Bandwidth(PT(s,t))=min{bandwidth(e),eєPT(s,t)}
- Delay_jitter(PT(s,t))=
- Packet_loss(PT(s,t))=
- Where PT(s,t) is the routing path from s to t.

- To find a multicast tree T(s,M), which satisfies：
- Delay constraint：Delay(PT(s,t))≦Dt,
- Bandwidth constraint：Bandwidth(PT(s,t))≧B,
- Delay jitter constraint：Delay_jitter(PT(s,t))≦DJt,
- Packet loss rate constraint：Packet_loss(PT(s,t))≦PLt,
- And Cost(T(s,M)) is minimized.

- Init(); // step 1
- CheckConstraint(PL,B); // step 2
- SetupUp(tabu); // step 3
- ChooseNextNode(tabu); // step 4
- ComputeIntensity(); // step 5
- UpdateIntensity(); // step 6
- CheckStop(); // step 7

- 1) Initialize network nodes
- t:=0; NC:=0; τij=c; △τij =0;

- 2) Check PL/B (packet loss rate/Bandwidth) of all nodes, deletes those edges that do not satisfy the PL/bandwidth constraint.

- 3) Setup tabu table.
- s:=1;
- For k:=1 to m
Put the values of source node into tabuk(s);

/* Tabu is used to save the nodes that were reached before t. tabuk(s) denotes the s-th node visited by the k-th ant in the current route and s is the index of tabu table. */

- 4) Repeat this step until tabu is full.
- s:=s+1;
- For k:=1 to m
Choose a node j according to the probability：

- Compute the delay and delay jitter to reach node j. If the result exceeds the constraints, choose a new node; otherwise move the k-th ant to node j.

- 5) Compute △τkij and △τij .
- For k:=1 to m (?)
For every edge(i,j)

For k:=1 to m

Set

Set △τij:=△τij+△τkij

- For k:=1 to m (?)

- 6) Compute τij(t+n) for every edge (i,j).
- τij(t+n)=ρ*τij(t)+△τij
- t:=t+n; NC:=NC+1;
- Set △τij:=0 for every edge (i,j).

- 7) Check stop condition.
- If (NC<NCmax) and (not develop state) then
empty all tabu; goto step 2.

else

output the minimum cost path until all nodes have beenpassed.

- If (NC<NCmax) and (not develop state) then

B=70,D=46, DJ=8, PL=0.001

Source Node

Destination

Node

Performance of Ant Algorithm

Performance of Genetic Algorithm

Scalability of ant algorithm – 16 nodes

Scalability of ant algorithm – 20 nodes

- The ant algorithm has the characteristics：
- The cost curve is stable,
- Optimum or suboptimum can be found quickly,
- Delay jitter curve can turn to stability quickly,
- Good scalability.

- Applying ant algorithm to solve QMR is a new attempt and needs more extensive tests.