National University of

Computer & Emerging Sciences

CS 3001 – COMPUTER NETWORKS

Lecture 10
Chapter 3

26th Septemebr, 2024

Nauman Moazzam Hayat

[email protected]
Office Hours: 02:00 pm till 04:30 pm (Every Tuesday & Thursday)
Chapter 3
Transport Layer
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. 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!)
▪ 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 material.
Computer Networking: A
For a revision history, see the slide note for this page.
Top-Down Approach
Thanks and enjoy! JFK/KWR 8th edition
All material copyright 1996-2023
Jim Kurose, Keith Ross
J.F Kurose and K.W. Ross, All Rights Reserved Pearson, 2020

Transport Layer: 3-2

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-3

 Principles of reliable data transfer

sending receiving
process process
application dat dat
transport a a
reliable channel

reliable service abstraction

Transport Layer: 3-4

 Principles of reliable data transfer

sending receiving sending receiving

process process process process
application dat dat application dat dat
transport a a transport a a
reliable channel
sender-side of receiver-side
reliable service abstraction reliable data of reliable data
transfer protocol transfer protocol

transport
network
unreliable channel

reliable service implementation

Transport Layer: 3-5

Principles of reliable data transfer

sending receiving
process process
application dat dat
transport a a

sender-side of receiver-side
Complexity of reliable data reliable data
transfer protocol
of reliable data
transfer protocol
transfer protocol will depend
(strongly) on characteristics of transport
network
unreliable channel (lose, unreliable channel
corrupt, reorder data?)
reliable service implementation

Transport Layer: 3-6

Principles of reliable data transfer

sending receiving
process process
application dat dat
transport a a

sender-side of receiver-side
reliable data of reliable data
Sender, receiver do not know transfer protocol transfer protocol
the “state” of each other, e.g.,
was a message received? transport
network
▪ unless communicated via a unreliable channel
message
reliable service implementation

Transport Layer: 3-7

 Reliable data transfer protocol (rdt): interfaces
rdt_send(): called from deliver_data(): called by rdt
above, (e.g., by app.). Passed to deliver data to upper layer
data to deliver to receiver
upper layer sending receiving
process process
rdt_send() dat dat
a a deliver_data(
)
sender-side data receiver-side
implementation of implementation of
rdt reliable data packet rdt reliable data
transfer protocol transfer protocol
udt_send() Heade dat Heade dat rdt_rcv()
r a r a
unreliable channel
udt_send(): called by rdt rdt_rcv(): called when packet
to transfer packet over Bi-directional communication over arrives on receiver side of
unreliable channel to unreliable channel channel
receiver Transport Layer: 3-8
Reliable data transfer: getting started
We will:
▪ incrementally develop sender, receiver sides of reliable data transfer
protocol (rdt)
▪ consider only unidirectional data transfer
• but control info will flow in both directions!
▪ use finite state machines (FSM) to specify sender, receiver

event causing state transition

actions taken on state transition
state: when in this “state”
next state uniquely state state
determined by next 1 event
2
event actions

Transport Layer: 3-9

Finite State Machine (FSM)
- Or simply a State Machine
- It is a mathematical model of computation.
- It is an abstract machine that can be in exactly one of a finite
number of states at any given time.
- The FSM can change from one state to another in response to some
event / input
- The change from one state to another is called a transition
- An FSM is defined by:
- a list of its states
- its initial state
- and the event / input that trigger each transition
- & the resultant actions that happen in response to the event
- Examples are vending machines, elevators, traffic signals, turnstile

State Diagram of a Turnstile

rdt1.0: reliable transfer over a reliable channel
▪ underlying channel perfectly reliable
• no bit errors
• no loss of packets

▪ separate FSMs for sender, receiver:

• sender sends data into underlying channel
• receiver reads data from underlying channel

Wait for rdt_send(data) Wait for rdt_rcv(packet)

sender call from packet = make_pkt(data) receiver call from extract (packet,data)
above udt_send(packet) below deliver_data(data)

Transport Layer: 3-11

rdt2.0: channel with bit errors
▪ underlying channel may flip bits in packet
• checksum (e.g., Internet checksum) to detect bit errors
▪ the question: how to recover from errors?

How do humans recover from “errors” during conversation?

Transport Layer: 3-12

