mindfry 1.9.0

Memory with a Conscience
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Stability Layer Benchmarks
//!
//! Benchmarks for crash recovery, warmup tracking, and exhaustion monitoring.

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use mindfry::stability::{
    ExhaustionLevel, ExhaustionMonitor, RecoveryAnalyzer, RecoveryState, ShutdownMarker,
    WarmupTracker,
};

// ═══════════════════════════════════════════════════════════════
// RECOVERY BENCHMARKS
// ═══════════════════════════════════════════════════════════════

fn bench_recovery_analyzer_new(c: &mut Criterion) {
    let marker = Some(ShutdownMarker::graceful());

    c.bench_function("recovery_analyzer_new", |b| {
        b.iter(|| black_box(RecoveryAnalyzer::new(marker.clone())))
    });
}

fn bench_recovery_analyzer_analyze(c: &mut Criterion) {
    let marker = Some(ShutdownMarker::graceful());
    let analyzer = RecoveryAnalyzer::new(marker);

    c.bench_function("recovery_analyzer_analyze", |b| {
        b.iter(|| black_box(analyzer.analyze()))
    });
}

fn bench_recovery_state_intensity(c: &mut Criterion) {
    c.bench_function("recovery_state_intensity", |b| {
        b.iter(|| {
            black_box(RecoveryState::Normal.intensity());
            black_box(RecoveryState::Shock.intensity());
            black_box(RecoveryState::Coma.intensity());
        })
    });
}

// ═══════════════════════════════════════════════════════════════
// WARMUP BENCHMARKS
// ═══════════════════════════════════════════════════════════════

fn bench_warmup_tracker_new(c: &mut Criterion) {
    c.bench_function("warmup_tracker_new", |b| {
        b.iter(|| black_box(WarmupTracker::new()))
    });
}

fn bench_warmup_tracker_is_ready(c: &mut Criterion) {
    let tracker = WarmupTracker::new();

    c.bench_function("warmup_tracker_is_ready", |b| {
        b.iter(|| black_box(tracker.is_ready()))
    });
}

fn bench_warmup_tracker_state(c: &mut Criterion) {
    let tracker = WarmupTracker::new();

    c.bench_function("warmup_tracker_state", |b| {
        b.iter(|| black_box(tracker.state()))
    });
}

fn bench_warmup_tracker_clone(c: &mut Criterion) {
    let tracker = WarmupTracker::new();

    c.bench_function("warmup_tracker_clone", |b| {
        b.iter(|| black_box(tracker.clone()))
    });
}

// ═══════════════════════════════════════════════════════════════
// EXHAUSTION BENCHMARKS
// ═══════════════════════════════════════════════════════════════

fn bench_exhaustion_level_from_energy(c: &mut Criterion) {
    c.bench_function("exhaustion_level_from_energy", |b| {
        b.iter(|| {
            black_box(ExhaustionLevel::from_energy(0.9));
            black_box(ExhaustionLevel::from_energy(0.5));
            black_box(ExhaustionLevel::from_energy(0.1));
        })
    });
}

fn bench_exhaustion_allows_writes(c: &mut Criterion) {
    c.bench_function("exhaustion_allows_writes", |b| {
        b.iter(|| {
            black_box(ExhaustionLevel::Normal.allows_writes());
            black_box(ExhaustionLevel::Elevated.allows_writes());
            black_box(ExhaustionLevel::Exhausted.allows_writes());
            black_box(ExhaustionLevel::Emergency.allows_writes());
        })
    });
}

fn bench_exhaustion_monitor_default(c: &mut Criterion) {
    c.bench_function("exhaustion_monitor_new", |b| {
        b.iter(|| black_box(ExhaustionMonitor::default()))
    });
}

criterion_group!(
    benches,
    // Recovery
    bench_recovery_analyzer_new,
    bench_recovery_analyzer_analyze,
    bench_recovery_state_intensity,
    // Warmup
    bench_warmup_tracker_new,
    bench_warmup_tracker_is_ready,
    bench_warmup_tracker_state,
    bench_warmup_tracker_clone,
    // Exhaustion
    bench_exhaustion_level_from_energy,
    bench_exhaustion_allows_writes,
    bench_exhaustion_monitor_default,
);

criterion_main!(benches);