Skip to main content

Increase of the Congestion Window when the Sender Is Rate-Limited
draft-ietf-ccwg-ratelimited-increase-08

The information below is for an old version of the document.
Document Type
This is an older version of an Internet-Draft whose latest revision state is "Active".
Authors Michael Welzl , Tom Henderson , Gorry Fairhurst , Mohit P. Tahiliani
Last updated 2026-08-06 (Latest revision 2026-08-05)
Replaces draft-welzl-ccwg-ratelimited-increase
RFC stream Internet Engineering Task Force (IETF)
Formats
Reviews
Additional resources Mailing list discussion
Stream WG state Submitted to IESG for Publication
Associated WG milestone
Submit Rate-Limited Increase of the Congestion Window for publication as a PS
Document shepherd Reese Enghardt
Shepherd write-up Show Last changed 2026-04-24
IESG IESG state IESG Evaluation::AD Followup
Consensus boilerplate Yes
Telechat date (None)
Has enough positions to pass.
Responsible AD Mike Bishop
Send notices to ietf@tenghardt.net
IANA IANA review state IANA OK - No Actions Needed
draft-ietf-ccwg-ratelimited-increase-08
Congestion Control Working Group                                M. Welzl
Internet-Draft                                        University of Oslo
Updates: 4341, 5681, 9002, 9260, 9438 (if                   T. Henderson
         approved)                              University of Washington
Intended status: Standards Track                            G. Fairhurst
Expires: 6 February 2027                          University of Aberdeen
                                                         M. P. Tahiliani
                              National Institute of Technology Karnataka
                                                           5 August 2026

   Increase of the Congestion Window when the Sender Is Rate-Limited
                draft-ietf-ccwg-ratelimited-increase-08

Abstract

   This document specifies how transport protocols increase their
   congestion window when the sender is rate-limited, and updates RFCs
   4341, 5681, 9002, 9260, and 9438.  Such a limitation can be caused by
   the sending application not supplying data or by receiver flow
   control.

About This Document

   This note is to be removed before publishing as an RFC.

   The latest revision of this draft can be found at https://ietf-wg-
   ccwg.github.io/draft-ietf-ccwg-ratelimited-increase/draft-ietf-ccwg-
   ratelimited-increase.html.  Status information for this document may
   be found at https://datatracker.ietf.org/doc/draft-ietf-ccwg-
   ratelimited-increase/.

   Discussion of this document takes place on the Congestion Control
   Working Group mailing list (mailto:ccwg@ietf.org), which is archived
   at https://mailarchive.ietf.org/arch/browse/ccwg/.  Subscribe at
   https://www.ietf.org/mailman/listinfo/ccwg/.

   Source for this draft and an issue tracker can be found at
   https://github.com/ietf-wg-ccwg/draft-ietf-ccwg-ratelimited-increase.

Status of This Memo

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

Welzl, et al.            Expires 6 February 2027                [Page 1]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   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 https://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 6 February 2027.

