Struct custos_math::custos::prelude::Cache

pub struct Cache<D>where
    D: RawConv,{
    pub nodes: HashMap<Ident, Rc<<D as CacheReturn>::CT>, RandomState>,
    /* private fields */
}

Fields

nodes: HashMap<Ident, Rc<<D as CacheReturn>::CT>, RandomState>

Implementations

impl<D> Cache<D>where D: RawConv,

pub fn add_node<'a, T, S>( &mut self, device: &'a D, node: Ident, _add_node: impl AddGraph ) -> Buffer<'a, T, D, S>where S: Shape, D: Alloc<'a, T, S> + RawConv,

Adds a new cache entry to the cache. The next get call will return this entry if the Ident is correct.

Example

use custos::prelude::*;
use custos::Ident;

let device = CPU::new();
let cache: Buffer = device
    .cache()
    .add_node(&device, Ident { idx: 0, len: 7 }, ());

let ptr = device
    .cache()
    .nodes
    .get(&Ident { idx: 0, len: 7 })
    .unwrap()
    .clone();

assert_eq!(cache.host_ptr(), ptr.ptr as *mut f32);

pub fn get<'a, T, S>( device: &'a D, len: usize, add_node: impl AddGraph ) -> Buffer<'a, T, D, S>where S: Shape, D: Alloc<'a, T, S> + RawConv,

Retrieves cached pointers and constructs a Buffer with the pointers and the given length. If a cached pointer doesn’t exist, a new Buffer will be added to the cache and returned.

Example

use custos::prelude::*;

let device = CPU::new();
     
let cache_entry: Buffer = Cache::get(&device, 10, ());
let new_cache_entry: Buffer = Cache::get(&device, 10, ());

assert_ne!(cache_entry.ptrs(), new_cache_entry.ptrs());

set_count(0);

let first_entry: Buffer = Cache::get(&device, 10, ());
assert_eq!(cache_entry.ptrs(), first_entry.ptrs());

Trait Implementations

impl<D> CacheAble<D> for Cache<D>where D: RawConv,

fn retrieve<T, S>( device: &D, len: usize, add_node: impl AddGraph ) -> Buffer<'_, T, D, S>where S: Shape, D: for<'b> Alloc<'b, T, S>,

impl<D> Debug for Cache<D>where D: Debug + RawConv, <D as CacheReturn>::CT: Debug,

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

Formats the value using the given formatter.

impl<D> Default for Cache<D>where D: RawConv,

fn default() -> Cache<D>

Returns the “default value” for a type.