Ljh684/moonnet-lab/src/tcp does not have a README file
CongestionControl
pub(open) trait CongestionControl {
fn window(Self) -> Int
fn ssthresh(Self) -> Int
fn name(Self) -> String
fn phase(Self) -> String
fn on_ack(Self, acked_bytes : Int, mss : Int, rtt_ps : Int64, now_ps : Int64) -> Unit
fn on_fast_retransmit(Self, flight_size : Int, mss : Int) -> Unit
fn on_duplicate_ack(Self, mss : Int) -> Unit
fn on_recovery_exit(Self, mss : Int) -> Unit
fn on_partial_ack(Self, mss : Int) -> Unit
fn on_timeout(Self, flight_size : Int, mss : Int) -> Unit
}How a connection decides how much data it may have in flight.
The connection owns the mechanics — sequence numbers, timers, retransmission —
and asks this object only for a window and tells it about events. That split
is what makes Reno, CUBIC and Vegas interchangeable: they differ in how they
react to the same four events, not in how the connection works.
flight_size is how many bytes are sent but not yet acknowledged when the
event happens. Losss-based algorithms need it because the amount to cut is a
fraction of what is actually outstanding, not a fraction of the window the
algorithm previously believed it had.
Cubic
pub struct Cubic {
mss : Int
cwnd : Int
ssthresh : Int
w_max : Int
cwnd_prior : Int
epoch_start : Int64
origin : Int
k_ps : Int64
w_est : Double
counter : Int
rtt_ps : Int64
in_recovery : Bool
fast_convergence : Bool
}CUBIC (RFC 9438).
Reno's window grows linearly with time, so its rate depends on the round trip
time: the same number of round trips buys the same number of segments, and a
path with a large bandwidth-delay product needs an impractical number of them
before it is full. CUBIC replaces the linear growth with a cubic function of
the time since the last congestion event:
W(t) = C * (t - K)^3 + W_maxW_max is the window at the previous loss and K is how long the curve takes
to climb back to it. Just after a loss the window is far below W_max, so the
curve is steep and the connection recovers quickly. As it approaches W_max
the curve flattens, so probing for more bandwidth becomes slow and careful.
That shape is the whole idea: be aggressive where the path has already proved
it can take the traffic, and cautious where it has not.
Everything inside this algorithm is measured in segments, because that is the
unit RFC 9438 is written in and the constant C has the unit segments per
second cubed. Bytes appear only at the boundary, where the connection asks
for a window.
Flags
The control bits a segment carries.
Flags::sequence_length
How many sequence numbers this segment consumes. SYN and FIN each occupy one
position in the sequence space even though they carry no payload; forgetting
that is the classic off-by-one that makes a handshake appear to work and the
first data segment appear to be missing one byte.
InFlight
type InFlightA segment that has been sent but not yet acknowledged.
The whole segment is kept, not just its sequence range, because a lost
segment has to be sent again and there is nowhere else to get the bytes from.
sequence_length differs from payload_length by one for a SYN or a FIN, so
acknowledgment accounting can report application bytes without the control
bits corrupting the totals.
LinkPair
pub(all) struct LinkPair {
client : TcpConnection
server : TcpConnection
up : Link[Segment]
down : Link[Segment]
}Two connections wired through a pair of one-way links.
The wiring is the interesting part. A connection cannot be handed a link at
construction time, because the link needs the other connection in its
delivery callback, and that connection does not exist yet. Instead each
connection starts with a no-op sender and is connected to its link
afterwards, which keeps the dependency a straight line rather than a cycle
and leaves the wiring visible in one place.
LinkPair::connect
Start the handshake from the client side.
LinkPair::new
LinkPair::new_with_cc
The same wiring, with a chosen congestion control algorithm on the client.
Only the client is given one because only the client sends bulk data here;
the server's algorithm would never be consulted. Handing the same object to
both ends would be a mistake anyway: the window and threshold are per
connection, so sharing one would let the two ends corrupt each other's state.
NoCongestionControl
pub struct NoCongestionControl {
limit : Int
}No congestion control at all: the window is effectively unbounded, so the
peer's advertised window is the only limit on the sending rate.
This is not a straw man. It is the control case that shows what congestion
control is buying: the same scenario run with and without it differs only in
how the sender behaves when a packet goes missing.
Reno
pub struct Reno {
cwnd : Int
ssthresh : Int
in_recovery : Bool
}Classical Reno congestion control (RFC 5681, with the NewReno recovery of
RFC 6582).
Reno makes one judgement: a lost packet means the path is congested, and the
response is to halve the sending rate and then creep back up. It has no
memory of what the path has delivered before, which is why it gives ground to
CUBIC on long fat links and why it is still the reference every other
algorithm is measured against.
Segment
A TCP segment.
window is what the sender of this segment is willing to receive from now
on, in bytes: flow control is carried on every segment, including pure ACKs,
so a receiver that frees buffer space can always tell the peer about it.
Segment::label
A compact label used in journals, for example SYN+ACK seq=1000 ack=4001.
Segment::new
Segment::payload_length
Bytes of payload in this segment.
Seq
A 32-bit TCP sequence number.
Sequence numbers wrap, so they cannot be compared with <. Two numbers on
opposite sides of the wrap point are "close" to each other even though their
numeric distance is enormous, and an implementation that compares them as
plain integers works perfectly until the day it does not. All comparisons go
through before, which measures the distance in the wrapping space where
half the space is "ahead" and half is "behind".
Seq::advance
Advance by length bytes, wrapping like real TCP.
Seq::before
True when self comes before other in the wrapping sequence space.
Seq::distance_to
Signed distance from self to other, in bytes.
TcpConfig
Connection parameters. Everything a run depends on is explicit here, so a
scenario file can describe a connection completely.
TcpConfig::new
TcpConnection
pub struct TcpConnection {
config : TcpConfig
cc : &CongestionControl
flow : UInt64
state : TcpState
emit : (Segment) -> Unit
snd_una : Seq
snd_nxt : Seq
rcv_nxt : Seq
peer_window : Int
send_queue : Bytes
send_offset : Int
fin_seq : Seq?
peer_fin : Bool
inflight : Array[InFlight]
inflight_head : Int
reorder : Array[Buffered]
reorder_bytes : Int
capture : Bool
delivered_bytes : Int
delivered : Bytes
has_delivered_chunk : Bool
last_delivery_ps : Int64
max_delivery_gap_ps : Int64
segments_sent : Int
segments_received : Int
bytes_sent : Int
bytes_acked : Int
duplicate_acks : Int
retransmits : Int
fast_retransmits : Int
timeouts : Int
consecutive_timeouts : Int
dup_ack_count : Int
in_recovery : Bool
recover_until : Seq
rtt_samples : Int
srtt_ps : Double
rttvar_ps : Double
has_rtt_sample : Bool
rto : Time
timer_running : Bool
timer_generation : Int
tlp_probe_pending : Bool
tlp_probe_end : Seq?
tlp_probes : Int
tlp_timer_running : Bool
tlp_timer_generation : Int
}One end of a TCP connection.
The connection is deliberately passive: it never schedules anything for
itself. It reacts to segments handed to it, and it hands outgoing segments to
whatever emit is set to. That keeps the TCP logic testable without a
network, and keeps "when does this happen" in the simulator rather than
inside the protocol.
TcpConnection::bytes_acked
Bytes of payload the peer has acknowledged.
TcpConnection::bytes_sent
Bytes of payload this end handed to the network.
TcpConnection::capture_delivered
Ask the connection to retain the byte stream it delivers, so that a test can
compare it against what was sent. Off by default; see the field comment.
TcpConnection::cc_name
The name of the congestion control algorithm.
TcpConnection::cc_phase
Which phase the congestion control algorithm reports.
TcpConnection::close
Close the connection. Only the ESTABLISHED and CLOSE-WAIT transitions are
modeled; a FIN sent from the middle of the handshake is a case this simulator
does not need yet.
TcpConnection::connect
Become the active side: send a SYN.
TcpConnection::cwnd
The congestion window currently in force, in bytes.
TcpConnection::delivered
Everything this end has delivered to the application, in order.
TcpConnection::delivered_bytes
How many bytes have been delivered to the application, in order.
TcpConnection::duplicate_acks
How many times an acknowledgment arrived that carried no new information.
TcpConnection::fast_retransmits
Segments sent again because duplicate acknowledgments revealed a hole,
without waiting for the timer.
TcpConnection::in_recovery
Whether the connection is currently repairing a hole discovered by
duplicate acknowledgments.
TcpConnection::inflight
Segments still waiting for an acknowledgment.
TcpConnection::listen
Become the passive side: wait for someone to connect.
TcpConnection::max_delivery_gap
Longest gap between consecutive in-order data deliveries during a traced run.
TcpConnection::new
A connection controlled by Reno, which is what a TCP connection normally is.
TcpConnection::new_with_cc
A connection with a specific congestion control algorithm, including
NoCongestionControl for experiments that want the peer's window to be the
only limit.
TcpConnection::on_segment
Handle one received segment.
TcpConnection::peer_window
The most recent window the peer advertised.
TcpConnection::retransmits
Segments sent again because the timer expired.
TcpConnection::rto
The retransmission timeout currently in force, including any backoff.
TcpConnection::rtt_samples
How many round-trip samples have been folded into the estimate.
TcpConnection::segments_received
TcpConnection::send
Queue application data and send as much of it as the peer's window allows.
TcpConnection::set_emit
Install the outgoing path. Until this is called the connection is a black
hole that accepts segments and produces none.
TcpConnection::set_flow
Give this connection an identity, so that several connections sharing a link
lose different packets. Flows are numbered from one; zero means "the only
connection", and leaves packets judged on their sequence number alone.
TcpConnection::srtt
The smoothed round-trip time, once a sample exists.
TcpConnection::ssthresh
The slow start threshold of the congestion control algorithm.
TcpConnection::state
The current state.
TcpConnection::timeouts
How many times the retransmission timer has expired.
TcpConnection::timer_running
Whether the retransmission timer is currently armed.
TcpConnection::tlp_probes
How many tail-loss probes this connection has sent.
TcpState
cubic
CUBIC, ready to hand to TcpConnection::new_with_cc.
header_bytes
fn header_bytes() -> IntA TCP header is 20 bytes when it carries no options. This simulator has no
options yet, so the number is exact rather than approximate.
initial_window
fn initial_window(mss : Int) -> IntThe initial window of RFC 6928: at most ten segments, at least two, and at
least 14 600 bytes once the segments are large enough to make that the
smaller number.
Ten segments is a deliberate compromise. Two segments take too long to reach
a useful rate on a short path, and a larger window would put more than a
comfortable burst into a network that has not been measured yet.
reno
Reno, ready to hand to TcpConnection::new_with_cc.
without_congestion_control
A control object that imposes no limit, ready to hand to
TcpConnection::new_with_cc.
Install
Download zipDeterministic packet-level network simulator and TCP congestion-control lab for MoonBit
simulationnetworktcpcongestion-controldeterministicdiscrete-event
Apache-2.0
Updated last month
32 downloads