Struct corundum::default::BuddyAlloc

pub struct BuddyAlloc {}

A memory allocator with buddy allocation mechanism

To define a new buddy allocator type as a memory pool, you may use pool!() macro.

Implementations

impl BuddyAlloc

pub fn open_impl(filename: &str) -> Result<Self>

Opens a memory pool file and returns an instance of BuddyAlloc if success. The pool remains open as long as the instance lives.

Trait Implementations

impl Drop for BuddyAlloc

fn drop(&mut self)

Executes the destructor for this type.

impl MemPool for BuddyAlloc

unsafe fn format(filename: &str) -> Result<()>

Formats the image file

fn name() -> &'static str

Returns the name of the pool type

fn gen() -> u32

fn tx_gen() -> u32

fn size() -> usize

Total size of the memory pool

fn available() -> usize

Available space in the pool

fn used() -> usize

Total occupied space

fn rng() -> Range<u64>

Valid Virtual Address Range

fn start() -> u64

Start of virtual address range

fn end() -> u64

End of virtual address range

unsafe fn pre_alloc(size: usize) -> (*mut u8, u64, usize, usize)

Prepares allocation without performing it

unsafe fn pre_dealloc(ptr: *mut u8, size: usize) -> usize

Prepares deallocation without performing it

unsafe fn log64(off: u64, val: u64, z: usize)

Adds a low-level log to update as 64-bit obj to val when perform() is called. As an example, please see Log::set().

unsafe fn drop_on_failure(off: u64, len: usize, z: usize)

Adds a low-level DropOnFailure log to perform inside the allocator. This is internally used to atomically allocate a new objects. Calling perform() drops these logs.

fn zone(off: u64) -> usize

Returns the zone index corresponding to a given address

unsafe fn prepare(z: usize)

In case of not using pre_alloc or pre_dealloc, starts a low-level atomic section on a given zone.

unsafe fn perform(z: usize)

Performs the prepared operations

unsafe fn discard(z: usize)

Discards the prepared operations

fn allocated(off: u64, len: usize) -> bool

Indicates if the given offset is allocated

unsafe fn journals_head() -> &'static u64

Returns a reference to the offset of the first journal

unsafe fn drop_journal(journal: &mut Journal)

Drops a journal from memory

unsafe fn journals<T, F: Fn(&mut HashMap<ThreadId, (u64, i32)>) -> T>(f: F) -> T

Runs a closure with a mutable reference to a thread->journal HashMap

unsafe fn recover()

Recovers from a crash

fn open<'a, U: 'a + PSafe + RootObj<Self>>(
    path: &str,
    flags: u32
) -> Result<RootCell<'a, U, Self>>

Opens a pool and retrieves the root object

fn is_open() -> bool

Returns true if the pool is open

fn open_no_root(path: &str, flags: u32) -> Result<Self>

Opens a new pool without any root object. This function is for testing and is not useful in real applications as none of the allocated objects in persistent region is durable. The reason is that they are not reachable from a root object as it doesn’t exists. All objects can live only in the scope of a transaction.

unsafe fn close() -> Result<()>

Commits all changes and clears the logs for all threads

fn print_info()

Prints memory information

unsafe fn apply_flags(path: &str, flags: u32) -> Result<()>

Applies open pool flags

unsafe fn off_unchecked<T: ?Sized>(x: *const T) -> u64

Translates raw pointers to memory offsets

unsafe fn get_unchecked<'a, T: 'a + ?Sized>(off: u64) -> &'a T

Acquires a reference pointer to the object

unsafe fn get_mut_unchecked<'a, T: 'a + ?Sized>(off: u64) -> &'a mut T

Acquires a mutable reference to the object

unsafe fn deref_slice_unchecked<'a, T: 'a>(off: u64, len: usize) -> &'a [T]

Acquires a reference to the slice

unsafe fn deref_slice_unchecked_mut<'a, T: 'a>(
    off: u64,
    len: usize
) -> &'a mut [T]

Acquires a mutable reference to the slice

unsafe fn deref<'a, T: 'a>(off: u64) -> Result<&'a T>

Acquires a reference to the object

unsafe fn deref_mut<'a, T: 'a>(off: u64) -> Result<&'a mut T>

Acquires a mutable reference pointer to the object

fn off<T: ?Sized>(x: *const T) -> Result<u64>

Translates raw pointers to memory offsets

fn valid<T: ?Sized>(p: *const T) -> bool

Checks if the reference p belongs to this pool

fn contains(addr: u64) -> bool

Checks if addr is in the valid address range if this allocator

unsafe fn alloc(size: usize) -> (*mut u8, u64, usize)

Allocate memory as described by the given size.

unsafe fn dealloc(ptr: *mut u8, size: usize)

Deallocate the block of memory at the given ptr pointer with the given size.

unsafe fn alloc_zeroed(size: usize) -> *mut u8

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

unsafe fn new<'a, T: PSafe + 'a>(x: T, j: &Journal<Self>) -> &'a mut T

Allocates new memory and then places x into it with DropOnFailure log

unsafe fn new_slice<'a, T: PSafe + 'a>(
    x: &'a [T],
    journal: &Journal<Self>
) -> &'a mut [T]

Allocates a new slice and then places x into it with DropOnAbort log

unsafe fn atomic_new<'a, T: 'a>(x: T) -> (&'a mut T, u64, usize, usize)

Allocates new memory and then places x into it without realizing the allocation

unsafe fn atomic_new_slice<'a, T: 'a + PSafe>(
    x: &'a [T]
) -> (&'a mut [T], u64, usize, usize)

Allocates new memory and then places x into it without realizing the allocation

unsafe fn new_uninit<'a, T: PSafe + 'a>(j: &Journal<Self>) -> &'a mut T

Allocates new memory without copying data

unsafe fn new_uninit_for_layout(size: usize, journal: &Journal<Self>) -> *mut u8

Allocates new memory without copying data

unsafe fn atomic_new_uninit<'a, T: 'a>() -> (&'a mut T, u64, usize, usize)

Allocates new memory without copying data and realizing the allocation

unsafe fn alloc_for_value<'a, T: ?Sized>(x: &T) -> &'a mut T

Allocates new memory for value x

unsafe fn free<'a, T: PSafe + ?Sized>(x: &mut T)

Creates a DropOnCommit log for the value x

unsafe fn free_slice<'a, T: PSafe>(x: &mut [T])

Creates a DropOnCommit log for the value x

unsafe fn free_nolog<'a, T: ?Sized>(x: &T)

Frees the allocation for value x immediately

unsafe fn commit()

Commits all changes and clears the logs for one thread

unsafe fn commit_no_clear()

Commits all changes without clearing the logs

unsafe fn clear()

Clears the logs

unsafe fn rollback() -> bool

Discards all changes and clears the logs

unsafe fn rollback_no_clear()

Discards all changes without clearing the logs

fn transaction<T, F: FnOnce(&'static Journal<Self>) -> T>(body: F) -> Result<T> where
    F: TxInSafe + UnwindSafe,
    T: TxOutSafe, 

Executes commands atomically with respect to system crashes