Chapter 3

Transport Layer
Part 4/5

A note on the use of these Powerpoint slides:

We’re making these slides freely available to all (faculty, students, readers).
They’re in PowerPoint form so you see the animations; and can add, modify,
and delete slides (including this one) and slide content to suit your needs.

Computer
They obviously represent a lot of work on our part. In return for use, we only
ask the following:

 If you use these slides (e.g., in a class) that you mention their source
(after all, we’d like people to use our book!)
Networking: A Top
 If you post any slides on a www site, that you note that they are adapted
from (or perhaps identical to) our slides, and note our copyright of this
Down Approach
material.
7th edition
Thanks and enjoy! JFK/KWR
Jim Kurose, Keith Ross
All material copyright 1996-2016 Pearson/Addison Wesley
J.F Kurose and K.W. Ross, All Rights Reserved April 2016
Transport Layer 2-1
Chapter 3 outline
3.1 transport-layer 3.5 connection-oriented
services transport: TCP
3.2 multiplexing and • segment structure
demultiplexing • reliable data transfer
3.3 connectionless • flow control
transport: UDP • connection management
3.4 principles of reliable 3.6 principles of congestion
data transfer control
3.7 TCP congestion control

Transport Layer 3-2

TCP: Overview RFCs: 793,1122,1323, 2018, 2581
 point-to-point:
• one sender, one receiver
 reliable, in-order byte
stream:
• Segments delivered to
app in order
 pipelined:
• TCP congestion and
flow control set window
size
 full duplex data:
• bi-directional data flow
in same connection
• MSS: maximum segment
size
 connection-oriented:
• handshaking (exchange
of control msgs) inits
sender, receiver state
before data exchange
 flow controlled:
• sender will not
overwhelm receiver
Transport Layer 3-3
 TCP segment structure
32 bits
URG: urgent data counting
(generally not used) source port # dest port #
by bytes
sequence number of data
ACK: ACK #
valid acknowledgement number (not segments!)
head not
PSH: push data now len used
UAP R S F receive window
(generally not used) # bytes
checksum Urg data pointer
rcvr willing
RST, SYN, FIN: to accept
options (variable length)
connection estab
(setup, teardown
commands) Indicates the
application
data location of the last
Internet
byte of this urgent
checksum (variable length)
data
(as in UDP)

Transport Layer 3-4

TCP seq. numbers, ACKs
sequence numbers:
• byte stream “number” of
outgoing segment from sender
source port # dest port #
sequence number
acknowledgement number

first byte in segment’s rwnd

data
checksum urg pointer

window size
acknowledgements: N

• seq # of next byte

expected from other side sender sequence number space
• cumulative ACK
sent sent, not- usable not
Q: how receiver handles ACKed yet ACKed but not usable
out-of-order segments (“in-
flight”)
yet sent

• A: TCP spec doesn’t say, incoming segment to sender

- up to implementor source port # dest port #
sequence number
acknowledgement number
A rwnd
checksum urg pointer

Transport Layer 3-5

 TCP seq. numbers, ACKs
Piggybacked ACK: Host A Host B

• ACK for client-to-server

data is carried in a User
segment carrying server- types
to-client data. ‘C’ Seq=42, ACK=79, data = ‘C’
host ACKs
acknowledgements: receipt of
• ACK=43 in server-to- ‘C’, echoes
Seq=79, ACK=43, data = ‘C’
client segment shows host ACKs
back ‘C’
server has received receipt
of echoed
everything upto byte 42 ‘C’ Seq=43, ACK=80
• Server waiting for byte 43
simple telnet scenario

Transport Layer 3-6

TCP round trip time and timeout

Transport Layer 3-7

TCP round trip time and timeout
Q: how to estimate RTT?
 SampleRTT: measured time from segment transmission
until ACK receipt

• ignore retransmissions

 SampleRTT will vary, want estimated RTT “smoother”

• average several recent measurements, not just current

SampleRTT

Transport Layer 3-8

 TCP round trip time and timeout
 We also want to give more recent measurements higher weight
