Chapter 3 Down Approach Transport Layer - Brock University

Computer Networking A Top Down Approach

A note on the use of these Powerpoint slidesWersquore making these slides freely available to all (faculty students readers) Theyrsquore in PowerPoint form so you see the animations and can add modify and delete slides (including this one) and slide content to suit your needs They obviously represent a lot of work on our part In return for use we only ask the following

If you use these slides (eg in a class) that you mention their source (after all wersquod like people to use our book)

If you post any slides on a www site that you note that they are adapted from (or perhaps identical to) our slides and note our copyright of this material

Thanks and enjoy JFKKWR

All material copyright 1996-2016 JF Kurose and KW Ross All Rights Reserved

7th edition Jim Kurose Keith RossPearsonAddison WesleyApril 2016

Chapter 3Transport Layer

Transport Layer 2-1

Transport Layer 3-2

Chapter 3 Transport Layerour goals understand

principles behind transport layer services

bull multiplexing demultiplexing

bull reliable data transferbull flow controlbull congestion control

learn about Internet transport layer protocols

bull UDP connectionless transport

bull TCP connection-oriented reliable transport

bull TCP congestion control

Transport Layer 3-3

Chapter 3 outline31 transport-layer

services32 multiplexing and

demultiplexing33 connectionless

transport UDP34 principles of reliable

data transfer

35 connection-oriented transport TCPbull segment structurebull reliable data transferbull flow controlbull connection

management36 principles of

congestion control37 TCP congestion control

Transport Layer 3-4

Transport services and protocols provide logical

communication between app processes running on different hosts

transport protocols run in end systems

bull send side breaks app messages into segments passes to network layer

bull rcv side reassembles segments into messages passes to app layer

more than one transport protocol available to apps

bull Internet TCP and UDP

applicationtransportnetworkdata linkphysical

logical end-end transportapplicationtransportnetworkdata linkphysical

Transport Layer 3-5

Transport vs network layer

network layer logical communication between hosts

transport layer logical communication between processes

bull relies on enhances network layer services

12 kids in Annrsquos house sending letters to 12 kids in Billrsquos house

hosts = houses processes = kids app messages = letters in

envelopes transport protocol = Ann and

Bill who demux to in-house siblings

network-layer protocol = postal service

household analogy

Transport Layer 3-6

Internet transport-layer protocols reliable in-order

delivery (TCP)bull congestion control bull flow controlbull connection setup

unreliable unordered delivery UDP

bull no-frills extension of ldquobest-effortrdquo IP

services not available bull delay guaranteesbull bandwidth guarantees



networkdata linkphysical







logical end-end transport

Transport Layer 3-7





data transfer




Transport Layer 3-8

Multiplexingdemultiplexing

process

socket

use header info to deliverreceived segments to correct socket

demultiplexing at receiverhandle data from multiplesockets add transport header (later used for demultiplexing)

multiplexing at sender

transport

application

physical

link

network

P2P1

transport

application

physical

link

network

P4

transport

application

physical

link

network

P3

Transport Layer 3-9

How demultiplexing works

host receives IP datagramsbull each datagram has source IP

address destination IP address

bull each datagram carries one transport-layer segment

bull each segment has source destination port number

host uses IP addresses amp port numbers to direct segment to appropriate socket

source port dest port

32 bits

applicationdata

(payload)

other header fields

TCPUDP segment format

Transport Layer 3-10

Connectionless demultiplexing recall created socket has

host-local port DatagramSocket mySocket1 = new DatagramSocket(12534)

when host receives UDP segment

bull checks destination port in segment

bull directs UDP segment to socket with that port

recall when creating datagram to send into UDP socket must specify

bull destination IP addressbull destination port

IP datagrams with same dest port but different source IP addresses andor source port numbers will be directed to same socket at dest


Connectionless demux exampleDatagramSocket serverSocket = new DatagramSocket

