torsh_graph/

jit.rs

//! Just-In-Time compilation for graph kernels
//!
//! This module provides JIT compilation capabilities for graph neural network
//! operations, enabling runtime optimization and kernel fusion for better performance.
// Framework infrastructure - components designed for future use
#![allow(dead_code)]
/// Crate-local result alias: the error type defaults to [`TorshError`],
/// so both `Result<T>` and `Result<T, OtherError>` stay valid.
type Result<T, E = torsh_core::error::TorshError> = std::result::Result<T, E>;

use crate::{GraphData, GraphLayer};
use std::collections::HashMap;
use std::fmt;
use torsh_tensor::Tensor;

/// JIT compilation backend types
#[derive(Debug, Clone, PartialEq)]
pub enum JITBackend {
    /// LLVM-based compilation
    LLVM,
    /// CPU-specific optimizations
    CPU,
    /// CUDA kernel compilation
    CUDA,
    /// WebAssembly compilation
    WASM,
}

/// JIT kernel optimization levels
#[derive(Debug, Clone, PartialEq)]
pub enum OptimizationLevel {
    /// No optimization (debug builds)
    O0,
    /// Basic optimization
    O1,
    /// Standard optimization
    O2,
    /// Aggressive optimization
    O3,
}

/// Graph operation types that can be JIT compiled
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum GraphOperation {
    /// Matrix multiplication in message passing
    MessagePassing,
    /// Graph convolution operations
    GraphConvolution,
    /// Attention mechanism computation
    AttentionComputation,
    /// Pooling operations
    GraphPooling,
    /// Activation functions
    Activation,
    /// Normalization operations
    Normalization,
    /// Custom fused operations
    CustomFused(String),
}

/// JIT compiled kernel representation
#[derive(Debug, Clone)]
pub struct CompiledKernel {
    /// Unique identifier for the kernel
    pub id: String,
    /// Operation type
    pub operation: GraphOperation,
    /// Compiled kernel code (platform-specific)
    pub kernel_code: Vec<u8>,
    /// Kernel metadata
    pub metadata: KernelMetadata,
    /// Input signature
    pub input_signature: Vec<TensorSignature>,
    /// Output signature
    pub output_signature: Vec<TensorSignature>,
}

/// Kernel compilation metadata
#[derive(Debug, Clone)]
pub struct KernelMetadata {
    /// Compilation backend used
    pub backend: JITBackend,
    /// Optimization level
    pub optimization_level: OptimizationLevel,
    /// Compilation time in milliseconds
    pub compilation_time_ms: u64,
    /// Expected performance gain
    pub performance_gain_estimate: f32,
    /// Memory usage estimate
    pub memory_usage_bytes: usize,
}

/// Tensor signature for type checking
#[derive(Debug, Clone, PartialEq)]
pub struct TensorSignature {
    /// Tensor shape (None for dynamic dimensions)
    pub shape: Vec<Option<usize>>,
    /// Data type
    pub dtype: String,
    /// Device placement
    pub device: String,
}

/// JIT compiler for graph operations
#[derive(Debug)]
pub struct GraphJITCompiler {
    /// Available backends
    pub backends: Vec<JITBackend>,
    /// Default optimization level
    pub default_opt_level: OptimizationLevel,
    /// Compiled kernel cache
    pub kernel_cache: HashMap<String, CompiledKernel>,
    /// Compilation statistics
    pub stats: CompilationStats,
    /// Kernel fusion rules
    pub fusion_rules: Vec<FusionRule>,
}

impl GraphJITCompiler {
    /// Create a new JIT compiler
    pub fn new() -> Self {
        Self {
            backends: vec![JITBackend::CPU, JITBackend::LLVM],
            default_opt_level: OptimizationLevel::O2,
            kernel_cache: HashMap::new(),
            stats: CompilationStats::new(),
            fusion_rules: Vec::new(),
        }
    }

    /// Add a backend to the compiler
    pub fn add_backend(&mut self, backend: JITBackend) {
        if !self.backends.contains(&backend) {
            self.backends.push(backend);
        }
    }

