transport layer chapter 3 architecture transport layer

Chapter 3Transport Layer

Transport Layer 3-1

Transport Layer

Central piece of the layered network architecture

Provides communications services to applications

process

socket

host orserver

process

socket

host orserver

applicationapplicationmsg

msg

Transport Layer 3-2

helliprelying on the service of the network layer

TCP withbuffersvariables

TCP withbuffersvariables

Internet

transportnetworkdata linkphysical

transportnetworkdata linkphysical

Transport Layer

Central piece of the layered network architecture

Provides communications services to applications

process

socket

host orserver

process

socket

host orserver

application application

Transport Layer 3-3

helliprelying on the service of the network layer

socket

Internetnetworkdata linkphysical

networkdata linkphysical

transport transportmsgTH

msg TH

Best effort routing of datagrams from sender to destination host

Transport Layer

Transport entities run in end systems

send side breaks app messages into segments passes to network layer

rcv side reassembles

process

socket

host orserver

process

socket

host orserver

application applicationmsg

msg

msg

Transport Layer 3-4

rcv side reassembles segments into messages passes to app layer

Extends host to host datagram delivery to app to app message transfer

socket

Internetnetworkdata linkphysical


transport transport

Best effort routing of datagrams from sender to destination host

mTHgTH sTHmTH sTHgTH

msgmsg

Internet transport-layer protocols

reliable in-order delivery (TCP)

congestion control

flow control

connection setup

applicationtransportnetworkdata linkphysical

networkdata link


networkdata linkphysicalnetwork

data linkphysical

Transport Layer 3-5

connection setup

unreliable unordered delivery UDP

no-frills extension of ldquobest-effortrdquo IP

services not available delay guarantees

bandwidth guarantees



data linkphysical

Multiplexingdemultiplexing

= process= socket

delivering received segmentsto correct socket

Demultiplexing at rcv hostgathering data from multiplesockets enveloping data with header (later used for demultiplexing)

Multiplexing at send host

Transport Layer 3-6

application

transport

network

link

physical

P1 application

transport

network

link

physical

application

transport

network

link

physical

P2P3 P4P1

host 1 host 2 host 3

transport

How demultiplexing works

host receives IP datagrams

each datagram has source IP address destination IP address (in the network layer header)

each datagram carries 1

Source IP addr

Dest IP addr

Source port

Dest portTransport Layer

Network Layer

Header

Segm

ent

Datagram ndash Network Layer PDU

Transport Layer 3-7

each datagram carries 1 transport-layer segment

each segment has source destination port number (in the transport layer header)

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

message

Transport Layer

Header

Application Layer

Message

Segm

ent ndash

Tran

sport L

ayer PD

U

Connectionless demultiplexing

Create sockets with port numbers

DatagramSocket mySocket1 = new DatagramSocket(9911)


When host receives UDP segment

checks destination port number in segment

directs UDP segment to socket with that port

Transport Layer 3-8

DatagramSocket(9922)

UDP socket identified by two-tuple

(IP address port number)

socket with that port number

IP datagrams with different source IP addresses andor source port but same destination port are directed to same socket

Connectionless demux (cont)

P3 P1P1P3 P4A2145 C6428 C7527 B9825

A C

B C

Transport Layer 3-9

ClientIPB

clientIP A

serverIP C

msg

2145 6428

msg

A C

2145 7527

msg

B C

9825 7527

Connection-oriented demux

TCP socket identified by 4-tuple

source IP address

source port number

dest IP address

Server host may support many simultaneous TCP sockets

each socket identified by its own 4-tuple

Transport Layer 3-10

dest IP address

dest port number

recv host uses all four values to direct segment to appropriate socket

Web servers have different sockets for each connecting client

non-persistent HTTP will have different socket for each request

Connection-oriented demux (cont)

P3 P1P1P3C80

B9825

A C

B C

A2145C80

C80A2145

B9825C80


ClientIPB

clientIP A

serverIP C

msg

2145 80

msg

B C

9825 80

UDP User Datagram Protocol [RFC 768]

ldquono frillsrdquo ldquobare bonesrdquo Internet transport protocol

ldquobest effortrdquo service UDP segments may be

lost

delivered out of order

Why is there a UDP no connection

establishment (which can add delay)

simple no connection state



to bare IP service UDP adds Muxdemux

checksum

connectionless

no handshaking between UDP sender receiver

each UDP segment handled independently of others

simple no connection state at sender receiver

small segment header

no congestion control UDP can blast away as fast as desired

UDP more

often used for streaming multimedia apps

loss tolerant

rate sensitive

other UDP uses

source port dest port

32 bits

length checksumLength in

bytes of UDPsegmentincludingheader


DNS

SNMP

reliable transfer over UDP add reliability at application layer

application-specific error recovery

Applicationdata

(message)

UDP segment format

header

UDP checksum

Sender treat segment contents

as sequence of 16-bit

Receiver compute checksum of

received segment

Goal detect ldquoerrorsrdquo (eg flipped bits) in transmitted segment


as sequence of 16-bit integers

checksum addition (1rsquos complement sum) of segment contents

sender puts checksum value into UDP checksum field

received segment

check if computed checksum equals checksum field value

NO - error detected

YES - no error detected But maybe errors nonetheless More later hellip

Internet checksum example

example add two 16-bit integers

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

1 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 1wraparound


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 0

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

wraparound

sum

checksum

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

Principles of Reliable data transfer

important in app transport link layers top-10 list of important networking topics


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

Reliable data transfer getting started

send receive

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

deliver_data() called by rdt to deliver data to upper


sendside

receiveside

udt_send() called by rdtto transfer packet over

unreliable channel to receiver

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


Wersquoll

incrementally develop sender receiver sides of reliable data transfer protocol (rdt)

consider only unidirectional data transfer but control info will flow on both directions


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 reliable no bit errors

