QUIC congestion control (RFC 9002 Section 7) More...

#include <congestion_controller.h>

Collaboration diagram for kcenon::network::protocols::quic::congestion_controller:

Public Member Functions
	congestion_controller ()
	Default constructor.

	congestion_controller (size_t max_datagram_size)
	Constructor with custom max datagram size.

auto	can_send (size_t bytes=0) const noexcept -> bool
	Check if we can send more data.

auto	available_window () const noexcept -> size_t
	Get available congestion window.

auto	on_packet_sent (size_t bytes) -> void
	Record bytes sent.

auto	on_packet_acked (const sent_packet &packet, std::chrono::steady_clock::time_point ack_time) -> void
	Handle packet acknowledgment (RFC 9002 Section 7.3)

auto	on_packet_lost (const sent_packet &packet) -> void
	Handle packet loss (RFC 9002 Section 7.3.2)

auto	on_congestion_event (std::chrono::steady_clock::time_point sent_time) -> void
	Handle congestion event (RFC 9002 Section 7.3.2)

auto	on_ecn_congestion (std::chrono::steady_clock::time_point sent_time) -> void
	Handle ECN congestion signal (RFC 9002 Section 7.1)

auto	on_persistent_congestion (const rtt_estimator &rtt) -> void
	Handle persistent congestion detection (RFC 9002 Section 7.6)

auto	cwnd () const noexcept -> size_t
	Get current congestion window.

auto	ssthresh () const noexcept -> size_t
	Get slow start threshold.

auto	bytes_in_flight () const noexcept -> size_t
	Get bytes in flight.

auto	state () const noexcept -> congestion_state
	Get current congestion state.

auto	max_datagram_size () const noexcept -> size_t
	Get max datagram size.

auto	set_max_datagram_size (size_t size) -> void
	Set max datagram size.

auto	reset () -> void
	Reset congestion controller to initial state.

Private Member Functions
auto	is_in_recovery (std::chrono::steady_clock::time_point sent_time) const noexcept -> bool
	Check if currently in recovery period.

Private Attributes
congestion_state	state_ {congestion_state::slow_start}
	Current congestion state.

size_t	cwnd_
	Congestion window in bytes.

size_t	ssthresh_ {std::numeric_limits<size_t>::max()}
	Slow start threshold.

size_t	bytes_in_flight_ {0}
	Bytes currently in flight.

size_t	max_datagram_size_
	Maximum datagram size.

std::chrono::steady_clock::time_point	congestion_recovery_start_
	Start of the current congestion recovery period.

size_t	initial_window_
	Initial window size (for reset)

size_t	minimum_window_
	Minimum window size.

Static Private Attributes
static constexpr double	kLossReductionFactor = 0.5
	Loss reduction factor (RFC 9002 Section 7.3.2)

static constexpr size_t	kDefaultMaxDatagramSize = 1200
	Default max datagram size (QUIC minimum guaranteed MTU)

static constexpr size_t	kInitialWindowPackets = 10
	Number of datagrams for initial window.

static constexpr size_t	kMinimumWindowPackets = 2
	Minimum window in packets.

Detailed Description

QUIC congestion control (RFC 9002 Section 7)

Implements the NewReno congestion control algorithm as specified in RFC 9002. Manages the congestion window, slow start threshold, and bytes in flight.

Definition at line 42 of file congestion_controller.h.

Constructor & Destructor Documentation

◆ congestion_controller() [1/2]

kcenon::network::protocols::quic::congestion_controller::congestion_controller ( )

Default constructor.

Initializes with default parameters:

Initial window: 10 * max_datagram_size (14720 bytes for 1472 byte datagrams)
Minimum window: 2 * max_datagram_size
Max datagram size: 1200 bytes (QUIC minimum)

Definition at line 28 of file congestion_controller.cpp.

    : congestion_controller(kDefaultMaxDatagramSize)
{
}

◆ congestion_controller() [2/2]

