use std::ffi::c_int;
#[allow(non_camel_case_types)]
pub type aclrtMemMallocPolicy = c_int;
pub const ACL_MEM_MALLOC_HUGE_FIRST: aclrtMemMallocPolicy = 0;
pub const ACL_MEM_MALLOC_HUGE_ONLY: aclrtMemMallocPolicy = 1;
pub const ACL_MEM_MALLOC_NORMAL_ONLY: aclrtMemMallocPolicy = 2;
pub const ACL_MEM_MALLOC_HUGE_FIRST_P2P: aclrtMemMallocPolicy = 3;
pub const ACL_MEM_MALLOC_HUGE_ONLY_P2P: aclrtMemMallocPolicy = 4;
pub const ACL_MEM_MALLOC_NORMAL_ONLY_P2P: aclrtMemMallocPolicy = 5;
pub const ACL_MEM_MALLOC_HUGE1G_ONLY: aclrtMemMallocPolicy = 6;
pub const ACL_MEM_MALLOC_HUGE1G_ONLY_P2P: aclrtMemMallocPolicy = 7;
pub const ACL_MEM_TYPE_LOW_BAND_WIDTH: aclrtMemMallocPolicy = 0x0100;
pub const ACL_MEM_TYPE_HIGH_BAND_WIDTH: aclrtMemMallocPolicy = 0x1000;
pub const ACL_MEM_ACCESS_USER_SPACE_READONLY: aclrtMemMallocPolicy = 0x100000;
#[allow(non_camel_case_types)]
pub type aclrtMemcpyKind = c_int;
pub const ACL_MEMCPY_HOST_TO_HOST: aclrtMemcpyKind = 0;
pub const ACL_MEMCPY_HOST_TO_DEVICE: aclrtMemcpyKind = 1;
pub const ACL_MEMCPY_DEVICE_TO_HOST: aclrtMemcpyKind = 2;
pub const ACL_MEMCPY_DEVICE_TO_DEVICE: aclrtMemcpyKind = 3;
pub const ACL_MEMCPY_DEFAULT: aclrtMemcpyKind = 4;
pub const ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE: aclrtMemcpyKind = 5;
pub const ACL_MEMCPY_INNER_DEVICE_TO_DEVICE: aclrtMemcpyKind = 6;
pub const ACL_MEMCPY_INTER_DEVICE_TO_DEVICE: aclrtMemcpyKind = 7;
#[cfg(cann_sys_ffi)]
use crate::acl_base_rt::aclError;
#[cfg(cann_sys_ffi)]
use std::ffi::c_void;
#[cfg(cann_sys_ffi)]
unsafe extern "C" {
pub fn aclrtMalloc(
devPtr: *mut *mut c_void,
size: usize,
policy: aclrtMemMallocPolicy,
) -> aclError;
pub fn aclrtFree(devPtr: *mut c_void) -> aclError;
pub fn aclrtMallocHost(hostPtr: *mut *mut c_void, size: usize) -> aclError;
pub fn aclrtFreeHost(hostPtr: *mut c_void) -> aclError;
pub fn aclrtMemcpy(
dst: *mut c_void,
destMax: usize,
src: *const c_void,
count: usize,
kind: aclrtMemcpyKind,
) -> aclError;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_type_aliases() {
let _: aclrtMemMallocPolicy = ACL_MEM_MALLOC_HUGE_FIRST;
let _: aclrtMemcpyKind = ACL_MEMCPY_HOST_TO_HOST;
let _: aclrtMemMallocPolicy = 0;
let _: aclrtMemcpyKind = 1;
}
#[test]
fn test_mem_malloc_policy_constants() {
assert_eq!(ACL_MEM_MALLOC_HUGE_FIRST, 0);
assert_eq!(ACL_MEM_MALLOC_HUGE_ONLY, 1);
assert_eq!(ACL_MEM_MALLOC_NORMAL_ONLY, 2);
assert_eq!(ACL_MEM_MALLOC_HUGE_FIRST_P2P, 3);
assert_eq!(ACL_MEM_MALLOC_HUGE_ONLY_P2P, 4);
assert_eq!(ACL_MEM_MALLOC_NORMAL_ONLY_P2P, 5);
assert_eq!(ACL_MEM_MALLOC_HUGE1G_ONLY, 6);
assert_eq!(ACL_MEM_MALLOC_HUGE1G_ONLY_P2P, 7);
assert_eq!(ACL_MEM_TYPE_LOW_BAND_WIDTH, 0x0100);
assert_eq!(ACL_MEM_TYPE_HIGH_BAND_WIDTH, 0x1000);
assert_eq!(ACL_MEM_ACCESS_USER_SPACE_READONLY, 0x100000);
}
#[test]
fn test_memcpy_kind_constants() {
assert_eq!(ACL_MEMCPY_HOST_TO_HOST, 0);
assert_eq!(ACL_MEMCPY_HOST_TO_DEVICE, 1);
assert_eq!(ACL_MEMCPY_DEVICE_TO_HOST, 2);
assert_eq!(ACL_MEMCPY_DEVICE_TO_DEVICE, 3);
assert_eq!(ACL_MEMCPY_DEFAULT, 4);
assert_eq!(ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE, 5);
assert_eq!(ACL_MEMCPY_INNER_DEVICE_TO_DEVICE, 6);
assert_eq!(ACL_MEMCPY_INTER_DEVICE_TO_DEVICE, 7);
}
}
#[cfg(all(cann_sys_ffi, test))]
mod ffi_tests {
use super::*;
use crate::acl_base_rt::ACL_SUCCESS;
use crate::acl_rt::{aclFinalize, aclInit};
use std::ffi::c_void;
const BUF_SIZE: usize = 64;
#[test]
#[ignore = "requires NPU driver"]
fn test_rt_malloc_free_roundtrip() {
let ret = unsafe { aclInit(std::ptr::null()) };
assert_eq!(ret, ACL_SUCCESS);
let mut dev_ptr: *mut c_void = std::ptr::null_mut();
let ret = unsafe { aclrtMalloc(&mut dev_ptr, BUF_SIZE, ACL_MEM_MALLOC_HUGE_FIRST) };
assert_eq!(ret, ACL_SUCCESS);
assert!(!dev_ptr.is_null());
let ret = unsafe { aclrtFree(dev_ptr) };
assert_eq!(ret, ACL_SUCCESS);
unsafe { aclFinalize(0) };
}
#[test]
#[ignore = "requires NPU driver"]
fn test_rt_malloc_host_free_roundtrip() {
let ret = unsafe { aclInit(std::ptr::null()) };
assert_eq!(ret, ACL_SUCCESS);
let mut host_ptr: *mut c_void = std::ptr::null_mut();
let ret = unsafe { aclrtMallocHost(&mut host_ptr, BUF_SIZE) };
assert_eq!(ret, ACL_SUCCESS);
assert!(!host_ptr.is_null());
let ret = unsafe { aclrtFreeHost(host_ptr) };
assert_eq!(ret, ACL_SUCCESS);
unsafe { aclFinalize(0) };
}
#[test]
#[ignore = "requires NPU driver"]
fn test_rt_memcpy_host_device_roundtrip() {
let ret = unsafe { aclInit(std::ptr::null()) };
assert_eq!(ret, ACL_SUCCESS);
let mut src_ptr: *mut c_void = std::ptr::null_mut();
let mut dst_ptr: *mut c_void = std::ptr::null_mut();
let mut dev_ptr: *mut c_void = std::ptr::null_mut();
let ret = unsafe { aclrtMallocHost(&mut src_ptr, BUF_SIZE) };
assert_eq!(ret, ACL_SUCCESS);
let ret = unsafe { aclrtMallocHost(&mut dst_ptr, BUF_SIZE) };
assert_eq!(ret, ACL_SUCCESS);
let ret = unsafe { aclrtMalloc(&mut dev_ptr, BUF_SIZE, ACL_MEM_MALLOC_HUGE_FIRST) };
assert_eq!(ret, ACL_SUCCESS);
let src = unsafe { std::slice::from_raw_parts_mut(src_ptr.cast::<u8>(), BUF_SIZE) };
for (i, b) in src.iter_mut().enumerate() {
*b = i as u8;
}
let ret = unsafe {
aclrtMemcpy(
dev_ptr,
BUF_SIZE,
src_ptr,
BUF_SIZE,
ACL_MEMCPY_HOST_TO_DEVICE,
)
};
assert_eq!(ret, ACL_SUCCESS);
let ret = unsafe {
aclrtMemcpy(
dst_ptr,
BUF_SIZE,
dev_ptr,
BUF_SIZE,
ACL_MEMCPY_DEVICE_TO_HOST,
)
};
assert_eq!(ret, ACL_SUCCESS);
let dst = unsafe { std::slice::from_raw_parts(dst_ptr.cast::<u8>(), BUF_SIZE) };
assert_eq!(dst, src);
let ret = unsafe { aclrtFreeHost(dst_ptr) };
assert_eq!(ret, ACL_SUCCESS);
let ret = unsafe { aclrtFreeHost(src_ptr) };
assert_eq!(ret, ACL_SUCCESS);
let ret = unsafe { aclrtFree(dev_ptr) };
assert_eq!(ret, ACL_SUCCESS);
unsafe { aclFinalize(0) };
}
}