Transcript Part I: Introduction

Chapter 3: Transport Layer
Chapter goals:
Chapter Overview:
r
r
understand principles
behind transport layer
services:
m
m
m
m
r
r
r
multiplexing/demultiplex
r
ing
reliable data transfer
r
flow control
congestion control
instantiation and
implementation in the
Internet
m
m
UDP
TCP
transport layer services
multiplexing/demultiplexing
connectionless transport: UDP
principles of reliable data
transfer
connection-oriented transport:
TCP
m
m
m
r
r
reliable transfer
flow control
connection management
principles of congestion control
TCP congestion control
3: Transport Layer
3a-1
Transport services and protocols
r
r
r
r
r
provide logical communication
between app’ processes
running on different hosts
transport protocols run in
end systems
transport vs network layer
services:
network layer: data transfer
between end systems
transport layer: data
transfer between processes
m
relies on, enhances, network
layer services
application
transport
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
application
transport
network
data link
physical
3: Transport Layer
3a-2
Transport-layer protocols
Internet transport services:
r reliable, in-order unicast
delivery (TCP)
m
m
m
r
r
congestion
flow control
connection setup
unreliable (“best-effort”),
unordered unicast or
multicast delivery: UDP
services not available:
m
m
m
real-time
bandwidth guarantees
reliable multicast
application
transport
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
network
data link
physical
application
transport
network
data link
physical
3: Transport Layer
3a-3
Multiplexing/demultiplexing
Recall: segment - unit of data
exchanged between
transport layer entities
m aka TPDU: transport
protocol data unit
application-layer
data
segment
header
segment
Ht M
Hn segment
P1
M
application
transport
network
P3
Demultiplexing: delivering
received segments to
correct app layer processes
receiver
M
M
application
transport
network
P4
M
P2
application
transport
network
3: Transport Layer
3a-4
Multiplexing/demultiplexing
Multiplexing:
gathering data from multiple
app processes, enveloping
data with header (later used
for demultiplexing)
multiplexing/demultiplexing:
r based on sender, receiver
port numbers, IP addresses
m source, dest port #s in
each segment
m recall: well-known port
numbers for specific
applications
32 bits
source port #
dest port #
other header fields
application
data
(message)
TCP/UDP segment format
3: Transport Layer
3a-5
Multiplexing/demultiplexing: examples
host A
source port: x
dest. port: 23
server B
source port:23
dest. port: x
Source IP: C
Dest IP: B
source port: y
dest. port: 80
port use: simple telnet app
Web client
host A
Web client
host C
Source IP: A
Dest IP: B
source port: x
dest. port: 80
Source IP: C
Dest IP: B
source port: x
dest. port: 80
Web
server B
port use: Web server
3: Transport Layer
3a-6
UDP: User Datagram Protocol [RFC 768]
r
r
r
“no frills,” “bare bones”
Internet transport
protocol
“best effort” service, UDP
segments may be:
m lost
m delivered out of order
to app
connectionless:
m
m
no handshaking between
UDP sender, receiver
each UDP segment
handled independently
of others
Why is there a UDP?
r
r
r
r
no connection
establishment (which can
add delay)
simple: no connection state
at sender, receiver
small segment header
no congestion control: UDP
can blast away as fast as
desired
3: Transport Layer
3a-7
UDP: more
r
r
often used for streaming
multimedia apps
m loss tolerant
Length, in
bytes of UDP
m rate sensitive
other UDP uses
(why?):
DNS
m SNMP
reliable transfer over UDP:
add reliability at
application layer
m application-specific
error recover!
m
r
segment,
including
header
32 bits
source port #
dest port #
length
checksum
Application
data
(message)
UDP segment format
3: Transport Layer
3a-8
UDP checksum
Goal: detect “errors” (e.g., flipped bits) in transmitted
segment
Sender:
r
r
r
treat segment contents
as sequence of 16-bit
integers
checksum: addition (1’s
complement sum) of
segment contents
sender puts checksum
value into UDP checksum
field
Receiver:
r
r
compute checksum of
received segment
check if computed checksum
equals checksum field value:
m NO - error detected
m YES - no error detected.
But maybe errors
nonethless? More later ….
3: Transport Layer
3a-9
TCP: Overview
r
point-to-point:
m
r
one sender, one receiver
m
no “message boundaries”
pipelined:
r
TCP congestion and flow
control set window size
send & receive buffers
application
writes data
application
reads data
TCP
send buffer
TCP
receive buffer
socket
door
bi-directional data flow
in same connection
MSS: maximum segment
size
connection-oriented:
m
r
socket
door
full duplex data:
m
steam:
m
r
r
reliable, in-order byte
m
r
RFCs: 793, 1122, 1323, 2018, 2581
handshaking (exchange
of control msgs) init’s
sender, receiver state
before data exchange
flow controlled:
m
sender will not
overwhelm receiver
segment
3: Transport Layer 3a-10
TCP segment structure
32 bits
URG: urgent data
(generally not used)
ACK: ACK #
valid
PSH: push data now
(generally not used)
RST, SYN, FIN:
connection estab
(setup, teardown
commands)
Internet
checksum
(as in UDP)
source port #
dest port #
sequence number
acknowledgement number
head not
UA P R S F
len used
checksum
rcvr window size
ptr urgent data
Options (variable length)
counting
by bytes
of data
(not segments!)
# bytes
rcvr willing
to accept
application
data
(variable length)
3: Transport Layer 3a-11
TCP seq. #’s and ACKs
Seq. #’s:
m byte stream
“number” of first
byte in segment’s
data
ACKs:
m seq # of next byte
expected from
other side
m cumulative ACK
Q: how receiver handles
out-of-order segments
m A: TCP spec doesn’t
say, - up to
implementor
Host A
User
types
‘C’
Host B
host ACKs
receipt of
‘C’, echoes
back ‘C’
host ACKs
receipt
of echoed
‘C’
simple telnet scenario
time
3: Transport Layer 3a-12
TCP: reliable data transfer
event: data received
from application above
create, send segment
wait
wait
for
for
event
event
simplified sender, assuming
•one way data transfer
•no flow, congestion control
event: timer timeout for
segment with seq # y
retransmit segment
event: ACK received,
with ACK # y
ACK processing
3: Transport Layer 3a-13
TCP:
reliable
data
transfer
Simplified
TCP
sender
00 sendbase = initial_sequence number
01 nextseqnum = initial_sequence number
02
03 loop (forever) {
04
switch(event)
05
event: data received from application above
06
create TCP segment with sequence number nextseqnum
07
start timer for segment nextseqnum
08
pass segment to IP
09
nextseqnum = nextseqnum + length(data)
10
event: timer timeout for segment with sequence number y
11
retransmit segment with sequence number y
12
compue new timeout interval for segment y
13
restart timer for sequence number y
14
event: ACK received, with ACK field value of y
15
if (y > sendbase) { /* cumulative ACK of all data up to y */
16
cancel all timers for segments with sequence numbers < y
17
sendbase = y
18
}
19
else { /* a duplicate ACK for already ACKed segment */
20
increment number of duplicate ACKs received for y
21
if (number of duplicate ACKS received for y == 3) {
22
/* TCP fast retransmit */
23
resend segment with sequence number y
24
restart timer for segment y
25
}
26
} /* end of loop forever */
3: Transport Layer 3a-14
TCP ACK generation
[RFC 1122, RFC 2581]
Event
TCP Receiver action
in-order segment arrival,
no gaps,
everything else already ACKed
delayed ACK. Wait up to 500ms
for next segment. If no next segment,
send ACK
in-order segment arrival,
no gaps,
one delayed ACK pending
immediately send single
cumulative ACK
out-of-order segment arrival
higher-than-expect seq. #
gap detected
send duplicate ACK, indicating seq. #
of next expected byte
arrival of segment that
partially or completely fills gap
immediate ACK if segment starts
at lower end of gap
3: Transport Layer 3a-15
TCP: retransmission scenarios
time
Host A
Host B
X
loss
lost ACK scenario
Host B
Seq=100 timeout
Seq=92 timeout
timeout
Host A
time
premature timeout,
cumulative ACKs
3: Transport Layer 3a-16
TCP Flow Control
flow control
sender won’t overrun
receiver’s buffers by
transmitting too much,
too fast
RcvBuffer = size or TCP Receive Buffer
RcvWindow = amount of spare room in Buffer
receiver: explicitly
informs sender of
(dynamically changing)
amount of free buffer
space
m RcvWindow field in
TCP segment
sender: keeps the amount
of transmitted,
unACKed data less than
most recently received
RcvWindow
receiver buffering
3: Transport Layer 3a-17
TCP Round Trip Time and Timeout
Q: how to set TCP
timeout value?
r
r
r
longer than RTT
m note: RTT will vary
too short: premature
timeout
m unnecessary
retransmissions
too long: slow reaction
to segment loss
Q: how to estimate RTT?
r
r
SampleRTT: measured time from
segment transmission until ACK
receipt
m ignore retransmissions,
cumulatively ACKed segments
SampleRTT will vary, want
estimated RTT “smoother”
m use several recent
measurements, not just
current SampleRTT
3: Transport Layer 3a-18
TCP Round Trip Time and Timeout
EstimatedRTT = (1-x)*EstimatedRTT + x*SampleRTT
r
r
r
Exponential weighted moving average
influence of given sample decreases exponentially fast
typical value of x: 0.1
Setting the timeout
r
r
EstimtedRTT plus “safety margin”
large variation in EstimatedRTT -> larger safety margin
Timeout = EstimatedRTT + 4*Deviation
Deviation = (1-x)*Deviation +
x*|SampleRTT-EstimatedRTT|
3: Transport Layer 3a-19
TCP Connection Management
Recall: TCP sender, receiver
r
r
establish “connection”
before exchanging data
segments
initialize TCP variables:
m seq. #s
m buffers, flow control
info (e.g. RcvWindow)
client: connection initiator
Socket clientSocket = new
Socket("hostname","port
r
Three way handshake:
Step 1: client end system
sends TCP SYN control
segment to server
m specifies initial seq #
Step 2: server end system
receives SYN, replies with
SYNACK control segment
m
number");
m
server: contacted by client
m
Socket connectionSocket =
welcomeSocket.accept();
ACKs received SYN
allocates buffers
specifies server->
receiver initial seq. #
3: Transport Layer 3a-20
TCP Connection Management (cont.)
Closing a connection:
client closes socket:
clientSocket.close();
client
close
Step 1: client end system
close
FIN, replies with ACK.
Closes connection, sends
FIN.
timed wait
sends TCP FIN control
segment to server
Step 2: server receives
server
closed
3: Transport Layer 3a-21
TCP Connection Management (cont.)
Step 3: client receives FIN,
replies with ACK.
m
client
server
closing
Enters “timed wait” will respond with ACK
to received FINs
closing
Step 4: server, receives
Note: with small
modification, can handly
simultaneous FINs.
timed wait
ACK. Connection closed.
closed
closed
3: Transport Layer 3a-22
TCP Connection Management (cont)
TCP server
lifecycle
TCP client
lifecycle
3: Transport Layer 3a-23
Principles of Congestion Control
Congestion:
informally: “too many sources sending too much
data too fast for network to handle”
r different from flow control!
r manifestations:
m lost packets (buffer overflow at routers)
m long delays (queueing in router buffers)
r a top-10 problem!
r
3: Transport Layer 3a-24
Causes/costs of congestion: scenario 1
two senders, two
receivers
r one router,
infinite buffers
r no retransmission
r
large delays
when congested
r maximum
achievable
throughput
r
3: Transport Layer 3a-25
Causes/costs of congestion: scenario 2
one router, finite buffers
r sender retransmission of lost packet
r
3: Transport Layer 3a-26
Causes/costs of congestion: scenario 2
r
r
r
= l
(goodput)
out
in
“perfect” retransmission only when loss:
always:
l
l > lout
in
retransmission of delayed (not lost) packet makes l
in
l
(than perfect case) for same
out
larger
“costs” of congestion:
r more work (retrans) for given “goodput”
r unneeded retransmissions: link carries multiple copies of pkt
3: Transport Layer 3a-27
Causes/costs of congestion: scenario 3
r
r
r
four senders
multihop paths
timeout/retransmit
Q: what happens as l
in
and l increase ?
in
3: Transport Layer 3a-28
Causes/costs of congestion: scenario 3
Another “cost” of congestion:
r when packet dropped, any “upstream transmission
capacity used for that packet was wasted!
3: Transport Layer 3a-29
Approaches towards congestion control
Two broad approaches towards congestion control:
End-end congestion
control:
r
r
r
no explicit feedback from
network
congestion inferred from
end-system observed loss,
delay
approach taken by TCP
Network-assisted
congestion control:
r
routers provide feedback
to end systems
m single bit indicating
congestion (SNA,
DECbit, TCP/IP ECN,
ATM)
m explicit rate sender
should send at
3: Transport Layer 3a-30
TCP Congestion Control
end-end control (no network assistance)
r transmission rate limited by congestion window
size, Congwin, over segments:
r
Congwin
r
w segments, each with MSS bytes sent in one RTT:
throughput =
w * MSS
Bytes/sec
RTT
3: Transport Layer 3a-31
TCP congestion control:
r
“probing” for usable
bandwidth:
m
m
m
ideally: transmit as fast
as possible (Congwin as
large as possible)
without loss
increase Congwin until
loss (congestion)
loss: decrease Congwin,
then begin probing
(increasing) again
r
two “phases”
m
m
r
slow start
congestion avoidance
important variables:
m
m
Congwin
threshold: defines
threshold between two
slow start phase,
congestion control
phase
3: Transport Layer 3a-32
TCP Slowstart
Host A
initialize: Congwin = 1
for (each segment ACKed)
Congwin++
until (loss event OR
CongWin > threshold)
r
r
exponential increase (per
RTT) in window size (not so
slow!)
loss event: timeout (Tahoe
TCP) and/or or three
duplicate ACKs (Reno TCP)
RTT
Slowstart algorithm
Host B
time
3: Transport Layer 3a-33
TCP Congestion Avoidance
Congestion avoidance
/* slowstart is over
*/
/* Congwin > threshold */
Until (loss event) {
every w segments ACKed:
Congwin++
}
threshold = Congwin/2
Congwin = 1
1
perform slowstart
1: TCP Reno skips slowstart (fast
recovery) after three duplicate ACKs
3: Transport Layer 3a-34
AIMD
TCP congestion
avoidance:
r AIMD: additive
increase,
multiplicative
decrease
m
m
increase window by 1
per RTT
decrease window by
factor of 2 on loss
event
TCP Fairness
Fairness goal: if N TCP
sessions share same
bottleneck link, each
should get 1/N of link
capacity
TCP connection 1
TCP
connection 2
bottleneck
router
capacity R
3: Transport Layer 3a-35
Why is TCP fair?
Two competing sessions:
r
r
Additive increase gives slope of 1, as throughout increases
multiplicative decrease decreases throughput proportionally
R
equal bandwidth share
loss: decrease window by factor of 2
congestion avoidance: additive increase
loss: decrease window by factor of 2
congestion avoidance: additive increase
Connection 1 throughput R
3: Transport Layer 3a-36