kcenon::network::protocols::quic::congestion_controller::congestion_controller ( size_t max_datagram_size )

explicit

Constructor with custom max datagram size.

Parameters

max_datagram_size Maximum datagram size in bytes

Definition at line 33 of file congestion_controller.cpp.

    : state_(congestion_state::slow_start)
    , max_datagram_size_(max_datagram_size)
    , congestion_recovery_start_()
{
    initial_window_ = kInitialWindowPackets * max_datagram_size_;
    minimum_window_ = kMinimumWindowPackets * max_datagram_size_;
    cwnd_ = initial_window_;
}

References cwnd_, initial_window_, kInitialWindowPackets, kMinimumWindowPackets, max_datagram_size_, and minimum_window_.

Member Function Documentation

◆ available_window()

auto kcenon::network::protocols::quic::congestion_controller::available_window ( ) const -> size_t

nodiscardnoexcept

Get available congestion window.

Returns: Number of bytes that can be sent

Definition at line 52 of file congestion_controller.cpp.

{
    if (bytes_in_flight_ >= cwnd_)
    {
        return 0;
    }
    return cwnd_ - bytes_in_flight_;
}

References bytes_in_flight_, and cwnd_.

◆ bytes_in_flight()

auto kcenon::network::protocols::quic::congestion_controller::bytes_in_flight ( ) const -> size_t

inlinenodiscardnoexcept

Get bytes in flight.

Returns: Current bytes in flight

Definition at line 143 of file congestion_controller.h.

    {
        return bytes_in_flight_;
    }

References bytes_in_flight_.

◆ can_send()

auto kcenon::network::protocols::quic::congestion_controller::can_send ( size_t bytes = 0 ) const -> bool

nodiscardnoexcept

Check if we can send more data.

Parameters

bytes Number of bytes to send (default 0 means any)

Returns: True if there is available congestion window

Definition at line 43 of file congestion_controller.cpp.

{
    if (bytes == 0)
    {
        return bytes_in_flight_ < cwnd_;
    }
    return bytes_in_flight_ + bytes <= cwnd_;
}

◆ cwnd()

auto kcenon::network::protocols::quic::congestion_controller::cwnd ( ) const -> size_t

inlinenodiscardnoexcept

Get current congestion window.

Returns: Current congestion window in bytes

Definition at line 125 of file congestion_controller.h.

    {
        return cwnd_;
    }

References cwnd_.

◆ is_in_recovery()

auto kcenon::network::protocols::quic::congestion_controller::is_in_recovery ( std::chrono::steady_clock::time_point sent_time ) const -> bool

nodiscardprivatenoexcept

Check if currently in recovery period.

Returns: True if in recovery

Definition at line 181 of file congestion_controller.cpp.

{
    if (state_ != congestion_state::recovery)
    {
        return false;
    }
 
    // We're in recovery if the packet was sent before recovery started
    return sent_time <= congestion_recovery_start_;
}

References kcenon::network::protocols::quic::recovery.

◆ max_datagram_size()

auto kcenon::network::protocols::quic::congestion_controller::max_datagram_size ( ) const -> size_t

inlinenodiscardnoexcept

Get max datagram size.

Returns: Maximum datagram size

Definition at line 161 of file congestion_controller.h.

    {
        return max_datagram_size_;
    }

References max_datagram_size_.

◆ on_congestion_event()

auto kcenon::network::protocols::quic::congestion_controller::on_congestion_event ( std::chrono::steady_clock::time_point sent_time ) -> void

Handle congestion event (RFC 9002 Section 7.3.2)

Parameters

sent_time Time the packet was sent

Called when ECN or persistent congestion is detected.

Definition at line 125 of file congestion_controller.cpp.

