Struct SimpleBench 

pub struct SimpleBench { /* private fields */ }

Implementations

impl SimpleBench

pub fn new(name: &str) -> Self

Examples found in repository

examples/simple_benchmark_example.rs (line 15)

fn main() {
    quick_calibrate_tsc_frequency();
    
    #[cfg(target_arch = "aarch64")]
    {
        let resolution_ns = 1_000_000_000u64 / 24_000_000u64;
        println!("Note: ARM64 timing resolution is ~{}ns. Very fast operations may show limited precision.\n", resolution_ns);
    }
    
    println!("=== Simple Arithmetic Benchmark ===");
    SimpleBench::new("arithmetic")
        .bench(10000, || {
            let a = 42u64;
            let b = 37u64;
            a.wrapping_add(b).wrapping_mul(2)
        })
        .report();
    
    println!("\n=== Vector Allocation Benchmark ===");
    SimpleBench::new("vec_allocation")
        .bench(1000, || {
            let vec: Vec<u64> = Vec::with_capacity(100);
            drop(vec);
        })
        .report();
    
    println!("\n=== Function Call Overhead ===");
    fn dummy_function(x: u64) -> u64 {
        x.wrapping_add(1)
    }
    
    SimpleBench::new("function_call")
        .bench(5000, || dummy_function(42))
        .report();
    
    println!("\n=== Custom Analysis Example ===");
    let analysis = SimpleBench::new("analysis_example")
        .bench(1000, || std::hint::black_box(42))
        .analyze();
    
    if analysis.meets_target(100) {
        println!("✓ Performance target met! P99: {}ns", analysis.p99);
    } else {
        println!("✗ Performance target missed. P99: {}ns", analysis.p99);
    }
    
    println!("\n=== Implementation Comparison ===");
    
    let old_analysis = SimpleBench::new("old_impl")
        .bench(1000, || {
            for _ in 0..10 {
                std::hint::black_box(42);
            }
        })
        .analyze();
    
    let new_analysis = SimpleBench::new("new_impl")
        .bench(1000, || {
            std::hint::black_box(42);
        })
        .analyze();
    
    println!("Old: {}ns P99, New: {}ns P99", old_analysis.p99, new_analysis.p99);
    
    if new_analysis.mean == 0 {
        println!("Improvement: Operation too fast to measure precisely (< {}ns resolution)", 
                 1_000_000_000u64 / 24_000_000u64);
    } else {
        let improvement = (old_analysis.mean as f64 / new_analysis.mean as f64 - 1.0) * 100.0;
        println!("Improvement: {:.1}% faster", improvement);
    }
}

examples/custom_benchmark.rs (line 33)

