Chapter 3 Transport Layer Our goals r understand

Chapter 3: Transport Layer Our goals: r understand principles behind transport layer services: m m multiplexing/demultipl exing reliable data transfer flow control congestion control r learn about transport layer protocols in the Internet: m m m UDP: connectionless transport TCP: connection-oriented transport TCP congestion control Transport Layer 3 -1

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -2

Transport services and protocols r provide logical communication al ic g lo d en d- en po s an tr rt between app processes running on different hosts r transport protocols run in end systems m send side: breaks app messages into segments, passes to network layer m rcv side: reassembles segments into messages, passes to app layer r more than one transport protocol available to apps m Internet: TCP and UDP application transport network data link physical Transport Layer 3 -3

Transport vs. network layer r network layer: logical communication between hosts r transport layer: logical communication between processes m relies on, enhances, network layer services Household analogy: 12 kids sending letters to 12 kids r processes = kids r app messages = letters in envelopes r hosts = houses r transport protocol = Ann and Bill r network-layer protocol = postal service Transport Layer 3 -4

Internet transport-layer protocols r reliable, in-order delivery (TCP) m no-frills extension of “best-effort” IP r services not available: m delay guarantees m bandwidth guarantees network data link physical t or delivery: UDP network data link physical network sp an tr r unreliable, unordered network data link physical nd -e nd m network data link physical e al m congestion control flow control connection setup c gi lo m application transport network data link physical Transport Layer 3 -5

5 AP 1 AP 2 process Port/socket AP 3 AP 4 5 4 4 3 IP 层 3 2 2 1 1 host A AP 1 AP 2 router 1 LAN 1 router 2 WAN IP TCP , UDP host B LAN 2 AP 3 AP 4

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -7

Multiplexing/demultiplexing Multiplexing at send host: gathering data from multiple sockets, enveloping data with header (later used for demultiplexing) Demultiplexing at rcv host: delivering received segments to correct socket = socket application transport network link = process P 3 P 1 application transport network P 2 P 4 application transport network link physical host 1 physical host 2 physical host 3 Transport Layer 3 -8

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

Connectionless demultiplexing r Create sockets with port numbers: Datagram. Socket my. Socket 1 = new Datagram. Socket(12534); Datagram. Socket my. Socket 2 = new Datagram. Socket(12535); r UDP socket identified by two-tuple: (dest IP address, dest port number) r When host receives UDP segment: m m checks destination port number in segment directs UDP segment to socket with that port number r IP datagrams with different source IP addresses and/or source port numbers directed to same socket Transport Layer 3 -10

Connectionless demux (cont) Datagram. Socket server. Socket = new Datagram. Socket(6428); P 2 SP: 6428 DP: 9157 SP: 6428 DP: 5775 SP: 9157 client IP: A P 1 P 3 DP: 6428 server IP: C SP: 5775 DP: 6428 Client IP: B SP provides “return address” Transport Layer 3 -11

Connection-oriented demux r TCP socket identified by 4 -tuple: m m source IP address source port number dest IP address dest port number r recv host uses all four values to direct segment to appropriate socket r Server host may support many simultaneous TCP sockets: m each socket identified by its own 4 -tuple r Web servers have different sockets for each connecting client m non-persistent HTTP will have different socket for each request Transport Layer 3 -12

Connection-oriented demux (cont) P 1 P 4 P 5 P 2 P 6 P 1 P 3 SP: 5775 DP: 80 S-IP: B D-IP: C client IP: A SP: 9157 DP: 80 S-IP: A D-IP: C SP: 9157 server IP: C DP: 80 S-IP: B D-IP: C Client IP: B Transport Layer 3 -13

Connection-oriented demux: Threaded Web Server P 1 P 2 P 4 P 1 P 3 SP: 5775 DP: 80 S-IP: B D-IP: C client IP: A SP: 9157 DP: 80 S-IP: A D-IP: C SP: 9157 server IP: C DP: 80 S-IP: B D-IP: C Client IP: B Transport Layer 3 -14

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -15

UDP: User Datagram Protocol r “no frills, ” “bare bones” Internet transport protocol r “best effort” service, UDP segments may be: m lost m delivered out of order to app r connectionless: m no handshaking between UDP sender, receiver m each UDP segment handled independently of others [RFC 768] Why is there a UDP? r no connection establishment (which can add delay) r simple: no connection state at sender, receiver r small segment header r no congestion control: UDP can blast away as fast as desired Transport Layer 3 -16