rdt2.0: channel with bit errors
▪ underlying channel may flip bits in packet
• checksum to detect bit errors
▪ the question: how to recover from errors?
• acknowledgements (ACKs): receiver explicitly tells sender that pkt received
OK
• negative acknowledgements (NAKs): receiver explicitly tells sender that pkt
had errors
• sender retransmits pkt on receipt of NAK
• new mechanisms in rdt2.0 (three new functionalities beyond
rdt1.0):
▪ error detection (e.g. checksum)
▪ feedback: control msgs (ACK,NAK) from receiver to sender
▪ retransmission: A packet arriving in error at receiver is
retransmitted by the sender.
stop and wait
sender sends one packet, then waits for receiver response
Transport Layer: 3-13
rdt2.0: FSM specifications
rdt_send(data)
snkpkt = make_pkt(data, checksum)
udt_send(sndpkt)
rdt_rcv(rcvpkt) &&
Wait for Wait for isNAK(rcvpkt)
sender call from ACK or udt_send(sndpkt rdt_rcv(rcvpkt) && corrupt(rcvpkt)
above NAK )
udt_send(NAK)

rdt_rcv(rcvpkt) && isACK(rcvpkt)

Wait for
 call from receiver
below

rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)

extract(rcvpkt,data)
deliver_data(data)
udt_send(ACK)

Transport Layer: 3-14

rdt2.0: FSM specification
rdt_send(data)
snkpkt = make_pkt(data, checksum)
udt_send(sndpkt)
rdt_rcv(rcvpkt) &&
Wait for Wait for isNAK(rcvpkt)
sender call from ACK or udt_send(sndpkt rdt_rcv(rcvpkt) && corrupt(rcvpkt)
above NAK )
udt_send(NAK)

rdt_rcv(rcvpkt) && isACK(rcvpkt)

Wait for
 call from receiver
below

Note: “state” of receiver (did the receiver get my

message correctly?) isn’t known to sender unless rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)
extract(rcvpkt,data)
somehow communicated from receiver to sender deliver_data(data)
▪ that’s why we need a protocol! udt_send(ACK)

Transport Layer: 3-15

rdt2.0: operation with no errors
rdt_send(data)
snkpkt = make_pkt(data, checksum)
udt_send(sndpkt)
rdt_rcv(rcvpkt) &&
Wait for Wait for isNAK(rcvpkt)
sender call from ACK or udt_send(sndpkt rdt_rcv(rcvpkt) && corrupt(rcvpkt)
above NAK )
udt_send(NAK)

rdt_rcv(rcvpkt) && isACK(rcvpkt)

Wait for
 call from receiver
below

rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)

extract(rcvpkt,data)
deliver_data(data)
udt_send(ACK)

Transport Layer: 3-16

rdt2.0: corrupted packet scenario
rdt_send(data)
snkpkt = make_pkt(data, checksum)
udt_send(sndpkt)
rdt_rcv(rcvpkt) &&
Wait for Wait for isNAK(rcvpkt)
sender call from ACK or udt_send(sndpkt rdt_rcv(rcvpkt) && corrupt(rcvpkt)
above NAK )
udt_send(NAK)

rdt_rcv(rcvpkt) && isACK(rcvpkt)

Wait for
 call from receiver
below

rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)

extract(rcvpkt,data)
deliver_data(data)
udt_send(ACK)

Transport Layer: 3-17

rdt2.0 has a fatal flaw!
what happens if ACK/NAK handling duplicates:
corrupted? ▪ sender retransmits current pkt
▪ sender doesn’t know what if ACK/NAK corrupted
happened at receiver! ▪ sender adds sequence number
▪ can’t just retransmit: possible to each pkt
duplicate ▪ receiver discards (doesn’t
deliver up) duplicate pkt

stop and wait

sender sends one packet, then
waits for receiver response
Transport Layer: 3-18
rdt2.1: sender, handling garbled ACK/NAKs
rdt_send(data)
sndpkt = make_pkt(0, data,
checksum) rdt_rcv(rcvpkt) &&
udt_send(sndpkt) (corrupt(rcvpkt) ||
Wait for Wait for isNAK(rcvpkt) )
call 0 from ACK or
NAK 0 udt_send(sndpkt)
above
rdt_rcv(rcvpkt)
rdt_rcv(rcvpkt)
&& notcorrupt(rcvpkt) &&
&& notcorrupt(rcvpkt)
isACK(rcvpkt)
&& isACK(rcvpkt)


Wait for Wait for
ACK or call 1 from
rdt_rcv(rcvpkt) NAK 1 above
&& (corrupt(rcvpkt) ||
isNAK(rcvpkt) ) rdt_send(data)

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

udt_send(sndpkt)

Transport Layer: 3-19

