hyperscan_tokio/

cache.rs

// src/cache.rs - Proper implementation of database caching
use crate::{Database, Pattern, Mode, Platform, Result};
use dashmap::DashMap;
use std::sync::Arc;
use std::time::{Duration, Instant};
use std::hash::{Hash, Hasher};
use std::collections::hash_map::DefaultHasher;
use parking_lot::Mutex;

/// Cacheable pattern configuration
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub struct CacheKey {
    patterns: Vec<CachePattern>,
    mode: u32,
    platform_hash: u64,
}

#[derive(Clone, Debug, Hash, PartialEq, Eq)]
struct CachePattern {
    expression: String,
    id: u32,
    flags: u32,
    min_offset: Option<u64>,
    max_offset: Option<u64>,
    min_length: Option<u64>,
    edit_distance: Option<u32>,
    hamming_distance: Option<u32>,
}

impl From<&Pattern> for CachePattern {
    fn from(p: &Pattern) -> Self {
        Self {
            expression: p.expression.clone(),
            id: p.id,
            flags: p.flags.bits(),
            min_offset: p.min_offset,
            max_offset: p.max_offset,
            min_length: p.min_length,
            edit_distance: p.edit_distance,
            hamming_distance: p.hamming_distance,
        }
    }
}

/// Cache entry with metadata
#[derive(Clone)]
struct CacheEntry {
    database: Arc<Database>,
    created_at: Instant,
    access_count: u64,
    last_accessed: Instant,
    size_bytes: usize,
}

/// Thread-safe database cache with proper key generation
pub struct DatabaseCache {
    cache: Arc<DashMap<CacheKey, CacheEntry>>,
    max_size: usize,
    max_memory_bytes: usize,
    ttl: Option<Duration>,
    current_memory_usage: Arc<Mutex<usize>>,
}

/// Builder for database cache
#[derive(Default)]
pub struct DatabaseCacheBuilder {
    max_size: Option<usize>,
    max_memory_bytes: Option<usize>,
    ttl: Option<Duration>,
}

impl DatabaseCacheBuilder {
    pub fn max_size(mut self, size: usize) -> Self {
        self.max_size = Some(size);
        self
    }
    
    pub fn max_memory_bytes(mut self, bytes: usize) -> Self {
        self.max_memory_bytes = Some(bytes);
        self
    }
    
    pub fn ttl(mut self, duration: Duration) -> Self {
        self.ttl = Some(duration);
        self
    }
    
    pub fn build(self) -> DatabaseCache {
        DatabaseCache {
            cache: Arc::new(DashMap::new()),
            max_size: self.max_size.unwrap_or(1000),
            max_memory_bytes: self.max_memory_bytes.unwrap_or(512 * 1024 * 1024),
            ttl: self.ttl,
            current_memory_usage: Arc::new(Mutex::new(0)),
        }
    }
}

impl DatabaseCache {
    pub fn new() -> Self {
        Self {
            cache: Arc::new(DashMap::new()),
            max_size: 1000,
            max_memory_bytes: 512 * 1024 * 1024, // 512MB default
            ttl: Some(Duration::from_secs(3600)), // 1 hour default
            current_memory_usage: Arc::new(Mutex::new(0)),
        }
    }
    
    /// Create a cache with custom settings
    pub fn builder() -> DatabaseCacheBuilder {
        DatabaseCacheBuilder::default()
    }
    
    /// Create cache key from patterns and configuration
    pub fn create_key(patterns: &[Pattern], mode: Mode, platform: Option<&Platform>) -> CacheKey {
        let mut cache_patterns: Vec<CachePattern> = patterns
            .iter()
            .map(|p| p.into())
            .collect();
        
        // Sort for consistent hashing
        cache_patterns.sort_by(|a, b| a.id.cmp(&b.id));
        
        let platform_hash = platform
            .map(|p| {
                let mut hasher = DefaultHasher::new();
                p.tune.hash(&mut hasher);
                p.cpu_features.hash(&mut hasher);
                hasher.finish()
            })
            .unwrap_or(0);
        
        CacheKey {
            patterns: cache_patterns,
            mode: mode.bits(),
            platform_hash,
        }
    }
    
