amberjs 1.16.1

JavaScript/TypeScript runtime built with Rust and V8
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

// 资源使用预测器 - Stage 90 Phase 5.3


use std::collections::VecDeque;
use chrono::{DateTime, Utc};
use serde::{Serialize, Deserialize};
/// 资源指标
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceMetrics {
    pub timestamp: DateTime<Utc>,
    pub cpu_usage: f64,
    pub memory_usage: f64,
    pub network_io: f64,
    pub disk_io: f64,
}
/// 预测结果
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PredictionResult {
    pub predicted_cpu: f64,
    pub predicted_memory: f64,
    pub confidence: f64,
    pub time_horizon: u32, // minutes
}
/// 利用率预测
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UtilizationForecast {
    pub time_points: Vec<DateTime<Utc>>,
    pub cpu_forecast: Vec<f64>,
    pub memory_forecast: Vec<f64>,
}
/// 资源使用预测器
pub struct ResourcePredictor {
    history: VecDeque<ResourceMetrics>,
    max_history: usize,
}
impl ResourcePredictor {
    pub fn new(max_history: usize) -> Self {
        Self {
            history: VecDeque::with_capacity(max_history),
            max_history,
        }
    }
    pub fn add_metrics(&mut self, metrics: ResourceMetrics) {
        self.history.push_back(metrics);
        if self.history.len() > self.max_history {
            self.history.pop_front();
        }
    }
    pub fn predict(&self, time_horizon: u32) -> PredictionResult {
        if self.history.len() < 2 {
            return PredictionResult {
                predicted_cpu: 0.0,
                predicted_memory: 0.0,
                confidence: 0.0,
                time_horizon,
            };
        }
        // 简化的线性预测
        let recent_metrics: Vec<_> = self.history.iter().rev().take(10).collect();
        let avg_cpu: _ = recent_metrics.iter().map(|m| m.cpu_usage).sum::<f64>() / recent_metrics.len() as f64;
        let avg_memory: _ = recent_metrics.iter().map(|m| m.memory_usage).sum::<f64>() / recent_metrics.len() as f64;
        // 基于历史趋势的简单预测
        let trend_cpu: _ = self.calculate_trend(&recent_metrics.iter().map(|m| m.cpu_usage).collect());
        let trend_memory: _ = self.calculate_trend(&recent_metrics.iter().map(|m| m.memory_usage).collect());
        PredictionResult {
            predicted_cpu: (avg_cpu + trend_cpu * time_horizon as f64 / 60.0).clamp(0.0, 100.0),
            predicted_memory: (avg_memory + trend_memory * time_horizon as f64 / 60.0).clamp(0.0, 100.0),
            confidence: 0.7,
            time_horizon,
        }
    }
    fn calculate_trend(&self, values: &[f64]) -> f64 {
        if values.len() < 2 {
            return 0.0;
        }
        // 简单的线性回归
        let n: _ = values.len() as f64;
        let sum_x: f64 = (0..values.len()).map(|i| i as f64).sum();
        let sum_y: f64 = values.iter().sum();
        let sum_xy: f64 = values.iter().enumerate().map(|(i, &y)| i as f64 * y).sum();
        let sum_x2: f64 = (0..values.len()).map(|i| (i as f64).powi(2)).sum();
        let slope: _ = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x * sum_x);
        slope
    }
    pub fn generate_forecast(&self, hours: u32) -> UtilizationForecast {
        let mut time_points = Vec::new();
        let mut cpu_forecast = Vec::new();
        let mut memory_forecast = Vec::new();
        let now: _ = Utc::now();
        for i in 0..hours {
            let time_point: _ = now + chrono::Duration::minutes(i as i64);
            let prediction: _ = self.predict(i * 60); // convert hours to minutes
            time_points.push(time_point);
            cpu_forecast.push(prediction.predicted_cpu);
            memory_forecast.push(prediction.predicted_memory);
        }
        UtilizationForecast {
            time_points,
            cpu_forecast,
            memory_forecast,
        }
    }
}
#[cfg(test)]
mod tests {
    use super::*;
use std::collections::{HashMap, BTreeMap};
use std::time::Duration;
    #[test]
    fn test_resource_predictor() {
        let mut predictor = ResourcePredictor::new(100);
        let now: _ = Utc::now();
        for i in 0..10 {
            predictor.add_metrics(ResourceMetrics {
                timestamp: now + chrono::Duration::minutes(i),
                cpu_usage: 50.0 + i as f64 * 2.0,
                memory_usage: 60.0 + i as f64,
                network_io: 100.0,
                disk_io: 50.0,
            });
        }
        let prediction: _ = predictor.predict(30);
        assert!(prediction.confidence > 0.0);
        assert!(prediction.predicted_cpu > 50.0);
    }
}