Introduction to NetworkingProject 3

Routing

Graph abstraction for routing algorithms:

graph nodes are routers graph edges are

physical links link cost: delay, $ cost,

or congestion level

Goal: determine “good” path

(sequence of routers) thru network from source to

dest.

Routing protocol

A

ED

CB

F

2

2

13

1

1

2

53

5

“good” path: typically means

minimum cost path other def’s possible

Routing Algorithm classificationGlobal or decentralized

information?Global: all routers have complete

topology, link cost info “link state” algorithms

Decentralized: router knows physically-

connected neighbors, link costs to neighbors

iterative process of computation, exchange of info with neighbors

“distance vector” algorithms

Static or dynamic?Static: routes change slowly

over time

Dynamic: routes change more

quicklyperiodic update in response to link

cost changes

A Link-State Routing Algorithm

Dijkstra’s algorithm net topology, link costs known to all

nodes accomplished via “link state

broadcast” all nodes have same info

computes least cost paths from one node (‘source”) to all other nodes gives routing table for that node

iterative: after k iterations, know least cost path to k dest.’s

Notation: c(i,j): link cost from node i to j.

cost infinite if not direct neighbors

D(v): current value of cost of path from source to dest. V

p(v): predecessor node along path from source to v, that is next v

N: set of nodes whose least cost path definitively known

Dijsktra’s Algorithm1 Initialization: 2 N = {A} 3 for all nodes v 4 if v adjacent to A 5 then D(v) = c(A,v) 6 else D(v) = infinity 7 8 Loop 9 find w not in N such that D(w) is a minimum 10 add w to N 11 update D(v) for all v adjacent to w and not in N: 12 D(v) = min( D(v), D(w) + c(w,v) ) 13 /* new cost to v is either old cost to v or known 14 shortest path cost to w plus cost from w to v */ 15 until all nodes in N

Dijkstra’s algorithm: exampleStep

012345

start NA

ADADE

ADEBADEBC

ADEBCF

D(B),p(B)2,A2,A2,A

D(C),p(C)5,A4,D3,E3,E

D(D),p(D)1,A

D(E),p(E)infinity

2,D

D(F),p(F)infinityinfinity

4,E4,E4,E

A

ED

CB

F

2

2

13

1

1

2

53

5

Distance Vector Routing Algorithmiterative: continues until no nodes

exchange info. self-terminating: no

“signal” to stop

asynchronous: nodes need not

exchange info/iterate in lock step!

distributed: each node

communicates only with directly-attached neighbors

Distance Table data structure each node has its own row for each possible destination column for each directly-attached

neighbor to node example: in node X, for dest. Y via

neighbor Z:

D (Y,Z)X

distance from X toY, via Z as next hop

c(X,Z) + min {D (Y,w)}Z

w

=

=

Distance Vector Routing Algorithmiterative: continues until no nodes

exchange info. self-terminating: no

“signal” to stop

asynchronous: nodes need not

exchange info/iterate in lock step!

distributed: each node

communicates only with directly-attached neighbors

wait for (change in local link cost of msg from neighbor)

recompute distance table

if least cost path to any dest

has changed, notify neighbors

Each node:

Routing LabProject 3 A distance-vector algorithm and a link-state

algorithm in the context of a simple routing simulator

Event-driven Simulation: event to event simulation, instead of simulating passage of time directly main loop repeatedly pulls the earliest event from a

event queue and passes it to a handler until there are no more events in the queue.

context.cc/context.h     SimulationContext (Written for you) demo.topo     A demonstration network topology file demo.event    A demonstration event file error.h       event.cc/event.h       Event (Written for you) eventqueue.cc/eventqueue.h EventQueue (Written for you) link.cc/link.h        Link (Written for you) Makefile  messages.cc   RoutingMessage (You will write this) messages.h node.cc       Node (You will extend this) node.h routesim.cc   main program table.cc      RoutingTable (You will write this) table.h   topology.cc/topology.h    Topology (Written for you)

“make TYPE=GENERIC” will build a single executable “routesim”, which contains no routing algorithm.

You will do TYPE=DISTANCEVECTOR and TYPE=LINKSTATE

To run: ./routesim topologyfile eventfile [singlestep]

Events in routesim come from the topology file, the event file, and from handlers that are executed in response to events.

The topology file generally only contains events that construct the network topology (the graph) arrival_time ADD_NODE node_num latency bandwidth arrival_time DELETE_NODE node_num latency bandwidth arrival_time ADD_LINK src_node_num dest_node_num latency

bandwidth arrival_time DELETE_LINK src_node_num dest_node_num

latency bandwidth

The event file generally only contains events that modify link characteristics in the graph, or draw the graph, a path and etc. arrival_time CHANGE_NODE node_num latency