    /// Compile a graph operation to optimized kernel
    pub fn compile_operation(
        &mut self,
        operation: GraphOperation,
        input_shapes: &[Vec<usize>],
        backend: Option<JITBackend>,
    ) -> Result<CompiledKernel, JITError> {
        let backend = backend.unwrap_or_else(|| self.select_best_backend(&operation));
        let kernel_id = self.generate_kernel_id(&operation, input_shapes, &backend);

        // Check cache first
        if let Some(cached_kernel) = self.kernel_cache.get(&kernel_id) {
            self.stats.cache_hits += 1;
            return Ok(cached_kernel.clone());
        }

        self.stats.cache_misses += 1;
        let start_time = std::time::Instant::now();

        // Generate kernel code based on operation and backend
        let kernel_code = self.generate_kernel_code(&operation, input_shapes, &backend)?;

        // Create input/output signatures
        let input_signature = self.create_input_signature(input_shapes);
        let output_signature = self.create_output_signature(&operation, input_shapes);

        let compilation_time = start_time.elapsed().as_millis() as u64;

        let metadata = KernelMetadata {
            backend: backend.clone(),
            optimization_level: self.default_opt_level.clone(),
            compilation_time_ms: compilation_time,
            performance_gain_estimate: self.estimate_performance_gain(&operation, &backend),
            memory_usage_bytes: self.estimate_memory_usage(&operation, input_shapes),
        };

        let compiled_kernel = CompiledKernel {
            id: kernel_id.clone(),
            operation,
            kernel_code,
            metadata,
            input_signature,
            output_signature,
        };

        // Cache the compiled kernel
        self.kernel_cache.insert(kernel_id, compiled_kernel.clone());
        self.stats.total_compilations += 1;

        Ok(compiled_kernel)
    }

    /// Execute a compiled kernel with given inputs
    pub fn execute_kernel(
        &self,
        kernel: &CompiledKernel,
        inputs: &[Tensor],
    ) -> Result<Vec<Tensor>, JITError> {
        // Validate input signatures
        self.validate_inputs(kernel, inputs)?;

        // Execute based on backend
        match kernel.metadata.backend {
            JITBackend::CPU => self.execute_cpu_kernel(kernel, inputs),
            JITBackend::LLVM => self.execute_llvm_kernel(kernel, inputs),
            JITBackend::CUDA => self.execute_cuda_kernel(kernel, inputs),
            JITBackend::WASM => self.execute_wasm_kernel(kernel, inputs),
        }
    }

    /// Analyze and fuse multiple operations for better performance
    pub fn fuse_operations(
        &mut self,
        operations: &[GraphOperation],
        input_shapes: &[Vec<usize>],
    ) -> Result<CompiledKernel, JITError> {
        // Analyze fusion opportunities
        let _fusion_plan = self.analyze_fusion_opportunities(operations)?;

        // Generate fused operation name
        let fused_name = format!(
            "fused_{}",
            operations
                .iter()
                .map(|op| format!("{:?}", op))
                .collect::<Vec<_>>()
                .join("_")
        );

        let fused_operation = GraphOperation::CustomFused(fused_name);

        // Compile the fused operation
        self.compile_operation(fused_operation, input_shapes, None)
    }

    /// Get compilation statistics
    pub fn get_stats(&self) -> &CompilationStats {
        &self.stats
    }

    /// Clear the kernel cache
    pub fn clear_cache(&mut self) {
        self.kernel_cache.clear();
        self.stats.cache_clears += 1;
    }

    // Internal helper methods

    fn select_best_backend(&self, operation: &GraphOperation) -> JITBackend {
        // Select the best backend based on operation characteristics
        match operation {
            GraphOperation::MessagePassing | GraphOperation::GraphConvolution => {
                if self.backends.contains(&JITBackend::CUDA) {
                    JITBackend::CUDA
                } else {
                    JITBackend::CPU
                }
            }
            GraphOperation::AttentionComputation => {
                if self.backends.contains(&JITBackend::LLVM) {
                    JITBackend::LLVM
                } else {
                    JITBackend::CPU
                }
            }
            _ => JITBackend::CPU,
        }
    }

    fn generate_kernel_id(
        &self,
        operation: &GraphOperation,
        input_shapes: &[Vec<usize>],
        backend: &JITBackend,
    ) -> String {
        format!(
            "{:?}_{:?}_{:?}_{:?}",
            operation, input_shapes, backend, self.default_opt_level
        )
    }

    fn generate_kernel_code(
        &self,
        operation: &GraphOperation,
        input_shapes: &[Vec<usize>],
        backend: &JITBackend,
    ) -> Result<Vec<u8>, JITError> {
        match backend {
            JITBackend::CPU => self.generate_cpu_code(operation, input_shapes),
            JITBackend::LLVM => self.generate_llvm_code(operation, input_shapes),
            JITBackend::CUDA => self.generate_cuda_code(operation, input_shapes),
            JITBackend::WASM => self.generate_wasm_code(operation, input_shapes),
        }
    }

