As per Relevance of the word modification, we have this rfc below:
Network Working Group S.
Request for Comments: 2582
Category: Experimental T.
U.C.
April 1999
The NewReno Modification to TCP's Fast Recovery
Status of this
This memo defines an Experimental Protocol for the
community. It does not specify an Internet standard of any kind
Discussion and suggestions for improvement are requested
Distribution of this memo is unlimited
Copyright
Copyright (C) The Internet Society (1999). All Rights Reserved
RFC 2001 [RFC2001] documents the following four intertwined
congestion control algorithms: Slow Start, Congestion Avoidance,
Retransmit, and Fast Recovery. RFC 2581 [RFC2581] explicitly
certain modifications of these algorithms, including
that use the TCP Selective Acknowledgement (SACK) option [MMFR96],
and modifications that respond to "partial acknowledgments" (
which cover new data, but not all the data outstanding when loss
detected) in the absence of SACK. This document describes a
algorithm for responding to partial acknowledgments, referred to
NewReno. This response to partial acknowledgments was first
by Janey Hoe in [Hoe95].
1.
For the typical implementation of the TCP Fast Recovery
described in [RFC2581] (first implemented in the 1990 BSD
release, and referred to as the Reno algorithm in [FF96]), the
data sender only retransmits a packet after a retransmit timeout
occurred, or after three duplicate acknowledgements have
triggering the Fast Retransmit algorithm. A single
timeout might result in the retransmission of several data packets
but each invocation of the Reno Fast Retransmit algorithm leads
the retransmission of only a single data packet
Floyd & Henderson Experimental [Page 1]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
Problems can arise, therefore, when multiple packets have
dropped from a single window of data and the Fast Retransmit and
Recovery algorithms are invoked. In this case, if the SACK option
available, the TCP sender has the information to make
decisions about which packets to retransmit and which packets not
retransmit during Fast Recovery. This document applies only for
connections that are unable to use the TCP Selective
(SACK) option
In the absence of SACK, there is little information available to
TCP sender in making retransmission decisions during Fast Recovery
From the three duplicate acknowledgements, the sender infers a
loss, and retransmits the indicated packet. After this, the
sender could receive additional duplicate acknowledgements, as
data receiver acknowledges additional data packets that were
in flight when the sender entered Fast Retransmit
In the case of multiple packets dropped from a single window of data
the first new information available to the sender comes when
sender receives an acknowledgement for the retransmitted packet (
is the packet retransmitted when Fast Retransmit was first entered).
If there had been a single packet drop, then the acknowledgement
this packet will acknowledge all of the packets transmitted
Fast Retransmit was entered (in the absence of reordering). However
when there were multiple packet drops, then the acknowledgement
the retransmitted packet will acknowledge some but not all of
packets transmitted before the Fast Retransmit. We call this
a partial acknowledgment
Along with several other suggestions, [Hoe95] suggested that
Fast Recovery the TCP data sender respond to a partial
by inferring that the indicated packet has been lost,
retransmitting that packet. This document describes a
to the Fast Recovery algorithm in Reno TCP that incorporates
response to partial acknowledgements received during Fast Recovery
We call this modified Fast Recovery algorithm NewReno, because it
a slight but significant variation of the basic Reno algorithm.
document does not discuss the other suggestions in [Hoe95]
[Hoe96], such as a change to the ssthresh parameter during Slow
Start, or the proposal to send a new packet for every two
acknowledgements during Fast Recovery. The version of NewReno
this document also draws on other discussions of NewReno in
literature [LM97].
We do not claim that the NewReno version of Fast Recovery
here is an optimal modification of Fast Recovery for responding
partial acknowledgements, for TCPs that are unable to use SACK
Based on our experiences with the NewReno modification in the
Floyd & Henderson Experimental [Page 2]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
simulator [NS], we believe that this modification improves
performance of the Fast Retransmit and Fast Recovery algorithms in
wide variety of scenarios, and we are simply documenting it for
benefit of the IETF community. We encourage the use of
modification to Fast Recovery, and we further encourage
about operational experiences with this or related modifications
2.
This document assumes that the reader is familiar with the
MAXIMUM SEGMENT SIZE (MSS), CONGESTION WINDOW (cwnd), and FLIGHT
(FlightSize) defined in [RFC2581]. FLIGHT SIZE is defined as
[RFC2581] as follows
FLIGHT SIZE
The amount of data that has been sent but not yet acknowledged
3. The Fast Retransmit and Fast Recovery algorithms in
The standard implementation of the Fast Retransmit and Fast
algorithms is given in [RFC2581]. The NewReno modification of
algorithms is given below. This NewReno modification differs
the implementation in [RFC2581] only in the introduction of
variable "recover" in step 1, and in the response to a partial or
acknowledgement in step 5. The modification defines a "Fast
procedure" that begins when three duplicate ACKs are received
ends when either a retransmission timeout occurs or an ACK
that acknowledges all of the data up to and including the data
was outstanding when the Fast Recovery procedure began
1. When the third duplicate ACK is received and the sender is
already in the Fast Recovery procedure, set ssthresh to no
than the value given in equation 1 below. (This is equation 3
from [RFC2581]).
ssthresh = max (FlightSize / 2, 2*MSS) (1)
Record the highest sequence number transmitted in the
"recover".
2. Retransmit the lost segment and set cwnd to ssthresh plus 3*MSS
This artificially "inflates" the congestion window by the
of segments (three) that have left the network and which
receiver has buffered
3. For each additional duplicate ACK received, increment cwnd
MSS. This artificially inflates the congestion window in
to reflect the additional segment that has left the network
Floyd & Henderson Experimental [Page 3]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
4. Transmit a segment, if allowed by the new value of cwnd and
receiver's advertised window
5. When an ACK arrives that acknowledges new data, this ACK could
the acknowledgment elicited by the retransmission from step 2,
elicited by a later retransmission
If this ACK acknowledges all of the data up to and
"recover", then the ACK acknowledges all the
segments sent between the original transmission of the
segment and the receipt of the third duplicate ACK. Set cwnd
either (1) min (ssthresh, FlightSize + MSS); or (2) ssthresh
where ssthresh is the value set in step 1; this is
"deflating" the window. (We note that "FlightSize" in step 1
referred to the amount of data outstanding in step 1, when
Recovery was entered, while "FlightSize" in step 5 refers to
amount of data outstanding in step 5, when Fast Recovery
exited.) If the second option is selected, the
should take measures to avoid a possible burst of data, in
the amount of data outstanding in the network was much less
the new congestion window allows [HTH98]. Exit the Fast
procedure
If this ACK does *not* acknowledge all of the data up to
including "recover", then this is a partial ACK. In this case
retransmit the first unacknowledged segment. Deflate
congestion window by the amount of new data acknowledged,
add back one MSS and send a new segment if permitted by the
value of cwnd. This "partial window deflation" attempts
ensure that, when Fast Recovery eventually ends,
ssthresh amount of data will be outstanding in the network.
not exit the Fast Recovery procedure (i.e., if any duplicate
subsequently arrive, execute Steps 3 and 4 above).
For the first partial ACK that arrives during Fast Recovery,
reset the retransmit timer
Note that in Step 5, the congestion window is deflated when a
acknowledgement is received. The congestion window was likely
have been inflated considerably when the partial acknowledgement
received. In addition, depending on the original pattern of
losses, the partial acknowledgement might acknowledge nearly a
of data. In this case, if the congestion window was not deflated
the data sender might be able to send nearly a window of data back
to-back
There are several possible variants to the simple response to
Floyd & Henderson Experimental [Page 4]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
acknowledgements described above. First, there is a question of
to reset the retransmit timer after a partial acknowledgement.
is discussed further in Section 4 below
There is a related question of how many packets to retransmit
each partial acknowledgement. The algorithm described
retransmits a single packet after each partial acknowledgement.
is the most conservative alternative, in that it is the least
to result in an unnecessarily-retransmitted packet. A variant
would recover faster from a window with many packet drops would be
effectively Slow-Start, requiring less than N roundtrip times
recover from N losses [Hoe96]. With this slightly-more-
response to partial acknowledgements, it would be advantageous
reset the retransmit timer after each retransmission. Because
have not experimented with this variant in our simulator, we do
discuss this variant further in this document
A third question involves avoiding multiple Fast Retransmits
by the retransmission of packets already received by the receiver
This is discussed in Section 5 below. Avoiding multiple
Retransmits is particularly important if more aggressive responses
partial acknowledgements are implemented, because in this case
sender is more likely to retransmit packets already received by
receiver
As a final note, we would observe that in the absence of the
option, the data sender is working from limited information.
could spend a great deal of time considering exactly which variant
Fast Recovery is optimal for which scenario in this case. When
issue of recovery from multiple dropped packets from a single
of data is of particular importance, the best alternative would be
use the SACK option
4. Resetting the retransmit timer
The algorithm in Section 3 resets the retransmit timer only after
first partial ACK. In this case, if a large number of packets
dropped from a window of data, the TCP data sender's retransmit
will ultimately expire, and the TCP data sender will invoke Slow
Start. (This is illustrated on page 12 of [F98].) We call this
Impatient variant of NewReno
In contrast, the NewReno simulations in [FF96] illustrate
algorithm described above, with the modification that the
timer is reset after each partial acknowledgement. We call this
Slow-but-Steady variant of NewReno. In this case, for a window
a large number of packet drops, the TCP data sender retransmits
most one packet per roundtrip time. (This behavior is illustrated
Floyd & Henderson Experimental [Page 5]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
the New-Reno TCP simulation of Figure 5 in [FF96], and on page 11
[F98].)
For TCP implementations where the Retransmission Timeout Value (RTO
is generally not much larger than the round-trip time (RTT),
Impatient variant can result in a retransmit timeout even in
scenario with a small number of packet drops. For
implementations where the Retransmission Timeout Value (RTO)
usually considerably larger than the round-trip time (RTT), the Slow
but-Steady variant can remain in Fast Recovery for a long time
multiple packets have been dropped from a window of data. Neither
these variants are optimal; one possibility for a more
algorithm might be one that recovered more quickly from
packet drops, and combined this with the Slow-but-Steady variant
terms of resetting the retransmit timers. We note, however,
there is a limitation to the potential performance in this case
the absence of the SACK option
5. Avoiding Multiple Fast
In the absence of the SACK option, a duplicate
carries no information to identify the data packet or packets at
TCP data receiver that triggered that duplicate acknowledgement.
TCP data sender is unable to distinguish between a
acknowledgement that results from a lost or delayed data packet,
a duplicate acknowledgement that results from the sender'
retransmission of a data packet that had already been received at
TCP data receiver. Because of this, multiple segment losses from
single window of data can sometimes result in unnecessary
Fast Retransmits (and multiple reductions of the congestion window
[Flo94].
With the Fast Retransmit and Fast Recovery algorithms in Reno
NewReno TCP, the performance problems caused by multiple
Retransmits are relatively minor (compared to the potential
with Tahoe TCP, which does not implement Fast Recovery).
Nevertheless, unnecessary Fast Retransmits can occur with Reno
NewReno TCP, particularly if a Retransmit Timeout occurs during
Recovery. (This is illustrated for Reno on page 6 of [F98], and
NewReno on page 8 of [F98].) With NewReno, the data sender
in Fast Recovery until either a Retransmit Timeout, or until all
the data outstanding when Fast Retransmit was entered has
acknowledged. Thus with NewReno, the problem of multiple
Retransmits from a single window of data can only occur after
Retransmit Timeout
The following modification to the algorithms in Section 3
the problem of multiple Fast Retransmits. (This modification
Floyd & Henderson Experimental [Page 6]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
called "bugfix" in [F98], and is illustrated on pages 7 and 9.)
modification uses a new variable "send_high", whose initial value
the initial send sequence number. After each retransmit timeout,
highest sequence numbers transmitted so far is recorded in
variable "send_high".
If, after a retransmit timeout, the TCP data sender retransmits
consecutive packets that have already been received by the
receiver, then the TCP data sender will receive three
acknowledgements that do not acknowledge "send_high". In this case
the duplicate acknowledgements are not an indication of a
instance of congestion. They are simply an indication that
sender has unnecessarily retransmitted at least three packets
We note that if the TCP data sender receives three
acknowledgements that do not acknowledge "send_high", the sender
not know whether these duplicate acknowledgements resulted from a
packet drop or not. For a TCP that implements the bugfix
in this section for avoiding multiple fast retransmits, the
does not infer a packet drop from duplicate acknowledgements in
circumstances. As always, the retransmit timer is the
mechanism for inferring packet loss in this case
The modification to Fast Retransmit for avoiding multiple
Retransmits replaces Step 1 in Section 3 with Step 1A below.
addition, the modification adds Step 6 below
1A. When the third duplicate ACK is received and the sender is
already in the Fast Recovery procedure, check to see if
duplicate ACKs cover more than "send_high". If they do, then
ssthresh to no more than the value given in equation 1,
the the highest sequence number transmitted in the
"recover", and go to Step 2. If the duplicate ACKs don't
"send_high", then do nothing. That is, do not enter the
Retransmit and Fast Recovery procedure, do not change ssthresh
do not go to Step 2 to retransmit the "lost" segment, and do
execute Step 3 upon subsequent duplicate ACKs
Steps 2-5 are the same as those steps in Section 3 above
6. After a retransmit timeout, record the highest sequence
transmitted in the variable "send_high" and exit the
Recovery procedure if applicable
Step 1A above, in checking whether the duplicate ACKs cover *more
than "send_high", is the Careful variant of this algorithm.
possible variant would be to require simply that the three
Floyd & Henderson Experimental [Page 7]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
acknowledgements *cover* "send_high" before initiating another
Retransmit. We call this the Less Careful variant to
Retransmit
There are two separate scenarios in which the TCP sender
receive three duplicate acknowledgements acknowledging "send_high
but no more than "send_high". One scenario would be that the
sender transmitted four packets with sequence numbers higher
"send_high", that the first packet was dropped in the network,
the following three packets triggered three
acknowledgements acknowledging "send_high". The second
would be that the sender unnecessarily retransmitted three
below "send_high", and that these three packets triggered
duplicate acknowledgements acknowledging "send_high". In the
of SACK, the TCP sender in unable to distinguish between these
scenarios
For the Careful variant of Fast Retransmit, the data sender
have to wait for a retransmit timeout in the first scenario,
would not have an unnecessary Fast Retransmit in the second scenario
For the Less Careful variant to Fast Retransmit, the data
would Fast Retransmit as desired in the first scenario, and
unnecessarily Fast Retransmit in the second scenario. The
simulator has implemented the Less Careful variant of NewReno,
the TCP implementation in Sun's Solaris 7 implements the
variant. This document recommends the Careful variant given in
1A above
6. Implementation issues for the data receiver
[RFC2001] specifies that "Out-of-order data segments SHOULD
acknowledged immediately, in order to trigger the fast
algorithm." Neal Cardwell has noted [C98] that some data receivers
not send an immediate acknowledgement when they send a
acknowledgment, but instead wait first for their
acknowledgement timer to expire. As [C98] notes, this
limits the potential benefit from NewReno by delaying the receipt
the partial acknowledgement at the data sender. Our
is that the data receiver send an immediate acknowledgement for
out-of-order segment, even when that out-of-order segment fills
hole in the buffer
7.
Simulations with NewReno are illustrated with the validation
"tcl/test/test-all-newreno" in the NS simulator. The
"../../ns test-suite-newreno.tcl reno" shows a simulation with
TCP, illustrating the data sender's lack of response to a
Floyd & Henderson Experimental [Page 8]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
acknowledgement. In contrast, the command "../../ns test-suite
newreno.tcl newreno_B" shows a simulation with the same
using the NewReno algorithms described in this paper
The tests "../../ns test-suite-newreno.tcl newreno1_B0" and "../../
test-suite-newreno.tcl newreno1_B" show the Slow-but-Steady and
Impatient variants of NewReno, respectively
8.
Our recommendation is that TCP implementations include the
modification to the Fast Recovery algorithm given in Section 3,
with the modification for avoiding multiple Fast Retransmits given
Section 5. The NewReno modification given in Section 3 can
important even for TCP implementations that support the SACK option
because the SACK option can only be used for TCP connections
both TCP end-nodes support the SACK option. The NewReno
given in Section 3 implements the Impatient rather than the Slow-but
Steady variant of NewReno
While this document mentions several possible variations to
NewReno algorithm, we have not explored all of these
variations, and therefore are unable to make recommendations
some of them. Our belief is that the differences between any
variants of NewReno are small compared to the differences
Reno and NewReno. That is, the important thing is to
NewReno instead of Reno, for a TCP invocation without SACK; it
less important exactly which variant of NewReno is implemented
9.
Many thanks to Anil Agarwal, Mark Allman, Vern Paxson, Kacheong Poon
and Bernie Volz for detailed feedback on this document
10.
[C98] Neal Cardwell, "delayed ACKs for retransmitted packets
ouch!". November 1998. Email to the tcpimpl
list, Message-ID "Pine.LNX.4.02A.9811021421340.26785-
100000@sake.cs.washington.edu", archived
"http://tcp-impl.lerc.nasa.gov/tcp-impl".
[F98] Sally Floyd. Revisions to RFC 2001. Presentation
the TCPIMPL Working Group, August 1998.
"ftp://ftp.ee.lbl.gov/talks/sf-tcpimpl-aug98.ps"
"ftp://ftp.ee.lbl.gov/talks/sf-tcpimpl-aug98.pdf".
[FF96] Kevin Fall and Sally Floyd. Simulation-
Floyd & Henderson Experimental [Page 9]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
Comparisons of Tahoe, Reno and SACK TCP.
Communication Review, July 1996.
"ftp://ftp.ee.lbl.gov/papers/sacks.ps.Z".
[Flo94] S. Floyd, TCP and Successive Fast Retransmits
Technical report, October 1994.
"ftp://ftp.ee.lbl.gov/papers/fastretrans.ps".
[Hen98] Tom Henderson, Re: NewReno and the 2001 Revision
September 1998. Email to the tcpimpl mailing list
Message ID "Pine.BSI.3.95.980923224136.26134A
100000@raptor.CS.Berkeley.EDU", archived
"http://tcp-impl.lerc.nasa.gov/tcp-impl".
[Hoe95] J. Hoe, Startup Dynamics of TCP's Congestion
and Avoidance Schemes. Master's Thesis, MIT, 1995.
"http://ana-www.lcs.mit.edu/anaweb/ps-papers/hoe
thesis.ps".
[Hoe96] J. Hoe, "Improving the Start-up Behavior of
Congestion Control Scheme for TCP", In ACM SIGCOMM
August 1996.
"http://www.acm.org/sigcomm/sigcomm96/program.html".
[HTH98] Hughes, A., Touch, J. and J. Heidemann, "Issues in
Slow-Start Restart After Idle", Work in Progress,
1998.
[LM97] Dong Lin and Robert Morris, "Dynamics of Random
Detection", SIGCOMM 97, September 1997.
"http://www.acm.org/sigcomm/sigcomm97/program.html".
[MMFR96] Mathis, M., Mahdavi, J., Floyd, S. and A. Romanow, "
Selective Acknowledgement Options", RFC 2018,
1996.
[NS] The UCB/LBNL/VINT Network Simulator (NS).
"http://www-mash.cs.berkeley.edu/ns/".
[RFC2001] Stevens, W., "TCP Slow Start, Congestion Avoidance
Fast Retransmit, and Fast Recovery Algorithms",
2001, January 1997.
[RFC2581] Stevens, W., Allman, M. and V. Paxson, "TCP
Control", RFC 2581, April 1999.
Floyd & Henderson Experimental [Page 10]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
11. Security
RFC 2581 discusses general security considerations concerning
congestion control. This document describes a specific
that conforms with the congestion control requirements of RFC 2581,
and so those considerations apply to this algorithm, too. There
no known additional security concerns for this specific algorithm
12. AUTHORS'
Sally
AT&T Center for Internet Research at ICSI (ACIRI
Phone: +1 (510) 642-4274 x189
EMail: floyd@acm.
URL: http://www.aciri.org/floyd
Tom
University of California at
Phone: +1 (510) 642-8919
EMail: tomh@cs.berkeley.
URL: http://www.cs.berkeley.edu/~tomh
Floyd & Henderson Experimental [Page 11]
RFC 2582 NewReno Modification to TCP's Fast Recovery April 1999
13. Full Copyright
Copyright (C) The Internet Society (1999). All Rights Reserved
This document and translations of it may be copied and furnished
others, and derivative works that comment on or otherwise explain
or assist in its implementation may be prepared, copied,
and distributed, in whole or in part, without restriction of
kind, provided that the above copyright notice and this paragraph
included on all such copies and derivative works. However,
document itself may not be modified in any way, such as by
the copyright notice or references to the Internet Society or
Internet organizations, except as needed for the purpose
developing Internet standards in which case the procedures
copyrights defined in the Internet Standards process must
followed, or as required to translate it into languages other
English
The limited permissions granted above are perpetual and will not
revoked by the Internet Society or its successors or assigns
This document and the information contained herein is provided on
"AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET
TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
Floyd & Henderson Experimental [Page 12]
if you see any problems within the linking, don't worry be happy,
this is version 0.1 of the Relevance System and you gotta expect some crappy subroutines sometimes,
just be content we did not write this in Java, which would have made this "bigger and better" HAHAHHA.
RFC documents can be found at I.E.T.F.
Relevance System Copyright © 2002 Spectrum WorldResearch
other technical nosh by ServerMasters Corporation
collaboration of BobX