no loss of packets

separate FSMs for sender receiver sender sends data into underlying channel


sender sends data into underlying channel

receiver read 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

Rdt20 channel with bit errors

underlying channel may flip bits in packet recall UDP checksum to detect bit errors

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

that pkt received OK



negative acknowledgements (NAKs) receiver explicitly tells sender that pkt had errors

sender retransmits pkt on receipt of NAK

new mechanisms in rdt20 (beyond rdt10) error detection

receiver feedback control msgs (ACKNAK) rcvr-gtsender

rdt20 FSM specification

Wait for call from above

sndpkt = make_pkt(data checksum)udt_send(sndpkt)

udt_send(sndpkt)

rdt_rcv(rcvpkt) ampampisNAK(rcvpkt)

udt_send(NAK)

rdt_rcv(rcvpkt) ampamp corrupt(rcvpkt)

Wait for ACK or

NAK

receiverrdt_send(data)


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

rdt_rcv(rcvpkt) ampamp notcorrupt(rcvpkt)

rdt_rcv(rcvpkt) ampamp isACK(rcvpkt)Wait for call from

belowsender

Λ

rdt20 operation with no errors


snkpkt = make_pkt(data checksum)udt_send(sndpkt)

udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ

rdt20 error scenario



udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ

rdt20 has a fatal flaw

What happens if ACKNAK corrupted

sender doesnrsquot know what happened at receiver

What to do

Handling duplicates sender adds sequence

number to each pkt

sender retransmits current pkt if ACKNAK garbled

