Network Working Group                                       T. Henderson
Internet-Draft                                                    Boeing
Obsoletes: 3782  (if approved)                                  S. Floyd
Intended status: Standards Track                                    ICSI
Expires:  June 24,  September 15, 2011                                   A. Gurtov
                                                                    HIIT
                                                              Y. Nishida
                                                            WIDE Project
                                                        January 24,
                                                          March 14, 2011

       The NewReno Modification to TCP's Fast Recovery Algorithm
                   draft-ietf-tcpm-rfc3782-bis-00.txt
                   draft-ietf-tcpm-rfc3782-bis-01.txt

Abstract

   RFC 5681 [RFC5681] documents the following four intertwined TCP
   congestion control algorithms: Slow Start, Congestion Avoidance, Fast
   Retransmit, and Fast Recovery.  RFC 5681 explicitly allows
   certain modifications of these algorithms, including modifications
   that use the TCP Selective Acknowledgement (SACK) option [RFC2883],
   and modifications that respond to "partial acknowledgments" (ACKs
   which cover new data, but not all the data outstanding when loss was
   detected) in the absence of SACK.  This document describes a specific
   algorithm for responding to partial acknowledgments, referred to as
   NewReno.  This response to partial acknowledgments was first proposed
   by Janey Hoe in [Hoe95].

   The purpose of this revision from [RFC3782] is to make errata changes
   and to adopt a proposal from Yoshifumi Nishida to slightly increase
   the minimum window size after Fast Recovery from one to two segments,
   to improve performance when the receiver uses delayed acknowledgments.

Status of this Memo

   This Internet-Draft is submitted to IETF in full conformance with the
   provisions of BCP 78 and BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF).  Note that other groups may also distribute
   working documents as Internet-Drafts.  The list of current Internet-
   Drafts is at http://datatracker.ietf.org/drafts/current/.

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."
   This Internet-Draft will expire on June 24, September 15, 2011.

Copyright Notice

   Copyright (c) 2011 IETF Trust and the persons identified as
   the document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (http://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

   This document may contain material from IETF Documents or IETF
   Contributions published or made publicly available before November
   10, 2008.  The person(s) controlling the copyright in some of this
   material may not have granted the IETF Trust the right to allow
   modifications of such material outside the IETF Standards Process.
   Without obtaining an adequate license from the person(s) controlling
   the copyright in such materials, this document may not be modified
   outside the IETF Standards Process, and derivative works of it may
   not be created outside the IETF Standards Process, except to format
   it for publication as an RFC or to translate it into languages other
   than English.

1.  Introduction

   For the typical implementation of the TCP Fast Recovery algorithm
   described in [RFC5681] (first implemented in the 1990 BSD Reno
   release, and referred to as the Reno algorithm in [FF96]), the TCP
   data sender only retransmits a packet after a retransmit timeout has
   occurred, or after three duplicate acknowledgements acknowledgments have arrived
   triggering the Fast Retransmit algorithm.  A single retransmit
   timeout might result in the retransmission of several data packets,
   but each invocation of the Fast Retransmit algorithm in RFC 5681
   leads to the retransmission of only a single data packet.

   Problems can arise, therefore,

   Two problems arise with Reno TCP when multiple packets are
   dropped from packet losses occur
   in a single window of data and the Fast Retransmit window.  First, Reno will often take a timeout, as
   has been documented in [Hoe95].  Second, even if a retransmission
   timeout is avoided, multiple fast retransmits and Fast
   Recovery algorithms are invoked.  In this case, window reductions
   can occur, as documented in [F94].  When multiple packet losses
   occur, if the SACK option [RFC2883] is available, the TCP sender
   has the information to make intelligent decisions about which packets
   to retransmit and which packets not to retransmit during Fast
   Recovery.  This document applies only for to TCP connections that are
   unable to use the TCP Selective Acknowledgement (SACK) option,
   either because the option is not locally supported or
   because the TCP peer did not indicate a willingness to use SACK.

   In the absence of SACK, there is little information available to the
   TCP sender in making retransmission decisions during Fast
   Recovery.  From the three duplicate acknowledgements, acknowledgments, the sender
   infers a packet loss, and retransmits the indicated packet.  After
   this, the data sender could receive additional duplicate
   acknowledgements,
   acknowledgments, as the data receiver acknowledges additional data
   packets that were already 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 the
   sender receives an acknowledgement acknowledgment for the retransmitted packet (that
   is, the packet retransmitted when Fast Retransmit was first
   entered).  If there is a single packet drop and no reordering, then the
   acknowledgement
   acknowledgment for this packet will acknowledge all of the packets
   transmitted before Fast Retransmit was entered.  However, if there
   are multiple packet drops, then the acknowledgement acknowledgment for the
   retransmitted packet will acknowledge some but not all of the packets
   transmitted before the Fast Retransmit.  We call this acknowledgement acknowledgment
   a partial acknowledgment.

   Along with several other suggestions, [Hoe95] suggested that during
   Fast Recovery the TCP data sender responds to a partial
   acknowledgment by inferring that the next in-sequence packet has been
   lost, and retransmitting that packet.  This document describes a
   modification to the Fast Recovery algorithm in RFC 5681 that
   incorporates a response to partial acknowledgements acknowledgments received during
   Fast Recovery.  We call this modified Fast Recovery algorithm
   NewReno, because it is a slight but significant variation of the
   basic Reno algorithm in RFC 5681.  This document does not discuss the
   other suggestions in [Hoe95] and [Hoe96], such as a change to the
   ssthresh parameter during Slow-Start, or the proposal to send a new
   packet for every two duplicate acknowledgements acknowledgments during Fast
   Recovery.  The version of NewReno in this document also draws on other
   discussions of NewReno in the literature [LM97, Hen98].

   We do not claim that the NewReno version of Fast Recovery described
   here is an optimal modification of Fast Recovery for responding to
   partial acknowledgements, acknowledgments, for TCP connections that are unable to use
   SACK.  Based on our experiences with the NewReno modification in the
   NS simulator [NS] and with numerous implementations of NewReno, we
   believe that this modification improves the performance of the Fast
   Retransmit and Fast Recovery algorithms in a wide variety of
   scenarios.

2.  Terminology and Definitions

   In this document, the key words "MUST", "MUST NOT", "REQUIRED",
   "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY",
   and "OPTIONAL" are to be interpreted as described in BCP 14, RFC 2119
   [RFC2119].  This RFC indicates requirement levels for compliant TCP
   implementations implementing the NewReno Fast Retransmit and Fast
   Recovery algorithms described in this document.

   This document assumes that the reader is familiar with the terms
   SENDER MAXIMUM SEGMENT SIZE (SMSS), CONGESTION WINDOW (cwnd), and
   FLIGHT SIZE (FlightSize) defined in [RFC5681].  FLIGHT SIZE is
   defined as in [RFC5681] as follows:

      FLIGHT SIZE:
         The amount of data that has been sent but not yet cumulatively
         acknowledged.

3.  The Fast Retransmit and Fast Recovery Algorithms in NewReno

   The basic idea of these extensions to the Fast Retransmit and
   Fast Recovery algorithms described in [RFC5681] is as follows.
   The TCP sender can infer, from the arrival of duplicate
   acknowledgments, whether multiple losses in the same window of
   data have most likely occurred, and avoid taking a retransmit
   timeout or making multiple congestion window reductions due to
   such an event.

   The standard implementation of the Fast Retransmit and Fast Recovery
   algorithms is given in [RFC5681].  This section specifies the basic
   NewReno algorithm.  Sections  Section 4 through describes heuristics for processing
   duplicate acknowledgments after a retransmission timeout.  Sections
   5 and 6 describe provide some optional
   variants, guidance to implementors based on experience
   with NewReno implementations.  Several appendices provide more
   background information and the motivations behind them, describe variations that an implementor
   may want to consider when tuning performance for certain network
   scenarios.  Sections 7 and 8 provide some guidance to implementors
   based on experience with NewReno implementations.

   The NewReno modification concerns applies to the Fast Recovery procedure that
   begins when three duplicate ACKs are received and ends when either a
   retransmission timeout occurs or an ACK arrives that acknowledges all
   of the data up to and including the data that was outstanding when
   the Fast Recovery procedure began.

   The NewReno algorithm specified in this document differs from extends the
   implementation in [RFC5681] in by introducing a variable specified as
   "recover" whose initial value is the introduction of initial send sequence number.
   This new variable is used by the sender to record the send sequence
   number that must be acknowledged before the Fast Recovery
   procedure is declared to be over.  This variable
   "recover" is used below
   in step 1, in the response to a partial or new
   acknowledgement
   acknowledgment in step 5, and in modifications to step 1 and the
   addition of step 6 for avoiding multiple Fast Retransmits caused by
   the retransmission of packets already received by the receiver.

   The algorithm specified in this document uses a variable "recover",
   whose initial value is the initial send sequence number.

   1)  Three duplicate ACKs:
       When the third duplicate ACK is received and the sender is not
       already in the Fast Recovery procedure, check to see if the
       Cumulative Acknowledgement Acknowledgment field covers more than
       "recover".  If so, go to Step 1A.  Otherwise, go to Step 1B.

   1A) Invoking Fast Retransmit:
       If so, then set ssthresh to no more than the value given in
       equation 1 below.  (This is equation 4 from [RFC5681]).

         ssthresh = max (FlightSize / 2, 2*SMSS)           (1)

       In addition, record the highest sequence number transmitted in
       the variable "recover", and go to Step 2.

   1B) Not invoking Fast Retransmit:
       Do not enter the Fast Retransmit and Fast Recovery procedure.  In
       particular, do not change ssthresh, do not go to Step 2 to
       retransmit the "lost" segment, and do not execute Step 3 upon
       subsequent duplicate ACKs.

   2)  Entering Fast Retransmit:
       Retransmit the lost segment and set cwnd to ssthresh plus
       3*SMSS.  This artificially "inflates" the congestion window by the
       number of segments (three) that have left the network and the
       receiver has buffered.

   3)  Fast Recovery:
       For each additional duplicate ACK received while in Fast
       Recovery, increment cwnd by SMSS.  This artificially inflates
       the congestion window in order to reflect the additional segment
       that has left the network.

   4)  Fast Recovery, continued:
       Transmit a segment, if allowed by the new value of cwnd and the
       receiver's advertised window.

   5)  When an ACK arrives that acknowledges new data, this ACK could be
       the acknowledgment elicited by the retransmission from step 2, or
       elicited by a later retransmission.

       Full acknowledgements: acknowledgments:
       If this ACK acknowledges all of the data up to and including
       "recover", then the ACK acknowledges all the intermediate
       segments sent between the original transmission of the lost
       segment and the receipt of the third duplicate ACK.  Set cwnd to
       either (1) min (ssthresh, max(FlightSize, SMSS) + SMSS) or
       (2) ssthresh, where ssthresh is the value set in step 1; this is
       termed "deflating" the window.  (We note that "FlightSize" in step 1
       referred to the amount of data outstanding in step 1, when Fast
       Recovery was entered, while "FlightSize" in step 5 refers to the
       amount of data outstanding in step 5, when Fast Recovery is
       exited.)  If the second option is selected, the implementation
       is encouraged to take measures to avoid a possible burst of
       data, in case the amount of data outstanding in the network is
       much less than the new congestion window allows.  A simple mechanism
       is to limit the number of data packets that can be sent in response
       to a single acknowledgement; this is known
       as "maxburst_" in the NS simulator. acknowledgment.  Exit the Fast Recovery procedure.

       Partial acknowledgements: acknowledgments:
       If this ACK does *not* acknowledge all of the data up to and
       including "recover", then this is a partial ACK.  In this case,
       retransmit the first unacknowledged segment.  Deflate the
       congestion window by the amount of new data acknowledged by the
       cumulative acknowledgement acknowledgment field.  If the partial ACK
       acknowledges at least one SMSS of new data, then add back SMSS
       bytes to the congestion window.  As in Step 3, this artificially
       inflates the congestion window in order to reflect the additional
       segment that has left the network.  Send a new segment if
       permitted by the new value of cwnd.  This "partial window
       deflation" attempts to ensure that, when Fast Recovery eventually
       ends, approximately ssthresh amount of data will be outstanding
       in the network.  Do not exit the Fast Recovery procedure (i.e.,
       if any duplicate ACKs subsequently arrive, execute Steps 3 and
       4 above).

       For the first partial ACK that arrives during Fast Recovery, also
       reset the retransmit timer.  Timer management is discussed in
       more detail in Section 4.

   6)  Retransmit timeouts:
       After a retransmit timeout, record the highest sequence number
       transmitted in the variable "recover" and exit the Fast
       Recovery procedure if applicable.

   Step 1 specifies a check that the Cumulative Acknowledgement Acknowledgment field
   covers more than "recover".  Because the acknowledgement acknowledgment field
   contains the sequence number that the sender next expects to receive,
   the acknowledgement acknowledgment "ack_number" covers more than "recover" when:

      ack_number - 1 > recover;

   i.e., at least one byte more of data is acknowledged beyond the
   highest byte that was outstanding when Fast Retransmit was last
   entered.

   Note that in Step 5, the congestion window is deflated after a
   partial acknowledgement acknowledgment is received.  The congestion window was
   likely to have been inflated considerably when the partial
   acknowledgement
   acknowledgment was received.  In addition, depending on the original
   pattern of packet losses, the partial acknowledgement acknowledgment might
   acknowledge nearly a window 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.

   This document does not specify the sender's response to duplicate
   ACKs when the Fast Retransmit/Fast Recovery algorithm is not
   invoked.  This is addressed in other documents, such as those
   describing the Limited Transmit procedure [RFC3042].  This document
   also does not address issues of adjusting the duplicate acknowledgement acknowledgment
   threshold, but assumes the threshold specified in the IETF standards;
   the current standard is RFC 5681, which specifies a threshold of three
   duplicate acknowledgements. acknowledgments.

   As a final note, we would observe that in the absence of the SACK
   option, the data sender is working from limited information.  When
   the issue of recovery from multiple dropped packets from a single
   window of data is of particular importance, the best alternative
   would be to use the SACK option.

