Introduction to Networking

1
Introduction to Networking

• Project 3

2
Routing
5
Goal determine good path (sequence of routers)
thru network from source to dest.
3
5
2
2
1
3

• Graph abstraction for routing algorithms
• graph nodes are routers
• graph edges are physical links
• link cost delay, cost, or congestion level

1
2
1

• good path
• typically means minimum cost path
• other defs possible

3
Routing Algorithm classification

• Global 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 quickly
• periodic update
• in response to link cost changes

4
A Link-State Routing Algorithm

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

5
Dijsktras Algorithm
1 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
6
Dijkstras algorithm example
D(B),p(B) 2,A 2,A 2,A
D(D),p(D) 1,A
Step 0 1 2 3 4 5
D(C),p(C) 5,A 4,D 3,E 3,E
D(E),p(E) infinity 2,D
start N A AD ADE ADEB ADEBC ADEBCF
D(F),p(F) infinity infinity 4,E 4,E 4,E
5
3
5
2
2
1
3
1
2
1
7
Distance Vector Routing Algorithm

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

8
Distance Vector Routing Algorithm

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

Each node
9
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.

10

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

11

• make TYPEGENERIC will build a single
  executable routesim, which contains no routing
  algorithm.
• You will do TYPEDISTANCEVECTOR and
  TYPELINKSTATE
• To run ./routesim topologyfile eventfile
  singlestep

12

• 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

13

• 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

14

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

15
The Node class (4 functions that you must
implement)

• void NodeLinkHasBeenUpdated(const Link l)
• is called to inform you that an outgoing link
  connected to your node has just changed its
  properties.
• void NodeProcessIncomingRoutingMessage(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 NodeGetNextHop(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 NodeGetRoutingTable() const
• is called when the simulation wants to get a copy
  of your current routing table.

16

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

17
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 maplt int, double gt 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.

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

19
General approach to implement a routing algorithm

• Understand what routesim (TYPEGENERIC) 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 NodeGetNextHop() and
  NodeGetRoutingTable()
• Develop your routing message. Think about where
  your routing message will go.
• Implement NodeLinkHasBeenUpdated ()
• Implement NodeProcessRoutingMessage()
• Implement NodeTimeOut(), if needed.

20

• 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

21
Sample code in LSLinkHasBeenUpdated(const Link
l)

• void NodeLinkHasBeenUpdated(const Link l)
• cerr ltlt thisltlt" Link Update "ltltlltltendl
• /update own lsa
  database/
• double ts (context).GetTime()
• lsatb-gtupdate_link(l-gtGetSrc(), l-gtGetDest(),
  l-gtGetLatency(), ts)
• /Pass this to its
  neighbours/
• RoutingMessage m new RoutingMessage()
• (m).LSAs.push_back(lsa(l-gtGetSrc(),
  l-gtGetDest(), l-gtGetLatency(),ts))
• SendToNeighbors(m)

22

• void NodeSendToNeighbors(const RoutingMessage
  m)
• cerr ltlt "Flooding source ID "ltlt number ltltendl
• dequeltNodegt ngbr GetNeighbors()
• for(dequeltNodegtiterator i ngbr-gtbegin()
• i! ngbr-gtend() i)
• SendToNeighbor(i,m)
• void NodeSendToNeighbor(const Node n, const
  RoutingMessage m)
• cerr ltlt "SendToNeighbor (Ngbr id "ltlt n-gtnumber
  ltltendl
• Link l
• l.SetSrc(number)
• l.SetDest((n).number)
• Link ml context-gtFindMatchingLink(l)
• assert(ml!NULL)

23
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, vectorltdatagt v,
  vectorltunsignedgt next)
• private
• unsigned my_id
• vectorltunsignedgt nodes
• vectorltaLinkgt links
• mapltunsigned, intgt routes

24
Pseudocode of Dijkstra Algorithm from Wiki
25
Pseudocode of B-F algorithm from Wiki