use std::sync::Arc;
#[cfg(test)]
use std::sync::Mutex;
use super::pending::List;
use super::{Hook, Registry, Slot};
#[cfg(test)]
use crate::env::gate::{Event, Gate, Run};
use crate::env::{Cab, EnvOptions, Environment, LoadMode, RawCab, Source};
use crate::limits::Meter;
use crate::raw::RawStr;
use bytes::Bytes;
use unityrs_testkit::env::{Obj, bundle, res_bytes, serialized};
use unityrs_testkit::rng::Rng;
impl Registry {
pub(super) fn peek(&self, key: &str) -> Option<Arc<Slot>> {
self.read()
.slots
.get(key.as_bytes())
.map(|e| e.slot.clone())
}
pub(super) fn has(&self, key: &str) -> bool {
self.read().slots.contains_key(key.as_bytes())
}
pub(crate) fn listed(&self) -> Vec<Arc<Slot>> {
let inner = self.read();
inner.pending.all().into_iter().map(|(_, s)| s).collect()
}
pub(crate) fn check(&self) {
let inner = self.read();
assert_eq!(inner.order.len(), inner.slots.len(), "order and table");
for (rank, key) in &inner.order {
let e = inner.slots.get(key.as_bytes()).expect("a key of the order");
assert_eq!(&e.first, rank, "a key's position");
assert!(e.slot.rank >= e.first, "a key's value ranks below it");
}
let listed = inner.pending.all();
assert!(listed.windows(2).all(|w| w[0].0 < w[1].0), "list order");
let len = |l| inner.pending.len(l);
let ordering = std::sync::atomic::Ordering::Acquire;
assert_eq!(
self.pending_len.load(ordering),
len(List::Listed),
"the list's count"
);
assert_eq!(
self.evicted_len.load(ordering),
len(List::Evicted),
"the evicted list's count"
);
}
}
fn cab(name: &str) -> Vec<u8> {
serialized(&[], &[Obj::named(1, name, &[])])
}
#[derive(Clone)]
struct Scene {
o: Bytes,
p: Bytes,
q: Bytes,
r: Bytes,
s: Bytes,
}
impl Scene {
fn new() -> Self {
let inner = bundle(&[("CAB-I", cab("i")), ("CAB-I.resS", res_bytes(8, 1))]);
let x = bundle(&[("CAB-X", cab("x"))]);
let y = bundle(&[("CAB-Y", cab("y"))]);
Self {
o: Bytes::from(bundle(&[("CAB-O", cab("o")), ("INNER", inner)])),
p: Bytes::from(bundle(&[("INNER", cab("p-inner"))])),
q: Bytes::from(bundle(&[("CAB-Q", cab("q")), ("X", x)])),
r: Bytes::from(bundle(&[("X", cab("r-x"))])),
s: Bytes::from(bundle(&[("Y", y)])),
}
}
}
fn src(name: &str, data: &Bytes) -> Source {
Source::Bytes {
name: RawStr::from(name),
data: data.clone(),
}
}
const SUBTREES: [(&str, &[&str]); 3] = [
("inner", &["cab-i", "cab-i.ress"]),
("x", &["cab-x"]),
("y", &["cab-y"]),
];
struct Rig {
scene: Scene,
env: Environment,
containers: Vec<(Arc<Slot>, &'static [&'static str])>,
}
impl Rig {
fn new(scene: &Scene) -> Self {
let mut o = EnvOptions::unitypy();
o.load = LoadMode::Lazy;
let env = Environment::new(o);
for (name, data) in [
("o.bundle", &scene.o),
("q.bundle", &scene.q),
("s.bundle", &scene.s),
] {
env.load(src(name, data)).unwrap();
}
let reg = env.registry();
let containers = SUBTREES
.iter()
.map(|(k, sub)| (reg.peek(k).expect("a container's key"), *sub))
.collect();
Self {
scene: scene.clone(),
env,
containers,
}
}
fn check(&self) {
let reg = self.env.registry();
reg.check();
for (slot, sub) in &self.containers {
if !slot.unreached() {
for k in *sub {
assert!(reg.has(k), "R3: a reached container lacks {k}");
}
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Op {
LoadP,
LoadR,
LoadO2,
GetI,
GetY,
Keys,
Pass,
}
const OPS: [Op; 7] = [
Op::LoadP,
Op::LoadR,
Op::LoadO2,
Op::GetI,
Op::GetY,
Op::Keys,
Op::Pass,
];
fn is_load(op: Op) -> bool {
matches!(op, Op::LoadP | Op::LoadR | Op::LoadO2)
}
fn loaded(scene: &Scene, op: Op) -> (&'static str, &Bytes) {
match op {
Op::LoadP => ("p.bundle", &scene.p),
Op::LoadR => ("r.bundle", &scene.r),
_ => ("o2.bundle", &scene.o),
}
}
const POINTS: [Hook; 4] = [
Hook::Published,
Hook::Deferred,
Hook::SettleTook,
Hook::Reached,
];
fn apply(env: &Environment, scene: &Scene, op: Op) -> Option<bool> {
let meter = Meter::unlimited();
match op {
Op::LoadP | Op::LoadR | Op::LoadO2 => {
let (name, data) = loaded(scene, op);
drop(env.load(src(name, data)).unwrap());
}
Op::GetI => {
let found = env.get_cab(&RawStr::from("CAB-I"), &meter).unwrap();
return Some(found.is_some());
}
Op::GetY => drop(env.get_cab(&RawStr::from("Y"), &meter).unwrap()),
Op::Keys => drop(env.registry().keys().count()),
Op::Pass => drop(env.container().unwrap().count()),
}
None
}
fn after(rig: &Rig, op: Op, listed: &[Arc<Slot>], found: Option<bool>) {
rig.check();
for slot in listed {
assert!(
!slot.unreached(),
"R4: {op:?} returned with a slot listed before it unreached"
);
}
let [inner, x, y] = [0, 1, 2].map(|i| &rig.containers[i].0);
let registered = |sub: &[&str], what: &str| {
let reg = rig.env.registry();
for k in sub {
assert!(reg.has(k), "{what}: {k} is not registered");
}
};
match op {
Op::LoadP => registered(SUBTREES[0].1, "R4: LoadP's own drop"),
Op::LoadR => assert!(!x.unreached(), "R4: LoadR's own drop"),
Op::GetY => assert!(!y.unreached(), "a lookup of Y"),
Op::Pass => {
for (_, sub) in &rig.containers {
registered(sub, "the pass reaches every container");
}
assert!(!x.unreached() && !y.unreached(), "the pass");
}
Op::LoadO2 | Op::GetI | Op::Keys => {}
}
if op == Op::GetI && listed.iter().any(|s| Arc::ptr_eq(s, inner)) {
assert_eq!(found, Some(true), "a lookup after INNER's drop");
}
}
fn answers(env: &Environment, own_key: bool) -> Vec<String> {
let meter = Meter::unlimited();
let names = [
"cab-o",
"cab-i",
"cab-i.ress",
"inner",
"cab-q",
"cab-x",
"x",
"cab-y",
];
names
.iter()
.filter(|n| !(own_key && **n == "inner"))
.map(|n| match env.get_cab(&RawStr::from(*n), &meter).unwrap() {
None => format!("{n}: none"),
Some(Cab::Serialized(sf)) => format!("{n}: {}", sf.name()),
Some(Cab::Raw(RawCab::InBundle { bundle, dir_index })) => {
format!("{n}: raw {}", bundle.directory()[dir_index].path)
}
Some(Cab::Raw(RawCab::File(f))) => format!("{n}: raw {}", f.name),
})
.collect()
}
fn keys(env: &Environment) -> Vec<String> {
env.registry()
.keys()
.map(|k| String::from_utf8_lossy(k.as_bytes()).into_owned())
.filter(|k| !SUBTREES.iter().any(|(c, _)| c == k))
.collect()
}
fn quiet(rig: &Rig, loads: &[Op]) {
rig.check();
rig.env.container().unwrap().count();
rig.check();
assert!(
rig.env.registry().listed().is_empty(),
"a slot stayed listed"
);
let eager = Environment::new(EnvOptions::unitypy());
let scene = &rig.scene;
let mut order = vec![
("o.bundle", &scene.o),
("q.bundle", &scene.q),
("s.bundle", &scene.s),
];
for op in loads {
order.push(loaded(scene, *op));
}
for (name, data) in order {
eager.load(src(name, data)).unwrap();
}
let at = |op| loads.iter().rposition(|o| *o == op);
let own_key = matches!((at(Op::LoadP), at(Op::LoadO2)), (Some(p), Some(o2)) if p < o2);
assert_eq!(
answers(&rig.env, own_key),
answers(&eager, own_key),
"R1: values"
);
assert_eq!(keys(&rig.env), keys(&eager), "R1: positions");
}
#[cfg(test)]
fn start(gate: &Gate, rig: &Rig, op: Op, at: Option<Hook>) -> (Run<Option<bool>>, Vec<Arc<Slot>>) {
let listed = rig.env.registry().listed();
let env = rig.env.clone();
let scene = rig.scene.clone();
let run = gate.run(at.map(|h| (h, 1)), move || apply(&env, &scene, op));
(run, listed)
}
#[cfg(test)]
fn finish(rig: &Rig, op: Op, (run, listed): (Run<Option<bool>>, Vec<Arc<Slot>>)) {
let found = run.finish();
after(rig, op, &listed, found);
}
#[test]
fn reach_and_settle_keep_their_invariants_under_every_interleaving() {
let scene = Scene::new();
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 = Rig::new(&scene);
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);
}
}
let loads: Vec<Op> = [a, b].into_iter().filter(|o| is_load(*o)).collect();
quiet(&rig, &loads);
}
}
}
}
}
assert_eq!(cases, 7 * 4 * 7 * 9);
}
#[test]
fn a_load_returns_with_its_drop_reached_while_another_settle_holds_it() {
let scene = Scene::new();
let rig = Rig::new(&scene);
let gate = Gate::install(&rig.env);
let load = start(&gate, &rig, Op::LoadP, Some(Hook::Deferred));
load.0.stopped();
let get = start(&gate, &rig, Op::GetI, Some(Hook::SettleTook));
get.0.stopped();
finish(&rig, Op::LoadP, load);
let inner = &rig.containers[0].0;
assert!(!inner.unreached(), "the load returned with INNER unreached");
let found = rig
.env
.get_cab(&RawStr::from("CAB-I"), &Meter::unlimited())
.unwrap();
assert!(found.is_some(), "a lookup right after the load");
finish(&rig, Op::GetI, get);
quiet(&rig, &[Op::LoadP]);
}
#[test]
fn a_reach_that_learns_a_lower_position_registers_there() {
let inner = bundle(&[("CAB-I", cab("i")), ("CAB-I.resS", res_bytes(8, 1))]);
let o = Bytes::from(bundle(&[
("CAB-O", cab("o")),
("INNER", inner),
("CAB-Z", cab("z")),
]));
for at in [Some((Hook::Published, 2)), Some((Hook::Reached, 1)), None] {
let mut options = EnvOptions::unitypy();
options.load = LoadMode::Lazy;
let env = Environment::new(options);
let gate = Gate::install(&env);
let load = |name: &'static str, at: Option<(Hook, usize)>| {
let (env, data) = (env.clone(), o.clone());
gate.run(at, move || drop(env.load(src(name, &data)).unwrap()))
};
let first = load("o.bundle", Some((Hook::Published, 1)));
first.stopped();
load("o2.bundle", None).finish();
let standing = env.registry().peek("inner").expect("INNER");
assert_eq!(standing.position(), standing.rank.load);
let get = {
let env = env.clone();
gate.run(at, move || {
let meter = Meter::unlimited();
drop(env.get_cab(&RawStr::from("INNER"), &meter).unwrap());
})
};
let what = format!("the reach stopped at {at:?}");
if at.is_none() {
get.finish();
first.finish();
} else {
get.stopped();
assert!(env.registry().has("cab-i.ress"), "{what}: it registered");
first.finish();
let lowered = standing.position() < standing.rank.load;
assert_eq!(lowered, at == Some((Hook::Published, 2)), "{what}");
assert!(env.registry().listed().is_empty(), "{what}");
assert!(standing.unreached(), "{what}: the reach is stopped");
get.finish();
}
assert!(!standing.unreached(), "{what}");
env.registry().check();
assert!(env.registry().listed().is_empty());
let eager = Environment::new(EnvOptions::unitypy());
for name in ["o.bundle", "o2.bundle"] {
eager.load(src(name, &o)).unwrap();
}
assert_eq!(answers(&env, false), answers(&eager, false), "{what}");
assert_eq!(keys(&env), keys(&eager), "{what}: the positions");
}
}
#[allow(clippy::type_complexity)]
fn raced_spans_oracle() -> (Vec<Option<String>>, Vec<((String, i64), Option<String>)>) {
let path = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/d/env.json");
let text = std::fs::read_to_string(path).expect("env.json");
let doc: serde_json::Value = serde_json::from_str(&text).expect("env.json");
let scene = doc["scenes"]
.as_array()
.expect("scenes")
.iter()
.find(|s| s["name"] == "nested_reloaded_spans_raced")
.expect("the scene is recorded");
let step = |op: &str| {
scene["steps"]
.as_array()
.expect("steps")
.iter()
.find(|s| s["op"][0] == op)
.expect("a recorded step")
};
let text = |v: &serde_json::Value| v.as_str().map(str::to_owned);
let rows = step("container")["result"]
.as_array()
.expect("rows")
.iter()
.map(|r| text(&r[0]))
.collect();
let paths = step("paths");
let objects = paths["objects"].as_array().expect("objects");
let mut last: Vec<((String, i64), Option<String>)> = Vec::new();
for (o, p) in objects
.iter()
.zip(paths["result"].as_array().expect("paths"))
{
let at = (
o[0].as_str().expect("a CAB").to_owned(),
o[1].as_i64().expect("a path id"),
);
last.retain(|(k, _)| *k != at);
last.push((at, text(p)));
}
(rows, last)
}
#[allow(clippy::type_complexity)]
fn raced_spans_answers(
env: &Environment,
objects: &[((String, i64), Option<String>)],
) -> (Vec<Option<String>>, Vec<((String, i64), Option<String>)>) {
use crate::container::ContainerPath;
let text = |b: &[u8]| String::from_utf8_lossy(b).into_owned();
let rows = env
.container()
.expect("the container")
.map(|i| i.expect("a row").row.path.map(|p| text(p.as_bytes())))
.collect();
let meter = Meter::unlimited();
let paths = objects
.iter()
.map(|((cab, id), _)| {
let Some(Cab::Serialized(sf)) =
env.get_cab(&RawStr::from(cab.as_str()), &meter).unwrap()
else {
panic!("{cab} is a SerializedFile");
};
let obj = sf
.objects()
.find(|o| o.path_id() == *id)
.expect("the object");
let path = match env.container_path(&obj).expect("a path") {
None => None,
Some(ContainerPath::Str(s)) => Some(text(s.as_bytes())),
Some(ContainerPath::NotAString) => Some("<not a str>".into()),
};
((cab.clone(), *id), path)
})
.collect();
(rows, paths)
}
const RACE_POINTS: [(Hook, usize); 4] = [
(Hook::Published, 1),
(Hook::Published, 2),
(Hook::Reached, 1),
(Hook::SettleTook, 1),
];
#[test]
fn no_pass_walks_a_reached_slot_whose_entries_can_still_move() {
let scene = unityrs_testkit::env::nested_reloaded_spans_raced();
let data = Bytes::from(scene.files[0].1.clone());
let (rows, paths) = raced_spans_oracle();
let mut cases = 0;
for pass_reaches in [false, true] {
for first in RACE_POINTS {
for second in std::iter::once(None).chain(RACE_POINTS.map(Some)) {
cases += 1;
let mut options = EnvOptions::unitypy();
options.load = LoadMode::Lazy;
let env = Environment::new(options);
let gate = Gate::install(&env);
let load = {
let (env, data) = (env.clone(), data.clone());
gate.run(Some((Hook::Published, 1)), move || {
drop(env.load(src("o.bundle", &data)).unwrap());
})
};
load.stopped();
drop(env.load(src("o2.bundle", &data)).unwrap());
let reach = {
let env = env.clone();
let stops = std::iter::once(first).chain(second).collect();
gate.run_stops(stops, move || {
if pass_reaches {
env.container().unwrap().count();
} else {
let meter = Meter::unlimited();
drop(env.get_cab(&RawStr::from("INNER"), &meter).unwrap());
}
})
};
let what = format!("pass {pass_reaches}, {first:?} then {second:?}");
if reach.next() == Event::Stopped {
load.finish();
reach.release();
if reach.next() == Event::Stopped {
env.container().unwrap().count();
}
} else {
load.finish();
}
reach.finish();
let got = raced_spans_answers(&env, &paths);
assert_eq!(got.0, rows, "{what}: the rows");
assert_eq!(got.1, paths, "{what}: the paths");
env.registry().check();
assert!(env.registry().listed().is_empty(), "{what}");
}
}
}
assert_eq!(cases, 2 * 4 * 5);
}
#[test]
fn every_load_and_the_key_listing_reach_what_is_listed() {
let scene = Scene::new();
let other = Bytes::from(bundle(&[("CAB-C", cab("c"))]));
for by_keys in [true, false] {
let rig = Rig::new(&scene);
let reg = rig.env.registry();
let y = rig.containers[2].0.clone();
{
let mut inner = reg.write();
inner.pending.push(y.clone());
reg.store_lens(&inner.pending);
}
if by_keys {
let _ = reg.keys().count();
} else {
drop(rig.env.load(src("c.bundle", &other)).unwrap());
}
assert!(!y.unreached(), "keys {by_keys}: Y was not reached");
assert!(reg.has("cab-y"), "keys {by_keys}");
assert!(reg.listed().is_empty(), "keys {by_keys}");
rig.check();
}
}
#[cfg(test)]
fn plain<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
#[cfg(test)]
#[test]
fn reach_and_settle_keep_their_invariants_under_a_random_stress() {
let scene = Scene::new();
for seed in 0..24_u64 {
let rig = Arc::new(Rig::new(&scene));
let loads = Arc::new(Mutex::new(Vec::new()));
let threads: Vec<_> = (0..4_u64)
.map(|t| {
let rig = rig.clone();
let loads = loads.clone();
std::thread::spawn(move || {
let mut rng = Rng::new(seed * 16 + t);
for _ in 0..12 {
let op = OPS[rng.below(OPS.len())];
let listed = rig.env.registry().listed();
let found = if is_load(op) {
let mut order = plain(&loads);
let found = apply(&rig.env, &rig.scene, op);
order.push(op);
found
} else {
apply(&rig.env, &rig.scene, op)
};
after(&rig, op, &listed, found);
}
})
})
.collect();
for t in threads {
t.join().unwrap();
}
let order = plain(&loads).clone();
quiet(&rig, &order);
}
}