pub struct PacketQueue<const TX: usize, const RX: usize> { /* private fields */ }Expand description
Ethernet descriptor rings.
This struct owns the DMA descriptors of the transmit and receive rings.
The frames themselves live in embassy-net’s packet buffer pool: the
receive ring holds one buffer per descriptor, filled by DMA in place, and
the transmit ring holds each frame’s buffer until the hardware is done
with it.
TX is the number of descriptors in the transmit ring, RX in the receive
ring. A bigger ring allows the hardware to receive more frames while the
CPU is busy doing other things, which may increase performance (especially
for RX), at the cost of pinning more packet buffers. Make sure the packet
pool (the packet-buf-count-N feature of xarxa) is bigger than
TX + RX, with room to spare for the stack and sockets.
Implementations§
Source§impl<const TX: usize, const RX: usize> PacketQueue<TX, RX>
impl<const TX: usize, const RX: usize> PacketQueue<TX, RX>
Sourcepub fn init(this: &mut MaybeUninit<Self>)
pub fn init(this: &mut MaybeUninit<Self>)
Initialize a packet queue in-place.
This can be helpful to avoid accidentally stack-allocating the packet queue in the stack. The
Rust compiler can sometimes be a bit dumb when working with large owned values: if you call new()
and then store the returned PacketQueue in its final place (like a static), the compiler might
place it temporarily on the stack then move it. Since this struct is quite big, it may result
in a stack overflow.
With this function, you can create an uninitialized static with type MaybeUninit<PacketQueue<...>>
and initialize it in-place, guaranteeing no stack usage.
After calling this function, calling assume_init on the MaybeUninit is guaranteed safe.