(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

DatagramSocket mySocket1 = new DatagramSocket (5775)


source port 9157dest port 6428





Connection-oriented demux TCP socket identified

by 4-tuple bull source IP addressbull source port numberbull dest IP addressbull dest port number

demux receiver uses all four values to direct segment to appropriate socket

server host may support many simultaneous TCP sockets

bull each socket identified by its own 4-tuple

web servers have different sockets for each connecting client

bull non-persistent HTTP will have different socket for each request


Connection-oriented demux example

transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2

source IPport A9157dest IP port B80

source IPport B80dest IPport A9157host IP

address Ahost IP

address C

network

P6P5P3

source IPport C5775dest IPport B80


three segments all destined to IP address B dest port 80 are demultiplexed to different sockets

server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer





UDP User Datagram Protocol [RFC 768]

ldquono frillsrdquo ldquobare bonesrdquo Internet transport protocol

ldquobest effortrdquo service UDP segments may be

bull lostbull delivered out-of-order to

app connectionless

bull no handshaking between UDP sender receiver

bull each UDP segment handled independently of others

UDP use streaming multimedia

apps (loss tolerant rate sensitive)

DNS SNMP

reliable transfer over UDP

add reliability at application layer

application-specific error recovery


UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum

length in bytes of UDP segment

including header

no connection establishment (which can add delay)

simple no connection state at sender receiver

small header size no congestion control UDP

can blast away as fast as desired

why is there a UDP


UDP checksum

sender treat segment contents

including header fields as sequence of 16-bit integers

checksum addition (onersquos complement sum) of segment contents

sender puts checksum value into UDP checksum field

receiver compute checksum of

received segment check if computed checksum

equals checksum field valuebull NO - error detectedbull YES - no error detected

But maybe errors nonetheless More later hellip

Goal detect ldquoerrorsrdquo (eg flipped bits) in transmitted segment


Internet checksum exampleexample add two 16-bit integers

1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum

Note when adding numbers a carryout from the most significant bit needs to be added to the result

Check out the online interactive exercises for more examples httpgaiacsumassedukurose_rossinteractive






data transfer





Principles of reliable data transfer important in application transport link layers

bull top-10 list of important networking topics

characteristics of unreliable channel will determine complexity of reliable data transfer protocol (rdt)







important in application transport link layersbull top-10 list of important networking topics

Principles of reliable data transfer


Reliable data transfer getting started

sendside

receiveside

rdt_send() called from above (eg by app) Passed data to deliver to receiver upper layer

udt_send() called by rdtto transfer packet over

unreliable channel to receiver

rdt_rcv() called when packet arrives on rcv-side of channel

deliver_data() called by rdt to deliver data to upper


wersquoll incrementally develop sender receiver sides of

reliable data transfer protocol (rdt) consider only unidirectional data transfer

bull but control info will flow on both directions use finite state machines (FSM) to specify sender

receiver

state1

state2

event causing state transitionactions taken on state transition

state when in this ldquostaterdquo next state

uniquely determined by next event

eventactions



rdt10 reliable transfer over a reliable channel

underlying channel perfectly reliablebull no bit errorsbull no loss of packets

separate FSMs for sender receiverbull sender sends data into underlying channelbull receiver reads data from underlying channel

Wait for call from above packet = make_pkt(data)

udt_send(packet)

rdt_send(data)extract (packetdata)deliver_data(data)

Wait for call from

below

rdt_rcv(packet)

sender receiver


underlying channel may flip bits in packetbull checksum to detect bit errors

the question how to recover from errorsbull acknowledgements (ACKs) receiver explicitly tells

sender that pkt received OKbull negative acknowledgements (NAKs) receiver explicitly

tells sender that pkt had errorsbull sender retransmits pkt on receipt of NAK

new mechanisms in rdt20 (beyond rdt10)bull error detectionbull receiver feedback control msgs (ACKNAK)

rcvr-gtsender

rdt20 channel with bit errors







rcvr-gtsender


How do humans recover from ldquoerrorsrdquo

during conversation






new mechanisms in rdt20 (beyond rdt10)bull error detectionbull feedback control msgs (ACKNAK) from receiver to

sender



rdt20 FSM specification

Wait for call from above

sndpkt = make_pkt(data checksum)udt_send(sndpkt)

extract(rcvpktdata)deliver_data(data)udt_send(ACK)

rdt_rcv(rcvpkt) ampamp notcorrupt(rcvpkt)

rdt_rcv(rcvpkt) ampamp isACK(rcvpkt)

udt_send(sndpkt)

rdt_rcv(rcvpkt) ampamp isNAK(rcvpkt)

udt_send(NAK)

rdt_rcv(rcvpkt) ampamp corrupt(rcvpkt)

Wait for ACK or

NAK

Wait for call from

belowsender

receiverrdt_send(data)

Λ


rdt20 operation with no errors


snkpkt = make_pkt(data checksum)udt_send(sndpkt)




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ


rdt20 error scenario






udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ


rdt20 has a fatal flaw

what happens if ACKNAK corrupted

sender doesnrsquot know what happened at receiver

canrsquot just retransmit possible duplicate

handling duplicates sender retransmits

current pkt if ACKNAK corrupted

sender adds sequence number to each pkt

receiver discards (doesnrsquot deliver up) duplicate pkt

stop and waitsender sends one packet then waits for receiver response


rdt21 sender handles garbled ACKNAKs

Wait for call 0 from

above

sndpkt = make_pkt(0 data checksum)udt_send(sndpkt)

rdt_send(data)

Wait for ACK or NAK 0 udt_send(sndpkt)

rdt_rcv(rcvpkt) ampamp ( corrupt(rcvpkt) ||isNAK(rcvpkt) )


rdt_send(data)

rdt_rcv(rcvpkt) ampamp notcorrupt(rcvpkt) ampamp isACK(rcvpkt)

udt_send(sndpkt)




above

Wait for ACK or NAK 1

ΛΛ


Wait for 0 from below

sndpkt = make_pkt(NAK chksum)udt_send(sndpkt)

rdt_rcv(rcvpkt) ampamp not corrupt(rcvpkt) ampamp has_seq0(rcvpkt)

rdt_rcv(rcvpkt) ampamp notcorrupt(rcvpkt) ampamp has_seq1(rcvpkt)

extract(rcvpktdata)deliver_data(data)sndpkt = make_pkt(ACK chksum)udt_send(sndpkt)




rdt_rcv(rcvpkt) ampamp (corrupt(rcvpkt)

sndpkt = make_pkt(ACK chksum)udt_send(sndpkt)





rdt21 receiver handles garbled ACKNAKs


rdt21 discussion

sender seq added to pkt two seq rsquos (01) will

suffice Why must check if received

ACKNAK corrupted twice as many states

bull state must ldquorememberrdquo whether ldquoexpectedrdquo pkt should have seq of 0 or 1

receiver must check if received

packet is duplicatebull state indicates

whether 0 or 1 is expected pkt seq

note receiver can not know if its last ACKNAK received OK at sender


rdt22 a NAK-free protocol

same functionality as rdt21 using ACKs only instead of NAK receiver sends ACK for last pkt

received OKbull receiver must explicitly include seq of pkt being

ACKed duplicate ACK at sender results in same action as

NAK retransmit current pkt


rdt22 sender receiver fragments


above


rdt_send(data)

udt_send(sndpkt)

rdt_rcv(rcvpkt) ampamp ( corrupt(rcvpkt) || isACK(rcvpkt1) )

rdt_rcv(rcvpkt) ampamp notcorrupt(rcvpkt) ampamp isACK(rcvpkt0)

Wait for ACK

0sender FSMfragment

rdt_rcv(rcvpkt) ampamp notcorrupt(rcvpkt) ampamp has_seq1(rcvpkt) extract(rcvpktdata)deliver_data(data)sndpkt = make_pkt(ACK1 chksum)udt_send(sndpkt)


rdt_rcv(rcvpkt) ampamp (corrupt(rcvpkt) || has_seq1(rcvpkt))

udt_send(sndpkt)receiver FSM

fragment

Λ


rdt30 channels with errors and loss

new assumption underlying channel can also lose packets (data ACKs)

bull checksum seq ACKs retransmissions will be of help hellip but not enough

approach sender waits ldquoreasonablerdquo amount of time for ACK

retransmits if no ACK received in this time

if pkt (or ACK) just delayed (not lost)

bull retransmission will be duplicate but seq rsquos already handles this

bull receiver must specify seq of pkt being ACKed

requires countdown timer


rdt30 sendersndpkt = make_pkt(0 data checksum)udt_send(sndpkt)start_timer

rdt_send(data)

Wait for

ACK0

rdt_rcv(rcvpkt) ampamp ( corrupt(rcvpkt) ||isACK(rcvpkt1) )


above

sndpkt = make_pkt(1 data checksum)udt_send(sndpkt)start_timer

rdt_send(data)




stop_timerstop_timer

udt_send(sndpkt)start_timer

timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss

pkt1timeoutresend pkt1

rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0

(d) premature timeout delayed ACK


ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0

send pkt0rcv ack1 pkt0

rcv pkt0send ack0ack0

rcv pkt0

send ack0(detect duplicate)


Performance of rdt30 rdt30 is correct but performance stinks eg 1 Gbps link 15 ms prop delay 8000 bit packet

U sender utilization ndash fraction of time sender busy sending

if RTT=30 msec 1KB pkt every 30 msec 33kBsec thruput over 1 Gbps link

network protocol limits use of physical resources

Dtrans =LR

8000 bits109 bitssec= = 8 microsecs


rdt30 stop-and-wait operation

first packet bit transmitted t = 0

sender receiver

RTT

last packet bit transmitted t = L R

first packet bit arriveslast packet bit arrives send ACK

ACK arrives send next packet t = RTT + L R


Pipelined protocols

pipelining sender allows multiple ldquoin-flightrdquo yet-to-be-acknowledged pkts

bull range of sequence numbers must be increasedbull buffering at sender andor receiver

two generic forms of pipelined protocols go-Back-N selective repeat


Pipelining increased utilization


sender receiver

RTT

last bit transmitted t = L R



last bit of 2nd packet arrives send ACKlast bit of 3rd packet arrives send ACK

3-packet pipelining increases utilization by a factor of 3


Pipelined protocols overviewGo-back-N sender can have up to N

unacked packets in pipeline receiver only sends

cumulative ackbull doesnrsquot ack packet if therersquos a

gap sender has timer for oldest

unacked packetbull when timer expires

retransmit all unacked packets

Selective Repeat sender can have up to N

unackrsquoed packets in pipeline

rcvr sends individual ack for each packet

sender maintains timer for each unacked packet

bull when timer expires retransmit only that unacked packet


Go-Back-N sender k-bit seq in pkt header ldquowindowrdquo of up to N consecutive unackrsquoed pkts allowed

ACK(n) ACKs all pkts up to including seq n - ldquocumulative ACKrdquo

bull may receive duplicate ACKs (see receiver) timer for oldest in-flight pkt timeout(n) retransmit packet n and all higher seq pkts in

window


GBN sender extended FSM

Wait start_timerudt_send(sndpkt[base])udt_send(sndpkt[base+1])hellipudt_send(sndpkt[nextseqnum-1])

timeout

rdt_send(data)

if (nextseqnum lt base+N) sndpkt[nextseqnum] = make_pkt(nextseqnumdatachksum) udt_send(sndpkt[nextseqnum]) if (base == nextseqnum) start_timer nextseqnum++ else refuse_data(data)

base = getacknum(rcvpkt)+1If (base == nextseqnum) stop_timer else start_timer


base=1nextseqnum=1


Λ


ACK-only always send ACK for correctly-received pkt with highest in-order seq

bull may generate duplicate ACKsbull need only remember expectedseqnum

out-of-order pkt bull discard (donrsquot buffer) no receiver bufferingbull re-ACK pkt with highest in-order seq

Wait

udt_send(sndpkt)default

rdt_rcv(rcvpkt) ampamp notcurrupt(rcvpkt) ampamp hasseqnum(rcvpktexpectedseqnum)

extract(rcvpktdata)deliver_data(data)sndpkt = make_pkt(expectedseqnumACKchksum)udt_send(sndpkt)expectedseqnum++

expectedseqnum=1sndpkt = make_pkt(expectedseqnumACKchksum)

Λ

GBN receiver extended FSM


GBN in action

send pkt0send pkt1send pkt2send pkt3

(wait)

sender receiver

receive pkt0 send ack0receive pkt1 send ack1 receive pkt3 discard (re)send ack1rcv ack0 send pkt4

rcv ack1 send pkt5

pkt 2 timeoutsend pkt2send pkt3send pkt4send pkt5

Xloss

receive pkt4 discard (re)send ack1receive pkt5 discard (re)send ack1

rcv pkt2 deliver send ack2rcv pkt3 deliver send ack3rcv pkt4 deliver send ack4rcv pkt5 deliver send ack5

ignore duplicate ACK

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8


Selective repeat receiver individually acknowledges all correctly

received pktsbull buffers pkts as needed for eventual in-order

delivery to upper layer sender only resends pkts for which ACK not

receivedbull sender timer for each unACKed pkt

sender windowbull N consecutive seq rsquosbull limits seq s of sent unACKed pkts


Selective repeat sender receiver windows


Selective repeat

data from above if next available seq in

window send pkttimeout(n) resend pkt n restart timerACK(n) in [sendbasesendbase+N] mark pkt n as received if n smallest unACKed pkt

advance window base to next unACKed seq

senderpkt n in [rcvbase rcvbase+N-1] send ACK(n) out-of-order buffer in-order deliver (also

deliver buffered in-order pkts) advance window to next not-yet-received pkt

pkt n in [rcvbase-Nrcvbase-1] ACK(n)otherwise ignore

receiver


Selective repeat in action


(wait)

sender receiver

receive pkt0 send ack0receive pkt1 send ack1 receive pkt3 buffer send ack3rcv ack0 send pkt4

rcv ack1 send pkt5

pkt 2 timeoutsend pkt2

Xloss

receive pkt4 buffer send ack4receive pkt5 buffer send ack5

rcv pkt2 deliver pkt2pkt3 pkt4 pkt5 send ack2

record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived

Q what happens when ack2 arrives


Selective repeatdilemmaexample seq rsquos 0 1 2 3 window size=3

receiver window(after receipt)

sender window(after receipt)

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0

timeoutretransmit pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX

will accept packetwith seq number 0(b) oops

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X

will accept packetwith seq number 0

0 1 2 3 0 1 2 pkt3

(a) no problem

receiver canrsquot see sender sidereceiver behavior identical in both cases

somethingrsquos (very) wrong

receiver sees no difference in two scenarios

duplicate data accepted as new in (b)

Q what relationship between seq size and window size to avoid problem in (b)






data transfer





TCP Overview RFCs 79311221323 2018 2581

full duplex databull bi-directional data flow in

same connectionbull MSS maximum segment

size connection-oriented

bull handshaking (exchange of control msgs) inits sender receiver state before data exchange

flow controlledbull sender will not overwhelm

receiver

point-to-pointbull one sender one receiver

reliable in-order byte steam

bull no ldquomessage boundariesrdquo pipelined

bull TCP congestion and flow control set window size


TCP segment structure


32 bits

applicationdata

(variable length)

sequence numberacknowledgement number

receive window

Urg data pointerchecksumFSRPAUhead

lennot

used

options (variable length)

URG urgent data (generally not used)

ACK ACK valid

PSH push data now(generally not used)

RST SYN FINconnection estab(setup teardown

commands)

bytes rcvr willingto accept

countingby bytes of data(not segments)

Internetchecksum

(as in UDP)


TCP seq numbers ACKssequence numbers

bullbyte stream ldquonumberrdquo of first byte in segmentrsquos data

acknowledgementsbullseq of next byte expected from other side

bullcumulative ACKQ how receiver handles out-of-order segmentsbullA TCP spec doesnrsquot say - up to implementor source port dest port


checksum

rwndurg pointer

incoming segment to sender

A

sent ACKed

sent not-yet ACKed(ldquoin-flightrdquo)

usablebut not yet sent

not usable

window size N

sender sequence number space



checksum

rwndurg pointer

outgoing segment from sender


TCP seq numbers ACKs

Usertypes

lsquoCrsquo

host ACKsreceipt

of echoedlsquoCrsquo

host ACKsreceipt oflsquoCrsquo echoesback lsquoCrsquo

simple telnet scenario

Host BHost A

Seq=42 ACK=79 data = lsquoCrsquo


Seq=43 ACK=80


TCP round trip time timeoutQ how to set TCP

timeout value longer than RTT

bull but RTT varies 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

bull ignore retransmissions SampleRTT will vary want

estimated RTT ldquosmootherrdquobull average several recent

measurements not just current SampleRTT


EstimatedRTT = (1- α)EstimatedRTT + αSampleRTT

exponential weighted moving average influence of past sample decreases exponentially fast typical value α = 0125

TCP round trip time timeoutRT

T (m

illis

econ

ds)

RTT gaiacsumassedu to fantasiaeurecomfr

sampleRTT

EstimatedRTT

time (seconds)


timeout interval EstimatedRTT plus ldquosafety marginrdquo

bull large variation in EstimatedRTT -gt larger safety margin estimate SampleRTT deviation from EstimatedRTT DevRTT = (1-β)DevRTT +

β|SampleRTT-EstimatedRTT|

TCP round trip time timeout

(typically β = 025)

TimeoutInterval = EstimatedRTT + 4DevRTT

estimated RTT ldquosafety marginrdquo







data transfer





TCP reliable data transfer TCP creates rdt service

on top of IPrsquos unreliable service

bull pipelined segmentsbull cumulative acksbull single retransmission

timer retransmissions

triggered bybull timeout eventsbull duplicate acks

letrsquos initially consider simplified TCP sender

bull ignore duplicate acksbull ignore flow control

congestion control


TCP sender eventsdata rcvd from app create segment with

seq seq is byte-stream

number of first data byte in segment

start timer if not already running

bull think of timer as for oldest unacked segment

bull expiration interval TimeOutInterval

timeout retransmit segment

that caused timeout restart timer ack rcvd if ack acknowledges

previously unacked segments

bull update what is known to be ACKed

bull start timer if there are still unacked segments


TCP sender (simplified)

waitfor

event

NextSeqNum = InitialSeqNumSendBase = InitialSeqNum

Λ

create segment seq NextSeqNumpass segment to IP (ie ldquosendrdquo)NextSeqNum = NextSeqNum + length(data) if (timer currently not running) start timer

data received from application above

retransmit not-yet-acked segment with smallest seq

start timer

timeout

if (y gt SendBase) SendBase = y SendBasendash1 last cumulatively ACKed byte if (there are currently not-yet-acked segments) start timer else stop timer

ACK received with ACK field value y


TCP retransmission scenarios

lost ACK scenario

Host BHost A

Seq=92 8 bytes of data

ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100

Seq=92 8bytes of data

timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120


TCP ACK generation [RFC 1122 RFC 2581]

event at receiver

arrival of in-order segment withexpected seq All data up toexpected seq already ACKed

arrival of in-order segment withexpected seq One other segment has ACK pending

arrival of out-of-order segmenthigher-than-expect seq Gap detected

arrival of segment that partially or completely fills gap

TCP receiver action

delayed ACK Wait up to 500msfor next segment If no next segmentsend ACK

immediately send single cumulative ACK ACKing both in-order segments

immediately send duplicate ACK indicating seq of next expected byte

immediate send ACK provided thatsegment starts at lower end of gap


TCP fast retransmit time-out period

often relatively longbull long delay before

resending lost packet detect lost segments

via duplicate ACKsbull sender often sends

many segments back-to-back

bull if segment is lost there will likely be many duplicate ACKs

if sender receives 3 ACKs for same data(ldquotriple duplicate ACKsrdquo) resend unacked segment with smallest seq

likely that unacked segment lost so donrsquot wait for timeout

TCP fast retransmit


X

fast retransmit after sender receipt of triple duplicate ACK

Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer





TCP flow controlapplication

process

TCP socketreceiver buffers

TCPcode

IPcode

application

OS

receiver protocol stack

application may remove data from

TCP socket buffers hellip

hellip slower than TCP receiver is delivering(sender is sending)

from sender

receiver controls sender so sender wonrsquot overflow receiverrsquos buffer by transmitting too much too fast

flow control


TCP flow control

buffered data

free buffer spacerwnd

RcvBuffer

TCP segment payloads

to application process receiver ldquoadvertisesrdquo free

buffer space by including rwnd value in TCP header of receiver-to-sender segments

bull RcvBuffer size set via socket options (typical default is 4096 bytes)

bull many operating systems autoadjust RcvBuffer

sender limits amount of unacked (ldquoin-flightrdquo) data to receiverrsquos rwnd value

guarantees receive buffer will not overflow

receiver-side buffering






data transfer





Connection Managementbefore exchanging data senderreceiver ldquohandshakerdquo agree to establish connection (each knowing the other willing

to establish connection) agree on connection parameters

connection state ESTABconnection variables

seq client-to-server server-to-clientrcvBuffer size at serverclient

application

network

connection state ESTABconnection Variables


application

network

Socket clientSocket = newSocket(hostnameport

number)

Socket connectionSocket = welcomeSocketaccept()


Q will 2-way handshake always work in network

variable delays retransmitted messages

(eg req_conn(x)) due to message loss

message reordering canrsquot ldquoseerdquo other side

2-way handshake

Letrsquos talk

OKESTAB

ESTAB

choose x req_conn(x)ESTAB

ESTABacc_conn(x)

Agreeing to establish a connection


Agreeing to establish a connection2-way handshake failure scenarios

retransmitreq_conn(x)

ESTAB

req_conn(x)

half open connection(no client)

client terminates

serverforgets x

connection x completes


ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)

data(x+1) acceptdata(x+1)

connection x completes server

forgets x


TCP 3-way handshake

SYNbit=1 Seq=x

choose init seq num xsend TCP SYN msg

ESTAB

SYNbit=1 Seq=yACKbit=1 ACKnum=x+1

choose init seq num ysend TCP SYNACKmsg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x) indicates server is livesend ACK for SYNACK

