Reliable Data Transfer

1. Reliable Data Transfer Instructor: Carey Williamson Office: ICT 740 Email: carey@cpsc.ucalgary.ca Class Location: ICT 122 Lectures: MWF 12:00 – 12:50 Notes derived from “Computer Networking: A Top Down Approach”, by Jim Kurose and Keith Ross, Addison-Wesley. Slides are adapted from the book’s companion Web site, with changes by Anirban Mahanti and Carey Williamson. CPSC 441: Reliable Transport

2. important in application, transport, and link layers top-10 list of important networking topics! characteristics of unreliable channel will determine complexity of reliable data transfer protocol (rdt) Receiving Process Receiving Process Sending Process Sending Process RDT protocol (sending side) RDT protocol (receiving side) Reliable Channel Unreliable Channel Principles of Reliable Data Transfer Application Layer Transport Layer Network Layer CPSC 441: Reliable Transport

3. 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) to specify sender, receiver event state 1 state 2 actions Reliable Data Transfer: FSMs event causing state transition actions taken on state transition state: when in this “state” next state uniquely determined by next event CPSC 441: Reliable Transport

4. underlying channel perfectly reliable no bit errors no loss of packets separate FSMs for sender, receiver: sender sends data into underlying channel receiver read data from underlying channel Rdt1.0: Data Transfer over a Perfect Channel rdt_send(data) rdt_rcv(packet) Wait for call from below Wait for call from above extract (packet,data) deliver_data(data) packet = make_pkt(data) udt_send(packet) sender receiver CPSC 441: Reliable Transport

5. Assumptions All packets are received Packets may be corrupted (i.e., bits may be flipped) Checksum to detect bit errors How to recover from errors? Use ARQ mechanism acknowledgements (ACKs): receiver explicitly tells sender that packet received correctly negative acknowledgements (NAKs): receiver explicitly tells sender that packet had errors sender retransmits pkt on receipt of NAK What about error correcting codes? Rdt2.0: channel with bit errors[stop & wait protocol] CPSC 441: Reliable Transport

6. Wait for ACK or NAK rdt_rcv(rcvpkt) && corrupt(rcvpkt) udt_send(NAK) Wait for call from below rdt2.0: FSM specification rdt_send(data) receiver snkpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && isNAK(rcvpkt) Wait for call from above udt_send(sndpkt) rdt_rcv(rcvpkt) && isACK(rcvpkt) L sender rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) extract(rcvpkt,data) deliver_data(data) udt_send(ACK) CPSC 441: Reliable Transport

7. Wait for ACK or NAK rdt2.0: Observations 1. A stop-and-Wait protocol rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && isNAK(rcvpkt) 2. What happens when ACK or NAK has bit errors? Wait for call from above udt_send(sndpkt) Approach 1: resend the current data packet? rdt_rcv(rcvpkt) && isACK(rcvpkt) L sender Duplicate packets CPSC 441: Reliable Transport

8. Handling Duplicate Packets • sender adds sequence number to each packet • sender retransmits current packet if ACK/NAK garbled • receiver discards (doesn’t deliver up) duplicate packet CPSC 441: Reliable Transport

9. Wait for ACK or NAK 0 Wait for call 1 from above Wait for ACK or NAK 1 rdt2.1: sender, handles garbled ACK/NAKs rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || isNAK(rcvpkt) ) Wait for call 0 from above udt_send(sndpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt) L L rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || isNAK(rcvpkt) ) rdt_send(data) sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) udt_send(sndpkt) CPSC 441: Reliable Transport

10. Wait for 0 from below Wait for 1 from below rdt2.1: receiver, handles garbled ACK/NAKs 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) udt_send(sndpkt) sndpkt = make_pkt(NAK, chksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq1(rcvpkt) rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq0(rcvpkt) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) sndpkt = make_pkt(ACK, chksum) 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) CPSC 441: Reliable Transport

11. PKT(0) ACK PKT(1) x NAK x PKT(1) ACK PKT(0) sender receiver rtd2.1: examples PKT(0) ACK Receiver expects a pkt with seq. # 1 x PKT(0) Duplicate pkt. ACK PKT(1) sender receiver CPSC 441: Reliable Transport

12. Sender: seq # added to pkt two seq. #’s (0,1) will suffice. Why? must check if received ACK/NAK corrupted twice as many states state must “remember” whether “current” pkt has 0 or 1 seq. # Receiver: must check if received packet is duplicate state indicates whether 0 or 1 is expected pkt seq # note: receiver can not know if its last ACK/NAK received OK at sender rdt2.1: summary CPSC 441: Reliable Transport

13. 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 rdt2.2: a NAK-free protocol CPSC 441: Reliable Transport

