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

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 33 matching lines @@
     // After achieving the highest possible bandwidth during the startup, lower
     // the pacing rate in order to drain the queue.
     DRAIN,
     // Cruising mode.
     PROBE_BW,
     // Temporarily slow down sending in order to empty the buffer and measure
     // the real minimum RTT.
     PROBE_RTT,
   };
 
+  // Indicates how the congestion control limits the amount of bytes in flight.
+  enum RecoveryState {
+    // Do not limit.
+    NOT_IN_RECOVERY,
+    // Allow an extra outstanding byte for each byte acknowledged.
+    CONSERVATION,
+    // Allow two extra outstanding bytes for each byte acknowledged (slow
+    // start).
+    GROWTH
+  };
+
   // Debug state can be exported in order to troubleshoot potential congestion
   // control issues.
   struct DebugState {
     explicit DebugState(const BbrSender& sender);
     DebugState(const DebugState& state);
 
     Mode mode;
     QuicBandwidth max_bandwidth;
     QuicRoundTripCount round_trip_count;
     int gain_cycle_index;
     QuicByteCount congestion_window;
 
     bool is_at_full_bandwidth;
     QuicBandwidth bandwidth_at_last_round;
     QuicRoundTripCount rounds_without_bandwidth_gain;
 
     QuicTime::Delta min_rtt;
     QuicTime min_rtt_timestamp;
 
+    RecoveryState recovery_state;
+    QuicByteCount recovery_window;
+
     bool last_sample_is_app_limited;
   };
 
   BbrSender(const QuicClock* clock,
             const RttStats* rtt_stats,
             const QuicUnackedPacketMap* unacked_packets,
             QuicPacketCount initial_tcp_congestion_window,
             QuicPacketCount max_tcp_congestion_window,
             QuicRandom* random);
   ~BbrSender() override;
@@ skipping 70 matching lines @@
   // Tracks for how many round-trips the bandwidth has not increased
   // significantly.
   void CheckIfFullBandwidthReached();
   // Transitions from STARTUP to DRAIN and from DRAIN to PROBE_BW if
   // appropriate.
   void MaybeExitStartupOrDrain(QuicTime now);
   // Decides whether to enter or exit PROBE_RTT.
   void MaybeEnterOrExitProbeRtt(QuicTime now,
                                 bool is_round_start,
                                 bool min_rtt_expired);
+  // Determines whether BBR needs to enter, exit or advance state of the
+  // recovery.
+  void UpdateRecoveryState(QuicPacketNumber last_acked_packet,
+                           bool has_losses,
+                           bool is_round_start);
 
   // 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 QuicClock* clock_;
   const RttStats* rtt_stats_;
   const QuicUnackedPacketMap* unacked_packets_;
   QuicRandom* random_;
 
   Mode mode_;
 
   // Bandwidth sampler provides BBR with the bandwidth measurements at
   // individual points.
@@ skipping 55 matching lines @@
   // that the time is yet unknown as the number of packets in flight has not
   // reached the required value.
   QuicTime exit_probe_rtt_at_;
   // Indicates whether a round-trip has passed since PROBE_RTT became active.
   bool probe_rtt_round_passed_;
 
   // Indicates whether the most recent bandwidth sample was marked as
   // app-limited.
   bool last_sample_is_app_limited_;
 
+  // Current state of recovery.
+  RecoveryState recovery_state_;
+  // Receiving acknowledgement of a packet after |end_recovery_at_| will cause
+  // BBR to exit the recovery mode.
+  QuicPacketNumber end_recovery_at_;
+  // A window used to limit the number of bytes in flight during loss recovery.
+  QuicByteCount recovery_window_;
+
   DISALLOW_COPY_AND_ASSIGN(BbrSender);
 };
 
 NET_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                             const BbrSender::Mode& mode);
 NET_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                             const BbrSender::DebugState& state);
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_CONGESTION_CONTROL_BBR_SENDER_H_