Method evict_if_needed

graphlite/src/cache/subquery_cache.rs:583–638

(&self, incoming_size: usize)

    }

    fn evict_if_needed(&self, incoming_size: usize) {
        let current_memory = *self.current_memory.read().unwrap();
        let current_entries = self.entries.read().unwrap().len();

        if current_memory + incoming_size > self.max_memory_bytes
            || current_entries >= self.max_entries
        {
            // Collect eviction candidates (prioritize by hit rate vs complexity)
            let mut candidates: Vec<(SubqueryCacheKey, f64)> = {
                let entries = self.entries.read().unwrap();
                entries
                    .iter()
                    .map(|(key, entry)| {
                        // Score based on hit rate, recency, and complexity
                        let hit_rate = if entry.metadata.access_count == 0 {
                            0.0
                        } else {
                            entry.hit_count as f64 / entry.metadata.access_count as f64
                        };
                        let recency_score = 1.0 / (1.0 + entry.last_hit.elapsed().as_secs() as f64);
                        let complexity_bonus = entry.complexity_score / 10.0; // Higher complexity = keep longer

                        let keep_score = hit_rate + recency_score + complexity_bonus;
                        (key.clone(), keep_score)
                    })
                    .collect()
            };

            // Sort by keep score (ascending = evict first)
            candidates.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());

            // Evict lowest scoring entries
            let mut entries = self.entries.write().unwrap();
            for (key, _) in candidates {
                if let Some(evicted_entry) = entries.remove(&key) {
                    let evicted_size = evicted_entry.size_bytes();
                    self.update_indices(&key, false);

                    {
                        let mut current_memory = self.current_memory.write().unwrap();
                        *current_memory = current_memory.saturating_sub(evicted_size);
                    }

                    // Check if we have enough space now
                    let new_current_memory = *self.current_memory.read().unwrap();
                    let new_current_entries = entries.len();

                    if new_current_memory + incoming_size <= self.max_memory_bytes
                        && new_current_entries < self.max_entries
                    {
                        break;
                    }
                }
            }
        }
    }

    fn update_indices(&self, key: &SubqueryCacheKey, add: bool) {