Method cleanup

src/cache/ttl_cache.rs:311–353

Force cleanup of expired entries

(&self)

    /// Force cleanup of expired entries
    pub fn cleanup(&self) {
        let mut entries = self.entries.write();
        let mut stats = self.stats.write();

        let mut last_cleanup = self.last_cleanup.write();
        *last_cleanup = Instant::now();

        let initial_count = entries.len();
        let mut removed_size = 0;

        entries.retain(|_key, entry| {
            if entry.is_expired() {
                removed_size += entry.size_bytes;
                false
            } else {
                true
            }
        });

        let removed_count = initial_count - entries.len();
        if removed_count > 0 {
            stats.total_entries = entries.len();
            stats.total_size_bytes = stats.total_size_bytes.saturating_sub(removed_size);
            stats.expired_evictions += removed_count as u64;
            stats.cleanup_runs += 1;

            debug!("Cache cleanup: removed {} expired entries, freed {} bytes",
                   removed_count, removed_size);

            // Unregister memory usage
            if removed_size > 0 {
                global_memory_monitor().record_query_deallocation(removed_size as u64);
            }
        }

        drop(stats);
        drop(entries);

        // Validate memory tracking consistency after cleanup
        if !self.validate_memory_tracking() {
            debug!("Memory tracking was inconsistent after cleanup, fixed automatically");
        }
    }

    /// Check if cleanup should be performed
    fn maybe_cleanup(&self) {