4.  Resetting the Retransmit Timer in Response to Partial
    Acknowledgements

   One possible variant to  Handling Duplicate Acknowledgments After A Timeout

   After each retransmit timeout, the response to partial acknowledgements
   specified highest sequence number
   transmitted so far is recorded in Section 3 concerns when to reset the retransmit timer variable "recover".
   If, after a partial acknowledgement.  The algorithm in Section 3, Step 5,
   resets the retransmit timer only after timeout, the first partial ACK.  In
   this case, if a large number of TCP data sender retransmits three
   consecutive packets were dropped from a window of
   data, that have already been received by the TCP data sender's retransmit timer will ultimately expire,
   and
   receiver, then the TCP data sender will invoke Slow-Start.  (This is illustrated
   on page 12 of [F98].)  We call receive three duplicate
   acknowledgments that do not cover more than "recover".  In this
   case, the Impatient variant duplicate acknowledgments are not an indication of NewReno.
   We note a new
   instance of congestion.  They are simply an indication that the Impatient variant
   sender has unnecessarily retransmitted at least three packets.

   However, when a retransmitted packet is itself dropped, the sender
   can also receive three duplicate acknowledgments that do not cover
   more than "recover".  In this case, the sender would have been
   better off if it had initiated Fast Retransmit.  For a TCP that
   implements the algorithm specified in Section 3 doesn't follow of this document, the
   recommended algorithm
   sender does not infer a packet drop from duplicate acknowledgments
   in RFC 2988 of restarting this scenario.  As always, the retransmit timer
   after every packet transmission or retransmission (step 5.1 of
   [RFC2988]).

   In contrast, is the NewReno simulations backup
   mechanism for inferring packet loss in [FF96] illustrate the
   algorithm described above with the modification that the retransmit
   timer is reset after each partial acknowledgement.  We call this case.

   There are several heuristics, based on timestamps or on the
   Slow-but-Steady variant amount of NewReno.  In this case, for a window with
   a large number
   advancement of packet drops, the TCP data sender retransmits at
   most one packet per roundtrip time.  (This behavior is illustrated in cumulative acknowledgment field, that allow the New-Reno TCP simulation of Figure 5
   sender to distinguish, in [FF96], some cases, between three duplicate
   acknowledgments following a retransmitted packet that was dropped,
   and on page 11 three duplicate acknowledgments from the unnecessary
   retransmission of
   [F98]).

   When N three packets have been dropped from [Gur03, GF04].  The TCP sender MAY use
   such a window of data for heuristic to decide to invoke a large
   value of N, the Slow-but-Steady variant can remain in Fast Recovery
   for N round-trip times, retransmitting one more dropped packet each
   round-trip time; for these scenarios, the Impatient variant gives a
   faster recovery and better performance.  The tests "ns
   test-suite-newreno.tcl impatient1" and "ns test-suite-newreno.tcl
   slow1" Retransmit in some cases,
   even when the NS simulator illustrate such a scenario, where the
   Impatient variant performs better three duplicate acknowledgments do not cover more than
   "recover".

   For example, when three duplicate acknowledgments are caused by the Slow-but-Steady
   variant.  The Impatient variant can
   unnecessary retransmission of three packets, this is likely to be particularly important for TCP
   connections with large congestion windows, as illustrated
   accompanied by the tests
   "ns test-suite-newreno.tcl impatient4" and "ns test-suite-newreno.tcl
   slow4" in the NS simulator.

   One can also construct scenarios where the Slow-but-Steady variant
   gives better performance than cumulative acknowledgment field advancing by at
   least four segments.  Similarly, a heuristic based on timestamps uses
   the Impatient variant.  As an example,
   this occurs fact that when only there is a small number of packets are dropped, hole in the RTO sequence space, the
   timestamp echoed in the duplicate acknowledgment is sufficiently small the timestamp of
   the most recent data packet that advanced the retransmit timer expires, and
   performance would have been better without a retransmit timeout.  The
   tests "ns test-suite-newreno.tcl impatient2" cumulative
   acknowledgment field [RFC1323].  If timestamps are used, and "ns
   test-suite-newreno.tcl slow2" in the NS simulator illustrate such a
   scenario.

   The Slow-but-Steady variant can also achieve higher goodput than
   sender stores the
   Impatient variant, by avoiding unnecessary retransmissions.  This
   could be timestamp of special interest for cellular links, where every
   transmission costs battery power and money.  The tests "ns
   test-suite-newreno.tcl impatient3" and "ns test-suite-newreno.tcl
   slow3" in the NS simulator illustrate such a scenario.  The
   Slow-but-Steady variant last acknowledged segment, then
   the timestamp echoed by duplicate acknowledgments can also be more robust used to delay variation in
   the network, where a delay spike might force the Impatient variant into
   distinguish between a timeout retransmitted packet that was dropped and go-back-N recovery.

   Neither
   three duplicate acknowledgments from the unnecessary
   retransmission of three packets.

