Chapter 3 Transport Layer

Transcription

1 Chapter 3 Transport Layer Computer Networking: A Top Down Approach 6 th edition Jim Kurose, Keith Ross Addison-Wesley March 2012 All material copyright J.F Kurose and K.W. Ross, All Rights Resered Transport Layer 3-1

2 Chapter 3: Transport Layer our goals: understand principles behind transport layer serices: multiplexing, demultiplexing reliable data transfer flow control congestion control learn about Internet transport layer protocols: UDP: connectionless transport TCP: connection-oriented reliable transport TCP congestion control Transport Layer 3-2

3 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-3

4 Transport serices and protocols proide logical communication between app processes running on different hosts transport protocols run in end systems send side: breaks app messages into segments, passes to network layer rc side: reassembles segments into messages, passes to app layer more than one transport protocol aailable to apps Internet: TCP and UDP application transport network data link physical application transport network data link physical Transport Layer 3-4

5 Transport s. network layer network layer: logical communication between hosts transport layer: logical communication between processes relies on, enhances, network layer serices 12 kids in Ann s house sending letters to 12 kids in Bill s house: hosts = houses processes = kids app messages = letters in household analogy: enelopes transport protocol = Ann and Bill who demux to inhouse siblings network-layer protocol = postal serice Transport Layer 3-5

6 Internet transport-layer protocols reliable, in-order deliery (TCP) congestion control flow control connection setup unreliable, unordered deliery: UDP no-frills extension of best-effort IP serices not aailable: delay guarantees bandwidth guarantees application transport network data link physical network data link physical network data link physical network data link physical network data link physical network data link physical network data link physical network data link physical application transport network data link physical Transport Layer 3-6

7 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-7

8 Multiplexing/demultiplexing multiplexing at sender: handle data from multiple sockets, add transport header (later used for demultiplexing) demultiplexing at receier: use header info to delier receied segments to correct socket application application P3 transport network link P1 P2 transport network link physical application P4 transport network link socket process physical physical Transport Layer 3-8

9 How demultiplexing works host receies IP datagrams each datagram has source IP address, destination IP address each datagram carries one transport-layer segment each segment has source, destination port number host uses IP addresses & port numbers to direct segment to appropriate socket 32 bits source port # dest port # other header fields application data (payload) TCP/UDP segment format Transport Layer 3-9

10 Connectionless demultiplexing recall: created socket has host-local port #: DatagramSocket mysocket1 = new DatagramSocket(12534); recall: when creating datagram to send into UDP socket, must specify destination IP address destination port # when host receies UDP segment: checks destination port # in segment directs UDP segment to socket with that port # IP datagrams with same dest. port #, but different source IP addresses and/or source port numbers will be directed to same socket at dest Transport Layer 3-10

11 Connectionless demux: example DatagramSocket mysocket2 = new DatagramSocket (9157); application P3 transport network link physical DatagramSocket serersocket = new DatagramSocket (6428); application P1 transport network link physical DatagramSocket mysocket1 = new DatagramSocket (5775); application P4 transport network link physical source port: 6428 dest port: 9157 source port:? dest port:? source port: 9157 dest port: 6428 source port:? dest port:? Transport Layer 3-11

12 Connection-oriented demux TCP socket identified by 4-tuple: source IP address source port number dest IP address dest port number demux: receier uses all four alues to direct segment to appropriate socket serer host may support many simultaneous TCP sockets: each socket identified by its own 4-tuple web serers hae different sockets for each connecting client non-persistent HTTP will hae different socket for each request Transport Layer 3-12

13 Connection-oriented demux: example application application P3 transport network link physical P4 P5 transport network link physical P6 serer: IP address B application P2 P3 transport network link physical host: IP address A source IP,port: B,80 dest IP,port: A,9157 source IP,port: C,5775 dest IP,port: B,80 host: IP address C source IP,port: A,9157 dest IP, port: B,80 three segments, all destined to IP address: B, dest port: 80 are demultiplexed to different sockets source IP,port: C,9157 dest IP,port: B,80 Transport Layer 3-13

14 Connection-oriented demux: example threaded serer application application P3 transport network link physical P4 transport network link physical serer: IP address B application P2 P3 transport network link physical host: IP address A source IP,port: B,80 dest IP,port: A,9157 source IP,port: C,5775 dest IP,port: B,80 host: IP address C source IP,port: A,9157 dest IP, port: B,80 source IP,port: C,9157 dest IP,port: B,80 Transport Layer 3-14

15 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-15

16 UDP: User Datagram Protocol [RFC 768] no frills, bare bones Internet transport protocol best effort serice, UDP segments may be: lost deliered out-of-order to app connectionless: no handshaking between UDP sender, receier each UDP segment handled independently of others UDP use: streaming multimedia apps (loss tolerant, rate sensitie) DNS SNMP reliable transfer oer UDP: add reliability at application layer application-specific error recoery! Transport Layer 3-16

17 UDP: segment header 32 bits source port # dest port # length application data (payload) checksum UDP segment format length, in bytes of UDP segment, including header why is there a UDP? no connection establishment (which can add delay) simple: no connection state at sender, receier small header size no congestion control: UDP can blast away as fast as desired Transport Layer 3-17

