Movatterモバイル変換

Internet Engineering Task Force (IETF)                      T. HendersonRequest for Comments: 6582                                        BoeingObsoletes:3782                                                 S. FloydCategory: Standards Track                                           ICSIISSN: 2070-1721                                                A. Gurtov                                                      University of Oulu                                                              Y. Nishida                                                            WIDE Project                                                              April 2012The NewReno Modification to TCP's Fast Recovery AlgorithmAbstractRFC 5681 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 Acknowledgment (SACK) option (RFC 2883), and   modifications that respond to "partial acknowledgments" (ACKs that   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.  This document obsoletesRFC 3782.Status of This Memo   This is an Internet Standards Track document.   This document is a product of the Internet Engineering Task Force   (IETF).  It represents the consensus of the IETF community.  It has   received public review and has been approved for publication by the   Internet Engineering Steering Group (IESG).  Further information on   Internet Standards is available inSection 2 of RFC 5741.   Information about the current status of this document, any errata,   and how to provide feedback on it may be obtained athttp://www.rfc-editor.org/info/rfc6582.Henderson, et al.            Standards Track                    [Page 1]

RFC 6582                      TCP NewReno                     April 2012Copyright Notice   Copyright (c) 2012 IETF Trust and the persons identified as the   document authors.  All rights reserved.   This document is subject toBCP 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 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 inRFC 5681   leads to the retransmission of only a single data packet.   Two problems arise with Reno TCP when multiple packet losses occur in   a single 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 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.Henderson, et al.            Standards Track                    [Page 2]

RFC 6582                      TCP NewReno                     April 2012   This document applies to TCP connections that are unable to use the   TCP Selective Acknowledgment (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 acknowledgments, the sender infers a packet   loss, and retransmits the indicated packet.  After this, the data   sender could receive additional duplicate 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 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   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 acknowledgment for the   retransmitted packet will acknowledge some but not all of the packets   transmitted before the fast retransmit.  We call this acknowledgment   a partial acknowledgment.   Along with several other suggestions, [Hoe95] suggested that during   fast recovery the TCP data sender respond 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 inRFC 5681 that incorporates a   response to partial acknowledgments received during fast recovery.   We call this modified fast recovery algorithm NewReno, because it is   a slight but significant variation of the behavior that has been   historically referred to as Reno.  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 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 acknowledgments, for TCP connections that are unable to use   SACK.  Based on our experiences with the NewReno modification in the   network simulator known as ns-2 [NS] and with numerous   implementations of NewReno, we believe that this modification   improves the performance of the fast retransmit and fast recoveryHenderson, et al.            Standards Track                    [Page 3]

RFC 6582                      TCP NewReno                     April 2012   algorithms in a wide variety of scenarios.  Previous versions of this   RFC [RFC2582] [RFC3782] provide simulation-based evidence of the   possible performance gains.2.  Terminology and Definitions   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].   This document defines an additional sender-side state variable called   "recover":      recover:         When in fast recovery, this variable records the send sequence         number that must be acknowledged before the fast recovery         procedure is declared to be over.3.  The Fast Retransmit and Fast Recovery Algorithms in NewReno3.1.  Protocol Overview   The basic idea of these extensions to the fast retransmit and fast   recovery algorithms described inSection 3.2 of [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 NewReno modification 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.Henderson, et al.            Standards Track                    [Page 4]

RFC 6582                      TCP NewReno                     April 20123.2.  Specification   The procedures specified inSection 3.2 of [RFC5681] are followed,   with the modifications listed below.  Note that this specification   avoids the use of the key words defined inRFC 2119 [RFC2119], since   it mainly provides sender-side implementation guidance for   performance improvement, and does not affect interoperability.   1)  Initialization of TCP protocol control block:       When the TCP protocol control block is initialized, recover is       set to the initial send sequence number.   2)  Three duplicate ACKs:       When the third duplicate ACK is received, the TCP sender first       checks the value of recover to see if the Cumulative       Acknowledgment field covers more than recover.  If so, the value       of recover is incremented to the value of the highest sequence       number transmitted by the TCP so far.  The TCP then enters fast       retransmit (step 2 ofSection 3.2 of [RFC5681]).  If not, the TCP       does not enter fast retransmit and does not reset ssthresh.   3)  Response to newly acknowledged data:       Step 6 of [RFC5681] specifies the response to the next ACK that       acknowledges previously unacknowledged data.  When an ACK arrives       that acknowledges new data, this ACK could be the acknowledgment       elicited by the initial retransmission from fast retransmit, or       elicited by a later retransmission.  There are two cases:       Full 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 when fast retransmit was entered,       and where FlightSize in (1) is the amount of data presently       outstanding.  This is termed "deflating" the window.  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       acknowledgment.  Exit the fast recovery procedure.Henderson, et al.            Standards Track                    [Page 5]

