RFC 6582

The NewReno Modification to TCP's Fast Recovery Algorithm

📅 published April 2012, from ietf

RFC 6582 🎀 The NewReno Modification to TCP's Fast Recovery Algorithm

Okay bestie, so this is RFC 6582 💖, and it's all about a TCP tweak called NewReno. It's a Standards Track document, published in April 2012, with ISSN 2070-1721. The authors are T. Henderson (Boeing), S. Floyd (ICSI), A. Gurtov (University of Oulu), and Y. Nishida (WIDE Project). It obsoletes RFC 3782 🦋, so that older one is officially replaced now. Slay 💅

Abstract

Okay so RFC 5681 lays out four TCP congestion control algorithms that are super intertwined: slow start, congestion avoidance, fast retransmit, and fast recovery. It explicitly allows some modifications of these, including ones that use the TCP Selective Acknowledgment (SACK) option (RFC 2883), and ones that respond to "partial acknowledgments" (ACKs that cover new data, but not all the data outstanding when loss was detected) when SACK isn't in the picture. This doc describes one specific algorithm for handling partial acknowledgments, called "NewReno" ✨. Janey Hoe was the first to propose this partial acknowledgment response 👑.

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 in Section 2 of RFC 5741.

Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at http://www.rfc-editor.org/info/rfc6582 🌸

Copyright (c) 2012 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.

Lowkey the legal bit matters: if you pull code out of this doc, it needs the Simplified BSD License text with it, and it comes with no warranty.

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 ✨

Okay so let's start with the typical version of the TCP fast recovery algorithm from [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 happened, or after three duplicate acknowledgments have arrived and kicked off the fast retransmit algorithm. A single retransmit timeout might lead to several data packets being retransmitted, but each time the fast retransmit algorithm runs under RFC 5681, only a single data packet gets retransmitted 🦋

Reno has two problems when multiple packets get lost from the same window. First, Reno will often take a timeout, as documented in [Hoe95]. Second, even if a retransmission timeout is avoided, you can end up with multiple fast retransmits and window reductions, as documented in [F94]. When multiple packets are lost, if the SACK option [RFC2883] is available, the TCP sender has the info it needs to make smart choices about which packets to retransmit and which ones to leave alone during fast recovery 🧠

This document applies to TCP connections that can't use the TCP Selective Acknowledgment (SACK) option. That happens either because the option isn't locally supported, or because the TCP peer didn't indicate it was willing to use SACK 🙈

Without SACK, the TCP sender doesn't have much info to work with when it's making retransmission decisions during fast recovery. From the three duplicate acknowledgments, the sender infers a packet loss and retransmits the indicated packet. After that, the data sender might keep getting duplicate acknowledgments, because the data receiver is acknowledging additional data packets that were already in flight when the sender entered fast retransmit 💀

When multiple packets are dropped from a single window of data, the first new information the sender gets comes when it receives an acknowledgment for the retransmitted packet (that is, the packet retransmitted when fast retransmit was first entered). If there's a single packet drop and no reordering, that acknowledgment will cover all of the packets transmitted before fast retransmit was entered. But if there are multiple drops, then the acknowledgment for the retransmitted packet only covers some of the packets sent before the fast retransmit. We call this acknowledgment a partial acknowledgment 🎀

Along with several other suggestions, [Hoe95] proposed 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 in RFC 5681 that bakes in a response to partial acknowledgments received during fast recovery. We call this modified fast recovery algorithm NewReno, because it's a slight but significant variation of the behavior that has historically been called Reno 👑 This document doesn't discuss the other suggestions in [Hoe95] and [Hoe96], like 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 can't 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 this modification improves the performance of the fast retransmit and fast recovery 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 NewReno 🦋

3.1. Protocol Overview 💅

The basic idea behind these extensions to the fast retransmit and fast recovery algorithms described in Section 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 because of that event. It's giving smart sender energy 🧚

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. ✨

3.2. Specification ✨