18 UDP checksum Goal: detect errors (e.g., flipped bits) in transmitted segment sender: treat segment contents, including header fields, as sequence of 16-bit integers checksum: addition (one s complement sum) of segment contents sender puts checksum alue into UDP checksum field receier: compute checksum of receied segment check if computed checksum equals checksum field alue: NO - error detected YES - no error detected. But maybe errors nonetheless? More later. Transport Layer 3-18

19 Internet checksum: example example: add two 16-bit integers wraparound sum checksum Note: when adding numbers, a carryout from the most significant bit needs to be added to the result Transport Layer 3-19

20 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-20

21 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-21

22 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-22

23 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-23

24 Reliable data transfer: getting started rdt_send(): called from aboe, (e.g., by app.). Passed data to delier to receier upper layer delier_data(): called by rdt to delier data to upper send side receie side udt_send(): called by rdt, to transfer packet oer unreliable channel to receier rdt_rc(): called when packet arries on rc-side of channel Transport Layer 3-24

25 Reliable data transfer: getting started we ll: incrementally deelop sender, receier 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, receier state: when in this state next state uniquely determined by next eent state 1 eent causing state transition actions taken on state transition eent actions state 2 Transport Layer 3-25

26 rdt1.0: reliable transfer oer a reliable channel underlying channel perfectly reliable no bit errors no loss of packets separate FSMs for sender, receier: sender sends data into underlying channel receier reads data from underlying channel Wait for call from aboe rdt_send(data) packet = make_pkt(data) udt_send(packet) Wait for call from below rdt_rc(packet) extract (packet,data) delier_data(data) sender receier Transport Layer 3-26

27 rdt2.0: channel with bit errors underlying channel may flip bits in packet checksum to detect bit errors the question: how to recoer from errors: acknowledgements (ACKs): receier explicitly tells sender that pkt receied OK negatie acknowledgements (NAKs): receier explicitly tells sender that pkt had errors How do humans recoer from errors during conersation? sender retransmits pkt on receipt of NAK new mechanisms in rdt2.0 (beyond rdt1.0): error detection receier feedback: control msgs (ACK,NAK) rcr- >sender Transport Layer 3-27

28 rdt2.0: channel with bit errors underlying channel may flip bits in packet checksum to detect bit errors the question: how to recoer from errors: acknowledgements (ACKs): receier explicitly tells sender that pkt receied OK negatie acknowledgements (NAKs): receier explicitly tells sender that pkt had errors sender retransmits pkt on receipt of NAK new mechanisms in rdt2.0 (beyond rdt1.0): error detection feedback: control msgs (ACK,NAK) from receier to sender Transport Layer 3-28

29 rdt2.0: FSM specification rdt_send(data) sndpkt = make_pkt(data, checksum) udt_send(sndpkt) Wait for call from aboe rdt_rc(rcpkt) && isack(rcpkt) L sender Wait for ACK or NAK rdt_rc(rcpkt) && isnak(rcpkt) udt_send(sndpkt) receier rdt_rc(rcpkt) && corrupt(rcpkt) udt_send(nak) Wait for call from below rdt_rc(rcpkt) && notcorrupt(rcpkt) extract(rcpkt,data) delier_data(data) udt_send(ack) Transport Layer 3-29

30 rdt2.0: operation with no errors rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) Wait for call from aboe rdt_rc(rcpkt) && isack(rcpkt) L Wait for ACK or NAK rdt_rc(rcpkt) && isnak(rcpkt) udt_send(sndpkt) rdt_rc(rcpkt) && corrupt(rcpkt) udt_send(nak) Wait for call from below rdt_rc(rcpkt) && notcorrupt(rcpkt) extract(rcpkt,data) delier_data(data) udt_send(ack) Transport Layer 3-30

31 rdt2.0: error scenario rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) Wait for call from aboe rdt_rc(rcpkt) && isack(rcpkt) L Wait for ACK or NAK rdt_rc(rcpkt) && isnak(rcpkt) udt_send(sndpkt) rdt_rc(rcpkt) && corrupt(rcpkt) udt_send(nak) Wait for call from below rdt_rc(rcpkt) && notcorrupt(rcpkt) extract(rcpkt,data) delier_data(data) udt_send(ack) Transport Layer 3-31

32 rdt2.0 has a fatal flaw! what happens if ACK/NAK corrupted? sender doesn t know what happened at receier! can t just retransmit: possible duplicate handling duplicates: stop and wait sender sends one packet, then waits for receier response sender retransmits current pkt if ACK/NAK corrupted sender adds sequence number to each pkt receier discards (doesn t delier up) duplicate pkt Transport Layer 3-32

33 rdt2.1: sender, handles garbled ACK/NAKs rdt_rc(rcpkt) && notcorrupt(rcpkt) && isack(rcpkt) L rdt_rc(rcpkt) && ( corrupt(rcpkt) isnak(rcpkt) ) udt_send(sndpkt) rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) Wait for call 0 from aboe Wait for ACK or NAK 1 rdt_send(data) Wait for ACK or NAK 0 Wait for call 1 from aboe rdt_rc(rcpkt) && ( corrupt(rcpkt) isnak(rcpkt) ) udt_send(sndpkt) rdt_rc(rcpkt) && notcorrupt(rcpkt) && isack(rcpkt) sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) L Transport Layer 3-33

