use tvm_ffi::collections::tensor::CPUNDAlloc;
use tvm_ffi::*;
fn create_tensor(val: f32, shape: &[i64]) -> Tensor {
let dtype = DLDataType::new(DLDataTypeCode::kDLFloat, 32, 1);
let device = DLDevice::new(DLDeviceType::kDLCPU, 0);
let tensor = Tensor::from_nd_alloc(CPUNDAlloc, shape, dtype, device);
if let Ok(slice) = unsafe { tensor.data_as_slice_mut::<f32>() } {
slice[0] = val;
}
tensor
}
fn get_val(tensor: &Tensor) -> f32 {
tensor
.data_as_slice::<f32>()
.expect("Type mismatch or null")[0]
}
#[test]
fn test_array_core_and_iteration() {
let t1 = create_tensor(10.0, &[1, 2]);
let t2 = create_tensor(20.0, &[3, 4, 5]);
let array = Array::from_vec(vec![t1.clone(), t2.clone()]);
assert_eq!(array.len(), 2);
assert!(!array.is_empty());
assert_eq!(get_val(&array[0]), 10.0);
assert_eq!(array[0].ndim(), 2);
assert_eq!(array[1].ndim(), 3);
let vals: Vec<f32> = array.iter().map(get_val).collect();
assert_eq!(vals, vec![10.0, 20.0]);
}
#[test]
fn test_array_any_conversions() {
let array = Array::from_vec(vec![
create_tensor(1.0, &[1]),
create_tensor(2.0, &[1]),
create_tensor(3.0, &[1]),
]);
let any = Any::from(array);
assert_eq!(any.type_index(), TypeIndex::kTVMFFIArray as i32);
let back: Array<Tensor> = Array::try_from(any).expect("Any -> Array failed");
assert_eq!(back.len(), 3);
assert_eq!(get_val(&back.get(2).unwrap()), 3.0);
let view = AnyView::from(&back);
let back_from_view: Array<Tensor> = Array::try_from(view).expect("AnyView -> Array failed");
assert_eq!(back_from_view.len(), 3);
}
#[test]
fn test_array_with_any_elements() {
let array = Array::from_vec(vec![
Any::from(7i64),
Any::from(String::from("value")),
Any::from(Array::from_vec(vec![1i64, 2])),
]);
assert_eq!(i64::try_from(array.get(0).unwrap()).unwrap(), 7);
assert_eq!(
String::try_from(array.get(1).unwrap()).unwrap().as_str(),
"value"
);
assert_eq!(
Array::<i64>::try_from(array.get(2).unwrap())
.unwrap()
.iter()
.copied()
.collect::<Vec<_>>(),
vec![1, 2]
);
let round_trip = Array::<Any>::try_from(Any::from(array)).unwrap();
assert_eq!(round_trip.len(), 3);
let array_size = Function::get_global("ffi.ArraySize").unwrap();
let by_value = i64::try_from(array_size.call_tuple((round_trip.clone(),)).unwrap()).unwrap();
let by_reference = i64::try_from(array_size.call_tuple((&round_trip,)).unwrap()).unwrap();
assert_eq!((by_value, by_reference), (3, 3));
let widened = Array::<Any>::try_from(Any::from(Array::from_vec(vec![3i64, 4]))).unwrap();
assert_eq!(
widened
.iter()
.map(|value| value.downcast_ref::<i64>().copied().unwrap())
.collect::<Vec<_>>(),
vec![3, 4]
);
}
#[test]
fn test_array_recursive_type_checking() {
let shape_array = Array::from_vec(vec![Shape::from(vec![1, 2]), Shape::from(vec![3])]);
let any_val = Any::from(shape_array);
let tensor_cast = Array::<Tensor>::try_from(any_val.clone());
assert!(
tensor_cast.is_err(),
"Should not be able to cast Array<Shape> to Array<Tensor>"
);
let shape_cast = Array::<Shape>::try_from(any_val);
assert!(
shape_cast.is_ok(),
"Should be able to cast back to correct type"
);
}
#[test]
fn test_array_parametric_heterogeneity() {
let shape_array = Array::from_vec(vec![Shape::from(vec![1, 2, 3]), Shape::from(vec![10])]);
assert_eq!(shape_array.get(0).unwrap().as_slice(), &[1, 2, 3]);
assert_eq!(shape_array.get(1).unwrap().as_slice(), &[10]);
let function_array = Array::from_vec(vec![
Function::get_global("ffi.String").unwrap(),
Function::get_global("ffi.Bytes").unwrap(),
]);
assert_eq!(
into_typed_fn!(
function_array.get(0).unwrap(),
Fn(String) -> Result<String>
)("hello".into())
.unwrap(),
"hello"
);
assert_eq!(
into_typed_fn!(
function_array.get(1).unwrap(),
Fn(Bytes) -> Result<Bytes>
)([1, 2, 3].into())
.unwrap(),
&[1, 2, 3]
);
}
#[test]
fn test_array_copy_on_write() {
let ptr = |a: &Array<String>| ObjectArc::as_ptr(<Array<String> as ObjectRefCore>::data(a));
let s = |x: &str| String::from(x);
let values = |a: &Array<String>| a.iter().map(|x| x.as_str().to_owned()).collect::<Vec<_>>();
let mut array = Array::from_vec(vec![s("a"), s("b"), s("c")]);
let shared = array.clone();
array.set(0, s("x"));
assert_ne!(ptr(&array), ptr(&shared));
assert_eq!(values(&shared), ["a", "b", "c"]);
let unique = ptr(&array);
array.set(1, s("y"));
array.truncate(2);
assert_eq!(array.pop().unwrap().as_str(), "y");
assert_eq!(ptr(&array), unique);
array.push(s("z"));
array.insert(0, s("w"));
assert_eq!(values(&array), ["w", "x", "z"]);
assert!(Array::<String>::new().pop().is_none());
}