use burn::{
prelude::Backend,
tensor::backend::DeviceOps,
};
mod value_cache {
use std::{
any::{
Any,
TypeId,
},
sync::LazyLock,
};
use burn::prelude::Backend;
use dashmap::DashMap;
type ValueCache = DashMap<TypeId, Box<dyn Any + Send + Sync>>;
static VALUE_CACHE: LazyLock<ValueCache> = LazyLock::new(DashMap::new);
pub fn cached_value<V>(init: impl FnOnce() -> V) -> V
where
V: Any + Clone + Send + Sync,
{
let key = TypeId::of::<V>();
if let Some(entry) = VALUE_CACHE.get(&key) {
return downcast_value(&**entry);
}
let value: Box<dyn Any + Send + Sync> = Box::new(init());
let entry = VALUE_CACHE.entry(key).or_insert(value);
downcast_value(&**entry)
}
fn downcast_value<V>(entry: &(dyn Any + Send + Sync)) -> V
where
V: Any + Clone,
{
entry
.downcast_ref::<V>()
.expect("cache slot holds a type other than the one keying it")
.clone()
}
pub fn set_cached_value<V>(value: V)
where
V: Any + Send + Sync,
{
VALUE_CACHE.insert(TypeId::of::<V>(), Box::new(value));
}
pub fn clear_cached_value<V>()
where
V: Any,
{
VALUE_CACHE.remove(&TypeId::of::<V>());
}
#[cfg(test)]
mod tests {
use serial_test::serial;
use super::*;
#[test]
#[serial(value_cache)]
fn test_cached_value_memoizes() {
clear_cached_value::<u32>();
assert_eq!(cached_value(|| 7_u32), 7);
assert_eq!(cached_value(|| 9_u32), 7);
clear_cached_value::<u32>();
}
#[test]
#[serial(value_cache)]
fn test_cached_value_set_and_clear() {
clear_cached_value::<u32>();
assert!(!VALUE_CACHE.contains_key(&TypeId::of::<u32>()));
set_cached_value(42_u32);
assert!(VALUE_CACHE.contains_key(&TypeId::of::<u32>()));
assert_eq!(cached_value(|| 7_u32), 42);
clear_cached_value::<u32>();
assert!(!VALUE_CACHE.contains_key(&TypeId::of::<u32>()));
assert_eq!(cached_value(|| 7_u32), 7);
clear_cached_value::<u32>();
}
#[test]
#[serial(value_cache)]
fn test_cached_value_types_do_not_collide() {
clear_cached_value::<u32>();
clear_cached_value::<String>();
assert_eq!(cached_value(|| 7_u32), 7);
assert_eq!(cached_value(|| "b".to_string()), "b");
assert_eq!(cached_value(|| 0_u32), 7);
clear_cached_value::<u32>();
clear_cached_value::<String>();
}
}
}
pub fn default_device<D: DeviceOps>() -> D {
value_cache::cached_value(D::default)
}
pub fn backend_device<B: Backend>() -> B::Device {
default_device::<B::Device>()
}
pub fn set_default_device<D: DeviceOps>(device: D) {
value_cache::set_cached_value(device);
}
pub fn reset_default_device<D: DeviceOps>() {
value_cache::clear_cached_value::<D>();
}
#[cfg(test)]
mod tests {
use burn::prelude::Device;
use super::*;
use crate::support::testing::CpuBackend;
#[test]
fn test_device_entry_points_agree() {
let device = backend_device::<CpuBackend>();
assert_eq!(device, backend_device::<CpuBackend>());
assert_eq!(device, default_device::<Device<CpuBackend>>());
}
#[test]
fn test_default_device_set_and_reset_round_trip() {
let device = backend_device::<CpuBackend>();
set_default_device(device.clone());
assert_eq!(backend_device::<CpuBackend>(), device);
reset_default_device::<Device<CpuBackend>>();
assert_eq!(backend_device::<CpuBackend>(), device);
}
}