in case things do change

EstimatedRTT(current)=(1- )*EstimatedRTT(Previous)+ *SampleRTT(recent)

 New EstimatedRTT is weighted combination of previous EstimatedRTT and new

SampleRTT

 All the samples are averaged using exponential weighted moving average
(EWMA)

 influence of past sample decreases exponentially fast

 Coefficient α is the degree of weighting decrease

 0<α<1, but typical value:  = 0.125

Transport Layer 3-9
TCP round trip time and timeout
RTT: gaia.cs.umass.edu to fantasia.eurecom.fr

350

RTT: gaia.cs.umass.edu to fantasia.eurecom.fr

RTT (milliseconds)

300

250
RTT (milliseconds)

200

sampleRTT
150

EstimatedRTT

100
1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106
time (seconnds)
time (seconds)
SampleRTT Estimated RTT

Transport Layer 3-13

 TCP round trip time and timeout
 timeout interval: EstimatedRTT plus “safety margin”
• large variation in EstimatedRTT -> larger safety margin
 estimate SampleRTT deviation from EstimatedRTT:

SampleDevRTT(recent) = |SampleRTT-EstimatedRTT|
DevRTT(current) = (1-)*DevRTT(Previous) + * SampleDevRTT(recent)

(0<β<1; typically  = 0.25)

TimeoutInterval = EstimatedRTT(current) + 4*DevRTT(Current)

estimated RTT “safety margin”

* Check out the online interactive exercises for more

examples: http://gaia.cs.umass.edu/kurose_ross/interactive/ Transport Layer 3-15
TCP round trip time and timeout (class exercises)

 Suppose that TCP's current estimatedRTT and DevRTT are 340 msec and 18
msec, respectively. Suppose that the next three SampleRTTs are 400, 270, and
390 respectively. Compute TCP's new value of estimatedRTT, DevRTT, and the
TCP timeout value after each of these three measured RTT values is
obtained.Use the values of α = 0.125 and β = 0.25.

EstimatedRTT(current)=(1- )*EstimatedRTT(Previous)+ *SampleRTT(recent)

EstimatedRTT = (1- )*EstimatedRTT + *SampleRTT

 Solution:
1) SampleRTT0 = 400ms, EstimatedRTT=340ms, DevRTT=18ms

estimatedRTT = ?
DevRTT = ?
TimeoutInterval = ?
Transport Layer 3-16
TCP round trip time and timeout (class exercises)

 Suppose that TCP's current estimatedRTT and DevRTT are 340 msec and 18
msec, respectively. Suppose that the next three SampleRTTs are 400, 270, and
390 respectively. Compute TCP's new value of estimatedRTT, DevRTT, and the
TCP timeout value after each of these three measured RTT values is
obtained.Use the values of α = 0.125 and β = 0.25.

EstimatedRTT(current)=(1- )*EstimatedRTT(Previous)+ *SampleRTT(recent)

EstimatedRTT = (1- )*EstimatedRTT + *SampleRTT

 Solution:
1) SampleRTT0 = 400ms, EstimatedRTT=340ms, DevRTT=18ms

estimatedRTT = 0.875*340 + 0.125*400 = 347.5 msecs

DevRTT = 0.75*18 + 0.25*(abs(400 - 347.5)) = 26.625 msecs
TimeoutInterval = 347.5 + 4*26.625 = 454 msecs
Transport Layer 3-17
TCP round trip time and timeout (class exercises)

2) SampleRTT1 = 270ms , EstimatedRTT=347.5ms, DevRTT=26.625ms

estimatedRTT = ?
DevRTT = ?
TimeoutInterval = ?

3) SampleRTT2 = 390ms , EstimatedRTT=337ms, DevRTT=36.921875ms

estimatedRTT = ??

DevRTT = ??
TimeoutInterval = ??

Transport Layer 3-18

TCP round trip time and timeout (class exercises)

2) SampleRTT1 = 270ms , EstimatedRTT=347.5ms, DevRTT=26.625ms

