116 lines
3.6 KiB
Rust
116 lines
3.6 KiB
Rust
//! Benchmarks for the verified RVF pipeline.
|
|
|
|
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
|
|
|
|
fn bench_proof_generation(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("proof_generation");
|
|
for dim in [128u32, 384, 768, 1536] {
|
|
group.bench_with_input(BenchmarkId::new("prove_dim_eq", dim), &dim, |b, &d| {
|
|
b.iter(|| {
|
|
let mut env = ruvector_verified::ProofEnvironment::new();
|
|
ruvector_verified::prove_dim_eq(&mut env, d, d).unwrap();
|
|
});
|
|
});
|
|
}
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_arena_intern(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("arena_intern");
|
|
group.bench_function("cold_100_misses", |b| {
|
|
b.iter(|| {
|
|
let arena = ruvector_verified::fast_arena::FastTermArena::new();
|
|
for i in 0..100u64 {
|
|
arena.intern(i);
|
|
}
|
|
});
|
|
});
|
|
group.bench_function("hot_100_hits", |b| {
|
|
let arena = ruvector_verified::fast_arena::FastTermArena::new();
|
|
arena.intern(42);
|
|
b.iter(|| {
|
|
for _ in 0..100 {
|
|
arena.intern(42);
|
|
}
|
|
});
|
|
});
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_gated_routing(c: &mut Criterion) {
|
|
use ruvector_verified::gated::{self, ProofKind};
|
|
|
|
let mut group = c.benchmark_group("gated_routing");
|
|
let env = ruvector_verified::ProofEnvironment::new();
|
|
group.bench_function("reflexivity", |b| {
|
|
b.iter(|| gated::route_proof(ProofKind::Reflexivity, &env));
|
|
});
|
|
group.bench_function("dimension_equality", |b| {
|
|
b.iter(|| {
|
|
gated::route_proof(
|
|
ProofKind::DimensionEquality {
|
|
expected: 384,
|
|
actual: 384,
|
|
},
|
|
&env,
|
|
)
|
|
});
|
|
});
|
|
group.bench_function("pipeline_composition", |b| {
|
|
b.iter(|| gated::route_proof(ProofKind::PipelineComposition { stages: 5 }, &env));
|
|
});
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_conversion_cache(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("conversion_cache");
|
|
group.bench_function("insert_1000", |b| {
|
|
b.iter(|| {
|
|
let mut cache = ruvector_verified::cache::ConversionCache::with_capacity(2048);
|
|
for i in 0..1000u32 {
|
|
cache.insert(i, 384, i + 1000);
|
|
}
|
|
});
|
|
});
|
|
group.bench_function("lookup_hit_1000", |b| {
|
|
let mut cache = ruvector_verified::cache::ConversionCache::with_capacity(2048);
|
|
for i in 0..1000u32 {
|
|
cache.insert(i, 384, i + 1000);
|
|
}
|
|
b.iter(|| {
|
|
for i in 0..1000u32 {
|
|
cache.get(i, 384);
|
|
}
|
|
});
|
|
});
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_attestation(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("attestation");
|
|
group.bench_function("create_and_serialize", |b| {
|
|
let env = ruvector_verified::ProofEnvironment::new();
|
|
b.iter(|| {
|
|
let att = ruvector_verified::proof_store::create_attestation(&env, 0);
|
|
att.to_bytes()
|
|
});
|
|
});
|
|
group.bench_function("roundtrip", |b| {
|
|
let env = ruvector_verified::ProofEnvironment::new();
|
|
let att = ruvector_verified::proof_store::create_attestation(&env, 0);
|
|
let bytes = att.to_bytes();
|
|
b.iter(|| ruvector_verified::ProofAttestation::from_bytes(&bytes).unwrap());
|
|
});
|
|
group.finish();
|
|
}
|
|
|
|
criterion_group!(
|
|
benches,
|
|
bench_proof_generation,
|
|
bench_arena_intern,
|
|
bench_gated_routing,
|
|
bench_conversion_cache,
|
|
bench_attestation,
|
|
);
|
|
criterion_main!(benches);
|