hibana 0.9.7

Choreographic programming in Rust with no_std and no heap allocation
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use super::dependency_conflict_for_scope;
use crate::global::{
    const_dsl::{EffList, ScopeId, ScopeKind},
    typestate::LocalConflict,
};

const SCOPE_KIND_COUNT: usize = 3;
const SCOPE_ORDINAL_COUNT: usize = ScopeId::LOCAL_CAPACITY as usize;

/// Immutable compiler facts shared by every role projection. The index is
/// exactly the encoded scope kind/ordinal domain, including sparse ordinals;
/// no event-count ceiling or runtime storage is introduced.
pub(crate) struct ScopeFacts {
    parents: [[Option<LocalConflict>; SCOPE_ORDINAL_COUNT]; SCOPE_KIND_COUNT],
    route_count: usize,
}

impl ScopeFacts {
    pub(crate) const fn new<const E: usize>(source: &EffList<E>) -> Self {
        let markers = source.scope_markers();
        let mut facts = Self {
            parents: [[None; SCOPE_ORDINAL_COUNT]; SCOPE_KIND_COUNT],
            route_count: 0,
        };
        let mut index = 0usize;
        while index < markers.len() {
            let marker = markers.at(index);
            if marker.event.is_primary_enter() {
                let scope = marker.scope_id;
                let kind = Self::kind_index(scope);
                let ordinal = scope.local_ordinal() as usize;
                if facts.parents[kind][ordinal].is_some() {
                    panic!("duplicate primary scope identity");
                }
                facts.parents[kind][ordinal] =
                    Some(dependency_conflict_for_scope(markers, source.len(), scope));
                if matches!(scope.kind(), Some(ScopeKind::Route)) {
                    facts.route_count += 1;
                }
            }
            index += 1;
        }
        facts
    }

    #[inline(always)]
    const fn kind_index(scope: ScopeId) -> usize {
        match scope.kind() {
            Some(ScopeKind::Route) => 0,
            Some(ScopeKind::Roll) => 1,
            Some(ScopeKind::Parallel) => 2,
            None => crate::invariant(),
        }
    }

    #[inline(always)]
    pub(in crate::global::role_program::image_impl) const fn conflict(
        &self,
        scope: ScopeId,
    ) -> LocalConflict {
        match self.parents[Self::kind_index(scope)][scope.local_ordinal() as usize] {
            Some(conflict) => conflict,
            None => panic!("scope projection fact missing"),
        }
    }

    #[inline(always)]
    pub(super) const fn route_count(&self) -> usize {
        self.route_count
    }
}

#[cfg(all(test, hibana_repo_tests))]
mod tests {
    use super::*;
    use crate::{
        eff::{EffAtom, EventOrigin},
        g::{Msg, Par, ProgramSourceData, Roll, Route, Send},
    };

    #[test]
    fn cached_parent_facts_match_the_source_definition_for_every_scope() {
        type Body = Roll<
            Par<
                Route<Send<0, 1, Msg<1, ()>>, Send<0, 1, Msg<2, ()>>>,
                Route<
                    Send<0, 2, Msg<3, ()>>,
                    Roll<Route<Send<0, 2, Msg<4, ()>>, Send<0, 2, Msg<5, ()>>>>,
                >,
            >,
        >;
        let source = ProgramSourceData::<32>::lower::<Body>();
        let source = source.eff_list();
        let facts = ScopeFacts::new(source);
        let markers = source.scope_markers();
        let mut routes = 0;
        for index in 0..markers.len() {
            let marker = markers.at(index);
            if marker.event.is_primary_enter() {
                assert_eq!(
                    facts.conflict(marker.scope_id),
                    dependency_conflict_for_scope(markers, source.len(), marker.scope_id)
                );
                if matches!(marker.scope_id.kind(), Some(ScopeKind::Route)) {
                    routes += 1;
                }
            }
        }
        assert_eq!(facts.route_count(), routes);
    }

    #[test]
    fn sparse_last_encoded_scope_ordinal_has_an_exact_cache_slot() {
        let mut source = EffList::<8>::new_partitioned(2, 4, 1);
        let atom = EffAtom {
            from: 0,
            to: 1,
            label: 1,
            payload_schema: 1,
            origin: EventOrigin::User,
            lane: 0,
        };
        source.push_event_mut(atom);
        source.push_event_mut(EffAtom { label: 2, ..atom });
        let scope = ScopeId::route(ScopeId::LOCAL_CAPACITY - 1);
        source.push_route_scope_mut(
            scope,
            0,
            1,
            2,
            crate::global::const_dsl::ReentryMark::SinglePass,
        );
        let facts = ScopeFacts::new(&source);
        assert_eq!(facts.conflict(scope), LocalConflict::Unconditional);
        assert_eq!(facts.route_count(), 1);
    }

    #[test]
    #[should_panic(expected = "scope projection fact missing")]
    fn absent_identity_is_rejected_instead_of_becoming_a_root() {
        ScopeFacts::new(&EffList::<1>::new()).conflict(ScopeId::route(0));
    }
}