estimatedRTT = 0.875*347.5 + 0.125*270 = 337.8125 msecs

DevRTT = 0.75*26.625 + 0.25*(abs(270 - 337.8125)) = 36.921875 msecs
TimeoutInterval = 337.8125 + 4*36.921875 = 485.5 msecs

3) SampleRTT2 = 390ms , EstimatedRTT=337ms, DevRTT=36.921875ms

estimatedRTT = ??

DevRTT = ??
TimeoutInterval = ??

Transport Layer 3-19

Chapter 3 outline
3.1 transport-layer 3.5 connection-oriented
services transport: TCP
3.2 multiplexing and • segment structure
demultiplexing • reliable data transfer
3.3 connectionless • flow control
transport: UDP • connection management
3.4 principles of reliable 3.6 principles of congestion
data transfer control
3.7 TCP congestion control

Transport Layer 3-20

TCP reliable data transfer
 TCP creates rdt service
on top of IP’s unreliable
service
• pipelined segments
• cumulative acks let’s initially consider
 retransmissions simplified TCP sender:
triggered by: • ignore duplicate acks
• timeout events • ignore flow control
• duplicate acks • ignore congestion control

Transport Layer 3-21

TCP sender events:
data rcvd from app: timeout:
 create segment with  retransmit segment
seq # that caused timeout
 seq # is byte-stream  restart timer
number of first data ack rcvd:
byte in segment  if ack acknowledges
 start timer if not previously unacked
already running segments
• think of timer as for • update what is known
oldest unacked to be ACKed
segment
• start timer if there are
• expiration interval: still unacked segments
TimeOutInterval

Transport Layer 3-22

TCP sender (simplified)
data received from application above
create segment, seq. #: NextSeqNum
pass segment to IP (i.e., “send”)
NextSeqNum = NextSeqNum + length(data)
if (timer currently not running)
L start timer
NextSeqNum = InitialSeqNum wait
SendBase = InitialSeqNum for
event timeout
retransmit not-yet-acked segment
with smallest seq. #
start timer
ACK received, with ACK field value y
if (y > SendBase) {
SendBase = y
/* SendBase–1: last cumulatively ACKed byte */
if (there are currently not-yet-acked segments)
start timer
else stop timer //no in-flight packet, so no need to start timer
} Transport Layer 3-23
TCP: retransmission scenarios
Host A Host B Host A Host B

SendBase=92
Seq=92, 8 bytes of data Seq=92, 8 bytes of data

Seq=100, 20 bytes of data

timeout

timeout
ACK=100
X
ACK=100
ACK=120

Seq=92, 8 bytes of data Seq=92, 8

SendBase=100 bytes of data
SendBase=120
ACK=100
ACK=120

SendBase=120

lost ACK scenario premature timeout

(In the last, receiver sends Cumulative ACK)
Transport Layer 3-25
TCP: retransmission scenarios
Host A Host B

Seq=92, 8 bytes of data

Seq=100, 20 bytes of data

timeout

ACK=100
X
ACK=120

Seq=120, 15 bytes of data

cumulative ACK
Transport Layer 3-26
TCP ACK generation recommendation [RFC
1122, RFC 2581]

event at receiver TCP receiver action

arrival of in-order segment with delayed ACK. Wait up to 500ms
expected seq #. All data up to for next segment. If no next segment,
expected seq # already ACKed send ACK

arrival of in-order segment with immediately send single cumulative

expected seq #. One other ACK, ACKing both in-order segments
segment has ACK pending

arrival of out-of-order segment immediately send duplicate ACK,

higher-than-expect seq. # . indicating seq. # of next expected byte
Gap detected

arrival of segment that immediately send ACK, provided that

partially or completely fills gap segment starts at lower end of gap

Transport Layer 3-27

TCP ACK generation recommendation [RFC
1122, RFC 2581]

event at receiver TCP receiver action

arrival of in-order segment with delayed ACK. Wait up to 500ms
expected seq #. All data up to for next segment. If no next segment,
expected seq # already ACKed send ACK

