use std::sync::Mutex;
use sha2::{Digest, Sha256};
use crate::economy::{CentralBankState, EconomyState};
use crate::engine::Engine;
use crate::market::TickCompany;
use crate::params::ModelParams;
pub const DEFAULT_CAPACITY: usize = 16;
pub const NAME_BUDGET: usize = 2000;
pub(crate) type Key = [u8; 32];
struct Cache {
capacity: usize,
budget: usize,
entries: Vec<(Key, Engine)>,
hits: u64,
misses: u64,
}
impl Cache {
const fn new(capacity: usize, budget: usize) -> Self {
Cache { capacity, budget, entries: Vec::new(), hits: 0, misses: 0 }
}
fn get(&mut self, key: &Key) -> Option<Engine> {
if self.capacity == 0 {
return None;
}
match self.entries.iter().position(|(k, _)| k == key) {
Some(at) => {
let entry = self.entries.remove(at);
let engine = entry.1.clone();
self.entries.push(entry);
self.hits += 1;
#[cfg(test)]
HITS.with(|n| n.set(n.get() + 1));
Some(engine)
}
None => {
self.misses += 1;
None
}
}
}
fn put(&mut self, key: Key, engine: &Engine) {
if self.capacity == 0 || engine.companies().len() > self.budget {
return;
}
self.entries.retain(|(k, _)| *k != key);
self.entries.push((key, engine.clone()));
self.trim();
}
fn set_capacity(&mut self, capacity: usize) {
self.capacity = capacity;
self.trim();
}
fn names(&self) -> usize {
self.entries.iter().map(|(_, e)| e.companies().len()).sum()
}
fn trim(&mut self) {
while self.entries.len() > self.capacity || self.names() > self.budget {
self.entries.remove(0);
}
}
fn info(&self) -> OpeningCacheInfo {
OpeningCacheInfo {
capacity: self.capacity,
entries: self.entries.len(),
names: self.names(),
hits: self.hits,
misses: self.misses,
}
}
}
static CACHE: Mutex<Cache> = Mutex::new(Cache::new(DEFAULT_CAPACITY, NAME_BUDGET));
fn cache() -> std::sync::MutexGuard<'static, Cache> {
CACHE.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct OpeningCacheInfo {
pub capacity: usize,
pub entries: usize,
pub names: usize,
pub hits: u64,
pub misses: u64,
}
pub(crate) fn on() -> bool {
cache().capacity > 0
}
pub(crate) fn key(
seed: u64,
companies: &[TickCompany],
economy: &EconomyState,
central_bank: &CentralBankState,
sector_keys: &[String],
params: &ModelParams,
settle_opening: bool,
) -> Option<Key> {
if companies.len() > NAME_BUDGET {
return None;
}
let text = format!(
"{seed:?}|{companies:?}|{economy:?}|{central_bank:?}|{sector_keys:?}|{params:?}|{settle_opening:?}"
);
if text.contains("NaN") {
return None;
}
Some(Sha256::digest(text.as_bytes()).into())
}
pub(crate) fn get(key: &Key) -> Option<Engine> {
cache().get(key)
}
pub(crate) fn put(key: Key, engine: &Engine) {
cache().put(key, engine);
}
pub(crate) fn set_capacity(capacity: usize) {
cache().set_capacity(capacity);
}
pub(crate) fn info() -> OpeningCacheInfo {
cache().info()
}
#[cfg(test)]
thread_local! {
static HITS: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
}
#[cfg(test)]
pub(crate) fn hits_here() -> u64 {
HITS.with(|n| n.get())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::economy::{create_initial_central_bank_state, create_initial_economy_state};
use crate::engine::{SessionBuffer, SessionRequest};
fn roster(names: usize, seed: u64) -> Vec<TickCompany> {
crate::universe::random_universe(names, seed)
.iter()
.enumerate()
.map(|(i, g)| g.to_init().to_tick_company(i))
.collect()
}
fn sector_keys() -> Vec<String> {
crate::sectors::keys().iter().map(|s| s.to_string()).collect()
}
fn short_prehistory() -> ModelParams {
crate::params::PT_V21.with_override("market_prehistory_sessions", 21.0).unwrap()
}
fn build(seed: u64, companies: Vec<TickCompany>, params: ModelParams) -> Engine {
Engine::with_params(
seed, companies, create_initial_economy_state(&Default::default()),
create_initial_central_bank_state(0), sector_keys(), params,
)
}
fn key_of(seed: u64, companies: &[TickCompany], params: &ModelParams) -> Option<Key> {
key(seed, companies, &create_initial_economy_state(&Default::default()),
&create_initial_central_bank_state(0), §or_keys(), params, true)
}
fn run_day(e: &mut Engine, day: i64, buffer: &mut SessionBuffer) {
e.open_market();
let bell = crate::market::GameTime::new(9, 30, 3);
e.run_session(&SessionRequest::new(bell, 390), buffer);
e.close_day(day);
}
#[test]
fn a_cached_build_is_the_cold_build_to_the_bit() {
for (seed, params) in [(90_101, short_prehistory()), (90_102, crate::params::PT_V21)] {
let companies = roster(4, seed);
let mut cold = Engine::build_from_opening(
seed, companies.clone(), create_initial_economy_state(&Default::default()),
create_initial_central_bank_state(0), sector_keys(), params.clone(), true,
);
let mut served = None;
for _ in 0..4 {
let before = hits_here();
let e = build(seed, companies.clone(), params.clone());
if hits_here() > before {
served = Some(e);
break;
}
}
let mut served = served.expect("no build was served from the cache");
assert_eq!(served.state_hash(0, false), cold.state_hash(0, false));
assert_eq!(served.rng_state(), cold.rng_state());
assert_eq!(served.draws_consumed(), cold.draws_consumed());
assert_eq!(served.opening_settled(), cold.opening_settled());
assert_eq!(served.opening_carry().len(), cold.opening_carry().len());
for (a, b) in served.opening_carry().iter().zip(cold.opening_carry()) {
assert_eq!(a.to_bits(), b.to_bits());
}
let mut buffer = SessionBuffer::new();
for day in 1..=5u32 {
run_day(&mut served, i64::from(day), &mut buffer);
run_day(&mut cold, i64::from(day), &mut buffer);
assert_eq!(served.state_hash(day, false), cold.state_hash(day, false), "day {day}");
assert_eq!(served.draws_consumed(), cold.draws_consumed(), "day {day}");
}
}
}
#[test]
fn the_key_reads_every_argument_to_the_bit() {
let companies = roster(3, 5);
let params = short_prehistory();
let base = key_of(7, &companies, ¶ms).unwrap();
assert_eq!(key_of(7, &companies, ¶ms), Some(base), "a key is a function");
assert_ne!(key_of(8, &companies, ¶ms), Some(base));
let mut nudged = companies.clone();
let p = nudged[2].stock.price;
nudged[2].stock.price = f64::from_bits(p.to_bits() + 1);
assert_ne!(key_of(7, &nudged, ¶ms), Some(base), "one ulp of one price");
let mut renamed = companies.clone();
renamed[0].ticker.push('X');
assert_ne!(key_of(7, &renamed, ¶ms), Some(base));
let mut swapped = companies.clone();
swapped.swap(0, 1);
assert_ne!(key_of(7, &swapped, ¶ms), Some(base), "the roster's order");
let off = crate::params::DIGEST_SILENT_AT_ZERO
.iter()
.find(|name| params.get(name).map(f64::to_bits) == Some(0))
.expect("pt-v21 leaves a silent switch off");
let signed = params.with_override(off, -0.0).unwrap();
assert_eq!(signed.get(off).map(f64::to_bits), Some((-0.0f64).to_bits()), "{off}");
assert_eq!(signed.fingerprint(), params.fingerprint(), "the digest is silent on {off}");
assert_ne!(key_of(7, &companies, &signed), Some(base), "the sign of a zero");
let econ = create_initial_economy_state(&Default::default());
let bank = create_initial_central_bank_state(0);
let keys = sector_keys();
let k = |econ: &EconomyState, bank: &CentralBankState, keys: &[String], settle: bool| {
key(7, &companies, econ, bank, keys, ¶ms, settle)
};
assert_eq!(k(&econ, &bank, &keys, true), Some(base));
let mut e2 = econ.clone();
e2.vix = f64::from_bits(e2.vix.to_bits() + 1);
assert_ne!(k(&e2, &bank, &keys, true), Some(base));
assert_ne!(k(&econ, &create_initial_central_bank_state(1), &keys, true), Some(base));
let mut reordered = keys.clone();
reordered.swap(0, 1);
assert_ne!(k(&econ, &bank, &reordered, true), Some(base));
assert_ne!(k(&econ, &bank, &keys, false), Some(base));
}
#[test]
fn a_nan_or_a_large_roster_is_never_keyed() {
let params = short_prehistory();
let mut companies = roster(3, 5);
companies[1].stock.short_interest = f64::NAN;
assert_eq!(key_of(7, &companies, ¶ms), None);
let big = roster(NAME_BUDGET + 1, 5);
assert_eq!(key_of(7, &big, ¶ms), None);
assert!(key_of(7, &big[..NAME_BUDGET], ¶ms).is_some());
}
#[test]
fn the_least_recently_used_engine_leaves_first() {
let p = crate::params::PT_V20;
let engines: Vec<Engine> = (0..3u64)
.map(|s| Engine::with_params_keeping_opening(
s, roster(2, 1), create_initial_economy_state(&Default::default()),
create_initial_central_bank_state(0), sector_keys(), p.clone()))
.collect();
let keys: Vec<Key> = (0..3u8).map(|i| [i; 32]).collect();
let mut cache = Cache::new(2, NAME_BUDGET);
assert!(cache.get(&keys[0]).is_none());
cache.put(keys[0], &engines[0]);
cache.put(keys[1], &engines[1]);
let a = cache.get(&keys[0]).expect("kept");
assert_eq!(a.state_hash(0, false), engines[0].state_hash(0, false));
cache.put(keys[2], &engines[2]);
assert!(cache.get(&keys[1]).is_none(), "1 was the least recently used");
assert!(cache.get(&keys[0]).is_some());
assert!(cache.get(&keys[2]).is_some());
let info = cache.info();
assert_eq!((info.capacity, info.entries, info.names), (2, 2, 4));
assert_eq!((info.hits, info.misses), (3, 2));
cache.put(keys[2], &engines[2]);
assert_eq!(cache.info().entries, 2, "a key is kept once");
cache.set_capacity(0);
assert_eq!(cache.info().entries, 0);
cache.put(keys[0], &engines[0]);
assert!(cache.get(&keys[0]).is_none());
assert_eq!(cache.info().misses, 2, "an off cache counts nothing");
}
#[test]
fn the_name_budget_holds_across_the_kept_engines() {
let p = crate::params::PT_V20;
let build = |s: u64, names: usize| Engine::with_params_keeping_opening(
s, roster(names, 1), create_initial_economy_state(&Default::default()),
create_initial_central_bank_state(0), sector_keys(), p.clone());
let mut cache = Cache::new(16, 5);
for i in 0..4u8 {
cache.put([i; 32], &build(u64::from(i), 2));
}
let info = cache.info();
assert_eq!((info.entries, info.names), (2, 4));
assert!(cache.get(&[3; 32]).is_some() && cache.get(&[2; 32]).is_some());
assert!(cache.get(&[1; 32]).is_none());
cache.put([9; 32], &build(9, 6));
assert!(cache.get(&[9; 32]).is_none(), "over the budget on its own");
assert_eq!(cache.info().entries, 2);
}
}