Transcript Lecture 15: Network Layer

• Review:
– Switched Ethernet
• How does the switch learn the location of a
machine?
• How does the switch forward a frame?
• Can the physical switch topology contain loops?
• Chapter 5 The network layer
• Physical layer: move bits between physically connected stations
• Data link layer: move frames between physically connected stations
• Network layer: move packets from source A to destination B
– Design issues:
• Service interface: what kind of services to be
supported at the network layer?
• Routing: Where to send the packets received?
• Congestion control: to avoid overloading some links
• Internetworking: How to interconnect different
networks?
• Service interface:
– One of the differences between the OSI model
and the TCP/IP model.
– Unreliable connectionless or reliable
connection-oriented?
• TCP/IP: the subnet is inherently unreliable
– network layer: provides connectionless service, let the
higher layer do the error control and flow control
• ATM: the subnet should provide a reliable
connection oriented service. The company can
charge based on the quality of service provided.
• Where to put the complexity?
– transport (TCP/IP) or network(ATM)
– Internal organization: virtual circuit/datagram
• virtual circuits:
– used in subnets whose services are connection-oriented.
– establish path before data transmission.
– choose the route once at path setup, avoid the complexity
of routing for every packet
• datagram :
– each packet is routed independently.
– more complexity to process packet
– more robust and adapt to failure
Datagram
Virtual Circuit
Circuit setup
no
required
Addressing
global addr.(large)
local VC number (small)
memory in
routers
no
state table for VCs
in each router
Routing
each packet
once for all packets in a VC
Router Failure
no effect
All VCs terminated.
Cong. control
hard
easy
Memory in packets versus memory in routers.
path setup time versus address parsing time
– Second issue: routing.
• Choose the appropriate paths.
• In datagram subnets, routing decision is made for each packet.
• In Virtual circuit subnets: routing decision is made once for a
VC in the path establishment.
• Desirable properties of the routing algorithms:
– correctness: of course
– simplicity: for efficiency
– robustness: must be able to sustain the changes in the networks
(cannot just rely on reboot)
– stability: when run long enough, should converge to equilibrium
– fairness: every one gets to send
– optimality: as efficient as possible, of course
» sometimes, these properties may conflict
– adaptive routing/non-adaptive routing
• Non-adaptive routing: the route between two nodes is fixed.
• Adaptive routing: the route between two nodes may change to
adapt to the network traffic.
– Static routing/dynamic routing
• static routing: routes are computed in advance
• dynamic routing: routes are computed on the fly
• Routing algorithms:
– Flooding
– send all the incoming packet to all outgoing links except the one
the packet arrived on
– lots of duplicate, use hop count to limit the duplicate packets.
– Reliable, fast, large overhead, not scalable
– user: military, distributed database(update everything), highly
reliable packets.
– Shorest path Routing:
• performance metric: distance, number of hops, delay, queue
length, etc
• find the shortest path from the source to all other nodes.
• Dijkstra algorithm: finding the shortest paths from the
source s to all other nodes in the network.
1) Initial set = empty,
2) maintain the distance from s to all other nodes
(distance(s, s) = 0, distance(s, t) = infinite)
3) repeat until all nodes are included in the set
4)
find a node d with shortest distance to s
5)
include d in the set
6)
update the distance from s to all other nodes using
7)
if distance(s, m) > distance(s, d) + dist(d, m) then
8)
distance(s, m) = distance(s, d) + dist (d, m)
– Shorest path Routing:
• Bellman-Ford algorithm:
1) initialization: distance(s, s) = 0, distance(s, t) = infinite
2) for I = 1 to |V(G)| -1
3)
4)
5)
for each edge (u, v) in E(G)
if (distance(s, v) > distance (s, u) + dist(u, v)) then
distance(s, v) = distance(s, u) + dist(u, v)