fn main() {
    println!("🎯 Custom Benchmark Examples\n");
    
    quick_calibrate_tsc_frequency();
    
    // Benchmark 1: Simple arithmetic
    println!("=== Arithmetic Operations ===");
    SimpleBench::new("fast_multiply")
        .bench(10000, || fast_multiply(12345, 67890))
        .report();
    
    // Benchmark 2: Recursive function (warning: slow!)
    println!("\n=== Recursive Function ===");
    SimpleBench::new("fibonacci_20")
        .bench(100, || fibonacci(20))  // Only 100 iterations - fibonacci is slow!
        .report();
    
    // Benchmark 3: String operations
    println!("\n=== String Operations ===");
    SimpleBench::new("string_ops")
        .bench(1000, || string_operations())
        .report();
    
    // Benchmark 4: Compare two implementations
    println!("\n=== Implementation Comparison ===");
    let method_a = SimpleBench::new("method_a")
        .bench(5000, || {
            // Method A: Manual loop
            let mut sum = 0u64;
            for i in 0..100 {
                sum += i;
            }
            sum
        })
        .analyze();
    
    let method_b = SimpleBench::new("method_b") 
        .bench(5000, || {
            // Method B: Iterator
            (0..100u64).sum::<u64>()
        })
        .analyze();
    
    println!("Method A (manual loop): {}ns P99", method_a.p99);
    println!("Method B (iterator):    {}ns P99", method_b.p99);
    
    if method_b.p99 < method_a.p99 {
        let improvement = (method_a.p99 as f64 / method_b.p99 as f64 - 1.0) * 100.0;
        println!("Iterator is {:.1}% faster!", improvement);
    } else {
        let degradation = (method_b.p99 as f64 / method_a.p99 as f64 - 1.0) * 100.0;
        println!("Manual loop is {:.1}% faster!", degradation);
    }
    
    // Benchmark 5: Performance validation
    println!("\n=== Performance Validation ===");
    let critical_path = SimpleBench::new("critical_operation")
        .bench(1000, || {
            // Simulate a critical operation
            std::hint::black_box(42 * 37 + 15)
        })
        .analyze();
    
    const TARGET_P99_NS: u64 = 100;
    if critical_path.meets_target(TARGET_P99_NS) {
        println!("✅ Performance target met! P99: {}ns (target: <{}ns)", 
                 critical_path.p99, TARGET_P99_NS);
    } else {
        println!("❌ Performance target missed! P99: {}ns (target: <{}ns)", 
                 critical_path.p99, TARGET_P99_NS);
    }
}

examples/real_comparison.rs (line 35)