receiver discards (doesnrsquot


What to do sender ACKsNAKs

receiverrsquos ACKNAK What if sender ACKNAK lost

retransmit but this might cause retransmission of correctly received pkt

receiver discards (doesnrsquot deliver up) duplicate pkt

Sender sends one packet then waits for receiver response

stop and wait

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_rcv(rcvpkt) rdt_rcv(rcvpkt) ampamp notcorrupt(rcvpkt)



rdt_send(data)

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

udt_send(sndpkt)


ampamp notcorrupt(rcvpkt) ampamp isACK(rcvpkt)

Wait forcall 1 from

above

Wait for ACK or NAK 1

ΛΛ

rdt21 receiver handles garbled ACKNAKs

sndpkt = make_pkt(NAK chksum)udt_send(sndpkt)

rdt_rcv(rcvpkt) ampamp notcorrupt(rcvpkt) ampamp has_seq0(rcvpkt)

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

rdt_rcv(rcvpkt) ampamp (corrupt(rcvpkt)rdt_rcv(rcvpkt) ampamp (corrupt(rcvpkt)



Wait for 0 from below

udt_send(sndpkt)

rdt_rcv(rcvpkt) ampamp not corrupt(rcvpkt) ampamphas_seq0(rcvpkt)




sndpkt = make_pkt(ACK chksum)udt_send(sndpkt)



rdt21 discussion

Sender

seq added to pkt

two seq rsquos (01) will suffice Why

must check if received

Receiver

must check if received packet is duplicate

state indicates whether 0 or 1 is expected pkt


must check if received ACKNAK corrupted

twice as many states state must ldquorememberrdquo

whether ldquocurrentrdquo pkt has 0 or 1 seq

0 or 1 is expected pkt seq

note receiver can notknow 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 OK

receiver must explicitly include seq of pkt being ACKed

duplicate ACK at sender results in same action as


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)

Wait for ACK

0

sender FSMfragment


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

fragment



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 FSMfragment

Λ

rdt30 channels with errors and loss

New assumptionunderlying channel can also lose packets (data or ACKs)

checksum seq ACKs

Approach sender waits ldquoreasonablerdquo amount of time for ACK

retransmits if no ACK received in this time


checksum seq ACKs retransmissions will be of help but not enough

Q how to deal with loss sender waits until

certain data or ACK lost then retransmits

yuck drawbacks

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

retransmission will be duplicate but use of seq rsquos already handles this

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



udt_send(sndpkt)start_timer

timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

ΛΛ



above

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

rdt_send(data)

ampamp notcorrupt(rcvpkt) ampamp isACK(rcvpkt0)


ampamp isACK(rcvpkt1)

stop_timerstop_timer


timeoutWait for

ACK1

Λrdt_rcv(rcvpkt)

Λ

rdt30 in action


rdt30 in action


Performance of rdt30

rdt30 works but performance stinks

example 1 Gbps link 15 ms e-e prop delay 1KB packet

Ttransmit =

8kbpkt109 bsec

= 8 microsecL (packet length in bits)R (transmission rate bps)

=


109 bsec

U sender utilization ndash fraction of time sender busy sending

1KB pkt every 30 msec -gt 267kbps thruput over 1 Gbps link

network protocol limits use of physical resources

U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

R (transmission rate bps)

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

U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols

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

range of sequence numbers must be increased

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

first packet bit arriveslast packet bit arrives send ACKlast bit of 2nd packet arrives send ACKlast bit of 3rd packet arrives send ACK



last bit of 3rd packet arrives send ACK

U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

Increase utilizationby a factor of 3

Pipelining Protocols

Go-back-N big picture Sender can have up to

N unacked packets in pipeline

Rcvr only sends cumulative acks

Selective Repeat big pic Sender can have up to


Rcvr acks individual packets



Doesnrsquot ack packet if therersquos a gap

Sender has timer for oldest unacked packet

If timer expires retransmit all unacked packets


Sender maintains timer for each unacked packet

When timer expires retransmit only unack packet

Go-Back-N

Trasmit multiple packets (up to N) without waiting for ACK

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

may receive duplicate ACKs (see receiver)

timeout(n) retransmit pkt n and all higher seq pkts in window

GBN sender extended FSM (1 timer)rdt_send(data)

if (nextseqnum lt base+N) sndpkt[nextseqnum] = make_pkt(nextseqnumdatachksum)udt_send(sndpkt[nextseqnum])if (base == nextseqnum)

start_timernextseqnum++

elserefuse_data(data)

base=1

Λ


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

timeout

base = getacknum(rcvpkt)+1If (base == nextseqnum)

stop_timerelsestart_timer


base=1nextseqnum=1


Λ

GBN receiver extended FSM

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(0ACKchksum)

Λ


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

may generate duplicate ACKs

need only remember expectedseqnum

out-of-order pkt discard (donrsquot buffer) -gt no receiver buffering

Re-ACK pkt with highest in-order seq

GBN inaction


Selective Repeat

receiver individually acknowledges all correctly received pkts

buffers pkts as needed for eventual in-order delivery to upper layer

sender only resends pkts for which ACK not received



sender timer for each unACKed pkt

sender window N consecutive seq rsquos

again limits seq s of sent unACKed pkts

Selective repeat sender receiver windows


Selective repeat

data from above if next available seq in

window send pkt

timeout(n) resend pkt n restart timer

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

receiver


resend pkt n restart timer

ACK(n) in [sendbasesendbase+N] mark pkt n as received

if n smallest unACKed pkt advance window base to next unACKed seq

pkts) advance window to next not-yet-received pkt

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

otherwise ignore

Selective repeat in action


Selective repeatdilemma

Example seq rsquos 0 1 2 3

window size=3

receiver sees no


receiver sees no difference in two scenarios

incorrectly passes duplicate data as new in (a)

Q what relationship between seq size and window size

TCP Overview RFCs 793 1122 1323 2018 2581

full duplex data bi-directional data flow

in same connection

MSS maximum segment size

connection-oriented

point-to-point one sender one receiver

reliable in-order byte steam

no ldquomessage boundariesrdquo


connection-oriented handshaking (exchange

of control msgs) initrsquos sender receiver state before data exchange

flow controlled sender will not

overwhelm receiver


pipelined TCP congestion and flow

control set window size

send amp receive buffers

socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment

applicationwrites data

applicationreads data

TCP segment structure


32 bits

sequence number

acknowledgement number

Receive window

Urg data pnterchecksum

FSRPAUheadlen

notused

URG urgent data (generally not used)

ACK ACK valid

PSH push data now(generally not used) bytes

rcvr willing

countingby bytes of data(not segments)


applicationdata

(variable length)


Options (variable length)RST SYN FINconnection estab(setup teardown

commands)

rcvr willingto accept

Internetchecksum

(as in UDP)

Sequence and Acknowledgement Numbers

TCP views data as unstructured but ordered data

In a segment

Sequence number is the byte-stream number of the first byte in the segment

Initial sequence number is randomly chosen



Ack number is the number of the next byte expected from the other side

TCP uses cumulative acknowledgements

Q how receiver handles out-of-order segments

A TCP spec doesnrsquot say - up to implementor

TCP seq numbers ACKs

sequence numbers

byte stream ldquonumberrdquoof first byte in segmentrsquos data

acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer

outgoing segment from sender


seq of next byte expected from other side

cumulative ACK




sequence number


checksum

rwndurg pointer

incoming segment to sender

A

sent

ACKed

sent not-yet ACKed

(ldquoin-flightrdquo)

usable

but not

yet sent

not

usable

sender sequence number space

TCP seq rsquos and ACKs

Host A Host B

UsertypeslsquoCrsquo

host ACKsreceipt oflsquoCrsquo echoesback lsquoCrsquo


host ACKsreceipt of echoed

lsquoCrsquo

back lsquoCrsquo

timesimple telnet scenario

TCP reliable data transfer

TCP creates rdt service on top of IPrsquos unreliable service

Pipelined segments

Cumulative acks

Retransmissions are triggered by

timeout events

duplicate acks

Initially consider


Cumulative acks

TCP should use a single retransmission timer

Initially consider simplified TCP sender

ignore duplicate acks

ignore flow control congestion control

TCP sender events

data rcvd from app

Create segment with seq

seq is byte-stream number of first data

timeout

retransmit segment that caused timeout

restart timer

Ack rcvd


number of first data byte in segment

start timer for that segment

expiration interval TimeOutInterval

Ack rcvd

If acknowledges previously unacked segments

update what is known to be acked

TCP sender(simplified)

NextSeqNum = InitialSeqNumSendBase = InitialSeqNum

loop (forever) switch(event)

event data received from application above create TCP segment with sequence number NextSeqNum if (timer currently not running)

start timerpass segment to IP NextSeqNum = NextSeqNum + length(data) break


breakevent timer timeout

retransmit not-yet acked segment with smallest sequence number

start timer break

event ACK received with ACK field value of y if (y gt SendBase)

Sendbase=yif( there are currently any not yet acked segment)

start timerbreak

end of loop forever

TCP sender (simplified)

wait

for NextSeqNum = InitialSeqNum

SendBase = InitialSeqNum

Λ

create segment seq NextSeqNum

pass segment to IP (ie ldquosendrdquo)

NextSeqNum = NextSeqNum + length(data)

if (timer currently not running)

start timer

data received from application above


eventSendBase = InitialSeqNum

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 scenariosHost A Host B

Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout


timepremature timeout

Seq=9

2 t

imeout

loss

lost ACK scenariotime

Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100

TCP retransmission scenarios (more)

Host A

loss

tim

eout

Host B

X


loss

Cumulative ACK scenariotime

SendBase= 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 with

TCP Receiver action

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

Immediately send single cumulative


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

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

Fast Retransmit

Time-out period often relatively long

long delay before resending lost packet

Detect lost segments

If sender receives 3 ACKs for the same data it supposes that segment after ACKed data was lost


Detect lost segments via duplicate ACKs

Sender often sends many segments back-to-back

If segment is lost there will likely be many duplicate ACKs

data was lost fast retransmit resend

segment before timer expires



start timer

Fast retransmit algorithm


else

increment count of dup ACKs received for yif (count of dup ACKs received for y = 3)

resend segment with sequence number y

break

a duplicate ACK for already ACKed segment

fast retransmit

X

Host BHost A

Seq=92 8 bytes of data

TCP fast retransmit



fast retransmit after sender

receipt of triple duplicate ACK

ACK=100

timeout

ACK=100

ACK=100

ACK=100


TCP Round Trip Time and Timeout

Q how to set TCP timeout value

longer than RTT but RTT varies

too short premature timeout

Q how to estimate RTT SampleRTT measured time from

segment transmission until ACK receipt

ignore retransmitted segments



unnecessary retransmissions

too long slow reaction to segment loss

segments

SampleRTT will vary want estimated RTT ldquosmootherrdquo

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


Example RTT estimationRTT gaiacsumassedu to fantasiaeurecomfr

250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)

