rdt 2 2 a NAKfree protocol r same

rdt 2. 2: a NAK-free protocol r same functionality as rdt 2. 1, using ACKs only r instead of NAK, receiver sends ACK for last pkt received OK m receiver must explicitly include seq # of pkt being ACKed r duplicate ACK at sender results in same action as NAK: retransmit current pkt Transport Layer 3 -1

rdt 2. 2: sender FSM rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) udt_rcv(rcvpkt) && Wait for ACK 0 Wait for call 0 from above udt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt, 1) sender FSM udt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt, 0) L udt_rcv(rcvpkt) && ( corrupt(rcvpkt) || is. ACK(rcvpkt, 0) ) udt_send(sndpkt) Wait for ACK 1 ( corrupt(rcvpkt) || is. ACK(rcvpkt, 1) ) udt_send(sndpkt) Wait for call 1 from above L rdt_send(data) sndpkt = make_pkt(1, data, checksum) Transport Layer udt_send(sndpkt) 3 -2

rdt 2. 2: receiver FSM udt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 0(rcvpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK 0, chksum) udt_send(sndpkt) udt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq 1(rcvpkt)) udt_send(sndpkt) Wait for 0 from below receiver FSM Wait for 1 from below udt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 1(rcvpkt) udt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq 0(rcvpkt)) udt_send(sndpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK 1, chksum) udt_send(sndpkt) Transport Layer 3 -3

rdt 3. 0: channels with errors and loss New assumption: underlying channel can also lose packets (data or ACKs) m checksum, seq. #, ACKs, retransmissions will be of help, but not enough Approach: sender waits “reasonable” amount of time for ACK r retransmits if no ACK received in this time r if pkt (or ACK) just delayed (not lost): m retransmission will be duplicate, but use of seq. #’s already handles this m receiver must specify seq # of pkt being ACKed r requires countdown timer Transport Layer 3 -4

rdt 3. 0 (stop and wait) sender rdt_send(data) udt_rcv(rcvpkt) L udt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt, 1) timeout udt_send(sndpkt) start_timer udt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt, 0) stop_timer Wait for ACK 1 udt_rcv(rcvpkt) && ( corrupt(rcvpkt) || is. ACK(rcvpkt, 0) ) L L Wait for ACK 0 Wait for call 0 from above timeout udt_send(sndpkt) start_timer udt_rcv(rcvpkt) && ( corrupt(rcvpkt) || is. ACK(rcvpkt, 1) ) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) start_timer Wait for call 1 from above rdt_send(data) sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) start_timer udt_rcv(rcvpkt) L Transport Layer 3 -5

rdt 3. 0 (stop and wait) receiver r Receiver does not have time-out issue m Work the same as rdt 2. 2 udt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 0(rcvpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK 0, chksum) udt_send(sndpkt) udt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq 1(rcvpkt)) udt_send(sndpkt) Wait for 0 from below receiver FSM Wait for 1 from below udt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 1(rcvpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK 1, chksum) udt_send(sndpkt) udt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq 0(rcvpkt)) udt_send(sndpkt) Transport Layer 3 -6

rdt 3. 0 in action Transport Layer 3 -7

rdt 3. 0 in action Transport Layer 3 -8

rdt 3. 0: stop-and-wait operation sender receiver first packet bit transmitted, t = 0 last packet bit transmitted, t = L / R first packet bit arrives last packet bit arrives, send ACK RTT ACK arrives, send next packet, t = RTT + L / R L: packet bit length R: link bandwidth (bps) Transport Layer 3 -9

Performance of rdt 3. 0 r rdt 3. 0 works, but performance stinks r example: 1 Gbps link, 15 ms e-e prop. delay, 1 KB packet: Ttransmit = m m m L (packet length in bits) 8 kb/pkt = R (transmission rate, bps) 109 b/sec = 0. 008 ms U sender: utilization – fraction of time sender busy sending 1 KB pkt every 30 msec -> 33 k. B/sec thruput over 1 Gbps link network protocol limits use of physical resources! Transport Layer 3 -10