UDP: more r often used for streaming multimedia apps m loss tolerant m rate sensitive Length, in bytes of UDP segment, including header r other UDP uses m DNS m SNMP r reliable transfer over UDP: add reliability at application layer m application-specific error recovery! 32 bits source port # dest port # length checksum Application data (message) UDP segment format Transport Layer 3 -17

UDP checksum Goal: detect “errors” (e. g. , flipped bits) in transmitted segment Sender: Receiver: r treat segment contents as r compute checksum of sequence of 16 -bit integers r checksum: addition (1’s complement sum) of segment contents r sender puts checksum value into UDP checksum field received segment r check if computed checksum equals checksum field value: m NO - error detected m YES - no error detected. …. Transport Layer 3 -18

Internet Checksum Example r Note m When adding numbers, a carryout from the most significant bit needs to be added to the result r Example: add two 16 -bit integers 1 1 0 0 1 1 1 0 1 0 1 wraparound 1 1 0 1 1 sum 1 1 0 1 1 0 0 checksum 1 0 0 0 0 1 1 Transport Layer 3 -19

Checksum: UDP segment + pseudo head byte 4 4 Source IP 2 2 S port UDP segment: D port 1 0 Destination IP 12 Pseudo head 1 17 2 length head 2 UDP length 2 checksum data IP head IP

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -21

Principles of Reliable data transfer r important in app. , transport, link layers r top-10 list of important networking topics! r characteristics of unreliable channel will determine complexity of reliable data transfer protocol (rdt) Transport Layer 3 -22

Principles of Reliable data transfer r important in app. , transport, link layers r top-10 list of important networking topics! r characteristics of unreliable channel will determine complexity of reliable data transfer protocol (rdt) Transport Layer 3 -23

Principles of Reliable data transfer r important in app. , transport, link layers r top-10 list of important networking topics! r characteristics of unreliable channel will determine complexity of reliable data transfer protocol (rdt) Transport Layer 3 -24

Reliable data transfer: getting started rdt_send(): called from above, (e. g. , by app. ). Passed data to deliver to receiver upper layer send side udt_send(): called by rdt, to transfer packet over unreliable channel to receiver deliver_data(): called by rdt to deliver data to upper receive side rdt_rcv(): called when packet arrives on rcv-side of channel Transport Layer 3 -25

Reliable data transfer: getting started We’ll: r incrementally develop sender, receiver sides of reliable data transfer protocol (rdt) r consider only unidirectional data transfer m but control info will flow on both directions! r use finite state machines (FSM) to specify sender, receiver state: when in this “state” next state uniquely determined by next event state 1 event causing state transition actions taken on state transition event actions state 2 Transport Layer 3 -26

Rdt 1. 0: reliable transfer over a reliable channel r underlying channel perfectly reliable m no bit errors m no loss of packets r separate FSMs for sender, receiver: m sender sends data into underlying channel m receiver read data from underlying channel Wait for call from above rdt_send(data) packet = make_pkt(data) udt_send(packet) sender Wait for call from below rdt_rcv(packet) extract (packet, data) deliver_data(data) receiver Transport Layer 3 -27

Rdt 2. 0: channel with bit errors r underlying channel may flip bits in packet m checksum to detect bit errors r the question: how to recover from errors: m acknowledgements (ACKs): receiver explicitly tells sender that pkt received OK m negative acknowledgements (NAKs): receiver explicitly tells sender that pkt had errors m sender retransmits pkt on receipt of NAK r new mechanisms in rdt 2. 0 (beyond rdt 1. 0): m m error detection receiver feedback: control msgs (ACK, NAK) rcvr->sender Transport Layer 3 -28

rdt 2. 0: FSM specification rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && is. NAK(rcvpkt) Wait for call from ACK or udt_send(sndpkt) above NAK rdt_rcv(rcvpkt) && is. ACK(rcvpkt) L sender receiver rdt_rcv(rcvpkt) && corrupt(rcvpkt) udt_send(NAK) Wait for call from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) extract(rcvpkt, data) deliver_data(data) udt_send(ACK) Transport Layer 3 -29

rdt 2. 0: operation with no errors rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && is. NAK(rcvpkt) Wait for call from ACK or udt_send(sndpkt) above NAK rdt_rcv(rcvpkt) && is. ACK(rcvpkt) L rdt_rcv(rcvpkt) && corrupt(rcvpkt) udt_send(NAK) Wait for call from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) extract(rcvpkt, data) deliver_data(data) udt_send(ACK) Transport Layer 3 -30

