Landing Recent QUIC changes until Thu Mar 16 17:24:53 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 64 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_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_(
@@ skipping 107 matching lines @@
   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) {
     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();
@@ skipping 279 matching lines @@
   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.
+    aggregation_epoch_bytes_ = newly_acked_bytes;
+    aggregation_epoch_start_time_ = ack_time;
+    return;
+  }
+
+  // Compute how many extra bytes were delivered vs max bandwidth.
+  // Include the bytes most recently acknowledged to account for stretch acks.
+  aggregation_epoch_bytes_ += newly_acked_bytes;
+  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 (is_at_full_bandwidth_) {
     pacing_rate_ = target_rate;
     return;
   }
@@ skipping 19 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_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();
   }
 
   // Instead of immediately setting the target CWND as the new one, BBR grows
   // the CWND towards |target_window| by only increasing it |bytes_acked| at a
   // time.
   if (is_at_full_bandwidth_) {
     congestion_window_ =
         std::min(target_window, congestion_window_ + bytes_acked);
   } else if (congestion_window_ < target_window ||
              sampler_.total_bytes_acked() < initial_congestion_window_) {
@@ skipping 80 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