    /// Get or compile a database
    pub async fn get_or_compile<F>(
        &self,
        key: CacheKey,
        compile_fn: F,
    ) -> Result<Arc<Database>>
    where
        F: FnOnce() -> Result<Database>,
    {
        // Check cache first
        if let Some(db) = self.get(&key) {
            return Ok(db);
        }
        
        // Compile if not found
        let db = compile_fn()?;
        let db_arc = Arc::new(db);
        
        // Insert into cache
        self.insert(key, db_arc.clone());
        
        Ok(db_arc)
    }
    
    /// Get database by key
    pub fn get(&self, key: &CacheKey) -> Option<Arc<Database>> {
        let mut should_remove = false;
        let result = self.cache.get_mut(key).and_then(|mut entry| {
            // Check TTL
            if let Some(ttl) = self.ttl {
                if entry.created_at.elapsed() > ttl {
                    should_remove = true;
                    return None;
                }
            }
            
            // Update access metadata
            entry.access_count += 1;
            entry.last_accessed = Instant::now();
            
            Some(entry.database.clone())
        });
        
        if should_remove {
            if let Some((_, entry)) = self.cache.remove(key) {
                *self.current_memory_usage.lock() -= entry.size_bytes;
            }
        }
        
        result
    }
    
    /// Insert a compiled database
    pub fn insert(&self, key: CacheKey, database: Arc<Database>) {
        let size = database.size().unwrap_or(0);
        
        // Check memory limit
        let mut current_usage = self.current_memory_usage.lock();
        if *current_usage + size > self.max_memory_bytes {
            drop(current_usage);
            self.evict_until_space(size);
        } else {
            *current_usage += size;
        }
        
        // Check item count limit
        if self.cache.len() >= self.max_size {
            self.evict_lru();
        }
        
        let entry = CacheEntry {
            database,
            created_at: Instant::now(),
            access_count: 1,
            last_accessed: Instant::now(),
            size_bytes: size,
        };
        
        self.cache.insert(key, entry);
    }
    
    /// Clear the cache
    pub fn clear(&self) {
        self.cache.clear();
        *self.current_memory_usage.lock() = 0;
    }
    
    /// Get cache statistics
    pub fn stats(&self) -> CacheStats {
        let mut total_hits = 0u64;
        let mut total_size = 0usize;
        
        for entry in self.cache.iter() {
            total_hits += entry.access_count;
            total_size += entry.size_bytes;
        }
        
        CacheStats {
            entries: self.cache.len(),
            capacity: self.max_size,
            memory_usage_bytes: *self.current_memory_usage.lock(),
            memory_limit_bytes: self.max_memory_bytes,
            total_hits,
        }
    }
    
    /// Evict least recently used entries until we have space
    fn evict_until_space(&self, needed_bytes: usize) {
        let mut entries: Vec<_> = self.cache
            .iter()
            .map(|entry| (entry.key().clone(), entry.last_accessed, entry.size_bytes))
            .collect();
        
        // Sort by last accessed time (oldest first)
        entries.sort_by_key(|(_, last_accessed, _)| *last_accessed);
        
        let mut freed = 0;
        let mut memory_usage = self.current_memory_usage.lock();
        
        for (key, _, size) in entries {
            // Check if we still need to free more space
            if freed >= needed_bytes && *memory_usage + needed_bytes <= self.max_memory_bytes {
                break;
            }
            
            if let Some((_, entry)) = self.cache.remove(&key) {
                freed += entry.size_bytes;
                *memory_usage = memory_usage.saturating_sub(entry.size_bytes);
            }
        }
    }
    