this segment may contain client-to-server data

received ACK(y) indicates client is live

SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN


TCP 3-way handshake FSM

closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)


SYN(x)SYNACK(seq=yACKnum=x+1)

create new socket for communication back to client

SYNACK(seq=yACKnum=x+1)

ACK(ACKnum=y+1)ACK(ACKnum=y+1)

Λ


TCP closing a connection client server each close their side of connection

bull send TCP segment with FIN bit = 1 respond to received FIN with ACK

bull on receiving FIN ACK can be combined with own FIN simultaneous FIN exchanges can be handled


FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

ACKbit=1 ACKnum=x+1 wait for server

close

can stillsend data

can no longersend data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED

TCP closing a connection

FIN_WAIT_1 FINbit=1 seq=xcan no longersend but can receive data

clientSocketclose()

client state server state

ESTABESTAB






data transfer





congestion informally ldquotoo many sources sending too much

data too fast for network to handlerdquo different from flow control manifestations

bull lost packets (buffer overflow at routers)bull long delays (queueing in router buffers)

a top-10 problem

Principles of congestion control


Causescosts of congestion scenario 1

two senders two receivers

one router infinite buffers

output link capacity R no retransmission

maximum per-connection throughput R2

unlimited shared output link buffers

Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin

large delays as arrival rate λin approaches capacity


