Computer Networks

(WEEK-6)
LECTURE-11&12

Principles of Reliable data Transfer

Protocols

Lecturer
Mudassar Butt
mudassar.b@scocs.edu.pk
Chapter 3
outline
1. transport- 5. connection-
layer services oriented
2. multiplexing transport: TCP
and • segment structure
demultiplexing • reliable data
3. connectionless transfer
transport: • flow control
UDP • connection
management
4. principles of
reliable data 6. principles of
transfer congestion control
7. TCP congestion
control Transport Layer 3-2
Principles of reliable data
transfer
 important in application, transport, link
layers
• top-10 list of important networking topics!

 characteristics of unreliable channel will

determine complexity of reliable data transfer
protocol (rdt)
Transport Layer 3-3
Principles of reliable data
transfer
 important in application, transport, link
layers
• top-10 list of important networking topics!

 characteristics of unreliable channel will

determine complexity of reliable data transfer
protocol (rdt)
Transport Layer 3-4
Principles of reliable data
transfer
 important in application, transport, link
layers
• top-10 list of important networking topics!

 characteristics of unreliable channel will

determine complexity of reliable data transfer
protocol (rdt)
Transport Layer 3-5
Reliable data transfer: getting
started
rdt_send(): called from above, deliver_data(): called by
(e.g., by app.). Passed data to rdt to deliver data to upper
deliver to receiver upper
layer

send receive
side side

udt_send(): called by rdt, rdt_rcv(): called when packet

to transfer packet over arrives on rcv-side of channel
unreliable channel to receiver

Transport Layer 3-6

Reliable data transfer: getting
started
we’ll:
 incrementally develop sender, receiver
sides of reliable data transfer protocol
(rdt)
 consider only unidirectional data
transfer
• but control info will flow on both
directions!
 use finite state machines (FSM)
state: when in this
to specify
sender,
“state” next receiver
state state state
uniquely determined 1 eventevent
causing state transition 2
by next event actions taken on state transition
actions

Transport Layer 3-7

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)
call from call from extract (packet,data)
above packet = make_pkt(data) below deliver_data(data)
udt_send(packet)

sender receiver

Transport Layer 3-8

rdt2.0: channel with bit
errors
 underlying channel may flip bits in
packet
• checksum to detect bit errors
• acknowledgements
 the question: how (ACKs): receiver
to recover explicitly tells
from
sender that pkt received O K
errors:
• negative acknowledgements (NAKs): receiver explicitly
tells sender that pkt had errors
• sender How
retransmits pkt on receipt
do humans of N AK
recover from
 new mechanisms in rdt2.0 (beyond rdt1.0):
• error detection “errors”
during
• receiver feedback: conversation?
control msgs (ACK,NAK) rcvr-
>sender

Transport Layer 3-9

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 O K
• negative acknowledgements (NAKs): receiver explicitly
tells sender that pkt had errors
• sender retransmits pkt on receipt of N AK
 new mechanisms in rdt2.0 (beyond rdt1.0):
• error detection
• feedback: control msgs (ACK,NAK) from receiver
to sender

Transport Layer 3-10

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

rdt_rcv(rcvpkt) && isACK(rcvpkt)

Wait for
 call from
below
sender
rdt_rcv(rcvpkt) &&
notcorrupt(rcvpkt)
extract(rcvpkt,data)
deliver_data(data)
udt_send(ACK)

Transport Layer 3-11

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

rdt_rcv(rcvpkt) && isACK(rcvpkt)

Wait for
 call from
below

rdt_rcv(rcvpkt) &&
notcorrupt(rcvpkt)
extract(rcvpkt,data)
deliver_data(data)
udt_send(ACK)

Transport Layer 3-12

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

rdt_rcv(rcvpkt) && isACK(rcvpkt)

Wait for
 call from
below

rdt_rcv(rcvpkt) &&
notcorrupt(rcvpkt)
extract(rcvpkt,data)
deliver_data(data)
udt_send(ACK)

Transport Layer 3-13

rdt2.0 has a fatal
flaw!
what happens if handling
ACK/NAK corrupted?
 sender doesn’t duplicates:
know what  sender retransmits
happened at current pkt if
receiver! AC K/N AK corrupted
 can’t just  sender adds
retransmit: possible sequence number
duplicate to each pkt
stop and wait
 receiver discards
sender sends (doesn’t
one deliver up)
packet, then waits forpkt
duplicate
receiver response

Transport Layer 3-14

rdt2.1: sender, handles garbled
AC K/N AKs rdt_send(data)
sndpkt = make_pkt(0, data, checksum)
udt_send(sndpkt) rdt_rcv(rcvpkt) &&
( corrupt(rcvpkt) ||
Wait for Wait for
ACK
isNAK(rcvpkt) )
call 0 from udt_send(sndpkt)
above or
rdt_rcv(rcvpkt) NAK 0
&& notcorrupt(rcvpkt) rdt_rcv(rcvpkt)
&& isACK(rcvpkt) && notcorrupt(rcvpkt)
&& isACK(rcvpkt)