4.1.  ACK Heuristic

   If the two variants discussed above are optimal.  Our
   recommendation ACK-based heuristic is for used, then following the Impatient variant, as specified in Section
   3 of this document, because advancement of
   the poor performance cumulative acknowledgment field, the sender stores the value of
   the
   Slow-but-Steady variant for TCP connections with large congestion
   windows.

   One possibility for a more optimal algorithm would be one that
   recovered from multiple packet drops as quickly previous cumulative acknowledgment as does slow-start,
   while resetting prev_highest_ack, and stores
   the retransmit timers after each partial
   acknowledgement, latest cumulative ACK as described in highest_ack.  In addition, the section below.  We note,
   however, that there following
   step is a limitation to the potential performance in
   this case in the absence of the SACK option.

5.  Retransmissions after a Partial Acknowledgement

   One possible variant to the response to partial acknowledgements
   specified performed if Step 1 in Section 3 would be fails, before proceeding to retransmit
   Step 1B.

   1*)  If the Cumulative Acknowledgment field didn't cover more than one packet
   after each partial acknowledgement, and
        "recover", check to reset see if the retransmit timer
   after each retransmission.  The algorithm specified in Section 3
   retransmits a single packet after each partial acknowledgement.  This congestion window is greater
        than SMSS bytes and the difference between highest_ack and
        prev_highest_ack is at most conservative alternative, 4*SMSS bytes.  If true, duplicate
        ACKs indicate a lost segment (proceed to Step 1A in that it is the least Section
        3).  Otherwise, duplicate ACKs likely
   to result in an unnecessarily-retransmitted packet.  A variant that
   would recover faster from a unnecessary
        retransmissions (proceed to Step 1B in Section 3).

   The congestion window with many packet drops would be check serves to
   effectively Slow-Start, retransmitting two packets protect against fast retransmit
   immediately after each partial
   acknowledgement.  Such an approach would take less than N roundtrip
   times to recover from N losses [Hoe96].  However, a retransmit timeout.

   If several ACKs are lost, the sender can see a jump in the absence cumulative
   ACK of
   SACK, recovering as quickly as slow-start introduces more than three segments, and the likelihood
   of unnecessarily retransmitting packets, and this could significantly
   complicate the recovery mechanisms.

   We note that the response to partial acknowledgements specified in
   Section 3 of this document and in heuristic can fail.
   RFC 2582 differs from the response
   in [FF96], even though both approaches only retransmit one packet in
   response to a partial acknowledgement.  Step 5 of Section 3 specifies 5681 recommends that the TCP sender responds to a partial ACK by deflating the
   congestion window by the amount of new receiver should
   send duplicate ACKs for every out-of-order data acknowledged, adding
   back SMSS bytes packet, such as a
   data packet received during Fast Recovery.  The ACK heuristic is more
   likely to fail if the partial ACK acknowledges at least SMSS bytes receiver does not follow this advice, because
   then a smaller number of new data, and sending ACK losses are needed to produce a new segment if permitted by
   sufficient jump in the new value
   of cwnd.  Thus, only one previously-sent packet cumulative ACK.

4.2.  Timestamp Heuristic

   If this heuristic is retransmitted in
   response to each partial acknowledgement, but additional new packets
   might be transmitted as well, depending on used, the amount sender stores the timestamp of new data
   acknowledged by the partial acknowledgement.
   last acknowledged segment.  In contrast, addition, the
   variant second paragraph of NewReno illustrated in [FF96] simply set the congestion
   window to ssthresh when a partial acknowledgement was received.  The
   approach step
   1 in [FF96] Section 3 is replaced as follows:

   1**) If the Cumulative Acknowledgment field didn't cover more conservative, and does not attempt than
        "recover", check to
   accurately track see if the actual number of outstanding packets after a
   partial acknowledgement is received.  While either of these
   approaches gives acceptable performance, echoed timestamp in the variant specified last
        non-duplicate acknowledgment equals the
        stored timestamp.  If true, duplicate ACKs indicate a lost
        segment (proceed to Step 1A in Section 3 recovers more smoothly when multiple packets are dropped 3).  Otherwise, duplicate
        ACKs likely result from a window of data.  (The [FF96] behavior can be seen in the NS
   simulator by setting the variable "partial_window_deflation_" for
   "Agent/TCP/Newreno" unnecessary retransmissions (proceed
        to 0; the behavior specified Step 1B in Section 3 is
   achieved 3).

   The timestamp heuristic works correctly, both when the receiver echoes
   timestamps as specified by setting "partial_window_deflation_" to 1.)

6.  Avoiding Multiple Fast Retransmits

   This section describes [RFC1323], and by its revision attempts.
   However, if the motivation for receiver arbitrarily echoes timestamps, the sender's state variable
   "recover", and discusses possible heuristics for distinguishing
   between heuristic
   can fail.  The heuristic can also fail if a retransmitted packet that timeout was dropped, spurious and three duplicate
   acknowledgements
   returning ACKs are not from retransmitted segments.  This can be
   prevented by detection algorithms such as [RFC3522].

5.  Implementation Issues for the unnecessary retransmission of three
   packets.

   In Data Receiver

   [RFC5681] specifies that "Out-of-order data segments SHOULD be
   acknowledged immediately, in order to accelerate loss recovery."
   Neal Cardwell has noted that some data receivers do not send an
   immediate acknowledgment when they send a partial acknowledgment,
   but instead wait first for their delayed acknowledgment timer to
   expire [C98].  As [C98] notes, this severely limits the absence potential
   benefit of NewReno by delaying the SACK option or timestamps, a duplicate
   acknowledgement carries no information to identify receipt of the data packet or
   packets partial
   acknowledgment at the TCP data receiver that triggered that duplicate
   acknowledgement.  In this case, sender.  Echoing RFC 5681, our
   recommendation is that the TCP data sender is unable to
   distinguish between receiver send an immediate
   acknowledgment for an out-of-order segment, even when that
   out-of-order segment fills a duplicate acknowledgement hole in the buffer.

