Struct static_alloc::unsync::MemBump [−][src]
#[repr(C)]pub struct MemBump { /* fields omitted */ }
Expand description
A dynamically sized allocation block in which any type can be allocated.
Implementations
impl MemBump
[src]
impl MemBump
[src]pub fn alloc(&self, layout: Layout) -> Option<NonNull<u8>>
[src]
pub fn alloc(&self, layout: Layout) -> Option<NonNull<u8>>
[src]Allocate a region of memory.
This is a safe alternative to GlobalAlloc::alloc.
Panics
This function will panic if the requested layout has a size of 0
. For the use in a
GlobalAlloc
this is explicitely forbidden to request and would allow any behaviour but we
instead strictly check it.
pub fn alloc_at(
&self,
layout: Layout,
level: Level
) -> Result<NonNull<u8>, Failure>
[src]
pub fn alloc_at(
&self,
layout: Layout,
level: Level
) -> Result<NonNull<u8>, Failure>
[src]Try to allocate some layout with a precise base location.
The base location is the currently consumed byte count, without correction for the alignment of the allocation. This will succeed if it can be allocate exactly at the expected location.
Panics
This function may panic if the provided level
is from a different slab.
pub fn get<V>(&self) -> Option<Allocation<'_, V>>
[src]
pub fn get<V>(&self) -> Option<Allocation<'_, V>>
[src]Get an allocation for a specific type.
It is not yet initialized but provides an interface for that initialization.
Usage
use core::cell::{Ref, RefCell}; let slab: Bump<[Ref<'static, usize>; 1]> = Bump::uninit(); let data = RefCell::new(0xff); // We can place a `Ref` here but we did not yet. let alloc = slab.get::<Ref<usize>>().unwrap(); let cell_ref = unsafe { alloc.leak(data.borrow()) }; assert_eq!(**cell_ref, 0xff);
pub fn get_at<V>(&self, level: Level) -> Result<Allocation<'_, V>, Failure>
[src]
pub fn get_at<V>(&self, level: Level) -> Result<Allocation<'_, V>, Failure>
[src]Get an allocation for a specific type at a specific level.
See get
for usage.
pub fn bump_box<'bump, T: 'bump>(
&'bump self
) -> Result<LeakBox<'bump, MaybeUninit<T>>, Failure>
[src]
pub fn bump_box<'bump, T: 'bump>(
&'bump self
) -> Result<LeakBox<'bump, MaybeUninit<T>>, Failure>
[src]Allocate space for one T
without initializing it.
Note that the returned MaybeUninit
can be unwrapped from LeakBox
. Or you can store an
arbitrary value and ensure it is safely dropped before the borrow ends.
Usage
use core::cell::RefCell; use static_alloc::leaked::LeakBox; let slab: Bump<[usize; 4]> = Bump::uninit(); let data = RefCell::new(0xff); let slot = slab.bump_box().unwrap(); let cell_box = LeakBox::write(slot, data.borrow()); assert_eq!(**cell_box, 0xff); drop(cell_box); assert!(data.try_borrow_mut().is_ok());
pub fn bump_array<'bump, T: 'bump>(
&'bump self,
n: usize
) -> Result<LeakBox<'bump, [MaybeUninit<T>]>, Failure>
[src]
pub fn bump_array<'bump, T: 'bump>(
&'bump self,
n: usize
) -> Result<LeakBox<'bump, [MaybeUninit<T>]>, Failure>
[src]Allocate space for a slice of T
s without initializing any.
Retrieve individual MaybeUninit
elements and wrap them as a LeakBox
to store values. Or
use the slice as backing memory for one of the containers from without-alloc
. Or manually
initialize them.
Usage
Quicksort, implemented recursively, requires a maximum of log n
stack frames in the worst
case when implemented optimally. Since each frame is quite large this is wasteful. We can
use a properly sized buffer instead and implement an iterative solution. (Left as an
exercise to the reader, or see the examples for without-alloc
where we use such a dynamic
allocation with an inline vector as our stack).