776 lines
23 KiB
Rust
776 lines
23 KiB
Rust
//! Comprehensive benchmarks for strange-loop crate
|
|
//!
|
|
//! Benchmarks cover:
|
|
//! - Pattern extraction performance
|
|
//! - Recursive optimization depth
|
|
//! - Meta-learning iteration speed
|
|
//! - Self-modification safety checks
|
|
//! - Rollback mechanism performance
|
|
//! - Validation overhead
|
|
//!
|
|
//! Performance targets:
|
|
//! - Pattern extraction: <10ms for 1000 patterns
|
|
//! - Recursive depth: >10 levels without stack overflow
|
|
//! - Iteration speed: >1000 iterations/second
|
|
//! - Safety overhead: <5% performance impact
|
|
|
|
use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId, Throughput};
|
|
use midstreamer_strange_loop::{
|
|
StrangeLoop, StrangeLoopConfig, MetaLevel, MetaKnowledge,
|
|
SafetyConstraint, ModificationRule,
|
|
};
|
|
|
|
// ============================================================================
|
|
// Test Data Generators
|
|
// ============================================================================
|
|
|
|
fn generate_pattern_data(size: usize, complexity: &str) -> Vec<String> {
|
|
match complexity {
|
|
"simple" => {
|
|
// Highly repetitive patterns
|
|
(0..size)
|
|
.map(|i| format!("pattern{}", i % 10))
|
|
.collect()
|
|
}
|
|
"medium" => {
|
|
// Moderate repetition with variations
|
|
(0..size)
|
|
.map(|i| {
|
|
let base = i % 50;
|
|
let variant = i % 3;
|
|
format!("pattern_{}_{}", base, variant)
|
|
})
|
|
.collect()
|
|
}
|
|
"complex" => {
|
|
// High diversity with some patterns
|
|
(0..size)
|
|
.map(|i| {
|
|
let hash = (i * 7919) % 200;
|
|
let subpattern = (i * 31) % 5;
|
|
format!("complex_{}_{}", hash, subpattern)
|
|
})
|
|
.collect()
|
|
}
|
|
"random" => {
|
|
// Mostly unique patterns
|
|
(0..size)
|
|
.map(|i| {
|
|
let hash1 = (i * 7919) % 10000;
|
|
let hash2 = (i * 31337) % 10000;
|
|
format!("random_{}_{}", hash1, hash2)
|
|
})
|
|
.collect()
|
|
}
|
|
_ => vec!["default".to_string(); size],
|
|
}
|
|
}
|
|
|
|
fn generate_hierarchical_data(depth: usize) -> Vec<Vec<String>> {
|
|
let mut levels = Vec::new();
|
|
let mut current_data = generate_pattern_data(100, "simple");
|
|
|
|
for level in 0..depth {
|
|
levels.push(current_data.clone());
|
|
// Generate meta-patterns from current level
|
|
current_data = current_data
|
|
.windows(2)
|
|
.map(|w| format!("meta_{}_{}", level, w.join("_")))
|
|
.collect();
|
|
}
|
|
|
|
levels
|
|
}
|
|
|
|
fn generate_large_pattern_set(count: usize) -> Vec<String> {
|
|
(0..count)
|
|
.map(|i| {
|
|
let pattern_type = i % 7;
|
|
match pattern_type {
|
|
0 => format!("linear_{}", i),
|
|
1 => format!("cyclic_{}", i % 100),
|
|
2 => format!("branching_{}_{}", i / 10, i % 10),
|
|
3 => format!("converging_{}", i / 20),
|
|
4 => format!("diverging_{}", i),
|
|
5 => format!("stable_{}", i % 50),
|
|
_ => format!("chaotic_{}", (i * 7919) % 1000),
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
// ============================================================================
|
|
// Pattern Extraction Benchmarks
|
|
// ============================================================================
|
|
|
|
fn bench_pattern_extraction_simple(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("pattern_extraction_simple");
|
|
|
|
for size in [100, 500, 1000, 2000, 5000].iter() {
|
|
group.throughput(Throughput::Elements(*size as u64));
|
|
|
|
group.bench_with_input(
|
|
BenchmarkId::new("simple_patterns", size),
|
|
size,
|
|
|b, &n| {
|
|
let data = generate_pattern_data(n, "simple");
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
}
|
|
);
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_pattern_extraction_complexity(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("pattern_extraction_complexity");
|
|
|
|
let size = 1000;
|
|
|
|
for complexity in ["simple", "medium", "complex", "random"].iter() {
|
|
group.bench_with_input(
|
|
BenchmarkId::new("complexity", complexity),
|
|
complexity,
|
|
|b, &comp| {
|
|
let data = generate_pattern_data(size, comp);
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
}
|
|
);
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_pattern_extraction_edge_cases(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("pattern_extraction_edge_cases");
|
|
|
|
// All identical patterns
|
|
group.bench_function("all_identical", |b| {
|
|
let data = vec!["identical".to_string(); 1000];
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// All unique patterns
|
|
group.bench_function("all_unique", |b| {
|
|
let data = generate_pattern_data(1000, "random");
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// Large pattern strings
|
|
group.bench_function("large_strings", |b| {
|
|
let data: Vec<String> = (0..1000)
|
|
.map(|i| format!("large_pattern_{}_", i).repeat(10))
|
|
.collect();
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Recursive Optimization Depth Benchmarks
|
|
// ============================================================================
|
|
|
|
fn bench_recursive_depth_scaling(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("recursive_depth");
|
|
|
|
for depth in [1, 3, 5, 10, 15].iter() {
|
|
group.bench_with_input(
|
|
BenchmarkId::new("depth", depth),
|
|
depth,
|
|
|b, &d| {
|
|
let mut config = StrangeLoopConfig::default();
|
|
config.max_meta_depth = d;
|
|
let mut strange_loop = StrangeLoop::new(config);
|
|
let data = generate_pattern_data(100, "simple");
|
|
|
|
b.iter(|| {
|
|
strange_loop.reset();
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
}
|
|
);
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_recursive_depth_stress(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("recursive_depth_stress");
|
|
|
|
// Deep recursion with simple patterns
|
|
group.bench_function("deep_simple", |b| {
|
|
let mut config = StrangeLoopConfig::default();
|
|
config.max_meta_depth = 10;
|
|
let mut strange_loop = StrangeLoop::new(config);
|
|
let data = generate_pattern_data(50, "simple");
|
|
|
|
b.iter(|| {
|
|
strange_loop.reset();
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// Deep recursion with complex patterns
|
|
group.bench_function("deep_complex", |b| {
|
|
let mut config = StrangeLoopConfig::default();
|
|
config.max_meta_depth = 10;
|
|
let mut strange_loop = StrangeLoop::new(config);
|
|
let data = generate_pattern_data(50, "complex");
|
|
|
|
b.iter(|| {
|
|
strange_loop.reset();
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// Maximum safe depth
|
|
group.bench_function("max_safe_depth", |b| {
|
|
let mut config = StrangeLoopConfig::default();
|
|
config.max_meta_depth = 20;
|
|
let mut strange_loop = StrangeLoop::new(config);
|
|
let data = generate_pattern_data(30, "simple");
|
|
|
|
b.iter(|| {
|
|
strange_loop.reset();
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Meta-Learning Iteration Speed Benchmarks
|
|
// ============================================================================
|
|
|
|
fn bench_meta_learning_iterations(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("meta_learning_iterations");
|
|
|
|
// Single iteration
|
|
group.bench_function("single_iteration", |b| {
|
|
let data = generate_pattern_data(100, "medium");
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// Multiple iterations (batch)
|
|
for iterations in [10, 100, 1000].iter() {
|
|
group.throughput(Throughput::Elements(*iterations as u64));
|
|
|
|
group.bench_with_input(
|
|
BenchmarkId::new("iterations", iterations),
|
|
iterations,
|
|
|b, &n| {
|
|
let data = generate_pattern_data(100, "medium");
|
|
|
|
b.iter(|| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
for _ in 0..n {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
)).ok();
|
|
}
|
|
});
|
|
}
|
|
);
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_iteration_throughput(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("iteration_throughput");
|
|
|
|
// Measure iterations per second
|
|
group.bench_function("iterations_per_second", |b| {
|
|
let data = generate_pattern_data(100, "simple");
|
|
let mut strange_loop = StrangeLoop::default();
|
|
let mut count = 0u64;
|
|
|
|
b.iter(|| {
|
|
strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
).ok();
|
|
count += 1;
|
|
black_box(count)
|
|
});
|
|
});
|
|
|
|
// Parallel meta-learning simulation
|
|
group.bench_function("parallel_simulation", |b| {
|
|
let data = generate_pattern_data(100, "medium");
|
|
|
|
b.iter(|| {
|
|
// Simulate parallel learning at different levels
|
|
let mut strange_loop = StrangeLoop::default();
|
|
for level in 0..3 {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel(level)),
|
|
black_box(&data)
|
|
)).ok();
|
|
}
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Self-Modification Safety Check Benchmarks
|
|
// ============================================================================
|
|
|
|
fn bench_safety_check_overhead(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("safety_check_overhead");
|
|
|
|
// Learning without safety checks
|
|
group.bench_function("no_safety_checks", |b| {
|
|
let mut config = StrangeLoopConfig::default();
|
|
config.safety_check_enabled = false;
|
|
let mut strange_loop = StrangeLoop::new(config);
|
|
let data = generate_pattern_data(100, "medium");
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// Learning with safety checks
|
|
group.bench_function("with_safety_checks", |b| {
|
|
let mut config = StrangeLoopConfig::default();
|
|
config.safety_check_enabled = true;
|
|
let mut strange_loop = StrangeLoop::new(config);
|
|
let data = generate_pattern_data(100, "medium");
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// Compare overhead percentage
|
|
group.bench_function("safety_overhead_ratio", |b| {
|
|
let data = generate_pattern_data(100, "medium");
|
|
|
|
b.iter(|| {
|
|
// With safety
|
|
let mut config_safe = StrangeLoopConfig::default();
|
|
config_safe.safety_check_enabled = true;
|
|
let mut safe_loop = StrangeLoop::new(config_safe);
|
|
|
|
let safe_result = black_box(safe_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
));
|
|
|
|
black_box(safe_result)
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_safety_constraint_validation(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("safety_constraint_validation");
|
|
|
|
// Minimal constraints
|
|
group.bench_function("minimal_constraints", |b| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
let data = generate_pattern_data(100, "simple");
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// Multiple constraints
|
|
group.bench_function("multiple_constraints", |b| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
// Add multiple safety constraints
|
|
for i in 0..10 {
|
|
strange_loop.add_safety_constraint(
|
|
SafetyConstraint::new(
|
|
format!("constraint_{}", i),
|
|
format!("G(safe_{})", i)
|
|
)
|
|
);
|
|
}
|
|
|
|
let data = generate_pattern_data(100, "simple");
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Rollback Mechanism Benchmarks
|
|
// ============================================================================
|
|
|
|
fn bench_rollback_reset(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("rollback_mechanism");
|
|
|
|
// Reset operation
|
|
group.bench_function("reset_empty", |b| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.reset())
|
|
});
|
|
});
|
|
|
|
// Reset after learning
|
|
group.bench_function("reset_after_learning", |b| {
|
|
let data = generate_pattern_data(100, "medium");
|
|
|
|
b.iter(|| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
strange_loop.learn_at_level(MetaLevel::base(), &data).ok();
|
|
black_box(strange_loop.reset())
|
|
});
|
|
});
|
|
|
|
// Reset after deep recursion
|
|
group.bench_function("reset_deep_recursion", |b| {
|
|
let data = generate_pattern_data(50, "simple");
|
|
|
|
b.iter(|| {
|
|
let mut config = StrangeLoopConfig::default();
|
|
config.max_meta_depth = 10;
|
|
let mut strange_loop = StrangeLoop::new(config);
|
|
strange_loop.learn_at_level(MetaLevel::base(), &data).ok();
|
|
black_box(strange_loop.reset())
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn bench_rollback_state_recovery(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("state_recovery");
|
|
|
|
// Save and restore simulation
|
|
group.bench_function("save_restore_cycle", |b| {
|
|
let data = generate_pattern_data(100, "medium");
|
|
|
|
b.iter(|| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
// Learn
|
|
strange_loop.learn_at_level(MetaLevel::base(), &data).ok();
|
|
|
|
// Get state (simulated save)
|
|
let summary = black_box(strange_loop.get_summary());
|
|
|
|
// Reset (simulated failure)
|
|
strange_loop.reset();
|
|
|
|
// Verify reset
|
|
let new_summary = black_box(strange_loop.get_summary());
|
|
|
|
black_box((summary, new_summary))
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Validation Overhead Benchmarks
|
|
// ============================================================================
|
|
|
|
fn bench_validation_overhead(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("validation_overhead");
|
|
|
|
// Get knowledge validation
|
|
group.bench_function("get_knowledge_at_level", |b| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
let data = generate_pattern_data(1000, "medium");
|
|
strange_loop.learn_at_level(MetaLevel::base(), &data).ok();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.get_knowledge_at_level(
|
|
black_box(MetaLevel::base())
|
|
))
|
|
});
|
|
});
|
|
|
|
// Get all knowledge validation
|
|
group.bench_function("get_all_knowledge", |b| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
let data = generate_pattern_data(500, "medium");
|
|
|
|
// Learn at multiple levels
|
|
for level in 0..3 {
|
|
strange_loop.learn_at_level(MetaLevel(level), &data).ok();
|
|
}
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.get_all_knowledge())
|
|
});
|
|
});
|
|
|
|
// Summary generation
|
|
group.bench_function("get_summary", |b| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
let data = generate_pattern_data(1000, "complex");
|
|
strange_loop.learn_at_level(MetaLevel::base(), &data).ok();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.get_summary())
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Complete Pipeline Benchmarks
|
|
// ============================================================================
|
|
|
|
fn bench_complete_meta_learning_pipeline(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("complete_pipeline");
|
|
|
|
group.bench_function("full_meta_learning", |b| {
|
|
let data = generate_pattern_data(200, "medium");
|
|
|
|
b.iter(|| {
|
|
let mut config = StrangeLoopConfig::default();
|
|
config.max_meta_depth = 3;
|
|
config.safety_check_enabled = true;
|
|
let mut strange_loop = StrangeLoop::new(config);
|
|
|
|
// Learn at base level (triggers recursive learning)
|
|
let result = strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
);
|
|
|
|
// Get summary
|
|
let summary = strange_loop.get_summary();
|
|
|
|
// Get knowledge
|
|
let knowledge = strange_loop.get_all_knowledge();
|
|
|
|
black_box((result, summary, knowledge))
|
|
});
|
|
});
|
|
|
|
group.bench_function("multi_level_learning", |b| {
|
|
let data = generate_pattern_data(150, "complex");
|
|
|
|
b.iter(|| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
// Learn at multiple levels explicitly
|
|
for level in 0..3 {
|
|
strange_loop.learn_at_level(
|
|
black_box(MetaLevel(level)),
|
|
black_box(&data)
|
|
).ok();
|
|
}
|
|
|
|
black_box(strange_loop.get_summary())
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Memory Efficiency Benchmarks
|
|
// ============================================================================
|
|
|
|
fn bench_memory_efficiency(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("memory_efficiency");
|
|
|
|
// Large pattern sets
|
|
group.bench_function("large_pattern_set", |b| {
|
|
let data = generate_large_pattern_set(5000);
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
b.iter(|| {
|
|
black_box(strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
))
|
|
});
|
|
});
|
|
|
|
// Repeated learning cycles
|
|
group.bench_function("repeated_cycles", |b| {
|
|
let data = generate_pattern_data(100, "medium");
|
|
|
|
b.iter(|| {
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
for _ in 0..10 {
|
|
strange_loop.learn_at_level(
|
|
black_box(MetaLevel::base()),
|
|
black_box(&data)
|
|
).ok();
|
|
}
|
|
|
|
black_box(strange_loop.get_summary())
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Criterion Configuration
|
|
// ============================================================================
|
|
|
|
criterion_group! {
|
|
name = pattern_extraction_benches;
|
|
config = Criterion::default()
|
|
.sample_size(100)
|
|
.measurement_time(std::time::Duration::from_secs(10))
|
|
.warm_up_time(std::time::Duration::from_secs(3));
|
|
targets = bench_pattern_extraction_simple,
|
|
bench_pattern_extraction_complexity,
|
|
bench_pattern_extraction_edge_cases
|
|
}
|
|
|
|
criterion_group! {
|
|
name = recursive_depth_benches;
|
|
config = Criterion::default()
|
|
.sample_size(50)
|
|
.measurement_time(std::time::Duration::from_secs(12));
|
|
targets = bench_recursive_depth_scaling,
|
|
bench_recursive_depth_stress
|
|
}
|
|
|
|
criterion_group! {
|
|
name = iteration_benches;
|
|
config = Criterion::default()
|
|
.sample_size(100)
|
|
.measurement_time(std::time::Duration::from_secs(10));
|
|
targets = bench_meta_learning_iterations,
|
|
bench_iteration_throughput
|
|
}
|
|
|
|
criterion_group! {
|
|
name = safety_benches;
|
|
config = Criterion::default()
|
|
.sample_size(100)
|
|
.measurement_time(std::time::Duration::from_secs(10));
|
|
targets = bench_safety_check_overhead,
|
|
bench_safety_constraint_validation
|
|
}
|
|
|
|
criterion_group! {
|
|
name = rollback_benches;
|
|
config = Criterion::default()
|
|
.sample_size(150)
|
|
.measurement_time(std::time::Duration::from_secs(8));
|
|
targets = bench_rollback_reset,
|
|
bench_rollback_state_recovery
|
|
}
|
|
|
|
criterion_group! {
|
|
name = validation_benches;
|
|
config = Criterion::default()
|
|
.sample_size(150)
|
|
.measurement_time(std::time::Duration::from_secs(8));
|
|
targets = bench_validation_overhead
|
|
}
|
|
|
|
criterion_group! {
|
|
name = pipeline_benches;
|
|
config = Criterion::default()
|
|
.sample_size(50)
|
|
.measurement_time(std::time::Duration::from_secs(15));
|
|
targets = bench_complete_meta_learning_pipeline
|
|
}
|
|
|
|
criterion_group! {
|
|
name = memory_benches;
|
|
config = Criterion::default()
|
|
.sample_size(50)
|
|
.measurement_time(std::time::Duration::from_secs(12));
|
|
targets = bench_memory_efficiency
|
|
}
|
|
|
|
criterion_main!(
|
|
pattern_extraction_benches,
|
|
recursive_depth_benches,
|
|
iteration_benches,
|
|
safety_benches,
|
|
rollback_benches,
|
|
validation_benches,
|
|
pipeline_benches,
|
|
memory_benches
|
|
);
|