loss_detector.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "ecn_tracker.h"
#include "frame_types.h"
#include "keys.h"
#include "rtt_estimator.h"
 
#include <chrono>
#include <cstdint>
#include <map>
#include <optional>
#include <vector>
 
namespace kcenon::network::protocols::quic
{
 
struct sent_packet
{
    uint64_t packet_number{0};
 
    std::chrono::steady_clock::time_point sent_time;
 
    size_t sent_bytes{0};
 
    bool ack_eliciting{false};
 
    bool in_flight{false};
 
    encryption_level level{encryption_level::initial};
 
    std::vector<frame> frames;
};
 
enum class loss_detection_event
{
    none,           
    packet_lost,    
    pto_expired,    
};
 
struct loss_detection_result
{
    loss_detection_event event{loss_detection_event::none};
 
    std::vector<sent_packet> acked_packets;
 
    std::vector<sent_packet> lost_packets;
 
    ecn_result ecn_signal{ecn_result::none};
 
    std::chrono::steady_clock::time_point ecn_congestion_sent_time{};
};
 
class loss_detector
{
public:
    explicit loss_detector(rtt_estimator& rtt);
 
    auto on_packet_sent(const sent_packet& packet) -> void;
 
    [[nodiscard]] auto on_ack_received(const ack_frame& ack,
                                       encryption_level level,
                                       std::chrono::steady_clock::time_point recv_time)
        -> loss_detection_result;
 
    [[nodiscard]] auto next_timeout() const
        -> std::optional<std::chrono::steady_clock::time_point>;
 
    [[nodiscard]] auto on_timeout() -> loss_detection_result;
 
    [[nodiscard]] auto largest_acked(encryption_level level) const noexcept -> uint64_t;
 
    [[nodiscard]] auto pto_count() const noexcept -> uint32_t
    {
        return pto_count_;
    }
 
    auto reset_pto_count() noexcept -> void
    {
        pto_count_ = 0;
    }
 
    [[nodiscard]] auto has_unacked_packets(encryption_level level) const -> bool;
 
    [[nodiscard]] auto bytes_in_flight(encryption_level level) const -> size_t;
 
    [[nodiscard]] auto total_bytes_in_flight() const -> size_t;
 
    auto discard_space(encryption_level level) -> void;
 
    auto set_handshake_confirmed(bool confirmed) noexcept -> void
    {
        handshake_confirmed_ = confirmed;
    }
 
    [[nodiscard]] auto get_ecn_tracker() noexcept -> class ecn_tracker&
    {
        return ecn_tracker_;
    }
 
    [[nodiscard]] auto get_ecn_tracker() const noexcept -> const class ecn_tracker&
    {
        return ecn_tracker_;
    }
 
private:
    struct space_state
    {
        uint64_t largest_acked{0};
 
        bool largest_acked_set{false};
 
        std::chrono::steady_clock::time_point time_of_last_ack_eliciting;
 
        std::map<uint64_t, sent_packet> sent_packets;
 
        std::chrono::steady_clock::time_point loss_time;
 
        size_t bytes_in_flight{0};
    };
 
    [[nodiscard]] auto space_index(encryption_level level) const noexcept -> size_t;
 
    [[nodiscard]] auto detect_lost_packets(encryption_level level,
                                            std::chrono::steady_clock::time_point now)
        -> std::vector<sent_packet>;
 
    auto set_loss_detection_timer() -> void;
 
    [[nodiscard]] auto get_loss_time_and_space() const
        -> std::pair<std::chrono::steady_clock::time_point, encryption_level>;
 
    [[nodiscard]] auto get_pto_time_and_space() const
        -> std::pair<std::chrono::steady_clock::time_point, encryption_level>;
 
    rtt_estimator& rtt_;
 
    class ecn_tracker ecn_tracker_;
 
    std::array<space_state, 3> spaces_;
 
    uint32_t pto_count_{0};
 
    bool handshake_confirmed_{false};
 
    std::chrono::steady_clock::time_point loss_detection_timer_;
 
    bool timer_armed_{false};
 
    static constexpr uint32_t kPacketThreshold = 3;
 
    static constexpr double kTimeThreshold = 9.0 / 8.0;  // 1.125
 
    static constexpr auto kGranularity = std::chrono::milliseconds{1};
};
 
} // namespace kcenon::network::protocols::quic