use core::{ffi::CStr, ptr::null_mut};
use alloc::{ffi::CString, rc::Rc};
use rocm_sys::hip::{
hipFunction_t, hipModule_t, hipModuleGetFunction, hipModuleLaunchKernel, hipModuleLoadData,
hipModuleUnload,
};
use crate::{
hip::{HipError, stream::HipStream},
hiprtc::program::Hsaco,
};
#[derive(Clone)]
#[repr(transparent)]
pub struct Module {
inner: Rc<ModuleInner>,
}
impl Module {
pub fn get_func(&self, name: &str) -> Result<Func, HipError> {
let name = CString::new(name).map_err(|_| HipError::InvalidValue)?;
self.get_func_c(&name)
}
pub fn get_func_c(&self, name: &CStr) -> Result<Func, HipError> {
let func: Result<hipFunction_t, HipError> = unsafe {
wrap_sys_res!(|func| hipModuleGetFunction(
(&raw mut func).cast(),
self.inner.raw,
name.as_ptr()
))
};
Ok(Func {
raw: func?,
module: self.clone(),
})
}
#[inline(always)]
pub fn as_raw(&self) -> hipModule_t {
self.inner.raw
}
#[inline(always)]
pub fn into_raw(self) -> hipModule_t {
self.inner.raw
}
}
#[cfg(all(feature = "hiprtc", any(hiprtc, feature = "dynamic-loading")))]
mod hiprtc {
use super::*;
impl Hsaco {
pub fn load(&self) -> Result<Module, HipError> {
Module::load(self)
}
}
impl Module {
pub fn load(code: &Hsaco) -> Result<Self, HipError> {
let module: Result<hipModule_t, HipError> = unsafe {
wrap_sys_res!(|module| hipModuleLoadData(
(&raw mut module).cast(),
code.code.as_ptr().cast()
))
};
let inner = Rc::new(ModuleInner { raw: module? });
Ok(Module { inner })
}
}
}
struct ModuleInner {
raw: hipModule_t,
}
impl Drop for ModuleInner {
fn drop(&mut self) {
unsafe {
hipModuleUnload(self.raw);
}
}
}
#[derive(Clone)]
pub struct Func {
pub(crate) raw: hipFunction_t,
module: Module,
}
impl Func {
#[inline(always)]
pub fn module_handle(&self) -> Module {
self.module.clone()
}
pub fn into_module_handle(self) -> Module {
self.module
}
}
impl HipStream {
pub unsafe fn launch(
&self,
func: &Func,
args: &mut [*mut u8],
conf: LaunchConfig,
) -> Result<(), HipError> {
unsafe {
try_err!(
hipModuleLaunchKernel(
func.raw,
conf.grid[0],
conf.grid[1],
conf.grid[2],
conf.block[0],
conf.block[1],
conf.block[2],
0,
self.raw.raw,
args.as_mut_ptr().cast(),
null_mut(),
),
Ok(())
)
}
}
}
#[derive(Debug, Clone)]
pub struct LaunchConfig {
pub grid: [u32; 3],
pub block: [u32; 3],
}