Computer Networks

Week9_Lecture2 (Chapter3)
Transport Layer

Subhan Ullah, PhD

[email protected]

BS(Computer Science) Spring-2024

Transport Layer: 3-1
Chapter 3: roadmap
 Transport-layer services
 Multiplexing and demultiplexing
 Connectionless transport: UDP
 Principles of reliable data transfer
 Connection-oriented transport: TCP
 Principles of congestion control
 TCP congestion control
 Evolution of transport-layer
functionality
Transport Layer: 3-2
rdt3.0: channels with errors and loss
New channel assumption: underlying channel can also lose
packets (data, ACKs)
• checksum, sequence #s, ACKs, retransmissions will be of help …
but not quite enough

Q: How do humans handle lost sender-to-

receiver words in conversation?

Transport Layer: 3-3

rdt3.0: channels with errors and loss
Approach: sender waits “reasonable” amount of time for ACK
 retransmits if no ACK received in this time
 if pkt (or ACK) just delayed (not lost):
• retransmission will be duplicate, but seq #s already handles this!
• receiver must specify seq # of packet being ACKed
 use countdown timer to interrupt after “reasonable” amount of
time
timeout

Transport Layer: 3-4

rdt3.0 sender
rdt_send(data)
sndpkt = make_pkt(0, data, checksum)
udt_send(sndpkt)
start_timer

Wait for Wait

call 0 from for
above ACK0
rdt_rcv(rcvpkt)
&& notcorrupt(rcvpkt) rdt_rcv(rcvpkt)
&& isACK(rcvpkt,1) && notcorrupt(rcvpkt)
stop_timer && isACK(rcvpkt,0)
stop_timer
Wait Wait for
for call 1 from
ACK1 above

rdt_send(data)
sndpkt = make_pkt(1, data, checksum)
udt_send(sndpkt)
start_timer

Transport Layer: 3-5

rdt3.0 sender
rdt_send(data)
rdt_rcv(rcvpkt) &&
sndpkt = make_pkt(0, data, checksum) ( corrupt(rcvpkt) ||
udt_send(sndpkt) isACK(rcvpkt,1) )
rdt_rcv(rcvpkt) start_timer L
L Wait for Wait
for timeout
call 0 from
ACK0 udt_send(sndpkt)
above
start_timer
rdt_rcv(rcvpkt)
&& notcorrupt(rcvpkt) rdt_rcv(rcvpkt)
&& isACK(rcvpkt,1) && notcorrupt(rcvpkt)
stop_timer && isACK(rcvpkt,0)
stop_timer
Wait Wait for
timeout for call 1 from
udt_send(sndpkt) ACK1 above
start_timer rdt_rcv(rcvpkt)
rdt_send(data) L
rdt_rcv(rcvpkt) &&
sndpkt = make_pkt(1, data, checksum)
( corrupt(rcvpkt) || udt_send(sndpkt)
isACK(rcvpkt,0) ) start_timer
L

Transport Layer: 3-6

rdt3.0 in action
sender receiver sender receiver
send pkt0 pkt0 send pkt0 pkt0
rcv pkt0 rcv pkt0
ack0 send ack0 ack0 send ack0
rcv ack0 rcv ack0
send pkt1 pkt1 send pkt1 pkt1
rcv pkt1 X
loss
ack1 send ack1
rcv ack1
send pkt0 pkt0
rcv pkt0 timeout
ack0 send ack0 resend pkt1 pkt1
rcv pkt1
ack1 send ack1
rcv ack1
send pkt0 pkt0
(a) no loss rcv pkt0
ack0 send ack0

(b) packet loss

Transport Layer: 3-7
rdt3.0 in action
sender receiver
sender receiver send pkt0
pkt0
rcv pkt0
send pkt0 pkt0 send ack0
ack0
rcv pkt0 rcv ack0
ack0 send ack0 send pkt1 pkt1
rcv ack0 rcv pkt1
send pkt1 pkt1 send ack1
rcv pkt1 ack1
ack1 send ack1
X timeout
loss resend pkt1
pkt1 rcv pkt1
timeout
resend pkt1 pkt1
rcv pkt1 rcv ack1 (detect duplicate)
send pkt0 pkt0 send ack1
(detect duplicate)
ack1 send ack1 ack1 rcv pkt0
rcv ack1 rcv ack1 send ack0
send pkt0 pkt0 (ignore) ack0
rcv pkt0
ack0 send ack0 pkt1

