Method check_memory_pressure

src/cache/memory_aware_manager.rs:214–260

Check memory pressure and take action if needed

(&self)

    /// Check memory pressure and take action if needed
    pub fn check_memory_pressure(&self) {
        if !self.config.enable_pressure_monitoring {
            return;
        }

        // Rate limit checks
        {
            let last_check = *self.last_check.read();
            if last_check.elapsed() < self.config.check_interval {
                return;
            }
        }

        let memory_stats = global_memory_monitor().get_stats();
        let current_memory_mb = memory_stats.total_bytes() as f64 / (1024.0 * 1024.0);

        // Update last check time
        {
            let mut last_check = self.last_check.write();
            *last_check = Instant::now();
        }

        // Update stats
        {
            let mut stats = self.stats.write();
            stats.pressure_checks += 1;
            stats.last_check_time = Some(Instant::now());
            stats.current_memory_pressure = memory_stats.pressure_level;
            stats.total_memory_bytes = memory_stats.total_bytes() as usize;
        }

        // Determine action based on memory usage and pressure
        let action = if current_memory_mb > self.config.critical_threshold_mb as f64 {
            MemoryAction::CriticalEviction
        } else if current_memory_mb > self.config.pressure_threshold_mb as f64 {
            MemoryAction::PressureEviction
        } else {
            match memory_stats.pressure_level {
                MemoryPressure::Critical => MemoryAction::CriticalEviction,
                MemoryPressure::High => MemoryAction::PressureEviction,
                MemoryPressure::Medium => MemoryAction::AdaptiveTtl,
                MemoryPressure::Low => MemoryAction::None,
            }
        };

        self.execute_memory_action(action, current_memory_mb);
    }

    fn execute_memory_action(&self, action: MemoryAction, current_memory_mb: f64) {
        match action {