rdt 2. 0: error scenario rdt_send(data) snkpkt = make_pkt(data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && is. NAK(rcvpkt) Wait for call from ACK or udt_send(sndpkt) above NAK rdt_rcv(rcvpkt) && is. ACK(rcvpkt) L rdt_rcv(rcvpkt) && corrupt(rcvpkt) udt_send(NAK) Wait for call from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) extract(rcvpkt, data) deliver_data(data) udt_send(ACK) Transport Layer 3 -31

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

rdt 2. 1: sender, handles garbled ACK/NAKs rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt) Wait for call 0 from above rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt) L rdt_rcv(rcvpkt) && ( corrupt(rcvpkt) || is. NAK(rcvpkt) ) udt_send(sndpkt) Wait for ACK or NAK 0 L Wait for ACK or NAK 1 Wait for call 1 from above rdt_send(data) sndpkt = make_pkt(1, data, checksum) udt_send(sndpkt) Transport Layer 3 -33

rdt 2. 1: receiver, handles garbled ACK/NAKs rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 0(rcvpkt) rdt_rcv(rcvpkt) && (corrupt(rcvpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && (corrupt(rcvpkt) sndpkt = make_pkt(NAK, chksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq 1(rcvpkt) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) sndpkt = make_pkt(NAK, chksum) udt_send(sndpkt) Wait for 0 from below Wait for 1 from below rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 1(rcvpkt) rdt_rcv(rcvpkt) && not corrupt(rcvpkt) && has_seq 0(rcvpkt) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK, chksum) udt_send(sndpkt) Transport Layer 3 -34

rdt 2. 1: discussion Sender: r seq # added to pkt r two seq. #’s (0, 1) will suffice. Why? r must check if received ACK/NAK corrupted r twice as many states m state must “remember” whether “current” pkt has 0 or 1 seq. # Receiver: r must check if received packet is duplicate m state indicates whether 0 or 1 is expected pkt seq # r note: receiver can not know if its last ACK/NAK received OK at sender Transport Layer 3 -35

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

rdt 2. 2: sender, receiver fragments rdt_send(data) sndpkt = make_pkt(0, data, checksum) udt_send(sndpkt) rdt_rcv(rcvpkt) && Wait for call 0 from above rdt_rcv(rcvpkt) && (corrupt(rcvpkt) || has_seq 1(rcvpkt)) udt_send(sndpkt) Wait for 0 from below ( corrupt(rcvpkt) || is. ACK(rcvpkt, 1) ) udt_send(sndpkt) Wait for ACK 0 sender FSM fragment rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && is. ACK(rcvpkt, 0) receiver FSM fragment L rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && has_seq 1(rcvpkt) extract(rcvpkt, data) deliver_data(data) sndpkt = make_pkt(ACK 1, chksum) udt_send(sndpkt) Transport Layer 3 -38

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

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

rdt 3. 0 in action Transport Layer 3 -41

rdt 3. 0 in action Transport Layer 3 -42

Performance of rdt 3. 0 r rdt 3. 0 works, but performance stinks r ex: 1 Gbps link, 15 ms prop. delay, 8000 bit packet: m m m 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 -43

rdt 3. 0: stop-and-wait operation sender receiver first packet bit transmitted, t = 0 last packet bit transmitted, t = L / R RTT first packet bit arrives last packet bit arrives, send ACK arrives, send next packet, t = RTT + L / R Transport Layer 3 -44

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: go-Back-N, selective repeat Transport Layer 3 -45

Pipelining: increased utilization sender first packet bit transmitted, t=0 last bit transmitted, t = L / R RTT ACK arrives, send next packet, t = RTT + L / R receiver 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 Increase utilization by a factor of 3! Transport Layer 3 -46

Pipelining Protocols Go-back-N: big picture r Sender can have up to N unacked packets in pipeline r Rcvr only sends cumulative acks m Doesn’t ack packet if there’s a gap r Sender has timer for oldest unacked packet m If timer expires, retransmit all unacked packets Selective Repeat: big pic r Sender can have up to N unacked packets in pipeline r Rcvr acks individual packets r Sender maintains timer for each unacked packet m When timer expires, retransmit only unack packet Transport Layer 3 -47

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 timer for each in-flight pkt r timeout(n): retransmit pkt n and all higher seq # pkts in window m Transport Layer 3 -48

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 rdt_rcv(rcvpkt) && corrupt(rcvpkt) timeout start_timer udt_send(sndpkt[base]) udt_send(sndpkt[base+1]) … udt_send(sndpkt[nextseqnum-1]) rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) base = getacknum(rcvpkt)+1 If (base == nextseqnum) stop_timer else start_timer Transport Layer 3 -49

GBN: receiver extended FSM default udt_send(sndpkt) L Wait expectedseqnum=1 sndpkt = make_pkt(expectedseqnum, ACK, chksum) rdt_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 -50

GBN in action Transport Layer 3 -51

Selective Repeat 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 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 -52

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

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 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) otherwise: r ignore Transport Layer 3 -54

