Omar SobhandClaude Sonnet 4.6
2ddb22897c
Four independent write-path improvements: 1. Cache compressed chunks between Pass 1 and Pass 2 (chunked_write.rs, file_writer.rs): the two-pass layout writer previously called build_chunked_data_at_ext() twice per chunked dataset — once in Pass 1 to get blob sizes and once in Pass 2 with real addresses. Add PrecompressedChunks / precompress_chunks() / build_chunked_data_from_ precompressed() to compress once in Pass 1, cache the result, and only rebuild the address-dependent index structures in Pass 2. Expected ~2× speedup for chunked+deflate writes (512×512 deflate: 3.33ms → ~1.7ms). 2. SIMD-vectorisable shuffle filter (filters.rs): replace the naïve O(N·S) nested loop with an unrolled u32-load path for 4-byte elements (f32) and a cache-blocked tile loop for all other sizes. LLVM auto-vectorises the 4-byte path into SSE2/AVX2/NEON byte-deinterleave sequences. 3. Zstd benchmark variant (h5bench_write.rs): add write_2d_chunked_zstd group measuring Zstd level 3 vs deflate level 6 side-by-side. Also fix the existing write_2d_chunked benchmark — the clawhdf5 path was missing .with_deflate(6), making the comparison apples-to-oranges. Add arXiv- backed doc recommendation on DatasetBuilder::with_zstd(). 4. Zero-copy HNSW save (hnsw.rs, clawhdf5-io/lib.rs): add FileWriter::write_bytes_owned(Vec<u8>) that takes ownership to avoid the full-file clone in write_all_bytes(&[u8]). HNSW::save_to_hdf5 uses it. Co-Authored-By: Claude Sonnet 4.6 <[email protected]>
273 lines
10 KiB
Rust
273 lines
10 KiB
Rust
//! h5bench-equivalent write workloads for clawhdf5.
|
||
//!
|
||
//! Mirrors the sequential and chunked write patterns from the h5bench HPC
|
||
//! benchmark suite but implemented in pure Rust using Criterion for statistical
|
||
//! rigor. The `libhdf5-compare` feature adds matching benchmarks via the `hdf5`
|
||
//! crate (requires a system libhdf5 install).
|
||
|
||
use clawhdf5::{AttrValue, FileBuilder};
|
||
use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
|
||
use tempfile::TempDir;
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Workload: write_1d_contiguous
|
||
// Write N × f32 as a single contiguous 1-D dataset.
|
||
// Measures raw serialization + HDF5 superblock / object-header overhead.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn bench_write_1d_contiguous(c: &mut Criterion) {
|
||
let mut group = c.benchmark_group("write_1d_contiguous");
|
||
|
||
for &n in &[1_000usize, 10_000, 100_000] {
|
||
let data: Vec<f32> = (0..n).map(|i| i as f32 * 0.001).collect();
|
||
group.throughput(Throughput::Bytes((n * size_of::<f32>()) as u64));
|
||
|
||
group.bench_with_input(BenchmarkId::new("clawhdf5", n), &data, |b, d| {
|
||
let tmp = TempDir::new().unwrap();
|
||
let path = tmp.path().join("write_1d_contiguous.h5");
|
||
b.iter(|| {
|
||
let mut fb = FileBuilder::new();
|
||
fb.create_dataset("data")
|
||
.with_f32_data(d)
|
||
.with_shape(&[n as u64]);
|
||
fb.write(&path).unwrap();
|
||
});
|
||
});
|
||
|
||
#[cfg(feature = "libhdf5-compare")]
|
||
group.bench_with_input(BenchmarkId::new("libhdf5", n), &data, |b, d| {
|
||
let tmp = TempDir::new().unwrap();
|
||
let path = tmp.path().join("write_1d_libhdf5.h5");
|
||
b.iter(|| {
|
||
let file = hdf5::File::create(&path).unwrap();
|
||
let ds = file
|
||
.new_dataset::<f32>()
|
||
.shape([d.len()])
|
||
.create("data")
|
||
.unwrap();
|
||
ds.write(d.as_slice()).unwrap();
|
||
});
|
||
});
|
||
}
|
||
|
||
group.finish();
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Workload: write_2d_chunked
|
||
// Write an M × N f32 matrix as a chunked 2-D dataset with deflate (level 6).
|
||
// Measures chunked layout creation + compression pipeline throughput.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn bench_write_2d_chunked(c: &mut Criterion) {
|
||
let mut group = c.benchmark_group("write_2d_chunked");
|
||
|
||
// (rows, cols, chunk_rows, chunk_cols)
|
||
let configs: &[(usize, usize, u64, u64)] = &[
|
||
(32, 32, 8, 32),
|
||
(128, 128, 32, 128),
|
||
(512, 512, 64, 512),
|
||
];
|
||
|
||
for &(rows, cols, cr, cc) in configs {
|
||
let n = rows * cols;
|
||
let data: Vec<f32> = (0..n).map(|i| i as f32).collect();
|
||
let label = format!("{rows}x{cols}");
|
||
group.throughput(Throughput::Bytes((n * size_of::<f32>()) as u64));
|
||
|
||
group.bench_with_input(BenchmarkId::new("clawhdf5", &label), &data, |b, d| {
|
||
let tmp = TempDir::new().unwrap();
|
||
let path = tmp.path().join("write_2d_chunked.h5");
|
||
b.iter(|| {
|
||
let mut fb = FileBuilder::new();
|
||
fb.create_dataset("matrix")
|
||
.with_f32_data(d)
|
||
.with_shape(&[rows as u64, cols as u64])
|
||
.with_chunks(&[cr, cc])
|
||
.with_deflate(6);
|
||
fb.write(&path).unwrap();
|
||
});
|
||
});
|
||
|
||
#[cfg(feature = "libhdf5-compare")]
|
||
group.bench_with_input(BenchmarkId::new("libhdf5", &label), &data, |b, d| {
|
||
let tmp = TempDir::new().unwrap();
|
||
let path = tmp.path().join("write_2d_libhdf5.h5");
|
||
b.iter(|| {
|
||
let file = hdf5::File::create(&path).unwrap();
|
||
let ds = file
|
||
.new_dataset::<f32>()
|
||
.shape([rows, cols])
|
||
.chunk([cr as usize, cc as usize])
|
||
.deflate(6)
|
||
.create("matrix")
|
||
.unwrap();
|
||
ds.write_raw(d.as_slice()).unwrap();
|
||
});
|
||
});
|
||
}
|
||
|
||
group.finish();
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Workload: write_2d_chunked_zstd
|
||
// Same matrix sizes as write_2d_chunked but uses Zstd level 3.
|
||
// Zstd level 3 typically encodes 500+ MiB/s vs deflate's ~300 MiB/s at the
|
||
// same or better compression ratio (arXiv 2604.06221, ROOT I/O 2019).
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn bench_write_2d_chunked_zstd(c: &mut Criterion) {
|
||
let mut group = c.benchmark_group("write_2d_chunked_zstd");
|
||
|
||
let configs: &[(usize, usize, u64, u64)] = &[
|
||
(32, 32, 8, 32),
|
||
(128, 128, 32, 128),
|
||
(512, 512, 64, 512),
|
||
];
|
||
|
||
for &(rows, cols, cr, cc) in configs {
|
||
let n = rows * cols;
|
||
let data: Vec<f32> = (0..n).map(|i| i as f32).collect();
|
||
let label = format!("{rows}x{cols}");
|
||
group.throughput(Throughput::Bytes((n * size_of::<f32>()) as u64));
|
||
|
||
group.bench_with_input(BenchmarkId::new("clawhdf5/zstd-3", &label), &data, |b, d| {
|
||
let tmp = TempDir::new().unwrap();
|
||
let path = tmp.path().join("write_2d_chunked_zstd.h5");
|
||
b.iter(|| {
|
||
let mut fb = FileBuilder::new();
|
||
fb.create_dataset("matrix")
|
||
.with_f32_data(d)
|
||
.with_shape(&[rows as u64, cols as u64])
|
||
.with_chunks(&[cr, cc])
|
||
.with_zstd(3);
|
||
fb.write(&path).unwrap();
|
||
});
|
||
});
|
||
|
||
group.bench_with_input(
|
||
BenchmarkId::new("clawhdf5/deflate-6", &label),
|
||
&data,
|
||
|b, d| {
|
||
let tmp = TempDir::new().unwrap();
|
||
let path = tmp.path().join("write_2d_chunked_deflate.h5");
|
||
b.iter(|| {
|
||
let mut fb = FileBuilder::new();
|
||
fb.create_dataset("matrix")
|
||
.with_f32_data(d)
|
||
.with_shape(&[rows as u64, cols as u64])
|
||
.with_chunks(&[cr, cc])
|
||
.with_deflate(6);
|
||
fb.write(&path).unwrap();
|
||
});
|
||
},
|
||
);
|
||
}
|
||
|
||
group.finish();
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Workload: write_f64_batch
|
||
// Write batches of f64 elements — simulates the clawhdf5-agent embedding
|
||
// write path (one f64 vector per memory entry).
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn bench_write_f64_batch(c: &mut Criterion) {
|
||
let mut group = c.benchmark_group("write_f64_batch");
|
||
|
||
for &n in &[128usize, 512, 1_024] {
|
||
let data: Vec<f64> = (0..n).map(|i| (i as f64).sin()).collect();
|
||
group.throughput(Throughput::Bytes((n * size_of::<f64>()) as u64));
|
||
|
||
group.bench_with_input(BenchmarkId::new("clawhdf5", n), &data, |b, d| {
|
||
let tmp = TempDir::new().unwrap();
|
||
let path = tmp.path().join("write_f64_batch.h5");
|
||
b.iter(|| {
|
||
let mut fb = FileBuilder::new();
|
||
fb.create_dataset("embedding")
|
||
.with_f64_data(d)
|
||
.with_shape(&[n as u64]);
|
||
fb.write(&path).unwrap();
|
||
});
|
||
});
|
||
}
|
||
|
||
group.finish();
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Workload: write_multi_dataset
|
||
// Write K independent f32 datasets into one file — stresses the object-header
|
||
// + link-storage path (compact → dense transition at >8 datasets).
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn bench_write_multi_dataset(c: &mut Criterion) {
|
||
let mut group = c.benchmark_group("write_multi_dataset");
|
||
|
||
for &k in &[4usize, 16, 64] {
|
||
let rows = 100usize;
|
||
let data: Vec<f32> = (0..rows).map(|i| i as f32).collect();
|
||
group.throughput(Throughput::Elements(k as u64));
|
||
|
||
group.bench_with_input(BenchmarkId::new("clawhdf5", k), &data, |b, d| {
|
||
let tmp = TempDir::new().unwrap();
|
||
let path = tmp.path().join("write_multi.h5");
|
||
b.iter(|| {
|
||
let mut fb = FileBuilder::new();
|
||
for i in 0..k {
|
||
fb.create_dataset(&format!("ds_{i:04}"))
|
||
.with_f32_data(d)
|
||
.with_shape(&[rows as u64]);
|
||
}
|
||
fb.write(&path).unwrap();
|
||
});
|
||
});
|
||
}
|
||
|
||
group.finish();
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Workload: write_with_attrs
|
||
// Write a dataset with K attributes — exercises attribute message allocation.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn bench_write_with_attrs(c: &mut Criterion) {
|
||
let mut group = c.benchmark_group("write_with_attrs");
|
||
|
||
for &k in &[4usize, 16, 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("write_attrs.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}"), AttrValue::I64(i as i64));
|
||
}
|
||
fb.write(&path).unwrap();
|
||
});
|
||
});
|
||
}
|
||
|
||
group.finish();
|
||
}
|
||
|
||
criterion_group!(
|
||
write_benches,
|
||
bench_write_1d_contiguous,
|
||
bench_write_2d_chunked,
|
||
bench_write_2d_chunked_zstd,
|
||
bench_write_f64_batch,
|
||
bench_write_multi_dataset,
|
||
bench_write_with_attrs,
|
||
);
|
||
criterion_main!(write_benches);
|