6.  Implementation Issues for the Data Sender

   In Section 3, Step 5 above, it is noted that results from implementations should
   take measures to avoid a
   lost or delayed possible burst of data packet, and a duplicate acknowledgement that
   results from when leaving Fast
   Recovery, in case the sender's unnecessary retransmission amount of a new data packet that had already been received at the TCP data receiver.  Because sender is eligible
   to send due to the new value of
   this, with the Retransmit and Fast Recovery algorithms in Reno TCP,
   multiple segment losses from a single congestion window of data is large.  This
   can sometimes
   result in unnecessary multiple Fast Retransmits (and multiple
   reductions of arise during NewReno when ACKs are lost or treated as pure window
   updates, thereby causing the congestion window) [F94].

   With sender to underestimate the Fast Retransmit and Fast Recovery algorithms in Reno TCP, number of
   new segments that can be sent during the performance problems caused by multiple Fast Retransmits are
   relatively minor compared to recovery procedure.
   Specifically, bursts can occur when the potential problems with Tahoe TCP,
   which does not implement FlightSize is much less than
   the new congestion window when exiting from Fast Recovery.  Nevertheless, unnecessary
   Fast Retransmits can occur with Reno TCP unless some explicit  One
   simple mechanism is added to avoid this, such as the use a burst of the "recover"
   variable.  (This modification data when leaving Fast Recovery
   is called "bugfix" in [F98], and is
   illustrated on pages 7 and 9 of that document.  Unnecessary Fast
   Retransmits for Reno without "bugfix" is illustrated on page 6 of
   [F98].)

   Section 3 of [RFC2582] defined a default variant of NewReno TCP that
   did not use the variable "recover", and did not check if duplicate
   ACKs cover the variable "recover" before invoking Fast Retransmit.
   With this default variant from RFC 2582, to limit the problem of multiple Fast
   Retransmits from a single window number of data packets that can occur after be sent in response
   to a Retransmit
   Timeout (as single acknowledgment.  (This is known as "maxburst_" in page 8 of [F98]) the ns
   simulator.)  Other possible mechanisms for avoiding bursts include
   rate-based pacing, or in scenarios with reordering (as
   in setting the validation test "./test-all-newreno newreno5_noBF" in
   directory "tcl/test" of slow-start threshold to the NS simulator.  This gives performance
   similar
   resultant congestion window and then resetting the congestion window
   to that FlightSize.  A recommendation on page 8 of [F03].)  RFC 2582 also defined Careful
   and Less Careful variants of the NewReno algorithm, and recommended general mechanism to avoid
   excessively bursty sending patterns is outside the Careful variant.

   The algorithm specified in Section 3 scope of this document corresponds
   document.

   An implementation may want to use a separate flag to record whether
   or not it is presently in the Careful variant Fast Recovery procedure.  The use of NewReno TCP from RFC 2582,
   the value of the duplicate acknowledgment counter for this purpose is
   not reliable because it can be reset upon window updates and eliminates
   out-of-order acknowledgments.

   When updating the
   problem Cumulative Acknowledgment field outside of multiple
   Fast Retransmits.  This algorithm uses Recovery, the "recover" state variable "recover", whose initial value is may also need to be
   updated in order to continue to permit possible entry into Fast
   Recovery (Section 3, step 1).  This issue arises when an update
   of the initial send Cumulative Acknowledgment field results in a sequence
   number.  After each retransmit timeout,
   wraparound that affects the highest sequence number
   transmitted so far ordering between the Cumulative
   Acknowledgment field and the "recover" state variable.  Entry
   into Fast Recovery is recorded in only possible when the variable "recover".

   If, after a retransmit timeout, Cumulative
   Acknowledgment field covers more than the "recover" state variable.

   It is important for the TCP data sender retransmits three
   consecutive packets that have already been to respond correctly to duplicate ACKs
   received by the data
   receiver, then when the TCP data sender will receive is no longer in Fast Recovery (e.g., because
   of a Retransmit Timeout).  The Limited Transmit procedure [RFC3042]
   describes possible responses to the first and second duplicate
   acknowledgments.  When three or more duplicate
   acknowledgements that do not acknowledgments are
   received, the Cumulative Acknowledgment field doesn't cover more
   than "recover".  In this
   case, the duplicate acknowledgements are not an indication of "recover", and a new
   instance of congestion.  They are simply an indication that the
   sender has unnecessarily retransmitted at least three packets.

   However, when a retransmitted packet Fast Recovery is itself dropped, not invoked, it is
   important that the sender
   can also receive three duplicate acknowledgements that do not cover
   more than "recover".  In this case, execute the sender would have been
   better off if it had initiated Fast Retransmit.  For a TCP that
   implements the algorithm specified Recovery steps (3) and
   (4) in Section 3 of this document, 3.  Otherwise, the sender does not infer a packet drop from duplicate acknowledgements
   in this scenario.  As always, the retransmit timer is the backup
   mechanism for inferring packet loss could end up in a chain of
   spurious timeouts.  We mention this case.

   There are only because several heuristics, based on timestamps or on NewReno
   implementations had this bug, including the amount of
   advancement of implementation in the cumulative acknowledgement field, NS
   simulator.

   It has been observed that allow the
   sender to distinguish, in some cases, between three duplicate
   acknowledgements following a retransmitted packet that was dropped,
   and three duplicate acknowledgements from the unnecessary
   retransmission of three packets [Gur03, GF04].  The TCP sender MAY use
   such a heuristic to decide to invoke implementations enter a Fast Retransmit in some cases,
   even when the three duplicate acknowledgements do not cover more than
   "recover".

   For example, when three duplicate acknowledgements are caused by slow start
   or congestion avoidance window updating algorithm immediately after
   the
   unnecessary retransmission of three packets, this cwnd is likely to be
   accompanied set by the cumulative acknowledgement field advancing by at
   least four segments.  Similarly, equation found in (Section 3, step 5), even
   without a heuristic based on timestamps uses new external event generating the fact cwnd change.  Note that when there is a hole in the sequence space, the
   timestamp echoed in the duplicate acknowledgement
   after cwnd is set based on the timestamp of
   the most recent data packet that advanced the cumulative
   acknowledgement field [RFC1323].  If timestamps are used, and the
   sender stores the timestamp of the last acknowledged segment, then
   the timestamp echoed by duplicate acknowledgements can procedure for exiting Fast Recovery
   (Section 3, step 5), cwnd SHOULD NOT be used to
   distinguish between updated until a retransmitted packet further
   event occurs (e.g., arrival of an ack, or timeout) after this
   adjustment.

7.  Security Considerations

   RFC 5681 discusses general security considerations concerning TCP
   congestion control.  This document describes a specific algorithm
   that was dropped and
   three duplicate acknowledgements from conforms with the unnecessary
   retransmission congestion control requirements of three packets.  The heuristics RFC 5681,
   and so those considerations apply to this algorithm, too.  There are illustrated in
   no known additional security concerns for this specific algorithm.

8.  IANA Considerations

   This document has no actions for IANA.

9.  Conclusions

   This document specifies the NS simulator in NewReno Fast Retransmit and Fast Recovery
   algorithms for TCP.  This NewReno modification to TCP can even be
   important for TCP implementations that support the validation test "./test-all-newreno".

6.1.  ACK Heuristic

   If SACK option,
   because the ACK-based heuristic is used, then following SACK option can only be used for TCP connections when
   both TCP end-nodes support the advancement SACK option.  NewReno performs better
   than Reno (RFC 5681) in a number of
   the cumulative acknowledgement field, the sender stores the value scenarios discussed herein.

   A number of options to the previous cumulative acknowledgement as prev_highest_ack, and stores
   the latest cumulative ACK as highest_ack.  In addition, the following
   step is performed if Step 1 basic algorithm presented in Section 3 fails, before proceeding are
   also described in appendices to
   Step 1B.

   1*)  If this document.  These include the Cumulative Acknowledgement field didn't cover more than
        "recover", check
   handling of the retransmission timer (Appendix A), the response to see if
   partial acknowledgments (Appendix B), and whether or not the congestion window sender
   maintains a state variable called "recover" (Appendix C).
   Our belief is greater
        than SMSS bytes and that the difference differences between highest_ack and
        prev_highest_ack is at most 4*SMSS bytes.  If true, duplicate
        ACKs indicate a lost segment (proceed to Step 1A in Section
        3).  Otherwise, duplicate ACKs likely result from unnecessary
        retransmissions (proceed these variants of NewReno
   are small compared to Step 1B in Section 3).

   The congestion window check serves the differences between Reno and NewReno.
   That is, the important thing is to protect against fast retransmit
   immediately after implement NewReno instead of Reno,
   for a retransmit timeout, similar TCP connection without SACK; it is less important exactly
   which of the variants of NewReno is implemented.

10.  Acknowledgments

   Many thanks to Anil Agarwal, Mark Allman, Armando Caro, Jeffrey Hsu,
   Vern Paxson, Kacheong Poon, Keyur Shah, and Bernie Volz for detailed
   feedback on this document or on its precursor, RFC 2582.  Jeffrey
   Hsu provided clarifications on the
   "exitFastRetrans_" variable in NS.  Examples handling of applying the ACK
   heuristic are in validation tests "./test-all-newreno
   newreno_rto_loss_ack" recover variable
   that were applied to RFC 3782 as errata, and "./test-all-newreno newreno_rto_dup_ack" now are in
   directory "tcl/test" Section 8
   of this document.  Yoshifumi Nishida contributed a modification
   to the NS simulator.

   If several ACKs are lost, fast recovery algorithm to account for the sender can see a jump case in which
   flightsize is 0 when the cumulative
   ACK of more than three segments, TCP sender leaves fast recovery, and the heuristic can fail.  A
   validation test for this scenario is "./test-all-newreno
   newreno_rto_loss_ackf".  RFC 5681 recommends that a
   TCP receiver should
   send duplicate ACKs for every out-of-order data packet, such as a
   data packet received during Fast Recovery.  The ACK heuristic is more
   likely uses delayed acknowledgments.  Alexander Zimmermann
   provided several suggestions to fail if improve the receiver does not clarity of the document.

11.  References

