Struct DeviceCounters 

pub struct DeviceCounters<C: CounterRepr = Counter> {

    pub send_total_frames: C,
    pub send_frame: C,
    pub send_bytes: C,
    pub send_queue_full: C,
    pub send_serialize_error: C,
    pub recv_frame: C,
    pub recv_bytes: C,
    pub recv_parse_error: C,
    pub recv_ipv4_delivered: C,
    pub recv_ipv6_delivered: C,
    pub send_ipv4_frame: C,
    pub send_ipv6_frame: C,
    pub send_dropped_no_queue: C,
    pub send_dropped_dequeue: C,
}

Device layer counters.

Fields

send_total_frames: C

Count of outgoing frames which enter the device layer (but may or may not have been dropped prior to reaching the wire).

send_frame: C

Count of frames sent.

send_bytes: C

Count of bytes sent.

send_queue_full: C

Count of frames that failed to send because of a full Tx queue.

send_serialize_error: C

Count of frames that failed to send because of a serialization error.

recv_frame: C

Count of frames received.

recv_bytes: C

Count of bytes received.

recv_parse_error: C

Count of incoming frames dropped due to a parsing error.

recv_ipv4_delivered: C

Count of incoming frames containing an IPv4 packet delivered.

recv_ipv6_delivered: C

Count of incoming frames containing an IPv6 packet delivered.

send_ipv4_frame: C

Count of sent frames containing an IPv4 packet.

send_ipv6_frame: C

Count of sent frames containing an IPv6 packet.

send_dropped_no_queue: C

Count of frames that failed to send because there was no Tx queue.

send_dropped_dequeue: C

Count of frames that were dropped during Tx queue dequeuing.

Implementations

impl DeviceCounters<u64>

pub fn assert_counters<D, CC: ResourceCounterContext<D, DeviceCounters>>( &self, core_ctx: &CC, device: &D, )

Assert that the counters tracked by core_ctx match expectations.

impl DeviceCounters

pub fn send_frame<I: Ip>(&self) -> &Counter

Either send_ipv4_frame or send_ipv6_frame depending on I.

Trait Implementations

impl<C: CounterRepr + CounterRepr> CounterCollection for DeviceCounters<C>

type Spec = DeviceCounters

The CounterCollectionSpec associated with this collection.

type Repr = C

The counter representation held by this collection.

fn cast<C>(&self) -> <Self::Spec as CounterCollectionSpec>::CounterCollection<C>

where C: CounterRepr,

A utility method to cast this collection of counters into a different underlying counter representation.

impl CounterCollectionSpec for DeviceCounters<Counter>

type CounterCollection<C: CounterRepr> = DeviceCounters<C>

The underlying CounterCollection for this specification.

fn transform<C1: CounterRepr, C2: CounterRepr>( counters: &DeviceCounters<C1>, ) -> DeviceCounters<C2>

A utility method to transform the underlying counter representation within Self::CounterCollection.

impl<C: Debug + CounterRepr> Debug for DeviceCounters<C>

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

Formats the value using the given formatter.

impl<C: Default + CounterRepr> Default for DeviceCounters<C>

fn default() -> DeviceCounters<C>

Returns the “default value” for a type.

impl Inspectable for DeviceCounters

fn record<I: Inspector>(&self, inspector: &mut I)

Records this value into inspector.

impl<C: PartialEq + CounterRepr> PartialEq for DeviceCounters<C>

fn eq(&self, other: &DeviceCounters<C>) -> 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<C: CounterRepr> StructuralPartialEq for DeviceCounters<C>