ecn_tracker.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 "frame_types.h"
 
#include <chrono>
#include <cstdint>
 
namespace kcenon::network::protocols::quic
{
 
enum class ecn_result
{
    none,              
    congestion_signal, 
    ecn_failure,       
};
 
[[nodiscard]] auto ecn_result_to_string(ecn_result result) noexcept -> const char*;
 
enum class ecn_marking : uint8_t
{
    not_ect = 0x00, 
    ect1 = 0x01,    
    ect0 = 0x02,    
    ecn_ce = 0x03,  
};
 
class ecn_tracker
{
public:
    ecn_tracker();
 
    [[nodiscard]] auto process_ecn_counts(const ecn_counts& counts,
                                          uint64_t packets_acked,
                                          std::chrono::steady_clock::time_point sent_time)
        -> ecn_result;
 
    [[nodiscard]] auto is_ecn_capable() const noexcept -> bool
    {
        return state_.capable && !state_.testing;
    }
 
    [[nodiscard]] auto is_testing() const noexcept -> bool
    {
        return state_.testing;
    }
 
    [[nodiscard]] auto has_failed() const noexcept -> bool
    {
        return state_.failed;
    }
 
    [[nodiscard]] auto get_ecn_marking() const noexcept -> ecn_marking
    {
        if (state_.failed)
        {
            return ecn_marking::not_ect;
        }
        return ecn_marking::ect0;
    }
 
    auto on_packets_sent(uint64_t packet_count) noexcept -> void;
 
    [[nodiscard]] auto last_congestion_sent_time() const noexcept
        -> std::chrono::steady_clock::time_point
    {
        return state_.last_congestion_sent_time;
    }
 
    [[nodiscard]] auto current_counts() const noexcept -> const ecn_counts&
    {
        return state_.counts;
    }
 
    auto reset() noexcept -> void;
 
    auto disable() noexcept -> void;
 
private:
    struct validation_state
    {
        bool capable{false};
 
        bool testing{true};
 
        bool failed{false};
 
        ecn_counts counts{};
 
        uint64_t packets_sent_with_ect{0};
 
        std::chrono::steady_clock::time_point last_congestion_sent_time{};
 
        static constexpr uint64_t kValidationThreshold = 10;
    };
 
    [[nodiscard]] auto validate_ecn(const ecn_counts& counts,
                                    uint64_t packets_acked) -> bool;
 
    validation_state state_;
};
 
} // namespace kcenon::network::protocols::quic