Struct crndm::stm::Log

pub struct Log<A: MemPool>(_, _);

The Log type for pool A

It is pair of LogEnum and Notifier to keep a log in the Journal. A Journal comprises multiple pages with a fixed number of log slots. Each slot can be filled by one Log. The Journal object uses these logs to provide data consistency. Logs reside in the persistent region and their durability is ensured by flushing the cache lines after each log.

The default mechanism of taking logs is copy-on-write which takes a log when the object is mutably dereferenced. This requires two clflushes: one for the log, and one for the update to the original data.

Implementations

impl<A: MemPool> Log<A>

pub fn set(&mut self, off: u64, len: usize)

Sets the off and len of the log

This function is used for low-level atomic allocation. The algorithm is as follows:

1. Take a neutral drop log (off = u64::MAX) in a log slot in the Journal
2. Prepare allocation using pre_alloc()
3. Add a low-level log for updating the off and len of the drop log using set function
4. Perform the prepared changes to the allocator

Note that the deallocation of owned objects are handled through RAII. To reclaim the allocation of any sort on a failure, low-level DropOnFailure log is provided with the allocation.

If a crash happens before step 4, all changes are discarded and the drop log remains neutral. If a crash happens in the middle of step 4, the recovery procedure continues performing the changes, including the low-level logs for updating the drop log. Once it has the high-level drop log, the high-level recovery procedure reclaims the allocation as the crash happened inside a transaction.

impl<A: MemPool> Log<A>

pub fn new(log: LogEnum, notifier: Notifier<A>) -> Self

Create a new log entry

pub fn take<T: PSafe + ?Sized>(
    x: &T,
    journal: &Journal<A>,
    notifier: Notifier<A>
) -> Ptr<Log<A>, A>

Takes a log of x into journal and notifies the owner that log is taken if notifier is specified.

pub fn drop_on_commit(
    offset: u64,
    len: usize,
    journal: &Journal<A>
) -> Ptr<Log<A>, A>

Creates a new DropOnCommit log and writes it on journal

pub fn drop_on_abort(
    offset: u64,
    len: usize,
    journal: &Journal<A>
) -> Ptr<Log<A>, A>

Creates a new DropOnAbort log and writes it on journal

pub fn drop_on_failure(
    offset: u64,
    len: usize,
    journal: &Journal<A>
) -> Ptr<Log<A>, A>

Creates a new DropOnFailure log and writes it on journal

pub fn unlock_on_commit(virt_addr: u64, journal: &Journal<A>)

Creates a new UnlockOnCommit for locking data in a thread

pub fn clear(&mut self)

Clears this log and notifies the owner

• If it is a DataLog, it reclaims the allocation for the log.
• If it is a UnlockOnCommit, it unlocks the mutex.

pub fn notify(&mut self, v: u8)

Notify the owner that the log is taken/cleared according to v

Trait Implementations

impl<A: MemPool> Clone for Log<A>

pub fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: MemPool> Copy for Log<A>

impl<A: MemPool> Debug for Log<A>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<A: MemPool> Default for Log<A>

pub fn default() -> Self

Returns the "default value" for a type.