SampleRTT Estimated RTT


Setting the timeout EstimtedRTT plus ldquosafety marginrdquo

large variation in EstimatedRTT -gt larger safety margin

first estimate of how much SampleRTT deviates from EstimatedRTT


EstimatedRTT

TimeoutInterval = EstimatedRTT + 4DevRTT

DevRTT = (1-ββββ)DevRTT +ββββ|SampleRTT-EstimatedRTT|

(typically ββββ = 025)

Then set timeout interval

TCP flow controlapplication

process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from

TCP socket buffers hellip

hellip slower than TCP

receiver is delivering

(sender is sending)


code

IP

code

receiver protocol stack

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 space

RcvBuffer

to application process receiver ldquoadvertisesrdquo

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


free buffer spacerwnd

TCP segment payloads

to-sender segments RcvBuffer size set via

socket options (typical default is 4096 bytes)

many operating systems autoadjust RcvBuffer

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

guarantees receive

receiver-side buffering

TCP Connection Management

Recall TCP sender receiver establish ldquoconnectionrdquo before exchanging data segments

initialize TCP variables

seq s

buffers flow control info (eg RcvWindow)



client connection initiatorSocket clientSocket = new Socket(hostnameport

number)

server contacted by clientSocket connectionSocket = welcomeSocketaccept()

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

establish connection)

agree on connection parameters



connection state ESTAB

connection variables

seq client-to-server

server-to-client

rcvBuffer size

at serverclient network


connection Variables


server-to-client

rcvBuffer size


Q will 2-way handshake always work in network

variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB

Agreeing to establish a connection


variable delays

retransmitted messages (eg req_conn(x)) due to message loss

message reordering

canrsquot ldquoseerdquo other side

ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)


2-way handshake failure scenarios

retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)

half open connection

(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates

ESTABdata(x+1) accept

data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x

choose init seq num x

send TCP SYN msg

choose init seq num y

send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)

indicates server is live

send ACK for SYNACK

this segment may contain

client-to-server data

received ACK(y)

indicates client is live

ESTAB

SYN RCVD

TCP 3-way handshake FSM

closed

ΛSocket clientSocket =

newSocket(hostnameport number)

SYN(seq=x)

Socket connectionSocket = welcomeSocketaccept()

SYN(x)

SYNACK(seq=yACKnum=x+1)


listen

SYN

rcvd

SYN

sent

ESTAB

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

create new socket for

communication back to client


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

Λ

TCP closing a connection

client server each close their side of connection send TCP segment with FIN bit = 1

respond to received FIN with ACK on receiving FIN ACK can be combined with


on receiving FIN ACK can be combined with own FIN

simultaneous FIN exchanges can be handled

FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1

wait for servercan still


FIN_WAIT_1 FINbit=1 seq=xcan no longer

send but can

receive data

clientSocketclose()

client state server state

ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED

Principles of Congestion Control

Congestion informally ldquotoo many sources sending too much

data too fast for network to handlerdquo

different from flow control

manifestations


manifestations

lost packets (buffer overflow at routers)

long delays (queueing in router buffers)

a top-10 problem

Causescosts of congestion scenario 1

two senders two receivers

one router infinite buffers

no retransmission

unlimited shared output link buffers

Host Aλin original data

Host B

λout


no retransmission

large delays when congested

maximum achievable throughput


one router finite buffers

sender retransmission of lost packet


λout

λ original data plus


finite shared output link buffersHost B

λin original data plus retransmitted data

idealization perfect knowledge

sender sends only when router buffers available

R2

R2

λ out

λin



finite shared output link buffers

λin original data

λoutλin original data plusretransmitted data

copy

free buffer space

Host B

A

Idealization known

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

sender only resends if packet known to be lost



λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out

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


λin original data


free buffer spaceA

Host B

R2

R2λin

λ out

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

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



A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin


Realistic duplicates packets can be lost dropped at router due to full buffers



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

copies of pktdecreasing goodput


four senders

multihop paths

timeoutretransmit

λin

Q what happens as and increase λ

in

Host Aλin original data λout




Host B


Host A

Host B

λou

t


Another ldquocostrdquo of congestion

when packet dropped any ldquoupstream transmission capacity used for that packet was wasted

Approaches towards congestion control

End-end congestion control

no explicit feedback from network

Network-assisted congestion control

routers provide feedback to end systems

Two broad approaches towards congestion control


network

congestion inferred from end-system observed loss delay

approach taken by TCP

to end systems

single bit indicating congestion (SNA DECbit TCPIP ECN ATM)

explicit rate sender should send at

Case study ATM ABR congestion control

ABR available bit rate ldquoelastic servicerdquo

if senderrsquos path ldquounderloadedrdquo

sender should use available bandwidth

RM (resource management) cells

sent by sender interspersed with data cells

