sim-expr-tree-calc 0.1.0

Bounded incremental calculation of ordinary SIM expressions and values.
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

use std::{
    fmt,
    sync::{Arc, RwLock},
};

use super::*;

pub(super) fn expr_identity(expr: &Expr) -> u64 {
    let mut identity = StableIdentity::new();
    identity.write_debug(&expr.canonical_key());
    identity.finish()
}

pub(super) fn state_identities(
    state: &Arc<RwLock<CalcState>>,
    context_factory: &Arc<ContextFactory>,
) -> Result<(u64, u64), DerivedSnapshotError> {
    let (
        cells,
        bound_names,
        bound_values,
        codec_registry_revision,
        tree_calc_policy,
        dir_calc_policies,
        cell_calc_policies,
        tree_codec_policy,
        dir_codec_policies,
        cell_codec_policies,
        authority_ceiling,
        tree_authority_policy,
        dir_authority_policies,
        cell_authority_policies,
        mounts,
    ) = {
        let state = state.read().expect("calc state poisoned");
        (
            state.cells.clone(),
            state.bound_names.clone(),
            state.bound_values.clone(),
            state.codec_registry_revision,
            state.tree_calc_policy.clone(),
            state.dir_calc_policies.clone(),
            state.cell_calc_policies.clone(),
            state.tree_codec_policy.clone(),
            state.dir_codec_policies.clone(),
            state.cell_codec_policies.clone(),
            state.authority_ceiling.clone(),
            state.tree_authority_policy.clone(),
            state.dir_authority_policies.clone(),
            state.cell_authority_policies.clone(),
            state.mounts.clone(),
        )
    };
    let mut source = StableIdentity::new();
    source.write_debug(&cells);
    source.write_debug(&bound_names);
    let mut cx = context_factory();
    for (name, value) in &bound_values {
        source.write(name.to_string().as_bytes());
        let expr = value.object().as_expr(&mut cx).map_err(backend_error)?;
        source.write_debug(&expr.canonical_key());
    }
    let mut control = StableIdentity::new();
    control.write_debug(&codec_registry_revision);
    control.write_debug(&tree_calc_policy);
    control.write_debug(&dir_calc_policies);
    control.write_debug(&cell_calc_policies);
    control.write_debug(&tree_codec_policy);
    control.write_debug(&dir_codec_policies);
    control.write_debug(&cell_codec_policies);
    control.write_debug(&authority_ceiling);
    control.write_debug(&tree_authority_policy);
    control.write_debug(&dir_authority_policies);
    control.write_debug(&cell_authority_policies);
    control.write_debug(&mounts);
    Ok((source.finish(), control.finish()))
}

pub(super) struct StableIdentity(u64);

impl StableIdentity {
    const OFFSET: u64 = 0xcbf2_9ce4_8422_2325;
    const PRIME: u64 = 0x0000_0100_0000_01b3;

    pub(super) fn new() -> Self {
        Self(Self::OFFSET)
    }

    pub(super) fn write(&mut self, bytes: &[u8]) {
        for byte in bytes {
            self.0 ^= u64::from(*byte);
            self.0 = self.0.wrapping_mul(Self::PRIME);
        }
        self.0 ^= 0xff;
        self.0 = self.0.wrapping_mul(Self::PRIME);
    }

    pub(super) fn write_debug(&mut self, value: &impl fmt::Debug) {
        self.write(format!("{value:?}").as_bytes());
    }

    pub(super) fn finish(self) -> u64 {
        self.0
    }
}