Struct crndm::alloc::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

pub fn drop(&mut self)

Executes the destructor for this type.

impl MemPool for BuddyAlloc

pub 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.

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

Commits all changes and clears the logs for all threads

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

Formats the image file

pub fn gen() -> u32

pub fn size() -> usize

Total size of the memory pool

pub fn available() -> usize

Available space in the pool

pub fn used() -> usize

Total occupied space

pub fn rng() -> Range<u64>

Valid Virtual Address Range

pub fn start() -> u64

Start of virtual address range

pub fn end() -> u64

End of virtual address range

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

Prepares allocation without performing it

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

Prepares deallocation without performing it

pub unsafe fn pre_realloc(
    ptr: *mut *mut u8,
    size: usize,
    new_size: usize
) -> bool

Prepares reallocation without performing it, updating the pointer to a new one, if required, with a new size

pub unsafe fn log64(obj: *const u64, val: u64)

Adds a low-level log to update as 64-bit obj to val when perform() is called. See Log::set() for more details.

pub unsafe fn drop_on_failure(off: u64, len: 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.

pub unsafe fn perform()

Performs the prepared operations

pub unsafe fn discard()

Discards the prepared operations

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

Indicates if the given offset is allocated

pub unsafe fn new_journal(tid: ThreadId)

Creates a new Journal object for the current thread

pub unsafe fn drop_journal(journal: &mut Journal)

Drops a journal from memory

pub unsafe fn journals(
) -> &'static mut HashMap<ThreadId, (&'static Journal, i32)>

Returns the list of all journals

pub unsafe fn guarded<T, F>(f: F) -> T where
    F: FnOnce() -> T, 

Executes a closure guarded by a global mutex

pub unsafe fn recover()

Recovers from a crash

pub 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

pub fn print_info()

Prints memory information

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

Applies open pool flags

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

Translates raw pointers to memory offsets

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

Acquires a reference pointer to the object

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

Acquires a mutable reference to the object

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

Acquires a reference to the slice

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

Acquires a mutable reference to the slice

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

Acquires a reference to the object

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

Acquires a mutable reference pointer to the object

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

Translates raw pointers to memory offsets

pub fn valid<T: ?Sized>(p: &T) -> bool

Checks if the reference p belongs to this pool

pub fn contains(addr: u64) -> bool

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

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

Allocate memory as described by the given layout.

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

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

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

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

pub unsafe fn realloc(ptr: *mut *mut u8, size: usize, new_size: usize) -> bool

Shrink or grow a block of memory to the given new_size. The block is described by the given ptr pointer and layout.

pub 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

pub 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

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

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

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

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

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

Allocates new memory without copying data

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

Allocates new memory without copying data

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

Allocates new memory without copying data and realizing the allocation

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

Allocates new memory for value x

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

Creates a DropOnCommit log for the value x

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

Creates a DropOnCommit log for the value x

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

Frees the allocation for value x

pub unsafe fn commit()

Commits all changes and clears the logs for one thread

pub unsafe fn commit_no_clear()

Commits all changes without clearing the logs

pub unsafe fn clear()

Clears the logs

pub unsafe fn rollback()

Discards all changes and clears the logs

pub unsafe fn rollback_no_clear()

Discards all changes without clearing the logs

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

Executes commands atomically