Struct abi::bbqueue_ipc::BBBuffer

#[repr(C)]
pub struct BBBuffer {
    buf: AtomicPtr<u8>,
    buf_len: AtomicUsize,
    write: AtomicUsize,
    read: AtomicUsize,
    last: AtomicUsize,
    reserve: AtomicUsize,
    read_in_progress: AtomicBool,
    write_in_progress: AtomicBool,
}

A backing structure for a BBQueue. Can be used to create either a BBQueue or a split Producer/Consumer pair

Fields

buf: AtomicPtr<u8>

buf_len: AtomicUsize

write: AtomicUsize

Where the next byte will be written

read: AtomicUsize

Where the next byte will be read from

last: AtomicUsize

Used in the inverted case to mark the end of the readable streak. Otherwise will == sizeof::<self.buf>(). Writer is responsible for placing this at the correct place when entering an inverted condition, and Reader is responsible for moving it back to sizeof::<self.buf>() when exiting the inverted condition

reserve: AtomicUsize

Used by the Writer to remember what bytes are currently allowed to be written to, but are not yet ready to be read from

read_in_progress: AtomicBool

Is there an active read grant?

write_in_progress: AtomicBool

Is there an active write grant?

Implementations

impl<'a> BBBuffer

pub unsafe fn initialize(&'a self, buf_start: *mut u8, buf_len: usize)

Attempt to split the BBBuffer into Consumer and Producer halves to gain access to the buffer. If buffer has already been split, an error will be returned.

NOTE: When splitting, the underlying buffer will be explicitly initialized to zero. This may take a measurable amount of time, depending on the size of the buffer. This is necessary to prevent undefined behavior. If the buffer is placed at static scope within the .bss region, the explicit initialization will be elided (as it is already performed as part of memory initialization)

NOTE: If the thumbv6 feature is selected, this function takes a short critical section while splitting.

use bbqueue::BBBuffer;

// Create and split a new buffer
let buffer: BBBuffer<6> = BBBuffer::new();
let (prod, cons) = buffer.try_split().unwrap();

// Not possible to split twice
assert!(buffer.try_split().is_err());

pub unsafe fn take_producer(me: *mut Self) -> Producer<'static>

pub unsafe fn take_consumer(me: *mut Self) -> Consumer<'static>

pub unsafe fn take_framed_producer(me: *mut Self) -> FrameProducer<'static>

pub unsafe fn take_framed_consumer(me: *mut Self) -> FrameConsumer<'static>

impl BBBuffer

pub const fn new() -> Self

Create a new constant inner portion of a BBBuffer.

NOTE: This is only necessary to use when creating a BBBuffer at static scope, and is generally never used directly. This process is necessary to work around current limitations in const fn, and will be replaced in the future.

use bbqueue::BBBuffer;

static BUF: BBBuffer<6> = BBBuffer::new();

fn main() {
   let (prod, cons) = BUF.try_split().unwrap();
}

Trait Implementations

impl Debug for BBBuffer

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

Formats the value using the given formatter.

impl Sync for BBBuffer