Struct StorageBenchmark 

pub struct StorageBenchmark { /* private fields */ }

Storage performance benchmarking engine.

Collects LatencySamples during a benchmark run, then computes statistical summaries via StorageBenchmark::compute_result.

Example

use ipfrs_storage::{BenchmarkConfig, BenchmarkOp, StorageBenchmark};

let config = BenchmarkConfig::default_write();
let mut bench = StorageBenchmark::new(config);

// Simulate recording some operations
bench.record_op(BenchmarkOp::Write, 120, 4096, true);
bench.record_op(BenchmarkOp::Write, 95, 4096, true);

let result = bench.compute_result(500_000); // 0.5 s in µs
println!("{}", StorageBenchmark::format_result(&result));

Implementations

impl StorageBenchmark

pub fn new(config: BenchmarkConfig) -> Self

Create a new benchmark engine from the given configuration.

The PRNG is seeded from config.seed; if the seed is zero the engine falls back to a fixed non-zero seed to satisfy xorshift64 requirements.

pub fn add_sample(&mut self, sample: LatencySample)

Push a pre-built LatencySample onto the collection.

pub fn record_op( &mut self, op: BenchmarkOp, latency_us: u64, bytes: usize, success: bool, )

Record a single operation result, constructing a LatencySample and adding it to the internal collection.

pub fn sample_count(&self) -> usize

Return the number of samples currently held.

pub fn success_rate(&self) -> f64

Fraction of recorded operations that succeeded (0.0 when no samples).

pub fn reset(&mut self)

Clear all recorded samples and reset the PRNG to the original seed.

pub fn compute_result(&self, duration_us: u64) -> BenchmarkResult

Compute a BenchmarkResult from all samples collected so far.

duration_us is the wall-clock time of the entire run in microseconds. When duration_us is zero, throughput is reported as 0.0 to avoid division-by-zero.

pub fn compute_percentile(samples: &mut [u64], percentile: f64) -> u64

Compute a percentile value from a mutable slice of latency samples.

The slice is sorted in place. Returns 0 for an empty slice. percentile must be in the range [0.0, 100.0]; values outside that range are clamped.

pub fn compute_throughput(bytes: u64, duration_us: u64) -> f64

Compute throughput in megabytes per second.

Returns 0.0 when duration_us is zero.

pub fn generate_block(&mut self, size: usize) -> Vec<u8>

Generate a pseudo-random block of size bytes using the internal xorshift64 PRNG.

Each call advances the PRNG state so successive calls produce different (but deterministic) data.

pub fn format_result(result: &BenchmarkResult) -> String

Format a BenchmarkResult as a human-readable summary string.