rdt2.1: receiver, handling garbled ACK/NAKs
rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)
&& has_seq0(rcvpkt)
extract(rcvpkt,data)
deliver_data(data)
sndpkt = make_pkt(ACK, chksum)
rdt_rcv(rcvpkt) && udt_send(sndpkt) rdt_rcv(rcvpkt) &&
(corrupt(rcvpkt) (corrupt(rcvpkt)
sndpkt = make_pkt(NAK, chksum) sndpkt = make_pkt(NAK, chksum)
udt_send(sndpkt) udt_send(sndpkt)
Wait Wait
rdt_rcv(rcvpkt) && for for rdt_rcv(rcvpkt) &&
not corrupt(rcvpkt) && 0 from 1 from not corrupt(rcvpkt) &&
has_seq1(rcvpkt) below below has_seq0(rcvpkt)
sndpkt = make_pkt(ACK, chksum) sndpkt = make_pkt(ACK, chksum)
udt_send(sndpkt) udt_send(sndpkt)
rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)
&& has_seq1(rcvpkt)

extract(rcvpkt,data)
deliver_data(data)
sndpkt = make_pkt(ACK, chksum)
udt_send(sndpkt)

Transport Layer: 3-20

rdt2.1: discussion
sender: receiver:
▪ seq # added to pkt ▪ must check if received packet
▪ two seq. #s (0,1) will suffice. Why? is duplicate
[since it is a simple stop and wait • state indicates whether 0 or 1 is
protocol, if receiver receives the same expected pkt seq #
sequence number twice (i.e.
consecutively), it knows it is duplicate.] ▪ note: receiver can not know if
▪ must check if received ACK/NAK its last ACK/NAK received OK
corrupted at sender
▪ twice as many states
• state must “remember” whether
“expected” pkt should have seq # of 0
or 1
Transport Layer: 3-21
rdt2.2: a NAK-free protocol
▪ same functionality as rdt2.1, using ACKs only
▪ instead of NAK, receiver sends ACK for last pkt received OK
• receiver must explicitly include seq # of pkt being ACKed
▪ duplicate ACK at sender results in same action as NAK:
retransmit current pkt

As we will see, TCP uses this approach to be NAK-free

Transport Layer: 3-22

rdt2.2: sender, receiver fragments
rdt_send(data)
sndpkt = make_pkt(0, data,
checksum) rdt_rcv(rcvpkt) &&
udt_send(sndpkt) ( corrupt(rcvpkt) ||
Wait for Wait for
ACK isACK(rcvpkt,1) )
call 0
from 0 udt_send(sndpkt)
above sender FSM
fragment rdt_rcv(rcvpkt)
&& notcorrupt(rcvpkt)
rdt_rcv(rcvpkt) && && isACK(rcvpkt,0)
(corrupt(rcvpkt) || 
has_seq1(rcvpkt)) Wait receiver FSM
for
udt_send(sndpkt) 0 from fragment
below
rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)
&& has_seq1(rcvpkt)
extract(rcvpkt,data)
deliver_data(data)
sndpkt = make_pkt(ACK1, chksum)
udt_send(sndpkt) Transport Layer: 3-23
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-24

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-25

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)
&& rdt_rcv(rcvpkt)
notcorrupt(rcvpkt) && notcorrupt(rcvpkt)
&& isACK(rcvpkt,1)
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-26

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 
 Wait for Wait
for timeout
call 0 from
ACK0 udt_send(sndpkt)
above
start_timer
rdt_rcv(rcvpkt)
&& rdt_rcv(rcvpkt)
notcorrupt(rcvpkt) && notcorrupt(rcvpkt)
&& isACK(rcvpkt,1)
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) 
rdt_rcv(rcvpkt)
&& sndpkt = make_pkt(1, data, checksum)
( corrupt(rcvpkt) udt_send(sndpkt)
|| start_timer

isACK(rcvpkt,0) )

Transport Layer: 3-27

rdt3.0 in action
sender receiver sender receiver
send pkt0 pkt0 send pkt0 pkt0
rcv pkt0 rcv pkt0
ack send ack0 ack0 send ack0
rcv ack0 0 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-28
rdt3.0 in action
sender receiver
sender receiver send pkt0
pkt0
rcv pkt0
send pkt0 pkt0 send ack0
ack
rcv pkt0 rcv ack0
send ack0 send pkt1 0
ack pkt
rcv ack0 0 1 rcv pkt1
send pkt1 pkt send ack1
1 rcv pkt1 ack1
ack1 send ack1
X timeout
loss resend pkt1
timeout
pkt1 rcv pkt1
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 pkt
1

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

Transport Layer: 3-29
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 = 9 = 8 microsecs
10 bits/sec

Transport Layer: 3-30

rdt3.0: stop-and-wait operation
sender receive
r
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-31

rdt3.0: stop-and-wait operation
sender receive
r
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-32

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-33

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-34

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-35

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-36