Selective repeat in action Transport Layer 3 -55

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

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -57

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

TCP segment structure Transport Layer 3 -59

TCP segment structure - Control field Transport Layer 3 -60

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) counting by bytes of data (not segments!) # bytes rcvr willing to accept application data (variable length) Transport Layer 3 -61

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

TCP seq. #’s and ACKs q The bytes of data being transferred in each connection are numbered by TCP. q The numbering starts with a randomly generated number. Transport Layer 3 -63

Problem 1: s A 100 B ready mutual transmission of data process B seq=M, the length of payload=100 B ACK=1, ack = 250 B ready seq = , length =250 ACK=1, ack = Transport Layer 3 -64

Problem 2: data and ack rocess A 100 B combined transmission of p s B proces seq =M, length=100 seq = M seq=N, length =500; ACK=1, ack = seq =N 500 B ACK=1, ack = Transport Layer 3 -65

Problem 3: process A 1000 B If some data is lost? seq= 4096, 1000 B process B Start_timer seq= 4096, 1000 B Retransmission Start_timer ACK=1, ack = ? Transport Layer 3 -66

Problem 3: s A 1000 B If some data is lost? process B seq= 90000, 100 B Start_timer ACK=1, ack = ? seq= ? , 100 B Start_timer ACK=1, ack = ? seq= ? , 100 B Transport Layer 3 -67

Problem 4: Data Merged process A 100 B process B seq=M wait 250 B more Merge: seq=? , ? B ACK=1, ack = ? Transport Layer 3 -68

Problem 5: ACK Merged process A process B seq=M, 100 B seq=? , 450 B Ack merged ACK=1, ack = ? Transport Layer 3 -69

Problem 6: Bulk transfer process A seq=M 1000 B each: seq=? process B Start_timer ACK=1, ack = ? ACK=1, ack =? Transport Layer 3 -70

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

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

Example RTT estimation: Transport Layer 3 -73

TCP Round Trip Time and Timeout Setting the timeout r Estimted. RTT plus “safety margin” m large variation in Estimated. RTT -> larger safety margin r 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 Transport Layer 3 -74

Adaptive Retransmission (Original Algorithm) r Measure Sample. RTT for each segment / ACK pair r Compute weighted average of RTT Est. RTT = a x Est. RTT + b x Sample. RTT m where a + b = 1 - a between 0. 8 and 0. 9 - b between 0. 1 and 0. 2 r Set timeout based on Est. RTT m Time. Out = 2 x Est. RTT m Transport Layer 3 -75

Karn/Partridge Algorithm r Do not sample RTT when retransmitting r Double timeout after each retransmission Transport Layer 3 -76

Jacobson/ Karels Algorithm r New Calculations for average RTT r Diff = Sample. RTT - Est. RTT r Est. RTT = Est. RTT + (d x Diff) r Dev = Dev + d( |Diff| - Dev) m where d is a factor between 0 and 1 r Consider variance when setting timeout value r Time. Out = m x Est. RTT + f x Dev m where m = 1 and f = 4 r Notes m algorithm only as good as granularity of clock (500 ms on Unix) m accurate timeout mechanism important to congestion control (later) Transport Layer 3 -77

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -78

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

Segment Size r Set to at most MSS (Maximum Segment Size) m MSS is the largest segment size that can be sent without IP fragmentation r TCP supports push operation to allow application to explicitly send a segment Transport Layer 3 -80

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

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 Transport Layer 3 -82

TCP: retransmission scenarios Host A 2, 8 by tes da t Seq=92 timeout a 00 ck=1 a X loss seq=9 2, 8 by tes da t a =100 Sendbase = 100 Send. Base = 120 ack Send. Base = 100 time Host B seq=9 Send. Base = 120 lost ACK scenario seq=1 2, 8 by tes da 00, 20 ta bytes data 0 10 20 k=1 ac k= ac seq=9 2 , 8 byt Seq=92 timeout seq=9 timeout Host A Host B time es dat a 120 = ack premature timeout Transport Layer 3 -83

TCP retransmission scenarios (more) Host A Host B seq=9 timeout 2, 8 by Send. Base = 120 tes da ta 100 ack= 00, 20 bytes data seq=1 X loss 120 ack= time Cumulative ACK scenario Transport Layer 3 -84

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 starts at lower end of gap Transport Layer 3 -85

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