bandwidth arrival_time CHANGE_LINK src_node_num

dest_node_num latency bandwidth arrival_time DRAW_TOPOLOGY arrival_time DRAW_TREE src_node_num

Note that although each link event contains both bandwidth and latency numbers, your algorithms will determine shortest paths using only the link latencies.

The Node class (4 functions that you must implement) void Node::LinkHasBeenUpdated(const Link *l)

is called to inform you that an outgoing link connected to your node has just changed its properties.

void Node::ProcessIncomingRoutingMessage(const RoutingMessage *m) is called when a routing message arrives at a node. In response,

you may send further routing messages using SendToNeighbors or SendToNeighbor. You may also update your tables.

Node *Node::GetNextHop(const Node *dest) const is called when the simulation wants to know what your node

currently thinks is the next hop on the path to the destination node. You should consult your routing table and then return the correct next node for reaching the destination.

Table *Node::GetRoutingTable() const is called when the simulation wants to get a copy of your current

routing table.

Your implementation will consist of implementations of the above four functions, as well as implementations of Table and RoutingMessage

The table class Mainly contains the routing table, different for

DISTANCEVECTOR and LINKSTATE as discussed in the class, please refer to your lecture notes.

Note that STL data structures can be quite useful here especially vector and map. Vectors can be used to store an unbounded array. Maps can be used to associate a value for each node in the

graph, like the latency to each neighbor. For example the cost table for LINKSTATE can be specified as

map< int, double > costtable which maps a double to an int. For a good reference to STL, see the recitals page. You should also know how iterators work if you plan to use these data structures.

The RoutingMessage Class

Implements the routing messages which will be sent by each node to its neighbors.

Need to carefully think what will go inside these routing messages depending on the routing algorithm you are implementing.LINKSTATE routing messages contain more

information than DISTANCEVECTOR routing messages.

General approach to implement a routing algorithm

Understand what routesim (TYPE=GENERIC) is doing. Read the link.h file to understand the Link class. Develop a Table class. This should provide you with what you

need to implement the GetNextHop() and GetRoutingTable() calls. It should also be updatable, as its contents will change with link updates and routing messages.

Extend the Node data structure to include your table Implement Node::GetNextHop() and Node::GetRoutingTable() Develop your routing message. Think about where your routing

message will go. Implement Node::LinkHasBeenUpdated () Implement Node::ProcessRoutingMessage() Implement Node::TimeOut(), if needed.

A number of ways to implementation

The rest are some sample codes, they are only showing you some rough idea on how to implement, DO NOT directly copy them in your own implementation, the sample codes does NOT guarantee to work;

Sample code in LSLinkHasBeenUpdated(const Link *l)

void Node::LinkHasBeenUpdated(const Link *l) { cerr << *this<<": Link Update: "<<*l<<endl;

/***********update own lsa database*****************/ double ts = (*context).GetTime(); lsatb->update_link(l->GetSrc(), l->GetDest(), l->GetLatency(), ts);

/*************Pass this to its neighbours*****************/ RoutingMessage *m = new RoutingMessage(); (*m).LSAs.push_back(lsa(l->GetSrc(), l->GetDest(), l-

>GetLatency(),ts)); SendToNeighbors(m); }

void Node::SendToNeighbors(const RoutingMessage *m) { cerr << "Flooding source ID: "<< number <<endl; deque<Node*> *ngbr = GetNeighbors(); for(deque<Node*>::iterator i = ngbr->begin(); i!= ngbr->end(); i++) { SendToNeighbor(*i,m); }

}

void Node::SendToNeighbor(const Node *n, const RoutingMessage *m) { cerr << "SendToNeighbor (Ngbr id: "<< n->number <<endl; Link l; l.SetSrc(number); l.SetDest((*n).number); Link *ml = context->FindMatchingLink(&l); assert(ml!=NULL); assert(n!=NULL); assert(m!=NULL); assert(context!=NULL); Event *e = new Event ((*context).GetTime()+(*ml).GetLatency(),

ROUTING_MESSAGE_ARRIVAL,(void*)n, (void*)m); (*context).PostEvent(e); }

Sample of Table head file for LS algorithm

class Table { public:

Table(unsigned my_id); ostream & Print(ostream &os) const; bool update_link(const unsigned s, const unsigned d, double l, double ts);

int get_next_hop(unsigned dest); Table *get_routing_table() const; protected:

void dijkstra(); int find_next_hop(data curr, vector<data> v, vector<unsigned> next);

private: unsigned my_id; vector<unsigned> nodes; vector<aLink*> links;

map<unsigned, int> routes;};

Pseudocode of Dijkstra Algorithm from Wiki

Pseudocode of B-F algorithm from Wiki