34 rdt2.1: receier, handles garbled ACK/NAKs rdt_rc(rcpkt) && (corrupt(rcpkt) sndpkt = make_pkt(nak, chksum) udt_send(sndpkt) rdt_rc(rcpkt) && not corrupt(rcpkt) && has_seq1(rcpkt) sndpkt = make_pkt(ack, chksum) udt_send(sndpkt) rdt_rc(rcpkt) && notcorrupt(rcpkt) && has_seq0(rcpkt) extract(rcpkt,data) delier_data(data) sndpkt = make_pkt(ack, chksum) udt_send(sndpkt) Wait for 0 from below Wait for 1 from below rdt_rc(rcpkt) && notcorrupt(rcpkt) && has_seq1(rcpkt) rdt_rc(rcpkt) && (corrupt(rcpkt) sndpkt = make_pkt(nak, chksum) udt_send(sndpkt) rdt_rc(rcpkt) && not corrupt(rcpkt) && has_seq0(rcpkt) sndpkt = make_pkt(ack, chksum) udt_send(sndpkt) extract(rcpkt,data) delier_data(data) sndpkt = make_pkt(ack, chksum) udt_send(sndpkt) Transport Layer 3-34

35 rdt2.1: discussion sender: seq # added to pkt two seq. # s (0,1) will suffice. Why? must check if receied ACK/NAK corrupted twice as many states state must remember whether expected pkt should hae seq # of 0 or 1 receier: must check if receied packet is duplicate state indicates whether 0 or 1 is expected pkt seq # note: receier can not know if its last ACK/NAK receied OK at sender Transport Layer 3-35

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

37 rdt2.2: sender, receier fragments rdt_rc(rcpkt) && (corrupt(rcpkt) has_seq1(rcpkt)) udt_send(sndpkt) rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) Wait for call 0 from aboe Wait for 0 from below sender FSM fragment receier FSM fragment Wait for ACK 0 rdt_rc(rcpkt) && ( corrupt(rcpkt) isack(rcpkt,1) ) udt_send(sndpkt) rdt_rc(rcpkt) && notcorrupt(rcpkt) && isack(rcpkt,0) L rdt_rc(rcpkt) && notcorrupt(rcpkt) && has_seq1(rcpkt) extract(rcpkt,data) delier_data(data) sndpkt = make_pkt(ack1, chksum) udt_send(sndpkt) Transport Layer 3-37

38 rdt3.0: channels with errors and loss new assumption: underlying channel can also lose packets (data, ACKs) checksum, seq. #, ACKs, retransmissions will be of help but not enough approach: sender waits reasonable amount of time for ACK retransmits if no ACK receied in this time if pkt (or ACK) just delayed (not lost): retransmission will be duplicate, but seq. # s already handles this receier must specify seq # of pkt being ACKed requires countdown timer Transport Layer 3-38

39 rdt3.0 sender rdt_rc(rcpkt) L Wait for call 0from aboe rdt_rc(rcpkt) && notcorrupt(rcpkt) && isack(rcpkt,1) stop_timer timeout udt_send(sndpkt) start_timer rdt_rc(rcpkt) && ( corrupt(rcpkt) isack(rcpkt,0) ) L Wait for ACK1 rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) start_timer rdt_send(data) Wait for ACK0 Wait for call 1 from aboe sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) start_timer rdt_rc(rcpkt) && ( corrupt(rcpkt) isack(rcpkt,1) ) L timeout udt_send(sndpkt) start_timer rdt_rc(rcpkt) && notcorrupt(rcpkt) && isack(rcpkt,0) stop_timer rdt_rc(rcpkt) L Transport Layer 3-39

40 rdt3.0 in action sender receier sender receier send pkt0 rc ack0 send pkt1 rc ack1 send pkt0 pkt0 ack0 pkt1 ack1 pkt0 ack0 (a) no loss rc pkt0 send ack0 rc pkt1 send ack1 rc pkt0 send ack0 send pkt0 rc ack0 send pkt1 timeout resend pkt1 rc ack1 send pkt0 pkt0 ack0 pkt1 X loss pkt1 ack1 pkt0 ack0 rc pkt0 send ack0 rc pkt1 send ack1 rc pkt0 send ack0 (b) packet loss Transport Layer 3-40

41 rdt3.0 in action sender send pkt0 rc ack0 send pkt1 timeout resend pkt1 rc ack1 send pkt0 pkt0 ack0 pkt1 ack1 X loss pkt1 ack1 pkt0 ack0 receier rc pkt0 send ack0 rc pkt1 send ack1 rc pkt1 (detect duplicate) send ack1 rc pkt0 send ack0 sender send pkt0 rc ack0 send pkt1 timeout resend pkt1 rc ack1 send pkt0 rc ack1 send pkt0 pkt0 ack0 pkt1 ack1 pkt1 pkt0 ack1 ack0 pkt0 ack0 receier rc pkt0 send ack0 rc pkt1 send ack1 rc pkt1 (detect duplicate) send ack1 rc pkt0 send ack0 rc pkt0 (detect duplicate) send ack0 (c) ACK loss (d) premature timeout/ delayed ACK Transport Layer 3-41

