arkhe-kernel 0.15.0

Domain-neutral deterministic microkernel for virtual worlds. WAL-backed, bit-identical replay, invariant-lifetime shell brand, no async / no unsafe / no floating-point in canonical paths.
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

//! End-to-end action dispatch benchmark.
//!
//! Measures the full kernel step pipeline: action submission, dispatch,
//! effect application, and observer staging — exercising the same code
//! path that bit-identical replay reproduces.

use arkhe_kernel::abi::{CapabilityMask, EntityId, Principal, Tick, TypeCode};
use arkhe_kernel::state::{ActionCompute, ActionContext, InstanceConfig, Op};
use arkhe_kernel::{ArkheAction, Kernel};
use std::hint::black_box;

use criterion::{criterion_group, criterion_main, Criterion};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, ArkheAction)]
#[arkhe(type_code = 1, schema_version = 1)]
struct NoopAction;

impl ActionCompute for NoopAction {
    fn compute(&self, _ctx: &ActionContext) -> Vec<Op> {
        vec![Op::SpawnEntity {
            id: EntityId::new(1).unwrap(),
            owner: Principal::System,
        }]
    }
}

fn bench_submit_step(c: &mut Criterion) {
    c.bench_function("kernel_submit_then_step_one_action", |b| {
        b.iter_batched(
            || {
                let mut k = Kernel::new();
                k.register_action::<NoopAction>();
                let inst = k.create_instance(InstanceConfig::default());
                (k, inst)
            },
            |(mut k, inst)| {
                k.submit(
                    inst,
                    Principal::System,
                    None,
                    CapabilityMask::SYSTEM,
                    Tick(0),
                    TypeCode(1),
                    Vec::new(),
                )
                .unwrap();
                let report = k.step(Tick(0), CapabilityMask::SYSTEM);
                black_box(report);
            },
            criterion::BatchSize::SmallInput,
        );
    });
}

fn bench_step_only(c: &mut Criterion) {
    // Pre-submit a queue of actions; bench measures the step pipeline alone.
    c.bench_function("kernel_step_with_100_pending_actions", |b| {
        b.iter_batched(
            || {
                let mut k = Kernel::new();
                k.register_action::<NoopAction>();
                let inst = k.create_instance(InstanceConfig::default());
                for i in 0..100u64 {
                    k.submit(
                        inst,
                        Principal::System,
                        None,
                        CapabilityMask::SYSTEM,
                        Tick(i),
                        TypeCode(1),
                        Vec::new(),
                    )
                    .unwrap();
                }
                k
            },
            |mut k| {
                for i in 0..100u64 {
                    let report = k.step(Tick(i), CapabilityMask::SYSTEM);
                    black_box(report);
                }
            },
            criterion::BatchSize::SmallInput,
        );
    });
}

criterion_group!(benches, bench_submit_step, bench_step_only);
criterion_main!(benches);