#![allow(unused_imports, dead_code, unused_variables)]
use mumu::parser::types::{Value, TensorValue};
use mumu::parser::interpreter::Interpreter;
use crate::vulkan::VULKAN_CONTEXT;
use crate::operators::elementwise::{elementwise_op, ensure_f32_tensor};
use crate::operators::to_tensor::{gpu_to_tensor_bridge, gpu_to_array_bridge};
#[cfg(debug_assertions)]
use crate::debug::set_last_call_info;
#[cfg(debug_assertions)]
macro_rules! set_last_call_info {
($op:expr, $used:expr) => { crate::debug::set_last_call_info($op, $used); };
}
#[cfg(not(debug_assertions))]
macro_rules! set_last_call_info {
($op:expr, $used:expr) => {};
}
fn try_get_vulkan_ctx() -> Option<std::sync::MutexGuard<'static, Option<crate::vulkan::AshVulkanContext>>> {
VULKAN_CONTEXT.try_lock().ok()
}
pub fn gpu_multiply_bridge(
interp: &mut Interpreter,
args: Vec<Value>
) -> Result<Value, String> {
if args.len() != 2 {
return Err(format!("gpu:multiply => expected 2 arguments, got {}", args.len()));
}
let a = ensure_f32_tensor(&args[0])?;
let b = ensure_f32_tensor(&args[1])?;
if let Some(ctx_lock) = try_get_vulkan_ctx() {
if ctx_lock.is_some() {
if interp.is_verbose() {
eprintln!("[begu:gpu:multiply] => using REAL Vulkan compute pipeline");
}
set_last_call_info!("multiply", true);
return crate::cpu_ops::perform_compute_multiply(ctx_lock.as_ref().unwrap(), a, b);
}
}
if interp.is_verbose() {
eprintln!("[begu:gpu:multiply] => fallback CPU (no real GPU).");
}
set_last_call_info!("multiply", false);
crate::cpu_ops::cpu_matrix_multiply(a, b)
}
pub fn gpu_add_bridge(
interp: &mut Interpreter,
args: Vec<Value>
) -> Result<Value, String> {
if args.len() != 2 {
return Err(format!("gpu:add => expected 2 arguments, got {}", args.len()));
}
let a = ensure_f32_tensor(&args[0])?;
let b = ensure_f32_tensor(&args[1])?;
if let Some(ctx_lock) = try_get_vulkan_ctx() {
if let Some(ctx) = &*ctx_lock {
if interp.is_verbose() {
eprintln!("[begu:gpu:add] => using REAL Vulkan compute pipeline");
}
set_last_call_info!("add", true);
return crate::cpu_ops::perform_compute_add(ctx, a, b);
}
}
if interp.is_verbose() {
eprintln!("[begu:gpu:add] => real GPU path not implemented => fallback CPU");
}
set_last_call_info!("add", false);
elementwise_op(a, b, |x, y| x + y)
}
pub fn gpu_subtract_bridge(
interp: &mut Interpreter,
args: Vec<Value>
) -> Result<Value, String> {
if args.len() != 2 {
return Err(format!("gpu:subtract => expected 2 arguments, got {}", args.len()));
}
let a = ensure_f32_tensor(&args[0])?;
let b = ensure_f32_tensor(&args[1])?;
if let Some(ctx_lock) = try_get_vulkan_ctx() {
if let Some(ctx) = &*ctx_lock {
if interp.is_verbose() {
eprintln!("[begu:gpu:subtract] => using REAL Vulkan compute pipeline");
}
set_last_call_info!("subtract", true);
return crate::cpu_ops::perform_compute_subtract(ctx, a, b);
}
}
if interp.is_verbose() {
eprintln!("[begu:gpu:subtract] => real GPU path not implemented => fallback CPU");
}
set_last_call_info!("subtract", false);
elementwise_op(a, b, |x, y| x - y)
}
pub fn gpu_hadamard_bridge(
interp: &mut Interpreter,
args: Vec<Value>
) -> Result<Value, String> {
if args.len() != 2 {
return Err(format!("gpu:hadamard => expected 2 arguments, got {}", args.len()));
}
let a = ensure_f32_tensor(&args[0])?;
let b = ensure_f32_tensor(&args[1])?;
if let Some(ctx_lock) = try_get_vulkan_ctx() {
if let Some(ctx) = &*ctx_lock {
if interp.is_verbose() {
eprintln!("[begu:gpu:hadamard] => using REAL Vulkan compute pipeline");
}
set_last_call_info!("hadamard", true);
return crate::cpu_ops::perform_compute_hadamard(ctx, a, b);
}
}
if interp.is_verbose() {
eprintln!("[begu:gpu:hadamard] => real GPU path not implemented => fallback CPU");
}
set_last_call_info!("hadamard", false);
elementwise_op(a, b, |x, y| x * y)
}
pub fn gpu_inverse_bridge(
interp: &mut Interpreter,
args: Vec<Value>
) -> Result<Value, String> {
if args.len() != 1 {
return Err(format!("gpu:inverse => expected 1 argument, got {}", args.len()));
}
let t = ensure_f32_tensor(&args[0])?;
if t.shape.len() != 2 || t.shape[0] != 2 || t.shape[1] != 2 {
return Err("gpu:inverse => only 2x2 supported".to_string());
}
if let Some(guard) = try_get_vulkan_ctx() {
if guard.is_some() && interp.is_verbose() {
eprintln!("[begu:gpu:inverse] => real GPU path not implemented => fallback CPU");
}
}
set_last_call_info!("inverse", false);
crate::cpu_ops::cpu_inverse_2x2(t)
}
pub fn gpu_transpose_bridge(
interp: &mut Interpreter,
args: Vec<Value>
) -> Result<Value, String> {
if args.len() != 1 {
return Err(format!("gpu:transpose => expected 1 argument, got {}", args.len()));
}
let t = ensure_f32_tensor(&args[0])?;
if t.shape.len() != 2 {
return Err("gpu:transpose => only rank=2 is currently implemented".to_string());
}
if let Some(ctx_lock) = try_get_vulkan_ctx() {
if let Some(ctx) = &*ctx_lock {
if interp.is_verbose() {
eprintln!("[begu:gpu:transpose] => using REAL Vulkan compute pipeline");
}
set_last_call_info!("transpose", true);
return crate::cpu_ops::perform_compute_transpose(ctx, t);
}
}
if interp.is_verbose() {
eprintln!("[begu:gpu:transpose] => real GPU path not implemented => fallback CPU");
}
set_last_call_info!("transpose", false);
crate::cpu_ops::cpu_transpose_2d(t)
}
pub fn gpu_reduce_sum_bridge(
interp: &mut Interpreter,
args: Vec<Value>
) -> Result<Value, String> {
if args.len() != 1 {
return Err(format!("gpu:reduce_sum => expected 1 argument, got {}", args.len()));
}
let t = ensure_f32_tensor(&args[0])?;
if let Some(guard) = try_get_vulkan_ctx() {
if guard.is_some() && interp.is_verbose() {
eprintln!("[begu:gpu:reduce_sum] => real GPU path not implemented => fallback CPU");
}
}
set_last_call_info!("reduce_sum", false);
crate::cpu_ops::cpu_reduce_sum(t)
}
pub fn gpu_scale_bridge(
interp: &mut Interpreter,
args: Vec<Value>
) -> Result<Value, String> {
if args.len() != 2 {
return Err(format!("gpu:scale => expected 2 arguments: (scalar, tensor), got {}", args.len()));
}
let scalar = match &args[0] {
Value::Int(i) => *i as f32,
Value::Float(ff) => *ff as f32,
_ => return Err("gpu:scale => first arg must be numeric int/float".to_string()),
};
let t = ensure_f32_tensor(&args[1])?;
if let Some(guard) = try_get_vulkan_ctx() {
if guard.is_some() && interp.is_verbose() {
eprintln!("[begu:gpu:scale] => real GPU path not implemented => fallback CPU");
}
}
set_last_call_info!("scale", false);
crate::cpu_ops::cpu_scale_tensor(t, scalar)
}