Landing Recent QUIC changes until Jun 27 19:50:48 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 71 matching lines @@
       random_(random),
       mode_(STARTUP),
       sampler_(),
       round_trip_count_(0),
       last_sent_packet_(0),
       current_round_trip_end_(0),
       max_bandwidth_(kBandwidthWindowSize, QuicBandwidth::Zero(), 0),
       max_ack_height_(kBandwidthWindowSize, 0, 0),
       aggregation_epoch_start_time_(QuicTime::Zero()),
       aggregation_epoch_bytes_(0),
+      bytes_acked_since_queue_drained_(0),
       min_rtt_(QuicTime::Delta::Zero()),
       min_rtt_timestamp_(QuicTime::Zero()),
       congestion_window_(initial_tcp_congestion_window * kDefaultTCPMSS),
       initial_congestion_window_(initial_tcp_congestion_window *
                                  kDefaultTCPMSS),
       max_congestion_window_(max_tcp_congestion_window * kDefaultTCPMSS),
       pacing_rate_(QuicBandwidth::Zero()),
       pacing_gain_(1),
       congestion_window_gain_(1),
       congestion_window_gain_constant_(
@@ skipping 10 matching lines @@
       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),
       recovery_state_(NOT_IN_RECOVERY),
       end_recovery_at_(0),
       recovery_window_(max_congestion_window_),
-      bytes_recently_acked_(0) {
+      bytes_recently_acked_(0),
+      rate_based_recovery_(false) {
   EnterStartupMode();
 }
 
 BbrSender::~BbrSender() {}
 
 bool BbrSender::InSlowStart() const {
   return mode_ == STARTUP;
 }
 
 bool BbrSender::OnPacketSent(QuicTime sent_time,
@@ skipping 64 matching lines @@
 
 QuicBandwidth BbrSender::BandwidthEstimate() const {
   return max_bandwidth_.GetBest();
 }
 
 QuicByteCount BbrSender::GetCongestionWindow() const {
   if (mode_ == PROBE_RTT) {
     return kMinimumCongestionWindow;
   }
 
-  if (InRecovery()) {
+  if (InRecovery() && !rate_based_recovery_) {
     return std::min(congestion_window_, recovery_window_);
   }
 
   return congestion_window_;
 }
 
 QuicByteCount BbrSender::GetSlowStartThreshold() const {
   return 0;
 }
 
 bool BbrSender::InRecovery() const {
   return recovery_state_ != NOT_IN_RECOVERY;
 }
 
 void BbrSender::SetFromConfig(const QuicConfig& config,
                               Perspective perspective) {
   if (config.HasClientRequestedIndependentOption(k1RTT, perspective)) {
     num_startup_rtts_ = 1;
   }
   if (config.HasClientRequestedIndependentOption(k2RTT, perspective)) {
     num_startup_rtts_ = 2;
   }
+  if (FLAGS_quic_reloadable_flag_quic_bbr_rate_recovery &&
+      config.HasClientRequestedIndependentOption(kBBRR, perspective)) {
+    rate_based_recovery_ = true;
+  }
 }
 
 void BbrSender::ResumeConnectionState(
     const CachedNetworkParameters& cached_network_params,
     bool max_bandwidth_resumption) {
   if (!FLAGS_quic_reloadable_flag_quic_bbr_bandwidth_resumption) {
     return;
   }
 
   QUIC_FLAG_COUNT(quic_reloadable_flag_quic_bbr_bandwidth_resumption);
@@ skipping 24 matching lines @@
   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);
 
+    const QuicByteCount bytes_acked =
+        sampler_.total_bytes_acked() - total_bytes_acked_before;
     if (FLAGS_quic_reloadable_flag_quic_bbr_slow_recent_delivery) {
       QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_slow_recent_delivery, 1,
                         2);
-      UpdateRecentlyAcked(
-          event_time, sampler_.total_bytes_acked() - total_bytes_acked_before);
+      UpdateRecentlyAcked(event_time, bytes_acked);
     }
 
     if (FLAGS_quic_reloadable_flag_quic_bbr_ack_aggregation_bytes) {
       QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_ack_aggregation_bytes, 1,
                         2);
-      UpdateAckAggregationBytes(
-          event_time, sampler_.total_bytes_acked() - total_bytes_acked_before);
+      UpdateAckAggregationBytes(event_time, bytes_acked);
+    }
+    if (FLAGS_quic_reloadable_flag_quic_bbr_ack_aggregation_bytes2) {
+      QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_ack_aggregation_bytes2, 1,
+                        2);
+      UpdateAckAggregationBytes(event_time, bytes_acked);
+      if (unacked_packets_->bytes_in_flight() <=
+          1.25 * GetTargetCongestionWindow(pacing_gain_)) {
+        bytes_acked_since_queue_drained_ = 0;
+      } else {
+        bytes_acked_since_queue_drained_ += bytes_acked;
+      }
     }
   }
 
   // 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_) {
