mumu-gpu 0.1.0

#![allow(unused_imports)]
#![allow(dead_code)]
#![allow(unused_variables)]
#![allow(unused_mut)]
#![allow(unused_assignments)]
#![allow(unused_macros)]

mod vulkan;
mod cpu_ops;
mod registration;
mod debug;

pub mod operators;
pub use operators::{
    gpu_multiply_bridge,
    gpu_add_bridge,
    gpu_subtract_bridge,
    gpu_hadamard_bridge,
    gpu_inverse_bridge,
    gpu_transpose_bridge,
    gpu_reduce_sum_bridge,
    gpu_scale_bridge,
    gpu_to_tensor_bridge,
    gpu_to_array_bridge,
    elementwise_op,
};

pub use vulkan::{AshVulkanContext, VULKAN_CONTEXT};
pub use cpu_ops::*;
pub use registration::register_all_gpu_fns;
#[cfg(debug_assertions)]
pub use debug::gpu_last_call_bridge;

use std::ffi::{c_void, CStr};
use mumu::parser::interpreter::Interpreter;

#[no_mangle]
pub unsafe extern "C" fn Cargo_lock(
    interp_ptr: *mut c_void,
    extra_str: *const c_void,
) -> i32 {
    if interp_ptr.is_null() {
        eprintln!("[gpu] cargo_lock => null interp ptr");
        return 1;
    }
    let interp = &mut *(interp_ptr as *mut Interpreter);

    let desc = if !extra_str.is_null() {
        let c_s = CStr::from_ptr(extra_str as *const i8);
        c_s.to_string_lossy().to_string()
    } else {
        "".to_string()
    };

    if interp.is_verbose() {
        eprintln!("[gpu] cargo_lock => attempt Vulkan init, extra='{}'", desc);
    }
    match vulkan::AshVulkanContext::new() {
        Ok(ctx) => {
            *vulkan::VULKAN_CONTEXT.lock().unwrap() = Some(ctx);
            if interp.is_verbose() {
                eprintln!("[gpu] Using real Vulkan context => success");
            }
        }
        Err(e) => {
            eprintln!("[gpu] Vulkan init failed => fallback CPU => error: {}", e);
            *vulkan::VULKAN_CONTEXT.lock().unwrap() = None;
        }
    }

    registration::register_all_gpu_fns(interp);
    0
}