caching_performance/

caching_performance.rs

//! Template Caching and Performance Example
//!
//! This example demonstrates the performance benefits of template caching
//! and various optimization features in the Tron template engine.

use tron::{TemplateCache, CacheConfig, TemplateLoader, LoaderConfig, TronTemplate};
use std::time::{Duration, Instant};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Tron Template Caching and Performance Example ===\n");

    // 1. Basic template caching
    demonstrate_basic_caching()?;
    
    // 2. Cache performance comparison
    demonstrate_cache_performance()?;
    
    // 3. Cache configuration and tuning
    demonstrate_cache_configuration()?;
    
    // 4. Advanced loader with caching
    demonstrate_loader_caching()?;
    
    // 5. Cache statistics and monitoring
    demonstrate_cache_monitoring()?;

    Ok(())
}

fn demonstrate_basic_caching() -> Result<(), Box<dyn std::error::Error>> {
    println!("1. Basic Template Caching:");
    
    let cache = TemplateCache::new();
    
    // Create and cache some templates
    let templates = vec![
        ("function", TronTemplate::new("fn @[name]@(@[params]@) -> @[return_type]@ { @[body]@ }")?),
        ("struct", TronTemplate::new("struct @[name]@ { @[fields]@ }")?),
        ("impl", TronTemplate::new("impl @[name]@ { @[methods]@ }")?),
    ];
    
    // Insert templates into cache
    for (name, template) in &templates {
        cache.insert_template(template.clone())?;
        println!("   - Cached template: {}", name);
    }
    
    println!("   - Cache size: {}", cache.size());
    
    // Retrieve from cache
    if let Some(_template) = cache.get_by_content("fn @[name]@(@[params]@) -> @[return_type]@ { @[body]@ }") {
        println!("   - Successfully retrieved function template from cache");
    }
    
    println!();
    Ok(())
}

fn demonstrate_cache_performance() -> Result<(), Box<dyn std::error::Error>> {
    println!("2. Cache Performance Comparison:");
    
    let template_content = "fn @[name]@(@[params]@) -> @[return_type]@ {\n    @[body]@\n}";
    let iterations = 1000;
    
    // Without caching - parse template every time
    let start = Instant::now();
    for _ in 0..iterations {
        let _template = TronTemplate::new(template_content)?;
    }
    let no_cache_duration = start.elapsed();
    
    // With caching - parse once, retrieve from cache
    let cache = TemplateCache::new();
    let template = TronTemplate::new(template_content)?;
    cache.insert_template(template)?;
    
    let start = Instant::now();
    for _ in 0..iterations {
        let _cached_template = cache.get_by_content(template_content);
    }
    let cache_duration = start.elapsed();
    
    println!("   - Without caching: {:?} ({} iterations)", no_cache_duration, iterations);
    println!("   - With caching:    {:?} ({} iterations)", cache_duration, iterations);
    println!("   - Performance improvement: {:.2}x faster", 
             no_cache_duration.as_nanos() as f64 / cache_duration.as_nanos() as f64);
    
    println!();
    Ok(())
}

fn demonstrate_cache_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("3. Cache Configuration and Tuning:");
    
    // High-performance cache configuration
    let config = CacheConfig {
        max_size: 50,                                    // Limit cache size
        max_age: Some(Duration::from_secs(300)),        // 5 minute TTL
        track_file_changes: true,                       // Watch for file modifications
        enable_stats: true,                             // Track performance metrics
    };
    
    let cache = TemplateCache::with_config(config);
    
    println!("   - Max cache size: 50 templates");
    println!("   - Max entry age: 5 minutes");
    println!("   - File change tracking: enabled");
    println!("   - Statistics tracking: enabled");
    
    // Add some templates to test eviction
    for i in 0..55 {
        let template = TronTemplate::new(&format!("Template {} content @[placeholder]@", i))?;
        cache.insert_template(template)?;
    }
    
    println!("   - Added 55 templates, cache size: {} (evicted {})", 
             cache.size(), 55 - cache.size());
    
    // Check statistics
    if let Some(stats) = cache.stats() {
        println!("   - Cache hits: {}", stats.hits);
        println!("   - Cache misses: {}", stats.misses);
        println!("   - Evictions: {}", stats.evictions);
    }
    
    println!();
    Ok(())
}

