Landing Recent QUIC changes until Mon Apr 17 2017

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"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/proto/cached_network_parameters.pb.h"
-#include "net/quic/core/quic_flags.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 #include "net/quic/platform/api/quic_flag_utils.h"
+#include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_logging.h"
 
 namespace net {
 
 namespace {
 // Constants based on TCP defaults.
 const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
 // The minimum CWND to ensure delayed acks don't reduce bandwidth measurements.
 // Does not inflate the pacing rate.
 const QuicByteCount kMinimumCongestionWindow = 4 * kMaxSegmentSize;
@@ skipping 47 matching lines @@
                      QuicRandom* random)
     : rtt_stats_(rtt_stats),
       unacked_packets_(unacked_packets),
       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_spacing_(kBandwidthWindowSize, QuicTime::Delta::Zero(), 0),
-      largest_acked_time_(QuicTime::Zero()),
-      largest_acked_sent_time_(QuicTime::Zero()),
       max_ack_height_(kBandwidthWindowSize, 0, 0),
       aggregation_epoch_start_time_(QuicTime::Zero()),
       aggregation_epoch_bytes_(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_(
-          static_cast<float>(base::GetFlag(FLAGS_quic_bbr_cwnd_gain))),
-      rtt_variance_weight_(static_cast<float>(
-          base::GetFlag(FLAGS_quic_bbr_rtt_variation_weight))),
+          static_cast<float>(GetQuicFlag(FLAGS_quic_bbr_cwnd_gain))),
+      rtt_variance_weight_(
+          static_cast<float>(GetQuicFlag(FLAGS_quic_bbr_rtt_variation_weight))),
       num_startup_rtts_(kRoundTripsWithoutGrowthBeforeExitingStartup),
       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),
@@ skipping 26 matching lines @@
 }
 
 QuicTime::Delta BbrSender::TimeUntilSend(QuicTime /* now */,
                                          QuicByteCount bytes_in_flight) const {
   if (bytes_in_flight < GetCongestionWindow()) {
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
-QuicBandwidth BbrSender::PacingRate(QuicByteCount /*bytes_in_flight*/) const {
+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 11 matching lines @@
   }
 }
 
 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);
+
   QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(
       max_bandwidth_resumption
           ? cached_network_params.max_bandwidth_estimate_bytes_per_second()
           : cached_network_params.bandwidth_estimate_bytes_per_second());
   QuicTime::Delta rtt =
       QuicTime::Delta::FromMilliseconds(cached_network_params.min_rtt_ms());
 
   max_bandwidth_.Update(bandwidth, round_trip_count_);
   if (!rtt.IsZero() && (min_rtt_ > rtt || min_rtt_.IsZero())) {
     min_rtt_ = rtt;
@@ skipping 12 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);
-    if (FLAGS_quic_reloadable_flag_quic_bbr_ack_spacing2) {
-      QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_ack_spacing2, 1, 2);
-      UpdateAckSpacing(event_time, last_acked_packet, acked_packets);
-    }
     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);
     }
   }
 
   // Handle logic specific to PROBE_BW mode.
   if (mode_ == PROBE_BW) {
@@ skipping 26 matching lines @@
 }
 
 QuicTime::Delta BbrSender::GetMinRtt() const {
   return !min_rtt_.IsZero()
              ? min_rtt_
              : QuicTime::Delta::FromMicroseconds(rtt_stats_->initial_rtt_us());
 }
 
 QuicByteCount BbrSender::GetTargetCongestionWindow(float gain) const {
   QuicByteCount bdp = GetMinRtt() * BandwidthEstimate();
+  if (FLAGS_quic_reloadable_flag_quic_bbr_base_cwnd_on_srtt &&
+      mode_ == PROBE_BW && gain >= 1 && !rtt_stats_->smoothed_rtt().IsZero()) {
+    bdp = rtt_stats_->smoothed_rtt() * BandwidthEstimate();
+  }
   QuicByteCount congestion_window = gain * bdp;
 
   // BDP estimate will be zero if no bandwidth samples are available yet.
   if (congestion_window == 0) {
     congestion_window = gain * initial_congestion_window_;
   }
 
   return std::max(congestion_window, kMinimumCongestionWindow);
 }
 
@@ skipping 203 matching lines @@
 
     case GROWTH:
       // Exit recovery if appropriate.
       if (!has_losses && last_acked_packet > end_recovery_at_) {
         recovery_state_ = NOT_IN_RECOVERY;
       }
       break;
   }
 }
 
-// TODO(ianswett): Move this logic into BandwidthSampler.
-void BbrSender::UpdateAckSpacing(QuicTime ack_time,
-                                 QuicPacketNumber largest_newly_acked,
-                                 const CongestionVector& acked_packets) {
-  // Ignore acks of reordered packets.
-  if (largest_newly_acked < unacked_packets_->largest_observed()) {
-    return;
-  }
-  // Ignore acks of only one packet to filter out delayed acks.
-  if (acked_packets.size() == 1) {
-    return;
-  }
-  QuicTime largest_newly_acked_sent_time =
-      unacked_packets_->GetTransmissionInfo(largest_newly_acked).sent_time;
-  // Initialize on the first ack.
-  if (!largest_acked_time_.IsInitialized()) {
-    largest_acked_time_ = ack_time;
-    largest_acked_sent_time_ = largest_newly_acked_sent_time;
-    return;
-  }
-  QuicTime::Delta ack_delta = ack_time - largest_acked_time_;
-  QuicTime::Delta send_delta =
-      largest_newly_acked_sent_time - largest_acked_sent_time_;
-  largest_acked_time_ = ack_time;
-  largest_acked_sent_time_ = largest_newly_acked_sent_time;
-  if (ack_delta <= send_delta) {
-    return;
-  }
-
-  // Limit the ack spacing to SRTT to filter outliers.
-  QuicTime::Delta ack_spacing =
-      std::min(ack_delta - send_delta, rtt_stats_->smoothed_rtt());
-  max_ack_spacing_.Update(ack_spacing, round_trip_count_);
-}
-
-// TODO(ianswett): Move this logic into BandwidthSampler.
 void BbrSender::UpdateAckAggregationBytes(QuicTime ack_time,
                                           QuicByteCount newly_acked_bytes) {
   // Compute how many bytes are expected to be delivered, assuming max bandwidth
   // is correct.
   QuicByteCount expected_bytes_acked =
       max_bandwidth_.GetBest() * (ack_time - aggregation_epoch_start_time_);
   // Reset the current aggregation epoch as soon as the ack arrival rate is less
   // than or equal to the max bandwidth.
   if (aggregation_epoch_bytes_ <= expected_bytes_acked) {
     // Reset to start measuring a new aggregation epoch.
@@ skipping 36 matching lines @@
   if (mode_ == PROBE_RTT) {
     return;
   }
 
   QuicByteCount target_window =
       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_spacing2 &&
-             is_at_full_bandwidth_) {
-    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_bbr_ack_spacing2, 2, 2);
-    // Add CWND for inter-ack spacing once STARTUP has been exited.
-    target_window += max_ack_spacing_.GetBest() * 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();
   }
   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;
@@ skipping 100 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