qualia_core_db/bundle/stream/runtime/
owner.rs1#[cfg(not(target_arch = "wasm32"))]
3use super::recovery_source::{RecoverySourceSlot, MAX_RETAINED_SOURCES};
4use super::sparse_workspace::{SparseWorkspaceSlot, MAX_SPARSE_WORKSPACES};
5use super::state::RuntimeClosePhase;
6use super::types::{schedule_id, Slot};
7use super::{RuntimeProfile, TransferState};
8mod close;
9mod counted;
10use crate::net::peer::runtime::{
11 FairScheduler, LeaseTable, OperationHandle, OperationTable, ReservationHandle,
12 ReservationLedger, ResourceBudget, ResourceGovernor,
13};
14use crate::net::qdnf::errors::QdnfError;
15use core::sync::atomic::AtomicUsize;
16static NEXT_OWNER: AtomicUsize = AtomicUsize::new(1);
17pub(super) const HOT_SLOTS: usize = 30;
18
19#[must_use = "drain actual I/O and call close before releasing the scoped owners"]
20pub struct TransferRuntime<'a> {
21 pub(super) ledger: &'a mut ReservationLedger,
22 pub(super) leases: &'a mut LeaseTable,
23 pub(super) operations: &'a mut OperationTable,
24 pub(super) scheduler: &'a mut FairScheduler,
25 pub(super) governor: &'a ResourceGovernor,
26 pub(super) profile: RuntimeProfile,
27 pub(super) slots: [Slot; HOT_SLOTS],
28 pub(super) sparse_workspaces: [SparseWorkspaceSlot; MAX_SPARSE_WORKSPACES],
29 pub(super) workspace_live: usize,
30 #[cfg(not(target_arch = "wasm32"))]
31 pub(super) recovery_sources: [RecoverySourceSlot; MAX_RETAINED_SOURCES],
32 pub(super) source_live: usize,
33 pub(super) owner: usize,
34 pub(super) serial: u64,
35 pub(super) static_charge: Option<ReservationHandle>,
36 pub(super) control_charge: Option<ReservationHandle>,
37 pub(super) control_operation: OperationHandle,
38 pub(super) static_charge_bytes: u64,
39 pub(super) control_budget: ResourceBudget,
40 pub(super) close_phase: RuntimeClosePhase,
41 pub(super) used_bytes: u64,
42 pub(super) live: usize,
43 pub(super) pending_records: usize,
44 pub(super) closed: bool,
45}
46impl<'a> TransferRuntime<'a> {
47 pub fn new(
48 ledger: &'a mut ReservationLedger,
49 leases: &'a mut LeaseTable,
50 operations: &'a mut OperationTable,
51 scheduler: &'a mut FairScheduler,
52 governor: &'a ResourceGovernor,
53 profile: RuntimeProfile,
54 control: ResourceBudget,
55 ) -> Result<Self, QdnfError> {
56 let static_bytes =
57 u64::try_from(core::mem::size_of::<Self>()).map_err(|_| QdnfError::Range)?;
58 Self::new_counted(
59 ledger,
60 leases,
61 operations,
62 scheduler,
63 governor,
64 profile,
65 control,
66 static_bytes,
67 )
68 }
69 pub const fn live_transfers(&self) -> usize {
70 self.live
71 }
72 pub const fn pending_schedule_records(&self) -> usize {
73 self.pending_records
74 }
75 pub const fn charged_window_bytes(&self) -> u64 {
76 self.used_bytes
77 }
78 pub fn leased_slots(&self) -> usize {
79 self.leases.occupied_count()
80 }
81 pub fn parent_used(&self) -> crate::net::peer::runtime::AdmissionScopes {
82 self.ledger.used()
83 }
84 pub fn supported_inflight(&self) -> usize {
85 let owned_limit = 30usize
86 .saturating_sub(self.workspace_live)
87 .saturating_sub(self.source_live);
88 let actual_headroom = self.live.saturating_add(self.ledger.available_handles());
89 owned_limit
90 .min(actual_headroom)
91 .min(self.profile.inflight_limit())
92 }
93 pub(super) fn require_open(&self) -> Result<(), QdnfError> {
94 if self.closed || self.close_phase != RuntimeClosePhase::Open {
95 Err(QdnfError::Closed)
96 } else {
97 Ok(())
98 }
99 }
100 pub(super) fn key(&self, slot: usize) -> Result<super::CompletionKey, QdnfError> {
101 let s = &self.slots[slot];
102 let operation = s.operation.ok_or(QdnfError::Closed)?.id;
103 Ok(super::CompletionKey {
104 owner: self.owner,
105 slot: slot as u8,
106 generation: s.generation,
107 operation,
108 })
109 }
110 pub(super) fn validate(&self, ticket: &super::TransferTicket) -> Result<usize, QdnfError> {
111 self.require_open()?;
112 if ticket.spent {
113 return Err(QdnfError::DoubleRelease);
114 }
115 let key = ticket.key;
116 if key.owner != self.owner {
117 return Err(QdnfError::StaleGeneration);
118 }
119 let i = usize::from(key.slot);
120 let slot = self.slots.get(i).ok_or(QdnfError::StaleGeneration)?;
121 if slot.state == TransferState::Vacant
122 || slot.generation != key.generation
123 || slot.operation.map(|h| h.id) != Some(key.operation)
124 {
125 return Err(QdnfError::StaleGeneration);
126 }
127 Ok(i)
128 }
129}