use alloc::{
string::{
String,
ToString,
},
sync::Arc,
};
use burn::{
Tensor,
tensor::kind::Basic,
};
use dashmap::DashMap;
use hashbrown::HashSet;
use crate::prelude::dynamic::DynTensor;
#[derive(Debug, Clone, Default)]
pub struct DynTensorEnv {
map: Arc<DashMap<String, DynTensor>>,
}
impl DynTensorEnv {
pub fn copy(&self) -> Self {
Self {
map: Arc::new(self.map.as_ref().clone()),
}
}
pub fn len(&self) -> usize {
self.map.len()
}
pub fn is_empty(&self) -> bool {
self.map.is_empty()
}
pub fn keys(&self) -> HashSet<String> {
self.iter().map(|r| r.key().clone()).collect()
}
pub fn iter(&self) -> dashmap::iter::Iter<'_, String, DynTensor> {
self.map.iter()
}
pub fn bind(
&mut self,
name: impl AsRef<str>,
tensor: impl Into<DynTensor>,
) {
self.map.insert(name.as_ref().to_string(), tensor.into());
}
pub fn drop(
&mut self,
name: impl AsRef<str>,
) -> Option<DynTensor> {
self.map.remove(name.as_ref()).map(|(_, v)| v)
}
pub fn contains_key(
&self,
name: impl AsRef<str>,
) -> bool {
self.map.contains_key(name.as_ref())
}
pub fn get_ref(
&self,
name: impl AsRef<str>,
) -> Option<dashmap::mapref::one::Ref<'_, String, DynTensor>> {
self.map.get(name.as_ref())
}
pub fn get_dyn(
&self,
name: impl AsRef<str>,
) -> Option<DynTensor> {
self.get_ref(name).map(|r| r.value().clone())
}
pub fn expect_dyn(
&self,
name: impl AsRef<str>,
) -> DynTensor {
let name = name.as_ref();
self.get_dyn(name)
.unwrap_or_else(|| panic!("tensor not found: {name:?}"))
}
pub fn get_tensor<const D: usize, K>(
&self,
name: impl AsRef<str>,
) -> Option<Tensor<D, K>>
where
K: Basic + 'static,
{
self.get_dyn(name).and_then(|dt| dt.downcast_clone())
}
pub fn expect_tensor<const D: usize, K>(
&self,
name: impl AsRef<str>,
) -> Tensor<D, K>
where
K: Basic + 'static,
{
let name = name.as_ref();
let dt = self.expect_dyn(name);
dt.downcast_clone().unwrap_or_else(|| {
panic!(
"tensor {name:?} (rank={}, kind={:?}) is not a Tensor<_, {D}, {}>",
dt.rank(),
dt.kind(),
core::any::type_name::<K>(),
)
})
}
}
#[cfg(test)]
mod tests {
use burn::{
Tensor,
prelude::{
Bool,
Float,
},
tensor::Int,
};
use super::*;
use crate::support::testing::cpu_device;
#[test]
fn test_dyn_tensor_env() {
let device = cpu_device();
let mut env1_a = DynTensorEnv::default();
let mut env1_b = env1_a.clone();
let int_tensor: Tensor<2, Int> = Tensor::arange(0..6, &device).reshape([2, 3]);
let float_tensor: Tensor<3> = Tensor::arange(0..24, &device).reshape([2, 3, 4]).float();
let bool_tensor: Tensor<1, Bool> = Tensor::zeros([2], &device);
assert_eq!(env1_a.contains_key("foo"), false);
assert_eq!(env1_b.contains_key("foo"), false);
env1_a.bind("foo", int_tensor.clone());
assert_eq!(env1_a.contains_key("foo"), true);
assert_eq!(env1_b.contains_key("foo"), true);
env1_a
.expect_tensor::<2, Int>("foo")
.to_data_as::<i32>()
.assert_eq(&int_tensor.to_data_as::<i32>(), true);
env1_b
.expect_tensor::<2, Int>("foo")
.to_data_as::<i32>()
.assert_eq(&int_tensor.to_data_as::<i32>(), true);
let float_dyn_tensor: DynTensor = float_tensor.clone().into();
env1_a.bind("bar", float_dyn_tensor);
assert_eq!(env1_a.contains_key("bar"), true);
assert_eq!(env1_b.contains_key("bar"), true);
env1_a
.expect_tensor::<3, Float>("bar")
.to_data_as::<f32>()
.assert_eq(&float_tensor.to_data_as::<f32>(), true);
env1_b
.expect_tensor::<3, Float>("bar")
.to_data_as::<f32>()
.assert_eq(&float_tensor.to_data_as::<f32>(), true);
env1_b.bind("baz", bool_tensor.clone());
assert_eq!(env1_a.contains_key("baz"), true);
assert_eq!(env1_b.contains_key("baz"), true);
env1_a
.expect_tensor::<1, Bool>("baz")
.to_data_as::<bool>()
.assert_eq(&bool_tensor.to_data_as::<bool>(), true);
env1_b
.expect_tensor::<1, Bool>("baz")
.to_data_as::<bool>()
.assert_eq(&bool_tensor.to_data_as::<bool>(), true);
let env1_keys: HashSet<String> = ["foo", "bar", "baz"]
.into_iter()
.map(String::from)
.collect();
assert_eq!(&env1_a.keys(), &env1_keys);
assert_eq!(&env1_b.keys(), &env1_keys);
let mut env2 = env1_a.copy();
env2.drop("baz");
assert_eq!(env2.contains_key("baz"), false);
let evn2_keys: HashSet<String> = ["foo", "bar"].into_iter().map(String::from).collect();
assert_eq!(&env2.keys(), &evn2_keys);
assert_eq!(&env1_a.keys(), &env1_keys);
assert_eq!(env1_a.contains_key("baz"), true);
assert_eq!(env1_b.contains_key("baz"), true);
env2.expect_tensor::<2, Int>("foo")
.to_data_as::<i32>()
.assert_eq(&int_tensor.to_data_as::<i32>(), true);
env2.expect_tensor::<3, Float>("bar")
.to_data_as::<f32>()
.assert_eq(&float_tensor.to_data_as::<f32>(), true);
assert!(env2.get_ref("baz").is_none());
}
#[test]
#[should_panic(expected = "tensor not found: \"missing\"")]
fn test_expect_dyn_missing() {
DynTensorEnv::default().expect_dyn("missing");
}
#[test]
#[should_panic(expected = "tensor not found: \"missing\"")]
fn test_expect_tensor_missing() {
DynTensorEnv::default().expect_tensor::<2, Float>("missing");
}
#[test]
#[should_panic(expected = "tensor \"foo\" (rank=2, kind=Int) is not a Tensor<_, 2, ")]
fn test_expect_tensor_type_mismatch() {
let device = cpu_device();
let mut env = DynTensorEnv::default();
let int_tensor: Tensor<2, Int> = Tensor::arange(0..6, &device).reshape([2, 3]);
env.bind("foo", int_tensor);
env.expect_tensor::<2, Float>("foo");
}
}