RFC 6582                      TCP NewReno                     April 2012       Partial 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 Acknowledgment field.  If the partial ACK acknowledges       at least one SMSS of new data, then add back SMSS bytes to the       congestion window.  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 step 4 ofSection 3.2 of [RFC5681]).       For the first partial ACK that arrives during fast recovery, also       reset the retransmit timer.  Timer management is discussed in       more detail inSection 4.   4)  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 2 above specifies a check that the Cumulative Acknowledgment   field covers more than recover.  Because the acknowledgment field   contains the sequence number that the sender next expects to receive,   the 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 3 above, the congestion window is deflated after a   partial acknowledgment is received.  The congestion window was likely   to have been inflated considerably when the partial acknowledgment   was received.  In addition, depending on the original pattern of   packet losses, the partial 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.Henderson, et al.            Standards Track                    [Page 6]

RFC 6582                      TCP NewReno                     April 2012   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 acknowledgment threshold,   but assumes the threshold specified in the IETF standards; the   current standard is [RFC5681], which specifies a threshold of three   duplicate 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.  Handling Duplicate Acknowledgments after a Timeout   After each retransmit timeout, the highest sequence number   transmitted so far is recorded in the variable recover.  If, after a   retransmit timeout, the TCP data sender retransmits three consecutive   packets that have already been received by the data receiver, then   the TCP data sender will receive three duplicate acknowledgments that   do not cover more than recover.  In this case, the duplicate   acknowledgments are not an indication of 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 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 sender that   implements the algorithm specified inSection 3.2 of this document,   the sender does not infer a packet drop from duplicate   acknowledgments in this scenario.  As always, the retransmit timer is   the backup mechanism for inferring packet loss in this case.   There are several heuristics, based on timestamps or on the amount of   advancement of the Cumulative Acknowledgment field, that allow the   sender to distinguish, in some cases, between three duplicate   acknowledgments following a retransmitted packet that was dropped,   and three duplicate acknowledgments from the unnecessary   retransmission of three packets [Gur03] [GF04].  The TCP sender may   use such a heuristic to decide to invoke a fast retransmit in some   cases, even when the three duplicate acknowledgments do not cover   more than recover.Henderson, et al.            Standards Track                    [Page 7]

RFC 6582                      TCP NewReno                     April 2012   For example, when three duplicate acknowledgments are caused by the   unnecessary retransmission of three packets, this is likely to be   accompanied by the Cumulative Acknowledgment field advancing by at   least four segments.  Similarly, a heuristic based on timestamps uses   the fact that when there is a hole in the sequence space, the   timestamp echoed in the duplicate acknowledgment is the timestamp of   the most recent data packet that advanced the Cumulative   Acknowledgment field [RFC1323].  If timestamps are used, and the   sender stores the timestamp of the last acknowledged segment, then   the timestamp echoed by duplicate acknowledgments can be used to   distinguish between a retransmitted packet that was dropped and three   duplicate acknowledgments from the unnecessary retransmission of   three packets.4.1.  ACK Heuristic   If the ACK-based heuristic is used, then following the advancement of   the Cumulative Acknowledgment field, the sender stores the value of   the previous cumulative acknowledgment as prev_highest_ack, and   stores the latest cumulative ACK as highest_ack.  In addition, the   following check is performed if, in step 2 ofSection 3.2, the   Cumulative Acknowledgment field does not cover more than recover.   2*)  If the Cumulative Acknowledgment field didn't cover more than        recover, check to see if the congestion window is greater than        SMSS bytes and the difference between highest_ack and        prev_highest_ack is at most 4*SMSS bytes.  If true, duplicate        ACKs indicate a lost segment (enter fast retransmit).        Otherwise, duplicate ACKs likely result from unnecessary        retransmissions (do not enter fast retransmit).   The congestion window check serves to protect against fast retransmit   immediately after a retransmit timeout.   If several ACKs are lost, the sender can see a jump in the cumulative   ACK of more than three segments, and the heuristic can fail.   [RFC5681] recommends that a 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 to fail if the   receiver does not follow this advice, because then a smaller number   of ACK losses are needed to produce a sufficient jump in the   cumulative ACK.Henderson, et al.            Standards Track                    [Page 8]