(c) ACK loss (d) premature timeout/ delayed ACK

Transport Layer: 3-8
Performance of rdt3.0 (stop-and-wait)
 U sender: utilization – fraction of time sender busy sending

 example: 1 Gbps link, 15 ms prop. delay, 8000 bit packet

• time to transmit packet into channel:
L 8000 bits
Dtrans = R = = 8 microsecs
109 bits/sec

Transport Layer: 3-9

rdt3.0: stop-and-wait operation
sender receiver
first packet bit transmitted, t = 0

first packet bit arrives

RTT last packet bit arrives, send ACK

ACK arrives, send next

packet, t = RTT + L / R

Transport Layer: 3-10

rdt3.0: stop-and-wait operation
sender receiver

L/R L/R
Usender =
RTT + L / R
.008 RTT
=
30.008
= 0.00027

 rdt 3.0 protocol performance stinks!

 Protocol limits performance of underlying infrastructure (channel)

Transport Layer: 3-11

rdt3.0: pipelined protocols operation
pipelining: sender allows multiple, “in-flight”, yet-to-be-acknowledged
packets
• range of sequence numbers must be increased
• buffering at sender and/or receiver

Transport Layer: 3-12

Pipelining: increased utilization
sender receiver
first packet bit transmitted, t = 0
last bit transmitted, t = L / R

first packet bit arrives

RTT last packet bit arrives, send ACK
last bit of 2nd packet arrives, send ACK
last bit of 3rd packet arrives, send ACK
ACK arrives, send next
packet, t = RTT + L / R
3-packet pipelining increases
utilization by a factor of 3!

U 3L / R .0024
sender = = = 0.00081
RTT + L / R 30.008

Transport Layer: 3-13

Go-Back-N: sender
 sender: “window” of up to N, consecutive transmitted but unACKed pkts
• k-bit seq # in pkt header

 cumulative ACK: ACK(n): ACKs all packets up to, including seq # n

• on receiving ACK(n): move window forward to begin at n+1
 timer for oldest in-flight packet
 timeout(n): retransmit packet n and all higher seq # packets in window
Transport Layer: 3-14
Go-Back-N: receiver
 ACK-only: always send ACK for correctly-received packet so far, with
highest in-order seq #
• may generate duplicate ACKs
• need only remember rcv_base
 on receipt of out-of-order packet:
• can discard (don’t buffer) or buffer: an implementation decision
• re-ACK pkt with highest in-order seq #
Receiver view of sequence number space:
received and ACKed

… … Out-of-order: received but not ACKed

rcv_base
Not received
Transport Layer: 3-15
 Go-Back-N in action
