- Every node keeps information about every other node in the network
- In case of adaptive routing, the routing calculations are done and updated for all the nodes.

- The Sub-network level, where each node in a region has information about its peers in the same region and about the region's interface with other regions. Different regions may have different 'local' routing algorithms. Each local algorithm handles the traffic between nodes of the same region and also directs the outgoing packets to the appropriate interface.
- The Network Level, where each region is considered as a single node connected to its interface nodes. The routing algorithms at this level handle the routing of packets between two interface nodes, and is isolated from intra-regional transfer.

In Hierarchical routing, the interfaces need to store information about:

- All nodes in its region which are at one level below it.
- Its peer interfaces.
- At least one interface at a level above it, for outgoing packages.

- Smaller sizes of routing tables.
- Substantially lesser calculations and updates of routing tables.

- Once the hierarchy is imposed on the network, it is followed and possibility of direct paths is ignored. This may lead to sub optimal routing.

- Initially, a path between nodes wishing to communicate is found out, either by flooding or by any other suitable method.
- This route is then specified in the header of each packet routed between these two nodes. A route may also be specified partially, or in terms of some intermediate hops.

- Bridges do not need to lookup their routing tables since the path is already specified in the packet itself.
- The throughput of the bridges is higher, and this may lead to better utilization of bandwidth, once a route is established.

- Establishing the route at first needs an expensive search method like flooding.
- To cope up with dynamic relocation of nodes in a network, frequent updates of tables are required, else all packets would be sent in wrong direction. This too is expensive.

**Minimum number of hops:**If each link is given a unit cost, the shortest path is the one with minimum number of hops. Such a route is easily obtained by a breadth first search method. This is easy to implement but ignores load, link capacity etc.**Transmission and Propagation Delays:**If the cost is fixed as a function of transmission and propagation delays, it will reflect the link capacities and the geographical distances. However these costs are essentially static and do not consider the varying load conditions.**Queuing Delays:**If the cost of a link is determined through its queuing delays, it takes care of the varying load conditions, but not of the propagation delays.

**Notation: **

d _{i,j }
= Length of path between nodes i and j, indicating the
cost of the link.

h
= Number of hops.

D[ i,h] =
Shortest path length from node i to node 1, with upto 'h' hops.

D[ 1,h] = 0
for all h .

**Algorithm :**

Initial condition :
D[ i, 0] = infinity, for all i ( i != 1 )

Iteration
:
D[i, h+1] = min_{ }{ d_{i,j} + D[j,h] }
over all values of j .

Termination : The algorithm terminates when

D[i, h] = D [ i, h+1] for all i .

**Principle: **

For zero hops, the minimum length path has length of infinity, for
every node. For one hop the shortest-path length associated with
a node is equal to the length of the edge between that node and node
1. Hereafter, we increment the number of hops allowed, (from h to h+1 )
and find out whether a shorter path exists through each of the other
nodes. If it exists, say through node 'j', then its length
must be the sum of the lengths between these two nodes (i.e. d_{i,j}
) and the shortest path between j and 1 obtainable in upto h paths. If
such a path doesn't exist, then the path length remains the same.
The algorithm is guaranteed to terminate,
since there are utmost N nodes, and so N-1 paths. It has time complexity
of O ( N^{3} ) .

**Notation:**

D_{i } = Length of shortest
path from node 'i' to node 1.

d_{i,j } = Length of path between
nodes i and j .

**Algorithm**

Each node j is labeled with Dj, which is an estimate of cost
of path from node j to node 1. Initially, let the estimates be infinity,
indicating that nothing is known about the paths. We now iterate
on the length of paths, each time revising our estimate to lower values,
as we obtain them. Actually, we divide the nodes into two groups ; the first one, called set P contains the nodes whose shortest distances have been found, and the other Q containing
all the remaining nodes. Initially P contains only the node 1. At each step,
we select the node that has minimum cost path to node 1. This node is transferred
to set P. At the first step, this corresponds to shifting the node
closest to 1 in P. Its minimum cost to node 1 is now known. At the next
step, select the next closest node from set Q and update the labels corresponding
to each node using :

Finally, after N-1 iterations, the
shortest paths for all nodes are known, and the algorithm terminates.

**Principle**

Let the closest node to 1 at some step be i. Then i is shifted to P. Now,
for each node j , the closest path to 1 either passes through i or it doesn't.
In the first case Dj remains the same. In the second case, the revised
estimate of D_{j} is the sum D_{i } + d_{i,j
}. So we take the minimum of these two cases and update D_{j }accordingly.
As each of the nodes get transferred to set P, the estimates get closer
to the lowest possible value. When a node is transferred, its shortest
path length is known. So finally all the nodes are in P and the D_{j
}'s represent the minimum costs.
The algorithm is guaranteed to terminate in N-1 iterations and its complexity is
O( N^{2} ).

**Notation**

D_{i,j} [n] = Length
of shortest path between the nodes i and j using only the nodes 1,2,....n
as intermediate nodes.

**Initial Condition**

Di,j[0] = d_{i,j }
for all nodes i,j .

**Algorithm**

Initially, n = 0. At each iteration,
add next node to n. i.e. For n = 1,2, .....N-1 ,

Di,j[n + 1] = min { D_{i,j}[n]
, D_{i,n+1}[n] + D_{n+1,j}[n] }

**Principle**

Suppose the shortest path between i and j using nodes 1,2,...n is known.
Now, if node n+1 is allowed to be an intermediate node, then the shortest
path under new conditions either passes through node n+1 or it doesn't.
If it does not pass through the node n+1, then D_{i,j}[n+1] is
same as D_{i,j}[n] . Else, we find the cost of the new route,
which is obtained from the sum, D_{i,n+1}[n] + D_{n+1,j}[n].
So we take the minimum of these two cases at each step. After adding
all the nodes to the set of intermediate nodes, we obtain the shortest
paths between all pairs of nodes together. The complexity of
Floyd-Warshall algorithm is O ( N^{3} ).

It is observed that all the three algorithms mentioned above give comparable performance, depending upon the exact topology of the network.

back to top

Prev| Next | Index