42 Performance of rdt3.0 rdt3.0 is correct, but performance stinks e.g.: 1 Gbps link, 15 ms prop. delay, 8000 bit packet: D trans = L R 8000 bits = 10 9 = 8 microsecs bits/sec U sender : utilization fraction of time sender busy sending U sender = L / R RTT + L / R = = if RTT=30 msec, 1KB pkt eery 30 msec: 33kB/sec thruput oer 1 Gbps link network protocol limits use of physical resources! Transport Layer 3-42

43 rdt3.0: stop-and-wait operation first packet bit transmitted, t = 0 last packet bit transmitted, t = L / R sender receier RTT first packet bit arries last packet bit arries, send ACK ACK arries, send next packet, t = RTT + L / R U sender = L / R RTT + L / R = = Transport Layer 3-43

44 Pipelined protocols pipelining: sender allows multiple, in-flight, yetto-be-acknowledged pkts range of sequence numbers must be increased buffering at sender and/or receier two generic forms of pipelined protocols: go-back-n, selectie repeat Transport Layer 3-44

45 Pipelining: increased utilization first packet bit transmitted, t = 0 last bit transmitted, t = L / R sender receier RTT ACK arries, send next packet, t = RTT + L / R first packet bit arries last packet bit arries, send ACK last bit of 2 nd packet arries, send ACK last bit of 3 rd packet arries, send ACK 3-packet pipelining increases utilization by a factor of 3! U sender = 3L / R RTT + L / R = = Transport Layer 3-45

46 Pipelined protocols: oeriew Go-back-N: sender can hae up to N unacked packets in pipeline receier only sends cumulatie ack doesn t ack packet if there s a gap sender has timer for oldest unacked packet when timer expires, retransmit all unacked packets Selectie Repeat: sender can hae up to N unack ed packets in pipeline rcr sends indiidual ack for each packet sender maintains timer for each unacked packet when timer expires, retransmit only that unacked packet Transport Layer 3-46

47 Go-Back-N: sender k-bit seq # in pkt header window of up to N, consecutie unack ed pkts allowed ACK(n): ACKs all pkts up to, including seq # n - cumulatie ACK may receie duplicate ACKs (see receier) timer for oldest in-flight pkt timeout(n): retransmit packet n and all higher seq # pkts in window Transport Layer 3-47

48 GBN: sender extended FSM rdt_send(data) L base=1 nextseqnum=1 rdt_rc(rcpkt) && corrupt(rcpkt) 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 timeout start_timer udt_send(sndpkt[base]) udt_send(sndpkt[base+1]) udt_send(sndpkt[nextseqnum-1]) rdt_rc(rcpkt) && notcorrupt(rcpkt) base = getacknum(rcpkt)+1 If (base == nextseqnum) stop_timer else start_timer Transport Layer 3-48

49 GBN: receier extended FSM default udt_send(sndpkt) L expectedseqnum=1 Wait sndpkt = make_pkt(expectedseqnum,ack,chksum) rdt_rc(rcpkt) && notcurrupt(rcpkt) && hasseqnum(rcpkt,expectedseqnum) extract(rcpkt,data) delier_data(data) sndpkt = make_pkt(expectedseqnum,ack,chksum) udt_send(sndpkt) expectedseqnum++ ACK-only: always send ACK for correctly-receied pkt with highest in-order seq # may generate duplicate ACKs need only remember expectedseqnum out-of-order pkt: discard (don t buffer): no receier buffering! re-ack pkt with highest in-order seq # Transport Layer 3-49

50 GBN in action sender window (N=4) sender send pkt0 send pkt1 send pkt2 send pkt3 (wait) rc ack0, send pkt4 rc ack1, send pkt5 ignore duplicate ACK pkt 2 timeout send pkt2 send pkt3 send pkt4 send pkt5 Xloss receier receie pkt0, send ack0 receie pkt1, send ack1 receie pkt3, discard, (re)send ack1 receie pkt4, discard, (re)send ack1 receie pkt5, discard, (re)send ack1 rc pkt2, delier, send ack2 rc pkt3, delier, send ack3 rc pkt4, delier, send ack4 rc pkt5, delier, send ack5 Transport Layer 3-50

51 Selectie repeat receier indiidually acknowledges all correctly receied pkts buffers pkts, as needed, for eentual in-order deliery to upper layer sender only resends pkts for which ACK not receied sender timer for each unacked pkt sender window N consecutie seq # s limits seq #s of sent, unacked pkts Transport Layer 3-51

52 Selectie repeat: sender, receier windows Transport Layer 3-52

53 Selectie repeat sender data from aboe: if next aailable seq # in window, send pkt timeout(n): resend pkt n, restart timer ACK(n) in [sendbase,sendbase+n]: mark pkt n as receied if n smallest unacked pkt, adance window base to next unacked seq # receier pkt n in [rcbase, rcbase+n-1] send ACK(n) out-of-order: buffer in-order: delier (also delier buffered, in-order pkts), adance window to next not-yet-receied pkt pkt n in [rcbase-n,rcbase-1] ACK(n) otherwise: ignore Transport Layer 3-53