    fn generate_cpu_code(
        &self,
        operation: &GraphOperation,
        _input_shapes: &[Vec<usize>],
    ) -> Result<Vec<u8>, JITError> {
        // Generate optimized CPU C source for the operations we have kernels
        // for. Operations without a real kernel return an honest
        // `UnsupportedOperation` error rather than emitting a placeholder
        // comment string that pretends to be a compiled kernel.
        let code = match operation {
            GraphOperation::MessagePassing => {
                // Optimized message passing kernel
                "
                // Optimized CPU kernel for message passing
                void message_passing_kernel(float* node_features, int* edge_index, float* output) {
                    // Vectorized message passing implementation
                    #pragma omp parallel for simd
                    for (int i = 0; i < num_edges; i++) {
                        int src = edge_index[i];
                        int dst = edge_index[i + num_edges];
                        // Accumulate messages with SIMD
                        __m256 src_vec = _mm256_load_ps(&node_features[src * feature_dim]);
                        __m256 dst_vec = _mm256_load_ps(&output[dst * feature_dim]);
                        dst_vec = _mm256_add_ps(dst_vec, src_vec);
                        _mm256_store_ps(&output[dst * feature_dim], dst_vec);
                    }
                }
                "
            }
            GraphOperation::GraphConvolution => {
                // Optimized graph convolution kernel
                "
                // Optimized CPU kernel for graph convolution
                void graph_conv_kernel(float* features, float* weight, int* edge_index, float* output) {
                    // Fused convolution and aggregation
                    #pragma omp parallel for
                    for (int node = 0; node < num_nodes; node++) {
                        // Zero output
                        memset(&output[node * out_dim], 0, out_dim * sizeof(float));

                        // Aggregate from neighbors
                        for (int edge = 0; edge < num_edges; edge++) {
                            if (edge_index[edge + num_edges] == node) {
                                int neighbor = edge_index[edge];
                                // BLAS-optimized matrix-vector multiplication
                                cblas_sgemv(CblasRowMajor, CblasNoTrans,
                                          out_dim, in_dim, 1.0f,
                                          weight, in_dim,
                                          &features[neighbor * in_dim], 1,
                                          1.0f, &output[node * out_dim], 1);
                            }
                        }
                    }
                }
                "
            }
            other => {
                return Err(JITError::UnsupportedOperation(other.clone()));
            }
        };

        Ok(code.as_bytes().to_vec())
    }

    fn generate_llvm_code(
        &self,
        operation: &GraphOperation,
        _input_shapes: &[Vec<usize>],
    ) -> Result<Vec<u8>, JITError> {
        // Generate LLVM IR for operations we have a real lowering for.
        // Anything else returns an honest `UnsupportedOperation` error instead
        // of a placeholder IR comment.
        let llvm_ir = match operation {
            GraphOperation::AttentionComputation => {
                r#"
                ; LLVM IR for optimized attention computation
                define void @attention_kernel(float* %queries, float* %keys, float* %values,
                                            float* %output, i32 %seq_len, i32 %head_dim) {
                entry:
                  ; Vectorized attention computation with loop unrolling
                  br label %loop.header

                loop.header:
                  %i = phi i32 [ 0, %entry ], [ %i.next, %loop.body ]
                  %cmp = icmp ult i32 %i, %seq_len
                  br i1 %cmp, label %loop.body, label %exit

                loop.body:
                  ; Optimized dot product with SIMD
                  %q_ptr = getelementptr float, float* %queries, i32 %i
                  %score = call float @simd_dot_product(float* %q_ptr, float* %keys, i32 %head_dim)

                  ; Apply softmax and value aggregation
                  %weighted_value = call float @apply_attention(float %score, float* %values, i32 %head_dim)
                  %out_ptr = getelementptr float, float* %output, i32 %i
                  store float %weighted_value, float* %out_ptr

                  %i.next = add i32 %i, 1
                  br label %loop.header

                exit:
                  ret void
                }

                declare float @simd_dot_product(float*, float*, i32)
                declare float @apply_attention(float, float*, i32)
                "#
            }
            other => {
                return Err(JITError::UnsupportedOperation(other.clone()));
            }
        };

        Ok(llvm_ir.as_bytes().to_vec())
    }