RFC 6582                      TCP NewReno                     April 20124.2.  Timestamp Heuristic   If this heuristic is used, the sender stores the timestamp of the   last acknowledged segment.  In addition, the last sentence of step 2   inSection 3.2 of this document is replaced as follows:   2**) If the Cumulative Acknowledgment field didn't cover more than        recover, check to see if the echoed timestamp in the last        non-duplicate acknowledgment equals the stored timestamp.  If        true, duplicate ACKs indicate a lost segment (enter fast        retransmit).  Otherwise, duplicate ACKs likely result from        unnecessary retransmissions (do not enter fast retransmit).   The timestamp heuristic works correctly, both when the receiver   echoes timestamps, as specified by [RFC1323], and by its revision   attempts.  However, if the receiver arbitrarily echoes timestamps,   the heuristic can fail.  The heuristic can also fail if a timeout was   spurious and returning ACKs are not from retransmitted segments.   This can be prevented by detection algorithms such as the Eifel   detection algorithm [RFC3522].5.  Implementation Issues for the 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 potential benefit of   NewReno by delaying the receipt of the partial acknowledgment at the   data sender.  Echoing [RFC5681], our recommendation is that the data   receiver send an immediate acknowledgment for an out-of-order   segment, even when that out-of-order segment fills a hole in the   buffer.6.  Implementation Issues for the Data Sender   InSection 3.2, step 3 above, it is noted that implementations should   take measures to avoid a possible burst of data when leaving fast   recovery, in case the amount of new data that the sender is eligible   to send due to the new value of the congestion window is large.  This   can arise during NewReno when ACKs are lost or treated as pure window   updates, thereby causing the sender to underestimate the number of   new segments that can be sent during the recovery procedure.   Specifically, bursts can occur when the FlightSize is much less than   the new congestion window when exiting from fast recovery.  One   simple mechanism to avoid a burst of data when leaving fast recoveryHenderson, et al.            Standards Track                    [Page 9]

RFC 6582                      TCP NewReno                     April 2012   is to limit the number of data packets that can be sent in response   to a single acknowledgment.  (This is known as "maxburst_" in ns-2   [NS].)  Other possible mechanisms for avoiding bursts include rate-   based pacing, or setting the slow start threshold to the resultant   congestion window and then resetting the congestion window to   FlightSize.  A recommendation on the general mechanism to avoid   excessively bursty sending patterns is outside the scope of this   document.   An implementation may want to use a separate flag to record whether   or not it is presently in the fast recovery procedure.  The use of   the value of the duplicate acknowledgment counter for this purpose is   not reliable, because it can be reset upon window updates and out-of-   order acknowledgments.   When updating the Cumulative Acknowledgment field outside of fast   recovery, the state variable recover may also need to be updated in   order to continue to permit possible entry into fast recovery   (Section 3.2, step 2).  This issue arises when an update of the   Cumulative Acknowledgment field results in a sequence wraparound that   affects the ordering between the Cumulative Acknowledgment field and   the state variable recover.  Entry into fast recovery is only   possible when the Cumulative Acknowledgment field covers more than   the state variable recover.   It is important for the sender to respond correctly to duplicate ACKs   received when the sender 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 acknowledgments are   received, the Cumulative Acknowledgment field doesn't cover more than   recover, and a new fast recovery is not invoked, the sender should   follow the guidance inSection 4.  Otherwise, the sender could end up   in a chain of spurious timeouts.  We mention this only because   several NewReno implementations had this bug, including the   implementation in ns-2 [NS].   It has been observed that some TCP implementations enter a slow start   or congestion avoidance window updating algorithm immediately after   the cwnd is set by the equation found inSection 3.2, step 3, even   without a new external event generating the cwnd change.  Note that   after cwnd is set based on the procedure for exiting fast recovery   (Section 3.2, step 3), cwnd should not be updated until a further   event occurs (e.g., arrival of an ack, or timeout) after this   adjustment.Henderson, et al.            Standards Track                   [Page 10]

