moonbitstack/moonquic/recovery does not have a README file
Control
pub(open) trait Control {
fn window(Self) -> Int64
fn in_flight(Self) -> Int64
fn on_sent(Self, Int64) -> Unit
fn on_ack(Self, Int64) -> Unit
fn on_lost(Self, Int64) -> Unit
fn on_congestion(Self, at~ : Int64, now~ : Int64) -> Unit
fn on_persistent(Self) -> Unit
fn on_ack_at(Self, Int64, now~ : Int64) -> Unit = _
fn on_rtt(Self, sample~ : Int64, now~ : Int64) -> Unit = _
fn on_new_path(Self) -> Unit = _
fn pacing_rate(Self) -> Double? = _
}A congestion controller (RFC 9002 §7): how much may be in flight, and what to make of
each packet sent, acknowledged or lost.
NewReno is the one RFC 9002 specifies, and the reason this is a trait rather than that
struct is §7's own opening — an endpoint may use any controller, and Cubic and BBR
answer the same questions. Implementing this is all it takes; nothing here changes.
Bbr
A BBR congestion controller, an implementation of Control.
An acknowledgement at a known time: out of flight, into the delivery-rate sample, and the
window recomputed from the model.
A congestion signal. BBR does not treat loss as its signal: it leaves the window the
model computes alone, and a loss in startup only ends startup early.
Persistent congestion is the one loss that resets the model: the path is not delivering,
so the window drops to the minimum and a fresh round-trip minimum is taken.
A round-trip sample: keep the smallest, and note when it was taken so probe-RTT knows how
long the path has gone without a fresher one.
What BBR would pace at: the bottleneck rate times the mode's gain, which is the rate the
model has decided the path can carry. The window gain is a different number on purpose —
pacing says how fast to send, the window says how much may be outstanding. Nothing is
offered before the first delivery-rate sample, so the connection is unpaced until it knows
something (RFC 9002 §7.7).
Bbr::bandwidth
The maximum delivery rate seen, in bytes per microsecond.
Bbr::bdp
The bandwidth-delay product in bytes: how much the path can hold in flight at once at the
best rate and the smallest round trip seen.
Bbr::min_rtt
The smallest round trip seen, in microseconds.
Bbr::minimum
The smallest window the controller will set (RFC 9002 §7.2).
Bbr::new
A fresh BBR controller at RFC 9002 §7.2's initial window, in startup.
Bbr::on_new_path
The defaulted methods of Control this controller inherits, named so the promotion to
methods on Bbr is explicit rather than implied by the impl.
Bbr::target
The window the model asks for: the bandwidth-delay product times the mode's window gain,
three datagrams of headroom, floored at the minimum. A loss leaves it unchanged, which is
what tells BBR from NewReno. While the round trip is being sampled the window is held at
four datagrams whatever the model says, so the queue the last cycle built can drain.
Cubic
pub struct Cubic {
window : Int64
ssthresh : Int64
in_flight : Int64
recovery : Int64
w_max : Int64
epoch : Int64
k : Double
rtt : Int64
policy : Policy
}A CUBIC congestion controller (RFC 9438), an implementation of Control.
Without a clock this can only take the bytes out of flight; the growth on an
acknowledgement comes through on_ack_at, which has the time.
A congestion signal (RFC 9438 §4.6): W_max remembers the window it fell from, the window
drops to β of it (with fast convergence when it was already below the last W_max), a new
epoch starts, and K is recomputed as the time it takes the cubic to climb back.
Persistent congestion collapses the window to the minimum and clears the recovery period,
as NewReno's does; the ssthresh left above it puts the next acknowledgement in slow start.
Cubic::minimum
The smallest window the controller will reduce to (RFC 9002 §7.2).
Cubic::new
A fresh CUBIC controller at RFC 9002 §7.2's initial window: the same start as NewReno,
since how a controller begins is not what makes it CUBIC.
Cubic::on_new_path
The defaulted methods of Control this controller inherits, named so the promotion to
methods on Cubic is explicit rather than implied by the impl.
Cubic::recovering
Whether a packet sent at at falls inside the recovery period already under way.
Cubic::target
The window the cubic and the Reno-friendly estimate ask for at now, in bytes — the
larger of the two (RFC 9438 §4.2, §4.3). A test reproduces this arithmetic itself so a
change to the curve is visible as a changed window.
Flight
What is outstanding in one packet-number space, and the largest number acknowledged so
far — -1 before any ACK has arrived.
Flight::largest_acked
The largest packet number acknowledged, or -1 before any ACK.
Flight::lost
Declare lost every outstanding packet that either sits at least packets behind the
largest acknowledged (RFC 9002 §6.1.1) or was sent longer than time ago while a later
packet has been acknowledged (§6.1.2), and stop tracking them.
The records come back whole, sizes included, because the congestion controller has to
take those bytes out of flight and only the caller knows which controller that is.
Flight::on_ack
Process an ACK's acknowledged ranges: drop every outstanding packet that falls in one,
advance the largest acknowledged, and answer with the bytes taken out of flight.
Flight::on_sent
Record that an ack-eliciting packet went out.
Flight::outstanding
The packet numbers still outstanding.
Mode
NewReno
pub struct NewReno {
window : Int64
ssthresh : Int64
in_flight : Int64
recovery : Int64
policy : Policy
}NewReno, the controller RFC 9002 §7 specifies.
Acknowledgement (RFC 9002 §7.3.1–§7.3.2): out of flight, then grow — by every
acknowledged byte below the threshold, and by one datagram per window above it.
A congestion signal (RFC 9002 §7.3.2): the window falls to the reduction factor of
itself, floored at the minimum, and a recovery period begins. A signal from a packet
sent inside the period already under way is ignored, so one round of loss costs one
halving rather than one per packet.
Persistent congestion (RFC 9002 §7.6): the window collapses to the minimum and slow
start begins again, because nothing got through for longer than a congestion period.
NewReno::minimum
The smallest window the controller will reduce to (RFC 9002 §7.2).
NewReno::new
A fresh controller (RFC 9002 §7.2): the initial window is
min(10·datagram, max(2·datagram, 14720)), the slow-start threshold is unbounded, and
nothing is in flight or in recovery.
NewReno::on_ack_at
The defaulted methods of Control this controller inherits, named so the promotion to
methods on NewReno is explicit rather than implied by the impl.
NewReno::on_congestion
NewReno::on_new_path
The defaulted methods of Control this controller inherits, named so the promotion to
methods on NewReno is explicit rather than implied by the impl.
NewReno::on_rtt
The defaulted methods of Control this controller inherits, named so the promotion to
methods on NewReno is explicit rather than implied by the impl.
NewReno::recovering
Whether a packet sent at at falls inside the recovery period already under way.
NewReno::ssthresh
The slow-start threshold in bytes.
Pacer
pub struct Pacer {
// private fields
}A token bucket over bytes, at a rate in bytes per microsecond. A rate of zero means the
connection is not paced and everything is allowed.
Pacer::allow
Whether bytes may go at now. Unpaced, always.
Pacer::new
A pacer that lets everything through until a rate is set.
Pacer::next_at
When bytes will have accrued, or None when it already has or nothing is paced. A driver
arms a timer on this and comes back for the packet.
Pacer::rate
The rate in bytes per microsecond; zero when unpaced.
Pacer::set_rate
Set the rate, in bytes per microsecond. Zero turns pacing off. The bucket starts full, so
the first burst after a quiet period is not delayed.
Policy
pub(all) struct Policy {
packets : Int64
time : Double
granularity : Int64
initial_rtt : Int64
persistent : Int64
reduction : Double
datagram : Int64
ack_delay : Int64
}The constants RFC 9002 leaves as tunables, and the two connection parameters the
timers are computed from. Every duration is microseconds and every size is bytes.
The presets are the values the RFC itself recommends (§6.1.1, §6.1.2, §6.2.2, §7.2,
§7.3, §7.6) together with RFC 9000 §18.2's default max_ack_delay and RFC 9000 §14's
minimum datagram size, which is the one every path is required to carry.
Policy::new
A policy by name, each part defaulting to RFC 9002's recommendation.
packets is kPacketThreshold, time kTimeThreshold, granularity kGranularity,
initial_rtt kInitialRtt, persistent kPersistentCongestionThreshold, reduction
kLossReductionFactor. datagram is the sender's maximum datagram size and
ack_delay the peer's advertised max_ack_delay, both of which a real connection
learns from its transport parameters rather than keeps at the default.
Rtt
pub struct Rtt {
latest : Int64
min : Int64
smoothed : Int64
variation : Int64
sampled : Bool
}An endpoint's round-trip estimate for one packet-number space (RFC 9002 §5).
Rtt::min
The smallest sample seen, which is the closest this endpoint has come to measuring the
path itself rather than the path plus the peer's delays.
Rtt::pto
The Probe Timeout: smoothed + max(4·variation, granularity) + ack_delay
(RFC 9002 §6.2.1), or twice the policy's initial RTT before the first sample
(§6.2.2).
Rtt::reset
Back to no sample, for a path nothing is known about.
Rtt::sample
Fold in a round-trip sample (RFC 9002 §5.3).
ack_delay is what the peer said it waited before acknowledging; it is capped at the
policy's ack_delay and subtracted only while doing so keeps the sample at or above
the minimum seen, so a peer cannot talk the estimate below the path's real latency.
The first sample seeds the estimate outright; later ones move the weighted average.
Rtt::sampled
Whether any sample has arrived. Before the first one the timers fall back to the
policy's initial RTT, which is the whole of what an endpoint knows at that point.
Rtt::smoothed
The smoothed estimate the timers are built on.
Rtt::threshold
The loss time threshold: max(time · max(smoothed, latest), granularity)
(RFC 9002 §6.1.2).
Sent
A sent, not yet acknowledged ack-eliciting packet (RFC 9002 §A.1): its number, when it
went out, and how many bytes it put in flight.
State
A sender's recovery state for one packet-number space: the round-trip estimate, what is
outstanding, and the congestion controller, driven by the two events a sender has —
a packet went out, an ACK came back.
State::can_send
Whether bytes more may go out without exceeding the congestion window.
State::new
A fresh state. Leave control out for NewReno under the same policy; give one to use
another controller.
State::on_ack
An ACK arrived (RFC 9002 §5–§7): sample the round trip off the largest newly
acknowledged packet, free the acknowledged bytes, then run loss detection over both
thresholds. Answers with the packet numbers declared lost — the frames to send again.
ack_delay is what the ACK frame said, in microseconds; the frame's own field is in
the peer's exponent and decoding it is the connection's job, not this one's.
One round of loss is one congestion signal however many packets it covers, and a round
spanning more than persistent probe timeouts is persistent congestion (§7.6).
State::on_new_path
The connection moved to a new path (RFC 9000 §9.4): the round trip and the window start over.
What is in flight stays tracked, since those packets can still be acknowledged.
State::on_pto
The probe timer fired (RFC 9002 §6.2.4): back off for the next arming. Sending the
probes is the caller's, because what to put in them is the connection's business.
State::on_sent
An ack-eliciting packet went out: track it for acknowledgement and charge the window.
State::outstanding
The packet numbers still outstanding.
State::pacing_rate
The rate to pace at, in bytes per microsecond (RFC 9002 §7.7): what the controller says when
it models the path, else the window over one and a quarter round trips, which is what keeps
a window from arriving as a burst.
State::pto
The probe timeout in microseconds, before backoff.
State::pto_count
How many probe timeouts have fired without an acknowledgement since the last one that
did — the backoff exponent.
State::pto_deadline
When the probe timer fires: the last ack-eliciting packet's send time plus the timeout
backed off by 2^pto_count (RFC 9002 §6.2.1). None when nothing is outstanding,
which is the timer disarmed.
can_send
Whether bytes more fit in the window.
Source Files
Install
Download zipQUIC transport for MoonBit.
quicquic-transporttransportudphttp3rfc9000rfc9001rfc9002rfc9221rfc9438congestion-controlnewrenocubicbbrloss-recoverydatagram0-rttearly-dataconnection-migrationpath-validationstateless-resetclienttls13retrymultipathpacingaddress-validationversion-negotiationpacket-recoveryprobe-timeoutstream-multiplexingrfc9369rfc9368quic-v2version-2moonbit
Apache-2.0
Updated 10 hours ago
4K downloads