Struct RwndDecision 

pub struct RwndDecision {
    pub set_rcv_buf: Option<u64>,
    pub app_read_bytes: Option<u64>,
}

A single receive-side decision emitted by a RwndTrace.

The two fields are independent, and between them they say what the receiver does for this step’s duration.

set_rcv_buf sizes the receive buffer. On its own it also states that the application is keeping up with it: the buffer holds that many bytes, the advertised window is held at that value, and the application drains continuously so the window’s right edge slides forward with the data received. That models a receiver whose buffer stopped growing – in-flight ends up limited by the window, and the window itself stays put.

app_read_bytes states the opposite situation: over this step the application reads exactly that many bytes and then stops. The window is whatever is left of the buffer once the unread backlog is subtracted, so it shrinks as data arrives and reaches zero when the buffer fills. That models a receiver whose application is the bottleneck.

Because the fields are independent, all four combinations are meaningful and none is a special case:

set_rcv_buf	app_read_bytes	meaning
Some(n)	None	buffer n, window pinned at n, application drains continuously
None	Some(m)	read m bytes against the standing buffer; window is what is left
Some(n)	Some(m)	resize the buffer to n, then read m bytes from it
None	None	carry the previous configuration forward for this step

Both fields on one step

The two apply in order: the buffer is resized first, and the read is taken against the new size. Three consequences are worth stating outright, because they are what distinguishes this from a buffer-only step:

• The window is not pinned. The “application keeps up” half of set_rcv_buf belongs to a step that states no read. Once app_read_bytes is present it is the application’s behaviour, so the window follows from n - unread and decays as data arrives, exactly as for a read-only step. A step of set_rcv_buf: n and app_read_bytes: m is therefore not equivalent to a buffer-only step of n followed by a read of m.
• The backlog survives the resize. Only the capacity changes; bytes already received and not yet read stay unread. Resizing does not discard, deliver, or otherwise account for them.
• The window saturates at zero. With unread bytes outstanding the window is n.saturating_sub(unread), so resizing to a value at or below the current backlog advertises a zero window until the application reads its way back under the new size. This is the intended way to state a receiver that shrank its buffer while behind.

Fields

set_rcv_buf: Option<u64>

If Some, size the receive buffer to this many bytes and hold the advertised window there, with the application draining continuously.

app_read_bytes: Option<u64>

If Some, the application reads exactly this many bytes over this step and then stops; the window follows from what is left unread.

Trait Implementations

impl Clone for RwndDecision

fn clone(&self) -> RwndDecision

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RwndDecision

impl Debug for RwndDecision

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RwndDecision

fn default() -> RwndDecision

Returns the “default value” for a type.

impl Eq for RwndDecision

impl PartialEq for RwndDecision

fn eq(&self, other: &RwndDecision) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RwndDecision