{
    // Only respond to congestion once per RTT (RFC 9002 Section 7.3.2)
    if (is_in_recovery(sent_time))
    {
        return;
    }
 
    // Enter recovery
    congestion_recovery_start_ = std::chrono::steady_clock::now();
    state_ = congestion_state::recovery;
 
    // Reduce cwnd and set ssthresh
    // ssthresh = cwnd * kLossReductionFactor
    // cwnd = max(ssthresh, minimum_window)
    ssthresh_ = static_cast<size_t>(
        static_cast<double>(cwnd_) * kLossReductionFactor);
    cwnd_ = std::max(ssthresh_, minimum_window_);
}

References kcenon::network::protocols::quic::recovery.

◆ on_ecn_congestion()

auto kcenon::network::protocols::quic::congestion_controller::on_ecn_congestion ( std::chrono::steady_clock::time_point sent_time ) -> void

Handle ECN congestion signal (RFC 9002 Section 7.1)

Parameters

sent_time Time the packet was sent that triggered the ECN-CE signal

Called when ECN-CE marks are detected in ACK_ECN frame. ECN congestion is treated similarly to packet loss but provides more responsive congestion detection without waiting for packet loss.

Only one congestion response is triggered per RTT to avoid over-reaction to multiple ECN-CE marks within the same round trip.

Definition at line 146 of file congestion_controller.cpp.

{
    // RFC 9002 Section 7.1: Processing ECN Information
    // ECN-CE marks indicate congestion without packet loss
    // Respond same as packet loss, but only once per RTT
 
    // Only respond to congestion once per RTT
    if (is_in_recovery(sent_time))
    {
        return;
    }
 
    // Enter recovery
    congestion_recovery_start_ = std::chrono::steady_clock::now();
    state_ = congestion_state::recovery;
 
    // Reduce cwnd and set ssthresh
    // RFC 9002 Section 7.1: "a sender that receives an ACK frame with
    // ECN feedback indicating the CE codepoint MUST enter congestion
    // avoidance"
    ssthresh_ = static_cast<size_t>(
        static_cast<double>(cwnd_) * kLossReductionFactor);
    cwnd_ = std::max(ssthresh_, minimum_window_);
}

References kcenon::network::protocols::quic::recovery.

Referenced by kcenon::network::protocols::quic::connection::handle_loss_detection_result().

Here is the caller graph for this function:

◆ on_packet_acked()

auto kcenon::network::protocols::quic::congestion_controller::on_packet_acked	(	const sent_packet &	packet,
		std::chrono::steady_clock::time_point	ack_time ) -> void

Handle packet acknowledgment (RFC 9002 Section 7.3)

Parameters

packet	Acknowledged packet information
ack_time	Time the ACK was received

Definition at line 66 of file congestion_controller.cpp.

{
    // Update bytes in flight
    if (packet.in_flight && bytes_in_flight_ >= packet.sent_bytes)
    {
        bytes_in_flight_ -= packet.sent_bytes;
    }
 
    // Don't increase cwnd in recovery
    if (is_in_recovery(packet.sent_time))
    {
        return;
    }
 
    // Exit recovery if we're receiving ACKs for packets sent after recovery started
    if (state_ == congestion_state::recovery)
    {
        state_ = congestion_state::congestion_avoidance;
    }
 
    // Congestion window increase (RFC 9002 Section 7.3.1)
    if (state_ == congestion_state::slow_start)
    {
        // Slow start: increase cwnd by the number of bytes acknowledged
        cwnd_ += packet.sent_bytes;
 
        // Check if we've exceeded slow start threshold
        if (cwnd_ >= ssthresh_)
        {
            state_ = congestion_state::congestion_avoidance;
        }
    }
    else
    {
        // Congestion avoidance: AIMD
        // cwnd += max_datagram_size * acked_bytes / cwnd
        auto increment = (max_datagram_size_ * packet.sent_bytes) / cwnd_;
        if (increment == 0)
        {
            increment = 1;  // Always increase by at least 1 byte
        }
        cwnd_ += increment;
    }
}

References kcenon::network::protocols::quic::congestion_avoidance, kcenon::network::protocols::quic::recovery, and kcenon::network::protocols::quic::slow_start.