    fn generate_cuda_code(
        &self,
        operation: &GraphOperation,
        _input_shapes: &[Vec<usize>],
    ) -> Result<Vec<u8>, JITError> {
        // Generate CUDA kernel source for operations we have a real kernel for.
        // Anything else returns an honest `UnsupportedOperation` error instead
        // of a placeholder comment string.
        let cuda_code = match operation {
            GraphOperation::MessagePassing => {
                "
                __global__ void message_passing_cuda_kernel(
                    float* node_features,
                    int* edge_index,
                    float* output,
                    int num_nodes,
                    int num_edges,
                    int feature_dim
                ) {
                    int tid = blockIdx.x * blockDim.x + threadIdx.x;
                    int stride = blockDim.x * gridDim.x;

                    // Coalesced memory access pattern
                    for (int edge = tid; edge < num_edges; edge += stride) {
                        int src = edge_index[edge];
                        int dst = edge_index[edge + num_edges];

                        // Vectorized feature aggregation
                        for (int f = 0; f < feature_dim; f += 4) {
                            float4 src_feat = reinterpret_cast<float4*>(&node_features[src * feature_dim + f])[0];
                            float4 dst_feat = reinterpret_cast<float4*>(&output[dst * feature_dim + f])[0];

                            dst_feat.x += src_feat.x;
                            dst_feat.y += src_feat.y;
                            dst_feat.z += src_feat.z;
                            dst_feat.w += src_feat.w;

                            reinterpret_cast<float4*>(&output[dst * feature_dim + f])[0] = dst_feat;
                        }
                    }
                }
                "
            }
            other => {
                return Err(JITError::UnsupportedOperation(other.clone()));
            }
        };

        Ok(cuda_code.as_bytes().to_vec())
    }

    fn generate_wasm_code(
        &self,
        operation: &GraphOperation,
        _input_shapes: &[Vec<usize>],
    ) -> Result<Vec<u8>, JITError> {
        // No real WebAssembly lowering exists for any graph operation yet. The
        // previous implementation emitted a trivial module that returned the
        // constant 42 for *every* operation, which is a fabricated kernel.
        // Return an honest error instead so callers do not run nonsense code.
        Err(JITError::UnsupportedOperation(operation.clone()))
    }

    fn create_input_signature(&self, input_shapes: &[Vec<usize>]) -> Vec<TensorSignature> {
        input_shapes
            .iter()
            .map(|shape| TensorSignature {
                shape: shape.iter().map(|&s| Some(s)).collect(),
                dtype: "f32".to_string(),
                device: "cpu".to_string(),
            })
            .collect()
    }

    fn create_output_signature(
        &self,
        operation: &GraphOperation,
        input_shapes: &[Vec<usize>],
    ) -> Vec<TensorSignature> {
        // Infer output shapes based on operation
        match operation {
            GraphOperation::MessagePassing => {
                if !input_shapes.is_empty() {
                    vec![TensorSignature {
                        shape: input_shapes[0].iter().map(|&s| Some(s)).collect(),
                        dtype: "f32".to_string(),
                        device: "cpu".to_string(),
                    }]
                } else {
                    vec![]
                }
            }
            _ => vec![TensorSignature {
                shape: vec![None, None], // Dynamic shape
                dtype: "f32".to_string(),
                device: "cpu".to_string(),
            }],
        }
    }

    fn estimate_performance_gain(&self, operation: &GraphOperation, backend: &JITBackend) -> f32 {
        // Estimate performance improvement over non-JIT implementation
        match (operation, backend) {
            (GraphOperation::MessagePassing, JITBackend::CUDA) => 10.0,
            (GraphOperation::GraphConvolution, JITBackend::CUDA) => 8.0,
            (GraphOperation::AttentionComputation, JITBackend::LLVM) => 5.0,
            (_, JITBackend::CPU) => 2.0,
            _ => 1.5,
        }
    }

    fn estimate_memory_usage(
        &self,
        operation: &GraphOperation,
        input_shapes: &[Vec<usize>],
    ) -> usize {
        // Estimate memory usage in bytes
        let total_elements: usize = input_shapes
            .iter()
            .map(|shape| shape.iter().product::<usize>())
            .sum();
        match operation {
            GraphOperation::AttentionComputation => total_elements * 16, // Higher memory for attention
            _ => total_elements * 4,                                     // 4 bytes per f32
        }
    }