RFC 6582                      TCP NewReno                     April 20127.  Security Considerations   [RFC5681] discusses general security considerations concerning TCP   congestion control.  This document describes a specific algorithm   that conforms with the congestion control requirements of [RFC5681],   and so those considerations apply to this algorithm, too.  There are   no known additional security concerns for this specific algorithm.8.  Conclusions   This document specifies the NewReno fast retransmit and fast recovery   algorithms for TCP.  This NewReno modification to TCP can even be   important for TCP implementations that support the SACK option,   because the SACK option can only be used for TCP connections when   both TCP end-nodes support the SACK option.  NewReno performs better   than Reno in a number of scenarios discussed in previous versions of   this RFC ([RFC2582] [RFC3782]).   A number of options for the basic algorithms presented inSection 3   are also referenced inAppendix A of this document.  These include   the handling of the retransmission timer, the response to partial   acknowledgments, and whether or not the sender must maintain a state   variable called recover.  Our belief is that the differences between   these variants of NewReno are small compared to the differences   between Reno and NewReno.  That is, the important thing is to   implement NewReno instead of Reno for a TCP connection without SACK;   it is less important exactly which variant of NewReno is implemented.9.  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 the precursor RFCs 2582 and 3782.  Jeffrey Hsu provided   clarifications on the handling of the variable recover; these   clarifications were applied toRFC 3782 via an erratum and are   incorporated into the text ofSection 6 of this document.  Yoshifumi   Nishida contributed a modification to the fast recovery algorithm to   account for the case in which FlightSize is 0 when the TCP sender   leaves fast recovery and the TCP receiver uses delayed   acknowledgments.  Alexander Zimmermann provided several suggestions   to improve the clarity of the document.Henderson, et al.            Standards Track                   [Page 11]

