use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use super::{Dependency, Hook, Open, Slot, open_bare};
use crate::budget::{BudgetExceeded, MemoryBudget, Permit, Reservation};
use crate::container::ContainerPath;
#[cfg(test)]
use crate::env::gate::{Event, Gate, Run};
use crate::env::{Cab, EnvOptions, Environment, LoadMode, Source};
use crate::limits::Meter;
use crate::options::FileContext;
use crate::raw::RawStr;
use bytes::Bytes;
use unityrs_testkit::env::{Obj, bundle, nested_between_loads, nested_dropped_evicted, serialized};
#[derive(Debug, Default)]
struct RefuseNext(AtomicBool);
impl MemoryBudget for RefuseNext {
fn try_reserve(&self, bytes: u64, what: Reservation) -> Result<Permit, BudgetExceeded> {
if what == Reservation::Dependency && self.0.swap(false, Ordering::AcqRel) {
return Err(BudgetExceeded {
requested: bytes,
what,
});
}
Ok(Permit::detached(bytes))
}
}
struct Rig {
env: Environment,
dropped: Arc<Slot>,
other: Bytes,
loads: Arc<AtomicUsize>,
pool: Arc<RefuseNext>,
}
impl Rig {
fn new() -> Self {
let scene = nested_dropped_evicted();
let pool = Arc::new(RefuseNext::default());
let mut ctx = FileContext::unitypy();
ctx.budget = pool.clone();
let mut options = EnvOptions::batch(Arc::new(ctx));
options.dep_cache_bytes = 1;
assert_eq!(options.load, LoadMode::Lazy);
let env = Environment::new(options);
let src = |i: usize| {
let (name, data) = &scene.scene.files[i];
Source::Bytes {
name: RawStr::new(name.clone()),
data: Bytes::from(data.clone()),
}
};
let mut dropped = None;
for i in 0..scene.scene.files.len() {
if scene.dependencies.contains(&i) {
drop(env.load_dependency(src(i)).unwrap());
} else {
drop(env.load(src(i)).unwrap());
}
if i == 1 {
dropped = env.registry().peek("inner");
}
}
let dropped = dropped.expect("a's INNER");
assert!(dropped.unreached(), "the drop was reached at the load");
assert!(
env.registry().evicted_waiting(),
"the drop waits for the pass"
);
let other = Bytes::from(bundle(&[(
"CAB-C",
serialized(&[], &[Obj::named(1, "c1", &[])]),
)]));
Self {
env,
dropped,
other,
loads: Arc::new(AtomicUsize::new(0)),
pool,
}
}
fn check(&self) {
let reg = self.env.registry();
reg.check();
if !self.dropped.unreached() {
assert!(reg.has("cab-d"), "R3: a reached container lacks cab-d");
}
}
fn path_of_f1(&self) -> Option<String> {
let meter = Meter::unlimited();
let Some(Cab::Serialized(sf)) = self.env.get_cab(&RawStr::from("CAB-F"), &meter).unwrap()
else {
panic!("CAB-F");
};
let f1 = sf.objects().find(|o| o.path_id() == 1).expect("f1");
match self.env.container_path(&f1).unwrap() {
Some(ContainerPath::Str(s)) => Some(String::from_utf8_lossy(s.as_bytes()).into()),
Some(ContainerPath::NotAString) => Some("<not a str>".into()),
None => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Op {
Pass,
RefusedPass,
Evict,
GetD,
Keys,
}
const OPS: [Op; 5] = [Op::Pass, Op::RefusedPass, Op::Evict, Op::GetD, Op::Keys];
const POINTS: [Hook; 5] = [
Hook::SettleTook,
Hook::Reached,
Hook::Touching,
Hook::Used,
Hook::Evicting,
];
fn apply(rig: &Rig, op: Op) {
let env = &rig.env;
match op {
Op::Pass => drop(env.container().unwrap().count()),
Op::RefusedPass => {
rig.pool.0.store(true, Ordering::Release);
env.container().unwrap().count();
}
Op::Evict => {
let n = rig.loads.fetch_add(1, Ordering::Relaxed);
let name = format!("c{n}.bundle");
drop(
env.load_dependency(Source::Bytes {
name: RawStr::from(name.as_str()),
data: rig.other.clone(),
})
.unwrap(),
);
}
Op::GetD => drop(
env.get_cab(&RawStr::from("CAB-D"), &Meter::unlimited())
.unwrap(),
),
Op::Keys => drop(env.registry().keys().count()),
}
}
fn after(rig: &Rig, op: Op, listed: &[Arc<Slot>]) {
rig.check();
if matches!(op, Op::Pass | Op::RefusedPass) {
for slot in listed {
assert!(!slot.unreached(), "R4: the pass left a listed slot");
}
assert!(rig.env.registry().has("cab-d"), "the pass missed cab-d");
}
}
fn quiet(rig: &Rig) {
rig.check();
rig.env.container().unwrap().count();
rig.check();
assert!(
rig.env.registry().listed().is_empty(),
"a slot stayed listed"
);
assert!(!rig.dropped.unreached());
assert_eq!(rig.path_of_f1().as_deref(), Some("assets/d.prefab"));
}
#[cfg(test)]
fn start(gate: &Gate, rig: &Arc<Rig>, op: Op, at: Option<Hook>) -> (Run<()>, Vec<Arc<Slot>>) {
let listed = rig.env.registry().listed();
let r = rig.clone();
(gate.run(at.map(|h| (h, 1)), move || apply(&r, op)), listed)
}
#[cfg(test)]
fn finish(rig: &Rig, op: Op, (run, listed): (Run<()>, Vec<Arc<Slot>>)) {
run.finish();
after(rig, op, &listed);
}
#[test]
fn the_pass_reaches_an_evicted_drop_under_every_interleaving() {
let mut cases = 0;
for a in OPS {
for p in POINTS {
for b in OPS {
for q in std::iter::once(None).chain(POINTS.map(Some)) {
for a_first in [true, false] {
if q.is_none() && !a_first {
continue;
}
cases += 1;
let rig = Arc::new(Rig::new());
let gate = Gate::install(&rig.env);
let ra = start(&gate, &rig, a, Some(p));
if ra.0.next() == Event::Stopped {
rig.check();
}
let rb = start(&gate, &rig, b, q);
if q.is_none() {
finish(&rig, b, rb);
finish(&rig, a, ra);
} else {
if rb.0.next() == Event::Stopped {
rig.check();
}
if a_first {
finish(&rig, a, ra);
finish(&rig, b, rb);
} else {
finish(&rig, b, rb);
finish(&rig, a, ra);
}
}
quiet(&rig);
}
}
}
}
}
assert_eq!(cases, 5 * 5 * 5 * 11);
}
#[test]
fn a_pass_whose_reopen_the_pool_refuses_makes_room_and_reaches_the_drop() {
let rig = Rig::new();
let evicted = rig.env.stats().dependencies_evicted;
apply(&rig, Op::RefusedPass);
assert!(!rig.pool.0.load(Ordering::Acquire), "nothing was refused");
assert!(!rig.dropped.unreached(), "the pass left the drop");
assert!(
rig.env.stats().dependencies_evicted > evicted,
"the retry evicted nothing"
);
quiet(&rig);
}
#[test]
fn only_the_pass_reopens_an_evicted_drop() {
let rig = Rig::new();
apply(&rig, Op::GetD);
apply(&rig, Op::Keys);
assert!(rig.dropped.unreached(), "a lookup reopened the dependency");
assert!(rig.env.registry().evicted_waiting());
quiet(&rig);
assert!(!rig.env.registry().evicted_waiting());
}
fn between_keys() -> Vec<String> {
let path = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/d/env.json");
let doc: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(path).expect("env.json")).expect("env.json");
let scene = doc["scenes"]
.as_array()
.expect("scenes")
.iter()
.find(|s| s["name"] == "nested_between_loads")
.expect("the scene is recorded");
let last = scene["steps"]
.as_array()
.expect("steps")
.last()
.expect("a step");
last["cabs"]
.as_array()
.expect("keys")
.iter()
.map(|k| k.as_str().expect("a key").to_owned())
.collect()
}
#[test]
fn a_drop_ranked_between_a_keys_position_and_value_is_reached_by_the_next_pass() {
let scene = nested_between_loads();
let ctx = Arc::new(FileContext::unitypy());
let env = Environment::new(EnvOptions::batch(ctx.clone()));
let src = |i: usize| Source::Bytes {
name: RawStr::new(scene.files[i].0.clone()),
data: Bytes::from(scene.files[i].1.clone()),
};
let reg = env.registry();
drop(env.load(src(0)).unwrap());
let load = reg.next_load();
let name = RawStr::new(scene.files[1].0.clone());
let source = src(1);
let meter = Meter::for_input(&ctx.limits, ctx.budget.clone(), Reservation::Dependency);
let file = open_bare(&name, &source, &meter, &ctx).unwrap();
let dep = Arc::new(Dependency {
name,
source,
open: std::sync::Mutex::new(Open::of(&file, meter.clone())),
ctx: ctx.clone(),
cache: Arc::downgrade(&env.inner.cache),
slots: AtomicUsize::new(0),
#[cfg(feature = "test-counters")]
load_id: crate::counters::LoadId::BARE,
});
reg.register_lazy_dependency(&RawStr::from("e0"), &dep, load, &[0], &meter)
.unwrap();
drop(env.load(src(2)).unwrap());
env.container().unwrap().count();
drop(file);
env.inner.cache.evict_others(None);
assert!(dep.alive().is_none(), "the dependency is still open");
reg.register_lazy_dependency(&RawStr::from("n"), &dep, load, &[1], &meter)
.unwrap();
assert!(reg.evicted_waiting(), "the drop does not wait for the pass");
assert!(
!reg.has("cab-z"),
"the drop was reached at its registration"
);
env.container().unwrap().count();
let keys: Vec<String> = reg
.keys()
.map(|k| String::from_utf8_lossy(k.as_bytes()).into_owned())
.collect();
assert_eq!(keys, between_keys(), "the keys");
let z = reg.peek("cab-z").expect("CAB-Z is registered");
assert!(z.walked(), "CAB-Z's table was not walked");
reg.check();
assert!(!reg.evicted_waiting());
}