11.1.  Normative References

   [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
             Requirement Levels", BCP 14, RFC 2119, March 1997.

   [RFC2988] Paxson, V. and M. Allman, "Computing TCP's Retransmission
             Timer", RFC 2988, November 2000.

   [RFC5681] Allman, M., Paxson, V. and  E. Blanton, "TCP Congestion
             Control", RFC 5681, September 2009.

11.2.  Informative References

   [C98]     Cardwell, N., "delayed ACKs for retransmitted packets: ouch!".
             November 1998,  Email to the tcpimpl mailing list, Message-ID
             "Pine.LNX.4.02A.9811021421340.26785-100000@sake.cs.washington.edu",
             archived at "http://tcp-impl.lerc.nasa.gov/tcp-impl".

   [F98]     Floyd, S., Revisions to RFC 2001, "Presentation to the TCPIMPL
             Working Group", August 1998.  URLs
             "ftp://ftp.ee.lbl.gov/talks/sf-tcpimpl-aug98.ps" and
             "ftp://ftp.ee.lbl.gov/talks/sf-tcpimpl-aug98.pdf".

   [F03]     Floyd, S., "Moving NewReno from Experimental to Proposed
             Standard?  Presentation to the TSVWG Working Group", March 2003.
             URLs "http://www.icir.org/floyd/talks/newreno-Mar03.ps" and
             "http://www.icir.org/floyd/talks/newreno-Mar03.pdf".

   [FF96]    Fall, K. and S. Floyd, "Simulation-based Comparisons of Tahoe,
             Reno and SACK TCP", Computer Communication Review, July 1996.  URL
             "ftp://ftp.ee.lbl.gov/papers/sacks.ps.Z".

   [F94]     Floyd, S., "TCP and Successive Fast Retransmits", Technical
             report, October 1994.  URL
             "ftp://ftp.ee.lbl.gov/papers/fastretrans.ps".

   [GF04]    Gurtov, A. and S. Floyd, "Resolving Acknowledgment Ambiguity
             in non-SACK TCP", Next Generation Teletraffic and
             Wired/Wireless Advanced Networking (NEW2AN'04), February
             2004.  URL "http://www.cs.helsinki.fi/u/gurtov/papers/
             heuristics.html".

   [Gur03]   Gurtov, A., "[Tsvwg] resolving the problem of unnecessary fast
             retransmits in go-back-N", email to the tsvwg mailing list, message
             ID <3F25B467.9020609@cs.helsinki.fi>, July 28, 2003.  URL
             "http://www1.ietf.org/mail-archive/working-groups/tsvwg/current/msg04334.html".

   [Hen98]   Henderson, T., 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 at "http://tcp-impl.lerc.nasa.gov/tcp-impl".

   [Hoe95]   Hoe, J., "Startup Dynamics of TCP's Congestion Control and
             Avoidance Schemes", Master's Thesis, MIT, 1995.

   [Hoe96]   Hoe, J., "Improving the Start-up Behavior of a Congestion
             Control Scheme for TCP", ACM SIGCOMM, August 1996.  URL
             "http://www.acm.org/sigcomm/sigcomm96/program.html".

   [LM97]    Lin, D. and R. Morris, "Dynamics of Random Early Detection",
             SIGCOMM 97, September 1997.  URL
             "http://www.acm.org/sigcomm/sigcomm97/program.html".

   [NS]      The Network Simulator (NS). URL "http://www.isi.edu/nsnam/ns/".

   [PF01]    Padhye, J. and S. Floyd, "Identifying the TCP Behavior of Web
             Servers", June 2001, SIGCOMM 2001.

   [RFC1323] Jacobson, V., Braden, R. and D. Borman, "TCP Extensions for
             High Performance", RFC 1323, May 1992.

   [RFC2582] Floyd, S. and T. Henderson, "The NewReno Modification to
             TCP's Fast Recovery Algorithm", RFC 2582, April 1999.

   [RFC2883] Floyd, S., J. Mahdavi, M. Mathis, and M. Podolsky, "The
             Selective Acknowledgment (SACK) Option for TCP, RFC 2883, July 2000.

   [RFC3042] Allman, M., Balakrishnan, H. and S. Floyd, "Enhancing TCP's
             Loss Recovery Using Limited Transmit", RFC 3042, January 2001.

   [RFC3522] Ludwig, R. and M. Meyer, "The Eifel Detection Algorithm for
             TCP", RFC 3522, April 2003.

   [RFC3782] Floyd, S., T. Henderson, and A. Gurtov, "The NewReno
             Modification to TCP's Fast Recovery Algorithm", RFC 3782, April 2004.

Appendix A.  Resetting the Retransmit Timer in Response to Partial
              Acknowledgments

             One possible variant to the response to partial acknowledgments
             specified in Section 3 concerns when to reset the retransmit timer
             after a partial acknowledgment.  The algorithm in Section 3, Step 5,
             resets the retransmit timer only after the first partial ACK.  In
             this case, if a large number of packets were dropped from a window of
             data, the TCP data sender's retransmit timer will ultimately expire,
             and the TCP data sender will invoke Slow-Start.  (This is illustrated
             on page 12 of [F98].)  We call this the Impatient variant of NewReno.
             We note that the Impatient variant in Section 3 doesn't follow the
             recommended algorithm in RFC 2988 of restarting the retransmit timer
             after every packet transmission or retransmission (step 5.1 of
             [RFC2988]).

             In contrast, the NewReno simulations in [FF96] illustrate the
             algorithm described above with the modification that the retransmit
             timer is reset after each partial acknowledgment.  We call this advice, because
   then the
             Slow-but-Steady variant of NewReno.  In this case, for a smaller window with
             a large number of ACK losses are needed to produce packet drops, the TCP data sender retransmits at
             most one packet per roundtrip time.  (This behavior is illustrated in
             the New-Reno TCP simulation of Figure 5 in [FF96], and on page 11 of
             [F98]).

             When N packets have been dropped from a
   sufficient jump window of data for a large
             value of N, the Slow-but-Steady variant can remain in Fast Recovery
             for N round-trip times, retransmitting one more dropped packet each
             round-trip time; for these scenarios, the cumulative ACK.

6.2.  Timestamp Heuristic

   If Impatient variant gives a
             faster recovery and better performance.
             The Impatient variant can be particularly important for TCP
             connections with large congestion windows.

             One can also construct scenarios where the Slow-but-Steady variant
             gives better performance than the Impatient variant.  As an example,
             this heuristic occurs when only a small number of packets are dropped, the RTO
             is used, sufficiently small that the sender stores retransmit timer expires, and
             performance would have been better without a retransmit timeout.

             The Slow-but-Steady variant can also achieve higher goodput than the timestamp
             Impatient variant, by avoiding unnecessary retransmissions.  This
             could be of special interest for cellular links, where every
             transmission costs battery power and money.  The
             Slow-but-Steady variant can also be more robust to delay variation in
             the
   last acknowledged segment.  In addition, network, where a delay spike might force the Impatient variant into
             a timeout and go-back-N recovery.

             Neither of the two variants discussed above are optimal.  Our
             recommendation is for the second paragraph of step
   1 Impatient variant, as specified in Section
             3 is replaced as follows:

   1**) If of this document, because of the Cumulative Acknowledgement field didn't cover poor performance of the
             Slow-but-Steady variant for TCP connections with large congestion
             windows.

             One possibility for a more than
        "recover", check to see if optimal algorithm would be one that
             recovered from multiple packet drops as quickly as does slow-start,
             while resetting the echoed timestamp retransmit timers after each partial
             acknowledgment, as described in the last
        non-duplicate acknowledgment equals the
        stored timestamp.  If true, duplicate ACKs indicate section below.  We note,
             however, that there is a lost
        segment (proceed limitation to Step 1A the potential performance in Section 3).  Otherwise, duplicate
        ACKs likely result from unnecessary retransmissions (proceed
        to Step 1B
             this case in Section 3).

   Examples the absence of applying the timestamp heuristic are in validation tests
   "./test-all-newreno newreno_rto_loss_tsh" and "./test-all-newreno
   newreno_rto_dup_tsh".  The timestamp heuristic works correctly, both
   when SACK option.

Appendix B.  Retransmissions after a Partial Acknowledgment

             One possible variant to the receiver echoes timestamps as response to partial acknowledgments
             specified by [RFC1323], in Section 3 would be to retransmit more than one packet
             after each partial acknowledgment, and by
   its revision attempts.  However, if the receiver arbitrarily echoes
   timestamps, to reset the heuristic can fail. retransmit timer
             after each retransmission.  The heuristic can also fail if algorithm specified in Section 3
             retransmits a
   timeout was spurious and returning ACKs are not from retransmitted
   segments.  This can be prevented by detection algorithms such as
   [RFC3522].

7.  Implementation Issues for the Data Receiver

   [RFC5681] specifies that "Out-of-order data segments SHOULD be
   acknowledged immediately, single packet after each partial acknowledgment.  This
             is the most conservative alternative, in order to accelerate loss recovery."
   Neal Cardwell has noted that some data receivers do not send it is the least likely
             to result in an
   immediate acknowledgement when they send unnecessarily-retransmitted packet.  A variant that
             would recover faster from a window with many packet drops would be to
             effectively Slow-Start, retransmitting two packets after each partial acknowledgment,
   but instead wait first for their delayed acknowledgement timer
             acknowledgment.  Such an approach would take less than N roundtrip
             times to
   expire [C98].  As [C98] notes, this severely limits recover from N losses [Hoe96].  However, in the potential
   benefit absence of NewReno by delaying
             SACK, recovering as quickly as slow-start introduces the receipt likelihood
             of unnecessarily retransmitting packets, and this could significantly
             complicate the partial
   acknowledgement at recovery mechanisms.

             We note that the data sender.  Echoing response to partial acknowledgments specified in
             Section 3 of this document and in RFC 5681, our
   recommendation is that 2582 differs from the data receiver send an immediate
   acknowledgement for an out-of-order segment, response
             in [FF96], even when that
   out-of-order segment fills a hole though both approaches only retransmit one packet in the buffer.

8.  Implementation Issues for the Data Sender

   In Section 3,
             response to a partial acknowledgment.  Step 5 above, it is noted of Section 3 specifies
             that implementations should
   take measures the TCP sender responds to avoid a possible burst of data when leaving Fast
   Recovery, in case partial ACK by deflating the
             congestion window by the amount of new data that acknowledged, adding
             back SMSS bytes if the sender is eligible
   to send due to partial ACK acknowledges at least SMSS bytes
             of new data, and sending a new segment if permitted by the new value
             of the congestion window cwnd.  Thus, only one previously-sent packet is large.  This
   can arise during NewReno when ACKs are lost or treated as pure window
   updates, thereby causing the sender retransmitted in
             response to underestimate each partial acknowledgment, but additional new packets
             might be transmitted as well, depending on the number amount of new segments that can be sent during data
             acknowledged by the recovery procedure.
   Specifically, bursts can occur when partial acknowledgment.  In contrast, the FlightSize is much less than
             variant of NewReno illustrated in [FF96] simply set the new congestion
             window when exiting from Fast Recovery.  One
   simple mechanism to avoid a burst of data ssthresh when leaving Fast Recovery a partial acknowledgment was received.  The
             approach in [FF96] is more conservative, and does not attempt to limit
             accurately track the actual number of data outstanding packets that can be sent in response
   to after a single acknowledgment.  (This
             partial acknowledgment is known as "maxburst_" received.  While either of these
             approaches gives acceptable performance, the variant specified in
             Section 3 recovers more smoothly when multiple packets are dropped
             from a window of data.

Appendix C.  Avoiding Multiple Fast Retransmits

             This appendix describes the ns
   simulator.)  Other possible mechanisms motivation for avoiding bursts include
   rate-based pacing, or setting the slow-start threshold to sender's state
             variable "recover".

             In the
   resultant congestion window and then resetting absence of the congestion window SACK option or timestamps, a duplicate
             acknowledgment carries no information to FlightSize.  A recommendation on identify the general mechanism to avoid
   excessively bursty sending patterns is outside data packet or
             packets at the scope of TCP data receiver that triggered that duplicate
             acknowledgment.  In this
   document.

   An implementation may want case, the TCP data sender is unable to use
             distinguish between a separate flag to record whether duplicate acknowledgment that results from a
             lost or not it is presently in delayed data packet, and a duplicate acknowledgment that
             results from the Fast Recovery procedure.  The use sender's unnecessary retransmission of a data packet
             that had already been received at the value TCP data receiver.  Because of
             this, with the duplicate acknowledgment counter for this purpose is
   not reliable because it can be reset upon window updates Retransmit and
   out-of-order acknowledgments.

   When updating the Cumulative Acknowledgement field outside of
   Fast Recovery, the "recover" state variable may also need to be
   updated in order to continue to permit possible entry into Fast Recovery (Section 3, step 1).  This issue arises when an update
   of the Cumulative Acknowledgement field results algorithms in Reno TCP,
             multiple segment losses from a sequence
   wraparound that affects single window of data can sometimes
             result in unnecessary multiple Fast Retransmits (and multiple
             reductions of the ordering between congestion window) [F94].

             With the Cumulative
   Acknowledgement field Fast Retransmit and the "recover" state variable.  Entry
   into Fast Recovery is only possible when the Cumulative
   Acknowledgment field covers more than the "recover" state variable.

   It is important for algorithms in Reno TCP,
             the sender to respond correctly performance problems caused by multiple Fast Retransmits are
             relatively minor compared to duplicate ACKs
   received when the sender is no longer in potential problems with Tahoe TCP,
             which does not implement Fast Recovery (e.g., because
   of a Retransmit Timeout).  The Limited Transmit procedure [RFC3042]
   describes possible responses Recovery.  Nevertheless, unnecessary
             Fast Retransmits can occur with Reno TCP unless some explicit
             mechanism is added to avoid this, such as the first and second duplicate
   acknowledgements.  When three or more duplicate acknowledgements are
   received, use of the Cumulative Acknowledgement field doesn't cover more
   than "recover", "recover"
             variable.  (This modification is called "bugfix" in [F98], and a new Fast Recovery is not invoked, it
             illustrated on pages 7 and 9 of that document.  Unnecessary Fast
             Retransmits for Reno without "bugfix" is
   important illustrated on page 6 of

             [F98].)

             Section 3 of [RFC2582] defined a default variant of NewReno TCP that
             did not use the sender variable "recover", and did not execute check if duplicate
             ACKs cover the variable "recover" before invoking Fast Recovery steps (3) and
   (4) in Section 3.  Otherwise, Retransmit.
             With this default variant from RFC 2582, the sender could end up in problem of multiple Fast
             Retransmits from a chain single window of
   spurious timeouts.  We mention this only because several NewReno
   implementations had this bug, including the implementation data can occur after a Retransmit
             Timeout (as in the NS
   simulator.  (This bug page 8 of [F98]) or in scenarios with reordering.
             RFC 2582 also defined Careful and Less Careful variants of the NS simulator was fixed NewReno
             algorithm, and recommended the Careful variant.

             The algorithm specified in July 2003,
   with Section 3 of this document corresponds to
             the variable "exitFastRetrans_".)

   It has been observed that some Careful variant of NewReno TCP implementations enter a slow start
   or congestion avoidance window updating from RFC 2582, and eliminates the
             problem of multiple Fast Retransmits.  This algorithm immediately after uses the cwnd
             variable "recover", whose initial value is set by the equation found initial send sequence
             number.  After each retransmit timeout, the highest sequence number
             transmitted so far is recorded in the variable "recover".

Appendix D.  Simulations

             This section provides pointers to simulation scripts available in (Section 3, step 5), even
   without a new external event generating
             the cwnd change.  Note NS simulator that
   after cwnd reproduce behavior described above.

             In Section 3, a simple mechanism is set based on described to limit the procedure for exiting Fast Recovery
   (Section 3, step 5), cwnd SHOULD NOT number of
             data packets that can be updated until sent in response to a further
   event occurs (e.g., arrival of an ack, or timeout) after this
   adjustment.

9.  Simulations single acknowledgment.
             This is known as "maxburst_" in the NS simulator.

             Simulations with NewReno are illustrated with the validation test
             "tcl/test/test-all-newreno" in the NS simulator.  The command
             "../../ns test-suite-newreno.tcl reno" shows a simulation with Reno
             TCP, illustrating the data sender's lack of response to a partial
   acknowledgement.
             acknowledgment.  In contrast, the command "../../ns
             test-suite-newreno.tcl newreno_B" shows a simulation with the same
   scenario using the NewReno algorithms described in this paper.

10.  Comparisons between Reno and NewReno TCP
   As we stated in the introduction, we believe that the NewReno
   modification described in this document improves the performance of
   the Fast Retransmit and Fast Recovery algorithms of Reno TCP in a
   wide variety of scenarios.  This has been discussed in some depth in
   [FF96], which illustrates Reno TCP's poor performance when multiple
   packets are dropped from a window of data and also illustrates
   NewReno TCP's good performance in that scenario.

   We do, however, know of one scenario where Reno TCP gives better
   performance than NewReno TCP, that we describe here for the sake of
   completeness.  Consider a scenario with no packet loss, but with
   sufficient reordering so that the TCP sender receives three duplicate
   acknowledgements.  This will trigger the Fast Retransmit and Fast
   Recovery algorithms.  With Reno TCP or with Sack TCP, this will
   result in the unnecessary retransmission of newreno_B" shows a single packet, combined simulation with a halving of the congestion window (shown on pages 4 and 6 of
   [F03]).  With same
             scenario using the NewReno TCP, however, this reordering will also result algorithms described in this paper.

             Regarding the unnecessary retransmission handling of an entire duplicate acknowledgments after a timeout,
             the congestion window of data (shown
   on page 5 of [F03]).

   While Reno TCP performs better than NewReno TCP in check serves to protect against fast retransmit
             immediately after a retransmit timeout, similar to the presence of
   reordering, NewReno's superior performance
             "exitFastRetrans_" variable in NS.  Examples of applying the presence ACK
             heuristic (Section 4) are in validation tests "./test-all-newreno
             newreno_rto_loss_ack" and "./test-all-newreno newreno_rto_dup_ack" in
             directory "tcl/test" of
   multiple packet drops generally outweighs its less optimal
   performance the NS simulator.
             If several ACKs are lost, the sender can see a jump in the presence cumulative
             ACK of reordering.  (Sack TCP more than three segments, and the heuristic can fail.  A
             validation test for this scenario is "./test-all-newreno
             newreno_rto_loss_ackf".

             Examples of applying the
   preferred solution, with good performance timestamp heuristic (Section 4) are in both scenarios.)  This
   document recommends the Fast Retransmit
             validation tests "./test-all-newreno newreno_rto_loss_tsh" and Fast Recovery algorithms
   of NewReno TCP instead of those of Reno TCP for those TCP connections
   that do not support SACK.  We would also note that NewReno's Fast
   Retransmit
             "./test-all-newreno newreno_rto_dup_tsh".

             Section 6 described a problem involving possible spurious timeouts,
             and Fast Recovery mechanisms are widely deployed mentions that this bug existed in TCP
   implementations the NS simulator.
             This bug in the Internet today, as documented NS simulator was fixed in [PF01].  For
   example, July 2003,
             with the variable "exitFastRetrans_".

             Regarding the Slow-but-Steady and Impatient variants described
             in Appendix A, The tests of TCP implementations "ns
             test-suite-newreno.tcl impatient1" and "ns test-suite-newreno.tcl
             slow1" in several thousand web servers the NS simulator illustrate a scenario in 2001 showed that which the
             Impatient variant performs better than the Slow-but-Steady
             variant.  The Impatient variant can be particularly important for those TCP
             connections where the web browser
   was not SACK-capable, more web servers used with large congestion windows, as illustrated by the Fast Retransmit tests
             "ns test-suite-newreno.tcl impatient4" and
   Fast Recovery algorithms of NewReno than those of Reno or Tahoe TCP
   [PF01].

