Landing Recent QUIC changes until Thu Mar 16 17:24:53 2017 +0000

net/quic/core/congestion_control/bbr_sender.h

 // 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.
 
 // BBR (Bottleneck Bandwidth and RTT) congestion control algorithm.
 
 #ifndef NET_QUIC_CORE_CONGESTION_CONTROL_BBR_SENDER_H_
 #define NET_QUIC_CORE_CONGESTION_CONTROL_BBR_SENDER_H_
 
 #include <cstdint>
@@ skipping 129 matching lines @@
                          QuicRoundTripCount,
                          QuicRoundTripCount>
       MaxBandwidthFilter;
 
   typedef WindowedFilter<QuicTime::Delta,
                          MaxFilter<QuicTime::Delta>,
                          QuicRoundTripCount,
                          QuicRoundTripCount>
       MaxAckDelayFilter;
 
+  typedef WindowedFilter<QuicByteCount,
+                         MaxFilter<QuicByteCount>,
+                         QuicRoundTripCount,
+                         QuicRoundTripCount>
+      MaxAckHeightFilter;
+
   // Returns the current estimate of the RTT of the connection.  Outside of the
   // edge cases, this is minimum RTT.
   QuicTime::Delta GetMinRtt() const;
   // Returns whether the connection has achieved full bandwidth required to exit
   // the slow start.
   bool IsAtFullBandwidth() const;
   // Computes the target congestion window using the specified gain.
   QuicByteCount GetTargetCongestionWindow(float gain) const;
 
   // Enters the STARTUP mode.
@@ skipping 28 matching lines @@
   // recovery.
   void UpdateRecoveryState(QuicPacketNumber last_acked_packet,
                            bool has_losses,
                            bool is_round_start);
 
   // Updates the ack spacing max filter if a larger value is observed.
   void UpdateAckSpacing(QuicTime ack_time,
                         QuicPacketNumber largest_newly_acked,
                         const CongestionVector& acked_packets);
 
+  // Updates the ack aggregation max filter in bytes.
+  void UpdateAckAggregationBytes(QuicTime ack_time,
+                                 QuicByteCount newly_acked_bytes);
+
   // Determines the appropriate pacing rate for the connection.
   void CalculatePacingRate();
   // Determines the appropriate congestion window for the connection.
   void CalculateCongestionWindow(QuicByteCount bytes_acked);
   // Determines the approriate window that constrains the in-flight during
   // recovery.
   void CalculateRecoveryWindow(QuicByteCount bytes_acked);
 
   const RttStats* rtt_stats_;
   const QuicUnackedPacketMap* unacked_packets_;
@@ skipping 18 matching lines @@
   // round-trips.
   MaxBandwidthFilter max_bandwidth_;
 
   // Tracks the maximum spacing between two acks acknowledging in order packets.
   MaxAckDelayFilter max_ack_spacing_;
 
   // The time the largest acked packet was acked and when it was sent.
   QuicTime largest_acked_time_;
   QuicTime largest_acked_sent_time_;
 
+  // Tracks the maximum number of bytes acked faster than the sending rate.
+  MaxAckHeightFilter max_ack_height_;
+
+  // The time this aggregation started and the number of bytes acked during it.
+  QuicTime aggregation_epoch_start_time_;
+  QuicByteCount aggregation_epoch_bytes_;
+
   // Minimum RTT estimate.  Automatically expires within 10 seconds (and
   // triggers PROBE_RTT mode) if no new value is sampled during that period.
   QuicTime::Delta min_rtt_;
   // The time at which the current value of |min_rtt_| was assigned.
   QuicTime min_rtt_timestamp_;
 
   // The maximum allowed number of bytes in flight.
   QuicByteCount congestion_window_;
 
   // The initial value of the |congestion_window_|.
@@ skipping 59 matching lines @@
 
 QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                              const BbrSender::Mode& mode);
 QUIC_EXPORT_PRIVATE std::ostream& operator<<(
     std::ostream& os,
     const BbrSender::DebugState& state);
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_CONGESTION_CONTROL_BBR_SENDER_H_