fn demonstrate_loader_caching() -> Result<(), Box<dyn std::error::Error>> {
    println!("4. Advanced Loader with Caching:");
    
    // Configure loader with caching enabled
    let loader_config = LoaderConfig {
        enable_caching: true,
        cache_config: CacheConfig {
            max_size: 100,
            max_age: Some(Duration::from_secs(600)), // 10 minutes
            track_file_changes: true,
            enable_stats: true,
        },
        ..LoaderConfig::default()
    };
    
    let mut loader = TemplateLoader::with_config(loader_config);
    
    // Load templates with caching
    println!("   - Loading templates from directory (with caching)...");
    let start = Instant::now();
    let templates = loader.load_from_directory("templates")?;
    let first_load_time = start.elapsed();
    
    println!("   - First load: {} templates in {:?}", templates.len(), first_load_time);
    println!("   - Cache size: {}", loader.cache_size());
    
    // Load again to test cache performance  
    let start = Instant::now();
    let _templates = loader.load_from_directory("templates")?;
    let cached_load_time = start.elapsed();
    
    println!("   - Cached load: {:?} ({}x faster)", 
             cached_load_time,
             first_load_time.as_nanos() / cached_load_time.as_nanos().max(1));
    
    // Show cache statistics
    if let Some(stats) = loader.cache_stats() {
        println!("   - Cache hit ratio: {:.2}%", stats.hit_ratio() * 100.0);
        println!("   - Total hits: {}, misses: {}", stats.hits, stats.misses);
    }
    
    println!();
    Ok(())
}

fn demonstrate_cache_monitoring() -> Result<(), Box<dyn std::error::Error>> {
    println!("5. Cache Statistics and Monitoring:");
    
    let cache = TemplateCache::with_config(CacheConfig {
        enable_stats: true,
        max_size: 10,
        ..CacheConfig::default()
    });
    
    // Generate some cache activity
    let templates = vec![
        "Template A: @[content]@",
        "Template B: @[data]@",
        "Template C: @[info]@",
        "Template D: @[value]@",
        "Template E: @[result]@",
    ];
    
    // Insert templates
    for template_content in &templates {
        let template = TronTemplate::new(template_content)?;
        cache.insert_template(template)?;
    }
    
    // Create cache hits and misses
    for _ in 0..10 {
        // Cache hits
        let _hit = cache.get_by_content(templates[0]);
        let _hit = cache.get_by_content(templates[1]);
        
        // Cache misses
        let _miss = cache.get_by_content("Nonexistent template @[x]@");
    }
    
    // Add more templates to trigger eviction
    for i in 6..15 {
        let template = TronTemplate::new(&format!("Template {}: @[data]@", i))?;
        cache.insert_template(template)?;
    }
    
    // Display comprehensive statistics
    if let Some(stats) = cache.stats() {
        println!("   - Cache Performance Metrics:");
        println!("     * Total requests: {}", stats.hits + stats.misses);
        println!("     * Cache hits: {}", stats.hits);
        println!("     * Cache misses: {}", stats.misses);
        println!("     * Hit ratio: {:.2}%", stats.hit_ratio() * 100.0);
        println!("     * Evictions: {}", stats.evictions);
        println!("     * Invalidations: {}", stats.invalidations);
    }
    
    println!("   - Current cache size: {}", cache.size());
    println!("   - Cache is empty: {}", cache.is_empty());
    
    // Clean up expired entries
    cache.cleanup_expired();
    println!("   - After cleanup: {} templates", cache.size());
    
    println!();
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cache_performance_benefits() -> Result<(), Box<dyn std::error::Error>> {
        let cache = TemplateCache::new();
        let template = TronTemplate::new("Test template @[placeholder]@")?;
        
        // Cache the template
        cache.insert_template(template.clone())?;
        
        // Verify cache hit
        let cached = cache.get_by_content("Test template @[placeholder]@");
        assert!(cached.is_some());
        assert_eq!(cached.unwrap().content(), template.content());
        
        Ok(())
    }
    
    #[test]
    fn test_loader_caching_integration() -> Result<(), Box<dyn std::error::Error>> {
        let config = LoaderConfig {
            enable_caching: true,
            ..LoaderConfig::default()
        };
        
        let loader = TemplateLoader::with_config(config);
        assert!(loader.cache_size() == 0);
        
        // Cache should be enabled
        assert!(loader.cache_stats().is_some());
        
        Ok(())
    }
}