RFC 6582                      TCP NewReno                     April 201210.  References10.1.  Normative References   [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate             Requirement Levels",BCP 14,RFC 2119, March 1997.   [RFC5681] Allman, M., Paxson, V., and E. Blanton, "TCP Congestion             Control",RFC 5681, September 2009.10.2.  Informative References   [C98]     Cardwell, N., "delayed ACKs for retransmitted packets:             ouch!".  November 1998, Email to the tcpimpl mailing list,             archived at             <http://groups.yahoo.com/group/tcp-impl/message/1428>.   [F94]     Floyd, S., "TCP and Successive Fast Retransmits", Technical             report, May 1995.             <ftp://ftp.ee.lbl.gov/papers/fastretrans.ps>.   [FF96]    Fall, K. and S. Floyd, "Simulation-based Comparisons of             Tahoe, Reno and SACK TCP", Computer Communication Review,             July 1996.  <ftp://ftp.ee.lbl.gov/papers/sacks.ps.Z>.   [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.  <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, July 28, 2003.  <http://www.ietf.org/mail-archive/web/tsvwg/current/msg04334.html>.   [Hen98]   Henderson, T., "Re: NewReno and the 2001 Revision",             September 1998.  Email to the tcpimpl mailing list,             archived at             <http://groups.yahoo.com/group/tcp-impl/message/1321>.   [Hoe95]   Hoe, J., "Startup Dynamics of TCP's Congestion Control and             Avoidance Schemes", Master's Thesis, MIT, June 1995.   [Hoe96]   Hoe, J., "Improving the Start-up Behavior of a Congestion             Control Scheme for TCP", ACM SIGCOMM, August 1996.             <http://ccr.sigcomm.org/archive/1996/conf/hoe.pdf>.Henderson, et al.            Standards Track                   [Page 12]

RFC 6582                      TCP NewReno                     April 2012   [LM97]    Lin, D. and R. Morris, "Dynamics of Random Early             Detection", SIGCOMM 97, October 1997.   [NS]      "The Network Simulator version 2 (ns-2)",             <http://www.isi.edu/nsnam/ns/>.   [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., Mahdavi, J., Mathis, M., and M. Podolsky, "An             Extension to the Selective Acknowledgement (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., Henderson, T., and A. Gurtov, "The NewReno             Modification to TCP's Fast Recovery Algorithm",RFC 3782,             April 2004.Henderson, et al.            Standards Track                   [Page 13]

RFC 6582                      TCP NewReno                     April 2012Appendix A.  Additional Information   Previous versions of this RFC ([RFC2582] [RFC3782]) contained   additional informative material on the following subjects, and may be   consulted by readers who may want more information about possible   variants to the algorithms and who may want references to specific   [NS] simulations that provide NewReno test cases.Section 4 of [RFC3782] discusses some alternative behaviors for   resetting the retransmit timer after a partial acknowledgment.Section 5 of [RFC3782] discusses some alternative behaviors for   performing retransmission after a partial acknowledgment.Section 6 of [RFC3782] describes more information about the   motivation for the sender's state variable recover.Section 9 of [RFC3782] introduces some NS simulation test suites for   NewReno.  In addition, references to simulation results can be found   throughout [RFC3782].Section 10 of [RFC3782] provides a comparison of Reno and   NewReno TCP.Section 11 of [RFC3782] lists changes relative to [RFC2582].Appendix B.  Changes Relative toRFC 3782   In [RFC3782], the cwnd after Full ACK reception will be set to   (1) min (ssthresh, FlightSize + SMSS) or (2) ssthresh.  However, the   first option carries a risk of performance degradation: With the   first option, if FlightSize is zero, the result will be 1 SMSS.  This   means TCP can transmit only 1 segment at that moment, which can cause   a delay in ACK transmission at the receiver due to a delayed ACK   algorithm.   The FlightSize on Full ACK reception can be zero in some situations.   A typical example is where the sending window size during fast   recovery is small.  In this case, the retransmitted packet and new   data packets can be transmitted within a short interval.  If all   these packets successfully arrive, the receiver may generate a Full   ACK that acknowledges all outstanding data.  Even if the window size   is not small, loss of ACK packets or a receive buffer shortage during   fast recovery can also increase the possibility of falling into this   situation.Henderson, et al.            Standards Track                   [Page 14]

RFC 6582                      TCP NewReno                     April 2012   The proposed fix in this document, which sets cwnd to at least 2*SMSS   if the implementation uses option 1 in the Full ACK case   (Section 3.2, step 3, option 1), ensures that the sender TCP   transmits at least two segments on Full ACK reception.   In addition, an erratum was reported forRFC 3782 (an editorial   clarification toSection 8); this erratum has been addressed inSection 6 of this document.   The specification text (Section 3.2 herein) was rewritten to more   closely trackSection 3.2 of [RFC5681].   Sections4,5, and9-11 of [RFC3782] were removed, and insteadAppendix A of this document was added to back-reference this   informative material.  A few references that have no citation in the   main body of the document have been removed.Henderson, et al.            Standards Track                   [Page 15]

RFC 6582                      TCP NewReno                     April 2012Authors' Addresses   Tom Henderson   The Boeing Company   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   University of Oulu   Centre for Wireless Communications CWC   P.O. Box 4500   FI-90014 University of Oulu   Finland   EMail: gurtov@ee.oulu.fi   Yoshifumi Nishida   WIDE Project   Endo 5322   Fujisawa, Kanagawa  252-8520   Japan   EMail: nishida@wide.ad.jpHenderson, et al.            Standards Track                   [Page 16]