Wait for Wait for
ACK call 1 from
rdt_rcv(rcvpkt) && or above
( corrupt(rcvpkt) || NAK 1
isNAK(rcvpkt) ) rdt_send(data)

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

udt_send(sndpkt)

Transport Layer 3-16

 rdt2.1: receiver, handles garbled
ACK/N AKs rdt_rcv(rcvpkt) && notcorrupt(rcvpkt)
&& has_seq0(rcvpkt)
extract(rcvpkt,data)
deliver_data(data)
sndpkt = make_pkt(ACK, chksum)
udt_send(sndpkt)
rdt_rcv(rcvpkt) && (corrupt(rcvpkt) rdt_rcv(rcvpkt) && (corrupt(rcvpkt)
sndpkt = make_pkt(NAK, chksum) sndpkt = make_pkt(NAK, chksum)
udt_send(sndpkt) udt_send(sndpkt)
Wait for Wait for
rdt_rcv(rcvpkt) && 0 from 1 from rdt_rcv(rcvpkt) &&
not corrupt(rcvpkt) && below below not corrupt(rcvpkt) &&
has_seq1(rcvpkt) 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-17

rdt2.1:
discussion
sender: receiver:
 seq # added to pkt  must check if
 two seq. #’s (0,1) received packet is
will suffice. Why? duplicate
 must check if • state indicates
whether 0 or 1 is
received ACK/NAK expected pkt seq #
corrupted  note: receiver can
 twice as many not know if its last
states ACK/NAK received
• state must O K at sender
“remember”
whether “expected”
pkt should have seq
# of 0 or 1 Transport Layer 3-18
rdt2.2: a N AK-free
protocol
 same functionality as rdt2.1, using ACKs only
 instead of N AK, receiver sends AC K for
last pkt received O K
• receiver must explicitly include seq # of pkt being
ACKed
 duplicate ACK at sender results in same action
as N A K: retransmit current pkt

Transport Layer 3-19

rdt3.0: channels with errors and
loss
new assumption: approach: sender waits
underlying channel “reasonable” amount
can also lose of time for AC K
packets (data,  retransmits if no
ACKs) AC K received in
this time
• checksum, seq. #,  if pkt (or AC K) just
ACKs, retransmissions delayed (not lost):
will be of help … • retransmission will
but not enough be duplicate, but
seq. #’s already
handles this
• receiver must specify
seq # of pkt being
AC Ked
 requires countdownTransport
timerLayer 3-23
rdt3.0
sender rdt_send(data)
sndpkt = make_pkt(0, data, checksum)
rdt_rcv(rcvpkt) &&
( corrupt(rcvpkt) ||
udt_send(sndpkt) isACK(rcvpkt,1) )
rdt_rcv(rcvpkt) start_timer 
 Wait for Wait
for timeout
call 0from udt_send(sndpkt)
above ACK0
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) 
rdt_rcv(rcvpkt) &&
( corrupt(rcvpkt) || sndpkt = make_pkt(1, data, checksum)
isACK(rcvpkt,0) ) udt_send(sndpkt)
start_timer


Transport Layer 3-24

 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 send pkt1
pkt1 rcv pkt1 pkt1 X
ack1 send ack1 lo
rcv ack1 s
send pkt0 s
pkt0 rcv pkt0 timeout
ack0 send ack0 resend pkt1 pkt1
rcv pkt1
ack1 send ack1
rcv ack1
send pkt0
(a) no loss pkt0 rcv pkt0
ack0 send ack0

(b) packet loss

Transport Layer 3-25
 rdt3.0 in
sender receiver
action
sender send pkt0 pkt0
receiver pkt0 rcv pkt0
ack0 send ack0
rcv pkt0
send pkt0 send ack0 rcv ack0
ack0 send pkt1
rcv ack0 pkt1 rcv pkt1
send pkt1
rcv pkt1 send ack1
pkt1 ack1
ack1 send ack1
X
loss timeout
resend pkt1 pkt1
rcv pkt1
timeout
resend pkt1 pkt1 rcv ack1 pkt0 (detect duplicate)
rcv pkt1 send send ack1
(detect duplicate) ack1
ack1 send ack1 pkt0 rcv pkt0
rcv ack1 a send ack0
pkt0 rcv ack1 ck0
send send rcv pkt0
rcv pkt0 p
pkt0 pkt0 (detect
ack0 send ack0 k duplicate)
t send ack0
0
(c) ACK loss (d) premature timeout/
a delayed ACK
ck0
Transport Layer 3-26
Performance of
rdt3.0
 rdt3.0 is correct, but performance stinks
 e.g.: 1 Gbps link, 15 ms prop. delay, 8000 bit
packet: 8000 bits
L =
Dtrans = R = 8 microsecs
109 bits/sec
 U sender: utilization – fraction of time sender busy
sending L/R
U = 0.00027
sender = . 008
=
30.008
RTT + L / R
 if RTT=30 msec, 1KB pkt every 30 msec: 33kB/sec
thruput over 1 Gbps link
 network protocol limits use of physical
resources!
Transport Layer 3-27
 rdt3.0: stop-and-wait
operation sender receiver
first packet bit transmitted, t = 0
last packet bit transmitted, t = L / R

first packet bit arrives

RTT last packet bit arrives, send ACK

ACK arrives, send next

packet, t = RTT + L / R

U L/R .00
sender = = 8 = 0.00027
RTT + L / R 30.008

Transport Layer 3-28

Pipelined
protocols
pipelining: sender allows multiple, “in-flight”,
yet- to-be-acknowledged pkts
• range of sequence numbers must be increased
• buffering at sender and/or receiver

 two generic forms of pipelined protocols: go-

Back-N, selective repeat
Transport Layer 3-29
 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-30

Pipelined protocols:
overview
Go-back-N: Selective Repeat:
 sender can have up  sender can have up to
to N unacked N unack’ed packets
packets in pipeline in pipeline
 receiver only sends  rcvr sends individual
cumulative ack ack
• doesn’t ack packet for each packet
if there’s a gap
 sender has timer for
oldest unacked  sender maintains
packet timer for each
• when timer expires, unacked packet
retransmit all • when timer
unacked packets expires,
retransmit only
that unacked
Transport Layer 3-31
Go-Back-N:
sender
 k-bit seq # in pkt header
 “window” of up to N, consecutive unack’ed pkts
allowed

 ACK(n): ACKs all pkts up to, including seq # n -

“cumulative ACK”
• may receive duplicate ACKs (see receiver)
 timer for oldest in-flight pkt
 timeout(n): retransmit packet n and all higher seq #
pkts in window
Transport Layer 3-32
 GBN in
action
sender window (N=4) sender receiver
0123 45678 send pkt0
0123 45678 send pkt1
0123 45678 send pkt2 receive pkt0, send ack0
send pkt3 receive pkt1, send
0123 45678 Xloss
(wait) ack1
receive pkt3, discard,
0 1234 5678 rcv ack0, send pkt4 (re)send ack1
01 2345 678 rcv ack1, send pkt5 receive pkt4, discard,
(re)send ack1
ignore duplicate ACK receive pkt5,
discard,
pkt 2 timeout
(re)send ack1
01 2345 678 send pkt2
01 2345 678 send pkt3
01 2345 678 send pkt4 rcv pkt2, deliver, send ack2
01 2345 678 send pkt5 rcv pkt3, deliver, send
ack3 rcv pkt4, deliver,
send ack4 rcv pkt5,
deliver, send ack5

Transport Layer 3-33

Selective
repeat
 receiver individually acknowledges all
correctly received pkts
• buffers pkts, as needed, for eventual in-order
delivery to upper layer
 sender only resends pkts for which AC K
not received
• sender timer for each unAC Ked pkt
 sender window
• N consecutive seq #’s
• limits seq #s of sent, unAC Ked pkts

Transport Layer 3-34

Selective repeat: sender, receiver
windows

Transport Layer 3-35

Selective
repeat
sender receiver
data from above: pkt n in [rcvbase,
 if next available seq rcvbase+N -1]
# in window, send  send AC K(n)
pkt  out-of-order: buffer
timeout(n):  in-order: deliver (also
 resend pkt n, restart deliver buffered, in-
timer order pkts), advance
window to next not-
AC K(n) in yet-received pkt
[sendbase,sendbase+N ]:
 mark pkt n as pkt n in [rcvbase-N ,rcvbase-
1]
received
 ACK(n)
 if n smallest unAC Ked
pkt, advance window otherwise:
base to next unAC Ked  ignore Transport Layer 3-36
 Selective repeat in
action
sender window (N=4) sender receiver
0123 45678 send pkt0
0123 45678 send pkt1
0123 45678 send pkt2 receive pkt0, send ack0
send pkt3 receive pkt1, send
0123 45678 Xloss
(wait) ack1
receive pkt3, buffer,
0 1234 5678 rcv ack0, send pkt4 send ack3
01 2345 678 rcv ack1, send pkt5 receive pkt4, buffer,
send ack4
record ack3 arrived receive pkt5, buffer,
sen
pkt 2 timeout
d ack5
01 2345 678 send pkt2
01 2345 678 record ack4 arrived
01 2345 678 rcv pkt2; deliver pkt2,
record ack5
01 2345 678 pkt3, pkt4, pkt5; send ack2
arrived
Q: what happens when ack2 arrives?

Transport Layer 3-37

 receiver window
Selective
sender window
(after receipt) (after receipt)

repeat: 012 3012 pkt0

dilemma 012 3012

012 3012
pkt1 0 123 012
01 230 12
pkt2 012 301 2
0 123 012 pkt3
example: 01 230 12
X

 seq #’s: 0, 1, 2, 3 pkt0 will accept packet

with seq number 0
(a) no problem
 window size=3
receiver can’t see sender side.
 receiver sees receiver behavior identical in both cases!
no difference something’s (very) wrong!
in two
scenarios! 012 3012 pkt0

 duplicate data 012 3012 0 123 012

pkt1
Q:accepted as new in
what relationship 012 3012 01 230 12
012 301 2
(b)
between seq # size pkt2
and window size to timeout
retransmit pkt0 XX
avoid problem in 012 3012 pkt0
will accept packet
(b)? X with seq number 0
(b) oops!

Transport Layer 3-38