use std::collections::HashMap;
use std::collections::hash_map::Entry;
use std::sync::Arc;
use crate::algebra::{Algebra, AlgebraBuildError};
use crate::ar::{TauError, tau_with_opposite};
use crate::module::Module;
use crate::opposite::{OppositeMap, opposite};
use crate::profile::{Site, hit};
#[derive(Clone, Debug, Default)]
struct OppositeCache {
entries: HashMap<usize, (Arc<Algebra>, OppositeMap)>,
}
impl OppositeCache {
fn get(&mut self, algebra: &Arc<Algebra>) -> Result<&OppositeMap, AlgebraBuildError> {
let key = Arc::as_ptr(algebra) as usize;
match self.entries.entry(key) {
Entry::Occupied(slot) => Ok(&slot.into_mut().1),
Entry::Vacant(slot) => {
let map = opposite(algebra)?;
Ok(&slot.insert((algebra.clone(), map)).1)
}
}
}
}
#[derive(Debug, Default)]
pub struct TauCache {
opposite: OppositeCache,
entries: HashMap<usize, CacheEntry>,
hits: u64,
misses: u64,
}
#[derive(Clone, Debug)]
struct CacheEntry {
module: Module,
translate: Module,
}
impl TauCache {
pub fn new() -> TauCache {
TauCache::default()
}
pub fn tau_of(&mut self, x: &Module) -> Result<&Module, TauError> {
hit(Site::TauCacheLookup);
let key = x.addr();
if self.entries.contains_key(&key) {
debug_assert!(
self.entries[&key].module.ptr_eq(x),
"TauCache: the entry keeps its module alive, so the key cannot be reused"
);
self.hits += 1;
} else {
let op = self.opposite.get(x.algebra()).map_err(TauError::Opposite)?;
let translate = tau_with_opposite(x, op)?;
self.misses += 1;
self.entries.insert(
key,
CacheEntry {
module: x.clone(),
translate,
},
);
}
Ok(&self.entries[&key].translate)
}
accessor_methods! {
pub len() -> usize = |this| this.entries.len();
pub is_empty() -> bool = |this| this.entries.is_empty();
pub hits() -> u64 = |this| this.hits;
pub misses() -> u64 = |this| this.misses;
}
}