54 Selectie repeat in action sender window (N=4) sender send pkt0 send pkt1 send pkt2 send pkt3 (wait) rc ack0, send pkt4 rc ack1, send pkt5 record ack3 arried pkt 2 timeout send pkt2 record ack4 arried record ack4 arried Xloss receier receie pkt0, send ack0 receie pkt1, send ack1 receie pkt3, buffer, send ack3 receie pkt4, buffer, send ack4 receie pkt5, buffer, send ack5 rc pkt2; delier pkt2, pkt3, pkt4, pkt5; send ack2 Q: what happens when ack2 arries? Transport Layer 3-54

55 Selectie repeat: dilemma example: seq # s: 0, 1, 2, 3 window size=3 receier sees no difference in two scenarios! duplicate data accepted as new in (b) Q: what relationship between seq # size and window size to aoid problem in (b)? sender window (after receipt) pkt0 pkt pkt2 X X timeout retransmit pkt0 X pkt0 (b) oops! pkt0 pkt1 pkt pkt3 (a) no problem pkt0 X receier window (after receipt) will accept packet with seq number 0 receier can t see sender side. receier behaior identical in both cases! something s (ery) wrong! will accept packet with seq number 0 Transport Layer 3-55

56 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-56

57 TCP: Oeriew RFCs: 793,1122,1323, 2018, 2581 point-to-point: one sender, one receier reliable, in-order byte steam: no message boundaries pipelined: TCP congestion and flow control set window size full duplex data: bi-directional data flow in same connection MSS: maximum segment size connection-oriented: handshaking (exchange of control msgs) inits sender, receier state before data exchange flow controlled: sender will not oerwhelm receier Transport Layer 3-57

58 TCP segment structure URG: urgent data (generally not used) ACK: ACK # alid PSH: push data now (generally not used) RST, SYN, FIN: connection estab (setup, teardown commands) Internet checksum (as in UDP) 32 bits source port # dest port # head len sequence number acknowledgement number not used UAP R S F checksum receie window application data (ariable length) Urg data pointer options (ariable length) counting by bytes of data (not segments!) # bytes rcr willing to accept Transport Layer 3-58

59 TCP seq. numbers, ACKs sequence numbers: byte stream number of first byte in segment s data acknowledgements: seq # of next byte expected from other side cumulatie ACK Q: how receier handles out-of-order segments A: TCP spec doesn t say, outgoing segment from sender source port # dest port # sequence number acknowledgement number rwnd checksum sent ACKed urg pointer window size N sender sequence number space sent, notyet usable not ACKed but not usable ( inflight ) yet sent incoming segment to sender - up to implementor source port # dest port # sequence number acknowledgement number A rwnd checksum urg pointer Transport Layer 3-59

60 TCP seq. numbers, ACKs Host A Host B User types C host ACKs receipt of echoed C Seq=42, ACK=79, data = C Seq=79, ACK=43, data = C Seq=43, ACK=80 host ACKs receipt of C, echoes back C simple telnet scenario Transport Layer 3-60

61 TCP round trip time, timeout Q: how to set TCP timeout alue? longer than RTT but RTT aries too short: premature timeout, unnecessary retransmissions too long: slow reaction to segment loss Q: how to estimate RTT? SampleRTT: measured time from segment transmission until ACK receipt ignore retransmissions SampleRTT will ary, want estimated RTT smoother aerage seeral recent measurements, not just current SampleRTT Transport Layer 3-61

62 TCP round trip time, timeout EstimatedRTT = (1- a)*estimatedrtt + a*samplertt exponential weighted moing aerage influence of past sample decreases exponentially fast typical alue: a = RTT: gaia.cs.umass.edu to fantasia.eurecom.fr 350 RTT: gaia.cs.umass.edu to fantasia.eurecom.fr RTT (milliseconds) RTT (milliseconds) samplertt EstimatedRTT time (seconnds) time (seconds) SampleRTT Estimated RTT Transport Layer 3-62

63 TCP round trip time, timeout timeout interal: EstimatedRTT plus safety margin large ariation in EstimatedRTT -> larger safety margin estimate SampleRTT deiation from EstimatedRTT: DeRTT = (1-b)*DeRTT + b* SampleRTT-EstimatedRTT (typically, b = 0.25) TimeoutInteral = EstimatedRTT + 4*DeRTT estimated RTT safety margin Transport Layer 3-63

64 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-64

65 TCP reliable data transfer TCP creates rdt serice on top of IP s unreliable serice pipelined segments cumulatie acks single retransmission timer retransmissions triggered by: timeout eents duplicate acks let s initially consider simplified TCP sender: ignore duplicate acks ignore flow control, congestion control Transport Layer 3-65

66 TCP sender eents: data rcd from app: create segment with seq # seq # is byte-stream number of first data byte in segment start timer if not already running think of timer as for oldest unacked segment expiration interal: TimeOutInteral timeout: retransmit segment that caused timeout restart timer ack rcd: if ack acknowledges preiously unacked segments update what is known to be ACKed start timer if there are still unacked segments Transport Layer 3-66

67 TCP sender (simplified) L NextSeqNum = InitialSeqNum SendBase = InitialSeqNum wait for eent ACK receied, with ACK field alue y data receied from application aboe create segment, seq. #: NextSeqNum pass segment to IP (i.e., send ) NextSeqNum = NextSeqNum + length(data) if (timer currently not running) start timer timeout retransmit not-yet-acked segment with smallest seq. # start timer if (y > SendBase) { SendBase = y /* SendBase 1: last cumulatiely ACKed byte */ if (there are currently not-yet-acked segments) start timer else stop timer } Transport Layer 3-67

