liminal-protocol 0.3.1

Shared participant-lifecycle protocol types for liminal
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

use crate::{
    algebra::WideResourceVector,
    lifecycle::{
        AttachedLifecycleRecord, BindingTerminalOwner, ClosureAccounting, CommittedBindingTerminal,
        RetainedCausalRecord, RetainedCausalRecordKind, RetainedRecordCharge,
    },
};

#[derive(Clone, Copy)]
struct MarkerAccounting {
    credits: u64,
    anchors: u64,
}

pub(super) fn accounting_after_rows(
    accounting: ClosureAccounting,
    charges: &[RetainedRecordCharge],
) -> Option<ClosureAccounting> {
    accounting_after_rows_with_state(
        accounting,
        charges,
        accounting.state(),
        MarkerAccounting {
            credits: accounting.marker_capacity_credits(),
            anchors: accounting.marker_anchors(),
        },
        accounting.edge_sequence_claims(),
        accounting.edge_order_position_claims(),
        accounting.edge_k_remaining(),
    )
}

pub(super) fn accounting_after_floor(
    accounting: ClosureAccounting,
    released: &[RetainedRecordCharge],
) -> Option<ClosureAccounting> {
    let baseline = released
        .iter()
        .try_fold(accounting.baseline(), |current, charge| {
            let charge = charge.encoded_charge();
            Some(WideResourceVector::new(
                current.entries.checked_sub(u128::from(charge.entries))?,
                current.bytes.checked_sub(u128::from(charge.bytes))?,
            ))
        })?;
    ClosureAccounting::try_new(
        accounting.state(),
        accounting.marker_capacity_credits(),
        accounting.marker_anchors(),
        accounting.edge_sequence_claims(),
        accounting.edge_order_position_claims(),
        accounting.edge_k_remaining(),
        baseline,
        accounting.configured_cap(),
        accounting.episode_churn_used(),
        accounting.episode_churn_limit(),
    )
    .ok()
}

pub(super) fn accounting_after_marker_ack(
    accounting: ClosureAccounting,
) -> Option<ClosureAccounting> {
    accounting_after_rows_with_state(
        accounting,
        &[],
        accounting.state(),
        MarkerAccounting {
            credits: accounting.marker_capacity_credits(),
            anchors: accounting.marker_anchors().checked_sub(1)?,
        },
        accounting.edge_sequence_claims(),
        accounting.edge_order_position_claims(),
        accounting.edge_k_remaining(),
    )
}

pub(super) fn accounting_after_fenced_attach(
    accounting: ClosureAccounting,
    charges: &[RetainedRecordCharge],
    next_state: crate::lifecycle::ClosureState,
) -> Option<ClosureAccounting> {
    accounting_after_rows_with_state(
        accounting,
        charges,
        next_state,
        MarkerAccounting {
            credits: accounting.marker_capacity_credits(),
            anchors: accounting.marker_anchors().checked_sub(1)?,
        },
        0,
        0,
        crate::algebra::ResourceVector::default(),
    )
}

pub(super) fn accounting_after_leave(
    accounting: ClosureAccounting,
    charges: &[RetainedRecordCharge],
    retired_marker_charge: Option<RetainedRecordCharge>,
) -> Option<ClosureAccounting> {
    let marker_released = u64::from(retired_marker_charge.is_some());
    let mut charges = charges.to_vec();
    if let Some(charge) = retired_marker_charge {
        charges.push(charge);
    }
    accounting_after_rows_with_state(
        accounting,
        &charges,
        accounting.state(),
        MarkerAccounting {
            credits: accounting
                .marker_capacity_credits()
                .checked_sub(marker_released)?,
            anchors: accounting.marker_anchors().checked_sub(marker_released)?,
        },
        accounting.edge_sequence_claims(),
        accounting.edge_order_position_claims(),
        accounting.edge_k_remaining(),
    )
}

fn accounting_after_rows_with_state(
    accounting: ClosureAccounting,
    charges: &[RetainedRecordCharge],
    state: crate::lifecycle::ClosureState,
    marker: MarkerAccounting,
    edge_sequence_claims: u64,
    edge_order_position_claims: u64,
    edge_k_remaining: crate::algebra::ResourceVector,
) -> Option<ClosureAccounting> {
    let baseline = charges
        .iter()
        .try_fold(accounting.baseline(), |current, charge| {
            let charge = charge.encoded_charge();
            Some(WideResourceVector::new(
                current.entries.checked_add(u128::from(charge.entries))?,
                current.bytes.checked_add(u128::from(charge.bytes))?,
            ))
        })?;
    ClosureAccounting::try_new(
        state,
        marker.credits,
        marker.anchors,
        edge_sequence_claims,
        edge_order_position_claims,
        edge_k_remaining,
        baseline,
        accounting.configured_cap(),
        accounting.episode_churn_used(),
        accounting.episode_churn_limit(),
    )
    .ok()
}

pub(super) const fn retained_attached(attached: AttachedLifecycleRecord) -> RetainedCausalRecord {
    RetainedCausalRecord {
        delivery_seq: attached.delivery_seq(),
        admission_order: attached.admission_order(),
        kind: RetainedCausalRecordKind::AttachLifecycle {
            participant_index: attached.participant_id(),
            binding_epoch: attached.binding_epoch(),
        },
    }
}

pub(super) const fn retained_terminal(terminal: CommittedBindingTerminal) -> RetainedCausalRecord {
    RetainedCausalRecord {
        delivery_seq: terminal.delivery_seq(),
        admission_order: terminal.admission_order(),
        kind: RetainedCausalRecordKind::BindingTerminal(BindingTerminalOwner {
            participant_index: terminal.participant_id(),
            binding_epoch: terminal.binding_epoch(),
        }),
    }
}