Announcement Homework 1 graded Homework 2 out Due

Announcement • Homework 1 graded • Homework 2 out – Due in a week, 1/30 • Project 2 problems – Minet can only compile w/ old version of gcc (2. 96). – Only tlab-login has that version – Statically compile it and run on other Tlab machines to avoid overload

Review of Previous Lecture • Reliable transfer protocols – – rdt 2. 1: sender, handles garbled ACK/NAKs rdt 2. 2: a NAK-free protocol rdt 3. 0: channels with errors and loss Pipelined protocols • Go-back-N Some slides are in courtesy of J. Kurose and K. Ross

Outline • Reliable transfer protocols – Pipelined protocols • Selective repeat • Connection-oriented transport: TCP – – Overview and segment structure Reliable data transfer Flow control Connection management • TCP congestion control (if time allowed)

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 deceive duplicate ACKs (see receiver) • Single timer for all in-flight pkts • timeout(n): retransmit pkt n and all higher seq # pkts in window

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 ACK not received – sender timer for each un. ACKed pkt • sender window – N consecutive seq #’s – again limits seq #s of sent, un. ACKed pkts

Selective repeat: sender, receiver windows

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

Selective repeat in action

Selective repeat: dilemma • 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?

Outline • Reliable transfer protocols – Pipelined protocols • Selective repeat • Connection-oriented transport: TCP – – Overview and segment structure Reliable data transfer Flow control Connection management

TCP: Overview • point-to-point: – one sender, one receiver • reliable, in-order byte steam: – no “message boundaries” • pipelined: – TCP congestion and flow control set window size • send & receive buffers RFCs: 793, 1122, 1323, 2018, 2581 • full duplex data: – bi-directional data flow in same connection – MSS: maximum segment size • connection-oriented: – handshaking (exchange of control msgs) init’s sender, receiver state before data exchange • flow controlled: – sender will not overwhelm receiver

TCP segment structure 32 bits URG: urgent data (generally not used) ACK: ACK # valid PSH: push data now (generally not used) RST, SYN, FIN: connection estab (setup, teardown commands) Internet checksum (as in UDP) source port # dest port # sequence number acknowledgement number head not UA P R S F len used checksum Receive window Urg data pnter Options (variable length) application data (variable length) counting by bytes of data (not segments!) # bytes rcvr willing to accept

TCP seq. #’s and ACKs Seq. #’s: – byte stream “number” of first byte in segment’s data Host B Host A User types ‘C’ Seq=4 2, ACK = 79, da ta ACKs: – seq # of next byte expected from other side – cumulative ACK Q: how receiver handles out-of-order segments – A: TCP spec doesn’t say, - up to implementor ata = d , 3 4 K= C 79, A = q e S host ACKs receipt of echoed ‘C’ = ‘C’ host ACKs receipt of ‘C’, echoes back ‘C’ Seq=4 3, ACK =80 simple telnet scenario time

TCP Round Trip Time and Timeout Q: how to set TCP timeout value? • longer than RTT – but RTT varies • too short: premature timeout – unnecessary retransmissions • too long: slow reaction to segment loss Q: how to estimate RTT? • Sample. RTT: measured time from segment transmission until ACK receipt – ignore retransmissions • Sample. RTT will vary, want estimated RTT “smoother” – average several recent measurements, not just current Sample. RTT

TCP Round Trip Time and Timeout Estimated. RTT = (1 - )*Estimated. RTT + *Sample. RTT • Exponential weighted moving average • influence of past sample decreases exponentially fast • typical value: = 0. 125

Example RTT estimation:

TCP Round Trip Time and Timeout Setting the timeout • Estimted. RTT plus “safety margin” – large variation in Estimated. RTT -> larger safety margin • first estimate of how much Sample. RTT deviates from Estimated. RTT: Dev. RTT = (1 - )*Dev. RTT + *|Sample. RTT-Estimated. RTT| (typically, = 0. 25) Then set timeout interval: Timeout. Interval = Estimated. RTT + 4*Dev. RTT

