diff --git a/airdef-mod/src/sim/ew.rs b/airdef-mod/src/sim/ew.rs index c22b818..a9fb61f 100644 --- a/airdef-mod/src/sim/ew.rs +++ b/airdef-mod/src/sim/ew.rs @@ -151,6 +151,11 @@ pub(super) struct KnownRelief { } impl KnownRelief { + /// What the relief holds, about (see `sim::memory`). + pub(super) fn bytes(&self) -> usize { + use super::memory::vec_bytes; + vec_bytes(&self.heights) + } pub(super) fn new(grid: raid::Grid, heights: Vec) -> Self { Self { grid, heights } } @@ -401,6 +406,11 @@ pub(super) struct KnowledgeSnapshot { } impl KnowledgeSnapshot { + /// What the snapshot holds, about (see `sim::memory`); shared `Arc`s are counted per holder. + pub(super) fn bytes(&self) -> usize { + use super::memory::vec_bytes; + vec_bytes(&self.contacts) + vec_bytes(&self.marks) + } pub(super) fn new(tick: u64, contacts: Vec, marks: Vec) -> Self { Self { tick, contacts, marks } } @@ -506,6 +516,12 @@ pub(super) struct Intel { } impl Intel { + /// What the enemy's memory holds, about (see `sim::memory`). + pub(super) fn bytes(&self) -> usize { + use super::memory::{btree_bytes, vecdeque_bytes}; + btree_bytes(self.contacts.len(), std::mem::size_of::() + std::mem::size_of::()) + + vecdeque_bytes(&self.outcomes) + } /// The picture as a save writes it, and back: the contacts (one per unit) and the sector scores. pub(super) fn contacts(&self) -> &BTreeMap { &self.contacts diff --git a/airdef-mod/src/sim/fires.rs b/airdef-mod/src/sim/fires.rs index 3ccc65b..bfd5dd0 100644 --- a/airdef-mod/src/sim/fires.rs +++ b/airdef-mod/src/sim/fires.rs @@ -67,6 +67,13 @@ pub fn level(age: f64, life: f64) -> (f32, f32) { } impl Fires { + /// What the fires hold, about (see `sim::memory`). + pub(super) fn bytes(&self) -> usize { + use super::memory::vec_bytes; + vec_bytes(&self.list) + + self.list.iter().map(|f| vec_bytes(&f.blocks)).sum::() + + self.cleanup.iter().map(|s| s.capacity()).sum::() + } /// Fires burning now. pub fn len(&self) -> usize { self.list.len() diff --git a/airdef-mod/src/sim/memory.rs b/airdef-mod/src/sim/memory.rs new file mode 100644 index 0000000..b409141 --- /dev/null +++ b/airdef-mod/src/sim/memory.rs @@ -0,0 +1,178 @@ +//! Where the mod's memory goes: an estimate of what each consumer holds, for the budget +//! tests and the diagnostics. The whole mod lives in one 64 MiB WASM linear memory +//! (`horizon-mods` runtime `MEMORY`): the simulation, the ground and block caches, the +//! recordings and the enemy's memory all share it, and a hashbrown rehash briefly holds +//! the old and the new table at once. The estimates count allocated capacity, not len, +//! and the tables' control bytes; they are a lower bound on the allocator's footprint +//! (fragmentation and the transient query/answer vectors come on top). +use super::*; + +/// A hashbrown table's allocation for `len` entries of `entry` bytes (key + value): +/// the capacity grows 3, 7, 14, 28, … at a 7/8 load, and the allocation is +/// `(capacity + group) * (entry + 1)` (one control byte per slot). +pub(super) fn map_bytes(len: usize, entry: usize) -> usize { + if len == 0 { + return 0; + } + let mut cap = 3usize; + while cap * 7 / 8 < len { + cap = if cap == 3 { 7 } else { cap * 2 }; + } + (cap + 16) * (entry + 1) +} + +/// A `BTreeMap`'s nodes, about: the entry plus the node's share of pointers and slack. +pub(super) fn btree_bytes(len: usize, entry: usize) -> usize { + len * (entry + 32) +} + +pub(super) fn vec_bytes(v: &Vec) -> usize { + v.capacity() * std::mem::size_of::() +} + +pub(super) fn vecdeque_bytes(v: &std::collections::VecDeque) -> usize { + v.capacity() * std::mem::size_of::() +} + +/// What each consumer holds, in bytes (estimated allocated capacity). +#[derive(Clone, Copy, Default, Debug)] +pub struct MemoryReport { + /// `Ground::known`: the answered land heights by column. + pub ground_known: usize, + /// The ground's other bookkeeping: loading, questions waiting, chunks wanted. + pub ground_other: usize, + /// `WorldCache::secs`: the block sections, table and the mixed ones' bits. + pub world_sections: usize, + /// The block cache's other bookkeeping: exact rays, queues, questions, blasts expected. + pub world_other: usize, + /// The simulation's vectors: drones (and their routes), missiles, systems, objects, + /// effects, blasts, the launch queue and the rest of the live state. + pub units: usize, + /// The radars' tracks and horizons. + pub tracks: usize, + /// The recording in progress. + pub recording: usize, + /// The replays kept. + pub replays: usize, + /// The enemy's memory of the layout (contacts and outcomes). + pub intel: usize, + /// The recon memory (sorties, marks, checked zones). + pub recon: usize, + /// The vehicles' ground routes and their searches. + pub routes: usize, + /// The raid's launch sites. + pub sites: usize, + /// The counter-strikes on the sites. + pub strikes: usize, + /// The raid being planned (its grid, prices, routes, knowledge) and the retarget jobs. + pub plan: usize, + /// The rest: fires, flares, roles, tallies, the smart refresh. + pub other: usize, +} + +impl MemoryReport { + pub fn total(&self) -> usize { + self.ground_known + + self.ground_other + + self.world_sections + + self.world_other + + self.units + + self.tracks + + self.recording + + self.replays + + self.intel + + self.recon + + self.routes + + self.sites + + self.strikes + + self.plan + + self.other + } + + /// The largest table a rehash could double while the old one is still held: the + /// transient peak is the total plus twice this (old + new − steady). + pub fn rehash_headroom(&self) -> usize { + 2 * self.ground_known.max(self.world_sections) + } + + /// One line per consumer, biggest first: the budget report's shape. + pub fn text(&self) -> String { + let mut rows = [ + ("ground.known", self.ground_known), + ("ground.other", self.ground_other), + ("world.secs", self.world_sections), + ("world.other", self.world_other), + ("sim.units", self.units), + ("sim.tracks", self.tracks), + ("recording", self.recording), + ("replays", self.replays), + ("intel", self.intel), + ("recon", self.recon), + ("routes", self.routes), + ("sites", self.sites), + ("strikes", self.strikes), + ("plan", self.plan), + ("other", self.other), + ]; + rows.sort_by(|a, b| b.1.cmp(&a.1)); + let mut out = format!("total {:.2} MiB (+{:.2} MiB rehash transient)", self.total() as f64 / (1024.0 * 1024.0), self.rehash_headroom() as f64 / (1024.0 * 1024.0)); + for (name, bytes) in rows { + if bytes > 0 { + out.push_str(&format!("\n {name}: {:.2} MiB", bytes as f64 / (1024.0 * 1024.0))); + } + } + out + } +} + +impl Sim { + /// What the simulation and the ground cache hold, about: the budget tests measure it + /// under load, and the diagnostics can show where the memory went. + pub fn memory(&self, ground: &Ground) -> MemoryReport { + let mut r = MemoryReport::default(); + r.ground_known = map_bytes(ground.known.len(), std::mem::size_of::<(i32, i32)>() + std::mem::size_of::<(i32, u64)>()); + r.ground_other = map_bytes(ground.loading.len(), std::mem::size_of::<(i32, i32)>() + std::mem::size_of::()) + + vec_bytes(&ground.wanted) + + map_bytes(ground.asked.len(), std::mem::size_of::<(i32, i32)>()) + + vec_bytes(&ground.chunks); + let (sections, other) = ground.world.memory(); + r.world_sections = sections; + r.world_other = other; + + r.units = vec_bytes(&self.drones) + + self.drones.iter().map(|d| vec_bytes(&d.route)).sum::() + + vec_bytes(&self.missiles) + + vec_bytes(&self.sams) + + vec_bytes(&self.targets) + + vec_bytes(&self.target_health) + + vec_bytes(&self.fx) + + vec_bytes(&self.blasts) + + vec_bytes(&self.queue) + + vec_bytes(&self.settling) + + vec_bytes(&self.later) + + vec_bytes(&self.flares) + + vec_bytes(&self.lit); + r.tracks = self.sams.iter().map(|s| vec_bytes(&s.tracks)).sum::() + + map_bytes(self.horizons.len(), std::mem::size_of::() + std::mem::size_of::()) + + self.horizons.values().map(|h| vec_bytes(&h.rays) + h.rays.iter().map(|ray| vec_bytes(ray)).sum::()).sum::(); + r.recording = self.rec.as_ref().map_or(0, |rec| rec.bytes()); + r.replays = self.replays.iter().map(|rec| rec.bytes()).sum(); + r.intel = self.intel.bytes(); + r.recon = vec_bytes(&self.recon.sorties) + + btree_bytes(self.recon.marks.len(), std::mem::size_of::() + std::mem::size_of::()) + + btree_bytes(self.recon.truth.len(), 2 * std::mem::size_of::()) + + btree_bytes(self.recon.checked.len(), std::mem::size_of::<(i64, i64)>() + std::mem::size_of::()); + r.routes = self.routes.bytes(); + r.sites = self.sites.bytes(); + r.strikes = self.strikes.bytes(); + r.plan = self.plan.as_ref().map_or(0, |p| p.bytes()) + + vecdeque_bytes(&self.retargets) + + self.retargets.iter().map(|j| j.known.bytes() + j.relief.as_ref().map_or(0, |k| k.bytes())).sum::() + + self.known_relief.as_ref().map_or(0, |k| k.bytes()); + r.other = map_bytes(self.roles.len(), std::mem::size_of::() + std::mem::size_of::()) + + self.fires.bytes() + + std::mem::size_of::() + + std::mem::size_of::(); + r + } +} diff --git a/airdef-mod/src/sim/mod.rs b/airdef-mod/src/sim/mod.rs index a4c9a9b..f022e46 100644 --- a/airdef-mod/src/sim/mod.rs +++ b/airdef-mod/src/sim/mod.rs @@ -41,6 +41,8 @@ pub mod outcome; mod units; pub mod why; pub mod world; +pub mod memory; +pub use memory::MemoryReport; pub mod profile; #[cfg(test)] mod balance; @@ -454,6 +456,10 @@ impl Ground { pub fn chunks_wanted(&self) -> usize { self.chunks.len() } + /// How many columns' heights are cached (the budget tests and the diagnostics read it). + pub fn known_len(&self) -> usize { + self.known.len() + } /// The chunks to ask the game to load this tick. pub fn take_chunks(&mut self) -> Vec<(i32, i32)> { std::mem::take(&mut self.chunks) diff --git a/airdef-mod/src/sim/raid.rs b/airdef-mod/src/sim/raid.rs index 3b7a70e..5d67666 100644 --- a/airdef-mod/src/sim/raid.rs +++ b/airdef-mod/src/sim/raid.rs @@ -127,6 +127,23 @@ pub(super) struct Plan { mapped: bool, } +impl Plan { + /// What the plan holds, about: the grid's heights, prices, routes and items (see `sim::memory`). + pub(super) fn bytes(&self) -> usize { + use super::memory::{map_bytes, vec_bytes}; + map_bytes(self.prices.len(), std::mem::size_of::() + std::mem::size_of::>()) + + self.prices.values().map(|p| vec_bytes(p)).sum::() + + map_bytes(self.routes.len(), std::mem::size_of::<(DroneKind, i32, i32, i32)>() + std::mem::size_of::>()) + + self.routes.values().map(|r| vec_bytes(r)).sum::() + + vec_bytes(&self.items) + + vec_bytes(&self.done) + + vec_bytes(&self.wants) + + vec_bytes(&self.heights) + + vec_bytes(&self.unanswered) + + self.knowledge.bytes() + } +} + /// The raid in progress: the counts at its start, for the report. pub(super) struct WaveStats { kills: u32, diff --git a/airdef-mod/src/sim/record.rs b/airdef-mod/src/sim/record.rs index 8c2ab60..051b8de 100644 --- a/airdef-mod/src/sim/record.rs +++ b/airdef-mod/src/sim/record.rs @@ -919,6 +919,35 @@ impl Recording { } } + /// What the recording holds, about: tracks and their points, the event and scene + /// journals, the systems' poses and the by-time index (see `sim::memory`). + pub fn bytes(&self) -> usize { + use super::memory::{map_bytes, vec_bytes}; + let mut n = vec_bytes(&self.tracks) + + self.tracks.iter().map(|t| vec_bytes(&t.points)).sum::() + + map_bytes(self.index.len(), std::mem::size_of::() + std::mem::size_of::()) + + vec_bytes(&self.events) + + vec_bytes(&self.sam_tracks) + + self.sam_tracks.iter().map(|t| vec_bytes(&t.keys)).sum::() + + map_bytes(self.sam_index.len(), std::mem::size_of::() + std::mem::size_of::()) + + vec_bytes(&self.ticks) + + vec_bytes(&self.times) + + vec_bytes(&self.sams) + + vec_bytes(&self.objects) + + self.index_bytes() + + std::mem::size_of::(); + if let Some(scene) = &self.scene { + n += vec_bytes(&scene.events) + + map_bytes(scene.tracks.len(), std::mem::size_of::<(u32, u32)>() + std::mem::size_of::<(bool, bool, DVec3)>()) + + map_bytes(scene.fires.len(), std::mem::size_of::() + std::mem::size_of::<(DVec3, u32, f32, bool, bool, Option)>()) + + vec_bytes(&scene.fire_events) + + map_bytes(scene.launches.len(), std::mem::size_of::() + std::mem::size_of::()) + + map_bytes(scene.ignitions.len(), std::mem::size_of::() + std::mem::size_of::()) + + map_bytes(scene.burnouts.len(), std::mem::size_of::() + std::mem::size_of::()); + } + n + } + /// The bytes the by-time index adds to a recording (its own journal aside). pub fn index_bytes(&self) -> usize { let order = self.time_order.as_ref().map_or(0, |o| o.capacity() * std::mem::size_of::()); diff --git a/airdef-mod/src/sim/route.rs b/airdef-mod/src/sim/route.rs index 04d0585..5dd1527 100644 --- a/airdef-mod/src/sim/route.rs +++ b/airdef-mod/src/sim/route.rs @@ -563,6 +563,23 @@ pub(super) struct Routes { } impl Routes { + /// What the routes and their searches hold, about (see `sim::memory`). + pub(super) fn bytes(&self) -> usize { + use super::memory::{map_bytes, vec_bytes}; + let cell = std::mem::size_of::<(i32, i32)>(); + let mut n = map_bytes(self.map.len(), std::mem::size_of::() + std::mem::size_of::()) + + map_bytes(self.unreachable.len(), std::mem::size_of::<(u32, u32)>() + std::mem::size_of::()); + for r in self.map.values() { + n += map_bytes(r.cells.len(), cell + std::mem::size_of::()) + + map_bytes(r.bad.len(), cell) + + map_bytes(r.g.len(), cell + std::mem::size_of::()) + + map_bytes(r.came.len(), 2 * cell) + + r.open.capacity() * std::mem::size_of::() + + vec_bytes(&r.parked) + + vec_bytes(&r.pts); + } + n + } pub(super) fn out_of_reach(&self, truck: u32, job: u32, now: u64) -> bool { self.unreachable.get(&(truck, job)).is_some_and(|&t| t > now) } diff --git a/airdef-mod/src/sim/sites.rs b/airdef-mod/src/sim/sites.rs index 2fcbcf2..f10d455 100644 --- a/airdef-mod/src/sim/sites.rs +++ b/airdef-mod/src/sim/sites.rs @@ -184,6 +184,11 @@ pub(super) enum Slot { } impl Sites { + /// What the sites hold, about (see `sim::memory`). + pub(super) fn bytes(&self) -> usize { + use super::memory::vec_bytes; + vec_bytes(&self.list) + vec_bytes(&self.jobs) + vec_bytes(&self.holding) + vec_bytes(&self.flying) + } pub fn get(&self, id: u32) -> Option<&LaunchSite> { self.list.iter().find(|s| s.id == id) } diff --git a/airdef-mod/src/sim/strike.rs b/airdef-mod/src/sim/strike.rs index f158e92..8de15fe 100644 --- a/airdef-mod/src/sim/strike.rs +++ b/airdef-mod/src/sim/strike.rs @@ -349,6 +349,13 @@ pub struct Strikes { } impl Strikes { + /// What the counter-strikes hold, about (see `sim::memory`). + pub(super) fn bytes(&self) -> usize { + use super::memory::vec_bytes; + vec_bytes(&self.known) + vec_bytes(&self.flights) + vec_bytes(&self.pending) + vec_bytes(&self.flown) + + vec_bytes(&self.wrecks) + vec_bytes(&self.cancelled) + + self.news.iter().map(|s| s.capacity()).sum::() + } pub fn new() -> Self { Strikes { stock: TUNE.stock, ..Default::default() } } diff --git a/airdef-mod/src/sim/world.rs b/airdef-mod/src/sim/world.rs index 5f6add2..2d051cb 100644 --- a/airdef-mod/src/sim/world.rs +++ b/airdef-mod/src/sim/world.rs @@ -232,6 +232,25 @@ impl WorldCache { .map(|e| 48 + if matches!(e.fill, Fill::Mixed(_)) { 512 } else { 0 }) .sum() } + /// What the cache holds, about: `(sections, other)` — the sections' table and mixed + /// bits, then the rays, queues, questions and blasts expected (see `sim::memory`). + pub fn memory(&self) -> (usize, usize) { + use super::memory::{map_bytes, vec_bytes}; + let entry = std::mem::size_of::() + std::mem::size_of::(); + let sections = map_bytes(self.secs.len(), entry) + + self.secs.values().filter(|e| matches!(e.fill, Fill::Mixed(_))).count() * 512; + let ray_entry = std::mem::size_of::<(u32, [i32; 3])>() + std::mem::size_of::(); + let other = map_bytes(self.rays.entries.len(), ray_entry) + + map_bytes(self.rays.by_id.len(), std::mem::size_of::() + std::mem::size_of::<(u32, [i32; 3])>()) + + vec_bytes(&self.rays.out) + + vec_bytes(&self.urgent) + + vec_bytes(&self.ahead) + + map_bytes(self.queued.len(), std::mem::size_of::()) + + map_bytes(self.asked.len(), std::mem::size_of::() + std::mem::size_of::()) + + vec_bytes(&self.expected) + + map_bytes(self.changed_cols.len(), std::mem::size_of::<(i32, i32)>()); + (sections, other) + } pub fn len(&self) -> usize { self.secs.len() }