Struct Cache

pub struct Cache<A> { /* private fields */ }

A general purpouse cache suitable for saving discarted memory allocations in a tight loop.

Dummy Example

extern crate owned_alloc;

use owned_alloc::{Cache, RawVec, UninitAlloc};

fn do_some_stuff(iter: usize, n: usize) -> usize {
    let mut cache = Cache::new();
    let mut res = 0usize;

    for i in 1 ..= iter {
        let alloc =
            cache.take_or(|| UninitAlloc::from(RawVec::with_capacity(n)));

        let inited = unsafe {
            alloc.init_in_place(|slice| {
                for j in 0 .. slice.len() {
                    (&mut slice[j] as *mut usize)
                        .write(i.wrapping_mul(j + 1))
                }
            })
        };

        for &item in &*inited {
            res = res.wrapping_add(item);
        }

        cache.store(inited.drop_in_place());
    }

    res
}

assert_eq!(do_some_stuff(2, 3), 1 + 2 + 3 + 2 + 4 + 6);

Implementations

impl<A> Cache<A>

pub fn new() -> Self

Creates a new cache with no data.

pub fn store(&mut self, val: A)

Stores data into the cache.

pub fn take(&mut self) -> Option<A>

Takes the data from the cache.

pub fn take_or<F>(&mut self, create: F) -> A

where F: FnOnce() -> A,

Takes the data from the cache. If there was no data, the passed closure is called to produce the returned data.

Trait Implementations

impl<A: Debug> Debug for Cache<A>

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

Formats the value using the given formatter.

impl<A> Default for Cache<A>

fn default() -> Self

Returns the “default value” for a type.