Struct PerformanceBenchmarkResults 

pub struct PerformanceBenchmarkResults {
    pub results: Vec<BenchmarkResult>,
}

Performance benchmark results

Fields

results: Vec<BenchmarkResult>

Individual benchmark results

Implementations

impl PerformanceBenchmarkResults

pub fn best_speedup(&self) -> f64

Get the best speedup achieved

Examples found in repository

examples/advanced_showcase.rs (line 184)

fn demonstrate_advanced_gpu_optimization() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n⚡ Advanced-GPU Optimization Demonstration");
    println!("=====================================");

    // Create GPU context (falls back to CPU if no GPU available)
    println!("🔧 Initializing GPU context...");
    let gpu_config = GpuConfig {
        backend: GpuBackend::Cpu,
        threads_per_block: 1, // CPU backend only supports 1 thread per block
        ..Default::default()
    };
    let gpu_context = GpuContext::new(gpu_config)?; // Using CPU backend for demo
    println!("   Backend: {:?}", gpu_context.backend());

    // Create advanced-GPU optimizer
    let optimizer = AdvancedGpuOptimizer::new()
        .with_adaptive_kernels(true)
        .with_memory_prefetch(true)
        .with_multi_gpu(false) // Single GPU for demo
        .with_auto_tuning(true);

    // Generate advanced-optimized matrix
    println!("🔥 Generating advanced-optimized matrix...");
    let start_time = Instant::now();
    let matrix = optimizer.generate_advanced_optimized_matrix(
        &gpu_context,
        500,      // rows
        200,      // cols
        "normal", // distribution
    )?;
    let generation_time = start_time.elapsed();

    println!(
        "   Generated {}x{} matrix in: {:?}",
        matrix.nrows(),
        matrix.ncols(),
        generation_time
    );
    let matrix_mean = matrix.clone().mean();
    let matrix_std = matrix.var(1.0).sqrt();
    println!(
        "   Matrix stats: mean={:.3}, std={:.3}",
        matrix_mean, matrix_std
    );

    // Benchmark performance
    println!("📊 Running performance benchmarks...");
    let datashapes = vec![(100, 50), (500, 200), (1000, 500)];
    let benchmark_results =
        optimizer.benchmark_performance(&gpu_context, "matrix_generation", &datashapes)?;

    println!("   Benchmark Results:");
    println!(
        "     Best Speedup: {:.2}x",
        benchmark_results.best_speedup()
    );
    println!(
        "     Average Speedup: {:.2}x",
        benchmark_results.average_speedup()
    );
    println!(
        "     Total Memory Usage: {:.1} MB",
        benchmark_results.total_memory_usage()
    );

    Ok(())
}

pub fn average_speedup(&self) -> f64

Get the average speedup

Examples found in repository

examples/advanced_showcase.rs (line 188)

fn demonstrate_advanced_gpu_optimization() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n⚡ Advanced-GPU Optimization Demonstration");
    println!("=====================================");

    // Create GPU context (falls back to CPU if no GPU available)
    println!("🔧 Initializing GPU context...");
    let gpu_config = GpuConfig {
        backend: GpuBackend::Cpu,
        threads_per_block: 1, // CPU backend only supports 1 thread per block
        ..Default::default()
    };
    let gpu_context = GpuContext::new(gpu_config)?; // Using CPU backend for demo
    println!("   Backend: {:?}", gpu_context.backend());

    // Create advanced-GPU optimizer
    let optimizer = AdvancedGpuOptimizer::new()
        .with_adaptive_kernels(true)
        .with_memory_prefetch(true)
        .with_multi_gpu(false) // Single GPU for demo
        .with_auto_tuning(true);

    // Generate advanced-optimized matrix
    println!("🔥 Generating advanced-optimized matrix...");
    let start_time = Instant::now();
    let matrix = optimizer.generate_advanced_optimized_matrix(
        &gpu_context,
        500,      // rows
        200,      // cols
        "normal", // distribution
    )?;
    let generation_time = start_time.elapsed();

    println!(
        "   Generated {}x{} matrix in: {:?}",
        matrix.nrows(),
        matrix.ncols(),
        generation_time
    );
    let matrix_mean = matrix.clone().mean();
    let matrix_std = matrix.var(1.0).sqrt();
    println!(
        "   Matrix stats: mean={:.3}, std={:.3}",
        matrix_mean, matrix_std
    );

    // Benchmark performance
    println!("📊 Running performance benchmarks...");
    let datashapes = vec![(100, 50), (500, 200), (1000, 500)];
    let benchmark_results =
        optimizer.benchmark_performance(&gpu_context, "matrix_generation", &datashapes)?;

    println!("   Benchmark Results:");
    println!(
        "     Best Speedup: {:.2}x",
        benchmark_results.best_speedup()
    );
    println!(
        "     Average Speedup: {:.2}x",
        benchmark_results.average_speedup()
    );
    println!(
        "     Total Memory Usage: {:.1} MB",
        benchmark_results.total_memory_usage()
    );

    Ok(())
}

pub fn total_memory_usage(&self) -> f64

Get total memory usage

Examples found in repository

examples/advanced_showcase.rs (line 192)

fn demonstrate_advanced_gpu_optimization() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n⚡ Advanced-GPU Optimization Demonstration");
    println!("=====================================");

    // Create GPU context (falls back to CPU if no GPU available)
    println!("🔧 Initializing GPU context...");
    let gpu_config = GpuConfig {
        backend: GpuBackend::Cpu,
        threads_per_block: 1, // CPU backend only supports 1 thread per block
        ..Default::default()
    };
    let gpu_context = GpuContext::new(gpu_config)?; // Using CPU backend for demo
    println!("   Backend: {:?}", gpu_context.backend());

    // Create advanced-GPU optimizer
    let optimizer = AdvancedGpuOptimizer::new()
        .with_adaptive_kernels(true)
        .with_memory_prefetch(true)
        .with_multi_gpu(false) // Single GPU for demo
        .with_auto_tuning(true);

    // Generate advanced-optimized matrix
    println!("🔥 Generating advanced-optimized matrix...");
    let start_time = Instant::now();
    let matrix = optimizer.generate_advanced_optimized_matrix(
        &gpu_context,
        500,      // rows
        200,      // cols
        "normal", // distribution
    )?;
    let generation_time = start_time.elapsed();

    println!(
        "   Generated {}x{} matrix in: {:?}",
        matrix.nrows(),
        matrix.ncols(),
        generation_time
    );
    let matrix_mean = matrix.clone().mean();
    let matrix_std = matrix.var(1.0).sqrt();
    println!(
        "   Matrix stats: mean={:.3}, std={:.3}",
        matrix_mean, matrix_std
    );

    // Benchmark performance
    println!("📊 Running performance benchmarks...");
    let datashapes = vec![(100, 50), (500, 200), (1000, 500)];
    let benchmark_results =
        optimizer.benchmark_performance(&gpu_context, "matrix_generation", &datashapes)?;

    println!("   Benchmark Results:");
    println!(
        "     Best Speedup: {:.2}x",
        benchmark_results.best_speedup()
    );
    println!(
        "     Average Speedup: {:.2}x",
        benchmark_results.average_speedup()
    );
    println!(
        "     Total Memory Usage: {:.1} MB",
        benchmark_results.total_memory_usage()
    );

    Ok(())
}

Trait Implementations

impl Clone for PerformanceBenchmarkResults

fn clone(&self) -> PerformanceBenchmarkResults

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PerformanceBenchmarkResults

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

Formats the value using the given formatter.