68 TCP: retransmission scenarios Host A Host B Host A Host B Seq=92, 8 bytes of data SendBase=92 Seq=92, 8 bytes of data timeout X ACK=100 timeout Seq=100, 20 bytes of data ACK=100 ACK=120 Seq=92, 8 bytes of data ACK=100 lost ACK scenario SendBase=100 SendBase=120 SendBase=120 Seq=92, 8 bytes of data ACK=120 premature timeout Transport Layer 3-68

69 TCP: retransmission scenarios Host A Host B Seq=92, 8 bytes of data Seq=100, 20 bytes of data timeout X ACK=100 ACK=120 Seq=120, 15 bytes of data cumulatie ACK Transport Layer 3-69

70 TCP ACK generation [RFC 1122, RFC 2581] eent at receier arrial of in-order segment with expected seq #. All data up to expected seq # already ACKed arrial of in-order segment with expected seq #. One other segment has ACK pending arrial of out-of-order segment higher-than-expect seq. #. Gap detected arrial of segment that partially or completely fills gap TCP receier action delayed ACK. Wait up to 500ms for next segment. If no next segment, send ACK immediately send single cumulatie ACK, ACKing both in-order segments immediately send duplicate ACK, indicating seq. # of next expected byte immediate send ACK, proided that segment starts at lower end of gap Transport Layer 3-70

71 TCP fast retransmit time-out period often relatiely long: long delay before resending lost packet detect lost segments ia duplicate ACKs. sender often sends many segments backto-back if segment is lost, there will likely be many duplicate ACKs. TCP fast retransmit if sender receies 3 ACKs for same data ( triple duplicate ACKs ), resend unacked segment with smallest seq # likely that unacked segment lost, so don t wait for timeout Transport Layer 3-71

72 TCP fast retransmit Host A Host B Seq=92, 8 bytes of data Seq=100, 20 bytes of data X timeout ACK=100 ACK=100 ACK=100 ACK=100 Seq=100, 20 bytes of data fast retransmit after sender receipt of triple duplicate ACK Transport Layer 3-72

73 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-73

74 TCP flow control application may remoe data from TCP socket buffers. slower than TCP receier is deliering (sender is sending) application process TCP socket receier buffers TCP code application OS flow control receier controls sender, so sender won t oerflow receier s buffer by transmitting too much, too fast from sender IP code receier protocol stack Transport Layer 3-74

75 TCP flow control receier adertises free buffer space by including rwnd alue in TCP header of receier-to-sender segments RcBuffer size set ia socket options (typical default is 4096 bytes) many operating systems autoadjust RcBuffer sender limits amount of unacked ( in-flight ) data to receier s rwnd alue guarantees receie buffer will not oerflow RcBuffer rwnd to application process buffered data free buffer space TCP segment payloads receier-side buffering Transport Layer 3-75

76 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-76

77 Connection Management before exchanging data, sender/receier handshake : agree to establish connection (each knowing the other willing to establish connection) agree on connection parameters application connection state: ESTAB connection ariables: seq # client-to-serer serer-to-client rcbuffer size at serer,client network application connection state: ESTAB connection Variables: seq # client-to-serer serer-to-client rcbuffer size at serer,client network Socket clientsocket = newsocket("hostname","port number"); Socket connectionsocket = welcomesocket.accept(); Transport Layer 3-77

78 Agreeing to establish a connection 2-way handshake: Let s talk ESTAB OK choose x req_conn(x) ESTAB acc_conn(x) ESTAB ESTAB Q: will 2-way handshake always work in network? ariable delays retransmitted messages (e.g. req_conn(x)) due to message loss message reordering can t see other side Transport Layer 3-78

79 Agreeing to establish a connection 2-way handshake failure scenarios: choose x retransmit req_conn(x) req_conn(x) acc_conn(x) ESTAB choose x retransmit req_conn(x) req_conn(x) acc_conn(x) ESTAB ESTAB client terminates req_conn(x) connection x completes serer forgets x ESTAB retransmit data(x+1) client terminates data(x+1) connection x completes req_conn(x) accept data(x+1) serer forgets x half open connection! (no client!) ESTAB data(x+1) ESTAB accept data(x+1) Transport Layer 3-79

80 TCP 3-way handshake client state LISTEN SYNSENT ESTAB choose init seq num, x send TCP SYN msg receied SYNACK(x) indicates serer is lie; send ACK for SYNACK; this segment may contain client-to-serer data SYNbit=1, Seq=x SYNbit=1, Seq=y ACKbit=1; ACKnum=x+1 ACKbit=1, ACKnum=y+1 choose init seq num, y send TCP SYNACK msg, acking SYN receied ACK(y) indicates client is lie serer state LISTEN SYN RCVD ESTAB Transport Layer 3-80

81 TCP 3-way handshake: FSM closed Socket connectionsocket = welcomesocket.accept(); SYN(x) SYNACK(seq=y,ACKnum=x+1) create new socket for communication back to client L listen Socket clientsocket = newsocket("hostname","port number"); SYN(seq=x) SYN rcd SYN sent ACK(ACKnum=y+1) L ESTAB SYNACK(seq=y,ACKnum=x+1) ACK(ACKnum=y+1) Transport Layer 3-81

