pmat 3.11.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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

// Auto-scaling manager
pub struct AutoScaler {
    allocator: Arc<AdaptiveAllocator>,
    manager: Arc<ResourceManager>,
    config: AutoScalerConfig,
    last_adjustment: Arc<RwLock<Option<Instant>>>,
}

#[derive(Clone)]
pub struct AutoScalerConfig {
    pub enabled: bool,
    pub check_interval: Duration,
    pub cooldown_period: Duration,
    pub scale_up_threshold: f32,
    pub scale_down_threshold: f32,
}

impl Default for AutoScalerConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            check_interval: Duration::from_secs(10),
            cooldown_period: Duration::from_secs(60),
            scale_up_threshold: 0.8,   // Scale up at 80% usage
            scale_down_threshold: 0.3, // Scale down at 30% usage
        }
    }
}

impl AutoScaler {
    pub fn new(
        allocator: Arc<AdaptiveAllocator>,
        manager: Arc<ResourceManager>,
        config: AutoScalerConfig,
    ) -> Self {
        Self {
            allocator,
            manager,
            config,
            last_adjustment: Arc::new(RwLock::new(None)),
        }
    }

    #[allow(clippy::cast_possible_truncation)]
    pub async fn run(&self) {
        if !self.config.enabled {
            return;
        }

        loop {
            tokio::time::sleep(self.config.check_interval).await;

            // Check cooldown
            if let Some(last) = *self.last_adjustment.read() {
                if last.elapsed() < self.config.cooldown_period {
                    continue;
                }
            }

            // Get current usage and limits
            let usage = match self.manager.get_current_usage() {
                Ok(u) => u,
                Err(_) => continue,
            };

            let limits = self.manager.limits.read().clone();

            // Calculate utilization
            let cpu_util = usage.cpu_percent / 100.0;
            let mem_util = usage.memory_bytes as f32 / limits.memory.max_bytes as f32;
            let overall_util = (cpu_util + mem_util) / 2.0;

            // Record for learning
            self.allocator
                .record_usage(usage, limits.clone(), 1.0 - overall_util);

            // Check if adjustment is needed
            if overall_util > self.config.scale_up_threshold
                || overall_util < self.config.scale_down_threshold
            {
                if let Some(new_limits) = self.allocator.suggest_adjustment(&limits) {
                    if let Ok(()) = self.manager.update_limits(new_limits) {
                        *self.last_adjustment.write() = Some(Instant::now());
                    }
                }
            }
        }
    }
}