one router finite buffers sender retransmission of timed-out packet

bull application-layer input = application-layer output λin = λoutbull transport-layer input includes retransmissions λin λin

finite shared output link buffers

Host A

λin original data

Host B

λoutλin original data plus retransmitted data

lsquo



idealization perfect knowledge

sender sends only when router buffers available


λin original dataλoutλin original data plus

retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space

Idealization known loss packets can be lost dropped at router due to full buffers

sender only resends if packet known to be lost


A

Host B



retransmitted data

free buffer space

Causescosts of congestion scenario 2 Idealization known

loss packets can be lost dropped at router due to full buffers


R2

R2λin

λ out

when sending at R2 some packets are retransmissions but asymptotic goodput is still R2 (why)

A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out

when sending at R2 some packets are retransmissions including duplicated that are delivered

Host B

Realistic duplicates packets can be lost dropped

at router due to full buffers sender times out

prematurely sending two copies both of which are delivered



R2

λ out


ldquocostsrdquo of congestion more work (retrans) for given ldquogoodputrdquo unneeded retransmissions link carries multiple copies of

pktbull decreasing goodput

R2λin

Causescosts of congestion scenario 2 Realistic duplicates packets can be lost dropped




four senders multihop paths timeoutretransmit

Q what happens as λin and λinrsquo