Transport Layer 3-28

TCP ACK generation recommendation [RFC
1122, RFC 2581]

event at receiver TCP receiver action

arrival of in-order segment with immediately send single cumulative
expected seq #. One other ACK, ACKing both in-order segments
segment has ACK pending

Transport Layer 3-29

TCP ACK generation recommendation [RFC
1122, RFC 2581]

event at receiver TCP receiver action

arrival of out-of-order segment immediately send duplicate ACK,
higher-than-expect seq. # . indicating seq. # of next expected byte
Gap detected

Transport Layer 3-30

TCP ACK generation recommendation [RFC
1122, RFC 2581]

event at receiver TCP receiver action

arrival of segment that immediately send ACK, provided that
partially or completely fills gap segment starts at lower end of gap

Transport Layer 3-31

 TCP fast retransmit
 time-out period often
relatively long:
• long delay before
resending lost packet
 detect lost segments via
duplicate ACKs.
• sender often sends many
segments back-to-back
• if segment is lost, there
will likely be many
duplicate ACKs.
TCP fast retransmit
if sender receives 3
ACKs for same data
(“triple
(“triple duplicate
duplicate ACKs”),
ACKs”),
resend unacked
segment with smallest
seq #
 likely that unacked
segment lost, so don’t
wait for timeout
Transport Layer 3-32
 TCP fast retransmit
Host A Host B
 Normally TCP sender will wait
for the time-out before
retransmission,
 But in TCP fast retransmit, Seq=92, 8 bytes of data
sender will retransmit before the Seq=100, 20 bytes of data
timeout happens. X

ACK=100

timeout
ACK=100
ACK=100
ACK=100
Seq=100, 20 bytes of data

fast retransmit after sender

receipt of triple duplicate ACK
Transport Layer 3-33
Chapter 3 outline
3.1 transport-layer 3.5 connection-oriented
services transport: TCP
3.2 multiplexing and • segment structure
demultiplexing • reliable data transfer
3.3 connectionless • flow control
transport: UDP • connection management
3.4 principles of reliable 3.6 principles of congestion
data transfer control
3.7 TCP congestion control

Transport Layer 3-34

TCP flow control
 receiver “advertises” free buffer space by including rwnd value in
TCP header of receiver-to-sender segments
• RcvBuffer size set via socket options (typical default is 4096 bytes)
• many operating systems autoadjust RcvBuffer
 sender limits amount of unacked (“in-flight”) data to receiver’s
rwnd value
 Flow control guarantees receive buffer will not overflow
to application process

RcvBuffer buffered data

rwnd free buffer space

TCP segment payloads

receiver-side buffering Transport Layer 3-36
 TCP flow control: how to calculate rwnd?
 Calculating rwnd
• rwnd = RcvBuffer-[LastByteRcvd-LastByteRead]

 LastByteRead: the number of the last byte in

the data stream read from the buffer by the
application process of the receiving host
to application process
 LastByteRcvd: the number of the last byte in
the data stream that has been received by the
receive buffer of the receiving host from the
network RcvBuffer buffered data

 Relationship between RcvBuffer, LastByteRcvd,

LastByteRead
rwnd free buffer space
LastByteRcvd-LastByteRead ≤ RcvBuffer

TCP segment payloads

receiver-side buffering
Transport Layer 3-37
 TCP flow control
 Deadlock Situation
• Receiver consumed some data
and free up some receive
buffer space to application process

• Sender thinks rwnd=0 and

doesn’t send segment RcvBuffer buffered data
• Sender has some data in the send
buffer, it periodically sends a one
byte TCP segment to the receiver
rwnd free buffer space
to trigger a response from
the receiver
• Ack for the byte size probe TCP TCP segment payloads
segment will contain the non-zero
value rwnd that the sender uses for receiver-side buffering
transmission

Transport Layer 3-38

Chapter 3 outline
3.1 transport-layer 3.5 connection-oriented
services transport: TCP
3.2 multiplexing and • segment structure
demultiplexing • reliable data transfer
3.3 connectionless • flow control
transport: UDP • connection management
3.4 principles of reliable 3.6 principles of congestion
data transfer control
3.7 TCP congestion control

