rfann 0.1.0

A pure Rust implementation of the Fast Artificial Neural Network (FANN) library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! WebGPU compute backend for rfann neural networks
//!
//! This module provides GPU acceleration for neural network operations using WebGPU.
//! It includes automatic fallback to SIMD/CPU backends when GPU is unavailable.
//!
//! Advanced features:
//! - Pipeline caching for optimized shader compilation
//! - Kernel optimization for different GPU architectures
//! - Performance monitoring and auto-tuning
//! - Comprehensive gradient operations for training
//! - Advanced 5-tier buffer pooling system
//! - Real-time memory pressure monitoring
//! - Circuit breaker protection and predictive analytics

pub mod backend;
pub mod compute_context;
pub mod error;
pub mod fallback;
pub mod memory;
pub mod shaders;

// Enhanced memory management components
pub mod buffer_pool;
pub mod pressure_monitor;

// Advanced shader system components
pub mod kernel_optimizer;
pub mod performance_monitor;
pub mod pipeline_cache;

#[cfg(any(feature = "gpu", feature = "webgpu"))]
pub mod webgpu_backend;

#[cfg(any(feature = "gpu", feature = "webgpu"))]
pub mod device;

// WASM GPU bridge for browser deployment
#[cfg(all(target_arch = "wasm32", feature = "webgpu"))]
pub mod wasm_gpu_bridge;

// Re-export main types
pub use backend::{BackendSelector, ComputeProfile};
pub use compute_context::{ComputeContext, ComputePerformanceStats};
pub use error::ComputeError;
pub use fallback::FallbackManager;
pub use memory::{BufferHandle, MemoryStats};

// Re-export enhanced memory management
pub use buffer_pool::{
    AdvancedBufferPool, BufferCategory, GpuBuffer as AdvancedGpuBuffer, MemoryPressure,
    PoolStatisticsSnapshot,
};
pub use pressure_monitor::{
    MemoryPressureMonitor, MonitorConfig, MonitoringReport, MonitoringStatistics, PressureReading,
};
// Enhanced memory types are now in memory module
pub use memory::{
    EnhancedGpuMemoryManager, EnhancedMemoryStats, GpuMemoryConfig, GpuMemoryManager,
    GpuMemoryManagerEnhanced, OptimizationResult, WebGPUMemoryManager,
};

// Re-export advanced shader system components
pub use kernel_optimizer::{GpuCapabilities, KernelConfig, KernelOptimizer, OptimizationMetrics};
pub use performance_monitor::{
    PerformanceAlert, PerformanceMeasurement, PerformanceMonitor, PerformanceStats,
};
pub use pipeline_cache::{CacheStats, CompilationStats, PipelineCache};

// Re-export traits
pub use backend::{BackendCapabilities, BackendType, MatrixSize, OperationType};
pub use backend::{ComputeBackend, MemoryManager, VectorOps};

// Re-export WebGPU backend when available
#[cfg(any(feature = "gpu", feature = "webgpu"))]
pub use webgpu_backend::WebGPUBackend;

#[cfg(any(feature = "gpu", feature = "webgpu"))]
pub use shaders::*;

#[cfg(any(feature = "gpu", feature = "webgpu"))]
pub use device::GpuDevice;

// Re-export WASM GPU bridge for browser deployment
#[cfg(all(target_arch = "wasm32", feature = "webgpu"))]
pub use wasm_gpu_bridge::{
    BrowserCompatibility, CrossOriginManager, SharedBuffer, WasmGpuBridge, WasmMemoryManager,
    WasmPerformanceMonitor, WebGpuContext,
};

/// Check if enhanced memory management features are available
pub fn has_enhanced_memory_features() -> bool {
    cfg!(feature = "gpu")
}

/// Get memory management capabilities summary
pub fn get_memory_capabilities() -> MemoryCapabilities {
    MemoryCapabilities {
        webgpu_available: cfg!(feature = "gpu"),
        enhanced_features: has_enhanced_memory_features(),
        pressure_monitoring: cfg!(feature = "gpu"),
        circuit_breaker: cfg!(feature = "gpu"),
        buffer_pooling: true,
        predictive_analytics: cfg!(feature = "gpu"),
        wasm_gpu_bridge: has_wasm_gpu_bridge(),
    }
}

/// Check if WASM GPU bridge is available
#[cfg(target_arch = "wasm32")]
pub fn has_wasm_gpu_bridge() -> bool {
    cfg!(feature = "wasm-gpu")
}

#[cfg(not(target_arch = "wasm32"))]
pub fn has_wasm_gpu_bridge() -> bool {
    false
}

/// Memory management capabilities
#[derive(Debug, Clone)]
pub struct MemoryCapabilities {
    pub webgpu_available: bool,
    pub enhanced_features: bool,
    pub pressure_monitoring: bool,
    pub circuit_breaker: bool,
    pub buffer_pooling: bool,
    pub predictive_analytics: bool,
    pub wasm_gpu_bridge: bool,
}

impl MemoryCapabilities {
    /// Get capabilities summary string
    pub fn summary(&self) -> String {
        let features = [
            ("WebGPU", self.webgpu_available),
            ("Enhanced Features", self.enhanced_features),
            ("Pressure Monitoring", self.pressure_monitoring),
            ("Circuit Breaker", self.circuit_breaker),
            ("Buffer Pooling", self.buffer_pooling),
            ("Predictive Analytics", self.predictive_analytics),
            ("WASM GPU Bridge", self.wasm_gpu_bridge),
        ];

        let enabled: Vec<&str> = features
            .iter()
            .filter_map(|(name, enabled)| if *enabled { Some(*name) } else { None })
            .collect();

        format!("Memory Capabilities: {}", enabled.join(", "))
    }
}

// Tests
#[cfg(test)]
mod tests;