Struct Simple 

pub struct Simple {
    pub alpha: f64,
    pub delay_budget: i64,
}

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].

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.

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 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>> Encode<Simple, D> for (T0, T1)

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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 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.

impl Copy for Simple

impl Persistable for Simple

impl StructuralPartialEq for Simple