Struct crossbeam_deque::deque::Buffer

struct Buffer<T> {
    ptr: *mut T,
    cap: usize,
}

A buffer that holds tasks in a worker queue.

This is just a pointer to the buffer and its length - dropping an instance of this struct will not deallocate the buffer.

Fields

ptr: *mut T

Pointer to the allocated memory.

cap: usize

Capacity of the buffer. Always a power of two.

Implementations

impl<T> Buffer<T>

fn alloc(cap: usize) -> Buffer<T>

Allocates a new buffer with the specified capacity.

unsafe fn dealloc(self)

Deallocates the buffer.

unsafe fn at(&self, index: isize) -> *mut T

Returns a pointer to the task at the specified index.

unsafe fn write(&self, index: isize, task: MaybeUninit<T>)

Writes task into the specified index.

This method might be concurrently called with another read at the same index, which is technically speaking a data race and therefore UB. We should use an atomic store here, but that would be more expensive and difficult to implement generically for all types T. Hence, as a hack, we use a volatile write instead.

unsafe fn read(&self, index: isize) -> MaybeUninit<T>

Reads a task from the specified index.

This method might be concurrently called with another write at the same index, which is technically speaking a data race and therefore UB. We should use an atomic load here, but that would be more expensive and difficult to implement generically for all types T. Hence, as a hack, we use a volatile load instead.

Trait Implementations

impl<T> Clone for Buffer<T>

fn clone(&self) -> Buffer<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Copy for Buffer<T>

impl<T> Send for Buffer<T>