Limit QUIC's Cubic CWND increases to 1/2 the bytes acked when in

net/quic/core/congestion_control/cubic_bytes.cc

 // Copyright (c) 2015 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/core/congestion_control/cubic_bytes.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
+#include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_protocol.h"
 
 using std::max;
+using std::min;
 
 namespace net {
 
 namespace {
 
 // Constants based on TCP defaults.
 // The following constants are in 2^10 fractions of a second instead of ms to
 // allow a 10 shift right to divide.
 const int kCubeScale = 40;  // 1024*1024^3 (first 1024 is from 0.100^3)
                             // where 0.100 is 100 ms which is the scaling
@@ skipping 118 matching lines @@
       ((current_time + delay_min - epoch_).ToMicroseconds() << 10) /
       kNumMicrosPerSecond;
 
   int64_t offset = time_to_origin_point_ - elapsed_time;
   QuicByteCount delta_congestion_window =
       ((kCubeCongestionWindowScale * offset * offset * offset) >> kCubeScale) *
       kDefaultTCPMSS;
 
   QuicByteCount target_congestion_window =
       origin_point_congestion_window_ - delta_congestion_window;
+  if (FLAGS_quic_limit_cubic_cwnd_increase) {
+    // Limit the CWND increase to half the acked bytes.
+    target_congestion_window =
+        min(target_congestion_window,
+            current_congestion_window + acked_bytes_count_ / 2);
+  }
 
   DCHECK_LT(0u, estimated_tcp_congestion_window_);
   // Increase the window by Alpha * 1 MSS of bytes every time we ack an
   // estimated tcp window of bytes.
   estimated_tcp_congestion_window_ += acked_bytes_count_ *
                                       (Alpha() * kDefaultTCPMSS) /
                                       estimated_tcp_congestion_window_;
   acked_bytes_count_ = 0;
 
   // We have a new cubic congestion window.
   last_target_congestion_window_ = target_congestion_window;
 
   // Compute target congestion_window based on cubic target and estimated TCP
   // congestion_window, use highest (fastest).
   if (target_congestion_window < estimated_tcp_congestion_window_) {
     target_congestion_window = estimated_tcp_congestion_window_;
   }
 
   DVLOG(1) << "Final target congestion_window: " << target_congestion_window;
   return target_congestion_window;
 }
 
 }  // namespace net