Referenced by kcenon::network::protocols::quic::connection::handle_loss_detection_result().

Here is the caller graph for this function:

◆ on_packet_lost()

auto kcenon::network::protocols::quic::congestion_controller::on_packet_lost ( const sent_packet & packet ) -> void

Handle packet loss (RFC 9002 Section 7.3.2)

Parameters

packet Lost packet information

Definition at line 113 of file congestion_controller.cpp.

{
    // Update bytes in flight
    if (packet.in_flight && bytes_in_flight_ >= packet.sent_bytes)
    {
        bytes_in_flight_ -= packet.sent_bytes;
    }
 
    // Trigger congestion event
    on_congestion_event(packet.sent_time);
}

Referenced by kcenon::network::protocols::quic::connection::handle_loss_detection_result().

Here is the caller graph for this function:

◆ on_packet_sent()

auto kcenon::network::protocols::quic::congestion_controller::on_packet_sent ( size_t bytes ) -> void

Record bytes sent.

Parameters

bytes Number of bytes sent

Definition at line 61 of file congestion_controller.cpp.

{
    bytes_in_flight_ += bytes;
}

◆ on_persistent_congestion()

auto kcenon::network::protocols::quic::congestion_controller::on_persistent_congestion ( const rtt_estimator & rtt ) -> void

Handle persistent congestion detection (RFC 9002 Section 7.6)

Parameters

rtt	RTT estimator for PTO calculation

Definition at line 172 of file congestion_controller.cpp.

{
    // RFC 9002 Section 7.6: Reset cwnd to minimum
    cwnd_ = minimum_window_;
    ssthresh_ = cwnd_;
    state_ = congestion_state::slow_start;
    congestion_recovery_start_ = std::chrono::steady_clock::time_point{};
}

References kcenon::network::protocols::quic::slow_start.

◆ reset()

auto kcenon::network::protocols::quic::congestion_controller::reset ( ) -> void

Reset congestion controller to initial state.

Definition at line 203 of file congestion_controller.cpp.

{
    state_ = congestion_state::slow_start;
    cwnd_ = initial_window_;
    ssthresh_ = std::numeric_limits<size_t>::max();
    bytes_in_flight_ = 0;
    congestion_recovery_start_ = std::chrono::steady_clock::time_point{};
}

References kcenon::network::protocols::quic::slow_start.

◆ set_max_datagram_size()

auto kcenon::network::protocols::quic::congestion_controller::set_max_datagram_size ( size_t size ) -> void

Set max datagram size.

Parameters

size	New maximum datagram size

Definition at line 193 of file congestion_controller.cpp.

{
    max_datagram_size_ = size;
    initial_window_ = kInitialWindowPackets * max_datagram_size_;
    minimum_window_ = kMinimumWindowPackets * max_datagram_size_;
 
    // Ensure cwnd is at least minimum window
    cwnd_ = std::max(cwnd_, minimum_window_);
}

Referenced by kcenon::network::protocols::quic::connection::disable_pmtud(), and kcenon::network::protocols::quic::connection::enable_pmtud().

Here is the caller graph for this function:

◆ ssthresh()

auto kcenon::network::protocols::quic::congestion_controller::ssthresh ( ) const -> size_t

inlinenodiscardnoexcept

Get slow start threshold.

Returns: Current slow start threshold

Definition at line 134 of file congestion_controller.h.

    {
        return ssthresh_;
    }

References ssthresh_.

◆ state()

auto kcenon::network::protocols::quic::congestion_controller::state ( ) const -> congestion_state

inlinenodiscardnoexcept

Get current congestion state.

Returns: Current state

Definition at line 152 of file congestion_controller.h.

    {
        return state_;
    }

References state_.

Member Data Documentation

◆ bytes_in_flight_

size_t kcenon::network::protocols::quic::congestion_controller::bytes_in_flight_ {0}

private

Bytes currently in flight.

Definition at line 195 of file congestion_controller.h.

195{0};