14. Wait for ACK 0 Wait for call 0 from above Wait for 0 from below rdt2.2: sender, receiver fragments rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || isACK(rcvpkt,1) ) udt_send(sndpkt) sender FSM fragment rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt,0) rdt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq1(rcvpkt)) L receiver FSM fragment udt_send(sndpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq1(rcvpkt) extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(ACK1, chksum) udt_send(sndpkt) CPSC 441: Reliable Transport

15. rdt3.0:The case of “Lossy” Channels • Assumption: underlying channel can also lose packets (data or ACKs) • Approach: sender waits “reasonable” amount of time for ACK (a Time-Out) • Time-out value? • Possibility of duplicate packets/ACKs? • if pkt (or ACK) just delayed (not lost): • retransmission will be duplicate, but use of seq. #’s already handles this • receiver must specify seq # of pkt being ACKed CPSC 441: Reliable Transport

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

17. rdt3.0 in action CPSC 441: Reliable Transport

18. rdt3.0 in action CPSC 441: Reliable Transport

19. stop-and-wait operation sender receiver first packet bit transmitted, t = 0 last packet bit transmitted, t = L / R first packet bit arrives D last packet bit arrives, send ACK ACK arrives, send next packet, t = D + L / R CPSC 441: Reliable Transport

20. Stop-and-wait allows the sender to only have a single unACKed packet at any time example: 1 Mbps link (R), end-2-end round trip propagation delay (D) of 92ms, 1KB packet (L): L (packet length in bits) 8kb/pkt T = = = 8 ms transmit R (transmission rate, bps) 10**3 kb/sec Pipelining: Motivation • 1KB pkt every 100 ms -> 80Kbps throughput on a 1 Mbps link • What does bandwidth x delay product tell us? CPSC 441: Reliable Transport

21. 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 Pipelined protocols CPSC 441: Reliable Transport

22. Pipelining: increased utilization sender receiver first packet bit transmitted, t = 0 last bit transmitted, t = L / R first packet bit arrives D 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 = D + L / R Increase utilization by a factor of 3! CPSC 441: Reliable Transport

23. Go-Back-N • Allow up to N unACKed pkts in the network • N is the Window size • Sender Operation: • If window not full, transmit • ACKs are cumulative • On timeout, send all packets previously sent but not yet ACKed. • Uses a single timer – represents the oldest transmitted, but not yet ACKed pkt CPSC 441: Reliable Transport

24. Wait GBN: sender extended 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++ } else refuse_data(data) L base=1 nextseqnum=1 timeout start_timer udt_send(sndpkt[base]) udt_send(sndpkt[base+1]) … udt_send(sndpkt[nextseqnum-1]) rdt_rcv(rcvpkt) && corrupt(rcvpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) base = getacknum(rcvpkt)+1 If (base == nextseqnum) stop_timer else start_timer CPSC 441: Reliable Transport

25. 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 # GBN: receiver extended FSM default udt_send(sndpkt) rdt_rcv(rcvpkt) && notcurrupt(rcvpkt) && hasseqnum(rcvpkt,expectedseqnum) L Wait extract(rcvpkt,data) deliver_data(data) sndpkt = make_pkt(expectedseqnum,ACK,chksum) udt_send(sndpkt) expectedseqnum++ expectedseqnum=1 sndpkt = make_pkt(expectedseqnum,ACK,chksum) CPSC 441: Reliable Transport

26. GBN inaction CPSC 441: Reliable Transport

27. 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 ACK not received sender timer for each unACKed pkt sender window N consecutive seq #’s again limits seq #s of sent, unACKed pkts Selective Repeat CPSC 441: Reliable Transport

28. Selective repeat: sender, receiver windows CPSC 441: Reliable Transport

29. data from above : if next available seq # in window, send pkt timeout(n): resend pkt n, restart timer ACK(n) in [sendbase,sendbase+N]: mark pkt n as received if n smallest unACKed pkt, advance window base to next unACKed seq # receiver sender Selective repeat 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 CPSC 441: Reliable Transport

30. 0 1234 56789 0123 456789 01 2345 6789 0 1234 56789 0 1234 56789 01234 5678 9 01234 5678 9 Selective Repeat Example PKT0 PKT1 PKT2 PKT3 ACK1 ACK0 ACK2 ACK3 PKT4 Time-Out PKT1 ACK4 ACK1 Receiver Sender CPSC 441: Reliable Transport

31. Another Example CPSC 441: Reliable Transport

32. Example: seq #’s: 0, 1, 2, 3 window size=3 receiver sees no difference in two scenarios! incorrectly passes duplicate data as new in (a) Q: what relationship between seq # size and window size? Selective repeat: dilemma CPSC 441: Reliable Transport