Struct maskerad_memory_allocators::DoubleBufferedAllocator

pub struct DoubleBufferedAllocator { /* fields omitted */ }

A double-buffered allocator.

This allocator is a wrapper around two StackAllocators.

It works like a StackAllocator, and allows you to swap the buffers. Their APIs are the same, all the functions of the DoubleBufferedAllocator call the functions of the active StackAllocator.

Refer to the StackAllocator documentation for more information.

Example

use maskerad_memory_allocators::DoubleBufferedAllocator;
//100 bytes for data implementing the Drop trait, 100 bytes for data implementing the `Copy` trait.
let mut allocator = DoubleBufferedAllocator::with_capacity(100, 100);
let mut closed = false;

while !closed {
    //swap the active and inactive buffers of the allocator.
    allocator.swap_buffers();

    //clear the newly active buffer.
    allocator.reset();

    //allocate with the current buffer, leaving the data in the inactive buffer intact.
    //You can use this data during this frame, or the next frame.
    let my_vec: &Vec<u8> = allocator.alloc(|| {
        Vec::with_capacity(10)
    })?;

    assert!(my_vec.is_empty());

    closed = true;
}

Methods

impl DoubleBufferedAllocator

fn with_capacity(capacity: usize, capacity_copy: usize) -> Self

Create a DoubleBufferedAllocator with the given capacity (in bytes).

The first capacity is for the memory storage holding data implementing the Drop trait, the second is for the memory storage holding data implementing the Copy trait.

Example

use maskerad_memory_allocators::DoubleBufferedAllocator;
let allocator = DoubleBufferedAllocator::with_capacity(100, 50);

assert_eq!(allocator.capacity(), 100);
assert_eq!(allocator.capacity_copy(), 50);

fn alloc_mut<T, F>(&self, op: F) -> AllocationResult<&mut T> where
    F: FnOnce() -> T, 

Allocates data in the active buffer, returning a mutable reference to the allocated data.

If the allocated data implements Drop, it will be placed in the memory storage storing data implementing the Drop trait. Otherwise, it will be placed in the other memory storage.

Panic

This function will panic if the allocation exceeds the maximum storage capacity of the active allocator.

fn alloc_mut_unchecked<T, F>(&self, op: F) -> &mut T where
    F: FnOnce() -> T, 

Allocates data in the active buffer, returning a mutable reference to the allocated data.

If the allocated data implements Drop, it will be placed in the memory storage storing data implementing the Drop trait. Otherwise, it will be placed in the other memory storage.

Warning

This function doesn't return an error if the allocated data doesn't fit in the StackAllocator's remaining capacity, It doesn't perform any check.

Use if you now that the data will fit into memory and you can't afford the checks.

fn alloc<T, F>(&self, op: F) -> AllocationResult<&T> where
    F: FnOnce() -> T, 

Allocates data in the active buffer, returning an immutable reference to the allocated data.

If the allocated data implements Drop, it will be placed in the memory storage storing data implementing the Drop trait. Otherwise, it will be placed in the other memory storage.

Panic

This function will panic if the allocation exceeds the maximum storage capacity of the active allocator.

fn alloc_unchecked<T, F>(&self, op: F) -> &T where
    F: FnOnce() -> T, 

Allocates data in the active buffer, returning an immutable reference to the allocated data.

If the allocated data implements Drop, it will be placed in the memory storage storing data implementing the Drop trait. Otherwise, it will be placed in the other memory storage.

Warning

This function doesn't return an error if the allocated data doesn't fit in the active buffer's remaining capacity, It doesn't perform any check.

Use if you now that the data will fit into memory and you can't afford the checks.

fn reset(&self)

Reset the active buffer's memory storage storing data implementing the Drop trait, dropping all the content residing inside it.

fn reset_copy(&self)

Reset the active buffer's memory storage storing data implementing the Copy trait.

fn reset_to_marker(&self, marker: usize)

Reset partially the active buffer's memory storage storing data implementing the Drop trait, dropping all the content residing between the marker and the first unused memory address of the memory storage.

fn reset_to_marker_copy(&self, marker: usize)

Reset partially the active buffer's memory storage storing data implementing the Copy trait.

fn marker(&self) -> usize

Returns the index of the first unused memory address of the active buffer's memory storage storing data implementing the Drop trait.

fn marker_copy(&self) -> usize

Returns the index of the first unused memory address of the active buffer's memory storage storing data implementing the Copy trait.

fn swap_buffers(&mut self)

Swap the buffers. The inactive one becomes the active.

fn capacity(&self) -> usize

Returns the maximum capacity the memory storage storing data implementing the Drop trait can hold.

fn capacity_copy(&self) -> usize

Returns the maximum capacity the memory storage storing data implementing the Copy trait can hold.

fn storage_as_ptr(&self) -> *const u8

Returns a raw pointer to the start of the memory storage used by the memory storage storing data implementing the Drop trait.

fn storage_copy_as_ptr(&self) -> *const u8

Returns a raw pointer to the start of the memory storage used by the memory storage storing data implementing the Copy trait.

Trait Implementations

impl Debug for DoubleBufferedAllocator

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.