Copyright Notice

   Copyright (c) 2026 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 (https://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 Revised BSD License text as
   described in Section 4.e of the Trust Legal Provisions and are
   provided without warranty as described in the Revised BSD License.

Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   3
   2.  Conventions and Definitions . . . . . . . . . . . . . . . . .   3
     2.1.  Terminology . . . . . . . . . . . . . . . . . . . . . . .   3
   3.  Rate-Limited Increase . . . . . . . . . . . . . . . . . . . .   4
     3.1.  Example . . . . . . . . . . . . . . . . . . . . . . . . .   5
       3.1.1.  Unconstrained sender  . . . . . . . . . . . . . . . .   5
       3.1.2.  Sender constrained by Rate-Limited Increase . . . . .   6
     3.2.  Discussion  . . . . . . . . . . . . . . . . . . . . . . .   6
       3.2.1.  Rate-based congestion control . . . . . . . . . . . .   6
       3.2.2.  Pacing  . . . . . . . . . . . . . . . . . . . . . . .   7
   4.  Updates to RFCs 4341, 5681, 9002, 9260, and 9438  . . . . . .   7
     4.1.  RFC 4341: Profile for Datagram Congestion Control Protocol
           (DCCP) Congestion Control ID 2: TCP-like Congestion
           Control . . . . . . . . . . . . . . . . . . . . . . . . .   7
     4.2.  RFC 5681: TCP Congestion Control  . . . . . . . . . . . .   7
     4.3.  RFC 9002: QUIC Loss Detection and Congestion Control  . .   7
     4.4.  RFC 9260: Stream Control Transmission Protocol  . . . . .   8
     4.5.  RFC 9438: CUBIC for Fast and Long-Distance Networks . . .   8
   5.  Security Considerations . . . . . . . . . . . . . . . . . . .   9
   6.  IANA Considerations . . . . . . . . . . . . . . . . . . . . .   9

Welzl, et al.            Expires 6 February 2027                [Page 2]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   7.  References  . . . . . . . . . . . . . . . . . . . . . . . . .   9
     7.1.  Normative References  . . . . . . . . . . . . . . . . . .   9
     7.2.  Informative References  . . . . . . . . . . . . . . . . .  10
   Appendix A.  An Example Using cwnd Represented in Bytes . . . . .  10
   Appendix B.  Change Log . . . . . . . . . . . . . . . . . . . . .  13
   Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . .  15
   Authors' Addresses  . . . . . . . . . . . . . . . . . . . . . . .  15

1.  Introduction

   A sender of a congestion controlled transport protocol becomes "rate-
   limited" when it does not send any data even though the congestion
   control rules would allow it to transmit data.  This could occur
   because the application has not provided sufficient data to fully
   utilize the congestion window (cwnd).  It could also occur because
   the receiver has limited the sender using flow control (e.g., by the
   advertised TCP receiver window (rwnd) or by the connection or stream
   flow credit in QUIC).  Current RFCs specifying congestion control
   algorithms diverge regarding the rules for increasing the cwnd when
   the sender is rate-limited.  This document provides a uniform
   behavior in (Section 3), and specifies updates to RFCs 4341, 5681,
   9002, 9260, and 9438 in (Section 4).

   Congestion Window Validation (CWV) [RFC7661] provides an experimental
   specification defining how to manage a cwnd that has become larger
   than the current flight size, and how to respond to detected
   congestion when this is the case.  In contrast, this present document
   concerns the increase in cwnd when a sender is rate-limited.  These
   two topics are distinct, but are related, because both describe the
   management of the cwnd when a sender does not fully utilize the
   current cwnd.

   An appendix provides an example of how rate-limited increase can play
   out.

2.  Conventions and Definitions

   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
   "OPTIONAL" in this document are to be interpreted as described in
   BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all
   capitals, as shown here.

2.1.  Terminology

   This document uses the terms defined in Section 2 of [RFC5681].

   Additionally, the following are defined:

Welzl, et al.            Expires 6 February 2027                [Page 3]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   *  cwnd-limited: A flow that has sent the maximum number of segments
      permitted by the cwnd, where the application utilises the allowed
      sending rate (based on the definition for TCP in Section 4.5.3 of
      [RFC7661]).

   *  rate-limited: A flow that does not consume more than one half of
      cwnd and hence operates in the non-validated phase.  This includes
      periods when an application is either idle or chooses to send at a
      rate less than the maximum permitted by the cwnd (based on the
      definition for TCP in Section 3 of [RFC7661]).

   *  initcwnd: The initial value of the congestion window, also known
      as the "initial window" ("IW" in [RFC5681]).

   *  maxFS: the largest value of FlightSize since the last time that
      cwnd was decreased.  If cwnd has never been decreased, maxFS is
      the maximum value of FlightSize since the start of the data
      transfer, and at least as large as initcwnd.

3.  Rate-Limited Increase

   When FlightSize < cwnd, regardless of the current state of a
   congestion control algorithm, the following "Rate-Limited Increase"
   rules apply for senders using a congestion controlled transport
   protocol:

   *  The sender MUST initialise the maxFS parameter to initcwnd when
      the congestion control algorithm is started.  Thereafter, when the
      FlightSize is updated, the sender also updates the maxFS:

   maxFS = max(FlightSize, maxFS)

   *  Upon a reduction of cwnd (for any reason), maxFS MUST be reset to
      zero.  This ensures that maxFS is reinitialized using the first
      FlightSize measurement taken after the cwnd reduction.

   *  The sender MUST cap cwnd to be no larger than limit(maxFS).

   The function limit() returns the maximum cwnd value the congestion
   control algorithm would yield by increasing for all ACKs that would
   be produced by successfully transmitting one window of size maxFS.
   For example, for Slow Start, as specified in [RFC5681],
   limit(maxFS)=2*maxFS, such that equation 2 in [RFC5681] becomes:

   cwnd_new = cwnd + min (N, SMSS)
   cwnd = min(cwnd_new, 2*maxFS)

Welzl, et al.            Expires 6 February 2027                [Page 4]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   where cwnd and SMSS follow their definitions in [RFC5681] and N is
   the number of previously unacknowledged bytes acknowledged in the
   incoming ACK.

   Similarly, with Rate-Limited Increase applied in Congestion
   Avoidance, limit(maxFS)=SMSS+maxFS, such that equation 3 in [RFC5681]
   becomes:

   cwnd_new = cwnd + SMSS*SMSS/cwnd
   cwnd = min(cwnd_new, SMSS+maxFS)

   where cwnd and SMSS follow their definitions in [RFC5681].

   NOTE: This specification defines the current method used to increase
   the cwnd for a rate-limited sender.  Without a way to reduce cwnd
   when the transport sender becomes rate-limited, maxFS can stay valid
   for a long time, possibly not reflecting the reality of the end-to-
   end Internet path in use.  This can be remedied by "Congestion Window
   Validation" in [RFC7661], which also defines a "pipeACK" variable
   that measures the recently acknowledged size of the network pipe when
   the sender was rate-limited.

3.1.  Example

   The working of Rate-Limited Increase can be illustrated by showing
   the increase of cwnd in two scenarios: when the growth of cwnd is
   unconstrained, and when the rate-limited sender is constrained by
   Rate-Limited Increase.  For simplicity, this example accounts for the
   cwnd in TCP segments (or QUIC packets), rather than bytes.  In both
   cases, this assumes the initial cwnd (initcwnd) = 10 segments, as
   defined for TCP in [RFC6928] and QUIC in [RFC9002], a single
   connection begins with Slow Start, the sender transmits a total of 14
   segments but pauses after transmitting 10 segments and resumes the
   transmission for the remaining 4 segments afterward, no packets are
   lost, and an ACK is sent for every packet.

3.1.1.  Unconstrained sender

   Initially, cwnd = initcwnd.  Therefore, using initcwnd = 10 segments,
   the sender transmits 10 segments and pauses.  Since the sender is in
   the Slow Start phase, the arrival of each ACK for the 10 sent
   segments increases the cwnd by 1 segment, resulting in the cwnd
   increasing to 20 segments.  Subsequently, after the pause, the sender
   transmits 4 segments and pauses again.  As a consequence, the arrival
   of 4 ACKs results in cwnd further increasing to 24 segments, even
   though the sender is rate-limited (i.e., has never sent more than 10
   segments per round-trip time (RTT)).

Welzl, et al.            Expires 6 February 2027                [Page 5]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

3.1.2.  Sender constrained by Rate-Limited Increase

   Initially, cwnd = initcwnd.  Therefore, using initcwnd = 10 segments,
   the sender transmits 10 segments and pauses; note that FlightSize and
   maxFS are both 10 segments at this point.  Since the sender is in the
   Slow Start phase, the arrival of each ACK for the 10 sent segments
   increases the cwnd by 1 segment, resulting in the cwnd increasing to
   20 segments.  Subsequently, when the sender resumes and transmits 4
   new segments, Rate-Limited Increase constrains the growth of the cwnd
   because FlightSize < cwnd and therefore this caps the cwnd to be no
   larger than limit(maxFS) = 2 X maxFS = 2 X 10 segments = 20 segments.

3.2.  Discussion

   If the sending rate is less than the rate permitted by the cwnd for
   multiple RTTs, limited either by the sending application or by the
   receiver-advertised window, a continuous increase in the cwnd would
   cause a mismatch between the cwnd and the capacity that the path
   supports (i.e., over-estimating the capacity).  Such unlimited growth
   in the cwnd is therefore disallowed.

   However, in most common congestion control algorithms, in the absence
   of an indication of congestion, a cwnd that has been fully utilized
   during an RTT (where a sender was cwnd-limited) permits the cwnd to
   be increased during the immediately following RTT.  This increase is
   allowed by Rate-Limited Increase.

3.2.1.  Rate-based congestion control

   The present document updates congestion control specifications that
   use a cwnd to limit the number of unacknowledged bytes (or packets)
   that a sender is allowed to emit.  Use of a cwnd variable to control
   sending rate is not the only mechanism available and not the only
   mechanism that is used in practice.

   Congestion control algorithms can also constrain data transmission by
   explicitly calculating the sending rate over some time interval, by
   "pacing" packets (injecting pauses in between their transmission) or
   via combinations of the above (e.g., BBR combines these three methods
   [I-D.ietf-ccwg-bbr]).  The guiding principle behind Rate-Limited
   Increase applies to all congestion control algorithms: in the absence
   of a congestion indication, a sender is allowed to increase its rate
   from the amount of data that it has transmitted during the previous
   RTT (this holds irrespective of whether the sender is rate-limited or
   not).

Welzl, et al.            Expires 6 February 2027                [Page 6]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   Rate-based congestion control algorithms MUST ensure their maximum
   sustained rate is limited to a value that is not greater than would
   have been permitted by the Rate-Limited Increase method defined in
   Section 3.

3.2.2.  Pacing

   Pacing mechanisms seek to avoid the negative impacts associated with
   "bursts" (flights of packets transmitted back-to-back).  Rate-Limited
   Increase introduces a limit using "maxFS", which is based on the
   number of bytes in flight during a previous RTT; thus, as long as the
   number of bytes in flight per RTT is unaffected by pacing, Rate-
   Limited Increase does not constrain the use of pacing mechanisms.

4.  Updates to RFCs 4341, 5681, 9002, 9260, and 9438

4.1.  RFC 4341: Profile for Datagram Congestion Control Protocol (DCCP)
      Congestion Control ID 2: TCP-like Congestion Control

   According to [RFC4341], a DCCP CCID specifying TCP-like behavior is
   allowed to grow the cwnd without limit during an uncongested period
   when it sends at a rate unconstrained by the current cwnd.  This
   document updates Section 5.1 of [RFC4341] by adding the text in
   Section 3 to specify how the cwnd is managed when the sender is rate-
   limited.

4.2.  RFC 5681: TCP Congestion Control

   [RFC5681] specifies no limit on cwnd growth in the standard TCP
   behavior when a TCP sender is unable to send at the maximum rate
   allowed by the cwnd.

   This document updates [RFC5681] by adding the text in Section 3 to
   specify how the cwnd is managed when the sender is rate-limited.

4.3.  RFC 9002: QUIC Loss Detection and Congestion Control

   Section 7.8 of [RFC9002] states:

      "When bytes in flight is smaller than the congestion window and
      sending is not pacing limited, the congestion window is
      underutilized.  This can happen due to insufficient application
      data or flow control limits.  When this occurs, the congestion
      window SHOULD NOT be increased in either slow start or congestion
      avoidance."

   This limits the cwnd growth in accordance with Rate-Limited Increase,
   but it is more conservative.

Welzl, et al.            Expires 6 February 2027                [Page 7]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   This document updates [RFC9002] by replacing the final sentence of
   the cited text with the text in Section 3 to specify how the cwnd is
   managed when the sender is rate-limited.

4.4.  RFC 9260: Stream Control Transmission Protocol

   Section 7.2.1 of [RFC9260] states:

      "When cwnd is less than or equal to ssthresh, an SCTP endpoint
      MUST use the slow-start algorithm to increase cwnd only if the
      current congestion window is being fully utilized and the data
      sender is not in Fast Recovery.  Only when these two conditions
      are met can the cwnd be increased; otherwise, the cwnd MUST NOT be
      increased."

   The quoted statement from [RFC9260] limits cwnd growth in accordance
   with Rate-Limited Increase, but it is more conservative.
   Section 7.2.1 of [RFC9260] only discusses Slow Start.  Congestion
   Avoidance is discussed in Section 7.2.2 of [RFC9260]; however, this
   section does not contain a similar rule.  It is therefore clear that
   the quoted statement from [RFC9260] only applies to Slow Start.

   This document updates [RFC9260] by replacing the final sentence of
   the quoted text with the text in Section 3 to specify how the cwnd is
   managed when the sender is rate-limited.

   Section 7.2.2 of [RFC9260] is also updated to add text in Section 3.

   This ensures that the update applies to both Slow Start and
   Congestion Avoidance.

4.5.  RFC 9438: CUBIC for Fast and Long-Distance Networks

   Section 5.8 of [RFC9438] states:

      "Cubic doesn't increase cwnd when it's limited by the sending
      application or rwnd".

   This limits the cwnd growth in accordance with Rate-Limited Increase,
   but it is more conservative.

   This document updates [RFC9438] by replacing the quoted text with the
   text in Section 3 to specify how the cwnd is managed when the sender
   is rate-limited.

Welzl, et al.            Expires 6 February 2027                [Page 8]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

5.  Security Considerations

   While congestion control designs could result in unwanted competing
   traffic, they do not directly result in new security considerations.

   The security considerations are the same as for other congestion
   control methods.  Such methods rely on the receiver appropriately
   acknowledging receipt of data.  The ability of an on-path or off-path
   attacker to influence congestion control depends upon the security
   properties of the transport protocol being used.  Transport protocols
   that provide authentication (including those using encryption), or
   are carried over protocols that provide authentication, can protect
   their congestion control algorithm from network attack.  This is
   orthogonal to the specification of congestion control rules.

6.  IANA Considerations

   This document requests no IANA action.

7.  References

7.1.  Normative References

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119,
              DOI 10.17487/RFC2119, March 1997,
              <https://www.rfc-editor.org/rfc/rfc2119>.

   [RFC4341]  Floyd, S. and E. Kohler, "Profile for Datagram Congestion
              Control Protocol (DCCP) Congestion Control ID 2: TCP-like
              Congestion Control", RFC 4341, DOI 10.17487/RFC4341, March
              2006, <https://www.rfc-editor.org/rfc/rfc4341>.

   [RFC5681]  Allman, M., Paxson, V., and E. Blanton, "TCP Congestion
              Control", RFC 5681, DOI 10.17487/RFC5681, September 2009,
              <https://www.rfc-editor.org/rfc/rfc5681>.

   [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
              2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
              May 2017, <https://www.rfc-editor.org/rfc/rfc8174>.

   [RFC9002]  Iyengar, J., Ed. and I. Swett, Ed., "QUIC Loss Detection
              and Congestion Control", RFC 9002, DOI 10.17487/RFC9002,
              May 2021, <https://www.rfc-editor.org/rfc/rfc9002>.

   [RFC9260]  Stewart, R., Tüxen, M., and K. Nielsen, "Stream Control
              Transmission Protocol", RFC 9260, DOI 10.17487/RFC9260,
              June 2022, <https://www.rfc-editor.org/rfc/rfc9260>.

Welzl, et al.            Expires 6 February 2027                [Page 9]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   [RFC9438]  Xu, L., Ha, S., Rhee, I., Goel, V., and L. Eggert, Ed.,
              "CUBIC for Fast and Long-Distance Networks", RFC 9438,
              DOI 10.17487/RFC9438, August 2023,
              <https://www.rfc-editor.org/rfc/rfc9438>.

7.2.  Informative References

   [I-D.ietf-ccwg-bbr]
              Cardwell, N., Swett, I., and J. Beshay, "BBR Congestion
              Control", Work in Progress, Internet-Draft, draft-ietf-
              ccwg-bbr-06, 6 July 2026,
              <https://datatracker.ietf.org/doc/html/draft-ietf-ccwg-
              bbr-06>.

   [RFC6928]  Chu, J., Dukkipati, N., Cheng, Y., and M. Mathis,
              "Increasing TCP's Initial Window", RFC 6928,
              DOI 10.17487/RFC6928, April 2013,
              <https://www.rfc-editor.org/rfc/rfc6928>.

   [RFC7661]  Fairhurst, G., Sathiaseelan, A., and R. Secchi, "Updating
              TCP to Support Rate-Limited Traffic", RFC 7661,
              DOI 10.17487/RFC7661, October 2015,
              <https://www.rfc-editor.org/rfc/rfc7661>.

Appendix A.  An Example Using cwnd Represented in Bytes

   The following informative example is provided for a sender that
   maintains the cwnd in bytes. 36 packets (or segments in the case of
   TCP) are sent in this example over four rounds of transmission.  This
   shows the initial growth of the cwnd by a rate-limited sender,
   followed by a transmission that uses the full available cwnd.  The
   SMSS (QUIC MPS)=1000.  N is the number of previously unacknowledged
   bytes in a received acknowledgement.  For simplicity, in this example
   the receiver sends an ACK for each received packet.

   The initial sender state is:

  Sender sequence number (seqno) = 0
  SMSS = 1000 bytes
  cwnd = 10000 bytes (initcwnd)
  maxFS = 10000 bytes (initcwnd)
  FlightSize (FS) = 0 bytes
  ssthresh is infinity, i.e. the congestion control algorithm is in slow start.

   The network path’s bandwidth-delay product is such that, throughout
   this example, all packets in each round are sent before an ACK is
   received for the first packet in a round.  One ACK is generated for
   each received packet.

Welzl, et al.            Expires 6 February 2027               [Page 10]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   Round 1, the sender has 4000B to send in 4 packets (1000B);
   cwnd=10000

     Send  seqno=0;    FS=1000; maxFS=10000
     Send  seqno=1000; FS=2000; maxFS=10000
     Send  seqno=2000; FS=3000; maxFS=10000
     Send  seqno=3000; FS=4000; maxFS=10000

   Received 4 ACKs (each N=1000); maxFS=10000 cwnd_new += N; cwnd =
   min(cwnd_new, 2*maxFS)

     ACK for  1000 ACK’ed=1000; FS-=1000: cwnd+= 1000; cwnd=11000
     ACK for  2000 ACK’ed=1000; FS-=1000: cwnd+= 1000; cwnd=12000
     ACK for  3000 ACK’ed=1000; FS-=1000: cwnd+= 1000; cwnd=13000
     ACK for  4000 ACK’ed=1000; FS-=1000: cwnd+= 1000; cwnd=14000

   Note: This round maxFS was not increased and cwnd was increased.

   Round 2, the sender has 8000B to send in 8 packets (1000B),
   cwnd=14000

     Send  seqno=4000; FS=1000; maxFS=10000
     Send  seqno=5000; FS=2000; maxFS=10000
     Send  seqno=6000; FS=3000; maxFS=10000
     Send  seqno=7000; FS=4000; maxFS=10000
     Send  seqno=8000; FS=5000; maxFS=10000
     Send  seqno=9000; FS=6000; maxFS=10000
     Send seqno=10000; FS=7000; maxFS=10000
     Send seqno=11000; FS=8000; maxFS=10000

   Received 8 ACKs (N=2000); maxFS=10000 cwnd_new += N; cwnd =
   min(cwnd_new, 2*maxFS)

     ACK for  5000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=15000
     ACK for  6000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=16000
     ACK for  7000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=17000
     ACK for  8000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=18000
     ACK for  9000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=19000
     ACK for 10000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=20000
     ACK for 11000 ACK’ed=1000; FS-=1000: cwnd+=0;    cwnd=20000
     ACK for 12000 ACK’ed=1000; FS-=1000: cwnd+=0;    cwnd=20000

   Note: This round maxFS was not increased and cwnd was limited to
   2*maxFS.

   Round 3, the sender has 4000B to send in 4 packets (1000B),
   cwnd=20000

Welzl, et al.            Expires 6 February 2027               [Page 11]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

     Send seqno=12000; FS=1000; maxFS=10000
     Send seqno=13000; FS=2000; maxFS=10000
     Send seqno=14000; FS=3000; maxFS=10000
     Send seqno=15000; FS=4000; maxFS=10000

   Received 2 ACKs (N=2000); maxFS=10000 cwnd_new += N; cwnd =
   min(cwnd_new, 2*maxFS)

     ACK for 13000 ACK’ed=1000; FS-=1000: cwnd+=0;    cwnd=20000
     ACK for 14000 ACK’ed=1000; FS-=1000: cwnd+=0;    cwnd=20000
     ACK for 15000 ACK’ed=1000; FS-=1000: cwnd+=0;    cwnd=20000
     ACK for 16000 ACK’ed=1000; FS-=1000: cwnd+=0;    cwnd=20000

   Note: This round maxFS was not increased and cwnd was not increased.

   Round 4, the sender has 20000B to send in 20 packets (1000B),
   cwnd=20000

     Send seqno=16000; FS= 1000; maxFS=10000
     Send seqno=17000; FS= 2000; maxFS=10000
     Send seqno=18000; FS= 3000; maxFS=10000
     Send seqno=19000; FS= 4000; maxFS=10000
     Send seqno=20000; FS= 5000; maxFS=10000
     Send seqno=21000; FS= 6000; maxFS=10000
     Send seqno=22000; FS= 7000; maxFS=10000
     Send seqno=23000; FS= 8000; maxFS=10000
     Send seqno=24000; FS= 9000; maxFS=10000
     Send seqno=25000; FS=10000; maxFS=10000
     Send seqno=26000; FS=11000; maxFS=11000
     Send seqno=27000; FS=12000; maxFS=12000
     Send seqno=28000; FS=13000; maxFS=13000
     Send seqno=29000; FS=14000; maxFS=14000
     Send seqno=30000; FS=15000; maxFS=15000
     Send seqno=31000; FS=16000; maxFS=16000
     Send seqno=32000; FS=17000; maxFS=17000
     Send seqno=33000; FS=18000; maxFS=18000
     Send seqno=34000; FS=19000; maxFS=19000
     Send seqno=35000; FS=20000; maxFS=20000

   Received 10 ACKs (N=2000); maxFS=20000 cwnd_new += N; cwnd =
   min(cwnd_new, 2*maxFS)

Welzl, et al.            Expires 6 February 2027               [Page 12]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

     ACK for 18000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=21000
     ACK for 19000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=22000
     ACK for 19000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=23000
     ACK for 20000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=24000
     ACK for 21000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=25000
     ACK for 22000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=26000
     ACK for 23000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=27000
     ACK for 24000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=28000
     ACK for 25000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=29000
     ACK for 26000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=30000
     ACK for 27000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=31000
     ACK for 28000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=32000
     ACK for 29000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=33000
     ACK for 30000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=34000
     ACK for 31000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=35000
     ACK for 32000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=36000
     ACK for 33000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=37000
     ACK for 34000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=38000
     ACK for 35000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=39000
     ACK for 36000 ACK’ed=1000; FS-=1000: cwnd+=1000; cwnd=40000

   Note: In this round, maxFS increased and therefore cwnd increased to
   2*maxFS.

Appendix B.  Change Log

   *  -00 was the first individual submission for feedback by CCWG.

   *  -01 includes editorial improvements

      -  Removes application interaction with QUIC pacing, since pacing
         might be within the QUIC stack.

      -  Adds explicit mention of DCCP/CCID2.

      -  Adds this change log.

   *  -02 addresses comments from IETF-119

      -  Discusses rate-based controls and pacing.

      -  Trims the list of possible RFCs to update.

      -  Some editorial fixes: "congestion control algorithm" instead of
         "mechanism" for consistency with RFC5033.bis; earlier
         definition of maxFS; explicit mention of RFCs to update in
         abstract.

Welzl, et al.            Expires 6 February 2027               [Page 13]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   *  -03 addresses comments from IETF-120

      -  Introduces a third rule, with MAY, that avoids having an
         unvalidated long-lived maxFS (using pipeACK from RFC 7661).

      -  Changes "inc" to "limit" and adapts the wording of rule 2 to
         make it clearer (thanks to Neal Cardwell).

      -  Appendix: updates ns-3 in line with the recent implementation.

      -  Appendix: makes the RFC 9002 text clearer and shorter.

   *  draft-ietf-ccwg-ratelimited-increase-00

      -  adds Mohit Tahiliani as a co-author

      -  refines the "rule" text (shorter, clearer)

      -  adds an example

   *  draft-ietf-ccwg-ratelimited-increase-01

      -  Clarified what we mean with an RTT

      -  rephrased example regarding initcwnd, citing RFCs 6928 and 9002

      -  removed the too vague rule 1 and made rule 2 (now rule 1) a
         MUST

   *  draft-ietf-ccwg-ratelimited-increase-02

      -  Improved the last sentence of section 3.1.2.

      -  Removed a confusing and unnecessary sentence about pacing (as
         suggested at IETF-123).

   *  draft-ietf-ccwg-ratelimited-increase-03

      -  The editors checked rule 2, and found that rule 1 was
         sufficient, and did not depend on the ordering of rules in
         newCWV (RFC7661), hence rule 2 was finally removed.

      -  Cleaned language and improved text explaining how this
         complements RFC7661.

      -  Checked/updated definitions.

      -  Added an example with cwnd in bytes.

Welzl, et al.            Expires 6 February 2027               [Page 14]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   *  draft-ietf-ccwg-ratelimited-increase-04

      -  Repeated definitions from RFC 7661 instead of just pointing at
         the RFC

      -  Made RFC 7661 informational

   *  draft-ietf-ccwg-ratelimited-increase-05

      -  Rephrased references to RFC 7661

      -  Nits

   *  draft-ietf-ccwg-ratelimited-increase-06

      -  Changed some TCP-specific language so it applies to QUIC too

      -  RFC 4341 added to list of updated RFCs in the abstract

      -  Nits

   *  draft-ietf-ccwg-ratelimited-increase-07

      -  Updated this list

      -  Made RFC 4341 reference normative

      -  Fixed Updates list to match boilerplate

      -  Moved some of appendix B to the main text as a new section that
         (only) defines the RFC updates.

      -  Updated description lines in appendix A

   *  draft-ietf-ccwg-ratelimited-increase-08

      -  Addressed a comment from Eric Vyncke about the paragraph on
         rate-based cc. algs.

Acknowledgments

   The authors would like to thank Neal Cardwell and Martin Duke for
   suggesting improvements to this document.

Authors' Addresses

Welzl, et al.            Expires 6 February 2027               [Page 15]
Internet-Draft         Rate-Limited cwnd Increase            August 2026

   Michael Welzl
   University of Oslo
   PO Box 1080 Blindern
   0316  Oslo
   Norway
   Email: michawe@ifi.uio.no
   URI:   http://welzl.at/

   Tom Henderson
   University of Washington
   185 Stevens Way
   Seattle, WA 98195,
   United States
   Email: tomh@tomh.org

   Godred Fairhurst
   University of Aberdeen
   Fraser Noble Building
   Aberdeen, AB24 3UE
   United Kingdom
   Email: gorry@erg.abdn.ac.uk
   URI:   https://www.erg.abdn.ac.uk/

   Mohit P. Tahiliani
   National Institute of Technology Karnataka
   P. O. Srinivasnagar, Surathkal
   Mangalore, Karnataka - 575025
   India
   Email: tahiliani@nitk.edu.in
   URI:   https://tahiliani.in/

Welzl, et al.            Expires 6 February 2027               [Page 16]