Host A Host B timeout X resend 2 nd se gment time Figure 3. 37 Resending a segment after triple duplicate ACK Transport Layer 3 -87

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 Transport Layer 3 -88

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -89

TCP Flow Control r receive side of TCP connection has a receive buffer: flow control sender won’t overflow receiver’s buffer by transmitting too much, too fast r speed-matching r app process may be service: matching the send rate to the receiving app’s drain rate slow at reading from buffer Transport Layer 3 -90

TCP Flow control: how it works r Rcvr advertises spare (Suppose TCP receiver discards out-of-order segments) r spare room in buffer = Rcv. Window = Rcv. Buffer-[Last. Byte. Rcvd Last. Byte. Read] room by including value of Rcv. Window in segments r Sender limits un. ACKed data to Rcv. Window m m guarantees receive buffer doesn’t overflow Last. Byte. Sent – Last. Byte. Acked <= Rcv. Window Transport Layer 3 -91

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) counting by bytes of data (not segments!) # bytes rcvr willing to accept application data (variable length) Transport Layer 3 -92

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -93

TCP Connection Management Recall: TCP sender, receiver establish “connection” before exchanging data segments r initialize TCP variables: m seq. #s m buffers, flow control info (e. g. Rcv. Window) r client: connection initiator Socket client. Socket = new Socket("hostname", "port number"); r server: contacted by client Socket connection. Socket = welcome. Socket. accept(); Three way handshake: Step 1: client host sends TCP SYN segment to server m specifies initial seq # m no data Step 2: server host receives SYN, replies with SYNACK segment server allocates buffers m specifies server initial seq. # Step 3: client receives SYNACK, replies with ACK segment, which may contain data m Transport Layer 3 -94

Three way handshake Transport Layer 3 -95

TCP Connection Management (cont. ) Closing a connection: client closes socket: client. Socket. close(); client close Step 1: client end system close FIN timed wait FIN, replies with ACK. Closes connection, sends FIN ACK sends TCP FIN control segment to server Step 2: server receives server ACK closed Transport Layer 3 -100

TCP Connection Management (cont. ) Step 3: client receives FIN, replies with ACK. m client closing Enters “timed wait” will respond with ACK to received FINs server FIN ACK Step 4: server, receives closing FIN Note: with small modification, can handle simultaneous FINs. timed wait ACK. Connection closed. ACK closed Transport Layer 3 -101

TCP Connection Management (cont) TCP server lifecycle TCP client lifecycle Transport Layer 3 -105

Problem 1 r 设TCP客户端当前已被确认的最大序列号是 9453, 服务器端当前已被确认的最大序列号是 65778，画出关闭从服务器端到客户端的TCP 连接的过程, 并在图上标出正确的序列号和确认 号。 Transport Layer 3 -106

Problem 1: solution Transport Layer 3 -107

Problem 2 r 以下是一个TCP传输过程, 请正确填写括号中的数字(假 设每次接收方都全部接受到达的数据)。 Transport Layer 3 -108

Problem 2: solution Transport Layer 3 -109

Problem 3 Transport Layer 3 -110

Problem 3: solution r Work it out yourself! Transport Layer 3 -111

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -112

Principles of Congestion Control Congestion: r informally: “too many sources sending too much data too fast for network to handle” r different from flow control! r manifestations: m m lost packets (buffer overflow at routers) long delays (queueing in router buffers) r a top-10 problem! Transport Layer 3 -113

Causes/costs of congestion: scenario 1 Host A r two senders, two receivers r one router, infinite buffers r no retransmission Host B lout lin : original data unlimited shared output link buffers r large delays when congested r maximum achievable throughput Transport Layer 3 -115

Causes/costs of congestion: scenario 2 r one router, finite buffers r sender retransmission of lost packet Host A lin : original data lout l'in : original data, plus retransmitted data Host B finite shared output link buffers Transport Layer 3 -116

Causes/costs of congestion: scenario 2 (goodput) = l out in r “perfect” retransmission only when loss: r always: l l > lout in r retransmission of delayed (not lost) packet makes (than perfect case) for same R/2 l lout R/2 in larger R/2 lin a. R/2 lout R/3 lin b. R/2 R/4 lin R/2 c. “costs” of congestion: r more work (retrans) for given “goodput” r unneeded retransmissions: link carries multiple copies of pkt Transport Layer 3 -117

