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 EnableECT0()98 bool EnableECT0() override { return false; } EnableECT1()99 bool EnableECT1() 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 GetNetworkModel()142 const Bbr2NetworkModel& GetNetworkModel() const { return model_; } 143 144 private: 145 void UpdatePacingRate(QuicByteCount bytes_acked); 146 void UpdateCongestionWindow(QuicByteCount bytes_acked); 147 QuicByteCount GetTargetCongestionWindow(float gain) const; 148 void OnEnterQuiescence(QuicTime now); 149 void OnExitQuiescence(QuicTime now); 150 151 // Helper function for BBR2_MODE_DISPATCH. probe_rtt_or_die()152 Bbr2ProbeRttMode& probe_rtt_or_die() { 153 QUICHE_DCHECK_EQ(mode_, Bbr2Mode::PROBE_RTT); 154 return probe_rtt_; 155 } 156 probe_rtt_or_die()157 const Bbr2ProbeRttMode& probe_rtt_or_die() const { 158 QUICHE_DCHECK_EQ(mode_, Bbr2Mode::PROBE_RTT); 159 return probe_rtt_; 160 } 161 RandomUint64(uint64_t max)162 uint64_t RandomUint64(uint64_t max) const { 163 return random_->RandUint64() % max; 164 } 165 166 // Cwnd limits imposed by the current Bbr2 mode. 167 Limits<QuicByteCount> GetCwndLimitsByMode() const; 168 169 // Cwnd limits imposed by caller. 170 const Limits<QuicByteCount>& cwnd_limits() const; 171 params()172 const Bbr2Params& params() const { return params_; } 173 174 Bbr2Mode mode_; 175 176 const RttStats* const rtt_stats_; 177 const QuicUnackedPacketMap* const unacked_packets_; 178 QuicRandom* random_; 179 QuicConnectionStats* connection_stats_; 180 181 // Don't use it directly outside of SetFromConfig and ApplyConnectionOptions. 182 // Instead, use params() to get read-only access. 183 Bbr2Params params_; 184 185 // Max congestion window when adjusting network parameters. 186 QuicByteCount max_cwnd_when_network_parameters_adjusted_ = 187 kMaxInitialCongestionWindow * kDefaultTCPMSS; 188 189 Bbr2NetworkModel model_; 190 191 const QuicByteCount initial_cwnd_; 192 193 // Current cwnd and pacing rate. 194 QuicByteCount cwnd_; 195 QuicBandwidth pacing_rate_; 196 197 QuicTime last_quiescence_start_ = QuicTime::Zero(); 198 199 Bbr2StartupMode startup_; 200 Bbr2DrainMode drain_; 201 Bbr2ProbeBwMode probe_bw_; 202 Bbr2ProbeRttMode probe_rtt_; 203 204 bool has_non_app_limited_sample_ = false; 205 206 // Debug only. 207 bool last_sample_is_app_limited_; 208 209 friend class Bbr2StartupMode; 210 friend class Bbr2DrainMode; 211 friend class Bbr2ProbeBwMode; 212 friend class Bbr2ProbeRttMode; 213 }; 214 215 QUICHE_EXPORT std::ostream& operator<<(std::ostream& os, 216 const Bbr2Sender::DebugState& state); 217 218 } // namespace quic 219 220 #endif // QUICHE_QUIC_CORE_CONGESTION_CONTROL_BBR2_SENDER_H_ 221