122 lines
3.3 KiB
Rust
122 lines
3.3 KiB
Rust
//! Benchmarks for AIMDS analysis layer
|
|
|
|
use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
|
|
use aimds_analysis::*;
|
|
use aimds_core::{Action, State};
|
|
use std::collections::HashMap;
|
|
|
|
fn behavioral_analysis_benchmark(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("behavioral_analysis");
|
|
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
|
|
for size in [100, 500, 1000].iter() {
|
|
let analyzer = BehavioralAnalyzer::new(10).unwrap();
|
|
let sequence: Vec<f64> = (0..*size).map(|i| (i as f64 * 0.1).sin()).collect();
|
|
|
|
group.bench_with_input(
|
|
BenchmarkId::from_parameter(size),
|
|
size,
|
|
|b, _| {
|
|
b.to_async(&rt).iter(|| async {
|
|
analyzer.analyze_behavior(black_box(&sequence)).await.unwrap()
|
|
});
|
|
},
|
|
);
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn policy_verification_benchmark(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("policy_verification");
|
|
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
|
|
for num_policies in [1, 5, 10].iter() {
|
|
let mut verifier = PolicyVerifier::new().unwrap();
|
|
|
|
for i in 0..*num_policies {
|
|
let policy = SecurityPolicy::new(
|
|
format!("policy_{}", i),
|
|
format!("Test policy {}", i),
|
|
"G authenticated"
|
|
);
|
|
verifier.add_policy(policy);
|
|
}
|
|
|
|
let action = Action::default();
|
|
|
|
group.bench_with_input(
|
|
BenchmarkId::from_parameter(num_policies),
|
|
num_policies,
|
|
|b, _| {
|
|
b.to_async(&rt).iter(|| async {
|
|
verifier.verify_policy(black_box(&action)).await.unwrap()
|
|
});
|
|
},
|
|
);
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn ltl_checking_benchmark(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("ltl_checking");
|
|
|
|
for trace_len in [10, 50, 100].iter() {
|
|
let checker = LTLChecker::new();
|
|
let mut trace = Trace::new();
|
|
|
|
for i in 0..*trace_len {
|
|
let mut props = HashMap::new();
|
|
props.insert("authenticated".to_string(), true);
|
|
trace.add_state(State::default(), props);
|
|
}
|
|
|
|
let formula = LTLFormula::parse("G authenticated").unwrap();
|
|
|
|
group.bench_with_input(
|
|
BenchmarkId::from_parameter(trace_len),
|
|
trace_len,
|
|
|b, _| {
|
|
b.iter(|| {
|
|
checker.check_formula(black_box(&formula), black_box(&trace))
|
|
});
|
|
},
|
|
);
|
|
}
|
|
|
|
group.finish();
|
|
}
|
|
|
|
fn full_analysis_benchmark(c: &mut Criterion) {
|
|
let mut group = c.benchmark_group("full_analysis");
|
|
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
|
|
let engine = AnalysisEngine::new(10).unwrap();
|
|
let sequence: Vec<f64> = (0..1000).map(|i| (i as f64 * 0.1).sin()).collect();
|
|
let action = Action::default();
|
|
|
|
group.bench_function("combined_analysis", |b| {
|
|
b.to_async(&rt).iter(|| async {
|
|
engine.analyze_full(
|
|
black_box(&sequence),
|
|
black_box(&action)
|
|
).await.unwrap()
|
|
});
|
|
});
|
|
|
|
group.finish();
|
|
}
|
|
|
|
criterion_group!(
|
|
benches,
|
|
behavioral_analysis_benchmark,
|
|
policy_verification_benchmark,
|
|
ltl_checking_benchmark,
|
|
full_analysis_benchmark
|
|
);
|
|
criterion_main!(benches);
|