bits in RM cell set by switches (ldquonetwork-assistedrdquo)


available bandwidth

if senderrsquos path congested

sender throttled to minimum guaranteed rate

(ldquonetwork-assistedrdquo)

NI bit no increase in rate (mild congestion)

CI bit congestion indication

RM cells returned to sender by receiver with bits intact



two-byte ER (explicit rate) field in RM cell congested switch may lower ER value in cell

senderrsquo send rate thus maximum supportable rate on path

EFCI bit in data cells set to 1 in congested switch if data cell preceding RM cell has EFCI set sender sets CI bit in returned RM cell

TCP Congestion Control

end-end control (no network

assistance)

How does sender perceive congestion

loss event = timeout or3 duplicate acks

TCP sender reduces

last byte

ACKedsent not-yet ACKed


last byte sent

cwndsender sequence number space


assistance)

sender limits transmissionLastByteSent-LastByteAcked

lelelele minCongWin RcvWindow

Roughly

CongWin is dynamic function of perceived network congestion

TCP sender reduces rate (CongWin) after loss event

three mechanisms slow start

AIMD

conservative after timeout events

rate =CongWinRTT

Bytessec

TCP Slow Start

When connection begins CongWin = 1 MSS

Example MSS = 500 bytes amp RTT = 200 msec

initial rate = 20 kbps

available bandwidth may

When connection begins increase rate exponentially fast until first loss event


available bandwidth may be gtgt MSSRTT

desirable to quickly ramp up to respectable rate

TCP Slow Start (more)

When connection begins increase rate exponentially until first loss event

double CongWin every

Host A

RTT

Host B


double CongWin every RTT

done by incrementing CongWin for every ACK received

Summary initial rate is slow but ramps up exponentially fast time

TCP AIMD

24 Kbytes

congestionwindow

multiplicative decreasecut CongWin in half after loss event

additive increaseincrease CongWin by 1 MSS every RTT in the absence of loss events probing


8 Kbytes

16 Kbytes

24 Kbytes

time

events probing

Long-lived TCP connection

Refinement inferring loss

After 3 dup ACKs

CongWin is cut in half

window then grows linearly

But after timeout event

bull 3 dup ACKs indicates network capable of delivering some segmentsbull timeout before 3 dup ACKs is ldquomore alarmingrdquo

Philosophy



CongWin instead set to 1 MSS

window then grows exponentially

to a threshold then grows linearly

bull timeout before 3 dup ACKs is ldquomore alarmingrdquo

Refinement (more)

Q When should the exponential increase switch to linear

A When CongWingets to 12 of its 4

6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold


gets to 12 of its value before timeout

Implementation Variable Threshold

At loss event Threshold is set to 12 of CongWin just before loss event

0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno

Summary TCP Congestion Control

When CongWin is below Threshold sender in slow-start phase window grows exponentially

When CongWin is above Threshold sender is in congestion-avoidance phase window grows linearly


When a triple duplicate ACK occurs Thresholdset to CongWin2 and CongWin set to Threshold

When timeout occurs Threshold set to CongWin2 and CongWin is set to 1 MSS

TCP sender congestion control

State Event TCP Sender Action Commentary

Slow Start (SS)

ACK receipt for previously unacked data

CongWin = CongWin + MSS If (CongWin gt Threshold)

set state to ldquoCongestion Avoidancerdquo

Resulting in a doubling of CongWin every RTT

CongestionAvoidance (CA)


CongWin = CongWin+MSS (MSSCongWin)

Additive increase resulting in increase of CongWin by 1 MSS every RTT


data

SS or CA Loss event detected by triple duplicate ACK

Threshold = CongWin2 CongWin = ThresholdSet state to ldquoCongestion Avoidancerdquo

Fast recovery implementing multiplicative decrease CongWin will not drop below 1 MSS

SS or CA Timeout Threshold = CongWin2 CongWin = 1 MSSSet state to ldquoSlow Startrdquo

Enter slow start

SS or CA Duplicate ACK

Increment duplicate ACK count for segment being acked

CongWin and Threshold not changed


timeoutssthresh = cwnd2

cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance

cwnd = cwnd + MSS (MSScwnd)

dupACKcount = 0

transmit new segment(s) as allowed

new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0


new ACKdupACKcount++

duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0

retransmit missing segment

dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0

retransmit missing segment ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3cwnd = ssthresh

dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput

avg TCP thruput as function of window size RTT ignore slow start assume always data to send

W window size (measured in bytes) where loss occurs avg window size ( in-flight bytes) is frac34 W

avg thruput is 34W per RTT


W

W2

avg TCP thruput = 34

WRTT

bytessec

TCP Futures TCP over ldquolong fat pipesrdquo

Example 1500 byte segments 100ms RTT want 10 Gbps throughput

Requires window size W = 83333 in-flight segments

Throughput in terms of loss rate



L = 210-10 Wow

New versions of TCP for high-speed

LRTT

MSSsdot221

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

TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair

Two competing sessions Additive increase gives slope of 1 as throughout increases

multiplicative decrease decreases throughput proportionally

R equal bandwidth share


RConnection 1 throughput

congestion avoidance additive increaseloss decrease window by factor of 2


Fairness (more)

Fairness and UDP

Multimedia apps often do not use TCP

do not want rate throttled by congestion

Fairness and parallel TCP connections

nothing prevents app from opening parallel cnctions between 2 hosts


throttled by congestion control

Instead use UDP pump audiovideo at constant rate tolerate packet loss

Research area TCP friendly

between 2 hosts

Web browsers do this

Example link of rate R supporting 9 cnctions

new app asks for 1 TCP gets rate R10

new app asks for 11 TCPs gets R2

Internet transport-layer protocols

reliable in-order delivery (TCP)

congestion control

flow control

connection setup


networkdata link


networkdata linkphysicalnetwork