sender window (N=4) sender receiver
012345678 send pkt0
012345678 send pkt1
send pkt2 receive pkt0, send ack0
012345678
send pkt3 Xloss receive pkt1, send ack1
012345678
(wait)
receive pkt3, discard,
012345678 rcv ack0, send pkt4 (re)send ack1
012345678 rcv ack1, send pkt5 receive pkt4, discard,
(re)send ack1
ignore duplicate ACK receive pkt5, discard,
(re)send ack1
pkt 2 timeout
012345678 send pkt2
012345678 send pkt3
012345678 send pkt4 rcv pkt2, deliver, send ack2
012345678 send pkt5 rcv pkt3, deliver, send ack3
rcv pkt4, deliver, send ack4
rcv pkt5, deliver, send ack5
Applets for Go-Back-N
https://computerscience.unicam.it/marcantoni/reti/applet/GoBackProtocol/goback.html Transport Layer: 3-16
https://media.pearsoncmg.com/aw/ecs_kurose_compnetwork_7/cw/content/interactiveanimations/go-back-n-protocol/index.html
GBN: sender extended FSM
rdt_send(data)
First, check if window is full,
if not send and update variables if (nextseqnum < base+N) {
sndpkt[nextseqnum] = make_pkt(nextseqnum,data,chksum)
N is the window size udt_send(sndpkt[nextseqnum])
base=oldest unack’ed if (base == nextseqnum)
nextseqnum=seqno of next pckt start_timer Timer associated with oldest unacked
nextseqnum++ base == nextseqnum, when?
}
L else
refuse_data(data)
base=1
nextseqnum=1 On timeout resend all
timeout
start_timer unack’ed packets
Wait
udt_send(sndpkt[base])
rdt_rcv(rcvpkt) udt_send(sndpkt[base+1])
Why wait?
&& corrupt(rcvpkt) …
L udt_send(sndpkt[nextseqnum-
Cumulative ACKs, receiver only rdt_rcv(rcvpkt) && 1])
ACKs when packets delivered notcorrupt(rcvpkt)
in order.
base = getacknum(rcvpkt)+1
If (base == nextseqnum)
Here we need to update base
stop_timer
and stop timer if nothing to send
else
or restart if some pckts left
start_timer Transport Layer: 3-17
GBN: receiver extended FSM
default
udt_send(sndpkt) rdt_rcv(rcvpkt)
&& notcurrupt(rcvpkt)
L && hasseqnum(rcvpkt,expectedseqnum)
expectedseqnum=1 Wait extract(rcvpkt,data)
sndpkt = deliver_data(data)
make_pkt(expectedseqnum- sndpkt = make_pkt(expectedseqnum,ACK,chksum)
1,ACK,chksum) udt_send(sndpkt)
expectedseqnum++

ACK-only: always send ACK for correctly-received pkt with

highest in-order seq #
• may generate duplicate ACKs
• need only remember expectedseqnum
 out-of-order pkt:
• discard (don’t buffer): no receiver buffering!
• re-ACK pkt with highest in-order seq #
Application Layer: 2-18
Go-Back-N

Transport Layer: 3-19

Go-Back-N

Application Layer: 2-20

Go-Back-N

Application Layer: 2-21

Go-Back-N

Application Layer: 2-22

Go-Back-N

Application Layer: 2-23

Go-Back-N

Application Layer: 2-24

Go-Back-N

Application Layer: 2-25

Go-Back-N

Application Layer: 2-26

Go-Back-N

Application Layer: 2-27

Go-Back-N
 Why N? why not having an unbound window size?

 Answer:
• Having an unbound window size means to end up with an
unbound number of unacknowledge segments
• An unbound window size means bombarding the buffers
on the network devices along the traffic path as well as
the buffer on the destination

Application Layer: 2-28

Selective repeat
 receiver individually acknowledges all correctly received packets
• buffers packets, as needed, for eventual in-order delivery to upper
layer
 sender times-out/retransmits individually for unACKed packets
• sender maintains timer for each unACKed pkt
 sender window
• N consecutive seq #s
• limits seq #s of sent, unACKed packets

Transport Layer: 3-29

Selective repeat: sender, receiver windows

Transport Layer: 3-30

Selective repeat: sender and receiver
sender receiver
data from above: packet n in [rcvbase, rcvbase+N-1]
 if next available seq # in  send ACK(n)
window, send packet  out-of-order: buffer
timeout(n):  in-order: deliver (also deliver
buffered, in-order packets),
 resend packet n, restart timer advance window to next not-yet-
ACK(n) in [sendbase, sendbase+N]: received packet
 mark packet n as received packet n in [rcvbase-N,rcvbase-1]
 ACK(n)
 if n smallest unACKed packet,
advance window base to next otherwise:
unACKed seq #  ignore

Transport Layer: 3-31

 Selective Repeat in action
sender window (N=4) sender receiver
012345678 send pkt0
012345678 send pkt1
012345678 send pkt2 receive pkt0, send ack0
012345678 send pkt3 Xloss receive pkt1, send ack1
(wait)
receive pkt3, buffer,
012345678 rcv ack0, send pkt4 send ack3
012345678 rcv ack1, send pkt5
receive pkt4, buffer,
record ack3 arrived send ack4
receive pkt5, buffer,
pkt 2 timeout send ack5
012345678 send pkt2
012345678 (but not 3,4,5)
012345678 rcv pkt2; deliver pkt2,
012345678 pkt3, pkt4, pkt5; send ack2

Q: what happens when ack2 arrives?