Referenced by available_window(), and bytes_in_flight().

◆ congestion_recovery_start_

std::chrono::steady_clock::time_point kcenon::network::protocols::quic::congestion_controller::congestion_recovery_start_

private

Start of the current congestion recovery period.

Definition at line 201 of file congestion_controller.h.

◆ cwnd_

size_t kcenon::network::protocols::quic::congestion_controller::cwnd_

private

Congestion window in bytes.

Definition at line 189 of file congestion_controller.h.

Referenced by available_window(), congestion_controller(), and cwnd().

◆ initial_window_

size_t kcenon::network::protocols::quic::congestion_controller::initial_window_

private

Initial window size (for reset)

Definition at line 204 of file congestion_controller.h.

Referenced by congestion_controller().

◆ kDefaultMaxDatagramSize

size_t kcenon::network::protocols::quic::congestion_controller::kDefaultMaxDatagramSize = 1200

staticconstexprprivate

Default max datagram size (QUIC minimum guaranteed MTU)

Definition at line 213 of file congestion_controller.h.

◆ kInitialWindowPackets

size_t kcenon::network::protocols::quic::congestion_controller::kInitialWindowPackets = 10

staticconstexprprivate

Number of datagrams for initial window.

Definition at line 216 of file congestion_controller.h.

Referenced by congestion_controller().

◆ kLossReductionFactor

double kcenon::network::protocols::quic::congestion_controller::kLossReductionFactor = 0.5

staticconstexprprivate

Loss reduction factor (RFC 9002 Section 7.3.2)

Definition at line 210 of file congestion_controller.h.

◆ kMinimumWindowPackets

size_t kcenon::network::protocols::quic::congestion_controller::kMinimumWindowPackets = 2

staticconstexprprivate

Minimum window in packets.

Definition at line 219 of file congestion_controller.h.

Referenced by congestion_controller().

◆ max_datagram_size_

size_t kcenon::network::protocols::quic::congestion_controller::max_datagram_size_

private

Maximum datagram size.

Definition at line 198 of file congestion_controller.h.

Referenced by congestion_controller(), and max_datagram_size().

◆ minimum_window_

size_t kcenon::network::protocols::quic::congestion_controller::minimum_window_

private

Minimum window size.

Definition at line 207 of file congestion_controller.h.

Referenced by congestion_controller().

◆ ssthresh_

size_t kcenon::network::protocols::quic::congestion_controller::ssthresh_ {std::numeric_limits<size_t>::max()}

private

Slow start threshold.

Definition at line 192 of file congestion_controller.h.

192{std::numeric_limits<size_t>::max()};

Referenced by ssthresh().

◆ state_

congestion_state kcenon::network::protocols::quic::congestion_controller::state_ {congestion_state::slow_start}

private

Current congestion state.

Definition at line 186 of file congestion_controller.h.

186{congestion_state::slow_start};

Referenced by state().

The documentation for this class was generated from the following files:

src/internal/protocols/quic/congestion_controller.h
src/protocols/quic/congestion_controller.cpp

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ congestion_controller() [1/2]

◆ congestion_controller() [2/2]

Member Function Documentation

◆ available_window()

◆ bytes_in_flight()

◆ can_send()

◆ cwnd()

◆ is_in_recovery()

◆ max_datagram_size()

◆ on_congestion_event()

◆ on_ecn_congestion()

◆ on_packet_acked()

◆ on_packet_lost()

◆ on_packet_sent()

◆ on_persistent_congestion()

◆ reset()

◆ set_max_datagram_size()

◆ ssthresh()

◆ state()

Member Data Documentation

◆ bytes_in_flight_

◆ congestion_recovery_start_

◆ cwnd_

◆ initial_window_

◆ kDefaultMaxDatagramSize

◆ kInitialWindowPackets

◆ kLossReductionFactor

◆ kMinimumWindowPackets

◆ max_datagram_size_

◆ minimum_window_

◆ ssthresh_

◆ state_