Skip to main content

qualia_core_db/bundle/stream/runtime/
owner.rs

1//! Scoped borrowing of canonical runtime owners; no copied root budgets.
2#[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}