data linkphysical

Transport Layer 3-5

connection setup

unreliable unordered delivery UDP

no-frills extension of ldquobest-effortrdquo IP

services not available delay guarantees

bandwidth guarantees



data linkphysical

Multiplexingdemultiplexing

= process= socket

delivering received segmentsto correct socket

Demultiplexing at rcv hostgathering data from multiplesockets enveloping data with header (later used for demultiplexing)

Multiplexing at send host

Transport Layer 3-6

application

transport

network

link

physical

P1 application

transport

network

link

physical

application

transport

network

link

physical

P2P3 P4P1

host 1 host 2 host 3

transport

How demultiplexing works

host receives IP datagrams

each datagram has source IP address destination IP address (in the network layer header)

each datagram carries 1

Source IP addr

Dest IP addr

Source port

Dest portTransport Layer

Network Layer

Header

Segm

ent

Datagram ndash Network Layer PDU

Transport Layer 3-7

each datagram carries 1 transport-layer segment

each segment has source destination port number (in the transport layer header)

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

message

Transport Layer

Header

Application Layer

Message

Segm

ent ndash

Tran

sport L

ayer PD

U

Connectionless demultiplexing

Create sockets with port numbers



When host receives UDP segment

checks destination port number in segment

directs UDP segment to socket with that port

Transport Layer 3-8

DatagramSocket(9922)

UDP socket identified by two-tuple

(IP address port number)

socket with that port number

IP datagrams with different source IP addresses andor source port but same destination port are directed to same socket


P3 P1P1P3 P4A2145 C6428 C7527 B9825

A C

B C

Transport Layer 3-9

ClientIPB

clientIP A

serverIP C

msg

2145 6428

msg

A C

2145 7527

msg

B C

9825 7527



source IP address

source port number

dest IP address




dest IP address

dest port number





P3 P1P1P3C80

B9825

A C

B C

A2145C80

C80A2145

B9825C80


ClientIPB

clientIP A

serverIP C

msg

2145 80

msg

B C

9825 80




lost








checksum

connectionless






UDP more


loss tolerant

rate sensitive

other UDP uses


32 bits




DNS

SNMP



Applicationdata

(message)

UDP segment format

header

UDP checksum




received segment






received segment


NO - error detected




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

1 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 1wraparound


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 0

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

wraparound

sum

checksum







send receive




sendside

receiveside





Wersquoll






state1

state2




eventactions



no loss of packets






udt_send(packet)

rdt_send(data)


Wait for call from

below

rdt_rcv(packet)

sender receiver














udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK






belowsender

Λ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




What to do


number to each pkt









stop and wait



above


rdt_send(data)






rdt_send(data)


udt_send(sndpkt)



Wait forcall 1 from

above


ΛΛ









udt_send(sndpkt)








rdt21 discussion

Sender

seq added to pkt



Receiver


















above


rdt_send(data)

udt_send(sndpkt)


isACK(rcvpkt1) )

rdt_rcv(rcvpkt)

Wait for ACK

0

sender FSMfragment



fragment





has_seq1(rcvpkt))

udt_send(sndpkt)


Λ



checksum seq ACKs







yuck drawbacks






rdt_send(data)

Wait for

ACK0





timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

ΛΛ



above


rdt_send(data)






timeoutWait for

ACK1

Λrdt_rcv(rcvpkt)

Λ

rdt30 in action


rdt30 in action





Ttransmit =

8kbpkt109 bsec


=


109 bsec




U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =




sender receiver

RTT





U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols








sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts






P3 P1P1P3 P4A2145 C6428 C7527 B9825

A C

B C

Transport Layer 3-9

ClientIPB

clientIP A

serverIP C

msg

2145 6428

msg

A C

2145 7527

msg

B C

9825 7527



source IP address

source port number

dest IP address




dest IP address

dest port number





P3 P1P1P3C80

B9825

A C

B C

A2145C80

C80A2145

B9825C80


ClientIPB

clientIP A

serverIP C

msg

2145 80

msg

B C

9825 80




lost








checksum

connectionless






UDP more


loss tolerant

rate sensitive

other UDP uses


32 bits




DNS

SNMP



Applicationdata

(message)

UDP segment format

header

UDP checksum




received segment






received segment


NO - error detected




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

1 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 1wraparound


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 0

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

wraparound

sum

checksum







send receive




sendside

receiveside





Wersquoll






state1

state2




eventactions



no loss of packets






udt_send(packet)

rdt_send(data)


Wait for call from

below

rdt_rcv(packet)

sender receiver














udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK






belowsender

Λ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




What to do


number to each pkt









stop and wait



above


rdt_send(data)






rdt_send(data)


udt_send(sndpkt)



Wait forcall 1 from

above


ΛΛ









udt_send(sndpkt)








rdt21 discussion

Sender

seq added to pkt



Receiver


















above


rdt_send(data)

udt_send(sndpkt)


isACK(rcvpkt1) )

rdt_rcv(rcvpkt)

Wait for ACK

0

sender FSMfragment



fragment





has_seq1(rcvpkt))

udt_send(sndpkt)


Λ



checksum seq ACKs







yuck drawbacks






rdt_send(data)

Wait for

ACK0





timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

ΛΛ



above


rdt_send(data)






timeoutWait for

ACK1

Λrdt_rcv(rcvpkt)

Λ

rdt30 in action


rdt30 in action





Ttransmit =

8kbpkt109 bsec


=


109 bsec




U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =




sender receiver

RTT





U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols








sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts





UDP more


loss tolerant

rate sensitive

other UDP uses


32 bits




DNS

SNMP



Applicationdata

(message)

UDP segment format

header

UDP checksum




received segment






received segment


NO - error detected




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

1 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 1wraparound


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 0

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

wraparound

sum

checksum







send receive




sendside

