Struct BenchmarkAnalysis 

pub struct BenchmarkAnalysis {
    pub name: String,
    pub count: usize,
    pub min: u64,
    pub max: u64,
    pub mean: u64,
    pub p50: u64,
    pub p95: u64,
    pub p99: u64,
    pub p999: u64,
    pub std_dev: f64,
}

Fields

name: String

count: usize

min: u64

max: u64

mean: u64

p50: u64

p95: u64

p99: u64

p999: u64

std_dev: f64

Implementations

impl BenchmarkAnalysis

pub fn empty(name: String) -> Self

pub fn summary(&self) -> String

pub fn meets_target(&self, target_p99_ns: u64) -> bool

Examples found in repository

examples/simple_benchmark_example.rs (line 45)

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 90)

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);
    }
}

Trait Implementations

impl Clone for BenchmarkAnalysis

fn clone(&self) -> BenchmarkAnalysis

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BenchmarkAnalysis

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.