Causes/costs of congestion: scenario 3 r four senders Q: what happens as l in and l increase ? r multihop paths in r timeout/retransmit Host A lin : original data lout l'in : original data, plus retransmitted data finite shared output link buffers Host B Transport Layer 3 -118

Causes/costs of congestion: scenario 3 H o st A l o u t H o st B Another “cost” of congestion: r when packet dropped, any “upstream transmission capacity used for that packet wasted! Transport Layer 3 -119

Question r Congestion happens when sum of lin> R m Large delays m Waste of resources (packet loss, re-trans) r How can we maximize goodput while minimizing delay, packet loss, number of re-transmission? Transport Layer 3 -120

Approaches towards congestion control Closed loop Two broad approaches towards congestion control: End-end congestion control: r no explicit feedback from network r congestion inferred from end-system observed loss, delay r approach taken by TCP Network-assisted congestion control: r routers provide feedback to end systems m single bit indicating congestion (SNA, DECbit, TCP/IP ECN, ATM) m explicit rate sender should send at Open loop: no need for cong control in circuit switching. Why? Transport Layer 3 -121

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

Case study: ATM ABR congestion control r two-byte ER (explicit rate) field in RM cell m congested switch may lower ER value in cell m sender’ send rate thus maximum supportable rate on path r EFCI bit in data cells: set to 1 in congested switch m if data cell preceding RM cell has EFCI set, sender sets CI bit in returned RM cell Transport Layer 3 -123

Chapter 3 outline r 3. 1 Transport-layer services r 3. 2 Multiplexing and demultiplexing r 3. 3 Connectionless transport: UDP r 3. 4 Principles of reliable data transfer r 3. 5 Connection-oriented transport: TCP m m segment structure reliable data transfer flow control connection management r 3. 6 Principles of congestion control r 3. 7 TCP congestion control Transport Layer 3 -124

TCP Congestion Control r Idea m assumes best-effort network (FIFO or FQ routers) m each source determines network capacity for itself m uses implicit feedback m ACKs pace transmission (self-clocking) Transport Layer 3 -125

TCP Congestion Control r Challenge m determining the available capacity in the first place (Without additional protocols or APIs) m adjusting to changes in the available capacity (Adjustments must be made quickly since a large window may already be out on the network) r Implementation m increase Congestion. Window when congestion goes down (slowly) m decrease Congestion. Window when congestion goes up (quickly) r Question: how does the source determine whether or not the network is congested? Transport Layer 3 -126

TCP Congestion Control: details r sender limits transmission: Last. Byte. Sent-Last. Byte. Acked Cong. Win r Roughly, rate = Cong. Win Bytes/sec RTT r Cong. Win is dynamic, function of perceived network congestion How does sender perceive congestion? r loss event = timeout or 3 duplicate acks r TCP sender reduces rate (Cong. Win) after loss event three mechanisms: m m m AIMD slow start conservative after timeout events Transport Layer 3 -127

TCP congestion control: additive increase, multiplicative decrease r Approach: increase transmission rate (window size), Saw tooth behavior: probing for bandwidth congestion window size probing for usable bandwidth, until loss occurs m additive increase: increase Cong. Win (congestion window) by 1 MSS (Maximum Segment Size )every RTT until loss detected MSS=MTU-IP-TCP m multiplicative decrease: cut Cong. Win in half after loss time Transport Layer 3 -128

TCP Slow Start r When connection begins, Cong. Win = 1 MSS m m Example: MSS = 500 bytes & RTT = 200 msec initial rate = 20 kbps r When connection begins, increase rate exponentially fast until first loss event r available bandwidth may be >> MSS/RTT m desirable to quickly ramp up to respectable rate Transport Layer 3 -129

TCP Slow Start (more) r When connection m m double Cong. Win every RTT done by incrementing Cong. Win for every ACK received RTT begins, increase rate exponentially until first loss event: Host A Host B one segme nt two segme nts four segme nts r Summary: initial rate is slow but ramps up exponentially fast time Transport Layer 3 -130

Figure 12. 11 Illustration of Slow Start and Congestion Avoidance Transport Layer 3 -131

Refinement: inferring loss r After 3 dup ACKs: m Cong. Win m window is cut in half then grows linearly r But after timeout event: m Cong. Win instead set to 1 MSS; m window then grows exponentially m to a threshold, then grows linearly Philosophy: q 3 dup ACKs indicates network capable of delivering some segments q timeout indicates a “more alarming” congestion scenario Transport Layer 3 -132

Refinement Q: When should the exponential increase switch to linear? A: When Cong. Win gets to 1/2 of its value before timeout. congestion-avoidance fast recovery slow-start Implementation: r Variable Threshold r At loss event, Threshold is set to 1/2 of Cong. Win just before loss event Transport Layer 3 -133