82 TCP: closing a connection client, serer each close their side of connection send TCP segment with FIN bit = 1 respond to receied FIN with ACK on receiing FIN, ACK can be combined with own FIN simultaneous FIN exchanges can be handled Transport Layer 3-82

83 TCP: closing a connection client state serer state ESTAB ESTAB clientsocket.close() FIN_WAIT_1 FIN_WAIT_2 can no longer send but can receie data wait for serer close FINbit=1, seq=x ACKbit=1; ACKnum=x+1 can still send data CLOSE_WAIT TIMED_WAIT timed wait for 2*max segment lifetime FINbit=1, seq=y ACKbit=1; ACKnum=y+1 can no longer send data LAST_ACK CLOSED CLOSED Transport Layer 3-83

84 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-84

85 Principles of congestion control congestion: informally: too many sources sending too much data too fast for network to handle different from flow control! manifestations: lost packets (buffer oerflow at routers) long delays (queueing in router buffers) a top-10 problem! Transport Layer 3-85

86 Causes/costs of congestion: scenario 1 two senders, two receiers one router, infinite buffers output link capacity: R no retransmission original data: l in Host A unlimited shared output link buffers throughput: l out Host B R/2 l out delay l in R/2 l in R/2 maximum per-connection throughput: R/2 large delays as arrial rate, l in, approaches capacity Transport Layer 3-86

87 Causes/costs of congestion: scenario 2 one router, finite buffers sender retransmission of timed-out packet application-layer input = application-layer output: l in = l out transport-layer input includes retransmissions : l in l in l in : original data l'in : original data, plus retransmitted data l out Host A Host B finite shared output link buffers Transport Layer 3-87

88 Causes/costs of congestion: scenario 2 idealization: perfect knowledge sender sends only when router buffers aailable R/2 l out l in R/2 copy l in : original data l'in : original data, plus retransmitted data l out A free buffer space! Host B finite shared output link buffers Transport Layer 3-88

89 Causes/costs of congestion: scenario 2 Idealization: known loss packets can be lost, dropped at router due to full buffers sender only resends if packet known to be lost copy l in : original data l'in : original data, plus retransmitted data l out A no buffer space! Host B Transport Layer 3-89

90 Causes/costs of congestion: scenario 2 Idealization: known loss packets can be lost, dropped at router due to full buffers sender only resends if packet known to be lost R/2 l out l in R/2 when sending at R/2, some packets are retransmissions but asymptotic goodput is still R/2 (why?) l in : original data l'in : original data, plus retransmitted data l out A free buffer space! Host B Transport Layer 3-90

91 Causes/costs of congestion: scenario 2 Realistic: duplicates packets can be lost, dropped at router due to full buffers sender times out prematurely, sending two copies, both of which are deliered R/2 l out l in R/2 when sending at R/2, some packets are retransmissions including duplicated that are deliered! copy timeout l in l' in l out A free buffer space! Host B Transport Layer 3-91

92 Causes/costs of congestion: scenario 2 Realistic: duplicates packets can be lost, dropped at router due to full buffers sender times out prematurely, sending two copies, both of which are deliered l out R/2 l in R/2 when sending at R/2, some packets are retransmissions including duplicated that are deliered! costs of congestion: more work (retrans) for gien goodput unneeded retransmissions: link carries multiple copies of pkt decreasing goodput Transport Layer 3-92

93 Causes/costs of congestion: scenario 3 four senders multihop paths timeout/retransmit Host A Q: what happens as l in and l in increase? A: as red l in increases, all arriing blue pkts at upper queue are dropped, blue throughput g 0 l in : original data l' in : original data, plus retransmitted data finite shared output link buffers l out Host B Host D Host C Transport Layer 3-93

94 Causes/costs of congestion: scenario 3 C/2 l out l in C/2 another cost of congestion: when packet dropped, any upstream transmission capacity used for that packet was wasted! Transport Layer 3-94

95 Approaches towards congestion control two broad approaches towards congestion control: end-end congestion control: no explicit feedback from network congestion inferred from end-system obsered loss, delay approach taken by TCP network-assisted congestion control: routers proide feedback to end systems single bit indicating congestion (SNA, DECbit, TCP/IP ECN, ATM) explicit rate for sender to send at Transport Layer 3-95

96 Case study: ATM ABR congestion control ABR: aailable bit rate: elastic serice if sender s path underloaded : sender should use aailable bandwidth if sender s path congested: sender throttled to minimum guaranteed rate RM (resource management) cells: sent by sender, interspersed with data cells bits in RM cell set by switches ( network-assisted ) NI bit: no increase in rate (mild congestion) CI bit: congestion indication RM cells returned to sender by receier, with bits intact Transport Layer 3-96

97 Case study: ATM ABR congestion control RM cell data cell two-byte ER (explicit rate) field in RM cell congested switch may lower ER alue in cell senders send rate thus max supportable rate on path EFCI bit in data cells: set to 1 in congested switch if data cell preceding RM cell has EFCI set, receier sets CI bit in returned RM cell Transport Layer 3-97