Applets for Selective repeat:
https://computerscience.unicam.it/marcantoni/reti/applet/SelectiveRepeatProtocol/selRepProt.html Transport Layer: 3-32
https://media.pearsoncmg.com/aw/ecs_kurose_compnetwork_7/cw/content/interactiveanimations/selective-repeat-protocol/index.html
Selective repeat

Transport Layer: 3-33

Selective repeat

Application Layer: 2-34

Selective repeat

Application Layer: 2-35

Selective repeat

Application Layer: 2-36

 receiver window

Selective repeat:
sender window
(after receipt) (after receipt)

pkt0

a dilemma!
0123012
0123012 pkt1 0123012
0123012 pkt2 0123012
0123012
example: 0123012 pkt3
X
0123012
 seq #s: 0, 1, 2, 3 (base 4 counting) pkt0 will accept packet
with seq number 0
 window size=3 (a) no problem

0123012 pkt0
0123012 pkt1 0123012
0123012 pkt2 X 0123012
X 0123012
X
timeout
retransmit pkt0
0123012 pkt0
will accept packet
with seq number 0
(b) oops!
Transport Layer: 3-37
 receiver window

Selective repeat:
sender window
(after receipt) (after receipt)

pkt0

a dilemma!
0123012
0123012 pkt1 0123012
0123012 pkt2 0123012
0123012
example: 0123012 pkt3
X
 seq #s: 0, 1, 2, 3 (base 4 counting)  receiver can’t
0123012
pkt0 will accept packet
see sender side with seq number 0
 window size=3 (a) no problem
 receiver
behavior
identical in both
cases!
0something’s
123012 pkt0
0(very)
1 2 3 0 1wrong!
Q: what relationship is needed 2 pkt1
pkt2
0123012
X
between sequence # size and 0123012 0123012
X 0123012
window size to avoid problem timeout
X
in scenario (b)? retransmit pkt0
0123012 pkt0
will accept packet
A: Window size should be less than or with seq number 0
(b) oops!
equal to half the sequence number. Transport Layer: 3-38
Summary

Application Layer: 2-39

Summary

Application Layer: 2-40

Chapter 3: roadmap
 Transport-layer services
 Multiplexing and demultiplexing
 Connectionless transport: UDP
 Principles of reliable data transfer
 Connection-oriented transport: TCP
• segment structure
• reliable data transfer
• flow control
• connection management
 Principles of congestion control
 TCP congestion control
Transport Layer: 3-41
TCP: overview RFCs: 793,1122, 2018, 5681, 7323
 point-to-point:  cumulative ACKs
• one sender, one receiver  pipelining:
 reliable, in-order byte • TCP congestion and flow control
stream: set window size
• no “message boundaries"  connection-oriented:
 full duplex data: • handshaking (exchange of control
• bi-directional data flow in messages) initializes sender,
same connection receiver state before data exchange
• MSS: maximum segment size  flow controlled:
• sender will not overwhelm receiver

Transport Layer: 3-42

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

first byte in segment’s data checksum

rwnd
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

ACKed yet ACKed but not usable
yet sent
Q: how receiver handles out-of- (“in-flight”)

order segments outgoing segment from receiver

• A: TCP spec doesn’t say, - up

source port # dest port #
sequence number

to implementor acknowledgement number

A rwnd
checksum urg pointer
Transport Layer: 3-43
MSS and MTU
 The maximum amount of data
in a segment is limited by the
maximum segment size (MSS)
 The MSS is typically set by first
determining (the so-called
maximum transmission unit,
MTU)
• MSS+ TCP/IP header when
encapsulated in an IP datagram)
will fit into a single link-layer
frame

Transport Layer: 3-44

MSS and MTU
 The MSS limits the maximum
size of a segment’s data field
 It is more or less a physical limit
 It is specified for each link
separately
 MTU reduction can occur
elsewhere in the
communication path

Transport Layer: 3-45

 Thank You All

A note on the origin of these ppt slides:

? 

All material copyright 1996-2020 J.F Kurose and K.W. Ross, All Rights Reserved Transport Layer: 3-150
These slides are freely provided by the book authors and it represents a lot of work on their part. We would like to thank J.F Kurose and K.W. Ross.