use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
#[cfg(test)]
use super::Hook;
use super::{
Cab, DepSlot, Dependency, Entry, LOAD_KEYS_HERE, ORDER_LEAF, PENDING_SHARE, Rank, Registry,
RegistryInner, SHARE, SLOT_ARC, Slot, SlotKind, pending, reach, slot,
};
use crate::error::Error;
use crate::files::BundleFile;
use crate::limits::{Charge, Meter, MeteredVec};
use crate::pystr::simplify_name;
use crate::raw::RawStr;
pub(crate) struct Staged {
key: RawStr,
position: Rank,
slot: Arc<Slot>,
share: Option<Charge>,
first_charge: Charge,
}
pub(crate) struct Stage {
staged: MeteredVec<Staged>,
root: bool,
}
impl Stage {
pub(crate) fn new(meter: &Arc<Meter>) -> Self {
Self {
staged: MeteredVec::new(meter),
root: false,
}
}
pub(crate) fn reserve(&mut self, n: usize) -> Result<(), Error> {
Ok(self.staged.reserve_exact(n)?)
}
}
struct Dropped {
slot: Arc<Slot>,
_charge: Charge,
listed: Option<u64>,
}
#[derive(Clone, Copy, Debug)]
pub(super) struct Loads {
pub(super) value: u64,
pub(super) position: u64,
}
impl Loads {
pub(super) fn at(load: u64) -> Self {
Self {
value: load,
position: load,
}
}
}
struct Stand {
standing: Arc<Slot>,
dropped: Arc<Slot>,
}
impl Stand {
fn of(new: &Arc<Slot>, value: &Arc<Slot>) -> Option<Self> {
let (standing, dropped) = match new.rank.cmp(&value.rank) {
std::cmp::Ordering::Greater => (new, value),
std::cmp::Ordering::Less => (value, new),
std::cmp::Ordering::Equal => return None,
};
(dropped.unreached() && reach::stands_in(standing, dropped)).then(|| Self {
standing: standing.clone(),
dropped: dropped.clone(),
})
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub(super) enum By {
Load,
Reach,
}
impl Registry {
pub(crate) fn next_load(&self) -> u64 {
self.loads.fetch_add(1, Ordering::Relaxed)
}
pub fn register(&self, name: &RawStr, cab: Cab, meter: &Arc<Meter>) -> Result<(), Error> {
let load = self.next_load();
self.register_ready(name, cab, load, &[], meter)
}
pub fn register_lazy(
&self,
name: &RawStr,
bundle: Arc<BundleFile>,
dir_index: usize,
meter: &Arc<Meter>,
) -> Result<(), Error> {
let load = self.next_load();
self.register_entry(name, bundle, dir_index, load, &[dir_index], meter)
}
pub(crate) fn register_ready(
&self,
name: &RawStr,
cab: Cab,
load: u64,
path: &[usize],
meter: &Arc<Meter>,
) -> Result<(), Error> {
self.insert(
name,
SlotKind::Ready(cab),
Loads::at(load),
path,
meter,
By::Load,
false,
)
}
pub(crate) fn register_entry(
&self,
name: &RawStr,
bundle: Arc<BundleFile>,
dir_index: usize,
load: u64,
path: &[usize],
meter: &Arc<Meter>,
) -> Result<(), Error> {
let kind = SlotKind::Entry { bundle, dir_index };
self.insert(name, kind, Loads::at(load), path, meter, By::Load, true)
}
pub(crate) fn register_dependency(
&self,
name: &RawStr,
dep: &Arc<Dependency>,
load: u64,
path: &[usize],
meter: &Arc<Meter>,
) -> Result<(), Error> {
let kind = SlotKind::Dependency {
dep: DepSlot::new(dep),
};
self.insert(name, kind, Loads::at(load), path, meter, By::Load, false)
}
#[cfg(test)]
pub(crate) fn register_lazy_dependency(
&self,
name: &RawStr,
dep: &Arc<Dependency>,
load: u64,
path: &[usize],
meter: &Arc<Meter>,
) -> Result<(), Error> {
let kind = SlotKind::Dependency {
dep: DepSlot::new(dep),
};
self.insert(name, kind, Loads::at(load), path, meter, By::Load, true)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn stage(
&self,
stage: &mut Stage,
name: &RawStr,
dep: &Arc<Dependency>,
load: u64,
path: &[usize],
meter: &Arc<Meter>,
lazy: bool,
) -> Result<(), Error> {
let kind = SlotKind::Dependency {
dep: DepSlot::new(dep),
};
let loads = Loads::at(load);
let staged = self.prepare(name, kind, loads, path, meter, lazy, &mut stage.root)?;
Ok(stage.staged.push(staged)?)
}
pub(crate) fn commit(&self, stage: Stage) -> Result<(), Error> {
let (staged, _list) = stage.staged.into_parts();
for one in staged {
self.apply(one, By::Load)?;
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub(super) fn insert(
&self,
name: &RawStr,
kind: SlotKind,
loads: Loads,
path: &[usize],
meter: &Arc<Meter>,
by: By,
lazy: bool,
) -> Result<(), Error> {
let staged = self.prepare(name, kind, loads, path, meter, lazy, &mut false)?;
self.apply(staged, by)
}
#[allow(clippy::too_many_arguments)]
fn prepare(
&self,
name: &RawStr,
kind: SlotKind,
loads: Loads,
path: &[usize],
meter: &Arc<Meter>,
lazy: bool,
root: &mut bool,
) -> Result<Staged, Error> {
let lowered = simplify_name(name, meter)?;
let slot = Self::new_slot(kind, loads.value, path, lazy, meter)?;
let position = Rank {
load: loads.position.min(loads.value),
path: slot.rank.path.clone(),
};
let (known, first) = {
let inner = self.read();
let known = inner.slots.contains_key(lowered.as_bytes());
(known, inner.order.is_empty() && !*root)
};
let (key, share) = if known {
(lowered, None)
} else {
let share = meter.charge(if first { SHARE + ORDER_LEAF } else { SHARE })?;
*root |= first;
(RawStr::charged(lowered.as_bytes(), meter)?, Some(share))
};
let first_charge = meter.charge(Rank::heap(path.len()))?;
Ok(Staged {
key,
position,
slot,
share,
first_charge,
})
}
fn apply(&self, staged: Staged, by: By) -> Result<(), Error> {
let Staged {
key,
position,
slot,
share,
first_charge,
} = staged;
let rank = slot.rank.clone();
let value = self
.read()
.slots
.get(key.as_bytes())
.map(|e| e.slot.clone());
let stand = value.as_ref().and_then(|v| Stand::of(&slot, v));
drop(value);
let hash = self.watches.hash(key.as_bytes());
let (dropped, changed, new_key) = {
let mut inner = self.write();
let RegistryInner {
order,
slots,
pending,
..
} = &mut *inner;
let out = if let Some(e) = slots.get_mut(key.as_bytes()) {
let moves = position < e.first;
let charge = if moves {
if let Some(key) = order.remove(&e.first) {
order.insert(position.clone(), key);
}
e.first = position;
std::mem::replace(&mut e.first_charge, first_charge)
} else {
first_charge
};
let replaces = rank > e.slot.rank;
let distinct = rank != e.slot.rank;
let slot = if replaces {
std::mem::replace(&mut e.slot, slot)
} else {
slot
};
let listed = (distinct
&& slot.unreached()
&& !Self::stood_in(stand.as_ref(), &e.slot, &slot))
.then(|| {
let (_, steps) = pending.push(slot.clone());
self.store_lens(pending);
steps
});
let dropped = Dropped {
slot,
_charge: charge,
listed,
};
(Some(dropped), moves || replaces, false)
} else if let Some(share) = share {
order.insert(position.clone(), key.clone());
slots.reserve(1);
slots.insert(
key,
Entry {
slot,
first: position,
_share: share,
first_charge,
},
);
(None, true, true)
} else {
return Err(Error::Malformed {
what: "registry",
detail: "a key vanished".into(),
});
};
if out.1 {
inner.publish(hash, by == By::Load);
} else if by == By::Load && out.0.as_ref().is_some_and(|d| d.listed.is_some()) {
inner.start_generation();
}
out
};
self.count_change(changed, new_key, by);
drop(stand);
self.release(dropped);
if by == By::Load {
self.settle().ok();
}
Ok(())
}
#[cfg_attr(not(test), allow(unused_variables, clippy::unused_self))]
fn count_change(&self, changed: bool, new_key: bool, by: By) {
#[cfg(test)]
if changed {
self.hook(Hook::Published);
}
if new_key && by == By::Load {
LOAD_KEYS_HERE.with(|c| c.set(c.get().saturating_add(1)));
}
}
fn stood_in(stand: Option<&Stand>, standing: &Arc<Slot>, dropped: &Arc<Slot>) -> bool {
let Some(stand) = stand else {
return false;
};
if !(Arc::ptr_eq(&stand.standing, standing) && Arc::ptr_eq(&stand.dropped, dropped)) {
return false;
}
standing.stand_for(dropped.position())
}
pub(super) fn store_lens(&self, pending: &pending::Pending) {
self.pending_len
.store(pending.len(pending::List::Listed), Ordering::Release);
self.evicted_len
.store(pending.len(pending::List::Evicted), Ordering::Release);
}
fn new_slot(
kind: SlotKind,
load: u64,
path: &[usize],
lazy: bool,
meter: &Arc<Meter>,
) -> Result<Arc<Slot>, Error> {
let mut charge = Charge::zero(meter);
charge.grow(SLOT_ARC)?;
charge.grow(Rank::heap(path.len()))?;
if lazy {
charge.grow(PENDING_SHARE)?;
}
let rank = Rank {
load,
path: Arc::from(path),
};
Ok(Arc::new(Slot {
kind,
rank,
lazy,
reached: AtomicBool::new(false),
stands_for: AtomicU64::new(slot::NONE),
counted: AtomicBool::new(false),
walked: AtomicBool::new(false),
charge,
}))
}
#[cfg_attr(not(test), allow(clippy::unused_self))]
fn release(&self, dropped: Option<Dropped>) {
if let Some(d) = &dropped
&& let Some(steps) = d.listed
{
d.slot
.input_meter()
.add_work(steps.saturating_mul(pending::STEP));
#[cfg(test)]
self.hook(Hook::Deferred);
}
drop(dropped);
}
}