use std::alloc::Layout;
use std::ffi::c_void;
use std::panic::{AssertUnwindSafe, catch_unwind};
use std::sync::atomic::AtomicU64;
use crate::object::{Object, ObjectArc, ObjectCore, ObjectRef, ObjectRefCore};
use crate::tvm_ffi_sys::TVMFFIObjectDeleterFlagBitMask::{
kTVMFFIObjectDeleterFlagBitMaskStrong, kTVMFFIObjectDeleterFlagBitMaskWeak,
};
use crate::tvm_ffi_sys::{COMBINED_REF_COUNT_BOTH_ONE, TVMFFIObject, TVMFFIObjectHandle};
use crate::type_traits::AnyCompatible;
use crate::{Error, INTERNAL_ERROR};
pub unsafe trait UnsafeInit: ObjectCore {
#[doc(hidden)]
unsafe fn drop_defined_fields(this: *mut Self);
}
unsafe impl UnsafeInit for Object {
unsafe fn drop_defined_fields(_this: *mut Self) {}
}
#[inline]
unsafe fn drop_if_defined<F: AnyCompatible>(field: *mut F) {
unsafe {
if !F::is_undefined(field) {
std::ptr::drop_in_place(field);
}
}
}
#[doc(hidden)]
pub mod field_drop {
use super::drop_if_defined;
use crate::any::Any;
use crate::type_traits::AnyCompatible;
pub struct FieldPtr<F>(pub *mut F);
pub trait DropDefined {
unsafe fn drop_field(&self);
}
impl<F: AnyCompatible> DropDefined for FieldPtr<F> {
#[inline(always)]
unsafe fn drop_field(&self) {
unsafe { drop_if_defined(self.0) }
}
}
impl DropDefined for FieldPtr<Any> {
#[inline(always)]
unsafe fn drop_field(&self) {
unsafe { std::ptr::drop_in_place(self.0) }
}
}
pub trait DropNothing {
fn drop_field(&self);
}
impl<F> DropNothing for &FieldPtr<F> {
#[inline(always)]
fn drop_field(&self) {
const {
assert!(
!std::mem::needs_drop::<F>(),
"a field of an `UnsafeInit` object must implement `AnyCompatible`, be \
`Any`, or have no drop glue"
)
};
}
}
}
pub unsafe fn unsafe_init<T: UnsafeInit>() -> ObjectRef {
let layout = Layout::new::<T>();
unsafe {
let ptr = std::alloc::alloc_zeroed(layout);
if ptr.is_null() {
std::alloc::handle_alloc_error(layout);
}
std::ptr::write(
ptr.cast::<TVMFFIObject>(),
TVMFFIObject {
combined_ref_count: AtomicU64::new(COMBINED_REF_COUNT_BOTH_ONE),
type_index: T::type_index(),
__padding: 0,
deleter: Some(unsafe_init_deleter::<T>),
},
);
ObjectRef::from_data(ObjectArc::from_raw(ptr.cast::<Object>()))
}
}
unsafe extern "C" fn unsafe_init_deleter<T: UnsafeInit>(ptr: *mut c_void, flags: i32) {
unsafe {
if flags & kTVMFFIObjectDeleterFlagBitMaskStrong as i32 != 0 {
T::drop_defined_fields(ptr.cast::<T>());
}
if flags & kTVMFFIObjectDeleterFlagBitMaskWeak as i32 != 0 {
std::alloc::dealloc(ptr.cast::<u8>(), Layout::new::<T>());
}
}
}
#[doc(hidden)]
pub unsafe extern "C" fn unsafe_init_creator<T: UnsafeInit>(
result: *mut TVMFFIObjectHandle,
) -> i32 {
let made = catch_unwind(AssertUnwindSafe(|| unsafe {
let object = unsafe_init::<T>();
let handle = ObjectArc::into_raw(ObjectRef::into_data(object));
std::ptr::write(result, handle as TVMFFIObjectHandle);
}));
match made {
Ok(()) => 0,
Err(_) => {
let message = format!("panic while creating an object of `{}`", T::TYPE_KEY);
Error::set_raised(&Error::new(INTERNAL_ERROR, &message));
-1
}
}
}
#[cfg(test)]
mod tests {
use std::mem::MaybeUninit;
use crate::tvm_ffi_sys::dlpack::{DLDevice, DLDeviceType};
use crate::type_traits::AnyCompatible;
use crate::{Array, BigInt, String};
fn zero_is_undefined<F: AnyCompatible>() -> bool {
let zero = MaybeUninit::<F>::zeroed();
unsafe { F::is_undefined(zero.as_ptr()) }
}
fn is_undefined<F: AnyCompatible>(value: F) -> bool {
unsafe { F::is_undefined(&value) }
}
#[test]
fn all_zero_bytes_are_undefined_where_they_are_no_value() {
assert!(zero_is_undefined::<Array<i64>>());
assert!(zero_is_undefined::<String>());
assert!(zero_is_undefined::<BigInt>());
assert!(zero_is_undefined::<DLDevice>());
assert!(!zero_is_undefined::<i64>());
assert!(!zero_is_undefined::<bool>());
assert!(!zero_is_undefined::<Option<Array<i64>>>());
assert!(!zero_is_undefined::<Option<DLDevice>>());
assert!(!zero_is_undefined::<Option<String>>());
}
#[test]
fn values_are_defined() {
let cpu = DLDevice {
device_type: DLDeviceType::kDLCPU as i32,
device_id: 0,
};
assert!(!is_undefined(Array::<i64>::new()));
assert!(!is_undefined(String::from("")));
assert!(!is_undefined(BigInt::from(0_i64)));
assert!(!is_undefined(cpu));
assert!(!is_undefined(Some(cpu)));
assert!(!is_undefined(None::<DLDevice>));
assert!(!is_undefined(None::<Array<i64>>));
}
}