mod cab;
mod dependency;
mod lru;
mod pending;
mod rank;
mod reach;
mod register;
mod slot;
use std::cell::Cell;
use std::collections::{BTreeMap, HashMap};
use std::mem::size_of;
use std::ops::Bound;
#[cfg(test)]
use std::sync::Mutex;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use std::sync::{Arc, RwLock};
pub use cab::{Cab, HeldCab, RawCab};
#[cfg(test)]
pub(crate) use dependency::open_bare;
pub(crate) use dependency::{
DepSlot, Dependency, Open, PoolRefusal, from_callers, open_source, pool_refused, with_room,
};
pub(crate) use lru::DepCache;
#[cfg(test)]
pub(crate) use lru::{Hook, HookFn};
pub(crate) use rank::Rank;
pub(crate) use reach::{Through, entry_of, probe_bundle_entry};
pub(crate) use register::Stage;
use register::{By, Loads};
pub(crate) use slot::{Slot, SlotKind};
use super::held::{self, Held, lock};
use super::watch::{Table, Under, Watches};
use crate::error::Error;
use crate::files::{BundleFile, File};
use crate::limits::{Charge, HASH_TABLE_SHARES, Meter, heap_cost};
use crate::raw::RawStr;
#[derive(Debug)]
struct Entry {
slot: Arc<Slot>,
first: Rank,
_share: Charge,
first_charge: Charge,
}
#[derive(Debug)]
pub struct Registry {
inner: RwLock<RegistryInner>,
loads: AtomicU64,
pending_len: AtomicUsize,
evicted_len: AtomicUsize,
built: AtomicU64,
parsed: AtomicU64,
watches: Watches,
#[cfg(test)]
pub(crate) hook: Mutex<Option<HookFn>>,
}
impl Default for Registry {
fn default() -> Self {
Self {
inner: RwLock::default(),
loads: AtomicU64::new(0),
pending_len: AtomicUsize::new(0),
evicted_len: AtomicUsize::new(0),
built: AtomicU64::new(0),
parsed: AtomicU64::new(0),
watches: Watches::default(),
#[cfg(test)]
hook: Mutex::new(None),
}
}
}
impl Under for Registry {
fn with_table(&self, f: &mut dyn FnMut(&mut Table)) {
f(&mut self.write().watched);
}
}
#[derive(Debug)]
struct RegistryInner {
order: BTreeMap<Rank, RawStr>,
slots: HashMap<RawStr, Entry>,
pending: pending::Pending,
watched: Table,
generation: u64,
}
impl Default for RegistryInner {
fn default() -> Self {
Self {
order: BTreeMap::new(),
slots: HashMap::new(),
pending: pending::Pending::default(),
watched: Table::default(),
generation: 1,
}
}
}
impl RegistryInner {
fn publish(&mut self, hash: u64, load: bool) {
self.watched.notify(hash);
if load {
self.start_generation();
}
}
fn start_generation(&mut self) {
self.generation = self.generation.saturating_add(1);
}
}
const ORDER_ELEMENT: usize = size_of::<Rank>() + size_of::<RawStr>();
const ORDER_LEAF: u64 = heap_cost((16 + 11 * ORDER_ELEMENT) as u64);
const ORDER_INTERNAL: u64 = heap_cost((16 + 11 * ORDER_ELEMENT + 12 * size_of::<usize>()) as u64);
const SHARE: u64 = ORDER_LEAF / 5
+ 1
+ ORDER_INTERNAL / 30
+ 1
+ HASH_TABLE_SHARES * (size_of::<RawStr>() + size_of::<Entry>() + 1) as u64;
const SLOT_ARC: u64 = heap_cost((size_of::<Slot>() + 2 * size_of::<usize>()) as u64);
const PENDING_SHARE: u64 = pending::SHARE;
thread_local! {
static LOAD_KEYS_HERE: Cell<u64> = const { Cell::new(0) };
}
pub(crate) fn load_keys_here() -> u64 {
LOAD_KEYS_HERE.with(Cell::get)
}
impl Registry {
#[cfg(test)]
pub(crate) fn hook(&self, at: Hook) {
let hook = lock(&self.hook).clone();
if let Some(HookFn(f)) = hook {
f(at);
}
}
fn read(&self) -> Held<std::sync::RwLockReadGuard<'_, RegistryInner>> {
held::read(&self.inner)
}
fn write(&self) -> Held<std::sync::RwLockWriteGuard<'_, RegistryInner>> {
held::write(&self.inner)
}
pub(crate) fn slot(
&self,
name: &RawStr,
meter: &Arc<Meter>,
) -> Result<Option<Arc<Slot>>, Error> {
self.slot_bytes(name.as_bytes(), meter)
}
pub(crate) fn slot_bytes(
&self,
name: &[u8],
meter: &Arc<Meter>,
) -> Result<Option<Arc<Slot>>, Error> {
self.settle().ok();
let key = crate::pystr::simplify_name_vec(name, meter)?;
Ok(self
.read()
.slots
.get(key.as_slice())
.map(|e| e.slot.clone()))
}
pub(crate) fn slot_after(&self, after: Option<&Rank>) -> Option<(Rank, Arc<Slot>)> {
let inner = self.read();
let lower = after.map_or(Bound::Unbounded, Bound::Excluded);
let (rank, key) = inner.order.range((lower, Bound::Unbounded)).next()?;
let slot = inner.slots.get(key.as_bytes())?.slot.clone();
Some((rank.clone(), slot))
}
fn key_after(&self, after: Option<&Rank>) -> Option<(Rank, RawStr)> {
let inner = self.read();
let lower = after.map_or(Bound::Unbounded, Bound::Excluded);
let (rank, key) = inner.order.range((lower, Bound::Unbounded)).next()?;
Some((rank.clone(), key.clone()))
}
pub(crate) fn watches(&self) -> &Watches {
&self.watches
}
#[cfg(test)]
pub(crate) fn watch_room(&self) -> (usize, usize, Vec<(usize, usize)>) {
self.read().watched.room()
}
pub(crate) fn generation(&self) -> u64 {
self.read().generation
}
pub(crate) fn built(&self, generation: u64) -> bool {
self.built.load(Ordering::Acquire) >= generation
}
pub(crate) fn publish_built(&self, generation: u64) {
self.built.fetch_max(generation, Ordering::AcqRel);
}
fn count(&self, slot: &Slot) {
if !slot.counted.swap(true, Ordering::Relaxed) {
self.parsed.fetch_add(1, Ordering::Relaxed);
}
}
pub(crate) fn parsed(&self) -> u64 {
self.parsed.load(Ordering::Relaxed)
}
pub fn get(&self, name: &RawStr, meter: &Arc<Meter>) -> Result<Option<Cab>, Error> {
Ok(self.get_held(name, meter)?.map(|h| h.cab))
}
pub(crate) fn get_held(
&self,
name: &RawStr,
meter: &Arc<Meter>,
) -> Result<Option<HeldCab>, Error> {
match self.slot(name, meter)? {
Some(slot) => self.resolve_held(&slot),
None => Ok(None),
}
}
pub(crate) fn resolve(&self, slot: &Arc<Slot>) -> Result<Option<Cab>, Error> {
Ok(self.resolve_held(slot)?.map(|h| h.cab))
}
pub(crate) fn resolve_held(&self, slot: &Arc<Slot>) -> Result<Option<HeldCab>, Error> {
let held = |cab: Option<Cab>| cab.map(|cab| HeldCab { cab, hold: None });
match &slot.kind {
SlotKind::Ready(cab) => Ok(held(Some(cab.clone()))),
SlotKind::Entry { bundle, dir_index } => {
let file = bundle.entry(*dir_index)?;
self.count(slot);
self.answer(slot, file, Some((bundle, *dir_index)))
.map(held)
}
SlotKind::Dependency { dep } => dep.with_room(|| self.resolve_dependency(slot, dep)),
}
}
fn resolve_dependency(
&self,
slot: &Arc<Slot>,
dep: &Arc<Dependency>,
) -> Result<Option<HeldCab>, Error> {
let top = dep.handle()?;
let mut file = top.clone();
let mut at: Option<(Arc<BundleFile>, usize)> = None;
let path = slot.rank.path();
for &i in path {
match file {
File::Bundle(b) => {
file = b.entry(i)?;
at = Some((b, i));
}
File::Web(w) => {
file = w.entry(i)?;
at = None;
}
_ => return Ok(None),
}
}
if !path.is_empty() {
self.count(slot);
}
if let Some(cache) = dep.cache.upgrade() {
cache.refresh(dep);
}
let at = at.as_ref().map(|(b, i)| (b, *i));
let cab = self.answer(slot, file, at)?;
Ok(cab.map(|cab| HeldCab {
cab,
hold: Some(top),
}))
}
fn answer(
&self,
slot: &Arc<Slot>,
file: File,
at: Option<(&Arc<BundleFile>, usize)>,
) -> Result<Option<Cab>, Error> {
let cab = match file {
File::Serialized(sf) => Some(Cab::Serialized(sf)),
File::Raw(raw) => Some(Cab::Raw(match at {
Some((bundle, dir_index)) => RawCab::InBundle {
bundle: bundle.clone(),
dir_index,
},
None => RawCab::File(raw),
})),
File::Bundle(nested) => {
self.reach(slot, Some(&nested))?;
return Ok(None);
}
File::Web(w) => {
self.reach_web(slot, &w)?;
return Ok(None);
}
};
slot.mark_reached();
Ok(cab)
}
#[must_use]
pub fn keys(&self) -> Keys<'_> {
self.settle().ok();
Keys {
registry: self,
after: None,
}
}
#[must_use]
pub fn len(&self) -> usize {
self.read().order.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
#[derive(Debug)]
pub struct Keys<'a> {
registry: &'a Registry,
after: Option<Rank>,
}
impl Iterator for Keys<'_> {
type Item = RawStr;
fn next(&mut self) -> Option<RawStr> {
let (rank, key) = self.registry.key_after(self.after.as_ref())?;
self.after = Some(rank);
Some(key)
}
}
#[cfg(test)]
mod pass_tests;
#[cfg(test)]
mod reach_tests;
#[cfg(test)]
mod room_tests;
#[cfg(test)]
mod tests;
pub(crate) use dependency::read_source;