98 Chapter 3 outline 3.1 transport-layer serices 3.2 multiplexing and demultiplexing 3.3 connectionless transport: UDP 3.4 principles of reliable data transfer 3.5 connection-oriented transport: TCP segment structure reliable data transfer flow control connection management 3.6 principles of congestion control 3.7 TCP congestion control Transport Layer 3-98

99 TCP congestion control: additie increase multiplicatie decrease approach: sender increases transmission rate (window size), probing for usable bandwidth, until loss occurs additie increase: increase cwnd by 1 MSS eery RTT until loss detected multiplicatie decrease: cut cwnd in half after loss AIMD saw tooth behaior: probing for bandwidth cwnd: TCP sender congestion window size additiely increase window size. until loss occurs (then cut window in half) time Transport Layer 3-99

100 TCP Congestion Control: details sender sequence number space cwnd last byte ACKed last byte sent sender limits transmission: sent, notyet ACKed ( inflight ) LastByteSent- LastByteAcked < cwnd TCP sending rate: roughly: send cwnd bytes, wait RTT for ACKS, then send more bytes rate ~ cwnd RTT bytes/sec cwnd is dynamic, function of perceied network congestion Transport Layer 3-100

101 TCP Slow Start when connection begins, increase rate exponentially until first loss eent: initially cwnd = 1 MSS double cwnd eery RTT done by incrementing cwnd for eery ACK receied summary: initial rate is slow but ramps up exponentially fast Host A RTT Host B time Transport Layer 3-101

102 TCP: detecting, reacting to loss loss indicated by timeout: cwnd set to 1 MSS; window then grows exponentially (as in slow start) to threshold, then grows linearly loss indicated by 3 duplicate ACKs: TCP RENO dup ACKs indicate network capable of deliering some segments cwnd is cut in half window then grows linearly TCP Tahoe always sets cwnd to 1 (timeout or 3 duplicate acks) Transport Layer 3-102

103 TCP: switching from slow start to CA Q: when should the exponential increase switch to linear? A: when cwnd gets to 1/2 of its alue before timeout. Implementation: ariable ssthresh on loss eent, ssthresh is set to 1/2 of cwnd just before loss eent Transport Layer 3-103

104 Summary: TCP Congestion Control L cwnd = 1 MSS ssthresh = 64 KB dupackcount = 0 timeout ssthresh = cwnd/2 cwnd = 1 MSS dupackcount = 0 retransmit missing segment dupackcount == 3 ssthresh= cwnd/2 cwnd = ssthresh + 3 retransmit missing segment duplicate ACK dupackcount++ slow start New ACK! new ACK cwnd = cwnd+mss dupackcount = 0 transmit new segment(s), as allowed cwnd > ssthresh L timeout ssthresh = cwnd/2 cwnd = 1 MSS dupackcount = 0 retransmit missing segment timeout ssthresh = cwnd/2 cwnd = 1 dupackcount = 0 retransmit missing segment fast recoery duplicate ACK new ACK cwnd = cwnd + MSS (MSS/cwnd) dupackcount = 0 transmit new segment(s), as allowed cwnd = ssthresh dupackcount = 0 congestion aoidance New ACK! New ACK cwnd = cwnd + MSS transmit new segment(s), as allowed. New ACK! duplicate ACK dupackcount++ dupackcount == 3 ssthresh= cwnd/2 cwnd = ssthresh + 3 retransmit missing segment Transport Layer 3-104

105 TCP throughput ag. TCP thruput as function of window size, RTT? ignore slow start, assume always data to send W: window size (measured in bytes) where loss occurs ag. window size (# in-flight bytes) is ¾ W ag. thruput is 3/4W per RTT ag TCP thruput = 3 4 W RTT bytes/sec W W/2 Transport Layer 3-105

106 TCP Futures: TCP oer long, fat pipes example: 1500 byte segments, 100ms RTT, want 10 Gbps throughput requires W = 83,333 in-flight segments throughput in terms of segment loss probability, L [Mathis 1997]: TCP throughput = MSS RTT L to achiee 10 Gbps throughput, need a loss rate of L = a ery small loss rate! new ersions of TCP for high-speed Transport Layer 3-106

107 TCP Fairness fairness goal: if K TCP sessions share same bottleneck link of bandwidth R, each should hae aerage rate of R/K TCP connection 1 TCP connection 2 bottleneck router capacity R Transport Layer 3-107

108 Why is TCP fair? two competing sessions: additie increase gies slope of 1, as throughout increases multiplicatie decrease decreases throughput proportionally R equal bandwidth share loss: decrease window by factor of 2 congestion aoidance: additie increase loss: decrease window by factor of 2 congestion aoidance: additie increase Connection 1 throughput R Transport Layer 3-108

109 Fairness (more) Fairness and UDP multimedia apps often do not use TCP do not want rate throttled by congestion control instead use UDP: send audio/ideo at constant rate, tolerate packet loss Fairness, parallel TCP connections application can open multiple parallel connections between two hosts web browsers do this e.g., link of rate R with 9 existing connections: new app asks for 1 TCP, gets rate R/10 new app asks for 11 TCPs, gets R/2 Transport Layer 3-109

110 Chapter 3: summary principles behind transport layer serices: multiplexing, demultiplexing reliable data transfer flow control congestion control instantiation, implementation in the Internet UDP TCP next: leaing the network edge (application, transport layers) into the network core Transport Layer 3-110