Landing Recent QUIC changes until 12:43 PM, Nov 5, 2016 UTC+8

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 39 matching lines @@
     : mode(sender.mode_),
       max_bandwidth(sender.max_bandwidth_.GetBest()),
       round_trip_count(sender.round_trip_count_),
       gain_cycle_index(sender.cycle_current_offset_),
       congestion_window(sender.congestion_window_),
       is_at_full_bandwidth(sender.is_at_full_bandwidth_),
       bandwidth_at_last_round(sender.bandwidth_at_last_round_),
       rounds_without_bandwidth_gain(sender.rounds_without_bandwidth_gain_),
       min_rtt(sender.min_rtt_),
       min_rtt_timestamp(sender.min_rtt_timestamp_),
+      recovery_state(sender.recovery_state_),
+      recovery_window(sender.recovery_window_),
       last_sample_is_app_limited(sender.last_sample_is_app_limited_) {}
 
 BbrSender::DebugState::DebugState(const DebugState& state) = default;
 
 BbrSender::BbrSender(const QuicClock* clock,
                      const RttStats* rtt_stats,
                      const QuicUnackedPacketMap* unacked_packets,
                      QuicPacketCount initial_tcp_congestion_window,
                      QuicPacketCount max_tcp_congestion_window,
                      QuicRandom* random)
@@ skipping 17 matching lines @@
       pacing_gain_(1),
       congestion_window_gain_(1),
       cycle_current_offset_(0),
       last_cycle_start_(QuicTime::Zero()),
       is_at_full_bandwidth_(false),
       rounds_without_bandwidth_gain_(0),
       bandwidth_at_last_round_(QuicBandwidth::Zero()),
       exiting_quiescence_(false),
       exit_probe_rtt_at_(QuicTime::Zero()),
       probe_rtt_round_passed_(false),
-      last_sample_is_app_limited_(false) {
+      last_sample_is_app_limited_(false),
+      recovery_state_(NOT_IN_RECOVERY),
+      end_recovery_at_(0) {
   EnterStartupMode();
 }
 
 BbrSender::~BbrSender() {}
 
 bool BbrSender::InSlowStart() const {
   return mode_ == STARTUP;
 }
 
 bool BbrSender::OnPacketSent(QuicTime sent_time,
@@ skipping 30 matching lines @@
 
 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_);
+  }
+
   return congestion_window_;
 }
 
 QuicByteCount BbrSender::GetSlowStartThreshold() const {
   return 0;
 }
 
 bool BbrSender::InRecovery() const {
-  return false;
+  return recovery_state_ != NOT_IN_RECOVERY;
 }
 
 void BbrSender::OnCongestionEvent(bool /*rtt_updated*/,
                                   QuicByteCount prior_in_flight,
                                   QuicTime event_time,
                                   const CongestionVector& acked_packets,
                                   const CongestionVector& lost_packets) {
   const QuicByteCount total_bytes_acked_before = sampler_.total_bytes_acked();
 
   bool is_round_start = false;
   bool min_rtt_expired = false;
 
   DiscardLostPackets(lost_packets);
 
   // Input the new data into the BBR model of the connection.
   if (!acked_packets.empty()) {
     QuicPacketNumber last_acked_packet = acked_packets.rbegin()->first;
     is_round_start = UpdateRoundTripCounter(last_acked_packet);
     min_rtt_expired = UpdateBandwidthAndMinRtt(event_time, acked_packets);
+    UpdateRecoveryState(last_acked_packet, !lost_packets.empty(),
+                        is_round_start);
   }
 
   // Handle logic specific to PROBE_BW mode.
   if (mode_ == PROBE_BW) {
     UpdateGainCyclePhase(event_time, prior_in_flight, !lost_packets.empty());
   }
 
   // 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);
 
   // 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);
 
   // Cleanup internal state.
   sampler_.RemoveObsoletePackets(unacked_packets_->GetLeastUnacked());
 }
 
 CongestionControlType BbrSender::GetCongestionControlType() const {
   return kBBR;
 }
 
 QuicTime::Delta BbrSender::GetMinRtt() const {
@@ skipping 189 matching lines @@
         } else {
           EnterProbeBandwidthMode(now);
         }
       }
     }
   }
 
   exiting_quiescence_ = false;
 }
 
+void BbrSender::UpdateRecoveryState(QuicPacketNumber last_acked_packet,
+                                    bool has_losses,
+                                    bool is_round_start) {
+  // 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;
+        // 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;
+      }
+
+    case GROWTH:
+      // Exit recovery if appropriate.
+      if (!has_losses && last_acked_packet > end_recovery_at_) {
+        recovery_state_ = NOT_IN_RECOVERY;
+      }
+      break;
+  }
+}
+
 void BbrSender::CalculatePacingRate() {
   if (BandwidthEstimate().IsZero()) {
     return;
   }
 
   pacing_rate_ = pacing_gain_ * BandwidthEstimate();
 }
 
 void BbrSender::CalculateCongestionWindow(QuicByteCount bytes_acked) {
   if (mode_ == PROBE_RTT) {
@@ skipping 14 matching lines @@
   } else if (congestion_window_ < target_window ||
              sampler_.total_bytes_acked() < initial_congestion_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) {
+  switch (recovery_state_) {
+    case CONSERVATION:
+      recovery_window_ = unacked_packets_->bytes_in_flight() + bytes_acked;
+      break;
+    case GROWTH:
+      recovery_window_ = unacked_packets_->bytes_in_flight() + 2 * bytes_acked;
+      break;
+    default:
+      break;
+  }
+  recovery_window_ = std::max(kMinimumCongestionWindow, recovery_window_);
+}
+
 std::string BbrSender::GetDebugState() const {
   std::ostringstream stream;
   stream << ExportDebugState();
   return stream.str();
 }
 
 void BbrSender::OnApplicationLimited(QuicByteCount bytes_in_flight) {
   if (bytes_in_flight >= GetCongestionWindow()) {
     return;
   }
@@ skipping 46 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