receiveside





Wersquoll






state1

state2




eventactions



no loss of packets






udt_send(packet)

rdt_send(data)


Wait for call from

below

rdt_rcv(packet)

sender receiver














udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK






belowsender

Λ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




What to do


number to each pkt









stop and wait



above


rdt_send(data)






rdt_send(data)


udt_send(sndpkt)



Wait forcall 1 from

above


ΛΛ









udt_send(sndpkt)








rdt21 discussion

Sender

seq added to pkt



Receiver


















above


rdt_send(data)

udt_send(sndpkt)


isACK(rcvpkt1) )

rdt_rcv(rcvpkt)

Wait for ACK

0

sender FSMfragment



fragment





has_seq1(rcvpkt))

udt_send(sndpkt)


Λ



checksum seq ACKs







yuck drawbacks






rdt_send(data)

Wait for

ACK0





timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

ΛΛ



above


rdt_send(data)






timeoutWait for

ACK1

Λrdt_rcv(rcvpkt)

Λ

rdt30 in action


rdt30 in action





Ttransmit =

8kbpkt109 bsec


=


109 bsec




U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =




sender receiver

RTT





U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols








sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts






send receive




sendside

receiveside





Wersquoll






state1

state2




eventactions



no loss of packets






udt_send(packet)

rdt_send(data)


Wait for call from

below

rdt_rcv(packet)

sender receiver














udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK






belowsender

Λ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




What to do


number to each pkt









stop and wait



above


rdt_send(data)






rdt_send(data)


udt_send(sndpkt)



Wait forcall 1 from

above


ΛΛ









udt_send(sndpkt)








rdt21 discussion

Sender

seq added to pkt



Receiver


















above


rdt_send(data)

udt_send(sndpkt)


isACK(rcvpkt1) )

rdt_rcv(rcvpkt)

Wait for ACK

0

sender FSMfragment



fragment





has_seq1(rcvpkt))

udt_send(sndpkt)


Λ



checksum seq ACKs







yuck drawbacks






rdt_send(data)

Wait for

ACK0





timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

ΛΛ



above


rdt_send(data)






timeoutWait for

ACK1

Λrdt_rcv(rcvpkt)

Λ

rdt30 in action


rdt30 in action





Ttransmit =

8kbpkt109 bsec


=


109 bsec




U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =




sender receiver

RTT





U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols








sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts








udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK






belowsender

Λ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




udt_send(sndpkt)


udt_send(NAK)


Wait for ACK or

NAK

rdt_send(data)





belowΛ




What to do


number to each pkt









stop and wait



above


rdt_send(data)






rdt_send(data)


udt_send(sndpkt)



Wait forcall 1 from

above


ΛΛ









udt_send(sndpkt)








rdt21 discussion

Sender

seq added to pkt



Receiver


















above


rdt_send(data)

udt_send(sndpkt)


isACK(rcvpkt1) )

rdt_rcv(rcvpkt)

Wait for ACK

0

sender FSMfragment



fragment





has_seq1(rcvpkt))

udt_send(sndpkt)


Λ



checksum seq ACKs







yuck drawbacks






rdt_send(data)

Wait for

ACK0





timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

ΛΛ



above


rdt_send(data)






timeoutWait for

ACK1

Λrdt_rcv(rcvpkt)

Λ

rdt30 in action


rdt30 in action





Ttransmit =

8kbpkt109 bsec


=


109 bsec




U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =




sender receiver

RTT





U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols








sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts







above


rdt_send(data)






rdt_send(data)


udt_send(sndpkt)



Wait forcall 1 from

above


ΛΛ









udt_send(sndpkt)








rdt21 discussion

Sender

seq added to pkt



Receiver


















above


rdt_send(data)

udt_send(sndpkt)


isACK(rcvpkt1) )

rdt_rcv(rcvpkt)

Wait for ACK

0

sender FSMfragment



fragment





has_seq1(rcvpkt))

udt_send(sndpkt)


Λ



checksum seq ACKs







yuck drawbacks






rdt_send(data)

Wait for

ACK0





timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

ΛΛ



above


rdt_send(data)






timeoutWait for

ACK1

Λrdt_rcv(rcvpkt)

Λ

rdt30 in action


rdt30 in action





Ttransmit =

8kbpkt109 bsec


=


109 bsec




U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =




sender receiver

RTT





U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols








sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts







above


rdt_send(data)

udt_send(sndpkt)


isACK(rcvpkt1) )

rdt_rcv(rcvpkt)

Wait for ACK

0

sender FSMfragment



fragment





has_seq1(rcvpkt))

udt_send(sndpkt)


Λ



checksum seq ACKs







yuck drawbacks






rdt_send(data)

Wait for

ACK0





timeout

rdt_rcv(rcvpkt)

Wait for call 0from

above

ΛΛ



above


rdt_send(data)






timeoutWait for

ACK1

Λrdt_rcv(rcvpkt)

Λ

rdt30 in action


rdt30 in action





Ttransmit =

8kbpkt109 bsec


=


109 bsec




U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =




sender receiver

RTT





U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols








sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts





rdt30 in action





Ttransmit =

8kbpkt109 bsec


=


109 bsec




U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =




sender receiver

RTT





U sender

= 008

30008 = 000027

microsec

L R

RTT + L R =

Pipelined protocols








sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts







sender receiver

RTT






U sender

= 024

30024 = 00008

microsecon

3 L R

RTT +3 L =

















Go-Back-N











base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts






Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts





Selective repeat


window send pkt



out-of-order buffer


receiver







otherwise ignore





window size=3

receiver sees no







in same connection


connection-oriented








overwhelm receiver





socketdoor

TCPsend buffer

TCPreceive buffer

socketdoor

segment





32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts







32 bits

sequence number


Receive window


