Struct Allocator

pub struct Allocator { /* private fields */ }

A bump-allocated memory arena based on bumpalo.

No Drops

Objects that are bump-allocated will never have their Drop implementation called — unless you do it manually yourself. This makes it relatively easy to leak memory or other resources.

Implementations

impl Allocator

pub fn alloc<T>(&self, val: T) -> &mut T

Allocate an object in this Allocator and return an exclusive reference to it.

Panics

Panics if reserving space for T fails.

Example

use oxc_allocator::Allocator;

let allocator = Allocator::default();
let x = allocator.alloc([1u8; 20]);
assert_eq!(x, &[1u8; 20]);

pub fn alloc_str<'alloc>(&'alloc self, src: &str) -> &'alloc mut str

Copy a string slice into this Allocator and return a reference to it.

Panics

Panics if reserving space for the string fails.

Example

use oxc_allocator::Allocator;
let allocator = Allocator::default();
let hello = allocator.alloc_str("hello world");
assert_eq!(hello, "hello world");

pub fn reset(&mut self)

Reset this allocator.

Performs mass deallocation on everything allocated in this arena by resetting the pointer into the underlying chunk of memory to the start of the chunk. Does not run any Drop implementations on deallocated objects.

If this arena has allocated multiple chunks to bump allocate into, then the excess chunks are returned to the global allocator.

Example

use oxc_allocator::Allocator;

let mut allocator = Allocator::default();

// Allocate a bunch of things.
{
    for i in 0..100 {
        allocator.alloc(i);
    }
}

// Reset the arena.
allocator.reset();

// Allocate some new things in the space previously occupied by the
// original things.
for j in 200..400 {
    allocator.alloc(j);
}

Trait Implementations

impl Allocator for &Allocator

SAFETY: https://github.com/fitzgen/bumpalo/blob/4eeab8847c85d5cde135ca21ae14a54e56b05224/src/lib.rs#L1938

fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

Attempts to allocate a block of memory.

unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout)

Deallocates the memory referenced by ptr.

unsafe fn shrink( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Attempts to shrink the memory block.

unsafe fn grow( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Attempts to extend the memory block.

unsafe fn grow_zeroed( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Behaves like grow, but also ensures that the new contents are set to zero before being returned.

fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

Behaves like allocate, but also ensures that the returned memory is zero-initialized.

fn by_ref(&self) -> &Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Allocator.

impl Default for Allocator

fn default() -> Allocator

Returns the “default value” for a type.

impl Send for Allocator

SAFETY: Not actually safe, but for enabling Send for downstream crates.

impl Sync for Allocator

SAFETY: Not actually safe, but for enabling Sync for downstream crates.