Struct LockedHeap

Source

pub struct LockedHeap(/* private fields */);

Expand description

A re-export of slab_allocator_rs::LockedHeap for ease-of-use reasons.

Implementations§

Source §

impl LockedHeap

Source

pub const fn empty() -> LockedHeap

Source

pub unsafe fn init(&self, heap_start_addr: usize, size: usize)

§Safety

This function is unsafe because it can cause undefined behavior if the given address is invalid.

Source

pub unsafe fn new(heap_start_addr: usize, heap_size: usize) -> LockedHeap

Creates a new heap with the given heap_start_addr and heap_size. The start address must be valid and the memory in the [heap_start_addr, heap_bottom + heap_size) range must not be used for anything else.

§Safety

This function is unsafe because it can cause undefined behavior if the given address is invalid.

Methods from Deref<Target = Mutex<Option<Heap>>>§

Source

pub fn lock(&self) -> MutexGuard<'_, T>

Locks the Mutex and returns a guard that permits access to the inner data.

The returned value may be dereferenced for data access and the lock will be dropped when the guard falls out of scope.

let lock = spin::Mutex::new(0);
{
    let mut data = lock.lock();
    // The lock is now locked and the data can be accessed
    *data += 1;
    // The lock is implicitly dropped at the end of the scope
}

Source

pub fn is_locked(&self) -> bool

Returns true if the lock is currently held.

§Safety

This function provides no synchronization guarantees and so its result should be considered ‘out of date’ the instant it is called. Do not use it for synchronization purposes. However, it may be useful as a heuristic.

Source

pub unsafe fn force_unlock(&self)

Force unlock this Mutex.

§Safety

This is extremely unsafe if the lock is not held by the current thread. However, this can be useful in some instances for exposing the lock to FFI that doesn’t know how to deal with RAII.

Source

pub fn try_lock(&self) -> Option<MutexGuard<'_, T>>

Try to lock this Mutex, returning a lock guard if successful.

§Example

let lock = spin::Mutex::new(42);

let maybe_guard = lock.try_lock();
assert!(maybe_guard.is_some());

// `maybe_guard` is still held, so the second call fails
let maybe_guard2 = lock.try_lock();
assert!(maybe_guard2.is_none());