Summary: TCP Congestion Control r When Cong. Win is below Threshold, sender in slow-start phase, window grows exponentially. r When Cong. Win is above Threshold, sender is in congestion-avoidance phase, window grows linearly. r When a triple duplicate ACK occurs, Threshold set to Cong. Win/2 and Cong. Win set to Threshold. r When timeout occurs, Threshold set to Cong. Win/2 and Cong. Win is set to 1 MSS. Transport Layer 3 -134

TCP sender congestion control State Event TCP Sender Action Commentary Slow Start (SS) ACK receipt Cong. Win = Cong. Win + MSS, for previously If (Cong. Win > Threshold) unacked data set state to “Congestion Avoidance” Resulting in a doubling of Cong. Win every RTT Congestion Avoidance (CA) ACK receipt Cong. Win = Cong. Win+MSS * for previously (MSS/Cong. Win) unacked data Additive increase, resulting in increase of Cong. Win by 1 MSS every RTT SS or CA Loss event detected by triple duplicate ACK Threshold = Cong. Win/2, Cong. Win = Threshold, Set state to “Congestion Avoidance” Fast recovery, implementing multiplicative decrease. Cong. Win will not drop below 1 MSS. SS or CA Timeout Threshold = Cong. Win/2, Cong. Win = 1 MSS, Set state to “Slow Start” Enter slow start SS or CA Duplicate ACK Increment duplicate ACK count for segment being acked Cong. Win and Threshold not changed Transport Layer 3 -135

congestion control algorithm Th = ? Cong. Win = 1 MSS /* slow start or exponential increase */ While (No Packet Loss and Cong. Win < Th) { send Cong. Win TCP segments for each ACK increase Cong. Win by 1 } /* congestion avoidance or linear increase */ While (No Packet Loss) { send Cong. Win TCP segments for Cong. Win ACKs, increase Cong. Win by 1 } Th = Cong. Win/2 If (3 Dup ACKs) Cong. Win = Th; If (timeout) Cong. Win=1; Transport Layer 3 -136

TCP Congestion Window Trace Transport Layer 3 -137

TCP throughput r What’s the average throughout of TCP as a r r function of window size and RTT? m Ignore slow start Let W be the window size when loss occurs. When window is W, throughput is W/RTT Just after loss, window drops to W/2, throughput to W/2 RTT. Average throughout: . 75 W/RTT Transport Layer 3 -138

TCP Futures: TCP over “long, fat pipes” r Example: 1500 byte segments, 100 ms RTT, want 10 Gbps throughput 10 * (10 ** 9) = W * 1500*8 /[ 100* (10 ** -3 )] r Requires window size W = 83, 333 in-flight segments r Throughput in terms of loss rate: r ➜ L = 2·10 -10 Wow r New versions of TCP for high-speed Transport Layer 3 -139

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

Why is TCP fair? Two competing sessions: r Additive increase gives slope of 1, as throughout increases r multiplicative decreases throughput proportionally equal bandwidth share Connection 2 throughput R loss: decrease window by factor of 2 congestion avoidance: additive increase Connection 1 throughput R Transport Layer 3 -141

Fairness (more) Fairness and UDP r Multimedia apps often do not use TCP m do not want rate throttled by congestion control r Instead use UDP: m pump audio/video at constant rate, tolerate packet loss r Research area: TCP friendly Fairness and parallel TCP connections r nothing prevents app from opening parallel connections between 2 hosts. r Web browsers do this r Example: link of rate R supporting 9 connections; m m new app asks for 1 TCP, gets rate R/10 new app asks for 11 TCPs, gets R/2 ! Transport Layer 3 -142

TCP Flavors r TCP Tahoe m W=1 adaptation on congestion r TCP Reno m W=W/2 adaptation on fast retransmit, W=1 on timeout r TCP new. Reno m TCP-Reno + fast recovery r TCP Vegas m Uses round-trip time as an early-congestion-feedback mechanism m Reduces losses r TCP SACK m Selective Acknowledgement r TCP FACK m Intelligently uses TCP SACK information to optimize the fast recovery mechanism further Transport Layer 3 -143

TCP Tahoe r Slow-start r Congestion control upon time-out or DUP-ACKs r When the sender receives 3 duplicate ACKs for the same sequence number, sender infers a loss r Congestion window reduced to 1 and slow-start performed again r Simple r Congestion control too aggressive Transport Layer 3 -144