    fn validate_inputs(&self, kernel: &CompiledKernel, inputs: &[Tensor]) -> Result<(), JITError> {
        if inputs.len() != kernel.input_signature.len() {
            return Err(JITError::SignatureMismatch(format!(
                "Expected {} inputs, got {}",
                kernel.input_signature.len(),
                inputs.len()
            )));
        }

        // Additional shape and type validation would go here
        Ok(())
    }

    fn execute_cpu_kernel(
        &self,
        kernel: &CompiledKernel,
        _inputs: &[Tensor],
    ) -> Result<Vec<Tensor>, JITError> {
        // The CPU backend currently generates kernel *source* but does not yet
        // compile and run it (no in-process C/JIT compiler is wired). Returning
        // the inputs unchanged would silently masquerade as a real computation,
        // so report an honest execution error instead.
        Err(JITError::ExecutionFailed(format!(
            "CPU kernel '{}' was generated but no runtime compiler is wired to execute it",
            kernel.id
        )))
    }

    fn execute_llvm_kernel(
        &self,
        kernel: &CompiledKernel,
        _inputs: &[Tensor],
    ) -> Result<Vec<Tensor>, JITError> {
        // LLVM IR is generated but no LLVM execution engine is linked in yet.
        Err(JITError::ExecutionFailed(format!(
            "LLVM kernel '{}' was generated but no LLVM execution engine is wired to run it",
            kernel.id
        )))
    }

    fn execute_cuda_kernel(
        &self,
        kernel: &CompiledKernel,
        _inputs: &[Tensor],
    ) -> Result<Vec<Tensor>, JITError> {
        // CUDA source is generated but no NVRTC/driver launch path is wired.
        Err(JITError::ExecutionFailed(format!(
            "CUDA kernel '{}' was generated but no CUDA launch path is wired to run it",
            kernel.id
        )))
    }

    fn execute_wasm_kernel(
        &self,
        kernel: &CompiledKernel,
        _inputs: &[Tensor],
    ) -> Result<Vec<Tensor>, JITError> {
        // No WebAssembly runtime is wired to execute generated modules.
        Err(JITError::ExecutionFailed(format!(
            "WASM kernel '{}' cannot be executed: no WebAssembly runtime is wired",
            kernel.id
        )))
    }

    fn analyze_fusion_opportunities(
        &self,
        operations: &[GraphOperation],
    ) -> Result<FusionPlan, JITError> {
        // Analyze which operations can be fused together
        Ok(FusionPlan {
            operations: operations.to_vec(),
            fusion_points: vec![],
            estimated_speedup: 1.5,
        })
    }
}

impl Default for GraphJITCompiler {
    fn default() -> Self {
        Self::new()
    }
}

/// Compilation statistics
#[derive(Debug, Clone)]
pub struct CompilationStats {
    pub total_compilations: u64,
    pub cache_hits: u64,
    pub cache_misses: u64,
    pub cache_clears: u64,
    pub total_compilation_time_ms: u64,
    pub average_compilation_time_ms: f64,
}

impl CompilationStats {
    pub fn new() -> Self {
        Self {
            total_compilations: 0,
            cache_hits: 0,
            cache_misses: 0,
            cache_clears: 0,
            total_compilation_time_ms: 0,
            average_compilation_time_ms: 0.0,
        }
    }
}

/// Kernel fusion rule
#[derive(Debug, Clone)]
pub struct FusionRule {
    pub pattern: Vec<GraphOperation>,
    pub fused_name: String,
    pub expected_speedup: f32,
}

/// Fusion analysis result
#[derive(Debug, Clone)]
pub struct FusionPlan {
    pub operations: Vec<GraphOperation>,
    pub fusion_points: Vec<usize>,
    pub estimated_speedup: f32,
}

/// JIT compilation errors
#[derive(Debug, Clone)]
pub enum JITError {
    /// Backend not available
    BackendNotAvailable(JITBackend),
    /// Compilation failed
    CompilationFailed(String),
    /// Input signature mismatch
    SignatureMismatch(String),
    /// Kernel execution failed
    ExecutionFailed(String),
    /// Operation not supported
    UnsupportedOperation(GraphOperation),
}

