Runtime Optimization

// The VM tracks:
- Function call counts
- Execution duration
- Argument patterns
- Memory allocation rates
- Cache behavior

// Example: This function becomes "hot" after 100 calls
private function calculate_distance(p1: Point, p2: Point) -> float {
    let dx = p2.x - p1.x;
    let dy = p2.y - p1.y;
    sqrt(dx * dx + dy * dy)
}

// Original bytecode
LOAD_LOCAL 0
LOAD_LOCAL 1
SUB
DUP
MUL
...

// Optimized variant (with CSE and strength reduction)
LOAD_LOCAL 0
LOAD_LOCAL 1
SUB_AND_SQUARE  // Fused operation
...

ExecutionMetrics {
    duration: 125µs → 23µs        // 5.4x faster
    instructions: 847 → 203       // 76% fewer instructions
    allocations: 12 → 2          // 83% less memory pressure
    cache_misses: 45 → 8         // Better cache utilization
}

// Example: Enable only memoization and CSE
let custom_strategy = OptimizationStrategy::Custom(0x1004);
// Bit 2 (0x004): Common Subexpression Elimination
// Bit 12 (0x1000): Memoization

// Common combinations:
const MEMORY_FOCUSED = 0x1404;  // Memoization + Loop Invariant Motion
const COMPUTE_FOCUSED = 0x10C;  // CSE + Inlining + Strength Reduction
const BALANCED = 0x80F;         // Multiple balanced optimizations

// Tests only 4 predefined strategies
ExplorationMode::Quick
// ✓ Fast exploration (< 1 second)
// ✓ Good for simple programs
// ✗ May miss optimal combinations

// Tests 19 carefully selected combinations
ExplorationMode::Smart
// ✓ Balanced exploration/exploitation
// ✓ Covers most common patterns
// ✓ Usually finds near-optimal solution

// Tests all 8192 possible combinations
ExplorationMode::Exhaustive
// ✓ Guaranteed to find optimal combination
// ✗ Very time consuming
// ✗ Usually overkill

// Enable with default settings
let mut vm = VM::new();
vm.enable_learning_mode(LearningModeConfig::default());

// Default configuration:
// - Hot threshold: 100 calls
// - Smart exploration mode
// - 20% exploration rate
// - RL agent enabled

let config = LearningModeConfig {
    // Lower threshold for faster optimization
    hot_threshold: 50,
    
    // More aggressive exploration
    max_strategies_per_function: 20,
    exploration_rate: 0.3,
    
    // Use exhaustive mode for critical functions
    exploration_mode: ExplorationMode::Exhaustive,
    
    // Save optimizations across runs
    save_learned_data: true,
    model_path: Some("./optimizations.flai"),
    
    // Enable AI-guided exploration
    use_rl_agent: true,
};

vm.enable_learning_mode(config);

// Force specific functions to use certain strategies
vm.set_function_hint("critical_path", OptimizationHint::Aggressive);
vm.set_function_hint("debug_func", OptimizationHint::None);

// Exclude functions from optimization
vm.exclude_from_optimization(&["logging", "debug_*"]);

// Get current optimization status
let stats = vm.get_learning_stats();

$(f"=== Optimization Report ===").print();
$(f"Functions analyzed: {stats.functions_analyzed}").print();
$(f"Hot functions: {stats.hot_functions}").print();
$(f"Optimized: {stats.functions_explored}").print();
$(f"Total variants: {stats.total_variants}").print();

// Track exploration progress
for (func, tested, total) in stats.exploration_progress {
    let percent = (tested as f32 / total as f32) * 100.0;
    $(f"{func}: {percent}% complete ({tested}/{total})").print();
}

// Compare performance before/after optimization
let baseline = vm.get_function_metrics("my_function", OptimizationStrategy::None);
let optimized = vm.get_function_metrics("my_function", OptimizationStrategy::Best);

let speedup = baseline.duration / optimized.duration;
$(f"Performance improvement: {speedup}x faster!").print();
$(f"Instructions reduced: {}%", 
    (1.0 - optimized.instructions / baseline.instructions) * 100.0
).print();

// Expensive recursive function
private function fibonacci(n: int) -> int {
    if (n <= 1) { n }
    else { fibonacci(n-1) + fibonacci(n-2) }
}

// First run: ~5 seconds for fib(40)
let result = fibonacci(40);

// After 100 calls, learning mode detects:
// - Function is pure (no side effects)
// - Recursive with overlapping subproblems
// - Applies automatic memoization

// Subsequent runs: ~0.001 seconds
// 5000x speedup achieved automatically!

// Original code with multiple passes
private function process_data(data: List) -> float {
    data
        .map(x => x * 2.0)      // Pass 1
        .filter(x => x > 10.0)  // Pass 2
        .map(x => sqrt(x))      // Pass 3
        .sum()                  // Pass 4
}

// After optimization:
// - Detects multiple traversals
// - Fuses operations into single pass
// - Applies SIMD vectorization
// Result: 4x faster with 75% less memory usage

// Function often called with specific values
private function render_shape(type: string, params: RenderParams) {
    match type {
        "circle" => render_circle(params),    // 70% of calls
        "square" => render_square(params),    // 20% of calls
        "triangle" => render_triangle(params), // 8% of calls
        _ => render_generic(params)           // 2% of calls
    }
}

// Learning mode creates specialized versions:
// - render_shape_circle() - optimized for circles
// - render_shape_generic() - handles other cases
// Result: 40% performance improvement

// Run typical workloads during learning phase
vm.enable_learning_mode(config);

// Execute representative operations
run_typical_workload();
process_average_dataset();
simulate_user_interactions();

// Save learned optimizations
vm.save_optimizations("production.flai");

// Set memory limits for variant storage
config.max_variants_memory = 100 * 1024 * 1024; // 100MB
config.variant_cache_policy = CachePolicy::LRU;

// Monitor variant memory usage
let memory_stats = vm.get_variant_memory_stats();
if memory_stats.total_size > threshold {
    vm.evict_cold_variants();
}

// Use static optimization hints where appropriate
#[inline(always)]
private function hot_path() { ... }

#[pure]
private function compute_hash(data: string) -> u64 { ... }

// Let runtime optimization handle the rest
vm.enable_learning_mode(config);

// Solution 1: Check for optimization conflicts
vm.validate_optimizations();

// Solution 2: Disable problematic optimizations
config.disabled_optimizations = vec![
    OptimizationPass::FunctionInlining,
];

// Solution 3: Reset and re-learn
vm.reset_optimization_data("function_name");

// Limit variants per function
config.max_variants_per_function = 5;

// Enable aggressive eviction
config.variant_eviction_threshold = 0.7;

// Monitor and clean up
vm.cleanup_cold_variants(Duration::from_secs(300));

// Use parallel exploration
config.parallel_exploration = true;
config.exploration_threads = 4;

// Reduce exploration space
config.exploration_mode = ExplorationMode::Quick;

// Focus on hot paths only
config.hot_threshold = 1000; // Higher threshold