TCP Reno r Tahoe + Fast re-transmit r Packet loss detected both through timeouts, and through DUP-ACKs r Sender reduces window by half, the ssthresh is set to half of current window, and congestion avoidance is performed (window increases only by 1 every round-trip time) r Fast recovery ensures that pipe does not become empty r Window cut-down to 1 (and subsequent slowstart) performed only on time-out Transport Layer 3 -145

TCP New-Reno r TCP-Reno with more intelligence during fast r r recovery In TCP-Reno, the first partial ACK will bring the sender out of the fast recovery phase Results in timeouts when there are multiple losses In TCP New-Reno, partial ACK is taken as an indication of another lost packet (which is immediately retransmitted). Sender comes out of fast recovery only after all outstanding packets (at the time of first loss) are ACKed Transport Layer 3 -146

TCP SACK r TCP (Tahoe, Reno, and New-Reno) uses cumulative acknowledgements r When there are multiple losses, TCP Reno and New-Reno can retransmit only one lost packet per round-trip time r SACK enables receiver to give more information to sender about received packets allowing sender to recover from multiple-packet losses faster Transport Layer 3 -147

TCP Vegas r Idea: source watches for some sign that some router's queue is building up and congestion will happen soon; e. g. , m m RTT is growing sending rate flattens Transport Layer 3 -148

Vegas Details r Value of throughput with no congestion is compared to current throughput r If current difference is smaller, increase window size linearly r If current difference is larger, decrease window size linearly r The change in the Slow Start Mechanism consists of doubling the window every other RTT, rather than every RTT and of using a boundary in the difference between throughputs to exit the Slow Start phase, rather than a window size value. Transport Layer 3 -149

Random Early Detection (RED) r Notification is implicit m just drop the packet (TCP will timeout) m could make explicit by marking the packet r Early random drop m rather than wait for queue to become full, drop each arriving packet with some drop probability whenever the queue length exceeds some drop level Transport Layer 3 -150

RED Details r Compute average queue length Avg. Len = (1 - Weight) * Avg. Len + Weight * Sample. Len 0 < Weight < 1 (usually 0. 002) Sample. Len is queue length each time a packet arrives Max. Threshold Min. Threshold Avg. Len Transport Layer 3 -151

RED Details (cont) r Two queue length thresholds if Avg. Len <= Min. Threshold then enqueue the packet if Min. Threshold < Avg. Len < Max. Threshold then calculate probability P drop arriving packet with probability P if Max. Threshold <= Avg. Len then drop arriving packet Transport Layer 3 -152

RED Details (cont) r Computing probability P Temp. P = Max. P * (Avg. Len - Min. Threshold)/ (Max. Threshold - Min. Threshold) P = Temp. P/(1 - count * Temp. P) r Drop Probability Curve P(drop) 1. 0 Max. P Avg. Len Min. Thresh Max. Thresh Transport Layer 3 -153

Tuning RED r Probability of dropping a particular flow’s packet(s) is r r roughly proportional to the share of the bandwidth that flow is currently getting Max. P is typically set to 0. 02, meaning that when the average queue size is halfway between the two thresholds, the gateway drops roughly one out of 50 packets. If traffic id bursty, then Min. Threshold should be sufficiently large to allow link utilization to be maintained at an acceptably high level Difference between two thresholds should be larger than the typical increase in the calculated average queue length in one RTT; setting Max. Threshold to twice Min. Threshold is reasonable for traffic on today’s Internet Penalty Box for Offenders Transport Layer 3 -154

Some definitions r Throughput: the gross bit rate that is transferred physically r Goodput: application level throughput, i. e. the number of useful bits per unit of time forwarded by the network from a certain source address to a certain destination, excluding protocol overhead, and excluding retransmitted data packets. r goodput is generally lower than throughput m m m Protocol overhead Transport layer flow control and congestion avoidance Retransmission Transport Layer 3 -155

Chapter 3: Summary r principles behind transport layer services: m multiplexing, demultiplexing m reliable data transfer m flow control m congestion control r instantiation and implementation in the Internet m UDP m TCP Next: r leaving the network “edge” (application, transport layers) r into the network “core” Transport Layer 3 -156

Chapter 3: 2 nd Homework r R 4, P 23 r TCP使用了哪些机制来实现可靠的数据传输？ Hand in at once by Monitors ONE week later. No print! Hand-writing with you ID and name. Transport Layer 3 -157

Review Questions See the textbook q R 1, R 5, R 7, R 8, R 14, R 16, R 17 q P 20, P 32 q 拥塞控制与流量控制的区别？ q TCP与回退N，选择重传的区别? Transport Layer 3 -158