use crate::Resources;
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use super::{
AsyncResource, DeclaredResource, ResourceCatalog, ResourceDemand, ResourceName, ResourceSource,
ResourceVisitor,
};
static BUILDS: AtomicUsize = AtomicUsize::new(0);
#[derive(Debug)]
struct Egemma {
dim: usize,
}
impl AsyncResource for Egemma {
type Options = usize;
type Error = core::convert::Infallible;
async fn build(_ctx: &Resources, dim: usize) -> Result<Self, Self::Error> {
BUILDS.fetch_add(1, Ordering::Relaxed);
Ok(Self { dim })
}
}
impl DeclaredResource for Egemma {}
#[derive(Debug)]
struct Whisper;
#[derive(Debug, derive_more::Display)]
#[display("no such checkpoint: {_0}")]
struct MissingCheckpoint(String);
impl core::error::Error for MissingCheckpoint {}
impl AsyncResource for Whisper {
type Options = String;
type Error = MissingCheckpoint;
async fn build(_ctx: &Resources, path: String) -> Result<Self, Self::Error> {
if path.is_empty() {
return Err(MissingCheckpoint(path));
}
Ok(Self)
}
}
impl DeclaredResource for Whisper {}
struct Undeclared;
impl AsyncResource for Undeclared {
type Options = ();
type Error = core::convert::Infallible;
async fn build(_ctx: &Resources, (): ()) -> Result<Self, Self::Error> {
Ok(Self)
}
}
fn ready<F: core::future::Future>(future: F) -> F::Output {
tokio::runtime::Builder::new_current_thread()
.build()
.expect("a current-thread runtime")
.block_on(future)
}
#[test]
fn one_build_and_the_handle_is_what_travels() {
let before = BUILDS.load(Ordering::Relaxed);
let shared =
ready(super::Shared::<Egemma>::build(&Resources::new(), 768)).expect("the model loads");
assert_eq!(BUILDS.load(Ordering::Relaxed), before + 1);
let members: Vec<_> = (0..4).map(|_| shared.clone()).collect();
assert_eq!(BUILDS.load(Ordering::Relaxed), before + 1);
assert_eq!(shared.holders(), 5);
for member in &members {
assert_eq!(member.dim, 768);
assert!(core::ptr::eq(member.get(), shared.get()));
}
drop(members);
assert_eq!(shared.holders(), 1);
}
#[test]
fn a_refused_construction_reports_in_the_authors_own_currency() {
let refused = ready(super::Shared::<Whisper>::build(
&Resources::new(),
String::new(),
))
.expect_err("an empty checkpoint path");
assert_eq!(refused.to_string(), "no such checkpoint: ");
assert!(
ready(super::Shared::<Whisper>::build(
&Resources::new(),
"base.en".to_owned()
))
.is_ok()
);
}
#[test]
fn a_handle_derefs_to_the_resource_and_borrows_it_three_ways() {
let shared = super::Shared::new(Egemma { dim: 384 });
assert_eq!(shared.dim, 384);
assert_eq!(shared.get().dim, 384);
assert_eq!(AsRef::<Egemma>::as_ref(&shared).dim, 384);
}
#[test]
fn a_handles_debug_names_the_resource_rather_than_dumping_it() {
let shared = super::Shared::new(Egemma { dim: 8 });
let rendered = format!("{shared:?}");
assert!(rendered.contains("Shared"), "{rendered}");
assert!(rendered.contains("Egemma"), "{rendered}");
assert!(rendered.contains("holders"), "{rendered}");
}
#[test]
fn a_handle_crosses_threads_because_the_supertraits_say_it_does() {
fn shareable<T: Send + Sync>(_: &T) {}
let shared = super::Shared::new(Egemma { dim: 1 });
shareable(&shared);
let second = shared.clone();
let elsewhere = std::thread::spawn(move || second.dim);
assert_eq!(elsewhere.join().expect("the thread"), 1);
}
#[test]
fn a_resource_name_is_the_compilers_own_path_and_both_sides_derive_it_once() {
let declared = <Egemma as DeclaredResource>::resource();
let demanded = ResourceDemand::of::<Egemma>().resource();
assert_eq!(declared, demanded);
assert!(
declared.as_str().ends_with("Egemma"),
"{}",
declared.as_str()
);
assert_ne!(declared, <Whisper as DeclaredResource>::resource());
assert_eq!(ResourceName::of::<Egemma>(), declared);
assert_eq!(
ResourceDemand::of::<Egemma>().to_string(),
declared.as_str()
);
}
#[test]
fn a_resource_name_views_a_str_and_keys_a_map_as_one() {
use std::collections::HashMap;
let mut held: HashMap<&ResourceName, usize> = HashMap::new();
held.insert(ResourceName::new("egemma"), 3);
assert_eq!(held.get(ResourceName::new("egemma")), Some(&3));
assert_eq!(ResourceName::new("egemma").as_str(), "egemma");
}
#[test]
fn the_walk_collects_citizens_and_answers_about_them_by_name() {
let mut declared = ResourceCatalog::new();
assert!(declared.is_empty());
declared
.next_resource::<Egemma>("egemma", ResourceSource::Section)
.expect("infallible");
declared
.next_resource::<Whisper>("whisper", ResourceSource::Prepare)
.expect("infallible");
declared
.next_resource::<Egemma>("egemma", ResourceSource::Section)
.expect("infallible");
assert_eq!(declared.len(), 2);
assert!(declared.declares(<Egemma as DeclaredResource>::resource()));
assert!(declared.declares(<Whisper as DeclaredResource>::resource()));
assert!(!declared.declares(ResourceDemand::of::<Undeclared>().resource()));
assert_eq!(declared.names().count(), 2);
}
#[test]
fn the_hand_written_door_and_the_walk_agree() {
let mut walked = ResourceCatalog::new();
walked
.next_resource::<Egemma>("egemma", ResourceSource::Section)
.expect("infallible");
assert_eq!(
walked,
ResourceCatalog::new().with::<Egemma>("egemma", ResourceSource::Section)
);
}
#[test]
fn a_demand_is_recordable_for_a_resource_nobody_declared() {
let demand = ResourceDemand::of::<Undeclared>();
assert!(demand.resource().as_str().ends_with("Undeclared"));
assert!(
!ResourceCatalog::new()
.with::<Egemma>("egemma", ResourceSource::Section)
.declares(demand.resource())
);
}
#[test]
fn several_units_hold_one_model_and_the_framework_never_locks_it() {
let shared = super::Shared::new(Egemma { dim: 1024 });
let seen = Arc::new(AtomicUsize::new(0));
let mut units = Vec::new();
for _ in 0..4 {
let held = shared.clone();
let seen = Arc::clone(&seen);
units.push(std::thread::spawn(move || {
seen.fetch_add(held.dim, Ordering::Relaxed);
}));
}
for unit in units {
unit.join().expect("a unit thread");
}
assert_eq!(seen.load(Ordering::Relaxed), 4 * 1024);
assert_eq!(shared.holders(), 1);
}