increase


Host A λout


Host B

Host CHost D

λin original dataλin original data plus

retransmitted data

A as red λinrsquo increases all arriving

blue pkts at upper queue are dropped blue throughput rarr 0


another ldquocostrdquo of congestion when packet dropped any ldquoupstream

transmission capacity used for that packet was wasted

Causescosts of congestion scenario 3 C2

C2

λ out

λinrsquo






data transfer





TCP congestion control additive increase multiplicative decrease

approach sender increases transmission rate (window size) probing for usable bandwidth until loss occurs

bull additive increase increase cwnd by 1 MSS every RTT until loss detected

bull multiplicative decrease cut cwnd in half after loss cwnd

TC

P s

ende

r co

nges

tion

win

dow

siz

e

AIMD saw toothbehavior probing

for bandwidth

additively increase window size helliphellip until loss occurs (then cut window in half)

time


TCP Congestion Control details

sender limits transmission

cwnd is dynamic function of perceived network congestion

TCP sending rate roughly send cwnd

bytes wait RTT for ACKS then send more bytes

last byteACKed sent

not-yet ACKed(ldquoin-flightrdquo)

last byte sent

cwnd

LastByteSent-LastByteAcked

lt cwnd


rate ~~cwndRTT

bytessec


TCP Slow Start when connection begins