11.  Changes Relative to RFC 2582

   The purpose of this document is to advance "ns test-suite-newreno.tcl
             slow4" in the NewReno's Fast
   Retransmit NS simulator.  The tests
             "ns test-suite-newreno.tcl impatient2" and Fast Recovery algorithms
             "ns test-suite-newreno.tcl slow2" in RFC 2582 to Standards Track.

   The main change the NS simulator illustrate
             scenarios in this document relative to RFC 2582 is to specify which the Careful Slow-but-Steady variant of NewReno's Fast Retransmit and Fast Recovery
   algorithms. outperforms the Impatient
             variant.  The base algorithm described in RFC 2582 did not attempt
   to avoid unnecessary multiple Fast Retransmits that can occur after a
   timeout (described tests "ns test-suite-newreno.tcl impatient3" and
             "ns test-suite-newreno.tcl slow3" in more detail the NS simulator illustrate
             scenarios in which the section above).  However,
   RFC 2582 also defined "Careful" and "Less Careful" Slow-but-Steady variants that avoid these unnecessary Fast Retransmits, and recommended the Careful
   variant.  This document specifies
             retransmissions.

             Appendix B describes different policies for partial window deflation.
             The [FF96] behavior can be seen in the previously-named "Careful"
   variant as NS
             simulator by setting the basic version of NewReno.  As described below, this
   algorithm uses a variable "recover", whose initial value is the send
   sequence number.

   The algorithm "partial_window_deflation_" for
             "Agent/TCP/Newreno" to 0; the behavior specified in Section 3 checks whether the
   acknowledgement field is
             achieved by setting "partial_window_deflation_" to 1.

             Section 3 of a partial acknowledgement covers *more* than
   "recover", as [RFC2582] defined in Section 3.  Another possible a default variant would be
   to simply require of NewReno TCP that
             did not use the acknowledgement field covers *more than or
   equal to* variable "recover", and did not check if duplicate
             ACKs cover the variable "recover" before initiating another invoking Fast Retransmit.  We
   called
             With this the Less Careful default variant in from RFC 2582.

   There are two separate scenarios in which the TCP sender could
   receive three duplicate acknowledgements acknowledging "recover" but
   no more than "recover".  One scenario would be that 2582, the problem of multiple Fast
             Retransmits from a single window of data sender
   transmitted four packets can occur after a Retransmit
             Timeout (as in page 8 of [F98]) or in scenarios with sequence numbers higher than "recover",
   that the first packet was dropped reordering (as
             An NS validation test "./test-all-newreno newreno5_noBF" in the network, and the following
   three packets triggered three duplicate acknowledgements
   acknowledging "recover".  The second scenario would be that the
   sender unnecessarily retransmitted three packets below "recover", and
   that these three packets triggered three duplicate acknowledgements
   acknowledging "recover".  In the absence
             directory "tcl/test" of SACK, the TCP sender is
   unable to distinguish between these two scenarios.

   For NS simulator illustartes the Careful default
             variant of Fast Retransmit, NewReno TCP that doesn't use the data sender would
   have variable "recover";
             this gives performance similar to wait for a retransmit timeout in the first scenario, but
   would not have an unnecessary Fast Retransmit that on page 8 of [F03].

Appendix E.  Comparisons between Reno and NewReno TCP

             As we stated in the second
   scenario.  For introduction, we believe that the Less Careful variant to Fast Retransmit, NewReno
             modification described in this document improves the performance of
             the data
   sender would Fast Retransmit as desired in the first scenario, and would
   unnecessarily Fast Retransmit Recovery algorithms of Reno TCP in the second scenario. a
             wide variety of scenarios.  This document
   only specifies the Careful variant has been discussed in Section 3.  Unnecessary Fast
   Retransmits with the Less Careful variant some depth in scenarios with
   reordering

             [FF96], which illustrates Reno TCP's poor performance when multiple
             packets are illustrated in page 8 dropped from a window of [F03].

   The document data and also specifies two heuristics illustrates
             NewReno TCP's good performance in that scenario.

             We do, however, know of one scenario where Reno TCP gives better
             performance than NewReno TCP, that we describe here for the sake of
             completeness.  Consider a scenario with no packet loss, but with
             sufficient reordering so that the TCP sender MAY
   use to decide to invoke Fast Retransmit even when the receives three duplicate
   acknowledgements do not cover more than "recover".  These heuristics,
   an ACK-based heuristic
             acknowledgments.  This will trigger the Fast Retransmit and a timestamp heuristic, are described Fast
             Recovery algorithms.  With Reno TCP or with Sack TCP, this will
             result in
   Sections 6.1 and 6.2 respectively.

12.  Changes Relative to RFC 3782

   In [RFC3782], the cwnd after Full ACK reception will be set to
   (1) min (ssthresh, FlightSize + SMSS) or (2) ssthresh.  However,
   there is unnecessary retransmission of a risk in single packet, combined
             with a halving of the first logic which results congestion window (shown on pages 4 and 6 of
             [F03]).  With NewReno TCP, however, this reordering will also result
             in performance
   degradation.  With the first logic, if FlightSize is zero, the result
   will be 1 SMSS. This means unnecessary retransmission of an entire window of data (shown
             on page 5 of [F03]).

             While Reno TCP performs better than NewReno TCP can transmit only 1 segment at this
   moment, which can cause delay in ACK transmission at receiver due to
   delayed ACK algorithm.

   The FlightSize on Full ACK reception can be zero the presence of
             reordering, NewReno's superior performance in some situations.
   A typical example is where sending window size during fast recovery is
   small. In this case, the retransmitted presence of
             multiple packet and new data packets can
   be transmitted within a short interval.  If all these packets
   successfully arrive, drops generally outweighs its less optimal
             performance in the receiver may generate a Full ACK that
   acknowledges all outstanding data.  Even if window size is not small,
   loss presence of ACK packets or receive buffer shortage during fast recovery can
   also increase reordering.  (Sack TCP is the possibility to fall into this situation.

   The proposed fix
             preferred solution, with good performance in this document ensures that sender TCP transmits at
   least two segments on Full ACK reception.

   In addition, errata for RFC3782 (editorial clarification to Section 8)
   has been applied.

13.  Conclusions both scenarios.)  This
             document specifies recommends the NewReno Fast Retransmit and Fast Recovery algorithms for TCP.  This
             of NewReno modification to TCP can even be
   important instead of those of Reno TCP for those TCP connections
             that do not support SACK.  We would also note that NewReno's Fast
             Retransmit and Fast Recovery mechanisms are widely deployed in TCP
             implementations in the Internet today, as documented in [PF01].  For
             example, tests of TCP implementations in several thousand web servers
             in 2001 showed that support the SACK option,
   because the SACK option can only be used for those TCP connections when
   both TCP end-nodes support where the SACK option. web browser
             was not SACK-capable, more web servers used the Fast Retransmit and
             Fast Recovery algorithms of NewReno performs better than Reno (RFC 5681) in a number of scenarios discussed herein.

   A number those of options Reno or Tahoe TCP
             [PF01].

Appendix F.  Changes Relative to the basic algorithm presented in Section 3 are
   also described.  These include the handling RFC 2582

             The purpose of the retransmission
   timer (Section 4), the response this document is to partial acknowledgments (Section
   5), and the value of advance the congestion window when leaving NewReno's Fast
             Retransmit and Fast Recovery
   (section 3, step 5).  Our belief algorithms in RFC 2582 to Standards Track.

             The main change in this document relative to RFC 2582 is that the differences between
   these variants of NewReno are small compared to specify
             the differences
   between Reno Careful variant of NewReno's Fast Retransmit and NewReno.  That is, the important thing is Fast Recovery
             algorithms.  The base algorithm described in RFC 2582 did not attempt
             to
   implement NewReno instead of Reno, for avoid unnecessary multiple Fast Retransmits that can occur after a TCP connection without SACK;
   it is less important exactly which of
             timeout (described in more detail in the variants of NewReno is
   implemented.

14.  Security Considerations section above).  However,
             RFC 5681 discusses general security considerations concerning TCP
   congestion control. 2582 also defined "Careful" and "Less Careful" variants that
             avoid these unnecessary Fast Retransmits, and recommended the Careful
             variant.  This document describes specifies the previously-named "Careful"
             variant as the basic version of NewReno.  As described below, this
             algorithm uses a specific variable "recover", whose initial value is the send
             sequence number.

             The algorithm
   that conforms with specified in Section 3 checks whether the congestion control requirements
             acknowledgment field of RFC 5681,
   and so those considerations apply a partial acknowledgment covers *more* than
             "recover", as defined in Section 3.  Another possible variant would be
             to simply require that the acknowledgment field covers *more than or
             equal to* "recover" before initiating another Fast Retransmit.  We
             called this algorithm, too. the Less Careful variant in RFC 2582.

             There are two separate scenarios in which the TCP sender could
             receive three duplicate acknowledgments acknowledging "recover" but
             no known additional security concerns for this specific algorithm.

15.  IANA Considerations

   This document has no actions for IANA.

16.  Acknowledgements

   Many thanks to Anil Agarwal, Mark Allman, Armando Caro, Jeffrey Hsu,
   Vern Paxson, Kacheong Poon, Keyur Shah, and Bernie Volz for detailed
   feedback on this document or on its precursor, RFC 2582.  Jeffrey
   Hsu provided clarifications on more than "recover".  One scenario would be that the handling of data sender
             transmitted four packets with sequence numbers higher than "recover",
             that the recover variable first packet was dropped in the network, and the following
             three packets triggered three duplicate acknowledgments
             acknowledging "recover".  The second scenario would be that were applied to RFC 3782 as errata, the
             sender unnecessarily retransmitted three packets below "recover", and now are in Section 8
             that these three packets triggered three duplicate acknowledgments
             acknowledging "recover".  In the absence of this document.  Yoshifumi Nishida contributed a modification SACK, the TCP sender is
             unable to distinguish between these two scenarios.

             For the fast recovery algorithm Careful variant of Fast Retransmit, the data sender would
             have to account wait for a retransmit timeout in the case first scenario, but
             would not have an unnecessary Fast Retransmit in which
   flightsize is 0 when the TCP second
             scenario.  For the Less Careful variant to Fast Retransmit, the data
             sender leaves fast recovery, would Fast Retransmit as desired in the first scenario, and would
             unnecessarily Fast Retransmit in the
   TCP receiver uses delayed acknowledgments.

17.  References

17.1.  Normative References

   [RFC2119] Bradner, S., "Key words for use second scenario.  This document
             only specifies the Careful variant in RFCs to Indicate
             Requirement Levels", BCP 14, RFC 2119, March 1997.

   [RFC2988] Paxson, V. and M. Allman, "Computing TCP's Retransmission
             Timer", RFC 2988, November 2000.

   [RFC5681] Allman, M., Paxson, V. and  E. Blanton, "TCP Congestion
             Control", RFC 5681, September 2009.

17.2.  Informative References

   [C98]     Cardwell, N., "delayed ACKs for retransmitted packets: ouch!".
             November 1998,  Email to Section 3.  Unnecessary Fast
             Retransmits with the tcpimpl mailing list, Message-ID
             "Pine.LNX.4.02A.9811021421340.26785-100000@sake.cs.washington.edu",
             archived at "http://tcp-impl.lerc.nasa.gov/tcp-impl".

   [F98]     Floyd, S., Revisions to RFC 2001, "Presentation to Less Careful variant in scenarios with
             reordering are illustrated in page 8 of [F03].

             The document also specifies two heuristics that the TCPIMPL
             Working Group", August 1998.  URLs
             "ftp://ftp.ee.lbl.gov/talks/sf-tcpimpl-aug98.ps" and
             "ftp://ftp.ee.lbl.gov/talks/sf-tcpimpl-aug98.pdf".

   [F03]     Floyd, S., "Moving NewReno from Experimental TCP sender MAY
             use to Proposed
             Standard?  Presentation decide to the TSVWG Working Group", March 2003.
             URLs "http://www.icir.org/floyd/talks/newreno-Mar03.ps" and
             "http://www.icir.org/floyd/talks/newreno-Mar03.pdf".

   [FF96]    Fall, K. and S. Floyd, "Simulation-based Comparisons of Tahoe,
             Reno and SACK TCP", Computer Communication Review, July 1996.  URL
             "ftp://ftp.ee.lbl.gov/papers/sacks.ps.Z".

   [F94]     Floyd, S., "TCP and Successive invoke Fast Retransmits", Technical
             report, October 1994.  URL
             "ftp://ftp.ee.lbl.gov/papers/fastretrans.ps".

   [GF04]    Gurtov, A. Retransmit even when the three duplicate
             acknowledgments do not cover more than "recover".  These heuristics,
             an ACK-based heuristic and S. Floyd, "Resolving Acknowledgment Ambiguity a timestamp heuristic, are described in non-SACK TCP", Next Generation Teletraffic
             Sections 6.1 and
             Wired/Wireless Advanced Networking (NEW2AN'04), February
             2004.  URL "http://www.cs.helsinki.fi/u/gurtov/papers/
             heuristics.html".

   [Gur03]   Gurtov, A., "[Tsvwg] resolving 6.2 respectively.

Appendix G.  Changes Relative to RFC 3782

             In [RFC3782], the problem of unnecessary fast
             retransmits in go-back-N", email cwnd after Full ACK reception will be set to
             (1) min (ssthresh, FlightSize + SMSS) or (2) ssthresh.  However,
             there is a risk in the tsvwg mailing list, message
             ID <3F25B467.9020609@cs.helsinki.fi>, July 28, 2003.  URL
             "http://www1.ietf.org/mail-archive/working-groups/tsvwg/current/msg04334.html".

   [Hen98]   Henderson, T., Re: NewReno and first logic which results in performance
             degradation.  With the 2001 Revision. September
             1998.  Email to first logic, if FlightSize is zero, the tcpimpl mailing list, Message ID
             "Pine.BSI.3.95.980923224136.26134A-100000@raptor.CS.Berkeley.EDU",
             archived result
             will be 1 SMSS. This means TCP can transmit only 1 segment at "http://tcp-impl.lerc.nasa.gov/tcp-impl".

   [Hoe95]   Hoe, J., "Startup Dynamics of TCP's Congestion Control and
             Avoidance Schemes", Master's Thesis, MIT, 1995.

   [Hoe96]   Hoe, J., "Improving the Start-up Behavior of a Congestion
             Control Scheme for TCP", ACM SIGCOMM, August 1996.  URL
             "http://www.acm.org/sigcomm/sigcomm96/program.html".

   [LM97]    Lin, D. and R. Morris, "Dynamics of Random Early Detection",
             SIGCOMM 97, September 1997.  URL
             "http://www.acm.org/sigcomm/sigcomm97/program.html".

   [NS] this
             moment, which can cause delay in ACK transmission at receiver due to
             delayed ACK algorithm.

             The Network Simulator (NS). URL "http://www.isi.edu/nsnam/ns/".

   [PF01]    Padhye, J. FlightSize on Full ACK reception can be zero in some situations.
             A typical example is where sending window size during fast recovery is
             small. In this case, the retransmitted packet and S. Floyd, "Identifying new data packets can
             be transmitted within a short interval.  If all these packets
             successfully arrive, the TCP Behavior receiver may generate a Full ACK that
             acknowledges all outstanding data.  Even if window size is not small,
             loss of Web
             Servers", June 2001, SIGCOMM 2001.

   [RFC1323] Jacobson, V., Braden, R. and D. Borman, "TCP Extensions for
             High Performance", RFC 1323, May 1992.

   [RFC2582] Floyd, S. and T. Henderson, "The NewReno Modification ACK packets or receive buffer shortage during fast recovery can
             also increase the possibility to
             TCP's Fast Recovery Algorithm", RFC 2582, April 1999.

   [RFC2883] Floyd, S., J. Mahdavi, M. Mathis, and M. Podolsky, "The
             Selective Acknowledgment (SACK) Option fall into this situation.

             The proposed fix in this document ensures that sender TCP transmits at
             least two segments on Full ACK reception.

             In addition, errata for TCP, RFC 2883, July 2000.

   [RFC3042] Allman, M., Balakrishnan, H. RFC3782 (editorial clarification to Section 8
             of RFC2582, which is now Section 6 of this document) has been applied.

             Sections 4, 5, and S. Floyd, "Enhancing TCP's
             Loss Recovery Using Limited Transmit", RFC 3042, January 2001.

   [RFC3522] Ludwig, R. 9-11 of RFC2582 were relocated to appendices of
             this document since they are non-normative and M. Meyer, "The Eifel Detection Algorithm for
             TCP", RFC 3522, April 2003.

   [RFC3782] Floyd, S., T. Henderson, provide background
             information and A. Gurtov, "The NewReno
             Modification references to TCP's Fast Recovery Algorithm", RFC 3782, April 2004. simulation results.

Appendix A. H.  Document Revision History

             To be removed upon publication

             +----------+--------------------------------------------------+
             | Revision | Comments                                         |
             +----------+--------------------------------------------------+
             | draft-00 | RFC3782 errata applied, and changes applied from |
             |          | draft-nishida-newreno-modification-02            |
             +----------+--------------------------------------------------+
             | draft-01 | Non-normative sections moved to appendices,      |
             |          | editorial clarifications applied as suggested    |
             |          | by Alexander Zimmermann.                         |
             +----------+--------------------------------------------------+

Authors' Addresses

   Thomas R.

   Tom Henderson
   The Boeing Company
   P.O. Box 3707
   Seattle, WA  98124

   EMail: thomas.r.henderson@boeing.com

   Sally Floyd
   International Computer Science Institute

   Phone: +1 (510) 666-2989
   EMail: floyd@acm.org
   URL: http://www.icir.org/floyd/
   Andrei Gurtov
   HIIT
   Helsinki Institute for Information Technology
   Aalto University
   P.O. Box 19800
   Helsinki  FIN-00076
   FINLAND 19215
   00076 Aalto
   Finland

   EMail: gurtov@hiit.fi

   Yoshifumi Nishida
   WIDE Project
   Endo 5322
   Fujisawa, Kanagawa  252-8520
   Japan

   Email: nishida@wide.ad.jp