impl fmt::Display for JITError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            JITError::BackendNotAvailable(backend) => {
                write!(f, "Backend {:?} is not available", backend)
            }
            JITError::CompilationFailed(msg) => write!(f, "Compilation failed: {}", msg),
            JITError::SignatureMismatch(msg) => write!(f, "Signature mismatch: {}", msg),
            JITError::ExecutionFailed(msg) => write!(f, "Execution failed: {}", msg),
            JITError::UnsupportedOperation(op) => write!(f, "Unsupported operation: {:?}", op),
        }
    }
}

impl std::error::Error for JITError {}

/// JIT-optimized graph layer that automatically compiles operations
#[derive(Debug)]
pub struct JITGraphLayer {
    /// Underlying layer implementation
    pub base_layer: Box<dyn GraphLayer>,
    /// JIT compiler instance
    pub compiler: GraphJITCompiler,
    /// Cached compiled operations
    pub compiled_ops: HashMap<String, CompiledKernel>,
    /// Enable/disable JIT compilation
    pub jit_enabled: bool,
}

impl JITGraphLayer {
    /// Create a new JIT-optimized layer
    pub fn new(base_layer: Box<dyn GraphLayer>) -> Self {
        Self {
            base_layer,
            compiler: GraphJITCompiler::new(),
            compiled_ops: HashMap::new(),
            jit_enabled: true,
        }
    }

    /// Enable or disable JIT compilation
    pub fn set_jit_enabled(&mut self, enabled: bool) {
        self.jit_enabled = enabled;
    }

    /// Warmup compilation for expected input shapes
    pub fn warmup(&mut self, input_shapes: &[Vec<usize>]) -> Result<(), JITError> {
        if !self.jit_enabled {
            return Ok(());
        }

        // Pre-compile common operations
        let operations = vec![
            GraphOperation::MessagePassing,
            GraphOperation::GraphConvolution,
            GraphOperation::AttentionComputation,
        ];

        for op in operations {
            let kernel = self.compiler.compile_operation(op, input_shapes, None)?;
            self.compiled_ops.insert(kernel.id.clone(), kernel);
        }

        Ok(())
    }
}

impl GraphLayer for JITGraphLayer {
    fn forward(&self, graph: &GraphData) -> Result<GraphData> {
        if self.jit_enabled {
            // Try to use JIT-compiled operations
            // This is a simplified implementation
            // In practice, would analyze the computation graph and apply JIT compilation
        }

        // Fallback to base layer
        self.base_layer.forward(graph)
    }

    fn parameters(&self) -> Vec<Tensor> {
        self.base_layer.parameters()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_jit_compiler_creation() {
        let compiler = GraphJITCompiler::new();
        assert_eq!(compiler.default_opt_level, OptimizationLevel::O2);
        assert!(compiler.backends.contains(&JITBackend::CPU));
    }

    #[test]
    fn test_backend_selection() {
        let compiler = GraphJITCompiler::new();
        let backend = compiler.select_best_backend(&GraphOperation::MessagePassing);
        assert_eq!(backend, JITBackend::CPU); // Should select CPU for basic setup
    }

    #[test]
    fn test_kernel_id_generation() {
        let compiler = GraphJITCompiler::new();
        let id = compiler.generate_kernel_id(
            &GraphOperation::MessagePassing,
            &[vec![10, 5]],
            &JITBackend::CPU,
        );
        assert!(id.contains("MessagePassing"));
        assert!(id.contains("CPU"));
    }

    #[test]
    fn test_performance_estimation() {
        let compiler = GraphJITCompiler::new();
        let gain =
            compiler.estimate_performance_gain(&GraphOperation::MessagePassing, &JITBackend::CUDA);
        assert_eq!(gain, 10.0);
    }

    #[test]
    fn test_memory_estimation() {
        let compiler = GraphJITCompiler::new();
        let memory =
            compiler.estimate_memory_usage(&GraphOperation::MessagePassing, &[vec![100, 50]]);
        assert_eq!(memory, 100 * 50 * 4); // 100*50 elements * 4 bytes per f32
    }

    #[test]
    fn test_tensor_signature() {
        let sig = TensorSignature {
            shape: vec![Some(10), Some(5)],
            dtype: "f32".to_string(),
            device: "cpu".to_string(),
        };
        assert_eq!(sig.shape.len(), 2);
        assert_eq!(sig.dtype, "f32");
    }

    #[test]
    fn test_compilation_stats() {
        let stats = CompilationStats::new();
        assert_eq!(stats.total_compilations, 0);
        assert_eq!(stats.cache_hits, 0);
    }
}