congestion_controller.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 "loss_detector.h"
#include "rtt_estimator.h"
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <limits>
 
namespace kcenon::network::protocols::quic
{
 
enum class congestion_state
{
    slow_start,           
    congestion_avoidance, 
    recovery,             
};
 
[[nodiscard]] auto congestion_state_to_string(congestion_state state) noexcept
    -> const char*;
 
class congestion_controller
{
public:
    congestion_controller();
 
    explicit congestion_controller(size_t max_datagram_size);
 
    [[nodiscard]] auto can_send(size_t bytes = 0) const noexcept -> bool;
 
    [[nodiscard]] auto available_window() const noexcept -> size_t;
 
    auto on_packet_sent(size_t bytes) -> void;
 
    auto on_packet_acked(const sent_packet& packet,
                         std::chrono::steady_clock::time_point ack_time) -> void;
 
    auto on_packet_lost(const sent_packet& packet) -> void;
 
    auto on_congestion_event(std::chrono::steady_clock::time_point sent_time) -> void;
 
    auto on_ecn_congestion(std::chrono::steady_clock::time_point sent_time) -> void;
 
    auto on_persistent_congestion(const rtt_estimator& rtt) -> void;
 
    [[nodiscard]] auto cwnd() const noexcept -> size_t
    {
        return cwnd_;
    }
 
    [[nodiscard]] auto ssthresh() const noexcept -> size_t
    {
        return ssthresh_;
    }
 
    [[nodiscard]] auto bytes_in_flight() const noexcept -> size_t
    {
        return bytes_in_flight_;
    }
 
    [[nodiscard]] auto state() const noexcept -> congestion_state
    {
        return state_;
    }
 
    [[nodiscard]] auto max_datagram_size() const noexcept -> size_t
    {
        return max_datagram_size_;
    }
 
    auto set_max_datagram_size(size_t size) -> void;
 
    auto reset() -> void;
 
private:
    [[nodiscard]] auto is_in_recovery(
        std::chrono::steady_clock::time_point sent_time) const noexcept -> bool;
 
    congestion_state state_{congestion_state::slow_start};
 
    size_t cwnd_;
 
    size_t ssthresh_{std::numeric_limits<size_t>::max()};
 
    size_t bytes_in_flight_{0};
 
    size_t max_datagram_size_;
 
    std::chrono::steady_clock::time_point congestion_recovery_start_;
 
    size_t initial_window_;
 
    size_t minimum_window_;
 
    static constexpr double kLossReductionFactor = 0.5;
 
    static constexpr size_t kDefaultMaxDatagramSize = 1200;
 
    static constexpr size_t kInitialWindowPackets = 10;
 
    static constexpr size_t kMinimumWindowPackets = 2;
};
 
} // namespace kcenon::network::protocols::quic