- TCP Reno congestion control:
1 new ACK: CWND = CWND + ------ CWND 1 3 duplicate ACKs: CWND = CWND - --- CWND 2
- The TCP throughput
B(p)
according to
the simplified Padhye's
analysis:
(see: click here )
------- 1 / 3 B(p) = ----- \ / ----- RTT \/ 2bp
Assuming b = 1 (i.e., no delayed ACK), we have:
------ 1 / 3 B(p) = ----- \ / ---- RTT \/ 2p ------ 1 / 1.5 = ----- \ / ---- RTT \/ p
1 1.2 B(p) = ----- * ------- . . . . . . . . . . . . (1) RTT ---- \/ p
- Observation:
- TCP throughput B(p) decreases when RTT increases !!!
TCP analysis can already tell us that the TCP performance will be biased against long RTT connections
- Goal:
- Design a
CWND update mechanism
that achieves a
throughput
that is
independent
of RTT
- I.e.:
1 1.2 B(p) = ----- * -------
RTT---- \/ p
$64,000 Question:
- How do we go about designing such a TCP congestion control mechanism ???
- Design a
CWND update mechanism
that achieves a
throughput
that is
independent
of RTT
- TCP Throughput and RTT:
- When there are no packet losses,
the CWND changes as follows:
W packets W+1 W+2 |<--------------->|<--------------->|<--------------->| RTT RTT RTTTCP throughput changes as follows:
W packets W+1 W+2 |<--------------->|<--------------->|<--------------->| RTT RTT RTT W W+1 W+2 TPut = ----- TPut = ----- TPut = ----- RTT RTT RTT \ / \ / \ / \ / \ / \ / 1 1 Difference = ----- Difference = ----- RTT RTTConclusion:
- TCP throughput
increases
by
(1/RTT) packet
in RTT sec
I.e.:
1/RTT Increase in TCP throughput = ------- packets per sec RTT 1 = ----- packets per sec RTT2
- TCP throughput
increases
by
(1/RTT) packet
in RTT sec
- How to make TCP throughput independent of RTT:
- TCP throughput will be
independent of
RTT if:
- The increase in TCP throughput is independent of RTT
Notice that:
- The increase in
TCP throughput
in TCP Reno is
dependent on
RTT
Namely:
1 Increase in TCP throughput = ------- packets per sec RTT2
- TCP throughput will be
independent of
RTT if:
- Consider the following increase procedure:
c * RTT new ACK: CWND = CWND + --------- CWND 1 TD ACK: CWND = CWND - --- CWND 2
- Change in CWND per transmission round (no packet losses):
W packets W+c*RTT W+2*c*RTT |<------------------>|<------------------>|<------------------>| RTT RTT RTTResulting increase in TCP throughput:
W packets W+c*RTT W+2*c*RTT |<------------------>|<------------------>|<------------------>| RTT RTT RTT W W+c*RTT W+2*c*RTT TPut = ----- TPut = --------- TPut = ----------- RTT RTT RTT \ / \ / \ / \ / \ / \ / Difference = c Difference = c - Rate of increase in throughput:
c Rate of increase in TCP throughput = ----- (packets per sec) RTTThe rate of increase of TCP throughput is still dependent of RTT...
- Now,
consider the following increase procedure:
c * RTT2 new ACK: CWND = CWND + --------- CWND 1 TD ACK: CWND = CWND - --- CWND 2 - Change in CWND per transmission round (no packet losses):
W packets W+c*RTT2 W+2*c*RTT2 |<------------------>|<------------------>|<------------------>| RTT RTT RTTResulting increase in TCP throughput:
W packets W+c*RTT2 W+2*c*RTT2 |<------------------>|<------------------>|<------------------>| RTT RTT RTT W W+c*RTT2 W+2*c*RTT2 TPut = ----- TPut = --------- TPut = ----------- RTT RTT RTT \ / \ / \ / \ / \ / \ / Difference = c*RTT Difference = c*RTT - Rate of increase in throughput:
c*RTT Rate of increase in TCP throughput = ------- = c (packets per sec) RTTNote:
- The rate of increase in TCP throughput is (in this case) independent from RTT !!!!!
- Achieving a constant rate of increase in TCP throughput:
- Increase CWND by:
CWND = CWND + c * RTT2 in RTT secWaiting for RTT sec requires a timer interrupt and it is difficult to program....
- We can count packets
instead of
counting seconds:
CWND = CWND + c * RTT2 after receiving CWND ACKs <=> CWND = CWND + 1 after receiving CWND/(c * RTT2) ACKs
- Increase CWND by:
- The RTT-independent
TCP congestion control algorithm
has also been implemented in
NS.
- The implementation code is avialable in
NS/tcp/tcp.cc
( click here )
as windowOption_ = 2:
(This code is executed after receiving a NEW ACK) case 2: /* This is the Constant-Rate increase algorithm * from the 1991 paper by S. Floyd on "Connections * with Multiple Congested Gateways". * The window is increased by roughly * wnd_const_*RTT^2 packets per round-trip time. */ f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_; /* t_srtt_ = smoothed round-trip time */ /* T_SRTT_BITS = exponent of weight for updating t_srtt_ */ /* tcp_tick_ = clock granularity, default 0.1 */ /* Net effect: f ~= RTT */ f *= f; /* f = RTT^2 */ f *= wnd_const_; /* wnd_const_ is the constant c in the above discussion */ /* f = c*RTT^2 */ f += fcnt_; /* f = cumulative total */ /* **************************************************************** Check if we have accumulated enough "credits" to increase cwnd_ **************************************************************** */ if (f > cwnd_) { ++cwnd_; // ***** CWND = CWND + 1 when: // // #ACKS * (c*RTT^2) ~= CWND // <=> #ACKS ~= CWND/(c*RTT^2) fcnt_ = 0; /* Reset cumulative total */ } else { fcnt_ = f; /* Keep cumulative total */ } break;
- How to use "RTT-independent" TCP Reno in NS2:
- (After creating a TCP Reno agent),
set the variable
"windowOption_" of the
TCP agent
to
2
- Optionally, you can change the
variable "windowConstant_"
(that's the conatnt c in
the discussion) to
change the rate of increase
- the default value of "windowConstant_" is 4.
- (After creating a TCP Reno agent),
set the variable
"windowOption_" of the
TCP agent
to
2
- Example:
set tcp [new Agent/TCP/Reno] $tcp set windowOption_ 2 ;# Make TCP Reno use "Constant Through increase rate" $tcp set windowConstant_ 3 ;# XXX - you can change the rate of increate if so desired
- I'll let you experiment with this new variety of TCP in a homework assignment....