Initial commit

2026-03-04 00:08:42 +00:00
commit 4d88dc0584
4449 changed files with 1556714 additions and 0 deletions
@@ -0,0 +1,89 @@
+//! RTX-Synthesis Bayesian Optimization Autotuning Engine
+//!
+//! This module provides a comprehensive autotuning system using Gaussian processes
+//! for optimal kernel parameter exploration, with hardware-aware optimization,
+//! multi-objective support, and persistent caching.
+
+mod bayesian_tuner;
+mod config;
+mod gaussian_process;
+mod legacy_tuner;
+mod metrics;
+mod parameters;
+mod types;
+
+// Re-export all public types
+pub use bayesian_tuner::BayesianAutoTuner;
+pub use config::{ConvergenceConfig, MultiObjectiveConfig, TuningConfig};
+pub use gaussian_process::{CacheEntry, GaussianProcess, PersistentCache};
+pub use legacy_tuner::AutoTuner;
+pub use metrics::{
+    AcquisitionHistoryEntry, GPPrediction, Observation, PerformanceMetrics, PerformanceStatistics,
+    TuningResult,
+};
+pub use parameters::{ParameterDimension, ParameterRange, ParameterSpace};
+pub use types::{AcquisitionFunction, ObjectiveMetric, ParameterType, SearchStrategy};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::templates::{ElementwiseOp, KernelOperation};
+
+    #[tokio::test]
+    async fn test_autotuner_creation() {
+        let result = AutoTuner::new();
+        assert!(result.is_ok());
+        let autotuner = result.unwrap();
+        assert_eq!(autotuner.cache_stats().0, 0);
+    }
+
+    #[tokio::test]
+    async fn test_parameter_range_generation() {
+        let range = ParameterRange::new("block_size", 64, 256, 64);
+        let values = range.generate_values();
+        assert_eq!(values, vec![64, 128, 192, 256]);
+
+        let candidates_range = ParameterRange::with_candidates("tile_size", vec![1, 2, 4, 8]);
+        let candidates = candidates_range.generate_values();
+        assert_eq!(candidates, vec![1, 2, 4, 8]);
+    }
+
+    #[tokio::test]
+    async fn test_tuning_config_for_gemm() {
+        let autotuner = AutoTuner::new().unwrap();
+        let operation = KernelOperation::Gemm {
+            m: 1024,
+            n: 1024,
+            k: 1024,
+            transpose_a: false,
+            transpose_b: false,
+        };
+
+        let config = autotuner.create_tuning_config(&operation).unwrap();
+
+        assert!(matches!(
+            config.search_strategy,
+            SearchStrategy::BayesianOptimization { .. }
+        ));
+        assert!(!config.parameter_ranges.is_empty());
+
+        let param_names: Vec<_> = config.parameter_ranges.iter().map(|r| &r.name).collect();
+        assert!(param_names.contains(&&"block_size_m".to_string()));
+        assert!(param_names.contains(&&"block_size_n".to_string()));
+        assert!(param_names.contains(&&"unroll_factor".to_string()));
+    }
+
+    #[tokio::test]
+    async fn test_cache_functionality() {
+        let mut autotuner = AutoTuner::new().unwrap();
+
+        let (total, expired) = autotuner.cache_stats();
+        assert_eq!(total, 0);
+        assert_eq!(expired, 0);
+
+        autotuner.clear_cache();
+
+        let (total_after_clear, _) = autotuner.cache_stats();
+        assert_eq!(total_after_clear, 0);
+    }
+}