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

msgmsg

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

Transport 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 UDPsegmentincluding

header


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

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

Selective repeat big picture

Sender can have up to N unacked packets in pipeline


Sender maintains timer for each unacked


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)

timer for each in-flight pkt

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 rsquos and ACKs

Host A Host B

Usertypes

lsquoCrsquohost ACKsreceipt oflsquoCrsquo echoes

back lsquoCrsquo


host ACKsreceipt

of echoedlsquoCrsquo

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

Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t


timepremature timeout

Seq=

92

tim

eou

t

loss

lost ACK scenariotime

Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100

TCP retransmission scenarios (more)

Host A

loss

tim

eou

t

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

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 Control

receive side of TCP connection has a receive buffer

speed-matching

sender wonrsquot overflowreceiverrsquos buffer by

transmitting too muchtoo fast

flow control


speed-matching service matching the send rate to the receiving apprsquos drain rate

app process may be slow at reading from buffer

TCP Flow control how it works

(Suppose TCP receiver

Rcvr advertises spare room by including value of RcvWindow in segments

Sender limits unACKed data to RcvWindow


(Suppose TCP receiver discards out-of-order segments)

spare room in buffer= RcvWindow

= RcvBuffer-[LastByteRcvd -LastByteRead]

data to RcvWindow guarantees receive

buffer doesnrsquot overflow

LastByteSent-LastByteAckedleRcvWindow

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


Three way handshake

Step 1 client host sends TCP SYN segment to server

specifies initial seq

no data

client server

Connectionrequest

Connectiongranted


no data

Step 2 server host receives SYN replies with SYNACK segment

server allocates buffers

specifies server initial seq

Step 3 client receives SYNACK replies with ACK segment which may contain data

ACK

TCP Connection Management (cont)

Closing a connection

client closes socketclientSocketclose()

Step 1 client end system

client server

close

close


Step 1 client end system sends TCP FIN control

segment to server

Step 2 server receives FIN replies with ACK Closes connection sends FIN

close

closed

tim

ed w

ait


Step 3 client receives FIN replies with ACK

Enters ldquotimed waitrdquo -will respond with ACK to received FINs

client server

close

close


Step 4 server receives ACK Connection closed

Note with small modification can handle simultaneous FINs

close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle

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






















packet

Causescosts of congestion scenario 2

one router finite buffers

sender retransmission of lost packet

Host Aλin original data

λout

λ original data plus


finite shared output link buffersHost B

λin original data plus retransmitted data


always (goodput)

ldquoperfectrdquo retransmission only when loss

retransmission of delayed (not lost) packet makes larger

(than perfect case) for same

λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2


ldquocostsrdquo of congestion

more work (retrans) for given ldquogoodputrdquo

unneeded retransmissions link carries multiple copies of pkt

R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin

Q what happens as and increase λ

in

Host Aλin original data λout



finite shared output link buffers

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 additive increase multiplicative decrease

Approach increase transmission rate (window size) probing for usable bandwidth until loss occurs

additive increase increase CongWin by 1 MSS every RTT until loss detected

multiplicative decrease cut CongWin in half after loss


8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth

TCP Congestion Control

end-end control (no network assistance)

sender limits transmissionLastByteSent-LastByteAcked

lelelele minCongWin RcvWindow

How does sender perceive congestion

loss event = timeout or3 duplicate acks

TCP sender reduces



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 =CongWin

RTTBytessec

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

RT

T

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

TCP throughput

Whatrsquos the average throughout of TCP as a function of window size and RTT Ignore slow start

Let W be the window size when loss occurs



When window is W throughput is WRTT

Just after loss window drops to W2 throughput to W2RTT

Average throughout 75 WRTT

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

Transport 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


sender receiver





UDP more


loss tolerant

rate sensitive

other UDP uses


32 bits



header


DNS

SNMP



Applicationdata

(message)

UDP segment format

header

UDP checksum




received segment






received segment


NO - error detected







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







=


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 =























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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


sender receiver





UDP more


loss tolerant

rate sensitive

other UDP uses


32 bits



header


DNS

SNMP



Applicationdata

(message)

UDP segment format

header

UDP checksum




received segment






received segment


NO - error detected







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







=


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 =























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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



header


DNS

SNMP



Applicationdata

(message)

UDP segment format

header

UDP checksum




received segment






received segment


NO - error detected







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







=


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 =























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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






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







=


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 =























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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

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







=


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 =























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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)








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







=


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 =























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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







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







=


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 =























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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










=


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 =























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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


























packet

Go-Back-N












base=1

Λ



timeout




base=1nextseqnum=1


Λ


Wait

udt_send(sndpkt)

default




Λ







GBN inaction


Selective Repeat











Selective repeat


window send pkt



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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



send ACK(n)

out-of-order buffer


receiver








ACK(n)

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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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










Host A Host B

Usertypes


back lsquoCrsquo


host ACKsreceipt


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


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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 sender events

data rcvd from app



timeout


restart timer

Ack rcvd





Ack rcvd











start timer break



start timerbreak

end of loop forever


Seq=

92

tim

eou

t

Host A

loss

tim

eou

t

Host B

X

Seq=

100

tim

eou

t



Seq=

92

tim

eou

t

loss


Seq=

100

tim

eou

t

SendBase= 100

SendBase= 120

SendBase= 120

Sendbase= 100


Host A

loss

tim

eou

t

Host B

X


loss


SendBase= 120


Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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






Event at Receiver



TCP Receiver action










Fast Retransmit













start timer



else



break


fast retransmit












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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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





TCP Flow Control


speed-matching



flow control


















seq s





number)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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)



Three way handshake



no data

client server

Connectionrequest

Connectiongranted


no data





ACK





client server

close

close



segment to server


close

closed

tim

ed w

ait




client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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








client server

close

close




close

closedti

med w

ait

closed


TCP serverlifecycle


TCP clientlifecycle





manifestations


manifestations



a top-10 problem






















packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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











packet





λout






always (goodput)




λin

λout

=

λin

λout

gtλ

inλ

outR2R2 R2





R2λin

λ out

b

R2λin

λ out

a

R2λin

λ out

c

R4

R3


four senders

multihop paths

timeoutretransmit

λin


in





Host B


Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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






Host A

Host B

λou

t











network



to end systems











available bandwidth




(mild congestion)














8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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










8 Kbytes

16 Kbytes

24 Kbytes

time

congestionwindow

loss

time

cong

estio

n w

indo

w s

ize

Saw tooth

behavior probing

for bandwidth







TCP sender reduces



Roughly




AIMD


rate =CongWin

RTTBytessec

TCP Slow Start












Host A

RT

T

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




TCP throughput















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




TCP throughput















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




TCP throughput















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





Why is TCP fair








Fairness (more)

Fairness and UDP










between 2 hosts





Documents

Transport Layer Chapter 3 Transport Layer