Transport Layer 3-39

Connection Management
before exchanging data, sender/receiver “handshake”:
 agree to establish connection (each knowing the other willing
to establish connection)
 agree on connection parameters

application application

connection state: ESTAB connection state: ESTAB

connection variables:
seq # client-to-server
server-to-client
rcvBuffer size
at server,client
connection Variables:
seq # client-to-server
server-to-client
rcvBuffer size
at server,client

network network

Socket clientSocket = Socket connectionSocket =

newSocket("hostname","port welcomeSocket.accept();
number");

Transport Layer 3-40

Connection Management: Agreeing to establish a connection

2-way handshake:
Q: will 2-way handshake
always work in
network?
Let’s talk
ESTAB  variable delays
OK
ESTAB  retransmitted messages (e.g.
req_conn(x)) due to
message loss
 message reordering
choose x
req_conn(x)
 can’t “see” other side
ESTAB
acc_conn(x)
ESTAB

Transport Layer 3-41

Agreeing to establish a connection
2-way handshake failure scenarios:

choose x choose x
req_conn(x) req_conn(x)
ESTAB ESTAB
retransmit acc_conn(x) retransmit acc_conn(x)
req_conn(x) req_conn(x)

ESTAB ESTAB
data(x+1) accept
req_conn(x)
retransmit data(x+1)
data(x+1)
connection connection
client x completes server x completes server
client
terminates forgets x terminates forgets x
req_conn(x)

ESTAB ESTAB
data(x+1) accept
half open connection! data(x+1)
(no client!)
Transport Layer 3-42
 TCP 3-way handshake

client state server state

LISTEN
choose init seq num, x
send TCP SYN msg
SYNSENT
received SYNACK(x)
ESTAB indicates server is live;
send ACK for SYNACK;
this segment may contain
client-to-server data
LISTEN
SYNbit=1, Seq=x
choose init seq num, y
send TCP SYNACK
msg, acking SYN SYN RCVD
SYNbit=1, Seq=y
ACKbit=1; ACKnum=x+1
ACKbit=1, ACKnum=y+1
received ACK(y)
indicates client is live
ESTAB

Transport Layer 3-43

TCP 3-way handshake: FSM
Initially client/server are closed
Socket clientSocket =
closed newSocket("hostname","port
number");
Socket connectionSocket =
welcomeSocket.accept(); SYN(seq=x)
L

Client sends SYN

SYN(x)
SYNACK(seq=y,ACKnum=x+1)
create new socket for
communication back to client listen

SYN SYN
rcvd sent

SYNACK(seq=y,ACKnum=x+1)
ESTAB ACK(ACKnum=y+1)
ACK(ACKnum=y+1)
L

Transport Layer 3-47

TCP: closing a connection
 client, server each close their side of connection
• send TCP segment with FIN bit = 1
 respond to received FIN with ACK
• on receiving FIN, ACK can be combined with own FIN
 simultaneous FIN exchanges can be handled

Transport Layer 3-48

TCP: closing a connection
client state server state
ESTAB ESTAB
clientSocket.close()
FIN_WAIT_1 can no longer FINbit=1, seq=x
send but can
receive data CLOSE_WAIT
ACKbit=1; ACKnum=x+1
can still
FIN_WAIT_2 wait for server send data
close

LAST_ACK
FINbit=1, seq=y
TIMED_WAIT can no longer
send data
ACKbit=1; ACKnum=y+1
timed wait
for 2*max CLOSED
segment lifetime

CLOSED

Transport Layer 3-49

Chapter 3 outline
3.1 transport-layer 3.5 connection-oriented
services transport: TCP
3.2 multiplexing and • segment structure
demultiplexing • reliable data transfer
3.3 connectionless • flow control
transport: UDP • connection management
3.4 principles of reliable 3.6 principles of congestion
data transfer control
3.7 TCP congestion control

Transport Layer 3-50