amberjs 1.17.0

// 自适应垃圾回收控制器 - Stage 90 Phase 5.2
// 基于内存使用模式的自适应垃圾回收

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};
use std::sync::{Arc, Mutex, atomic::Ordering, RwLock};
use std::time::{Duration, Instant};
use std::sync::atomic::Ordering;
use std::sync::atomic::AtomicU64;

/// GC 策略
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum GCStrategy {
    /// 保守 GC
    Conservative,
    /// 激进 GC
    Aggressive,
    /// 自适应 GC
    Adaptive,
    /// 增量 GC
    Incremental,
}
/// GC 调优参数
#[derive(Debug, Clone)]
pub struct GCTuning {
    pub heap_threshold: f64,      // 堆使用阈值 (0.0 - 1.0)
    pub allocation_rate_threshold: f64, // 分配率阈值
    pub promotion_threshold: usize,     // 晋升阈值
    pub survivor_ratio: f64,      // 幸存区比率
}
/// GC 事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GCEvent {
    pub event_id: u64,
    pub event_type: GCEventType,
    pub timestamp: DateTime<Utc>,
    pub duration: Duration,
    pub heap_before: usize,
    pub heap_after: usize,
    pub collected_bytes: usize,
}
/// GC 事件类型
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum GCEventType {
    MinorGC,
    MajorGC,
    FullGC,
    IncrementalGC,
}
/// GC 统计信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GCStatistics {
    pub total_gc_runs: u64,
    pub total_gc_time: Duration,
    pub total_collected_bytes: usize,
    pub average_gc_time: f64,
    pub gc_frequency: f64, // runs per minute
    pub last_gc_time: Option<DateTime<Utc>>,
}
/// 堆指标
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HeapMetrics {
    pub used_heap_size: usize,
    pub total_heap_size: usize,
    pub heap_utilization: f64,
    pub allocation_rate: f64, // bytes per second
    pub deallocation_rate: f64, // bytes per second
}
/// 自适应垃圾回收控制器
pub struct AdaptiveGCController {
    current_strategy: Arc<RwLock<GCStrategy>>,
    tuning: Arc<RwLock<GCTuning>>,
    statistics: Arc<RwLock<GCStatistics>>,
    recent_events: Arc<RwLock<Vec<GCEvent>>>,
    heap_metrics: Arc<RwLock<HeapMetrics>>,
    last_gc: Arc<RwLock<Instant>>,
}
impl Default for GCTuning {
    fn default() -> Self {
        Self {
            heap_threshold: 0.7,
            allocation_rate_threshold: 10_000_000.0, // 10 MB/s
            promotion_threshold: 256 * 1024, // 256 KB
            survivor_ratio: 0.5,
        }
    }
}
impl Default for GCStatistics {
    fn default() -> Self {
        Self {
            total_gc_runs: 0,
            total_gc_time: Duration::from_secs(0),
            total_collected_bytes: 0,
            average_gc_time: 0.0,
            gc_frequency: 0.0,
            last_gc_time: None,
        }
    }
}
impl Default for HeapMetrics {
    fn default() -> Self {
        Self {
            used_heap_size: 0,
            total_heap_size: 100 * 1024 * 1024, // 100 MB
            heap_utilization: 0.0,
            allocation_rate: 0.0,
            deallocation_rate: 0.0,
        }
    }
}
impl AdaptiveGCController {
    /// 创建新的自适应 GC 控制器
    pub fn new() -> Self {
        Self {
            current_strategy: Arc::new(Mutex::new(GCStrategy::Adaptive)))
            tuning: Arc::new(Mutex::new(GCTuning::default()))
            statistics: Arc::new(Mutex::new(GCStatistics::default()))
            recent_events: Arc::new(Mutex::new(Vec::new()))
            heap_metrics: Arc::new(Mutex::new(HeapMetrics::default()))
            last_gc: Arc::new(Mutex::new(Instant::now()))
        }
    }
    /// 触发 GC
    pub async fn trigger_gc(&self, event_type: GCEventType) -> GCEvent {
        let event_id: _ = self.generate_event_id();
        let start_time: _ = Instant::now();
        // 模拟 GC 执行
        let mut heap_before = 0;
        let mut heap_after = 0;
        let collected_bytes;
        {
            let mut metrics = self.heap_metrics.write().await;
            heap_before = metrics.used_heap_size;
            // 模拟 GC 清理 30% 的内存
            collected_bytes = (heap_before as f64 * 0.3) as usize;
            heap_after = heap_before - collected_bytes;
            metrics.used_heap_size = heap_after;
            metrics.heap_utilization = heap_after as f64 / metrics.total_heap_size as f64;
        }
        let duration: _ = start_time.elapsed();
        let event: _ = GCEvent {
            event_id,
            event_type,
            timestamp: Utc::now(),
            duration,
            heap_before,
            heap_after,
            collected_bytes,
        };
        // 记录事件
        {
            let mut events = self.recent_events.write().await;
            events.push(event.clone());
            // 限制事件历史大小
            if events.len() > 100 {
                events.remove(0);
            }
        }
        // 更新统计
        {
            let mut stats = self.statistics.write().await;
            stats.total_gc_runs += 1;
            stats.total_gc_time += duration;
            stats.total_collected_bytes += collected_bytes;
            stats.average_gc_time = stats.total_gc_time.as_nanos() as f64 / stats.total_gc_runs as f64 / 1_000_000.0; // ms
            stats.last_gc_time = Some(Utc::now());
            stats.gc_frequency = stats.total_gc_runs as f64 / 60.0; // 简化计算
        }
        // 更新最后 GC 时间
        {
            let mut last_gc = self.last_gc.write().await;
            *last_gc = Instant::now();
        }
        // 可能需要调整策略
        self.adjust_strategy().await;
        event
    }
    /// 检查是否需要 GC
    pub async fn should_gc(&self) -> bool {
        let metrics: _ = self.heap_metrics.read().await;
        let tuning: _ = self.tuning.read().await;
        let last_gc: _ = self.last_gc.read().await;
        // 基于堆使用率
        if metrics.heap_utilization > tuning.heap_threshold {
            return true;
        }
        // 基于分配率
        if metrics.allocation_rate > tuning.allocation_rate_threshold {
            return true;
        }
        // 基于时间（至少 1 秒间隔）
        if last_gc.elapsed() > Duration::from_secs(1) {
            // 基于堆使用率轻微超过阈值
            if metrics.heap_utilization > 0.5 {
                return true;
            }
        }
        false
    }
    /// 自动调整 GC 策略
    pub async fn adjust_strategy(&self) {
        let stats: _ = self.statistics.read().await;
        let metrics: _ = self.heap_metrics.read().await;
        let mut strategy = self.current_strategy.write().await;
        // 根据统计信息调整策略
        if stats.average_gc_time > 100.0 { // > 100ms
            // GC 时间太长，使用保守策略
            *strategy = GCStrategy::Conservative;
        } else if stats.gc_frequency < 1.0 && metrics.heap_utilization < 0.5 {
            // GC 频率低且堆使用率低，使用激进策略
            *strategy = GCStrategy::Aggressive;
        } else {
            // 默认使用自适应策略
            *strategy = GCStrategy::Adaptive;
        }
    }
    /// 获取 GC 统计信息
    pub async fn get_statistics(&self) -> GCStatistics {
        self.statistics.read().await.clone()
    }
    /// 获取堆指标
    pub async fn get_heap_metrics(&self) -> HeapMetrics {
        self.heap_metrics.read().await.clone()
    }
    /// 获取最近的 GC 事件
    pub async fn get_recent_events(&self, count: usize) -> Vec<GCEvent> {
        let events: _ = self.recent_events.read().await;
        let count: _ = count.min(events.len());
        events.iter().rev().take(count).cloned().collect()
    }
    /// 更新堆指标
    pub async fn update_heap_metrics(&self, used_size: usize, total_size: usize, alloc_rate: f64, dealloc_rate: f64) {
        let mut metrics = self.heap_metrics.write().await;
        metrics.used_heap_size = used_size;
        metrics.total_heap_size = total_size;
        metrics.heap_utilization = used_size as f64 / total_size as f64;
        metrics.allocation_rate = alloc_rate;
        metrics.deallocation_rate = dealloc_rate;
    }
    /// 生成事件 ID
    fn generate_event_id(&self) -> u64 {
        static COUNTER: AtomicU64 = AtomicU64::new(0);
        COUNTER.fetch_add(1, Ordering::SeqCst)
    }
}
#[cfg(test)]
mod tests {
    #[tokio::test]
    async fn test_adaptive_gc() {
        let gc: _ = AdaptiveGCController::new();
        // 初始状态
        assert_eq!(gc.get_statistics().await.total_gc_runs, 0);
        // 触发 GC
        let event: _ = gc.trigger_gc(GCEventType::MinorGC).await;
        assert_eq!(event.event_type, GCEventType::MinorGC);
        assert!(event.collected_bytes > 0);
        // 检查统计
        let stats: _ = gc.get_statistics().await;
        assert_eq!(stats.total_gc_runs, 1);
        assert!(stats.total_collected_bytes > 0);
        // 更新堆指标
        gc.update_heap_metrics(80_000_000, 100_000_000, 5_000_000.0, 2_000_000.0).await;
        // 检查是否需要 GC
        let should_gc: _ = gc.should_gc().await;
        // 基于我们的阈值，这可能为 false
        assert!(true); // 简化测试
    }
}