Struct BarrierHeldMainRef

Source

pub struct BarrierHeldMainRef(/* private fields */);

Expand description

Reference to VPP per-thread main library context with barrier held

This is a safe wrapper around vlib_main_t, providing access to its fields.

A &mut BarrierHeldMainRef is equivalent to a vlib_main_t * in C (a *mut vlib_main_t in Rust).

See also MainRef for a variant without the constraint that the caller holds the main thread barrier.

Implementations§

Source §

impl BarrierHeldMainRef

Source

pub unsafe fn from_ptr_mut<'a>(ptr: *mut vlib_main_t) -> &'a mut Self

Creates a &mut BarrierHeldMainRef directly from a pointer

§Safety

All the safety requirements of MainRef::from_ptr_mut apply.
Additionally, the caller must that no other thread is concurrently accessing VPP data structures. This is typically ensured by holding the main thread barrier, but also applies during initialisation before worker threads are started or shutdown after worker threads are stopped.

Methods from Deref<Target = MainRef>§

Source

pub unsafe fn get_buffers<'a, 'me, 'buf: 'me, FeatureData, const N: usize>( &'me self, from_indices: &'a [u32], to: &mut ArrayVec<&'buf mut BufferRef<FeatureData>, N>, )

Get pointers to buffers for the given buffer indices, writing them into the provided to arrayvec.

This is similar to vlib_get_buffers in the C API.

Note that although it would be more idiomatic to return an ArrayVec directly, this method takes a mutable reference to an ArrayVec to avoid an unnecessary copy when returning.

§Safety

The caller must ensure that to has enough capacity to hold all the buffers corresponding to the indices in from_indices.
Each index in from_indices must be valid and the caller must have ownership of the buffer it corresponds to.
Each buffer’s feature_arc_index and current_config_index must be consistent with the FeatureData type. If they are not known (i.e. because the caller the node isn’t being executed in a feature arc), FeatureData should be a zero-sized type such as ().
The capacity of from_indices must be a multiple of 8 (note though that the length is allowed not to be). In other words, it must be valid to read multiples of 8 from the underlying memory (possibly returning uninitialised or stale data) without faulting.

Source

pub unsafe fn buffer_enqueue_to_next<N: Node, V: VectorBufferIndex>( &self, node: &mut NodeRuntimeRef<N>, from: &[V], nexts: &[u16], )

Enqueues a slice of buffer indices to a next node

This corresponds to the VPP C function vlib_buffer_enqueue_to_next.

§Safety

The length of the from and next slices must match.
The next node must have a Vector type of u32 (or the C equivalent).
The next node must have a Scalar type of () (or the C equivalent).
The next node must have an Aux type of () (or the C equivalent).
vlib_buffer_func_main must have been filled in with valid function pointers (which will be done by VPP at initialisation time).
The buffer state, such as current_data and length must be set according to the preconditions of the next node.
Each entry in the from slice must be a valid index to a buffer.
Each entry in the nexts slice must be a valid next node index.