okay so the procedures in Section 3.2 of [RFC5681] still apply, just with a few mods listed below 💅 quick heads up: this spec skips the key words from RFC 2119 [RFC2119] on purpose 🫶 it's mostly sender-side guidance for performance and doesn't touch interoperability, so no drama 🌸

  1. Initialization of TCP protocol control block: when the TCP protocol control block is initialized, recover gets set to the initial send sequence number 🎀
  2. Three duplicate ACKs: when the third duplicate ACK shows up, the TCP sender first checks recover to see if the Cumulative Acknowledgment field covers more than recover. if it does, recover gets bumped up to the highest sequence number the TCP has transmitted so far. then the TCP enters fast retransmit (step 2 of Section 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] covers the response to the next ACK that acknowledges previously unacknowledged data. when an ACK comes in that acknowledges new data, it could be the acknowledgment kicked off by the initial retransmission from fast retransmit, or one kicked off by a later retransmission. there are two cases here 👑
    • Full acknowledgments: if this ACK acknowledges all of the data up to and including recover, then it 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 called "deflating" the window 🦋 if you pick the second option, the implementation is encouraged to take measures to avoid a possible burst of data, just in case the amount of data outstanding in the network is way 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. then exit the fast recovery procedure ✨
    • Partial acknowledgments: if this ACK does not acknowledge all of the data up to and including recover, then it's 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, add back SMSS bytes to the congestion window. this artificially inflates the congestion window to reflect the extra segment that has left the network 🧚 then send a new segment if the new value of cwnd permits it. this "partial window deflation" tries to make sure that, when fast recovery eventually ends, roughly ssthresh amount of data will be outstanding in the network. do not exit the fast recovery procedure (so if any duplicate ACKs show up later, execute step 4 of Section 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 in Section 4 ⏰

  1. 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 checks that the Cumulative Acknowledgment field covers more than recover. because the acknowledgment field holds the sequence number the sender expects to receive next, the acknowledgment ack_number covers more than recover when:

ack_number - 1 > recover;

that's the same as saying 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 gets deflated after a partial acknowledgment is received. the congestion window was probably pretty inflated by the time that partial ACK showed up 😭 plus, depending on the original pattern of packet losses, the partial acknowledgment might acknowledge nearly a whole window of data. in that case, if the congestion window wasn't deflated, the data sender could send nearly a whole window back-to-back, which is a lot 💀

this document doesn't specify how the sender responds to duplicate ACKs when the fast retransmit/fast recovery algorithm isn't invoked. that's covered in other documents, like the ones describing the Limited Transmit procedure [RFC3042] 🌈 this document also doesn't deal with adjusting the duplicate acknowledgment threshold. it assumes the threshold from the IETF standards, and the current standard is [RFC5681], which sets the threshold at three duplicate acknowledgments ✨

one last thing: without the SACK option, the data sender is working with pretty limited info. if recovering from multiple dropped packets out of a single window of data really matters to you, the best option is to use the SACK option 👑

4. Handling Duplicate Acknowledgments after a Timeout 🌸

after each retransmit timeout, the highest sequence number transmitted so far gets recorded in the variable recover. if, after a retransmit timeout, the TCP data sender retransmits three consecutive packets that the data receiver already has, then the TCP data sender will receive three duplicate acknowledgments that don't cover more than recover. in that case the duplicate ACKs aren't a sign of a new congestion event. they just show that the sender unnecessarily retransmitted at least three packets 🙈

but here's the twist: when a retransmitted packet is itself dropped, the sender can also get three duplicate ACKs that don't cover more than recover. in that case the sender would've been better off starting fast retransmit 😩 for a TCP sender that implements the algorithm in Section 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 here ⏰

there are several heuristics, based on timestamps or on how far the Cumulative Acknowledgment field advanced, that let the sender tell apart, in some cases, three duplicate ACKs following a dropped retransmitted packet and three duplicate ACKs from unnecessarily retransmitting 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 don't cover more than recover.

for example, when three duplicate ACKs are caused by unnecessarily retransmitting three packets, that's likely to come with the Cumulative Acknowledgment field advancing by at least four segments 🧁 similarly, a timestamp-based heuristic uses the fact that when there's a hole in the sequence space, the timestamp echoed in the duplicate ACK 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 ACKs can tell apart a dropped retransmitted packet from three duplicate ACKs caused by unnecessarily retransmitting three packets 💖

4.1. ACK Heuristic 🎀

if the ACK-based heuristic is used, then after the Cumulative Acknowledgment field advances, the sender stores the previous cumulative acknowledgment as prev_highest_ack, and stores the latest cumulative ACK as highest_ack. on top of that, the following check runs if, in step 2 of Section 3.2, the Cumulative Acknowledgment field doesn't cover more than recover.

2*) if the Cumulative Acknowledgment field didn't cover more than recover, check whether 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 that's 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 is there to protect against fast retransmit right 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 then the heuristic can fail 😬 [RFC5681] recommends that a receiver send duplicate ACKs for every out-of-order data packet, like a data packet received during fast recovery. the ACK heuristic is more likely to fail if the receiver doesn't follow this advice, because then fewer ACK losses are needed to produce a big enough jump in the cumulative ACK 🌊

4.2. Timestamp Heuristic ⏳

if this heuristic is used, the sender stores the timestamp of the last acknowledged segment. on top of that, the last sentence of step 2 in Section 3.2 of this document gets replaced like this:

