d803bfe2b1
git-subtree-dir: vendor/ruvector git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
140 lines
4.1 KiB
Rust
140 lines
4.1 KiB
Rust
// Prefetch Prediction Benchmark - Accuracy and performance metrics
|
|
use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
|
|
use demand_paged_cognition::*;
|
|
|
|
fn bench_prefetch_accuracy(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("prefetch_accuracy");
|
|
|
|
// Sequential pattern
|
|
group.bench_function("sequential_pattern", |b| {
|
|
b.iter_with_setup(
|
|
|| PrefetchCoordinator::new(),
|
|
|coordinator| {
|
|
let context = vec![0.1, 0.2, 0.3];
|
|
|
|
// Build sequential pattern
|
|
for i in 0..100 {
|
|
coordinator.record_access(i, &context);
|
|
}
|
|
|
|
// Predict next
|
|
let predictions = coordinator.predict_and_queue(100, &context, 10);
|
|
black_box(predictions)
|
|
},
|
|
);
|
|
});
|
|
|
|
// Random pattern
|
|
group.bench_function("random_pattern", |b| {
|
|
b.iter_with_setup(
|
|
|| {
|
|
use std::collections::hash_map::DefaultHasher;
|
|
use std::hash::{Hash, Hasher};
|
|
|
|
let coordinator = PrefetchCoordinator::new();
|
|
let context = vec![0.1, 0.2, 0.3];
|
|
|
|
// Build pseudo-random pattern
|
|
for i in 0..100 {
|
|
let mut hasher = DefaultHasher::new();
|
|
i.hash(&mut hasher);
|
|
let page = (hasher.finish() % 1000) as u64;
|
|
coordinator.record_access(page, &context);
|
|
}
|
|
|
|
coordinator
|
|
},
|
|
|coordinator| {
|
|
let context = vec![0.1, 0.2, 0.3];
|
|
let predictions = coordinator.predict_and_queue(500, &context, 10);
|
|
black_box(predictions)
|
|
},
|
|
);
|
|
});
|
|
|
|
// Cyclic pattern
|
|
group.bench_function("cyclic_pattern", |b| {
|
|
b.iter_with_setup(
|
|
|| {
|
|
let coordinator = PrefetchCoordinator::new();
|
|
let context = vec![0.1, 0.2, 0.3];
|
|
|
|
// Build cyclic pattern: 1->2->3->4->1
|
|
for _ in 0..25 {
|
|
coordinator.record_access(1, &context);
|
|
coordinator.record_access(2, &context);
|
|
coordinator.record_access(3, &context);
|
|
coordinator.record_access(4, &context);
|
|
}
|
|
|
|
coordinator
|
|
},
|
|
|coordinator| {
|
|
let context = vec![0.1, 0.2, 0.3];
|
|
let predictions = coordinator.predict_and_queue(4, &context, 5);
|
|
black_box(predictions)
|
|
},
|
|
);
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_streaming_learning(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("streaming_learning");
|
|
|
|
// Hoeffding Tree update
|
|
group.bench_function("hoeffding_update", |b| {
|
|
let predictor = HoeffdingTreePredictor::new();
|
|
let features = AccessFeatures::new(42);
|
|
|
|
b.iter(|| {
|
|
predictor.update(black_box(42), black_box(&features))
|
|
});
|
|
});
|
|
|
|
// Markov update
|
|
group.bench_function("markov_update", |b| {
|
|
let predictor = MarkovPredictor::new();
|
|
|
|
b.iter(|| {
|
|
predictor.update(black_box(1), black_box(2))
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_feature_extraction(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("feature_extraction");
|
|
|
|
for history_len in [10, 50, 100].iter() {
|
|
group.bench_with_input(
|
|
BenchmarkId::from_parameter(history_len),
|
|
history_len,
|
|
|b, &history_len| {
|
|
let history: Vec<u64> = (0..history_len).collect();
|
|
let context = vec![0.1, 0.2, 0.3, 0.4, 0.5];
|
|
|
|
b.iter(|| {
|
|
let features = AccessFeatures::from_history(
|
|
black_box(&history),
|
|
black_box(&context),
|
|
);
|
|
black_box(features.to_vector())
|
|
});
|
|
},
|
|
);
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
criterion_group!(
|
|
benches,
|
|
bench_prefetch_accuracy,
|
|
bench_streaming_learning,
|
|
bench_feature_extraction
|
|
);
|
|
criterion_main!(benches);
|