fn main() {
    quick_calibrate_tsc_frequency();
    
    println!("🔬 Real Algorithm Comparisons\n");
    
    // Test 1: Sum algorithms
    println!("=== Sum Algorithms (n=100) ===");
    
    let loop_perf = SimpleBench::new("sum_with_loop")
        .bench(10000, || sum_with_loop(100))
        .analyze();
    
    let formula_perf = SimpleBench::new("sum_with_formula")
        .bench(10000, || sum_with_formula(100))
        .analyze();
    
    println!("Loop method:    mean={}ns, P99={}ns", loop_perf.mean, loop_perf.p99);
    println!("Formula method: mean={}ns, P99={}ns", formula_perf.mean, formula_perf.p99);
    
    if formula_perf.mean < loop_perf.mean {
        let improvement = (loop_perf.mean as f64 / formula_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Formula is {:.1}% faster", improvement);
    } else if loop_perf.mean < formula_perf.mean {
        let degradation = (formula_perf.mean as f64 / loop_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Loop is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both methods perform similarly");
    }
    
    // Test 2: Even number check
    println!("\n=== Even Number Check ===");
    
    let modulo_perf = SimpleBench::new("is_even_modulo")
        .bench(10000, || is_even_modulo(12345))
        .analyze();
    
    let bitwise_perf = SimpleBench::new("is_even_bitwise")
        .bench(10000, || is_even_bitwise(12345))
        .analyze();
    
    println!("Modulo method:  mean={}ns, P99={}ns", modulo_perf.mean, modulo_perf.p99);
    println!("Bitwise method: mean={}ns, P99={}ns", bitwise_perf.mean, bitwise_perf.p99);
    
    if bitwise_perf.mean < modulo_perf.mean {
        let improvement = (modulo_perf.mean as f64 / bitwise_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Bitwise is {:.1}% faster", improvement);
    } else if modulo_perf.mean < bitwise_perf.mean {
        let degradation = (bitwise_perf.mean as f64 / modulo_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Modulo is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both methods perform similarly");
    }
    
    // Test 3: Vector vs Array
    println!("\n=== Vector vs Array Access ===");
    
    let vec_data = vec![1, 2, 3, 4, 5];
    let array_data = [1, 2, 3, 4, 5];
    
    let vec_perf = SimpleBench::new("vector_access")
        .bench(10000, || {
            let sum = vec_data.iter().sum::<i32>();
            std::hint::black_box(sum);
        })
        .analyze();
    
    let array_perf = SimpleBench::new("array_access")
        .bench(10000, || {
            let sum = array_data.iter().sum::<i32>();
            std::hint::black_box(sum);
        })
        .analyze();
    
    println!("Vector access: mean={}ns, P99={}ns", vec_perf.mean, vec_perf.p99);
    println!("Array access:  mean={}ns, P99={}ns", array_perf.mean, array_perf.p99);
    
    if array_perf.mean < vec_perf.mean {
        let improvement = (vec_perf.mean as f64 / array_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Array is {:.1}% faster", improvement);
    } else if vec_perf.mean < array_perf.mean {
        let degradation = (array_perf.mean as f64 / vec_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Vector is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both perform similarly");
    }
    
    println!("\n💡 Note: Results may vary between runs due to:");
    println!("   - CPU cache state");
    println!("   - System load");
    println!("   - Compiler optimizations");
    println!("   - Memory layout");
}

pub fn bench<F, R>(self, iterations: usize, f: F) -> Self

where F: FnMut() -> R,

Examples found in repository

examples/simple_benchmark_example.rs (lines 16-20)

fn main() {
    quick_calibrate_tsc_frequency();
    
    #[cfg(target_arch = "aarch64")]
    {
        let resolution_ns = 1_000_000_000u64 / 24_000_000u64;
        println!("Note: ARM64 timing resolution is ~{}ns. Very fast operations may show limited precision.\n", resolution_ns);
    }
    
    println!("=== Simple Arithmetic Benchmark ===");
    SimpleBench::new("arithmetic")
        .bench(10000, || {
            let a = 42u64;
            let b = 37u64;
            a.wrapping_add(b).wrapping_mul(2)
        })
        .report();
    
    println!("\n=== Vector Allocation Benchmark ===");
    SimpleBench::new("vec_allocation")
        .bench(1000, || {
            let vec: Vec<u64> = Vec::with_capacity(100);
            drop(vec);
        })
        .report();
    
    println!("\n=== Function Call Overhead ===");
    fn dummy_function(x: u64) -> u64 {
        x.wrapping_add(1)
    }
    
    SimpleBench::new("function_call")
        .bench(5000, || dummy_function(42))
        .report();
    
    println!("\n=== Custom Analysis Example ===");
    let analysis = SimpleBench::new("analysis_example")
        .bench(1000, || std::hint::black_box(42))
        .analyze();
    
    if analysis.meets_target(100) {
        println!("✓ Performance target met! P99: {}ns", analysis.p99);
    } else {
        println!("✗ Performance target missed. P99: {}ns", analysis.p99);
    }
    
    println!("\n=== Implementation Comparison ===");
    
    let old_analysis = SimpleBench::new("old_impl")
        .bench(1000, || {
            for _ in 0..10 {
                std::hint::black_box(42);
            }
        })
        .analyze();
    
    let new_analysis = SimpleBench::new("new_impl")
        .bench(1000, || {
            std::hint::black_box(42);
        })
        .analyze();
    
    println!("Old: {}ns P99, New: {}ns P99", old_analysis.p99, new_analysis.p99);
    
    if new_analysis.mean == 0 {
        println!("Improvement: Operation too fast to measure precisely (< {}ns resolution)", 
                 1_000_000_000u64 / 24_000_000u64);
    } else {
        let improvement = (old_analysis.mean as f64 / new_analysis.mean as f64 - 1.0) * 100.0;
        println!("Improvement: {:.1}% faster", improvement);
    }
}

examples/custom_benchmark.rs (line 34)

fn main() {
    println!("🎯 Custom Benchmark Examples\n");
    
    quick_calibrate_tsc_frequency();
    
    // Benchmark 1: Simple arithmetic
    println!("=== Arithmetic Operations ===");
    SimpleBench::new("fast_multiply")
        .bench(10000, || fast_multiply(12345, 67890))
        .report();
    
    // Benchmark 2: Recursive function (warning: slow!)
    println!("\n=== Recursive Function ===");
    SimpleBench::new("fibonacci_20")
        .bench(100, || fibonacci(20))  // Only 100 iterations - fibonacci is slow!
        .report();
    
    // Benchmark 3: String operations
    println!("\n=== String Operations ===");
    SimpleBench::new("string_ops")
        .bench(1000, || string_operations())
        .report();
    
    // Benchmark 4: Compare two implementations
    println!("\n=== Implementation Comparison ===");
    let method_a = SimpleBench::new("method_a")
        .bench(5000, || {
            // Method A: Manual loop
            let mut sum = 0u64;
            for i in 0..100 {
                sum += i;
            }
            sum
        })
        .analyze();
    
    let method_b = SimpleBench::new("method_b") 
        .bench(5000, || {
            // Method B: Iterator
            (0..100u64).sum::<u64>()
        })
        .analyze();
    
    println!("Method A (manual loop): {}ns P99", method_a.p99);
    println!("Method B (iterator):    {}ns P99", method_b.p99);
    
    if method_b.p99 < method_a.p99 {
        let improvement = (method_a.p99 as f64 / method_b.p99 as f64 - 1.0) * 100.0;
        println!("Iterator is {:.1}% faster!", improvement);
    } else {
        let degradation = (method_b.p99 as f64 / method_a.p99 as f64 - 1.0) * 100.0;
        println!("Manual loop is {:.1}% faster!", degradation);
    }
    
    // Benchmark 5: Performance validation
    println!("\n=== Performance Validation ===");
    let critical_path = SimpleBench::new("critical_operation")
        .bench(1000, || {
            // Simulate a critical operation
            std::hint::black_box(42 * 37 + 15)
        })
        .analyze();
    
    const TARGET_P99_NS: u64 = 100;
    if critical_path.meets_target(TARGET_P99_NS) {
        println!("✅ Performance target met! P99: {}ns (target: <{}ns)", 
                 critical_path.p99, TARGET_P99_NS);
    } else {
        println!("❌ Performance target missed! P99: {}ns (target: <{}ns)", 
                 critical_path.p99, TARGET_P99_NS);
    }
}

examples/real_comparison.rs (line 36)

fn main() {
    quick_calibrate_tsc_frequency();
    
    println!("🔬 Real Algorithm Comparisons\n");
    
    // Test 1: Sum algorithms
    println!("=== Sum Algorithms (n=100) ===");
    
    let loop_perf = SimpleBench::new("sum_with_loop")
        .bench(10000, || sum_with_loop(100))
        .analyze();
    
    let formula_perf = SimpleBench::new("sum_with_formula")
        .bench(10000, || sum_with_formula(100))
        .analyze();
    
    println!("Loop method:    mean={}ns, P99={}ns", loop_perf.mean, loop_perf.p99);
    println!("Formula method: mean={}ns, P99={}ns", formula_perf.mean, formula_perf.p99);
    
    if formula_perf.mean < loop_perf.mean {
        let improvement = (loop_perf.mean as f64 / formula_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Formula is {:.1}% faster", improvement);
    } else if loop_perf.mean < formula_perf.mean {
        let degradation = (formula_perf.mean as f64 / loop_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Loop is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both methods perform similarly");
    }
    
    // Test 2: Even number check
    println!("\n=== Even Number Check ===");
    
    let modulo_perf = SimpleBench::new("is_even_modulo")
        .bench(10000, || is_even_modulo(12345))
        .analyze();
    
    let bitwise_perf = SimpleBench::new("is_even_bitwise")
        .bench(10000, || is_even_bitwise(12345))
        .analyze();
    
    println!("Modulo method:  mean={}ns, P99={}ns", modulo_perf.mean, modulo_perf.p99);
    println!("Bitwise method: mean={}ns, P99={}ns", bitwise_perf.mean, bitwise_perf.p99);
    
    if bitwise_perf.mean < modulo_perf.mean {
        let improvement = (modulo_perf.mean as f64 / bitwise_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Bitwise is {:.1}% faster", improvement);
    } else if modulo_perf.mean < bitwise_perf.mean {
        let degradation = (bitwise_perf.mean as f64 / modulo_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Modulo is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both methods perform similarly");
    }
    
    // Test 3: Vector vs Array
    println!("\n=== Vector vs Array Access ===");
    
    let vec_data = vec![1, 2, 3, 4, 5];
    let array_data = [1, 2, 3, 4, 5];
    
    let vec_perf = SimpleBench::new("vector_access")
        .bench(10000, || {
            let sum = vec_data.iter().sum::<i32>();
            std::hint::black_box(sum);
        })
        .analyze();
    
    let array_perf = SimpleBench::new("array_access")
        .bench(10000, || {
            let sum = array_data.iter().sum::<i32>();
            std::hint::black_box(sum);
        })
        .analyze();
    
    println!("Vector access: mean={}ns, P99={}ns", vec_perf.mean, vec_perf.p99);
    println!("Array access:  mean={}ns, P99={}ns", array_perf.mean, array_perf.p99);
    
    if array_perf.mean < vec_perf.mean {
        let improvement = (vec_perf.mean as f64 / array_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Array is {:.1}% faster", improvement);
    } else if vec_perf.mean < array_perf.mean {
        let degradation = (array_perf.mean as f64 / vec_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Vector is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both perform similarly");
    }
    
    println!("\n💡 Note: Results may vary between runs due to:");
    println!("   - CPU cache state");
    println!("   - System load");
    println!("   - Compiler optimizations");
    println!("   - Memory layout");
}

pub fn report(self)

Examples found in repository

examples/simple_benchmark_example.rs (line 21)

fn main() {
    quick_calibrate_tsc_frequency();
    
    #[cfg(target_arch = "aarch64")]
    {
        let resolution_ns = 1_000_000_000u64 / 24_000_000u64;
        println!("Note: ARM64 timing resolution is ~{}ns. Very fast operations may show limited precision.\n", resolution_ns);
    }
    
    println!("=== Simple Arithmetic Benchmark ===");
    SimpleBench::new("arithmetic")
        .bench(10000, || {
            let a = 42u64;
            let b = 37u64;
            a.wrapping_add(b).wrapping_mul(2)
        })
        .report();
    
    println!("\n=== Vector Allocation Benchmark ===");
    SimpleBench::new("vec_allocation")
        .bench(1000, || {
            let vec: Vec<u64> = Vec::with_capacity(100);
            drop(vec);
        })
        .report();
    
    println!("\n=== Function Call Overhead ===");
    fn dummy_function(x: u64) -> u64 {
        x.wrapping_add(1)
    }
    
    SimpleBench::new("function_call")
        .bench(5000, || dummy_function(42))
        .report();
    
    println!("\n=== Custom Analysis Example ===");
    let analysis = SimpleBench::new("analysis_example")
        .bench(1000, || std::hint::black_box(42))
        .analyze();
    
    if analysis.meets_target(100) {
        println!("✓ Performance target met! P99: {}ns", analysis.p99);
    } else {
        println!("✗ Performance target missed. P99: {}ns", analysis.p99);
    }
    
    println!("\n=== Implementation Comparison ===");
    
    let old_analysis = SimpleBench::new("old_impl")
        .bench(1000, || {
            for _ in 0..10 {
                std::hint::black_box(42);
            }
        })
        .analyze();
    
    let new_analysis = SimpleBench::new("new_impl")
        .bench(1000, || {
            std::hint::black_box(42);
        })
        .analyze();
    
    println!("Old: {}ns P99, New: {}ns P99", old_analysis.p99, new_analysis.p99);
    
    if new_analysis.mean == 0 {
        println!("Improvement: Operation too fast to measure precisely (< {}ns resolution)", 
                 1_000_000_000u64 / 24_000_000u64);
    } else {
        let improvement = (old_analysis.mean as f64 / new_analysis.mean as f64 - 1.0) * 100.0;
        println!("Improvement: {:.1}% faster", improvement);
    }
}

examples/custom_benchmark.rs (line 35)

fn main() {
    println!("🎯 Custom Benchmark Examples\n");
    
    quick_calibrate_tsc_frequency();
    
    // Benchmark 1: Simple arithmetic
    println!("=== Arithmetic Operations ===");
    SimpleBench::new("fast_multiply")
        .bench(10000, || fast_multiply(12345, 67890))
        .report();
    
    // Benchmark 2: Recursive function (warning: slow!)
    println!("\n=== Recursive Function ===");
    SimpleBench::new("fibonacci_20")
        .bench(100, || fibonacci(20))  // Only 100 iterations - fibonacci is slow!
        .report();
    
    // Benchmark 3: String operations
    println!("\n=== String Operations ===");
    SimpleBench::new("string_ops")
        .bench(1000, || string_operations())
        .report();
    
    // Benchmark 4: Compare two implementations
    println!("\n=== Implementation Comparison ===");
    let method_a = SimpleBench::new("method_a")
        .bench(5000, || {
            // Method A: Manual loop
            let mut sum = 0u64;
            for i in 0..100 {
                sum += i;
            }
            sum
        })
        .analyze();
    
    let method_b = SimpleBench::new("method_b") 
        .bench(5000, || {
            // Method B: Iterator
            (0..100u64).sum::<u64>()
        })
        .analyze();
    
    println!("Method A (manual loop): {}ns P99", method_a.p99);
    println!("Method B (iterator):    {}ns P99", method_b.p99);
    
    if method_b.p99 < method_a.p99 {
        let improvement = (method_a.p99 as f64 / method_b.p99 as f64 - 1.0) * 100.0;
        println!("Iterator is {:.1}% faster!", improvement);
    } else {
        let degradation = (method_b.p99 as f64 / method_a.p99 as f64 - 1.0) * 100.0;
        println!("Manual loop is {:.1}% faster!", degradation);
    }
    
    // Benchmark 5: Performance validation
    println!("\n=== Performance Validation ===");
    let critical_path = SimpleBench::new("critical_operation")
        .bench(1000, || {
            // Simulate a critical operation
            std::hint::black_box(42 * 37 + 15)
        })
        .analyze();
    
    const TARGET_P99_NS: u64 = 100;
    if critical_path.meets_target(TARGET_P99_NS) {
        println!("✅ Performance target met! P99: {}ns (target: <{}ns)", 
                 critical_path.p99, TARGET_P99_NS);
    } else {
        println!("❌ Performance target missed! P99: {}ns (target: <{}ns)", 
                 critical_path.p99, TARGET_P99_NS);
    }
}

pub fn analyze(self) -> BenchmarkAnalysis

Examples found in repository

examples/simple_benchmark_example.rs (line 43)

fn main() {
    quick_calibrate_tsc_frequency();
    
    #[cfg(target_arch = "aarch64")]
    {
        let resolution_ns = 1_000_000_000u64 / 24_000_000u64;
        println!("Note: ARM64 timing resolution is ~{}ns. Very fast operations may show limited precision.\n", resolution_ns);
    }
    
    println!("=== Simple Arithmetic Benchmark ===");
    SimpleBench::new("arithmetic")
        .bench(10000, || {
            let a = 42u64;
            let b = 37u64;
            a.wrapping_add(b).wrapping_mul(2)
        })
        .report();
    
    println!("\n=== Vector Allocation Benchmark ===");
    SimpleBench::new("vec_allocation")
        .bench(1000, || {
            let vec: Vec<u64> = Vec::with_capacity(100);
            drop(vec);
        })
        .report();
    
    println!("\n=== Function Call Overhead ===");
    fn dummy_function(x: u64) -> u64 {
        x.wrapping_add(1)
    }
    
    SimpleBench::new("function_call")
        .bench(5000, || dummy_function(42))
        .report();
    
    println!("\n=== Custom Analysis Example ===");
    let analysis = SimpleBench::new("analysis_example")
        .bench(1000, || std::hint::black_box(42))
        .analyze();
    
    if analysis.meets_target(100) {
        println!("✓ Performance target met! P99: {}ns", analysis.p99);
    } else {
        println!("✗ Performance target missed. P99: {}ns", analysis.p99);
    }
    
    println!("\n=== Implementation Comparison ===");
    
    let old_analysis = SimpleBench::new("old_impl")
        .bench(1000, || {
            for _ in 0..10 {
                std::hint::black_box(42);
            }
        })
        .analyze();
    
    let new_analysis = SimpleBench::new("new_impl")
        .bench(1000, || {
            std::hint::black_box(42);
        })
        .analyze();
    
    println!("Old: {}ns P99, New: {}ns P99", old_analysis.p99, new_analysis.p99);
    
    if new_analysis.mean == 0 {
        println!("Improvement: Operation too fast to measure precisely (< {}ns resolution)", 
                 1_000_000_000u64 / 24_000_000u64);
    } else {
        let improvement = (old_analysis.mean as f64 / new_analysis.mean as f64 - 1.0) * 100.0;
        println!("Improvement: {:.1}% faster", improvement);
    }
}

examples/custom_benchmark.rs (line 60)

fn main() {
    println!("🎯 Custom Benchmark Examples\n");
    
    quick_calibrate_tsc_frequency();
    
    // Benchmark 1: Simple arithmetic
    println!("=== Arithmetic Operations ===");
    SimpleBench::new("fast_multiply")
        .bench(10000, || fast_multiply(12345, 67890))
        .report();
    
    // Benchmark 2: Recursive function (warning: slow!)
    println!("\n=== Recursive Function ===");
    SimpleBench::new("fibonacci_20")
        .bench(100, || fibonacci(20))  // Only 100 iterations - fibonacci is slow!
        .report();
    
    // Benchmark 3: String operations
    println!("\n=== String Operations ===");
    SimpleBench::new("string_ops")
        .bench(1000, || string_operations())
        .report();
    
    // Benchmark 4: Compare two implementations
    println!("\n=== Implementation Comparison ===");
    let method_a = SimpleBench::new("method_a")
        .bench(5000, || {
            // Method A: Manual loop
            let mut sum = 0u64;
            for i in 0..100 {
                sum += i;
            }
            sum
        })
        .analyze();
    
    let method_b = SimpleBench::new("method_b") 
        .bench(5000, || {
            // Method B: Iterator
            (0..100u64).sum::<u64>()
        })
        .analyze();
    
    println!("Method A (manual loop): {}ns P99", method_a.p99);
    println!("Method B (iterator):    {}ns P99", method_b.p99);
    
    if method_b.p99 < method_a.p99 {
        let improvement = (method_a.p99 as f64 / method_b.p99 as f64 - 1.0) * 100.0;
        println!("Iterator is {:.1}% faster!", improvement);
    } else {
        let degradation = (method_b.p99 as f64 / method_a.p99 as f64 - 1.0) * 100.0;
        println!("Manual loop is {:.1}% faster!", degradation);
    }
    
    // Benchmark 5: Performance validation
    println!("\n=== Performance Validation ===");
    let critical_path = SimpleBench::new("critical_operation")
        .bench(1000, || {
            // Simulate a critical operation
            std::hint::black_box(42 * 37 + 15)
        })
        .analyze();
    
    const TARGET_P99_NS: u64 = 100;
    if critical_path.meets_target(TARGET_P99_NS) {
        println!("✅ Performance target met! P99: {}ns (target: <{}ns)", 
                 critical_path.p99, TARGET_P99_NS);
    } else {
        println!("❌ Performance target missed! P99: {}ns (target: <{}ns)", 
                 critical_path.p99, TARGET_P99_NS);
    }
}

examples/real_comparison.rs (line 37)

fn main() {
    quick_calibrate_tsc_frequency();
    
    println!("🔬 Real Algorithm Comparisons\n");
    
    // Test 1: Sum algorithms
    println!("=== Sum Algorithms (n=100) ===");
    
    let loop_perf = SimpleBench::new("sum_with_loop")
        .bench(10000, || sum_with_loop(100))
        .analyze();
    
    let formula_perf = SimpleBench::new("sum_with_formula")
        .bench(10000, || sum_with_formula(100))
        .analyze();
    
    println!("Loop method:    mean={}ns, P99={}ns", loop_perf.mean, loop_perf.p99);
    println!("Formula method: mean={}ns, P99={}ns", formula_perf.mean, formula_perf.p99);
    
    if formula_perf.mean < loop_perf.mean {
        let improvement = (loop_perf.mean as f64 / formula_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Formula is {:.1}% faster", improvement);
    } else if loop_perf.mean < formula_perf.mean {
        let degradation = (formula_perf.mean as f64 / loop_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Loop is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both methods perform similarly");
    }
    
    // Test 2: Even number check
    println!("\n=== Even Number Check ===");
    
    let modulo_perf = SimpleBench::new("is_even_modulo")
        .bench(10000, || is_even_modulo(12345))
        .analyze();
    
    let bitwise_perf = SimpleBench::new("is_even_bitwise")
        .bench(10000, || is_even_bitwise(12345))
        .analyze();
    
    println!("Modulo method:  mean={}ns, P99={}ns", modulo_perf.mean, modulo_perf.p99);
    println!("Bitwise method: mean={}ns, P99={}ns", bitwise_perf.mean, bitwise_perf.p99);
    
    if bitwise_perf.mean < modulo_perf.mean {
        let improvement = (modulo_perf.mean as f64 / bitwise_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Bitwise is {:.1}% faster", improvement);
    } else if modulo_perf.mean < bitwise_perf.mean {
        let degradation = (bitwise_perf.mean as f64 / modulo_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Modulo is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both methods perform similarly");
    }
    
    // Test 3: Vector vs Array
    println!("\n=== Vector vs Array Access ===");
    
    let vec_data = vec![1, 2, 3, 4, 5];
    let array_data = [1, 2, 3, 4, 5];
    
    let vec_perf = SimpleBench::new("vector_access")
        .bench(10000, || {
            let sum = vec_data.iter().sum::<i32>();
            std::hint::black_box(sum);
        })
        .analyze();
    
    let array_perf = SimpleBench::new("array_access")
        .bench(10000, || {
            let sum = array_data.iter().sum::<i32>();
            std::hint::black_box(sum);
        })
        .analyze();
    
    println!("Vector access: mean={}ns, P99={}ns", vec_perf.mean, vec_perf.p99);
    println!("Array access:  mean={}ns, P99={}ns", array_perf.mean, array_perf.p99);
    
    if array_perf.mean < vec_perf.mean {
        let improvement = (vec_perf.mean as f64 / array_perf.mean as f64 - 1.0) * 100.0;
        println!("✅ Array is {:.1}% faster", improvement);
    } else if vec_perf.mean < array_perf.mean {
        let degradation = (array_perf.mean as f64 / vec_perf.mean as f64 - 1.0) * 100.0;
        println!("⚠️  Vector is {:.1}% faster", degradation);
    } else {
        println!("🤝 Both perform similarly");
    }
    
    println!("\n💡 Note: Results may vary between runs due to:");
    println!("   - CPU cache state");
    println!("   - System load");
    println!("   - Compiler optimizations");
    println!("   - Memory layout");
}