#[cfg(test)]
use std::sync::{Arc, Barrier, Mutex, mpsc};
#[cfg(test)]
use std::thread::ThreadId;
use super::{By, Cab, Hook, HookFn, Loads, Rank, RawCab, Registry, SlotKind};
use crate::detect::FileType;
use crate::env::heap::{self, Noted};
use crate::env::watch::REGISTRY;
use crate::env::{EnvOptions, Environment, Source, held};
use crate::files::RawFile;
use crate::limits::Meter;
use crate::raw::RawStr;
use bytes::Bytes;
use unityrs_testkit::env::{Obj, bundle, res_bytes, serialized};
fn two_keys() -> Source {
Source::Bytes {
name: RawStr::from("d.bundle"),
data: Bytes::from(bundle(&[
("CAB-X", serialized(&[], &[Obj::named(1, "x1", &[])])),
("CAB-X.resS", res_bytes(64, 3)),
])),
}
}
#[cfg(test)]
struct Pause {
at: Hook,
armed: Mutex<Option<ThreadId>>,
stopped: Mutex<Option<mpsc::Sender<()>>>,
go: Mutex<Option<mpsc::Receiver<()>>>,
}
#[cfg(test)]
struct Held {
pause: Arc<Pause>,
stopped: mpsc::Receiver<()>,
go: mpsc::Sender<()>,
}
#[cfg(test)]
impl Held {
fn install(env: &Environment, at: Hook) -> Self {
let (stopped_tx, stopped) = mpsc::channel();
let (go, go_rx) = mpsc::channel();
let pause = Arc::new(Pause {
at,
armed: Mutex::new(None),
stopped: Mutex::new(Some(stopped_tx)),
go: Mutex::new(Some(go_rx)),
});
let p = pause.clone();
*env.inner.cache.hook.lock().unwrap() = Some(HookFn(Arc::new(move |h| p.reach(h))));
Self { pause, stopped, go }
}
fn wait_stopped(&self) {
unityrs_testkit::guard::wait(&self.stopped, "the armed thread to reach its hook");
}
fn release(&self) {
self.go.send(()).unwrap();
}
}
#[cfg(test)]
impl Pause {
fn arm(&self) {
*self.armed.lock().unwrap() = Some(std::thread::current().id());
}
fn reach(&self, h: Hook) {
if h != self.at {
return;
}
let me = std::thread::current().id();
let stop = {
let mut armed = self.armed.lock().unwrap();
let stop = *armed == Some(me);
if stop {
*armed = None;
}
stop
};
if !stop {
return;
}
if let Some(tx) = self.stopped.lock().unwrap().take() {
let _ = tx.send(());
}
let go = self.go.lock().unwrap().take();
if let Some(rx) = go {
unityrs_testkit::guard::hold(&rx, "the test to let the held thread go");
}
}
}
fn current_dep_bytes(env: &Environment) -> u64 {
let held = env
.get_cab_held(&RawStr::from("cab-x"), &Meter::unlimited())
.unwrap()
.unwrap();
held.hold.unwrap().meter().used()
}
#[cfg(test)]
#[test]
fn two_slots_dropped_at_once_leave_the_lru_once() {
let env = Environment::new(EnvOptions::unitypy());
let m = Meter::unlimited();
env.load_dependency(two_keys()).unwrap();
let a = env
.registry()
.slot(&RawStr::from("cab-x"), &m)
.unwrap()
.unwrap();
let b = env
.registry()
.slot(&RawStr::from("cab-x.ress"), &m)
.unwrap()
.unwrap();
env.load_dependency(two_keys()).unwrap();
assert_eq!(env.inner.cache.len(), 2);
let held = Held::install(&env, Hook::SlotReleased);
let first = {
let held_pause = held.pause.clone();
std::thread::spawn(move || {
held_pause.arm();
drop(a);
})
};
held.wait_stopped();
drop(b);
held.release();
first.join().unwrap();
assert_eq!(env.inner.cache.len(), 1, "the replaced dependency left");
assert_eq!(env.stats().dependency_bytes, current_dep_bytes(&env));
}
#[cfg(test)]
#[test]
fn a_load_whose_keys_are_replaced_before_it_returns_leaves_the_lru() {
let env = Environment::new(EnvOptions::unitypy());
let held = Held::install(&env, Hook::LoadChecked);
let first = {
let env = env.clone();
let held_pause = held.pause.clone();
std::thread::spawn(move || {
held_pause.arm();
env.load_dependency(two_keys()).unwrap();
})
};
held.wait_stopped();
env.load_dependency(two_keys()).unwrap();
held.release();
first.join().unwrap();
assert_eq!(env.inner.cache.len(), 1);
assert_eq!(env.stats().dependency_bytes, current_dep_bytes(&env));
}
#[cfg(test)]
#[test]
fn a_load_whose_keys_are_replaced_before_its_touch_leaves_the_lru() {
let env = Environment::new(EnvOptions::unitypy());
let held = Held::install(&env, Hook::LoadRegistered);
let first = {
let env = env.clone();
let held_pause = held.pause.clone();
std::thread::spawn(move || {
held_pause.arm();
env.load_dependency(two_keys()).unwrap();
})
};
held.wait_stopped();
env.load_dependency(two_keys()).unwrap();
held.release();
first.join().unwrap();
assert_eq!(env.inner.cache.len(), 1);
assert_eq!(env.stats().dependency_bytes, current_dep_bytes(&env));
}
#[cfg(test)]
#[test]
fn a_lazy_load_whose_keys_are_replaced_before_its_paid_touch_leaves_the_lru() {
let mut options = EnvOptions::unitypy();
options.load = crate::env::LoadMode::Lazy;
let env = Environment::new(options);
let held = Held::install(&env, Hook::LoadRegistered);
let first = {
let env = env.clone();
let held_pause = held.pause.clone();
std::thread::spawn(move || {
held_pause.arm();
env.load_dependency(two_keys()).unwrap();
})
};
held.wait_stopped();
env.load_dependency(two_keys()).unwrap();
held.release();
first.join().unwrap();
assert_eq!(env.inner.cache.len(), 1);
let current = current_dep_bytes(&env);
assert_eq!(env.stats().dependency_bytes, current);
}
#[cfg(target_pointer_width = "64")]
#[test]
fn a_staged_registration_is_240_bytes() {
assert_eq!(std::mem::size_of::<super::register::Staged>(), 240);
}
#[cfg(test)]
#[test]
fn slots_dropped_together_never_leave_a_dependency_behind() {
const ROUNDS: usize = 2_000;
let env = Environment::new(EnvOptions::unitypy());
let m = Meter::unlimited();
env.load_dependency(two_keys()).unwrap();
for round in 0..ROUNDS {
let a = env
.registry()
.slot(&RawStr::from("cab-x"), &m)
.unwrap()
.unwrap();
let b = env
.registry()
.slot(&RawStr::from("cab-x.ress"), &m)
.unwrap()
.unwrap();
env.load_dependency(two_keys()).unwrap();
let start = Arc::new(Barrier::new(2));
let other = {
let start = start.clone();
std::thread::spawn(move || {
start.wait();
drop(b);
})
};
start.wait();
drop(a);
other.join().unwrap();
assert_eq!(env.inner.cache.len(), 1, "round {round}");
}
}
fn listed(env: &Environment) -> usize {
let reg = &env.inner.registry;
reg.pending_len.load(std::sync::atomic::Ordering::Acquire)
+ reg.evicted_len.load(std::sync::atomic::Ordering::Acquire)
}
fn foo(env: &Environment) -> Option<(usize, Rank)> {
let inner = env.inner.registry.read();
let entry = inner.slots.get(b"foo".as_slice())?;
Some((Arc::as_ptr(&entry.slot) as usize, entry.first.clone()))
}
#[test]
fn at_each_release_a_registrations_key_flags_and_generation_agree() {
let cases = [
("a new key", &[][..], 5, true, false),
("a later load replaces the value", &[5][..], 9, true, true),
("an earlier load moves the key", &[5][..], 3, true, true),
("an equal rank is no change", &[5][..], 5, false, false),
(
"a load between its position and its value",
&[3, 9][..],
5,
false,
true,
),
];
for (by, lazy) in [
(By::Load, false),
(By::Reach, false),
(By::Load, true),
(By::Reach, true),
] {
for (what, before, at, changes, drops) in cases {
let what = format!("{what}, lazy {lazy}");
let env = Environment::new(EnvOptions::unitypy());
env.load(Source::Bytes {
name: RawStr::from("seed"),
data: Bytes::from(serialized(&[], &[Obj::named(1, "s1", &[])])),
})
.unwrap();
let meter = Meter::unlimited();
let name = RawStr::from("foo");
let cab: Cab = env.get_cab(&RawStr::from("seed"), &meter).unwrap().unwrap();
let register = |load: u64, by: By| {
let kind = SlotKind::Ready(cab.clone());
let reg = &env.inner.registry;
reg.insert(&name, kind, Loads::at(load), &[], &meter, by, lazy)
.unwrap();
};
for &load in before {
register(load, By::Load);
}
let reg = &env.inner.registry;
let mut walk = reg.watches().start(&meter, [reg, &env.inner.files]);
let hash = walk.hash(b"foo");
let flag = walk.watch(&[(REGISTRY, hash)]).unwrap();
let (key_before, generation_before) = (foo(&env), reg.generation());
assert_eq!(listed(&env), 0, "{what}: a slot is listed before");
let seen = std::rc::Rc::new(std::cell::Cell::new((0_u32, 0_u32, 0_u32)));
let was_listed = std::rc::Rc::new(std::cell::Cell::new(false));
held::after_each_release(Some(std::rc::Rc::new({
let (env, flag, key_before, seen, was_listed) = (
env.clone(),
flag.clone(),
key_before.clone(),
seen.clone(),
was_listed.clone(),
);
let by_load = by == By::Load;
let what = what.clone();
move || {
let changed = foo(&env) != key_before;
let generation = env.inner.registry.generation();
was_listed.set(was_listed.get() || listed(&env) != 0);
let listed = was_listed.get();
assert_eq!(
flag.changed(),
changed,
"{what}: at a release the key's change and the walks' flag differ (W1)"
);
assert_eq!(
generation != generation_before,
(changed || listed) && by_load,
"{what}: at a release the key's change or the slot's listing and the \
generation differ (P1)"
);
let (releases, with_change, with_listing) = seen.get();
seen.set((
releases + 1,
with_change + u32::from(changed),
with_listing + u32::from(listed),
));
}
})));
register(at, by);
held::after_each_release(None);
let (releases, with_change, with_listing) = seen.get();
assert_ne!(releases, 0, "{what}: no lock was released");
assert_eq!(with_change != 0, changes, "{what}");
assert_eq!(with_listing != 0, drops && lazy, "{what}: the listing");
}
}
}
#[test]
fn a_keys_entry_releases_its_paths_charge_after_the_path() {
heap::count();
let reg = Registry::default();
let meter = Meter::unlimited();
let raw = RawFile::new(
RawStr::from("CAB-K.resS"),
Bytes::from_static(b"raw"),
FileType::ResourceFile,
&meter,
)
.unwrap();
reg.register(&RawStr::from("CAB-K"), Cab::Raw(RawCab::File(raw)), &meter)
.unwrap();
let mut entry = {
let mut inner = reg.write();
let entry = inner.slots.remove(b"cab-k".as_slice()).expect("the key");
inner.order.remove(&entry.first);
entry
};
let (noted_meter, noted) = Noted::meter();
let paid = noted_meter
.charge(Rank::heap(entry.first.path().len()))
.unwrap();
drop(std::mem::replace(&mut entry.first_charge, paid));
let from = noted.releases();
let before = heap::live();
drop(entry);
let after = heap::live();
assert!(before > after, "the drop freed nothing");
heap::released_last(¬ed, from, after, "the path's charge");
}