Method new

cake-core/src/backends/rocm/mod.rs:149–206

()

impl RocmBackend {
    pub fn new() -> std::result::Result<Self, String> {
        let ffi = Box::new(RocmFfi::load()?);

        let err = unsafe { (ffi.hip_init)(0) };
        if err != 0 { return Err(format!("hipInit: error {err}")); }

        // Two-layer defense against HIP's broken atexit cleanup:
        // 1. SIGABRT handler catches abort() from HIP's assertion failures
        // 2. atexit handler terminates before HIP's cleanup runs (LIFO order)
        if !HIP_INITIALIZED.swap(true, Ordering::Relaxed) {
            unsafe {
                let mut sa: libc::sigaction = std::mem::zeroed();
                sa.sa_sigaction = hip_sigabrt_handler as *const () as libc::sighandler_t;
                libc::sigemptyset(&mut sa.sa_mask);
                sa.sa_flags = libc::SA_NODEFER;
                libc::sigaction(libc::SIGABRT, &sa, std::ptr::null_mut());
                libc::atexit(hip_atexit_handler);
            }
        }

        let mut count = 0i32;
        unsafe { (ffi.hip_get_device_count)(&mut count) };
        if count == 0 { return Err("no HIP devices".into()); }

        unsafe { (ffi.hip_set_device)(0) };

        let mut name = [0u8; 256];
        unsafe { (ffi.hip_device_get_name)(name.as_mut_ptr() as *mut i8, 256, 0) };
        let name = std::ffi::CStr::from_bytes_until_nul(&name)
            .unwrap_or_default().to_string_lossy();

        let mut free = 0usize;
        let mut total = 0usize;
        unsafe { (ffi.hip_mem_get_info)(&mut free, &mut total) };

        log::info!("ROCm backend: {} ({:.1} GiB free / {:.1} GiB total)",
            name, free as f64 / 1e9, total as f64 / 1e9);

        let mut handle = std::ptr::null_mut();
        let err = unsafe { (ffi.rocblas_create_handle)(&mut handle) };
        if err != 0 { return Err(format!("rocblas_create_handle: error {err}")); }

        let mut stream = std::ptr::null_mut();
        let err = unsafe { (ffi.hip_stream_create)(&mut stream) };
        if err != 0 { return Err(format!("hipStreamCreate: error {err}")); }

        // Bind stream to rocBLAS for async GEMM
        let err = unsafe { (ffi.rocblas_set_stream)(handle, stream) };
        if err != 0 { return Err(format!("rocblas_set_stream: error {err}")); }

        Ok(Self {
            device: Device::Cpu,
            ffi,
            blas_handle: handle,
            stream,
            cache: RwLock::new(HashMap::with_capacity(64)),
        })
    }