Struct BenchmarkResult 

pub struct BenchmarkResult {
    pub operation: String,
    pub parameters: HashMap<String, String>,
    pub duration: Duration,
    pub memory_used: Option<usize>,
    pub samples: usize,
    pub features: usize,
    pub throughput: f64,
    pub success: bool,
    pub error: Option<String>,
}

Benchmark result for a single operation

Fields

operation: String

Name of the operation

parameters: HashMap<String, String>

Parameters used in the benchmark

duration: Duration

Total execution time

memory_used: Option<usize>

Memory usage in bytes (if measured)

samples: usize

Number of samples processed

features: usize

Number of features

throughput: f64

Throughput (samples per second)

success: bool

Success/failure status

error: Option<String>

Error message if failed

Implementations

impl BenchmarkResult

pub fn new(operation: String, parameters: HashMap<String, String>) -> Self

Create a new benchmark result

pub fn success( self, duration: Duration, samples: usize, features: usize, ) -> Self

Mark the benchmark as successful with timing information

pub fn failure(self, error: String) -> Self

Mark the benchmark as failed with error message

pub fn with_memory(self, memoryused: usize) -> Self

Set memory usage

pub fn formatted_duration(&self) -> String

Get formatted duration string

Examples found in repository

examples/scikit_learn_benchmark.rs (line 80)

fn analyze_toy_dataset_performance(suites: &[BenchmarkSuite]) {
    if let Some(toy_suite) = suites.iter().find(|s| s.name == "Toy Datasets") {
        println!("\n📊 TOY DATASET LOADING ANALYSIS");
        println!("{}", "-".repeat(40));

        let mut total_loading_time = Duration::ZERO;
        let mut total_samples = 0;
        let mut fastestdataset = ("", Duration::MAX);
        let mut slowestdataset = ("", Duration::ZERO);

        for result in toy_suite.successful_results() {
            total_loading_time += result.duration;
            total_samples += result.samples;

            if result.duration < fastestdataset.1 {
                fastestdataset = (&result.operation, result.duration);
            }
            if result.duration > slowestdataset.1 {
                slowestdataset = (&result.operation, result.duration);
            }

            println!(
                "  {}: {} ({} samples, {:.1} samples/s)",
                result.operation.replace("load_", ""),
                result.formatted_duration(),
                result.samples,
                result.throughput
            );
        }

        println!("\n  Summary:");
        println!(
            "    Total loading time: {:.2}s",
            total_loading_time.as_secs_f64()
        );
        println!("    Total samples loaded: {total_samples}");
        println!(
            "    Average throughput: {:.1} samples/s",
            total_samples as f64 / total_loading_time.as_secs_f64()
        );
        println!(
            "    Fastest: {} ({})",
            fastestdataset.0,
            format_duration(fastestdataset.1)
        );
        println!(
            "    Slowest: {} ({})",
            slowestdataset.0,
            format_duration(slowestdataset.1)
        );
    }
}

examples/real_world_datasets.rs (line 406)

fn demonstrate_performance_comparison() -> Result<(), Box<dyn std::error::Error>> {
    println!("⚡ PERFORMANCE COMPARISON");
    println!("{}", "-".repeat(40));

    let runner = BenchmarkRunner::new().with_iterations(3).with_warmup(1);

    // Benchmark real-world dataset loading
    println!("Benchmarking real-world dataset operations...");

    // Titanic loading benchmark
    let titanic_params = HashMap::from([("dataset".to_string(), "titanic".to_string())]);
    let titanic_result =
        runner.run_benchmark("load_titanic", titanic_params, || match load_titanic() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load Titanic: {e}")),
        });

    // California Housing loading benchmark
    let housing_params = HashMap::from([("dataset".to_string(), "california_housing".to_string())]);
    let housing_result = runner.run_benchmark("load_california_housing", housing_params, || {
        match load_california_housing() {
            Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
            Err(e) => Err(format!("Failed to load California Housing: {e}")),
        }
    });

    // Heart Disease loading benchmark
    let heart_params = HashMap::from([("dataset".to_string(), "heart_disease".to_string())]);
    let heart_result =
        runner.run_benchmark(
            "load_heart_disease",
            heart_params,
            || match load_heart_disease() {
                Ok(dataset) => Ok((dataset.n_samples(), dataset.n_features())),
                Err(e) => Err(format!("Failed to load Heart Disease: {e}")),
            },
        );

    // Display results
    println!("\nReal-world dataset loading performance:");

    let results = vec![
        ("Titanic", &titanic_result),
        ("California Housing", &housing_result),
        ("Heart Disease", &heart_result),
    ];

    for (name, result) in results {
        if result.success {
            println!(
                "  {}: {} ({} samples, {} features, {:.1} samples/s)",
                name,
                result.formatted_duration(),
                result.samples,
                result.features,
                result.throughput
            );
        } else {
            println!(
                "  {}: Failed - {}",
                name,
                result
                    .error
                    .as_ref()
                    .unwrap_or(&"Unknown error".to_string())
            );
        }
    }

    // Memory usage estimation
    let total_samples = titanic_result.samples + housing_result.samples + heart_result.samples;
    let total_features = titanic_result.features + housing_result.features + heart_result.features;
    let estimated_memory_mb = (total_samples * total_features * 8) as f64 / (1024.0 * 1024.0);

    println!("\nMemory usage estimate:");
    println!("  Total samples: {total_samples}");
    println!("  Total features: {total_features}");
    println!("  Estimated memory: {estimated_memory_mb:.1} MB");

    // Performance recommendations
    println!("\nPerformance recommendations:");
    if estimated_memory_mb > 100.0 {
        println!("  • Consider using streaming for large datasets");
        println!("  • Enable caching for frequently accessed datasets");
    }
    println!("  • Use train/test splitting to reduce memory usage");
    println!("  • Apply feature selection to reduce dimensionality");

    println!();
    Ok(())
}

pub fn formatted_throughput(&self) -> String

Get formatted throughput string

pub fn formatted_memory(&self) -> String

Get formatted memory usage string

Trait Implementations

impl Clone for BenchmarkResult

fn clone(&self) -> BenchmarkResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BenchmarkResult

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

Formats the value using the given formatter.