Struct pagecache::PageCache

source · 
pub struct PageCache<PM, P, R>where
    P: 'static + Send + Sync,{ /* private fields */ }
Expand description

A lock-free pagecache which supports fragmented pages for dramatically improving write throughput.

Working with the PageCache

extern crate pagecache;

use pagecache::{pin, Materializer};

pub struct TestMaterializer;

impl Materializer for TestMaterializer {
    // The possibly fragmented page, written to log storage sequentially, and
    // read in parallel from multiple locations on disk when serving
    // a request to read the page. These will be merged to a single version
    // at read time, and possibly cached.
    type PageFrag = String;

    // The state returned by a call to `PageCache::recover`, as
    // described by `Materializer::recover`
    type Recovery = ();

    // Create a new `Materializer` with the previously recovered
    // state if any existed.
    fn new(config: pagecache::Config, last_recovery: &Option<Self::Recovery>) -> Self {
        TestMaterializer
    }

    // Used to merge chains of partial pages into a form
    // that is useful for the `PageCache` owner.
    fn merge(&self, frags: &[&Self::PageFrag]) -> Self::PageFrag {
        let mut consolidated = String::new();
        for frag in frags.into_iter() {
            consolidated.push_str(&*frag);
        }

        consolidated
    }

    // Used to feed custom recovery information back to a higher-level abstraction
    // during startup. For example, a B-Link tree must know what the current
    // root node is before it can start serving requests.
    fn recover(&self, _: &Self::PageFrag) -> Option<Self::Recovery> {
        None
    }

    // Used to determine the resident size for this item in cache.
    fn size_in_bytes(&self, frag: &String) -> usize {
        std::mem::size_of::<String>() + frag.as_bytes().len()
    }

}

fn main() {
    let config = pagecache::ConfigBuilder::new().temporary(true).build();
    let pc: pagecache::PageCache<TestMaterializer, _, _> =
        pagecache::PageCache::start(config).unwrap();
    {
        let guard = pin();
        let id = pc.allocate(&guard).unwrap();
        let mut key = pagecache::PagePtr::allocated();

        // The first item in a page should be set using replace,
        // which signals that this is the beginning of a new
        // page history, and that any previous items associated
        // with this page should be forgotten.
        key = pc.replace(id, key, "a".to_owned(), &guard).unwrap();

        // Subsequent atomic updates should be added with link.
        key = pc.link(id, key, "b".to_owned(), &guard).unwrap();
        key = pc.link(id, key, "c".to_owned(), &guard).unwrap();

        // When getting a page, the provided `Materializer` is
        // used to merge all pages together.
        let (consolidated, key) = pc.get(id, &guard).unwrap().unwrap();

        assert_eq!(*consolidated, "abc".to_owned());
    }
}

Implementations

Instantiate a new PageCache.

Flushes any pending IO buffers to disk to ensure durability.

Return the recovered state from the snapshot

Create a new page, trying to reuse old freed pages if possible to maximize underlying Radix pointer density.

Free a particular page.

Try to atomically add a PageFrag to the page. Returns Ok(new_key) if the operation was successful. Returns Err(None) if the page no longer exists. Returns Err(Some(actual_key)) if the atomic append fails.

Replace an existing page with a different set of PageFrags. Returns Ok(new_key) if the operation was successful. Returns Err(None) if the page no longer exists. Returns Err(Some(actual_key)) if the atomic swap fails.

Try to retrieve a page by its logical ID.

Trait Implementations

Formats the value using the given formatter. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The alignment of pointer.
The type for initializers.
Initializes a with the given initializer. Read more
Dereferences the given pointer. Read more
Mutably dereferences the given pointer. Read more
Drops the object pointed to by the given pointer. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.