quantumclaw/clawhdf5
3
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

feat: add h5bench-equivalent Criterion benchmarks to clawhdf5-bench

Browse Source 
Adds three Criterion benchmark suites mirroring the h5bench HPC I/O
benchmark workloads in pure Rust — no C libhdf5 required for the default
path, with an optional `libhdf5-compare` feature for side-by-side numbers.

  - benches/h5bench_write.rs: write_1d_contiguous, write_2d_chunked,
    write_f64_batch, write_multi_dataset, write_with_attrs
  - benches/h5bench_read.rs: read_sequential, read_f64_sequential,
    read_chunked_2d, read_from_disk, read_hyperslab
  - benches/h5bench_meta.rs: metadata_attrs_write, metadata_attrs_read,
    metadata_groups_create, metadata_groups_traverse, metadata_string_attrs

All benchmarks pass `cargo bench --bench <name> -- --test` and clippy
reports zero warnings.  Run with `cargo bench -p clawhdf5-bench`.

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>
This commit is contained in:
Omar Sobh
2026-06-30 11:41:41 +00:00
co-authored by Claude Sonnet 4.6
parent 28a0dc3384
commit 90bdd7cd13
4 changed files with 681 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/clawhdf5-bench/benches/h5bench_meta.rs
+231
View File
@@ -0,0 +1,231 @@
//! h5bench-equivalent metadata workloads for clawhdf5.
//!
//! Measures attribute creation/read throughput and group traversal latency —
//! the workloads that h5bench's `metadata` mode targets against libhdf5.
use clawhdf5::{AttrValue, File, FileBuilder};
use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
use tempfile::TempDir;
// ---------------------------------------------------------------------------
// Workload: metadata_attrs_write
// Create K attributes on a single dataset.
// Exercises attribute message allocation and compact → dense header transition.
// ---------------------------------------------------------------------------
fn bench_metadata_attrs_write(c: &mut Criterion) {
let mut group = c.benchmark_group("metadata_attrs_write");
for &k in &[4usize, 16, 64, 128] {
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("clawhdf5", k), &k, |b, &k| {
let tmp = TempDir::new().unwrap();
let path = tmp.path().join("attrs_write.h5");
b.iter(|| {
let mut fb = FileBuilder::new();
let ds = fb
.create_dataset("data")
.with_f64_data(&[1.0, 2.0, 3.0])
.with_shape(&[3]);
for i in 0..k {
ds.set_attr(&format!("attr_{i:04}"), AttrValue::I64(i as i64));
}
fb.write(&path).unwrap();
});
});
#[cfg(feature = "libhdf5-compare")]
group.bench_with_input(BenchmarkId::new("libhdf5", k), &k, |b, &k| {
let tmp = TempDir::new().unwrap();
let path = tmp.path().join("attrs_libhdf5.h5");
b.iter(|| {
let file = hdf5::File::create(&path).unwrap();
let ds = file
.new_dataset::<f64>()
.shape([3])
.create("data")
.unwrap();
ds.write(&[1.0f64, 2.0, 3.0]).unwrap();
for i in 0..k {
ds.new_attr::<i64>()
.create(&format!("attr_{i:04}"))
.unwrap()
.write_scalar(&(i as i64))
.unwrap();
}
});
});
}
group.finish();
}
// ---------------------------------------------------------------------------
// Workload: metadata_attrs_read
// Open a pre-built file and read all K attributes back.
// ---------------------------------------------------------------------------
fn bench_metadata_attrs_read(c: &mut Criterion) {
let mut group = c.benchmark_group("metadata_attrs_read");
for &k in &[4usize, 16, 64, 128] {
// Build the reference file in memory.
let bytes = {
let mut fb = FileBuilder::new();
let ds = fb
.create_dataset("data")
.with_f64_data(&[1.0, 2.0, 3.0])
.with_shape(&[3]);
for i in 0..k {
ds.set_attr(&format!("attr_{i:04}"), AttrValue::I64(i as i64));
}
fb.finish().unwrap()
};
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("clawhdf5", k), &bytes, |b, raw| {
b.iter(|| {
let file = File::from_bytes(raw.clone()).unwrap();
let ds = file.dataset("data").unwrap();
ds.attrs().unwrap()
});
});
}
group.finish();
}
// ---------------------------------------------------------------------------
// Workload: metadata_groups_create
// Create K top-level groups (no datasets inside).
// Measures link-storage allocation: compact → dense B-tree transition.
// ---------------------------------------------------------------------------
fn bench_metadata_groups_create(c: &mut Criterion) {
let mut group = c.benchmark_group("metadata_groups_create");
for &k in &[4usize, 16, 32, 64] {
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("clawhdf5", k), &k, |b, &k| {
let tmp = TempDir::new().unwrap();
let path = tmp.path().join("groups_create.h5");
b.iter(|| {
let mut fb = FileBuilder::new();
for i in 0..k {
let mut g = fb.create_group(&format!("group_{i:04}"));
// Minimal dataset inside each group to make it non-trivial.
g.create_dataset("x").with_f64_data(&[0.0]);
let finished = g.finish();
fb.add_group(finished);
}
fb.write(&path).unwrap();
});
});
#[cfg(feature = "libhdf5-compare")]
group.bench_with_input(BenchmarkId::new("libhdf5", k), &k, |b, &k| {
let tmp = TempDir::new().unwrap();
let path = tmp.path().join("groups_libhdf5.h5");
b.iter(|| {
let file = hdf5::File::create(&path).unwrap();
for i in 0..k {
let g = file.create_group(&format!("group_{i:04}")).unwrap();
g.new_dataset::<f64>()
.shape([1])
.create("x")
.unwrap()
.write_scalar(&0.0f64)
.unwrap();
}
});
});
}
group.finish();
}
// ---------------------------------------------------------------------------
// Workload: metadata_groups_traverse
// Open a pre-built file with K groups and traverse (list) the root group.
// ---------------------------------------------------------------------------
fn bench_metadata_groups_traverse(c: &mut Criterion) {
let mut group = c.benchmark_group("metadata_groups_traverse");
for &k in &[4usize, 16, 32, 64] {
// Pre-build.
let bytes = {
let mut fb = FileBuilder::new();
for i in 0..k {
let mut g = fb.create_group(&format!("group_{i:04}"));
g.create_dataset("x").with_f64_data(&[0.0]);
let finished = g.finish();
fb.add_group(finished);
}
fb.finish().unwrap()
};
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("clawhdf5", k), &bytes, |b, raw| {
b.iter(|| {
let file = File::from_bytes(raw.clone()).unwrap();
let root = file.root();
root.groups().unwrap()
});
});
}
group.finish();
}
// ---------------------------------------------------------------------------
// Workload: metadata_roundtrip_string_attrs
// Write and read back K variable-length string attributes.
// String attrs require a dedicated VL heap entry — distinct from numeric ones.
// ---------------------------------------------------------------------------
fn bench_metadata_string_attrs(c: &mut Criterion) {
let mut group = c.benchmark_group("metadata_string_attrs");
for &k in &[4usize, 16, 32] {
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("clawhdf5", k), &k, |b, &k| {
b.iter(|| {
let mut fb = FileBuilder::new();
let ds = fb
.create_dataset("data")
.with_f64_data(&[1.0])
.with_shape(&[1]);
for i in 0..k {
ds.set_attr(
&format!("label_{i:04}"),
AttrValue::String(format!("value-{i}-some-longer-string-payload")),
);
}
let bytes = fb.finish().unwrap();
// Immediately read back to exercise both directions.
let file = File::from_bytes(bytes).unwrap();
let ds_r = file.dataset("data").unwrap();
ds_r.attrs().unwrap()
});
});
}
group.finish();
}
criterion_group!(
meta_benches,
bench_metadata_attrs_write,
bench_metadata_attrs_read,
bench_metadata_groups_create,
bench_metadata_groups_traverse,
bench_metadata_string_attrs,
);
criterion_main!(meta_benches);