increase rate exponentially until first loss event

bull initially cwnd = 1 MSSbull double cwnd every RTTbull done by incrementing cwnd for every ACK received

summary initial rate is slow but ramps up exponentially fast

Host A

one segment

RTT

Host B

time

two segments

four segments


TCP detecting reacting to loss loss indicated by timeout

bullcwnd set to 1 MSS bull window then grows exponentially (as in slow start)

to threshold then grows linearly loss indicated by 3 duplicate ACKs TCP RENO

bull dup ACKs indicate network capable of delivering some segments

bullcwnd is cut in half window then grows linearly TCP Tahoe always sets cwnd to 1 (timeout or 3

duplicate acks)


Q when should the exponential increase switch to linear

A when cwnd gets to 12 of its value before timeout

Implementation variable ssthresh on loss event ssthresh

is set to 12 of cwnd just before loss event

TCP switching from slow start to CA



Summary TCP Congestion Control

timeoutssthresh = cwnd2

cwnd = 1 MSSdupACKcount = 0

retransmit missing segment

Λcwnd gt ssthresh

congestionavoidance

cwnd = cwnd + MSS (MSScwnd)dupACKcount = 0

transmit new segment(s) as allowed

new ACK

dupACKcount++

duplicate ACK

fastrecovery

cwnd = cwnd + MSStransmit new segment(s) as allowed

duplicate ACK

ssthresh= cwnd2cwnd = ssthresh + 3


dupACKcount == 3

timeoutssthresh = cwnd2cwnd = 1 dupACKcount = 0retransmit missing segment

ssthresh= cwnd2cwnd = ssthresh + 3retransmit missing segment

dupACKcount == 3cwnd = ssthreshdupACKcount = 0

New ACK

slow start




cwnd = cwnd+MSSdupACKcount = 0transmit new segment(s) as allowed

new ACKdupACKcount++

duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KBdupACKcount = 0

NewACK

NewACK

NewACK


TCP throughput avg TCP thruput as function of window size RTT

bull ignore slow start assume always data to send W window size (measured in bytes) where loss occurs

bull avg window size ( in-flight bytes) is frac34 Wbull avg thruput is 34W per RTT

W

W2

avg TCP thruput = 34WRTT bytessec


TCP Futures TCP over ldquolong fat pipesrdquo

example 1500 byte segments 100ms RTT want 10 Gbps throughput

requires W = 83333 in-flight segments throughput in terms of segment loss probability

L [Mathis 1997]

to achieve 10 Gbps throughput need a loss rate of L = 210-10 ndash a very small loss rate

new versions of TCP for high-speed

TCP throughput = 122 MSSRTT L


fairness goal if K TCP sessions share same bottleneck link of bandwidth R each should have average rate of RK

TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2


Why is TCP fairtwo competing sessions additive increase gives slope of 1 as throughout increases multiplicative decrease decreases throughput proportionally

R

R

equal bandwidth share

Connection 1 throughput

Con

nect

ion

2 th

roug

hput

congestion avoidance additive increaseloss decrease window by factor of 2



Fairness (more)Fairness and UDP multimedia apps

often do not use TCPbull do not want rate

throttled by congestion control

instead use UDPbull send audiovideo at

constant rate tolerate packet loss

Fairness parallel TCP connections

