use std::ffi::c_int;
use std::ffi::c_void;
#[allow(non_camel_case_types)]
pub type aclnnStatus = c_int;
#[allow(non_camel_case_types)]
pub type aclTensor = c_void;
#[allow(non_camel_case_types)]
pub type aclScalar = c_void;
#[allow(non_camel_case_types)]
pub type aclTensorList = c_void;
#[allow(non_camel_case_types)]
pub type aclIntArray = c_void;
#[allow(non_camel_case_types)]
pub type aclFloatArray = c_void;
#[allow(non_camel_case_types)]
pub type aclBoolArray = c_void;
#[cfg(cann_sys_ffi)]
use crate::acl_datatype::{aclDataType, aclFormat};
#[cfg(cann_sys_ffi)]
unsafe extern "C" {
pub fn aclCreateTensor(
viewDims: *const i64,
viewDimsNum: u64,
dataType: aclDataType,
stride: *const i64,
offset: i64,
format: aclFormat,
storageDims: *const i64,
storageDimsNum: u64,
tensorData: *mut c_void,
) -> *mut c_void;
pub fn aclCreateScalar(value: *mut c_void, dataType: aclDataType) -> *mut c_void;
pub fn aclCreateTensorList(value: *const *const c_void, size: u64) -> *mut c_void;
pub fn aclCreateIntArray(value: *const i64, size: u64) -> *mut c_void;
pub fn aclCreateFloatArray(value: *const f32, size: u64) -> *mut c_void;
pub fn aclCreateBoolArray(value: *const bool, size: u64) -> *mut c_void;
pub fn aclDestroyTensor(tensor: *const c_void) -> aclnnStatus;
pub fn aclDestroyTensorList(array: *const c_void) -> aclnnStatus;
pub fn aclDestroyScalar(scalar: *const c_void) -> aclnnStatus;
pub fn aclGetViewShape(
tensor: *const c_void,
viewDims: *mut *mut i64,
viewDimsNum: *mut u64,
) -> aclnnStatus;
pub fn aclGetStorageShape(
tensor: *const c_void,
storageDims: *mut *mut i64,
storageDimsNum: *mut u64,
) -> aclnnStatus;
pub fn aclGetViewStrides(
tensor: *const c_void,
stridesValue: *mut *mut i64,
stridesNum: *mut u64,
) -> aclnnStatus;
pub fn aclGetViewOffset(tensor: *const c_void, offset: *mut i64) -> aclnnStatus;
pub fn aclGetFormat(tensor: *const c_void, format: *mut aclFormat) -> aclnnStatus;
pub fn aclGetDataType(tensor: *const c_void, dataType: *mut aclDataType) -> aclnnStatus;
pub fn aclGetTensorListSize(tensorList: *const c_void, size: *mut u64) -> aclnnStatus;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_opaque_types_are_pointer_sized() {
assert_eq!(size_of::<*const aclTensor>(), size_of::<*const c_void>());
assert_eq!(size_of::<*const aclScalar>(), size_of::<*const c_void>());
assert_eq!(
size_of::<*const aclTensorList>(),
size_of::<*const c_void>()
);
assert_eq!(size_of::<*const aclIntArray>(), size_of::<*const c_void>());
assert_eq!(
size_of::<*const aclFloatArray>(),
size_of::<*const c_void>()
);
assert_eq!(size_of::<*const aclBoolArray>(), size_of::<*const c_void>());
}
#[test]
fn test_aclnn_status_is_i32() {
assert_eq!(size_of::<aclnnStatus>(), size_of::<i32>());
}
}
#[cfg(all(cann_sys_ffi, test))]
mod ffi_tests {
use super::*;
use crate::acl_datatype::{ACL_FLOAT, ACL_FORMAT_ND, ACL_INT32};
#[test]
#[ignore = "requires NPU driver"]
fn create_get_destroy_tensor() {
let dims: [i64; 2] = [2, 2];
let strides: [i64; 2] = [2, 1];
let storage: [i64; 2] = [2, 2];
unsafe {
let tensor = aclCreateTensor(
dims.as_ptr(),
2,
ACL_FLOAT,
strides.as_ptr(),
0,
ACL_FORMAT_ND,
storage.as_ptr(),
2,
std::ptr::null_mut(),
);
let mut dt: aclDataType = -1;
let status = aclGetDataType(tensor, &mut dt);
assert_eq!(status, 0);
assert_eq!(dt, ACL_FLOAT);
let status = aclDestroyTensor(tensor);
assert_eq!(status, 0);
}
}
#[test]
#[ignore = "requires NPU driver"]
fn create_destroy_scalar() {
let mut value: i32 = 1;
unsafe {
let scalar = aclCreateScalar(std::ptr::addr_of_mut!(value).cast(), ACL_INT32);
let status = aclDestroyScalar(scalar);
assert_eq!(status, 0);
}
}
#[test]
#[ignore = "requires NPU driver"]
fn create_get_destroy_tensor_list() {
let dims: [i64; 1] = [4];
let strides: [i64; 1] = [1];
let storage: [i64; 1] = [4];
unsafe {
let t1 = aclCreateTensor(
dims.as_ptr(),
1,
ACL_FLOAT,
strides.as_ptr(),
0,
ACL_FORMAT_ND,
storage.as_ptr(),
1,
std::ptr::null_mut(),
);
let tensor_ptr: *const c_void = t1;
let list = aclCreateTensorList(&tensor_ptr as *const *const c_void, 1);
let mut size: u64 = 0;
let status = aclGetTensorListSize(list, &mut size);
assert_eq!(status, 0);
assert_eq!(size, 1);
let status = aclDestroyTensorList(list);
assert_eq!(status, 0);
let status = aclDestroyTensor(t1);
assert_eq!(status, 0);
}
}
}