    /// Evict least recently used entry
    fn evict_lru(&self) {
        if let Some((key, _)) = self.cache
            .iter()
            .min_by_key(|entry| entry.value().last_accessed)
            .map(|entry| (entry.key().clone(), entry.value().clone()))
        {
            if let Some((_, entry)) = self.cache.remove(&key) {
                *self.current_memory_usage.lock() -= entry.size_bytes;
            }
        }
    }
}

/// Enhanced cache statistics
#[derive(Debug, Clone)]
pub struct CacheStats {
    pub entries: usize,
    pub capacity: usize,
    pub memory_usage_bytes: usize,
    pub memory_limit_bytes: usize,
    pub total_hits: u64,
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{DatabaseBuilder, prelude::*};
    
    #[test]
    fn test_cache_key_generation() {
        let patterns = vec![
            Pattern::new(r"\d+").id(1).build().unwrap(),
            Pattern::new(r"[a-z]+").id(2).flags(Flags::CASELESS).build().unwrap(),
        ];
        
        let key1 = DatabaseCache::create_key(&patterns, Mode::BLOCK, None);
        let key2 = DatabaseCache::create_key(&patterns, Mode::BLOCK, None);
        
        assert_eq!(key1, key2);
        
        // Different mode should produce different key
        let key3 = DatabaseCache::create_key(&patterns, Mode::STREAM, None);
        assert_ne!(key1, key3);
    }
    
    #[tokio::test]
    async fn test_cache_functionality() {
        let cache = DatabaseCache::new();
        
        let patterns = vec![
            Pattern::new(r"\d+").id(1).build().unwrap(),
        ];
        
        let key = DatabaseCache::create_key(&patterns, Mode::BLOCK, None);
        
        // First access - compile
        let db1 = cache.get_or_compile(key.clone(), || {
            DatabaseBuilder::new()
                .add_pattern(patterns[0].clone())
                .build()
        }).await.unwrap();
        
        // Second access - should hit cache
        let db2 = cache.get(&key).unwrap();
        
        assert_eq!(db1.fingerprint(), db2.fingerprint());
        
        let stats = cache.stats();
        assert_eq!(stats.entries, 1);
        assert_eq!(stats.total_hits, 2); // Initial insert + one get
    }
    
    #[tokio::test]
    async fn test_ttl_expiration() {
        let cache = DatabaseCache::builder()
            .ttl(Duration::from_millis(100))
            .build();
        
        let patterns = vec![
            Pattern::new(r"\d+").id(1).build().unwrap(),
        ];
        
        let key = DatabaseCache::create_key(&patterns, Mode::BLOCK, None);
        
        // Insert into cache
        let db = cache.get_or_compile(key.clone(), || {
            DatabaseBuilder::new()
                .add_pattern(patterns[0].clone())
                .build()
        }).await.unwrap();
        
        // Should be in cache
        assert!(cache.get(&key).is_some());
        
        // Wait for TTL to expire
        tokio::time::sleep(Duration::from_millis(150)).await;
        
        // Should be expired and removed
        assert!(cache.get(&key).is_none());
        
        // Memory should be freed
        let stats = cache.stats();
        assert_eq!(stats.entries, 0);
        assert_eq!(stats.memory_usage_bytes, 0);
    }
    
    #[test]
    fn test_memory_limit() {
        let cache = DatabaseCache::builder()
            .max_memory_bytes(1024) // Very small limit
            .build();
        
        // Create multiple patterns
        for i in 0..10 {
            let patterns = vec![
                Pattern::new(&format!("pattern{}", i)).id(i).build().unwrap(),
            ];
            
            let key = DatabaseCache::create_key(&patterns, Mode::BLOCK, None);
            let db = DatabaseBuilder::new()
                .add_pattern(patterns[0].clone())
                .build()
                .unwrap();
            
            cache.insert(key, Arc::new(db));
        }
        
        // Should have evicted some entries to stay under memory limit
        let stats = cache.stats();
        assert!(stats.memory_usage_bytes <= 1024);
        assert!(stats.entries < 10);
    }
}