application can open multiple parallel connections between two hosts

web browsers do this eg link of rate R with 9

existing connectionsbull new app asks for 1 TCP gets

rate R10bull new app asks for 11 TCPs gets

R2


network-assisted congestion control two bits in IP header (ToS field) marked by network

router to indicate congestion congestion indication carried to receiving host receiver (seeing congestion indication in IP datagram) )

sets ECE bit on receiver-to-sender ACK segment to notify sender of congestion

Explicit Congestion Notification (ECN)

sourceapplication

transportnetwork

linkphysical

destinationapplicationtransportnetwork

linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment


Chapter 3 summary principles behind

transport layer servicesbull multiplexing

demultiplexingbull reliable data transferbull flow controlbull congestion control

instantiation implementation in the Internet

bull UDPbull TCP

next leaving the

network ldquoedgerdquo (application transport layers)

into the network ldquocorerdquo

two network layer chapters

bull data planebull control plane

Transport Layer 3-2

Chapter 3 Transport Layerour goals understand

principles behind transport layer services

bull multiplexing demultiplexing

bull reliable data transferbull flow controlbull congestion control

learn about Internet transport layer protocols

bull UDP connectionless transport

bull TCP connection-oriented reliable transport

bull TCP congestion control

Transport Layer 3-3





data transfer




Transport Layer 3-4










Transport Layer 3-5










household analogy

Transport Layer 3-6
















Transport Layer 3-7





data transfer




Transport Layer 3-8


process

socket




transport

application

physical

link

network

P2P1

transport

application

physical

link

network

P4

transport

application

physical

link

network

P3

Transport Layer 3-9








32 bits

applicationdata

(payload)

other header fields













