Struct Simple 

pub struct Simple {
    pub alpha: f64,
    pub delay_budget: i64,
    pub intercept: u16,
    pub sample_interval: i64,
    pub variance_threshold: f64,
}

Fields

alpha: f64

This is used to calculate the arrival rate: Rate_n = alpha * Sample_n + (1 - alpha) * Rate_(n-1) The bigger this value, the more sensitive it is to the latest sample.

Must be in the range (0, 1]. Defaults to server-assigned value if zero.

delay_budget: i64

Wait time budget at the driver.

This is equivalent to W in Little’s Law. More practically, this is an upper bound for the average time buffers spend waiting in the queue of the device impl before they are processed by the device interface.

Guidance for driver implementors:

1. If your driver uses a interrupt coalescing timeout, then this W should just be that or slightly larger to account for the processing time.
2. If your driver does not use moderation, this value can be tuned: a starting point would be to use (bit rate, MTU, Rx depth) to derive a W under maximum pressure. As a reference (1Gbps, 1500, 256) leads to a W of 3.0 ms (256 / (10**9 / 8 / 1500) seconds). It will make little sense to go any bigger than that and you can decrease it and monitor for packet drops. You can compare the value against common interrupt coalescing configurations for reference.

Defaults to server-assigned value if zero.

intercept: u16

Number of Rx buffers the device holds regardless of the arrival rate.

This is the constant offset (intercept in L = lambda * W + intercept). delay_budget only accounts for buffers that are in flight because of queueing delay; it cannot account for buffers a device parks for structural reasons, such as keeping a fixed size hardware descriptor ring filled or letting firmware hold a reserve of host buffers. Those buffers are never returned to the device interface, no matter how slow the traffic is, so they must be accounted for separately.

Guidance for driver implementors: set this to the number of buffers the device can hold without completing them. Leaving it at zero while the device parks buffers will starve the device until min_rx_buffers covers the shortfall.

Note that this is distinct from [fuchsia.hardware.network.driver/DeviceImplInfo.min_rx_buffers], which is a floor applied to the final target. A floor keeps the target flat until the rate dependent term grows past it, whereas intercept shifts the whole curve up.

sample_interval: i64

The sampling interval for estimating packet arrival rate.

Determines how frequently the arrival rate is sampled and updated.

Defaults to server-assigned value if zero.

variance_threshold: f64

The multiple of variance to consider when triggering immediate buffer requests.

When the current packet arrival rate exceeds the average arrival rate by more than variance_threshold times the variance, the queue will immediately request additional buffers.

Must be positive. Defaults to server-assigned value if zero.

Trait Implementations

impl Clone for Simple

fn clone(&self) -> Simple

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Simple

impl Debug for Simple

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

Formats the value using the given formatter.

impl<D: ResourceDialect> Decode<Simple, D> for Simple

fn new_empty() -> Self

Creates a valid instance of Self. The specific value does not matter, since it will be overwritten by decode.

unsafe fn decode( &mut self, decoder: &mut Decoder<'_, D>, offset: usize, _depth: Depth, ) -> Result<()>

Decodes an object of type T from the decoder’s buffers into self.

impl<D: ResourceDialect> Encode<Simple, D> for &Simple

unsafe fn encode( self, encoder: &mut Encoder<'_, D>, offset: usize, _depth: Depth, ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl<D: ResourceDialect, T0: Encode<f64, D>, T1: Encode<i64, D>, T2: Encode<u16, D>, T3: Encode<i64, D>, T4: Encode<f64, D>> Encode<Simple, D> for (T0, T1, T2, T3, T4)

unsafe fn encode( self, encoder: &mut Encoder<'_, D>, offset: usize, depth: Depth, ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl PartialEq for Simple

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Simple

fn partial_cmp(&self, other: &Simple) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Persistable for Simple

impl StructuralPartialEq for Simple

impl TypeMarker for Simple

type Owned = Simple

The owned Rust type which this FIDL type decodes into.

fn inline_align(_context: Context) -> usize

Returns the minimum required alignment of the inline portion of the encoded object. It must be a (nonzero) power of two.

fn inline_size(_context: Context) -> usize

Returns the size of the inline portion of the encoded object, including padding for alignment. Must be a multiple of inline_align.

fn encode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and encoding requires no validation. When true, we can optimize encoding arrays and vectors of Self::Owned to a single memcpy.

fn decode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and decoding requires no validation. When true, we can optimize decoding arrays and vectors of Self::Owned to a single memcpy.

impl ValueTypeMarker for Simple

type Borrowed<'a> = &'a Simple

The Rust type to use for encoding. This is a particular Encode<Self> type cheaply obtainable from &Self::Owned. There are three cases:

fn borrow(value: &<Self as TypeMarker>::Owned) -> Self::Borrowed<'_>

Cheaply converts from &Self::Owned to Self::Borrowed.