FSRPAUheadlen

notused


ACK ACK valid


rcvr willing



applicationdata

(variable length)



commands)


Internetchecksum

(as in UDP)



In a segment










sequence numbers


acknowledgements

seq of next byte

window size

N


sequence number


checksum

rwnd

urg pointer




cumulative ACK




sequence number


checksum

rwndurg pointer


A

sent

ACKed

sent not-yet ACKed


usable

but not

yet sent

not

usable



Host A Host B





lsquoCrsquo

back lsquoCrsquo




Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts







Pipelined segments

Cumulative acks


timeout events

duplicate acks

Initially consider


Cumulative acks





TCP sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


wait



Λ





start timer





start timer

timeout

if (y gt SendBase)

SendBase = y



start timer

else stop timer



Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts






Seq=9

2 t

imeout

Host A

loss

tim

eout

Host B

X

Seq=1

00

tim

eout



Seq=9

2 t

imeout

loss


Seq=1

00

tim

eout

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eout

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts







start timer



else



break


fast retransmit

X

Host BHost A


TCP fast retransmit





ACK=100

timeout

ACK=100

ACK=100

ACK=100













segments










250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts






250

300

350

RT

T (

mil

lisec

on

ds)


100

150

200

1 8 15 22 29 36 43 50 57 64 71 78 85 92 99 106

time (seconnds)

RT

T (

mil

lisec

on

ds)







EstimatedRTT






process

TCP socket

receiver buffers

TCP

application

OS

application may

remove data from




(sender is sending)


code

IP

code


from sender



too fast

flow control

TCP flow control

buffered data

free buffer space

RcvBuffer










guarantees receive





seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts








seq s





number)










server-to-client

rcvBuffer size





server-to-client

rcvBuffer size



variable delays

2-way handshake

Letrsquos talk

OKESTAB

ESTAB



variable delays


message reordering


ESTAB

choose xreq_conn(x)

ESTAB

ESTABacc_conn(x)



retransmit

req_conn(x)

retransmit

req_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)

choose xreq_conn(x)

ESTAB

acc_conn(x)


req_conn(x)

ESTAB

req_conn(x)


(no client)

client terminates

server

forgets x

connection

x completes

req_conn(x)

ESTAB

req_conn(x)

data(x+1)

retransmit

data(x+1)

accept

data(x+1)

ESTAB

client terminates


data(x+1)

connection

x completes server

forgets x

TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts





TCP 3-way handshake

SYNbit=1 Seq=x


send TCP SYN msg


send TCP SYNACK

SYNSENT

SYN RCVD

client state

LISTEN

server state

LISTEN


ESTAB

SYNbit=1 Seq=y

ACKbit=1 ACKnum=x+1

send TCP SYNACK

msg acking SYN

ACKbit=1 ACKnum=y+1

received SYNACK(x)


send ACK for SYNACK



received ACK(y)


ESTAB

SYN RCVD


closed



SYN(seq=x)


SYN(x)



listen

SYN

rcvd

SYN

sent

ESTAB






Λ







FIN_WAIT_2

CLOSE_WAIT

ACKbit=1 ACKnum=x+1




send but can

receive data

clientSocketclose()


ESTABESTAB


FIN_WAIT_2

FINbit=1 seq=y

ACKbit=1 ACKnum=y+1

wait for server

closesend data

can no longer

send data

LAST_ACK

CLOSED

TIMED_WAIT

timed wait

for 2max

segment lifetime

CLOSED





manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts









manifestations


manifestations



a top-10 problem




no retransmission



Host B

λout


no retransmission







λout







R2

R2

λ out

λin




λin original data


copy

free buffer space

Host B

A

Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts





Idealization known





λin original data


copy

no buffer spaceA

Host B


Idealization known



R2

R2λin

λ out



λin original data


free buffer spaceA

Host B

R2

R2λin

λ out







A

λin λoutλincopy

free buffer space

timeout

Host B

R2

λ out


R2λin








four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts






four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth














assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts












assistance)



TCP sender reduces

last byte



last byte sent



assistance)



Roughly




AIMD


rate =CongWinRTT

Bytessec

TCP Slow Start












Host A

RTT

Host B





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts





TCP AIMD

24 Kbytes

congestionwindow




8 Kbytes

16 Kbytes

24 Kbytes

time

events probing



After 3 dup ACKs





Philosophy







Refinement (more)



6

8

10

12

14

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

threshold





0

2

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transmission round

con

ges

tio

n w

ind

ow

siz

e (s

egm

ents

)

Series1 Series2

threshold

TCPTahoe

TCPReno









Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts







Slow Start (SS)










data





Enter slow start






cwnd = 1 MSS

Λcwnd gt ssthresh

congestion

avoidance


dupACKcount = 0


new ACK

dupACKcount++

duplicate ACK

slow

start

timeout

cwnd = cwnd+MSS

dupACKcount = 0



duplicate ACK

Λcwnd = 1 MSS

ssthresh = 64 KB

dupACKcount = 0

New

ACK

New

ACK


cwnd = 1 MSS

dupACKcount = 0


dupACKcount++

fast

recovery

cwnd = cwnd + MSS


duplicate ACK

ssthresh= cwnd2

cwnd = ssthresh + 3


dupACKcount == 3


cwnd = 1

dupACKcount = 0


cwnd = ssthresh + 3



dupACKcount = 0

New ACK


cwnd = 1 MSS

dupACKcount = 0


New

ACK

TCP throughput





W

W2


WRTT

bytessec







L = 210-10 Wow


LRTT

MSSsdot221


TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts






TCP connection 1

TCP Fairness


bottleneckrouter

capacity R

TCP connection 2

Why is TCP fair








Fairness (more)

Fairness and UDP









between 2 hosts





transport layer chapter 3 architecture transport layer

Documents