Outline • Reliable transfer protocols – Pipelined protocols • Selective repeat • Connection-oriented transport: TCP – – Overview and segment structure Reliable data transfer Flow control Connection management

TCP reliable data transfer • TCP creates rdt • Retransmissions are service on top of IP’s triggered by: unreliable service – timeout events • Pipelined segments • Cumulative acks • TCP uses single retransmission timer – duplicate acks • Initially consider simplified TCP sender: – ignore duplicate acks – ignore flow control, congestion control

TCP sender events: data rcvd from app: timeout: • Create segment with seq # • retransmit segment that caused timeout • seq # is byte-stream • restart timer number of first data Ack rcvd: byte in segment • If acknowledges previously • start timer if not unacked segments already running (think – update what is known to be of timer as for oldest acked unacked segment) – start timer if there are • expiration interval: Time. Out. Interval outstanding segments • Difference from GBN?

Next. Seq. Num = Initial. Seq. Num Send. Base = Initial. Seq. Num loop (forever) { switch(event) event: data received from application above create TCP segment with sequence number Next. Seq. Num if (timer currently not running) start timer pass segment to IP Next. Seq. Num = Next. Seq. Num + length(data) event: timer timeout retransmit not-yet-acknowledged segment with smallest sequence number start timer event: ACK received, with ACK field value of y if (y > Send. Base) { Send. Base = y if (there are currently not-yet-acknowledged segments) start timer } } /* end of loop forever */ TCP sender (simplified) Comment: • Send. Base-1: last cumulatively ack’ed byte Example: • Send. Base-1 = 71; y= 73, so the rcvr wants 73+ ; y > Send. Base, so that new data is acked

TCP: retransmission scenarios Host A 2, 8 by tes da t Seq=92 timeout a =100 X ACK loss Seq=9 2, 8 by tes da ta 100 Sendbase = 100 Send. Base = 120 = ACK Send. Base = 100 time Host B Seq=9 Send. Base = 120 lost ACK scenario 2, 8 by Seq= 100, 2 tes da ta 0 byte s data 0 10 = K 120 = C K A AC Seq=92 timeout Seq=9 timeout Host A Host B time 2, 8 by tes da ta 20 K=1 AC premature timeout

TCP retransmission scenarios (more) Host A Host B Seq=9 timeout 2, 8 by Send. Base = 120 Seq=1 tes da ta =100 K C A 00, 20 bytes data X loss 120 = ACK time Cumulative ACK scenario

TCP ACK generation [RFC 1122, RFC 2581] Event at Receiver TCP Receiver action Arrival of in-order segment with expected seq #. All data up to expected seq # already ACKed Delayed ACK. Wait up to 500 ms for next segment. If no next segment, send ACK Arrival of in-order segment with expected seq #. One other segment has ACK pending Immediately send single cumulative ACK, ACKing both in-order segments Arrival of out-of-order segment higher-than-expect seq. #. Gap detected Immediately send duplicate ACK, indicating seq. # of next expected byte Arrival of segment that partially or completely fills gap Immediate send ACK, provided that segment startsat lower end of gap

Fast Retransmit • Time-out period often relatively long: • If sender receives 3 ACKs for the same data, it supposes that – long delay before resending lost packet segment after ACKed data was lost: • Detect lost segments via – fast retransmit: resend duplicate ACKs. – Sender often sends many segments back-to-back – If segment is lost, there will likely be many duplicate ACKs. segment before timer expires

Fast retransmit algorithm: event: ACK received, with ACK field value of y if (y > Send. Base) { Send. Base = y if (there are currently not-yet-acknowledged segments) start timer } else { increment count of dup ACKs received for y if (count of dup ACKs received for y = 3) { resend segment with sequence number y } a duplicate ACK for already ACKed segment fast retransmit