Implement a QUIC No PRR connection option, NPRR. Protected by FLAGS_quic_allow_no_prr

net/quic/congestion_control/tcp_cubic_sender_base.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/congestion_control/tcp_cubic_sender_packets.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram_macros.h"
 #include "net/quic/congestion_control/prr_sender.h"
@@ skipping 23 matching lines @@
                                        QuicConnectionStats* stats)
     : rtt_stats_(rtt_stats),
       stats_(stats),
       reno_(reno),
       num_connections_(kDefaultNumConnections),
       largest_sent_packet_number_(0),
       largest_acked_packet_number_(0),
       largest_sent_at_last_cutback_(0),
       min4_mode_(false),
       last_cutback_exited_slowstart_(false),
-      slow_start_large_reduction_(false) {}
+      slow_start_large_reduction_(false),
+      no_prr_(false) {}
 
 TcpCubicSenderBase::~TcpCubicSenderBase() {}
 
 void TcpCubicSenderBase::SetFromConfig(const QuicConfig& config,
                                        Perspective perspective) {
   if (perspective == Perspective::IS_SERVER) {
     if (config.HasReceivedConnectionOptions() &&
         ContainsQuicTag(config.ReceivedConnectionOptions(), kIW03)) {
       // Initial window experiment.
       SetCongestionWindowInPackets(3);
@@ skipping 22 matching lines @@
         ContainsQuicTag(config.ReceivedConnectionOptions(), kMIN4)) {
       // Min CWND of 4 experiment.
       min4_mode_ = true;
       SetMinCongestionWindowInPackets(1);
     }
     if (config.HasReceivedConnectionOptions() &&
         ContainsQuicTag(config.ReceivedConnectionOptions(), kSSLR)) {
       // Slow Start Fast Exit experiment.
       slow_start_large_reduction_ = true;
     }
+    if (FLAGS_quic_allow_noprr && config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kNPRR)) {
+      // Use unity pacing instead of PRR.
+      no_prr_ = true;
+    }
   }
 }
 
 void TcpCubicSenderBase::ResumeConnectionState(
     const CachedNetworkParameters& cached_network_params,
     bool max_bandwidth_resumption) {
   QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(
       max_bandwidth_resumption
           ? cached_network_params.max_bandwidth_estimate_bytes_per_second()
           : cached_network_params.bandwidth_estimate_bytes_per_second());
@@ skipping 35 matching lines @@
     OnPacketAcked(it->first, it->second, bytes_in_flight);
   }
 }
 
 void TcpCubicSenderBase::OnPacketAcked(QuicPacketNumber acked_packet_number,
                                        QuicByteCount acked_bytes,
                                        QuicByteCount bytes_in_flight) {
   largest_acked_packet_number_ =
       max(acked_packet_number, largest_acked_packet_number_);
   if (InRecovery()) {
-    // PRR is used when in recovery.
-    prr_.OnPacketAcked(acked_bytes);
+    if (!no_prr_) {
+      // PRR is used when in recovery.
+      prr_.OnPacketAcked(acked_bytes);
+    }
     return;
   }
   MaybeIncreaseCwnd(acked_packet_number, acked_bytes, bytes_in_flight);
   if (InSlowStart()) {
     hybrid_slow_start_.OnPacketAcked(acked_packet_number);
   }
 }
 
 bool TcpCubicSenderBase::OnPacketSent(
     QuicTime /*sent_time*/,
@@ skipping 15 matching lines @@
   }
   DCHECK_LT(largest_sent_packet_number_, packet_number);
   largest_sent_packet_number_ = packet_number;
   hybrid_slow_start_.OnPacketSent(packet_number);
   return true;
 }
 
 QuicTime::Delta TcpCubicSenderBase::TimeUntilSend(
     QuicTime /* now */,
     QuicByteCount bytes_in_flight) const {
-  if (InRecovery()) {
+  if (!no_prr_ && InRecovery()) {
     // PRR is used when in recovery.
     return prr_.TimeUntilSend(GetCongestionWindow(), bytes_in_flight,
                               GetSlowStartThreshold());
   }
   if (GetCongestionWindow() > bytes_in_flight) {
     return QuicTime::Delta::Zero();
   }
   if (min4_mode_ && bytes_in_flight < 4 * kDefaultTCPMSS) {
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 QuicBandwidth TcpCubicSenderBase::PacingRate() const {
   // We pace at twice the rate of the underlying sender's bandwidth estimate
   // during slow start and 1.25x during congestion avoidance to ensure pacing
   // doesn't prevent us from filling the window.
   QuicTime::Delta srtt = rtt_stats_->smoothed_rtt();
   if (srtt.IsZero()) {
     srtt = QuicTime::Delta::FromMicroseconds(rtt_stats_->initial_rtt_us());
   }
   const QuicBandwidth bandwidth =
       QuicBandwidth::FromBytesAndTimeDelta(GetCongestionWindow(), srtt);
-  return bandwidth.Scale(InSlowStart() ? 2 : 1.25);
+  return bandwidth.Scale(InSlowStart() ? 2
+                                       : (no_prr_ && InRecovery() ? 1 : 1.25));
 }
 
 QuicBandwidth TcpCubicSenderBase::BandwidthEstimate() const {
   QuicTime::Delta srtt = rtt_stats_->smoothed_rtt();
   if (srtt.IsZero()) {
     // If we haven't measured an rtt, the bandwidth estimate is unknown.
     return QuicBandwidth::Zero();
   }
   return QuicBandwidth::FromBytesAndTimeDelta(GetCongestionWindow(), srtt);
 }
@@ skipping 38 matching lines @@
 void TcpCubicSenderBase::OnConnectionMigration() {
   hybrid_slow_start_.Restart();
   prr_ = PrrSender();
   largest_sent_packet_number_ = 0;
   largest_acked_packet_number_ = 0;
   largest_sent_at_last_cutback_ = 0;
   last_cutback_exited_slowstart_ = false;
 }
 
 }  // namespace net