Landing Recent QUIC changes until Sat Apr 29 00:22:04 2017 +0000

net/quic/core/congestion_control/bbr_sender.cc

 // Copyright 2016 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/bbr_sender.h"
 
 #include <algorithm>
 #include <sstream>
 
 #include "net/quic/core/congestion_control/rtt_stats.h"
@@ skipping 174 matching lines @@
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 QuicBandwidth BbrSender::PacingRate(QuicByteCount bytes_in_flight) const {
   if (pacing_rate_.IsZero()) {
     return kHighGain * QuicBandwidth::FromBytesAndTimeDelta(
                            initial_congestion_window_, GetMinRtt());
   }
-  if (FLAGS_quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate &&
-      mode_ == PROBE_BW && bytes_in_flight > congestion_window_) {
-    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate,
-                      1, 2);
-    if (pacing_gain_ > 1) {
-      return max_bandwidth_.GetBest();
-    } else {
-      return max_bandwidth_.GetThirdBest();
-    }
-  }
   return pacing_rate_;
 }
 
 QuicBandwidth BbrSender::BandwidthEstimate() const {
   return max_bandwidth_.GetBest();
 }
 
 QuicByteCount BbrSender::GetCongestionWindow() const {
   if (mode_ == PROBE_RTT) {
     return kMinimumCongestionWindow;
   }
 
   if (InRecovery()) {
     return std::min(congestion_window_, recovery_window_);
   }
 
-  if (FLAGS_quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate &&
-      mode_ == PROBE_BW && pacing_gain_ >= 1) {
-    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate,
-                      2, 2);
-    // Send for another SRTT at a more recently measured bandwidth.
-    return congestion_window_ +
-           max_bandwidth_.GetThirdBest() * rtt_stats_->smoothed_rtt();
-  }
-
   return congestion_window_;
 }
 
 QuicByteCount BbrSender::GetSlowStartThreshold() const {
   return 0;
 }
 
 bool BbrSender::InRecovery() const {
   return recovery_state_ != NOT_IN_RECOVERY;
 }
@@ skipping 75 matching lines @@
 
   // Handle logic specific to STARTUP and DRAIN modes.
   if (is_round_start && !is_at_full_bandwidth_) {
     CheckIfFullBandwidthReached();
   }
   MaybeExitStartupOrDrain(event_time);
 
   // Handle logic specific to PROBE_RTT.
   MaybeEnterOrExitProbeRtt(event_time, is_round_start, min_rtt_expired);
 
+  // Calculate number of packets acked and lost.
+  QuicByteCount bytes_acked =
+      sampler_.total_bytes_acked() - total_bytes_acked_before;
+  QuicByteCount bytes_lost = 0;
+  for (const auto& packet : lost_packets) {
+    bytes_lost += packet.second;
+  }
+
   // After the model is updated, recalculate the pacing rate and congestion
   // window.
-  QuicByteCount bytes_acked =
-      sampler_.total_bytes_acked() - total_bytes_acked_before;
   CalculatePacingRate();
   CalculateCongestionWindow(bytes_acked);
-  CalculateRecoveryWindow(bytes_acked);
+  CalculateRecoveryWindow(bytes_acked, bytes_lost);
 
   // Cleanup internal state.
   sampler_.RemoveObsoletePackets(unacked_packets_->GetLeastUnacked());
 }
 
 CongestionControlType BbrSender::GetCongestionControlType() const {
   return kBBR;
 }
 
 QuicTime::Delta BbrSender::GetMinRtt() const {
@@ skipping 204 matching lines @@
   // Exit recovery when there are no losses for a round.
   if (has_losses) {
     end_recovery_at_ = last_sent_packet_;
   }
 
   switch (recovery_state_) {
     case NOT_IN_RECOVERY:
       // Enter conservation on the first loss.
       if (has_losses) {
         recovery_state_ = CONSERVATION;
-        if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation) {
+        if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation ||
+            FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation2) {
           // This will cause the |recovery_window_| to be set to the correct
           // value in CalculateRecoveryWindow().
           recovery_window_ = 0;
           QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation, 1,
                             3);
+          QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation2, 1,
+                            3);
         }
         // Since the conservation phase is meant to be lasting for a whole
         // round, extend the current round as if it were started right now.
         current_round_trip_end_ = last_sent_packet_;
       }
       break;
 
     case CONSERVATION:
       if (is_round_start) {
         recovery_state_ = GROWTH;
@@ skipping 137 matching lines @@
     // If the connection is not yet out of startup phase, do not decrease the
     // window.
     congestion_window_ = congestion_window_ + bytes_acked;
   }
 
   // Enforce the limits on the congestion window.
   congestion_window_ = std::max(congestion_window_, kMinimumCongestionWindow);
   congestion_window_ = std::min(congestion_window_, max_congestion_window_);
 }
 
-void BbrSender::CalculateRecoveryWindow(QuicByteCount bytes_acked) {
+void BbrSender::CalculateRecoveryWindow(QuicByteCount bytes_acked,
+                                        QuicByteCount bytes_lost) {
+  if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation2) {
+    if (recovery_state_ == NOT_IN_RECOVERY) {
+      return;
+    }
+
+    // Set up the initial recovery window.
+    if (recovery_window_ == 0) {
+      QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation2, 2, 3);
+      recovery_window_ = unacked_packets_->bytes_in_flight() + bytes_acked;
+      recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
+      return;
+    }
+
+    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation2, 3, 3);
+
+    // Remove losses from the recovery window, while accounting for a potential
+    // integer underflow.
+    recovery_window_ = recovery_window_ >= bytes_lost
+                           ? recovery_window_ - bytes_lost
+                           : kMaxSegmentSize;
+
+    // In CONSERVATION mode, just subtracting losses is sufficient.  In GROWTH,
+    // release additional |bytes_acked| to achieve a slow-start-like behavior.
+    if (recovery_state_ == GROWTH) {
+      recovery_window_ += bytes_acked;
+    }
+
+    // Sanity checks.  Ensure that we always allow to send at least
+    // |bytes_acked| in response.
+    recovery_window_ = std::max(
+        recovery_window_, unacked_packets_->bytes_in_flight() + bytes_acked);
+    recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
+    return;
+  }
+
   switch (recovery_state_) {
     case CONSERVATION:
       if (FLAGS_quic_reloadable_flag_quic_bbr_fix_conservation) {
         QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_fix_conservation, 2, 3);
         recovery_window_ =
             std::max(unacked_packets_->bytes_in_flight() + bytes_acked,
                      recovery_window_);
       } else {
         recovery_window_ = unacked_packets_->bytes_in_flight() + bytes_acked;
       }
@@ skipping 74 matching lines @@
   os << "Minimum RTT timestamp: " << state.min_rtt_timestamp.ToDebuggingValue()
      << std::endl;
 
   os << "Last sample is app-limited: "
      << (state.last_sample_is_app_limited ? "yes" : "no");
 
   return os;
 }
 
 }  // namespace net