From 2a9cb75e13ebfaf79dd9cf4d7296ae7b3ae612fd Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Mon, 17 Aug 2020 15:01:50 +1000 Subject: [PATCH 01/14] Attempt to define slow start/congestion avoidance This essentially rewrites these small sections. The definitions are new. The text on how the congestion window increases is just tweaked. The reaction to loss is moved to the congestion avoidance section, to avoid repetition. Closes #3982. --- draft-ietf-quic-recovery.md | 37 +++++++++++++++++++++++-------------- 1 file changed, 23 insertions(+), 14 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 0c7dfebd4d..2481dbac94 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -763,24 +763,33 @@ The RECOMMENDED value is 2 * max_datagram_size. ## Slow Start -While in slow start, QUIC increases the congestion window by the -number of bytes acknowledged when each acknowledgment is processed, resulting -in exponential growth of the congestion window. +The congestion controller is in slow start any time the congestion window is +below the slow start threshold. The congestion controller begins in slow start. -QUIC exits slow start upon loss or upon increase in the ECN-CE counter. -When slow start is exited, the congestion window halves and the slow start -threshold is set to the new congestion window. QUIC re-enters slow start -any time the congestion window is less than the slow start threshold, -which only occurs after persistent congestion is declared. +While the congestion controller is in slow start, the congestion window +increases by the number of bytes acknowledged when each acknowledgment is +processed. This results in exponential growth of the congestion window. + +The congestion controller exits slow start and enters congestion avoidance when +a packet is lost or when the ECN-CE count increases. + +The congestion controller re-enters slow start any time the congestion window is +less than the slow start threshold, which only occurs after persistent +congestion is declared. ## Congestion Avoidance -Slow start exits to congestion avoidance. Congestion avoidance uses an -Additive Increase Multiplicative Decrease (AIMD) approach that increases -the congestion window by one maximum packet size per congestion window -acknowledged. When a loss or ECN-CE marking is detected, NewReno halves -the congestion window, sets the slow start threshold to the new -congestion window, and then enters the recovery period. +The congestion controller is in congestion avoidance any time the congestion +window is at or above the slow start threshold. + +Congestion avoidance uses an Additive Increase Multiplicative Decrease (AIMD) +approach that increases the congestion window by one maximum packet size per +congestion window acknowledged. + +When first entering congestion avoidance, when a packet is declared lost, or +when the ECN-CE count is detected, the congestion controller halves the +congestion window, reduces the slow start threshold to the resulting size, and +enters the recovery period. ## Recovery Period From 2f3927e55f3a01aae44ee42ed324f49788214509 Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Tue, 18 Aug 2020 08:33:07 +1000 Subject: [PATCH 02/14] detected/increased Co-authored-by: Mike Bishop --- draft-ietf-quic-recovery.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 2481dbac94..5d3ca4bb99 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -787,7 +787,7 @@ approach that increases the congestion window by one maximum packet size per congestion window acknowledged. When first entering congestion avoidance, when a packet is declared lost, or -when the ECN-CE count is detected, the congestion controller halves the +when the ECN-CE count is increased, the congestion controller halves the congestion window, reduces the slow start threshold to the resulting size, and enters the recovery period. From 755f59a06e4e0f507c3963bf1515720db5b3940e Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Tue, 18 Aug 2020 11:23:25 +1000 Subject: [PATCH 03/14] Integrate the changes from #3978 This will mean that I can ignore those changes when rebasing. Though @ianswett probably should review to ensure that I retained the intent. --- draft-ietf-quic-recovery.md | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 5d3ca4bb99..573d193d8e 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -783,13 +783,15 @@ The congestion controller is in congestion avoidance any time the congestion window is at or above the slow start threshold. Congestion avoidance uses an Additive Increase Multiplicative Decrease (AIMD) -approach that increases the congestion window by one maximum packet size per -congestion window acknowledged. +approach that increases the congestion window by one maximum datagram size per +congestion window acknowledged. A congestion controller MUST NOT increase the +congestion window by more than this amount. When first entering congestion avoidance, when a packet is declared lost, or -when the ECN-CE count is increased, the congestion controller halves the -congestion window, reduces the slow start threshold to the resulting size, and -enters the recovery period. +when the ECN-CE count is increased, the congestion controller described in this +document halves the congestion window, reduces the slow start threshold to the +resulting size, and enters the recovery period. A congestion controller MUST +reduce the congestion window when a loss or ECN-CE marking is detected. ## Recovery Period From 2775fdd582e3f7f977f1774300bd1f3486e072e1 Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Wed, 19 Aug 2020 09:01:44 +1000 Subject: [PATCH 04/14] ssthresh being initiallly infinite means that you start in slow start Co-authored-by: ianswett --- draft-ietf-quic-recovery.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 573d193d8e..c24c9eee74 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -764,7 +764,8 @@ The RECOMMENDED value is 2 * max_datagram_size. ## Slow Start The congestion controller is in slow start any time the congestion window is -below the slow start threshold. The congestion controller begins in slow start. +below the slow start threshold. The congestion controller begins in slow start +because the slow start threshold is initialized to an infinite value. While the congestion controller is in slow start, the congestion window increases by the number of bytes acknowledged when each acknowledgment is From bb961751b3168fc43ba08df5a268811452559628 Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Tue, 25 Aug 2020 11:44:26 +1000 Subject: [PATCH 05/14] Reword congestion signal response Co-authored-by: Jana Iyengar --- draft-ietf-quic-recovery.md | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index c24c9eee74..031d948b8a 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -788,13 +788,16 @@ approach that increases the congestion window by one maximum datagram size per congestion window acknowledged. A congestion controller MUST NOT increase the congestion window by more than this amount. -When first entering congestion avoidance, when a packet is declared lost, or -when the ECN-CE count is increased, the congestion controller described in this -document halves the congestion window, reduces the slow start threshold to the -resulting size, and enters the recovery period. A congestion controller MUST -reduce the congestion window when a loss or ECN-CE marking is detected. +The congestion controller described in this document, when not in the +recovery period ({{recovery}}), MUST take the following steps when first +entering congestion avoidance, when a packet is declared lost, or when +the ECN-CE count is increased: -## Recovery Period +* halve the congestion window, +* set the slow start threshold to the size of the reduced congestion window, and +* enter the recovery period. + +## Recovery Period {#recovery} A recovery period is entered when loss or ECN-CE marking of a packet is detected in congestion avoidance after the congestion window and slow start From 571c641974bde509e9b86b68997e8a55110b8ad2 Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Wed, 26 Aug 2020 10:22:22 +1000 Subject: [PATCH 06/14] A Congestion Control state machine This adds a state machine and makes further changes to the presentation of the congestion control states in line with that presentation. This rolls in the normative changes from #3978. Closes #4045. --- draft-ietf-quic-recovery.md | 107 +++++++++++++++++++++++------------- 1 file changed, 70 insertions(+), 37 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 558506f00e..b82f929151 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -762,62 +762,95 @@ The minimum congestion window is the smallest value the congestion window can decrease to as a response to loss, ECN-CE, or persistent congestion. The RECOMMENDED value is 2 * max_datagram_size. -## Slow Start +## Congestion Control States -The congestion controller is in slow start any time the congestion window is -below the slow start threshold. The congestion controller begins in slow start -because the slow start threshold is initialized to an infinite value. +The congestion controller has three distinct states, as shown in +{{fig-cc-fsm}}. -While the congestion controller is in slow start, the congestion window -increases by the number of bytes acknowledged when each acknowledgment is -processed. This results in exponential growth of the congestion window. +~~~ + Start or +------------+ + persistent congestion | Slow | + (O)---------------------->| Start | + +------------+ + | + Loss or | + ECN-CE increase | + v + +------------+ Loss or +------------+ + | Congestion | ECN-CE increase | Recovery | + | Avoidance |------------------>| Period | + +------------+ +------------+ + ^ | + | | + +----------------------------+ + Acknowledgment of packet + sent during recovery +~~~ +{: #fig-cc-fsm title="Congestion Control States and Transitions"} -The congestion controller exits slow start and enters congestion avoidance when -a packet is lost or when the ECN-CE count increases. +These states and the transitions between them are described in subsequent +sections. -The congestion controller re-enters slow start any time the congestion window is -less than the slow start threshold, which only occurs after persistent -congestion is declared. +### Slow Start -## Congestion Avoidance +A sender is in slow start any time the congestion window is below the slow +start threshold. A sender begins in slow start because the slow start threshold +is initialized to an infinite value. -The congestion controller is in congestion avoidance any time the congestion -window is at or above the slow start threshold. +While a sender is in slow start, the congestion window increases by the number +of bytes acknowledged when each acknowledgment is processed. This results in +exponential growth of the congestion window. -Congestion avoidance uses an Additive Increase Multiplicative Decrease (AIMD) -approach that increases the congestion window by one maximum datagram size per -congestion window acknowledged. A congestion controller MUST NOT increase the -congestion window by more than this amount. +The sender exits slow start and enters a recovery period when a packet is lost +or when the ECN-CE count reported by its peer increases. -The congestion controller described in this document, when not in the recovery -period ({{recovery-period}}), MUST take the following steps when first entering -congestion avoidance, when a packet is declared lost, or when the ECN-CE count -is increased: +A sender re-enters slow start any time the congestion window is less than the +slow start threshold, which only occurs after persistent congestion is +declared. -* halve the congestion window, -* set the slow start threshold to the size of the reduced congestion window, and -* enter the recovery period. +### Recovery Period {#recovery-period} -## Recovery Period {#recovery-period} +A sender enters the recovery period when it detects the loss of a packet or the +ECN-CE count reported by its peer increases. A sender that is already in a +recovery period stays in it and does not re-enter it. -A recovery period is entered when loss or ECN-CE marking of a packet is -detected in congestion avoidance after the congestion window and slow start -threshold have been decreased. A recovery period ends when a packet sent -during the recovery period is acknowledged. This is slightly different from -TCP's definition of recovery, which ends when the lost packet that started -recovery is acknowledged. +On entering a recovery period, a sender MUST set the slow start threshold to +the half the value of the congestion window at the moment that loss is +detected. The congestion window MUST be set to the reduced value of the slow +start threshold before exiting the recovery period. Implementations MAY set the +congestion window immediately on entering a recovery period or use other +mechanisms, such as Proportional Rate Reduction ({{?PRR=RFC6937}}), to reduce +it more gradually. The recovery period aims to limit congestion window reduction to once per round -trip. Therefore during recovery, the congestion window remains unchanged -irrespective of new losses or increases in the ECN-CE counter. +trip. Therefore during a recovery period, the congestion window remains does +not change in response to new losses or increases in the ECN-CE count. + +A recovery period ends and the sender enters congestion avoidance when a packet +sent during the recovery period is acknowledged. This is slightly different +from TCP's definition of recovery, which ends when the lost packet that started +recovery is acknowledged. -When entering recovery, a single packet MAY be sent even if bytes in flight -now exceeds the recently reduced congestion window. This speeds up loss +When entering a recovery period, a single packet MAY be sent even if bytes in +flight now exceeds the recently reduced congestion window. This speeds up loss recovery if the data in the lost packet is retransmitted and is similar to TCP as described in Section 5 of {{?RFC6675}}. If further packets are lost while the sender is in recovery, sending any packets in response MUST obey the congestion window limit. +### Congestion Avoidance + +A sender is in congestion avoidance any time the congestion window is at or +above the slow start threshold and not in a recovery period. + +A NewReno sender in congestion avoidance uses an Additive Increase +Multiplicative Decrease (AIMD) approach that MUST limit the increase to the +congestion window to at most one maximum datagram size for each congestion +window that is acknowledged. + +The sender exits congestion avoidance and enters a recovery period when a +packet is lost or when the ECN-CE count reported by its peer increases. + ## Ignoring Loss of Undecryptable Packets During the handshake, some packet protection keys might not be available when From ec01b201edfa755c39d8b172eda6aa55c7c7a502 Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Wed, 26 Aug 2020 10:29:34 +1000 Subject: [PATCH 07/14] Make pseudocode match directly --- draft-ietf-quic-recovery.md | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index b82f929151..c933ae5f02 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -1616,20 +1616,21 @@ OnPacketAcked(acked_packet): ## On New Congestion Event Invoked from ProcessECN and OnPacketsLost when a new congestion event is -detected. May start a new recovery period and reduces the congestion -window. +detected. If not in a recovery period, this starts a recovery period and +reduces the slow start threshold and congestion window immediately. ~~~ OnCongestionEvent(sent_time): - // Start a new congestion event if packet was sent after the - // start of the previous congestion recovery period. - if (!InCongestionRecovery(sent_time)): - congestion_recovery_start_time = now() - congestion_window *= kLossReductionFactor - congestion_window = max(congestion_window, kMinimumWindow) - ssthresh = congestion_window - // A packet can be sent to speed up loss recovery. - MaybeSendOnePacket() + // No reaction when recovery period. + if (InCongestionRecovery(sent_time)): + return + + // Enter recovery period. + congestion_recovery_start_time = now() + ssthresh = congestion_window * kLossReductionFactor + congestion_window = max(ssthresh, kMinimumWindow) + // A packet can be sent to speed up loss recovery. + MaybeSendOnePacket() ~~~ From a995b265247af1c7187263df77413919bb41741a Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Wed, 26 Aug 2020 10:48:58 +1000 Subject: [PATCH 08/14] Corrections and suggestions Co-authored-by: Jana Iyengar --- draft-ietf-quic-recovery.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index c933ae5f02..ed8f7f8925 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -815,7 +815,7 @@ ECN-CE count reported by its peer increases. A sender that is already in a recovery period stays in it and does not re-enter it. On entering a recovery period, a sender MUST set the slow start threshold to -the half the value of the congestion window at the moment that loss is +half the value of the congestion window at the moment that loss is detected. The congestion window MUST be set to the reduced value of the slow start threshold before exiting the recovery period. Implementations MAY set the congestion window immediately on entering a recovery period or use other @@ -823,13 +823,13 @@ mechanisms, such as Proportional Rate Reduction ({{?PRR=RFC6937}}), to reduce it more gradually. The recovery period aims to limit congestion window reduction to once per round -trip. Therefore during a recovery period, the congestion window remains does +trip. Therefore during a recovery period, the congestion window does not change in response to new losses or increases in the ECN-CE count. A recovery period ends and the sender enters congestion avoidance when a packet sent during the recovery period is acknowledged. This is slightly different -from TCP's definition of recovery, which ends when the lost packet that started -recovery is acknowledged. +from TCP's definition of recovery, which ends when the lost segment that started +recovery is acknowledged ({{?RFC5681}}). When entering a recovery period, a single packet MAY be sent even if bytes in flight now exceeds the recently reduced congestion window. This speeds up loss @@ -1621,7 +1621,7 @@ reduces the slow start threshold and congestion window immediately. ~~~ OnCongestionEvent(sent_time): - // No reaction when recovery period. + // No reaction if already in a recovery period. if (InCongestionRecovery(sent_time)): return From 5d3f651cf191c411ebe674e03cebcd279c5279b5 Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Thu, 27 Aug 2020 08:49:08 +1000 Subject: [PATCH 09/14] a/the Co-authored-by: Jana Iyengar --- draft-ietf-quic-recovery.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index ed8f7f8925..8392183fa3 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -810,7 +810,7 @@ declared. ### Recovery Period {#recovery-period} -A sender enters the recovery period when it detects the loss of a packet or the +A sender enters a recovery period when it detects the loss of a packet or the ECN-CE count reported by its peer increases. A sender that is already in a recovery period stays in it and does not re-enter it. From 3ad13ceb7a26bc88631f24385cb628089330c589 Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Wed, 2 Sep 2020 08:23:49 +1000 Subject: [PATCH 10/14] Sprinkle some NewReno pixie dust --- draft-ietf-quic-recovery.md | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 73add5de59..4d5c39dc46 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -818,20 +818,20 @@ The RECOMMENDED value is 2 * max_datagram_size. ## Slow Start -The congestion controller is in slow start any time the congestion window is -below the slow start threshold. The congestion controller begins in slow start -because the slow start threshold is initialized to an infinite value. +A NewReno sender is in slow start any time the congestion window is below the +slow start threshold. A sender begins in slow start because the slow start +threshold is initialized to an infinite value. -While the congestion controller is in slow start, a NewReno sender increases the -congestion window by the number of bytes acknowledged when each acknowledgment is -processed. This results in exponential growth of the congestion window. +While a sender is in slow start, the congestion window increases by the number +of bytes acknowledged when each acknowledgment is processed. This results in +exponential growth of the congestion window. A sender exits slow start and enters congestion avoidance when a packet is lost or when the ECN-CE count increases. -The congestion controller re-enters slow start any time the congestion window is -less than the slow start threshold, which only occurs after persistent -congestion is declared. +A sender re-enters slow start any time the congestion window is less than the +slow start threshold, which only occurs after persistent congestion is +declared. ## Congestion Avoidance @@ -840,13 +840,12 @@ above the slow start threshold. Congestion avoidance uses an Additive Increase Multiplicative Decrease (AIMD) approach that increases the congestion window by one maximum datagram size per -congestion window acknowledged. A congestion controller MUST NOT increase the -congestion window by more than this amount. +congestion window acknowledged. A sender MUST NOT increase the congestion +window by more than this amount. -The congestion controller described in this document, when not in the recovery -period ({{recovery-period}}), MUST take the following steps when first entering -congestion avoidance, when a packet is declared lost, or when the ECN-CE count -is increased: +A NewReno sender, when not in the recovery period ({{recovery-period}}), MUST +take the following steps when first entering congestion avoidance, when a +packet is declared lost, or when the ECN-CE count is increased: * halve the congestion window, * set the slow start threshold to the size of the reduced congestion window, and From e094c5f27c67bd0703f1f1c3011ab8c0127248a4 Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Wed, 2 Sep 2020 10:10:44 +1000 Subject: [PATCH 11/14] Ian's suggestions Co-authored-by: ianswett --- draft-ietf-quic-recovery.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 0179e0424e..10d3bdefae 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -822,7 +822,7 @@ The congestion controller has three distinct states, as shown in {{fig-cc-fsm}}. ~~~ - Start or +------------+ + New Path or +------------+ persistent congestion | Slow | (O)---------------------->| Start | +------------+ @@ -855,21 +855,21 @@ While a sender is in slow start, the congestion window increases by the number of bytes acknowledged when each acknowledgment is processed. This results in exponential growth of the congestion window. -The sender exits slow start and enters a recovery period when a packet is lost +The sender MUST exit slow start and enter a recovery period when a packet is lost or when the ECN-CE count reported by its peer increases. A sender re-enters slow start any time the congestion window is less than the slow start threshold, which only occurs after persistent congestion is declared. -### Recovery Period {#recovery-period} +### Recovery {#recovery-period} A NewReno sender enters a recovery period when it detects the loss of a packet or the ECN-CE count reported by its peer increases. A sender that is already in a recovery period stays in it and does not re-enter it. On entering a recovery period, a sender MUST set the slow start threshold to -half the value of the congestion window at the moment that loss is +half the value of the congestion window when loss is detected. The congestion window MUST be set to the reduced value of the slow start threshold before exiting the recovery period. Implementations MAY set the congestion window immediately on entering a recovery period or use other @@ -1697,7 +1697,7 @@ OnPacketAcked(acked_packet): ## On New Congestion Event Invoked from ProcessECN and OnPacketsLost when a new congestion event is -detected. If not in a recovery period, this starts a recovery period and +detected. If not already in recovery, this starts a recovery period and reduces the slow start threshold and congestion window immediately. ~~~ From e43ad7c0a3b1d7cbdcd058b866eb02966f7fe85e Mon Sep 17 00:00:00 2001 From: Martin Thomson Date: Wed, 2 Sep 2020 10:13:03 +1000 Subject: [PATCH 12/14] Reshuffle paragraphs, reflow --- draft-ietf-quic-recovery.md | 39 ++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 10d3bdefae..70e6522f8f 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -855,8 +855,8 @@ While a sender is in slow start, the congestion window increases by the number of bytes acknowledged when each acknowledgment is processed. This results in exponential growth of the congestion window. -The sender MUST exit slow start and enter a recovery period when a packet is lost -or when the ECN-CE count reported by its peer increases. +The sender MUST exit slow start and enter a recovery period when a packet is +lost or when the ECN-CE count reported by its peer increases. A sender re-enters slow start any time the congestion window is less than the slow start threshold, which only occurs after persistent congestion is @@ -864,31 +864,30 @@ declared. ### Recovery {#recovery-period} -A NewReno sender enters a recovery period when it detects the loss of a -packet or the ECN-CE count reported by its peer increases. A sender that is -already in a recovery period stays in it and does not re-enter it. +A NewReno sender enters a recovery period when it detects the loss of a packet +or the ECN-CE count reported by its peer increases. A sender that is already in +a recovery period stays in it and does not re-enter it. On entering a recovery period, a sender MUST set the slow start threshold to -half the value of the congestion window when loss is -detected. The congestion window MUST be set to the reduced value of the slow -start threshold before exiting the recovery period. Implementations MAY set the -congestion window immediately on entering a recovery period or use other -mechanisms, such as Proportional Rate Reduction ({{?PRR=RFC6937}}), to reduce -it more gradually. - -If the congestion window is reduced immediately, a single packet can be sent -prior to reduction. This speeds up loss recovery if the data in the lost packet -is retransmitted and is similar to TCP as described in Section 5 of -{{?RFC6675}}. +half the value of the congestion window when loss is detected. The congestion +window MUST be set to the reduced value of the slow start threshold before +exiting the recovery period. + +Implementations MAY set the congestion window immediately upon entering a +recovery period or use other mechanisms, such as Proportional Rate Reduction +({{?PRR=RFC6937}}), to reduce the congestion window more gradually. If the +congestion window is reduced immediately, a single packet can be sent prior to +reduction. This speeds up loss recovery if the data in the lost packet is +retransmitted and is similar to TCP as described in Section 5 of {{?RFC6675}}. The recovery period aims to limit congestion window reduction to once per round -trip. Therefore during a recovery period, the congestion window does -not change in response to new losses or increases in the ECN-CE count. +trip. Therefore during a recovery period, the congestion window does not change +in response to new losses or increases in the ECN-CE count. A recovery period ends and the sender enters congestion avoidance when a packet sent during the recovery period is acknowledged. This is slightly different -from TCP's definition of recovery, which ends when the lost segment that started -recovery is acknowledged ({{?RFC5681}}). +from TCP's definition of recovery, which ends when the lost segment that +started recovery is acknowledged ({{?RFC5681}}). ### Congestion Avoidance From 45fbd4389d76e213ca305439d5572b2f30bc9624 Mon Sep 17 00:00:00 2001 From: Jana Iyengar Date: Fri, 4 Sep 2020 13:11:09 -0700 Subject: [PATCH 13/14] Update draft-ietf-quic-recovery.md Co-authored-by: ianswett --- draft-ietf-quic-recovery.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 70e6522f8f..55c52ca97c 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -873,7 +873,7 @@ half the value of the congestion window when loss is detected. The congestion window MUST be set to the reduced value of the slow start threshold before exiting the recovery period. -Implementations MAY set the congestion window immediately upon entering a +Implementations MAY reduce the congestion window immediately upon entering a recovery period or use other mechanisms, such as Proportional Rate Reduction ({{?PRR=RFC6937}}), to reduce the congestion window more gradually. If the congestion window is reduced immediately, a single packet can be sent prior to From 0194e02c796f0a9d31789a20e448870fceb74232 Mon Sep 17 00:00:00 2001 From: Jana Iyengar Date: Fri, 4 Sep 2020 13:15:15 -0700 Subject: [PATCH 14/14] Update draft-ietf-quic-recovery.md --- draft-ietf-quic-recovery.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/draft-ietf-quic-recovery.md b/draft-ietf-quic-recovery.md index 55c52ca97c..a94bce7506 100644 --- a/draft-ietf-quic-recovery.md +++ b/draft-ietf-quic-recovery.md @@ -818,8 +818,8 @@ The RECOMMENDED value is 2 * max_datagram_size. ## Congestion Control States -The congestion controller has three distinct states, as shown in -{{fig-cc-fsm}}. +The NewReno congestion controller described in this document has three +distinct states, as shown in {{fig-cc-fsm}}. ~~~ New Path or +------------+