Pipelined protocols Pipelining: sender allows multiple, “in-flight”, yet-tobe-acknowledged pkts m m range of sequence numbers must be increased buffering at sender and/or receiver r Two generic forms of pipelined protocols: m go-Back-N, selective repeat Transport Layer 3 -11

Pipelining: increased utilization sender receiver first packet bit transmitted, t = 0 last bit transmitted, t = L / R RTT first packet bit arrives last packet bit arrives, send ACK last bit of 2 nd packet arrives, send ACK last bit of 3 rd packet arrives, send ACK arrives, send next packet, t = RTT + L / R Increase utilization by a factor of 3! Transport Layer 3 -12

Go-Back-N Sender: r k-bit seq # in pkt header r “window” of up to N, consecutive unack’ed pkts allowed r ACK(n): ACKs all pkts up to, including seq # n - “cumulative ACK” may receive duplicate ACKs (see receiver) r A single timer for the oldest transmitted but un-acked pkt r timeout: retransmit all pkts in window (up to N packets) m Transport Layer 3 -13

GBN: sender extended FSM rdt_send(data) L base=1 nextseqnum=1 if (nextseqnum < base+N) { sndpkt[nextseqnum] = make_pkt(nextseqnum, data, chksum) udt_send(sndpkt[nextseqnum]) if (base == nextseqnum) start_timer nextseqnum++ } else refuse_data(data) Wait udt_rcv(rcvpkt) && corrupt(rcvpkt) L timeout start_timer udt_send(sndpkt[base]) udt_send(sndpkt[base+1]) … udt_send(sndpkt[nextseqnum-1]) udt_rcv(rcvpkt) && notcorrupt(rcvpkt) base = getacknum(rcvpkt)+1 If (base == nextseqnum) stop_timer else start_timer Transport Layer 3 -14

GBN: receiver extended FSM default udt_send(sndpkt) L Wait expectedseqnum=1 sndpkt = make_pkt(expectedseqnum 1, ACK, chksum) udt_rcv(rcvpkt) && notcurrupt(rcvpkt) && hasseqnum(rcvpkt, expectedseqnum) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(expectedseqnum, ACK, chksum) udt_send(sndpkt) expectedseqnum++ ACK-only: always send ACK for correctly-received pkt with highest in-order seq # m m may generate duplicate ACKs need only remember expectedseqnum r out-of-order pkt: m discard (don’t buffer) -> no receiver buffering! m Re-ACK pkt with highest in-order seq # Transport Layer 3 -15

GBN in action Transport Layer 3 -16

Selective Repeat r Problem with Go-back-N: m Sender: resend many packets with a single lose m Receiver: discard many good received (out-of-order) packets m Very inefficient when N becomes bigger (high-speed) r receiver individually acknowledges all correctly received pkts m buffers pkts, as needed, for eventual in-order delivery to upper layer r sender only resends pkts for which ACK not received m sender keeps timer for each un. ACKed pkt r sender window m N consecutive seq #’s m again limits seq #s of sent, un. ACKed pkts Transport Layer 3 -17

Selective repeat: sender, receiver windows Transport Layer 3 -18

Selective repeat sender data from above : receiver pkt n in [rcvbase, rcvbase+N-1] r if next available seq # in r send ACK(n) timeout(n): r in-order: deliver (also window, send pkt r resend pkt n, restart timer for #n ACK(n) in [sendbase, sendbase+N]: r mark pkt n as received r if n smallest un. ACKed pkt, advance window base to next un. ACKed seq # r out-of-order: buffer deliver buffered, in-order pkts), advance window to next not-yet-received pkt n in [rcvbase-N, rcvbase-1] r ACK(n) Why? otherwise: r ignore Transport Layer 3 -19

Selective repeat in action Transport Layer 3 -20

Selective repeat: dilemma Example: r seq #’s: 0, 1, 2, 3 r window size=3 r Receiver sees no difference in two scenarios! r incorrectly passes duplicate data as new in (a) Q: what relationship between seq # size and window size? Transport Layer 3 -21