| // Copyright 2015 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. | |
| #ifndef QUICHE_QUIC_CORE_CONGESTION_CONTROL_GENERAL_LOSS_ALGORITHM_H_ | |
| #define QUICHE_QUIC_CORE_CONGESTION_CONTROL_GENERAL_LOSS_ALGORITHM_H_ | |
| #include <algorithm> | |
| #include <map> | |
| #include "quiche/quic/core/congestion_control/loss_detection_interface.h" | |
| #include "quiche/quic/core/quic_packets.h" | |
| #include "quiche/quic/core/quic_time.h" | |
| #include "quiche/quic/core/quic_types.h" | |
| #include "quiche/quic/core/quic_unacked_packet_map.h" | |
| #include "quiche/quic/platform/api/quic_export.h" | |
| namespace quic { | |
| // Class which can be configured to implement's TCP's approach of detecting loss | |
| // when 3 nacks have been received for a packet or with a time threshold. | |
| // Also implements TCP's early retransmit(RFC5827). | |
| class QUIC_EXPORT_PRIVATE GeneralLossAlgorithm : public LossDetectionInterface { | |
| public: | |
| GeneralLossAlgorithm() = default; | |
| GeneralLossAlgorithm(const GeneralLossAlgorithm&) = delete; | |
| GeneralLossAlgorithm& operator=(const GeneralLossAlgorithm&) = delete; | |
| ~GeneralLossAlgorithm() override {} | |
| void SetFromConfig(const QuicConfig& /*config*/, | |
| Perspective /*perspective*/) override {} | |
| // Uses |largest_acked| and time to decide when packets are lost. | |
| DetectionStats DetectLosses(const QuicUnackedPacketMap& unacked_packets, | |
| QuicTime time, const RttStats& rtt_stats, | |
| QuicPacketNumber largest_newly_acked, | |
| const AckedPacketVector& packets_acked, | |
| LostPacketVector* packets_lost) override; | |
| // Returns a non-zero value when the early retransmit timer is active. | |
| QuicTime GetLossTimeout() const override; | |
| // Called to increases time and/or packet threshold. | |
| void SpuriousLossDetected(const QuicUnackedPacketMap& unacked_packets, | |
| const RttStats& rtt_stats, | |
| QuicTime ack_receive_time, | |
| QuicPacketNumber packet_number, | |
| QuicPacketNumber previous_largest_acked) override; | |
| void OnConfigNegotiated() override { | |
| QUICHE_DCHECK(false) | |
| << "Unexpected call to GeneralLossAlgorithm::OnConfigNegotiated"; | |
| } | |
| void OnMinRttAvailable() override { | |
| QUICHE_DCHECK(false) | |
| << "Unexpected call to GeneralLossAlgorithm::OnMinRttAvailable"; | |
| } | |
| void OnUserAgentIdKnown() override { | |
| QUICHE_DCHECK(false) | |
| << "Unexpected call to GeneralLossAlgorithm::OnUserAgentIdKnown"; | |
| } | |
| void OnConnectionClosed() override { | |
| QUICHE_DCHECK(false) | |
| << "Unexpected call to GeneralLossAlgorithm::OnConnectionClosed"; | |
| } | |
| void OnReorderingDetected() override { | |
| QUICHE_DCHECK(false) | |
| << "Unexpected call to GeneralLossAlgorithm::OnReorderingDetected"; | |
| } | |
| void Initialize(PacketNumberSpace packet_number_space, | |
| LossDetectionInterface* parent); | |
| void Reset(); | |
| QuicPacketCount reordering_threshold() const { return reordering_threshold_; } | |
| int reordering_shift() const { return reordering_shift_; } | |
| void set_reordering_shift(int reordering_shift) { | |
| reordering_shift_ = reordering_shift; | |
| } | |
| void set_reordering_threshold(QuicPacketCount reordering_threshold) { | |
| reordering_threshold_ = reordering_threshold; | |
| } | |
| bool use_adaptive_reordering_threshold() const { | |
| return use_adaptive_reordering_threshold_; | |
| } | |
| void set_use_adaptive_reordering_threshold(bool value) { | |
| use_adaptive_reordering_threshold_ = value; | |
| } | |
| bool use_adaptive_time_threshold() const { | |
| return use_adaptive_time_threshold_; | |
| } | |
| void enable_adaptive_time_threshold() { use_adaptive_time_threshold_ = true; } | |
| bool use_packet_threshold_for_runt_packets() const { | |
| return use_packet_threshold_for_runt_packets_; | |
| } | |
| void disable_packet_threshold_for_runt_packets() { | |
| use_packet_threshold_for_runt_packets_ = false; | |
| } | |
| private: | |
| LossDetectionInterface* parent_ = nullptr; | |
| QuicTime loss_detection_timeout_ = QuicTime::Zero(); | |
| // Fraction of a max(SRTT, latest_rtt) to permit reordering before declaring | |
| // loss. Fraction calculated by shifting max(SRTT, latest_rtt) to the right | |
| // by reordering_shift. | |
| int reordering_shift_ = kDefaultLossDelayShift; | |
| // Reordering threshold for loss detection. | |
| QuicPacketCount reordering_threshold_ = kDefaultPacketReorderingThreshold; | |
| // If true, uses adaptive reordering threshold for loss detection. | |
| bool use_adaptive_reordering_threshold_ = true; | |
| // If true, uses adaptive time threshold for time based loss detection. | |
| bool use_adaptive_time_threshold_ = false; | |
| // If true, uses packet threshold when largest acked is a runt packet. | |
| bool use_packet_threshold_for_runt_packets_ = true; | |
| // The least in flight packet. Loss detection should start from this. Please | |
| // note, least_in_flight_ could be largest packet ever sent + 1. | |
| QuicPacketNumber least_in_flight_{1}; | |
| PacketNumberSpace packet_number_space_ = NUM_PACKET_NUMBER_SPACES; | |
| }; | |
| } // namespace quic | |
| #endif // QUICHE_QUIC_CORE_CONGESTION_CONTROL_GENERAL_LOSS_ALGORITHM_H_ |