1 // Copyright 2019 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef QUICHE_QUIC_CORE_CONGESTION_CONTROL_BBR2_SENDER_H_ 6 #define QUICHE_QUIC_CORE_CONGESTION_CONTROL_BBR2_SENDER_H_ 7 8 #include <cstdint> 9 10 #include "quiche/quic/core/congestion_control/bandwidth_sampler.h" 11 #include "quiche/quic/core/congestion_control/bbr2_drain.h" 12 #include "quiche/quic/core/congestion_control/bbr2_misc.h" 13 #include "quiche/quic/core/congestion_control/bbr2_probe_bw.h" 14 #include "quiche/quic/core/congestion_control/bbr2_probe_rtt.h" 15 #include "quiche/quic/core/congestion_control/bbr2_startup.h" 16 #include "quiche/quic/core/congestion_control/bbr_sender.h" 17 #include "quiche/quic/core/congestion_control/rtt_stats.h" 18 #include "quiche/quic/core/congestion_control/send_algorithm_interface.h" 19 #include "quiche/quic/core/congestion_control/windowed_filter.h" 20 #include "quiche/quic/core/quic_bandwidth.h" 21 #include "quiche/quic/core/quic_types.h" 22 #include "quiche/quic/platform/api/quic_export.h" 23 #include "quiche/quic/platform/api/quic_flags.h" 24 25 namespace quic { 26 27 class QUICHE_EXPORT Bbr2Sender final : public SendAlgorithmInterface { 28 public: 29 Bbr2Sender(QuicTime now, const RttStats* rtt_stats, 30 const QuicUnackedPacketMap* unacked_packets, 31 QuicPacketCount initial_cwnd_in_packets, 32 QuicPacketCount max_cwnd_in_packets, QuicRandom* random, 33 QuicConnectionStats* stats, BbrSender* old_sender); 34 35 ~Bbr2Sender() override = default; 36 37 // Start implementation of SendAlgorithmInterface. InSlowStart()38 bool InSlowStart() const override { return mode_ == Bbr2Mode::STARTUP; } 39 InRecovery()40 bool InRecovery() const override { 41 // TODO(wub): Implement Recovery. 42 return false; 43 } 44 45 void SetFromConfig(const QuicConfig& config, 46 Perspective perspective) override; 47 48 void ApplyConnectionOptions(const QuicTagVector& connection_options) override; 49 50 void AdjustNetworkParameters(const NetworkParams& params) override; 51 52 void SetInitialCongestionWindowInPackets( 53 QuicPacketCount congestion_window) override; 54 55 void OnCongestionEvent(bool rtt_updated, QuicByteCount prior_in_flight, 56 QuicTime event_time, 57 const AckedPacketVector& acked_packets, 58 const LostPacketVector& lost_packets, 59 QuicPacketCount num_ect, 60 QuicPacketCount num_ce) override; 61 62 void OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight, 63 QuicPacketNumber packet_number, QuicByteCount bytes, 64 HasRetransmittableData is_retransmittable) override; 65 66 void OnPacketNeutered(QuicPacketNumber packet_number) override; 67 OnRetransmissionTimeout(bool)68 void OnRetransmissionTimeout(bool /*packets_retransmitted*/) override {} 69 OnConnectionMigration()70 void OnConnectionMigration() override {} 71 72 bool CanSend(QuicByteCount bytes_in_flight) override; 73 74 QuicBandwidth PacingRate(QuicByteCount bytes_in_flight) const override; 75 BandwidthEstimate()76 QuicBandwidth BandwidthEstimate() const override { 77 return model_.BandwidthEstimate(); 78 } 79 HasGoodBandwidthEstimateForResumption()80 bool HasGoodBandwidthEstimateForResumption() const override { 81 return has_non_app_limited_sample_; 82 } 83 84 QuicByteCount GetCongestionWindow() const override; 85 GetSlowStartThreshold()86 QuicByteCount GetSlowStartThreshold() const override { return 0; } 87 GetCongestionControlType()88 CongestionControlType GetCongestionControlType() const override { 89 return kBBRv2; 90 } 91 92 std::string GetDebugState() const override; 93 94 void OnApplicationLimited(QuicByteCount bytes_in_flight) override; 95 96 void PopulateConnectionStats(QuicConnectionStats* stats) const override; 97 SupportsECT0()98 bool SupportsECT0() const override { return false; } SupportsECT1()99 bool SupportsECT1() const override { return false; } 100 // End implementation of SendAlgorithmInterface. 101 Params()102 const Bbr2Params& Params() const { return params_; } 103 GetMinimumCongestionWindow()104 QuicByteCount GetMinimumCongestionWindow() const { 105 return cwnd_limits().Min(); 106 } 107 108 // Returns the min of BDP and congestion window. 109 QuicByteCount GetTargetBytesInflight() const; 110 IsBandwidthOverestimateAvoidanceEnabled()111 bool IsBandwidthOverestimateAvoidanceEnabled() const { 112 return model_.IsBandwidthOverestimateAvoidanceEnabled(); 113 } 114 115 struct QUICHE_EXPORT DebugState { 116 Bbr2Mode mode; 117 118 // Shared states. 119 QuicRoundTripCount round_trip_count; 120 QuicBandwidth bandwidth_hi = QuicBandwidth::Zero(); 121 QuicBandwidth bandwidth_lo = QuicBandwidth::Zero(); 122 QuicBandwidth bandwidth_est = QuicBandwidth::Zero(); 123 QuicByteCount inflight_hi; 124 QuicByteCount inflight_lo; 125 QuicByteCount max_ack_height; 126 QuicTime::Delta min_rtt = QuicTime::Delta::Zero(); 127 QuicTime min_rtt_timestamp = QuicTime::Zero(); 128 QuicByteCount congestion_window; 129 QuicBandwidth pacing_rate = QuicBandwidth::Zero(); 130 bool last_sample_is_app_limited; 131 QuicPacketNumber end_of_app_limited_phase; 132 133 // Mode-specific debug states. 134 Bbr2StartupMode::DebugState startup; 135 Bbr2DrainMode::DebugState drain; 136 Bbr2ProbeBwMode::DebugState probe_bw; 137 Bbr2ProbeRttMode::DebugState probe_rtt; 138 }; 139 140 DebugState ExportDebugState() const; 141 142 private: 143 void UpdatePacingRate(QuicByteCount bytes_acked); 144 void UpdateCongestionWindow(QuicByteCount bytes_acked); 145 QuicByteCount GetTargetCongestionWindow(float gain) const; 146 void OnEnterQuiescence(QuicTime now); 147 void OnExitQuiescence(QuicTime now); 148 149 // Helper function for BBR2_MODE_DISPATCH. probe_rtt_or_die()150 Bbr2ProbeRttMode& probe_rtt_or_die() { 151 QUICHE_DCHECK_EQ(mode_, Bbr2Mode::PROBE_RTT); 152 return probe_rtt_; 153 } 154 probe_rtt_or_die()155 const Bbr2ProbeRttMode& probe_rtt_or_die() const { 156 QUICHE_DCHECK_EQ(mode_, Bbr2Mode::PROBE_RTT); 157 return probe_rtt_; 158 } 159 RandomUint64(uint64_t max)160 uint64_t RandomUint64(uint64_t max) const { 161 return random_->RandUint64() % max; 162 } 163 164 // Cwnd limits imposed by the current Bbr2 mode. 165 Limits<QuicByteCount> GetCwndLimitsByMode() const; 166 167 // Cwnd limits imposed by caller. 168 const Limits<QuicByteCount>& cwnd_limits() const; 169 params()170 const Bbr2Params& params() const { return params_; } 171 172 Bbr2Mode mode_; 173 174 const RttStats* const rtt_stats_; 175 const QuicUnackedPacketMap* const unacked_packets_; 176 QuicRandom* random_; 177 QuicConnectionStats* connection_stats_; 178 179 // Don't use it directly outside of SetFromConfig and ApplyConnectionOptions. 180 // Instead, use params() to get read-only access. 181 Bbr2Params params_; 182 183 // Max congestion window when adjusting network parameters. 184 QuicByteCount max_cwnd_when_network_parameters_adjusted_ = 185 kMaxInitialCongestionWindow * kDefaultTCPMSS; 186 187 Bbr2NetworkModel model_; 188 189 const QuicByteCount initial_cwnd_; 190 191 // Current cwnd and pacing rate. 192 QuicByteCount cwnd_; 193 QuicBandwidth pacing_rate_; 194 195 QuicTime last_quiescence_start_ = QuicTime::Zero(); 196 197 Bbr2StartupMode startup_; 198 Bbr2DrainMode drain_; 199 Bbr2ProbeBwMode probe_bw_; 200 Bbr2ProbeRttMode probe_rtt_; 201 202 bool has_non_app_limited_sample_ = false; 203 204 // Debug only. 205 bool last_sample_is_app_limited_; 206 207 friend class Bbr2StartupMode; 208 friend class Bbr2DrainMode; 209 friend class Bbr2ProbeBwMode; 210 friend class Bbr2ProbeRttMode; 211 }; 212 213 QUICHE_EXPORT std::ostream& operator<<(std::ostream& os, 214 const Bbr2Sender::DebugState& state); 215 216 } // namespace quic 217 218 #endif // QUICHE_QUIC_CORE_CONGESTION_CONTROL_BBR2_SENDER_H_ 219