Struct crndm::stm::journal::Journal

pub struct Journal<A: MemPool> { /* fields omitted */ }

A Journal object to be used for writing logs onto

Each transaction, hence each thread, may have only one journal for every memory pool to write the logs. The journal itself resides in a pool. Journals are linked together in the MemPool object to be accessible in recovery procedure.

It is not allowed to create a Journal object. However, transaction() creates a journal at the beginning and passes a reference to it to the body closure. So, to obtain a reference to a Journal, you may wrap a transaction around your code. For example:

use crndm::alloc::*;
use crndm::boxed::Pbox;
use crndm::cell::LogCell;

let cell = Heap::transaction(|journal| {
    let cell = Pbox::new(LogCell::new(10, journal), journal);
 
    assert_eq!(cell.get(), 10);
}).unwrap();

A Journal consists of one or more pages. A page provides a fixed number of log slots which is specified by PAGE_SIZE (64). This helps performance as the logs are pre-allocated. When the number of logs in a page exceeds 64, Journal object atomically allocate a new page for another 64 pages before running the operations.

Journals by default are deallocated after the transaction or recovery. However, it is possible to pin journals in the pool if they are used frequently by enabling "pin_journals" feature.

Implementations

impl<A: MemPool> Journal<A>

pub unsafe fn new() -> Self

Create new Journal with default values

pub fn is_committed(&self) -> bool

Returns true if the journal is committed

pub fn is_set(&self, flag: u64) -> bool

Checks a flag

pub fn enter_into(&mut self, head_off: &u64)

Atomically enters into the list journals of the owner pool

pub fn commit(&mut self)

Commits all logs in the journal

pub fn rollback(&mut self)

Reverts all changes

pub fn recover(&mut self)

Recovers from a crash or power failure

pub fn clear(&mut self)

Clears all logs and drops itself from the memory pool

pub fn fast_forward(&self) -> bool

Determines whether to fast-forward or rollback the transaction on recovery according to the following table:

 ┌───────────┬────────────┬──────────┬─────┐
 │ Committed │ Chaperoned │ Complete │  FF │
 ╞═══════════╪════════════╪══════════╪═════╡
 │    TRUE   │    FALSE   │     X    │ YES │
 │    TRUE   │    TRUE    │   TRUE   │ YES │
 │    TRUE   │    TRUE    │   FALSE  │  NO │
 │   FALSE   │      X     │     X    │  NO │
 └───────────┴────────────┴──────────┴─────┘

Fast-forward means that no matter the transaction is committed or not, if there exist logs, discard them all without rolling back.

States:

• Committed: Transaction is already committed but not complete (Logs still exist).
• Chaperoned: The transaction was attached to a Chaperon::transaction.
• Complete: The Chaperon::transaction is complete.

pub unsafe fn next_off(&self) -> u64

Returns the offset of the next journal, if any. Otherwise, returns zero

Trait Implementations

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

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

Formats the value using the given formatter.

impl<A: MemPool> !LooseTxInUnsafe for Journal<A>

impl<A: MemPool> !RefUnwindSafe for Journal<A>

impl<A: MemPool> !Send for Journal<A>

impl<A: MemPool> !Sync for Journal<A>

impl<A: MemPool> !TxInSafe for Journal<A>

impl<A: MemPool> !TxOutSafe for Journal<A>

impl<A: MemPool> !UnwindSafe for Journal<A>