Reliable Data Transfer: Part 2

Gaurav S. Kasbekar
Dept. of Electrical Engineering
IIT Bombay

Introduction 1-1
Reference
 These are a modified version of slides by
Kurose and Ross available at:
http://ctas.poly.asu.edu/millard/CET459/lectno/K%
20-%20R%20stuff/index.html

Introduction 1-2
Reliable Data Transfer

Transport Layer 3-3

 Model 3

 Bit errors
 Channel can lose packets (data or ACKs)
 No re-ordering

Transport Layer 3-4

Rdt3.0
• Sender retransmits on timeout

Transport Layer 3-5

 Rdt3.0
• Receiver must ACK duplicate packet • Sender ignores duplicate ACKs

Transport Layer 3-6

 Stop-and-Wait
 Rdt 3.0 is a “stop-and-wait” protocol
 Lot of time wasted when round-trip time large
 Example: 1 Gbps link, 15 ms end-to-end prop.
delay, 1000 byte packet:
 Utilization: 0.00027
 Throughput: 267 kbps

Transport Layer 3-7

 Pipelined Protocols
Pipelining: sender allows multiple, “in-flight”, yet-to-
be-acknowledged pkts

Note:
• More than two sequence numbers needed
• Initially assume infinite number of sequence
numbers for simplicity Transport Layer 3-8
 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

Increase in utilization
Utilization: by a factor of 3!

U 3*L/R .024
= = = 0.0008
sender 30.008
RTT + L / R microsecon 3-9
 Window
 How many transmitted,
unacknowledged packets
should be allowed?
 e.g., in interval [𝑡1, 𝑡2] in fig
 In “ideal scenario”
 no congestion, unlimited
memory at receiver’s buffer
 unlimited

 Need to impose limit due to

congestion, receiver memory
limitations
 say “N” (window size)
Transport Layer 3-10
Example: N = 3

Transport Layer 3-11

Example: N = 3

 Sender blocked
until A1 received

3-12
Packet Loss
 What should the receiver
do upon receipt of packet
3?
1) Buffer and selectively
ACK packet 3
 Selective Repeat Protocol
2) Discard packet 3
 Go-Back-N
 useful when receiver has
limited storage, processing
capabilities
Transport Layer 3-13
Go-Back-N Operation
• Receiver discards out-of-
order packets
• When timeout occurs,
sender resends that packet
and all subsequent packets
in window
• hence the name “Go-Back-N”
• Receiver ACKs are
cumulative
• ACK(n): ACKs all packets up
to and including packet n
• In figure, wouldn’t matter if
ACK0 were lost provided
ACK1 reached before pkt0’s
timeout
Transport Layer 3-14
Sender’s and Receiver’s Views of
Sequence Numbers

 Sender’s Window:
 send_base = seq. no. of oldest sent, unACKed packet
 nextseqnum=smallest unused seq. no.

 Receiver keeps track of:

 expectedseqnum=next in-order seq. no. expected by receiver

 Relation between expectedseqnum and send_base:

 expectedseqnum ≥ send_base

 Relation between expectedseqnum and nextseqnum:

 expectedseqnum ≤ nextseqnum 3-15
 Go-Back-N Operation
• If receiver receives
packet with seq. no. less
than expectedseqnum:
❑ discards packet (duplicate)
❑ must send ACK
❑ else sender’s window may
never move forward!
❑ ACK is cumulative ACK up to
expectedseqnum-1
• In figure, upon duplicate
receipt of P1, receiver
sends:
❑ A4

3-16
Go-Back-N Operation
• If receiver receives packet
with seq. no. greater than
expectedseqnum:
• discards packet (out-of-order)
• ACK not necessary for correct
operation
• But cumulative
ACK(expectedseqnum-1) still sent
• useful if previous ACKs were lost

3-17
Go-Back-N Operation
• Can the sender get an ACK for
a pkt with sequence number <
send_base-1?
• No, due to “no-reordering”
assumption

3-18
 GBN: Sender FSM
rdt_send(data)
if (nextseqnum < base+N) {
sndpkt[nextseqnum] = make_pkt(nextseqnum,data,chksum)
udt_send(sndpkt[nextseqnum])
if (base == nextseqnum)
start_timer
nextseqnum++
}
L else
refuse_data(data)
base=1
nextseqnum=1
timeout
start_timer
Wait udt_send(sndpkt[base])
udt_send(sndpkt[base+1])
rdt_rcv(rcvpkt)
…
&& corrupt(rcvpkt)
udt_send(sndpkt[nextseqnum-1])
L rdt_rcv(rcvpkt) &&
notcorrupt(rcvpkt)
base = getacknum(rcvpkt)+1
If (base == nextseqnum)
stop_timer
else
start_timer
3-19
 GBN: Receiver 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,ACK,chksum) sndpkt = make_pkt(expectedseqnum,ACK,chksum)
udt_send(sndpkt)
expectedseqnum++

Transport Layer 3-20

Selective Repeat
 Receiver buffers and
selectively ACKs out-of-order
packets
 packet 3 in figure
 delivered above when missing
packets received
 Sender only resends pkt for
which ACK not received until
timeout
 separate timer for each pkt

Transport Layer 3-21

Selective Repeat
 Sender’s window of size N:
 limits number of transmitted, unACKed pkts
 as in GBN

 Receiver also maintains a window of size N

 Recall: in GBN, receiver only needs to keep
track of expectedseqnum
 since out of order pkts discarded

Transport Layer 3-22

Selective Repeat Operation

Transport Layer 3-23

Selective repeat: sender, receiver windows

Transport Layer 3-24

Selective Repeat
sender
data from above :
 if next available seq # in
window, send pkt
timeout(n):
 resend pkt n, restart timer
ACK(n) in [sendbase,sendbase+N-
1]:
 mark pkt n as received
 if n smallest unACKed pkt,
advance window base to
next unACKed seq #
receiver
pkt n in [rcvbase, rcvbase+N-1]
 send ACK(n)
 out-of-order: buffer
 in-order: deliver (also
deliver buffered, in-order
pkts), advance window to
next not-yet-received pkt
pkt n in [rcvbase-N,rcvbase-1]
 ACK(n)
otherwise:
 ignore
Transport Layer 3-25
 Number of Distinct Seq. Nos
 For given value of N, how many distinct
sequence numbers needed?
 Clearly ≥ 𝑁

Transport Layer 3-26

 Problem with Small
Seq. No. Space
Example:
 N=3
 Seq. nos. 0, 1, 2, 3 used
 Two different
scenarios
 Receiver sees no
difference between
them!
 Exercise: Find minimum
no. of seq. nos for a
given window size for
correct operation
Transport Layer 3-27