Rollback of merge internal change: 87346681.

net/quic/congestion_control/tcp_cubic_sender.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.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "net/quic/congestion_control/prr_sender.h"
@@ skipping 13 matching lines @@
 const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
 const int kMaxBurstLength = 3;
 const float kRenoBeta = 0.7f;  // Reno backoff factor.
 const uint32 kDefaultNumConnections = 2;  // N-connection emulation.
 }  // namespace
 
 TcpCubicSender::TcpCubicSender(const QuicClock* clock,
                                const RttStats* rtt_stats,
                                bool reno,
                                QuicPacketCount initial_tcp_congestion_window,
+                               QuicPacketCount max_tcp_congestion_window,
                                QuicConnectionStats* stats)
     : hybrid_slow_start_(clock),
       cubic_(clock),
       rtt_stats_(rtt_stats),
       stats_(stats),
       reno_(reno),
       num_connections_(kDefaultNumConnections),
-      num_acked_packets_(0),
+      congestion_window_count_(0),
       largest_sent_sequence_number_(0),
       largest_acked_sequence_number_(0),
       largest_sent_at_last_cutback_(0),
       congestion_window_(initial_tcp_congestion_window),
       min_congestion_window_(kDefaultMinimumCongestionWindow),
-      slowstart_threshold_(std::numeric_limits<uint64>::max()),
+      slowstart_threshold_(max_tcp_congestion_window),
       last_cutback_exited_slowstart_(false),
+      max_tcp_congestion_window_(max_tcp_congestion_window),
       clock_(clock) {
 }
 
 TcpCubicSender::~TcpCubicSender() {
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.FinalTcpCwnd", congestion_window_);
 }
 
 void TcpCubicSender::SetFromConfig(const QuicConfig& config,
                                    Perspective perspective,
                                    bool using_pacing) {
@@ skipping 27 matching lines @@
   }
 
   QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(
       cached_network_params.bandwidth_estimate_bytes_per_second());
   QuicTime::Delta rtt_ms =
       QuicTime::Delta::FromMilliseconds(cached_network_params.min_rtt_ms());
 
   // Make sure CWND is in appropriate range (in case of bad data).
   QuicPacketCount new_congestion_window =
       bandwidth.ToBytesPerPeriod(rtt_ms) / kMaxPacketSize;
-  congestion_window_ = max(
-      min(new_congestion_window, kMaxCongestionWindowForBandwidthResumption),
-      kMinCongestionWindowForBandwidthResumption);
+  congestion_window_ = max(min(new_congestion_window, kMaxTcpCongestionWindow),
+                           kMinCongestionWindowForBandwidthResumption);
 
   // TODO(rjshade): Set appropriate CWND when previous connection was in slow
   // start at time of estimate.
   return true;
 }
 
 void TcpCubicSender::SetNumEmulatedConnections(int num_connections) {
   num_connections_ = max(1, num_connections);
   cubic_.SetNumConnections(num_connections_);
 }
@@ skipping 70 matching lines @@
         cubic_.CongestionWindowAfterPacketLoss(congestion_window_);
   }
   slowstart_threshold_ = congestion_window_;
   // Enforce a minimum congestion window.
   if (congestion_window_ < min_congestion_window_) {
     congestion_window_ = min_congestion_window_;
   }
   largest_sent_at_last_cutback_ = largest_sent_sequence_number_;
   // reset packet count from congestion avoidance mode. We start
   // counting again when we're out of recovery.
-  num_acked_packets_ = 0;
+  congestion_window_count_ = 0;
   DVLOG(1) << "Incoming loss; congestion window: " << congestion_window_
            << " slowstart threshold: " << slowstart_threshold_;
 }
 
 bool TcpCubicSender::OnPacketSent(QuicTime /*sent_time*/,
                                   QuicByteCount /*bytes_in_flight*/,
                                   QuicPacketSequenceNumber sequence_number,
                                   QuicByteCount bytes,
                                   HasRetransmittableData is_retransmittable) {
   // Only update bytes_in_flight_ for data packets.
@@ skipping 100 matching lines @@
 void TcpCubicSender::MaybeIncreaseCwnd(
     QuicPacketSequenceNumber acked_sequence_number,
     QuicByteCount bytes_in_flight) {
   LOG_IF(DFATAL, InRecovery()) << "Never increase the CWND during recovery.";
   if (!IsCwndLimited(bytes_in_flight)) {
     // We don't update the congestion window unless we are close to using the
     // window we have available.
     return;
   }
   if (InSlowStart()) {
-    // TCP slow start, exponential growth, increase by one for each ACK.
-    ++congestion_window_;
+    // congestion_window_cnt is the number of acks since last change of snd_cwnd
+    if (congestion_window_ < max_tcp_congestion_window_) {
+      // TCP slow start, exponential growth, increase by one for each ACK.
+      ++congestion_window_;
+    }
     DVLOG(1) << "Slow start; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_;
     return;
   }
+  if (congestion_window_ >= max_tcp_congestion_window_) {
+    return;
+  }
   // Congestion avoidance
   if (reno_) {
     // Classic Reno congestion avoidance.
-    ++num_acked_packets_;
+    ++congestion_window_count_;
     // Divide by num_connections to smoothly increase the CWND at a faster
     // rate than conventional Reno.
-    if (num_acked_packets_ * num_connections_ >= congestion_window_) {
+    if (congestion_window_count_ * num_connections_ >= congestion_window_) {
       ++congestion_window_;
-      num_acked_packets_ = 0;
+      congestion_window_count_ = 0;
     }
 
     DVLOG(1) << "Reno; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_
-             << " congestion window count: " << num_acked_packets_;
+             << " congestion window count: " << congestion_window_count_;
   } else {
-    congestion_window_ = cubic_.CongestionWindowAfterAck(congestion_window_,
-                                                         rtt_stats_->min_rtt());
+    congestion_window_ = min(max_tcp_congestion_window_,
+                             cubic_.CongestionWindowAfterAck(
+                                 congestion_window_, rtt_stats_->min_rtt()));
     DVLOG(1) << "Cubic; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_;
   }
 }
 
 void TcpCubicSender::OnRetransmissionTimeout(bool packets_retransmitted) {
   largest_sent_at_last_cutback_ = 0;
   if (!packets_retransmitted) {
     return;
   }
   cubic_.Reset();
   hybrid_slow_start_.Restart();
   slowstart_threshold_ = congestion_window_ / 2;
   congestion_window_ = min_congestion_window_;
 }
 
 CongestionControlType TcpCubicSender::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net