@@ skipping 307 matching lines @@
   max_ack_height_.Update(aggregation_epoch_bytes_ - expected_bytes_acked,
                          round_trip_count_);
 }
 
 void BbrSender::CalculatePacingRate() {
   if (BandwidthEstimate().IsZero()) {
     return;
   }
 
   QuicBandwidth target_rate = pacing_gain_ * BandwidthEstimate();
+  if (rate_based_recovery_ && InRecovery()) {
+    QUIC_FLAG_COUNT(quic_reloadable_flag_quic_bbr_rate_recovery);
+    pacing_rate_ = pacing_gain_ * max_bandwidth_.GetThirdBest();
+  }
   if (is_at_full_bandwidth_) {
     pacing_rate_ = target_rate;
     return;
   }
 
   // Pace at the rate of initial_window / RTT as soon as RTT measurements are
   // available.
   if (pacing_rate_.IsZero() && !rtt_stats_->min_rtt().IsZero()) {
     pacing_rate_ = QuicBandwidth::FromBytesAndTimeDelta(
         initial_congestion_window_, rtt_stats_->min_rtt());
@@ skipping 13 matching lines @@
       GetTargetCongestionWindow(congestion_window_gain_);
 
   if (rtt_variance_weight_ > 0.f && !BandwidthEstimate().IsZero()) {
     target_window += rtt_variance_weight_ * rtt_stats_->mean_deviation() *
                      BandwidthEstimate();
   } else if (FLAGS_quic_reloadable_flag_quic_bbr_ack_aggregation_bytes &&
              is_at_full_bandwidth_) {
     QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_ack_aggregation_bytes, 2,
                       2);
     target_window += max_ack_height_.GetBest();
+  } else if (FLAGS_quic_reloadable_flag_quic_bbr_ack_aggregation_bytes2 &&
+             is_at_full_bandwidth_) {
+    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_ack_aggregation_bytes2, 2,
+                      2);
+    if (2 * max_ack_height_.GetBest() > bytes_acked_since_queue_drained_) {
+      target_window +=
+          2 * max_ack_height_.GetBest() - bytes_acked_since_queue_drained_;
+    }
   }
   if (FLAGS_quic_reloadable_flag_quic_bbr_add_tso_cwnd) {
     // QUIC doesn't have TSO, but it does have similarly quantized pacing, so
     // allow extra CWND to make QUIC's BBR CWND identical to TCP's.
     QuicByteCount tso_segs_goal = 0;
     if (pacing_rate_ < QuicBandwidth::FromKBitsPerSecond(1200)) {
       tso_segs_goal = kDefaultTCPMSS;
     } else if (pacing_rate_ < QuicBandwidth::FromKBitsPerSecond(24000)) {
       tso_segs_goal = 2 * kDefaultTCPMSS;
     } else {
@@ skipping 17 matching lines @@
     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,
                                         QuicByteCount bytes_lost) {
+  if (rate_based_recovery_) {
+    return;
+  }
   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_);
@@ skipping 94 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