Increases inflight limit for QUIC BBR if the ack rate in the past half-rtt was lower than half the…

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 101 matching lines @@
                          const CongestionVector& acked_packets,
                          const CongestionVector& lost_packets) override;
   bool OnPacketSent(QuicTime sent_time,
                     QuicByteCount bytes_in_flight,
                     QuicPacketNumber packet_number,
                     QuicByteCount bytes,
                     HasRetransmittableData is_retransmittable) override;
   void OnRetransmissionTimeout(bool packets_retransmitted) override {}
   void OnConnectionMigration() override {}
   QuicTime::Delta TimeUntilSend(QuicTime now,
-                                QuicByteCount bytes_in_flight) const override;
+                                QuicByteCount bytes_in_flight) override;
   QuicBandwidth PacingRate(QuicByteCount bytes_in_flight) const override;
   QuicBandwidth BandwidthEstimate() const override;
   QuicByteCount GetCongestionWindow() const override;
   QuicByteCount GetSlowStartThreshold() const override;
   CongestionControlType GetCongestionControlType() const override;
   std::string GetDebugState() const override;
   void OnApplicationLimited(QuicByteCount bytes_in_flight) override;
   // End implementation of SendAlgorithmInterface.
 
   // Gets the number of RTTs BBR remains in STARTUP phase.
@@ skipping 56 matching lines @@
   // 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);
 
+  // Returns true if recent ack rate has decreased substantially and if sender
+  // is allowed to continue sending when congestion window limited.
+  bool SlowDeliveryAllowsSending(QuicTime now, QuicByteCount bytes_in_flight);
+
+  // Updates history of recently received acks. Acks are considered recent
+  // if received within kRecentlyAckedRttFraction x smoothed RTT in the past.
+  // Adds new ack to recently_acked_ if |newly_acked_bytes| is non-zero.
+  void UpdateRecentlyAcked(QuicTime new_ack_time,
+                           QuicByteCount newly_acked_bytes);
+
   // 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.
@@ skipping 54 matching lines @@
 
   // The gain used for the congestion window during PROBE_BW.  Latched from
   // quic_bbr_cwnd_gain flag.
   const float congestion_window_gain_constant_;
   // The coefficient by which mean RTT variance is added to the congestion
   // window.  Latched from quic_bbr_rtt_variation_weight flag.
   const float rtt_variance_weight_;
   // The number of RTTs to stay in STARTUP mode.  Defaults to 3.
   QuicRoundTripCount num_startup_rtts_;
 
+  // Gain to use when delivery rate is slow.
+  // TODO(jri): Make this a constant if we decide to use this code for BBR.
+  const float congestion_window_gain_for_slow_delivery_;
+  // Threshold multiplier below which delivery is considered slow.
+  // TODO(jri): Make this a constant if we decide to use this code for BBR.
+  const float threshold_multiplier_for_slow_delivery_;
+
   // Number of round-trips in PROBE_BW mode, used for determining the current
   // pacing gain cycle.
   int cycle_current_offset_;
   // The time at which the last pacing gain cycle was started.
   QuicTime last_cycle_start_;
 
   // Indicates whether the connection has reached the full bandwidth mode.
   bool is_at_full_bandwidth_;
   // Number of rounds during which there was no significant bandwidth increase.
   QuicRoundTripCount rounds_without_bandwidth_gain_;
@@ skipping 15 matching lines @@
   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_;
 
+  // Records information about a received ack
+  struct DataDelivered {
+    QuicTime ack_time;
+    QuicByteCount acked_bytes;
+  };
+
+  // Data structure to record recently received acks. Used for determining
+  // recently seen ack rate over a short period in the past.
+  std::deque<DataDelivered> recently_acked_;
+  QuicByteCount bytes_recently_acked_;
+
   DISALLOW_COPY_AND_ASSIGN(BbrSender);
 };
 
 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_