Landing Recent QUIC changes until 4/22/2016 14:55 UTC

net/quic/congestion_control/tcp_cubic_sender_packets.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 @@
     QuicPacketCount max_tcp_congestion_window,
     QuicConnectionStats* stats)
     : TcpCubicSenderBase(clock, rtt_stats, reno, stats),
       cubic_(clock),
       congestion_window_count_(0),
       congestion_window_(initial_tcp_congestion_window),
       min_congestion_window_(kDefaultMinimumCongestionWindow),
       slowstart_threshold_(max_tcp_congestion_window),
       max_tcp_congestion_window_(max_tcp_congestion_window),
       initial_tcp_congestion_window_(initial_tcp_congestion_window),
-      initial_max_tcp_congestion_window_(max_tcp_congestion_window) {}
+      initial_max_tcp_congestion_window_(max_tcp_congestion_window),
+      min_slow_start_exit_window_(min_congestion_window_) {}
 
 TcpCubicSenderPackets::~TcpCubicSenderPackets() {}
 
 void TcpCubicSenderPackets::SetCongestionWindowFromBandwidthAndRtt(
     QuicBandwidth bandwidth,
     QuicTime::Delta rtt) {
-  // Make sure CWND is in appropriate range (in case of bad data).
   QuicPacketCount new_congestion_window =
       bandwidth.ToBytesPerPeriod(rtt) / kDefaultTCPMSS;
-  congestion_window_ = max(min(new_congestion_window, kMaxCongestionWindow),
-                           kMinCongestionWindowForBandwidthResumption);
+  if (FLAGS_quic_no_lower_bw_resumption_limit) {
+    // Limit new CWND to be in the range [1, kMaxCongestionWindow].
+    congestion_window_ = max(min_congestion_window_,
+                             min(new_congestion_window, kMaxCongestionWindow));
+  } else {
+    congestion_window_ = max(min(new_congestion_window, kMaxCongestionWindow),
+                             kMinCongestionWindowForBandwidthResumption);
+  }
 }
 
 void TcpCubicSenderPackets::SetCongestionWindowInPackets(
     QuicPacketCount congestion_window) {
   congestion_window_ = congestion_window;
 }
 
 void TcpCubicSenderPackets::SetMinCongestionWindowInPackets(
     QuicPacketCount congestion_window) {
   min_congestion_window_ = congestion_window;
@@ skipping 21 matching lines @@
   if (packet_number <= largest_sent_at_last_cutback_) {
     if (last_cutback_exited_slowstart_) {
       ++stats_->slowstart_packets_lost;
       stats_->slowstart_bytes_lost += lost_bytes;
       if (slow_start_large_reduction_) {
         if (stats_->slowstart_packets_lost == 1 ||
             (stats_->slowstart_bytes_lost / kDefaultTCPMSS) >
                 (stats_->slowstart_bytes_lost - lost_bytes) / kDefaultTCPMSS) {
           // Reduce congestion window by 1 for every mss of bytes lost.
           congestion_window_ =
-              max(congestion_window_ - 1, min_congestion_window_);
+              max(congestion_window_ - 1, min_slow_start_exit_window_);
         }
         slowstart_threshold_ = congestion_window_;
       }
     }
     DVLOG(1) << "Ignoring loss for largest_missing:" << packet_number
              << " because it was sent prior to the last CWND cutback.";
     return;
   }
   ++stats_->tcp_loss_events;
   last_cutback_exited_slowstart_ = InSlowStart();
   if (InSlowStart()) {
     ++stats_->slowstart_packets_lost;
   }
 
   prr_.OnPacketLost(bytes_in_flight);
 
   // TODO(jri): Separate out all of slow start into a separate class.
   if (slow_start_large_reduction_ && InSlowStart()) {
     DCHECK_LT(1u, congestion_window_);
+    if (FLAGS_quic_sslr_limit_reduction &&
+        congestion_window_ >= 2 * initial_tcp_congestion_window_) {
+      min_slow_start_exit_window_ = congestion_window_ / 2;
+    }
     congestion_window_ = congestion_window_ - 1;
   } else if (reno_) {
     congestion_window_ = congestion_window_ * RenoBeta();
   } else {
     congestion_window_ =
         cubic_.CongestionWindowAfterPacketLoss(congestion_window_);
   }
   // Enforce a minimum congestion window.
   if (congestion_window_ < min_congestion_window_) {
     congestion_window_ = min_congestion_window_;
@@ skipping 74 matching lines @@
   congestion_window_ = initial_tcp_congestion_window_;
   slowstart_threshold_ = initial_max_tcp_congestion_window_;
   max_tcp_congestion_window_ = initial_max_tcp_congestion_window_;
 }
 
 CongestionControlType TcpCubicSenderPackets::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net