2**) if the Cumulative Acknowledgment field didn't cover more than recover, check whether the echoed timestamp in the last non-duplicate acknowledgment equals the stored timestamp. if that's 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 also with its revision attempts 🦋 however, if the receiver echoes timestamps arbitrarily, the heuristic can fail. it can also fail if a timeout was spurious and the returning ACKs aren't from retransmitted segments 🙃 detection algorithms like the Eifel detection algorithm [RFC3522] can prevent that.

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 don't send an immediate acknowledgment when they send a partial acknowledgment, and instead wait for their delayed acknowledgment timer to expire [C98] 😤 as [C98] points out, that severely limits the potential benefit of NewReno, because the partial acknowledgment gets delayed on its way to 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 ✨

okay bestie, so back in Section 3.2, step 3, it says implementations should take measures to avoid a possible burst of data when leaving fast recovery 💥. The worry is that the new congestion window can let you send a LOT of new data at once. This happens in NewReno when ACKs get lost or get treated as pure window updates. Then the sender undercounts how many new segments it can send during recovery 🙈. Bursts show up when FlightSize is way less than the new congestion window on exit.

One simple fix is to limit how many data packets go out in response to a single acknowledgment. This is called maxburst_ in ns-2 [NS] 🎀. Other options are rate-based pacing, or setting the slow start threshold to the resulting congestion window and then resetting the congestion window to FlightSize 🌸. The general mechanism for avoiding excessively bursty sending patterns is outside the scope of this document, so we're not going to go deep on it here.

An implementation may want a separate flag to record whether or not it's currently in the fast recovery procedure 🚩. Using the duplicate acknowledgment counter for this is not reliable, because the counter can be reset by window updates and out-of-order acknowledgments. Total mess, so don't do it 💀.

When you update the Cumulative Acknowledgment field outside of fast recovery, the state variable recover may also need an update. That keeps you allowed to enter fast recovery later (Section 3.2, step 2) 🔑. This gets tricky when a Cumulative Acknowledgment update causes a sequence wraparound that messes up the ordering between the Cumulative Acknowledgment field and recover. Entry into fast recovery is only possible when the Cumulative Acknowledgment field covers more than the state variable recover.

It's important for the sender to respond correctly to duplicate ACKs when it's no longer in fast recovery, for example 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 arrive, the Cumulative Acknowledgment field doesn't cover more than recover, and a new fast recovery is not invoked, the sender should follow the guidance in Section 4. If it doesn't, the sender could end up in a chain of spurious timeouts 😭. We only mention this because several NewReno implementations had this bug, including the implementation in ns-2 [NS] 💅.

Some TCP implementations enter a slow start or congestion avoidance window updating algorithm right after cwnd is set by the equation in Section 3.2, step 3, even without a new external event causing the change 👀. So, 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 (for example, arrival of an ack, or timeout) after this adjustment. Patience is a virtue, bestie 🧚.

7. 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], so those considerations apply to this algorithm too. There are no known additional security concerns for this specific algorithm. No drama here, just the standard stuff 🫶.

8. Conclusions 👑

This document specifies the NewReno fast retransmit and fast recovery algorithms for TCP. Honestly this NewReno modification is iconic, and it can even matter for TCP implementations that support the SACK option 🔥. The reason is that 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 in Section 3 are also referenced in Appendix 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 🧩. The authors believe the differences between these variants of NewReno are small compared to the differences between Reno and NewReno. So the main thing is to implement NewReno instead of Reno for a TCP connection without SACK. Which exact variant of NewReno you pick matters less 🌈.

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 to RFC 3782 via an erratum and are incorporated into the text of Section 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 ✍️.

10. References 📚

10.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>.

[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.

Appendix A. Additional Information 🗂️

Previous versions of this RFC ([RFC2582] [RFC3782]) contained additional informative material on the following subjects. Readers who want more information about possible variants of the algorithms, or references to specific [NS] simulations that provide NewReno test cases, may consult them 🔍.

  • 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 to RFC 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. That 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 🫠.

The proposed fix in this document 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). This ensures that the sender TCP transmits at least two segments on Full ACK reception 🎉.

In addition, an erratum was reported for RFC 3782 (an editorial clarification to Section 8). This erratum has been addressed in Section 6 of this document ✅.

The specification text (Section 3.2 herein) was rewritten to more closely track Section 3.2 of [RFC5681] ✍️.

Sections 4, 5, and 9-11 of [RFC3782] were removed, and instead Appendix 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 🧹.

Authors' Addresses ✨

okay bestie, here's the whole squad behind this doc and how to reach each of them 💌🫶

Tom Henderson 🎀

Tom Henderson
The Boeing Company

EMail: thomas.r.henderson@boeing.com

Sally Floyd 🦋

Sally Floyd
International Computer Science Institute

Phone: +1 (510) 666-2989
EMail: floyd@acm.org
URL: http://www.icir.org/floyd/

Andrei Gurtov 🌸

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 🧚

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

EMail: nishida@wide.ad.jp

that's the full crew, periodt 👑✨

📦 where this page comes from