(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the





Transport Layer 3-3





data transfer




Transport Layer 3-4










Transport Layer 3-5










household analogy

Transport Layer 3-6
















Transport Layer 3-7





data transfer




Transport Layer 3-8


process

socket




transport

application

physical

link

network

P2P1

transport

application

physical

link

network

P4

transport

application

physical

link

network

P3

Transport Layer 3-9








32 bits

applicationdata

(payload)

other header fields













(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the





Transport Layer 3-4










Transport Layer 3-5










household analogy

Transport Layer 3-6
















Transport Layer 3-7





data transfer




Transport Layer 3-8


process

socket




transport

application

physical

link

network

P2P1

transport

application

physical

link

network

P4

transport

application

physical

link

network

P3

Transport Layer 3-9








32 bits

applicationdata

(payload)

other header fields













(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the





Transport Layer 3-5










household analogy

Transport Layer 3-6
















Transport Layer 3-7





data transfer




Transport Layer 3-8


process

socket




transport

application

physical

link

network

P2P1

transport

application

physical

link

network

P4

transport

application

physical

link

network

P3

Transport Layer 3-9








32 bits

applicationdata

(payload)

other header fields













(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the





Transport Layer 3-6
















Transport Layer 3-7





data transfer




Transport Layer 3-8


process

socket




transport

application

physical

link

network

P2P1

transport

application

physical

link

network

P4

transport

application

physical

link

network

P3

Transport Layer 3-9








32 bits

applicationdata

(payload)

other header fields













(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the





Transport Layer 3-7





data transfer




Transport Layer 3-8


process

socket




transport

application

physical

link

network

P2P1

transport

application

physical

link

network

P4

transport

application

physical

link

network

P3

Transport Layer 3-9








32 bits

applicationdata

(payload)

other header fields













(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the





Transport Layer 3-8


process

socket




transport

application

physical

link

network

P2P1

transport

application

physical

link

network

P4

transport

application

physical

link

network

P3

Transport Layer 3-9








32 bits

applicationdata

(payload)

other header fields













(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the





Transport Layer 3-9








32 bits

applicationdata

(payload)

other header fields













(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the
















(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the







(6428)

transport

application

physical

link

network

P3transport

application

physical

link

network

P1

transport

application

physical

link

network

P4

















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the















transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the







transport

application

physical

link

network

P3transport

application

physical

link

P4

transport

application

physical

link

network

P2



address Ahost IP

address C

network

P6P5P3




server IP address B



transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the







transport

application

physical

link

network

P3transport

application

physical

link

transport

application

physical

link

network

P2



address Ahost IP

address C

server IP address B

network

P3



P4

threaded server






data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the










data transfer









app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the










app connectionless





DNS SNMP





UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the






UDP segment header


32 bits

applicationdata

(payload)

UDP segment format

length checksum


including header





why is there a UDP


UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the






UDP checksum












1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the







1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 01 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1

1 1 0 1 1 1 0 1 1 1 0 1 1 1 1 0 01 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1

wraparound

sumchecksum








data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the










data transfer


















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the



















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the















sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the











sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the







sendside

receiveside










receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the









receiver

state1

state2




eventactions







udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the










udt_send(packet)


Wait for call from

below

rdt_rcv(packet)

sender receiver







rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the











rcvr-gtsender








rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the











rcvr-gtsender



during conversation







sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the











sender









udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the












udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

belowsender


Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the












udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the












udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

Wait for call from

below

rdt_send(data)

Λ














above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the


















above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the








above


rdt_send(data)




rdt_send(data)


udt_send(sndpkt)




above


ΛΛ


















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the






















rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the






rdt21 discussion


















above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the














above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the








above


rdt_send(data)

udt_send(sndpkt)



Wait for ACK

0sender FSMfragment





fragment

Λ













rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the

















rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the







rdt_send(data)

Wait for

ACK0



above


rdt_send(data)






timeout


timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

Wait for

ACK1

Λrdt_rcv(rcvpkt)

ΛΛ

Λ


sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the






sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

pkt1

ack1

ack0

ack0

(a) no loss

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(b) packet loss

pkt1X

loss


rdt30 in action


rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the






rdt30 in action

rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

rcv pkt0

send ack0

send ack1

send ack0

rcv ack0

send pkt0

send pkt1

rcv ack1

send pkt0rcv pkt0

pkt0

pkt0

ack1

ack0

ack0

(c) ACK loss

ack1X

loss


rcv pkt1send ack1

(detect duplicate)

pkt1

sender receiver

rcv pkt1

send ack0rcv ack0

send pkt1

send pkt0rcv pkt0

pkt0

ack0



ack1

send ack1

send pkt0rcv ack1

pkt0

ack1

ack0



rcv pkt0







Dtrans =LR





sender receiver

RTT





Pipelined protocols







sender receiver

RTT






















window




timeout

rdt_send(data)




base=1nextseqnum=1


Λ





Wait





Λ



GBN in action


(wait)

sender receiver


rcv ack1 send pkt5


Xloss




0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8










Selective repeat







receiver




(wait)

sender receiver


rcv ack1 send pkt5


Xloss



record ack3 arrived

0 1 2 3 4 5 6 7 8

sender window (N=4)

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8

record ack4 arrived

record ack5 arrived






0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2 pkt0


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2XXX


0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

pkt0

pkt1

pkt2

0 1 2 3 0 1 2pkt0

0 1 2 3 0 1 2

0 1 2 3 0 1 2

0 1 2 3 0 1 2

X


0 1 2 3 0 1 2 pkt3

(a) no problem











data transfer











receiver








32 bits

applicationdata

(variable length)


receive window


lennot

used



ACK ACK valid



commands)



Internetchecksum

(as in UDP)







checksum

rwndurg pointer


A

sent ACKed



not usable

window size N




checksum

rwndurg pointer




Usertypes

lsquoCrsquo

host ACKsreceipt




Host BHost A



Seq=43 ACK=80
















T (m

illis

econ

ds)


sampleRTT

EstimatedRTT

time (seconds)















data transfer












congestion control















waitfor

event


Λ




start timer

timeout





lost ACK scenario

Host BHost A


ACK=100


Xtimeo

ut

ACK=100

premature timeout

Host BHost A


ACK=100


timeo

ut

ACK=120


ACK=120

SendBase=100

SendBase=120

SendBase=120

SendBase=92



X

cumulative ACK

Host BHost A


ACK=100


timeo ut


ACK=120



event at receiver





TCP receiver action














TCP fast retransmit


X


Host BHost A


ACK=100

timeo

ut

ACK=100

ACK=100

ACK=100

TCP fast retransmit








data transfer






process


TCPcode

IPcode

application

OS





from sender


flow control


TCP flow control

buffered data


RcvBuffer














data transfer









application

network



application

network


number)







2-way handshake

Letrsquos talk

OKESTAB

ESTAB


ESTABacc_conn(x)





ESTAB

req_conn(x)


client terminates

serverforgets x



ESTAB

req_conn(x)

data(x+1)

retransmitdata(x+1)

acceptdata(x+1)

choose xreq_conn(x)

ESTAB

ESTAB

acc_conn(x)

client terminates

ESTAB

choose xreq_conn(x)

ESTAB

acc_conn(x)



forgets x


TCP 3-way handshake

SYNbit=1 Seq=x


ESTAB



ACKbit=1 ACKnum=y+1




SYNSENT

ESTAB

SYN RCVD

client state

LISTEN

server state

LISTEN



closed

Λ

listen

SYNrcvd

SYNsent

ESTAB


number)

SYN(seq=x)






Λ






FIN_WAIT_2

CLOSE_WAIT

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1


close

can stillsend data


LAST_ACK

CLOSED

TIMED_WAIT

timed wait for 2max

segment lifetime

CLOSED



clientSocketclose()


ESTABESTAB






data transfer








a top-10 problem









Host A

original data λin

Host B

throughput λout

R2

R2

λ out

λin R2de

lay

λin






Host A

λin original data

Host B


lsquo







retransmitted data

copy

free buffer space

R2

R2

λ out

λin


Host B

A



retransmitted data

copy

no buffer space




A

Host B



retransmitted data

free buffer space




R2

R2λin

λ out


A

Host B


A

λin λoutλincopy

free buffer space

timeout

R2

R2λin

λ out


Host B






R2

λ out




R2λin







increase


Host A λout


Host B

Host CHost D


retransmitted data







C2

λ out

λinrsquo






data transfer









TC

P s

ende

r co

nges

tion

win

dow

siz

e


for bandwidth


time







last byteACKed sent


last byte sent

cwnd


lt cwnd


rate ~~cwndRTT

bytessec






Host A

one segment

RTT

Host B

time

two segments

four segments







duplicate acks)













Λcwnd gt ssthresh

congestionavoidance



new ACK

dupACKcount++

duplicate ACK

fastrecovery


duplicate ACK



dupACKcount == 3




New ACK

slow start






duplicate ACK

Λcwnd = 1 MSS


NewACK

NewACK

NewACK





W

W2






L [Mathis 1997]






TCP connection 1

bottleneckrouter

capacity R

TCP Fairness

TCP connection 2



R

R



Con

nect

ion

2 th

roug

hput














R2






sourceapplication

transportnetwork

linkphysical


linkphysical

ECN=11

ECN=00 ECN=11

ECE=1

IP datagram

TCP ACK segment






bull UDPbull TCP

next leaving the





Documents

Chapter 3 Down Approach Transport Layer - Brock University