Keep replay transitions through the SAM pose decimation (#142)
build / mod (push) Failing after 36s

Sampling slowed by the pose budget skipped whole short stages: the six-tick
tube cover opening, the ejection and the radar switch fell between samples,
and thinning then halved already recorded transitions along with poses.

Poses still share the adaptive sam_step grid and the unchanged 32768-key
budget, but the recording is now sampled every tick for facts: a discrete
change (spent_cells, cap_cell, radar_on, mode, role) and every frame of the
cover's own movement are kept on the tick they happen, with the stage's start
backdated one tick so the opening still spans exactly OPEN_TICKS. These keys
carry an event mark and decimation halves poses only, keeping events, the
first and the last key.

Events get their own explicit 4096-key budget instead of raising the pose
budget: when it runs out the oldest stop being critical and thin as poses
while the newest stay exact.

Test: 64 turning radars plus an S-400 at sam_step 16, ejection on tick 4103
(cover 0.8333333 a tick before, spent cell on the ejection tick), a cancelled
opening and a radar switch off the pose grid, all surviving further thinning;
a 64-radar chattering recording stays exactly at the event budget with the
newest switch exact.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
This commit is contained in:
2026-11-21 09:12:18 +03:00
parent 433e1500e2
commit 41ab52e802
2 changed files with 232 additions and 26 deletions
+205 -26
View File
@@ -30,6 +30,9 @@ pub struct SamKey {
spent_cells: u8,
cap_cell: u8,
cap_open: f32,
/// A discrete transition or a frame of a tube cover's opening rather than a pose sample (#142):
/// decimation keeps it, within its own budget.
event: bool,
}
impl SamKey {
@@ -51,6 +54,7 @@ impl SamKey {
spent_cells: sam.spent_cells,
cap_cell: sam.cap_cell,
cap_open: sam.cap_open,
event: false,
}
}
/// The same pose (to within what could be seen).
@@ -68,6 +72,18 @@ impl SamKey {
&& self.spent_cells == o.spent_cells && self.cap_cell == o.cap_cell
&& near(self.cap_open, o.cap_open, 0.001)
}
/// The states a replay reads as facts rather than as interpolated poses: which round is spent,
/// which tube the cover opens, whether the radar emits, and the mount's configuration.
fn discrete(&self) -> (battery::SamMode, battery::RadarRole, bool, u8, u8) {
(self.mode, self.radar_role, self.radar_on, self.spent_cells, self.cap_cell)
}
/// The tube cover's stage: shut, on its way open, or wide.
fn cover(&self) -> u8 { cover_stage(self.cap_open) }
}
/// The cover's stage an opening (`launch::OPEN_TICKS` long) passes through.
fn cover_stage(open: f32) -> u8 {
if open <= 0.0 { 0 } else if open < 1.0 { 1 } else { 2 }
}
/// A system through a recording: its poses (a new one only when it changed, with the
@@ -115,6 +131,7 @@ impl SamTrack {
spent_cells: a.spent_cells,
cap_cell: a.cap_cell,
cap_open: if a.cap_cell == b.cap_cell && a.spent_cells == b.spent_cells { l(a.cap_open, b.cap_open) } else { a.cap_open },
event: false,
})
}
/// The system as it stood at `t`, as a ghost to draw with the ids from `id`.
@@ -157,6 +174,7 @@ impl Recording {
sam_tracks: Vec::new(),
sam_index: HashMap::new(),
sam_keys: 0,
sam_events: 0,
sam_step: STEP,
ticks: Vec::new(),
times: Vec::new(),
@@ -190,6 +208,10 @@ const LONGEST: u32 = 12_000;
const KEPT: usize = 3;
/// SAM poses share a fixed memory budget; under pressure old poses are thinned and new ones slow down.
const MAX_SAM_KEYS: usize = 32_768;
/// Discrete transitions and cover-opening frames have their own small budget (#142): they are
/// facts a replay must not lose, but they may not spend the pose budget either. When it runs out
/// the oldest stop being critical (the newest are kept) and decimation may thin them as poses.
const MAX_SAM_EVENTS: usize = 4_096;
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum What {
@@ -387,6 +409,8 @@ pub struct Recording {
pub sam_tracks: Vec<SamTrack>,
sam_index: HashMap<u32, usize>,
sam_keys: usize,
/// How many of `sam_keys` are critical transitions (#142).
sam_events: usize,
sam_step: u32,
/// The game's tick number as sampled with the clock: (recording tick, game tick). A replay
/// shows the world's blocks as of this time.
@@ -597,37 +621,70 @@ impl Recording {
sam_tracks: Vec::new(),
sam_index: HashMap::new(),
sam_keys: 0,
sam_events: 0,
sam_step: STEP,
ticks: Vec::new(),
times: Vec::new(),
quiet: 0,
}
}
fn thin_sam_tracks(&mut self) {
/// Halves each track's poses, keeping its critical transitions, its first and its last key (#142).
fn thin_sam_poses(&mut self) {
for track in &mut self.sam_tracks {
let len = track.keys.len();
let mut kept = 0;
for read in (0..len).step_by(2) {
track.keys[kept] = track.keys[read];
kept += 1;
}
if len % 2 == 0 && len > 0 {
track.keys[kept] = track.keys[len - 1];
kept += 1;
let mut poses = 0;
for read in 0..len {
let key = track.keys[read];
let keep = if key.event {
true
} else {
poses += 1;
poses % 2 == 1 || read + 1 == len
};
if keep {
track.keys[kept] = key;
kept += 1;
}
}
track.keys.truncate(kept);
track.keys.shrink_to_fit();
}
self.sam_keys = self.sam_tracks.iter().map(|track| track.keys.len()).sum();
self.count_sam_keys();
self.sam_step = self.sam_step.saturating_mul(2).min(LONGEST);
}
/// The transitions' budget ran out: the oldest stop being critical, so decimation may thin them
/// as poses. The newest transitions, which a replay is watched closest for, are kept (#142).
fn thin_sam_events(&mut self) {
let mut over = self.sam_events.saturating_sub(MAX_SAM_EVENTS);
while over > 0 {
let mut demoted = 0;
for track in &mut self.sam_tracks {
if over == 0 { break; }
if let Some(key) = track.keys.iter_mut().find(|key| key.event) {
key.event = false;
over -= 1;
demoted += 1;
}
}
if demoted == 0 { break; }
}
self.count_sam_keys();
}
fn count_sam_keys(&mut self) {
self.sam_keys = self.sam_tracks.iter().map(|track| track.keys.len()).sum();
self.sam_events = self.sam_tracks.iter().map(|track| track.keys.iter().filter(|key| key.event).count()).sum();
}
/// Notes the systems' poses at the recording's tick `now`: a pose only when it changed, with
/// the pose it held marked before it so a replay doesn't glide through the stillness.
///
/// Poses are sampled on the adaptive `sam_step` grid under its own budget, but the cover's
/// opening (`launch::OPEN_TICKS`, shorter than a decimated interval) and the discrete
/// transitions — a round ejected, a tube cancelled, the radar switched, the mount's
/// configuration — are facts: they are kept on the tick they happen, in their own budget (#142).
fn note_sams(&mut self, sams: &[Sam], now: u32) {
if now % self.sam_step != 0 {
return;
}
let pose_due = now % self.sam_step == 0;
for sam in sams {
let key = SamKey::of(sam, self.origin, now);
let i = *self.sam_index.entry(sam.id).or_insert_with(|| {
@@ -636,20 +693,41 @@ impl Recording {
});
let track = &mut self.sam_tracks[i];
let before = track.keys.len();
match track.keys.last().copied() {
None => track.keys.push(key),
Some(last) if last.same(&key) => {}
Some(last) => {
if last.at + self.sam_step < now {
track.keys.push(SamKey { at: now - self.sam_step, ..last });
}
track.keys.push(key);
}
let Some(last) = track.keys.last().copied() else {
track.keys.push(key);
self.sam_keys += 1;
continue;
};
if last.same(&key) {
continue;
}
self.sam_keys += track.keys.len() - before;
// The cover's opening is short: its first frame only differs from the shut pose by a
// fraction, so the stage's start is backdated to the tick it began (#142).
if last.cover() == 0 && key.cover() == 1 && now > last.at + 1 {
track.keys.push(SamKey { at: now - 1, cap_open: 0.0, event: true, ..key });
}
let transitioning = last.discrete() != key.discrete() || last.cover() != key.cover();
// Every frame of the cover's own movement is kept, so the stage's six ticks survive intact.
let moving = key.cover() == 1 && last.cap_open != key.cap_open;
if transitioning || moving {
let mut event = key;
event.event = true;
track.keys.push(event);
} else if pose_due {
if last.at + self.sam_step < now {
track.keys.push(SamKey { at: now - self.sam_step, event: false, ..last });
}
track.keys.push(key);
}
let added = track.keys.len() - before;
self.sam_keys += added;
self.sam_events += track.keys[before..].iter().filter(|key| key.event).count();
}
if self.sam_keys > MAX_SAM_KEYS {
self.thin_sam_tracks();
if self.sam_events > MAX_SAM_EVENTS {
self.thin_sam_events();
}
if self.sam_keys.saturating_sub(self.sam_events) > MAX_SAM_KEYS {
self.thin_sam_poses();
}
}
/// Actual launch, if observed during this recording. Missing is not proof of no launch:
@@ -874,9 +952,10 @@ impl Sim {
}
r.ticks.push((r.len, self.engine_tick));
}
// Poses share the adaptive grid inside; the discrete transitions and the cover's short
// opening must be seen on the tick they happen, whatever the grid (#142).
r.note_sams(&self.sams, r.len);
if r.len % STEP == 0 {
let now = r.len;
r.note_sams(&self.sams, now);
for d in self.drones.iter().filter(|d| !recon::is_drone_id(d.id)) {
r.point(d.id, What::Drone(d.kind), d.pos);
}
@@ -1089,6 +1168,7 @@ mod tests {
sam_tracks: Vec::new(),
sam_index: HashMap::new(),
sam_keys: 0,
sam_events: 0,
sam_step: STEP,
ticks: Vec::new(),
times: Vec::new(),
@@ -1244,6 +1324,7 @@ mod tests {
let keys: usize = r.sam_tracks.iter().map(|track| track.keys.len()).sum();
let allocated: usize = r.sam_tracks.iter().map(|track| track.keys.capacity()).sum();
assert_eq!(keys, r.sam_keys);
assert_eq!(r.sam_events, 0, "a turning dish is a pose, not a transition");
assert!(keys <= MAX_SAM_KEYS, "a full recording retained {keys} SamKeys");
assert!(allocated <= 2 * MAX_SAM_KEYS, "SamKey allocations reached {} MiB", allocated * size_of::<SamKey>() / (1024 * 1024));
assert!(r.sam_step > STEP, "the rotating radars never engaged adaptive sampling");
@@ -1252,6 +1333,104 @@ mod tests {
assert!(last.dish > 100.0, "the final radar pose was not recorded");
}
// #142: sixty-four turning radars on a 16-tick pose grid plus a cold S-400 launch. The
// cover's six-tick opening, the ejection and the spent cell must survive the decimation, and
// so must the radar's switch and a cancelled cover, on the tick they happened.
#[test]
fn decimation_keeps_a_cold_launch_cover_ejection_and_the_radar_switch() {
let mut r = recording();
let mut sams: Vec<_> = (0..64).map(|id| Sam::new(id, SamKind::Radar, DVec3::ZERO, 0.0)).collect();
sams.push(Sam::new(100, SamKind::S400, DVec3::ZERO, 0.0));
let turned_off = 5_usize;
// The pose budget of a long recording has already slowed the sampling down.
r.sam_step = 16;
let eject = 4103u32;
let start = eject - launch::OPEN_TICKS as u32;
let (reopen, close, switch) = (4120u32, 4122u32, 4131u32);
for now in 0..4_200 {
for sam in &mut sams[..64] {
sam.dish = now as f64 * 0.01;
}
let s400 = sams.len() - 1;
if now == start {
assert!(!sams[s400].prepare_tube(7, now as u64));
} else if (start + 1..=eject).contains(&now) {
if sams[s400].prepare_tube(7, now as u64) {
assert_eq!(now, eject);
sams[s400].eject_cell(0);
}
} else if (reopen..close).contains(&now) {
// A second opening, cancelled before it is wide: the cover closes.
sams[s400].prepare_tube(7, now as u64);
} else if now == close {
sams[s400].cancel_prepare();
}
if now == switch {
sams[turned_off].radar_on = false;
}
r.note_sams(&sams, now);
}
let track = |id: u32| r.sam_tracks.iter().find(|track| track.id == id).unwrap();
let pose = |id: u32, t: f64| track(id).pose(t).unwrap();
let s400 = track(100);
assert!(s400.keys.len() < 32, "the launch track kept {} keys", s400.keys.len());
// The cover was shut before the stage and opens exactly over `OPEN_TICKS` ticks.
assert_eq!(pose(100, f64::from(start - 1)).cap_open, 0.0);
for k in 1..launch::OPEN_TICKS as u32 {
let want = k as f32 / launch::OPEN_TICKS as f32;
let got = pose(100, f64::from(start + k)).cap_open;
assert!((got - want).abs() < 1e-5, "tick {} of the opening: {got} not {want}", start + k);
}
assert!(s400.keys.iter().any(|k| k.at == start && k.event && k.cap_open == 0.0), "the stage's start key is kept");
// The last tick before the ejection: the cover stands five sixths open, not shut.
assert!((pose(100, f64::from(eject - 1)).cap_open - 5.0 / 6.0).abs() < 1e-5);
// The ejection: the cell is spent on its own tick, not on the next pose sample.
assert_eq!(pose(100, f64::from(eject - 1)).spent_cells, 0);
assert_eq!(pose(100, f64::from(eject)).spent_cells, 1);
assert!(track(100).keys.iter().any(|k| k.at == eject && k.event));
// The cancelled opening closes the cover on the tick it was cancelled.
assert!(pose(100, f64::from(close - 1)).cap_open > 0.0);
assert_eq!(pose(100, f64::from(close)).cap_open, 0.0);
// The radar's switch is on its own tick, between two 16-tick pose samples.
assert!(pose(turned_off as u32, f64::from(switch - 1)).radar_on);
assert!(!pose(turned_off as u32, f64::from(switch)).radar_on);
assert!(track(turned_off as u32).keys.iter().any(|k| k.at == switch && k.event));
// Later decimation halves poses only: the recorded launch still reads as it did.
r.thin_sam_poses();
r.thin_sam_poses();
let track = |id: u32| r.sam_tracks.iter().find(|track| track.id == id).unwrap();
let pose = |id: u32, t: f64| track(id).pose(t).unwrap();
assert!((pose(100, f64::from(eject - 1)).cap_open - 5.0 / 6.0).abs() < 1e-5);
assert_eq!(pose(100, f64::from(eject)).spent_cells, 1);
assert!(!pose(turned_off as u32, f64::from(switch)).radar_on);
}
// #142: the transitions have their own explicit budget. A recording that chatters must stay
// bounded, and the newest transitions — what a replay is watched closest for — stay exact.
#[test]
fn critical_transitions_have_their_own_explicit_budget() {
let mut r = recording();
let mut sams: Vec<_> = (0..64).map(|id| Sam::new(id, SamKind::Radar, DVec3::ZERO, 0.0)).collect();
let ticks = 1_500u32;
for now in 0..ticks {
for sam in &mut sams {
sam.radar_on = now % 2 == 0;
}
r.note_sams(&sams, now);
}
let keys: usize = r.sam_tracks.iter().map(|track| track.keys.len()).sum();
assert_eq!(keys, r.sam_keys);
assert_eq!(r.sam_events, MAX_SAM_EVENTS, "the transitions' budget is explicit");
assert!(keys <= MAX_SAM_KEYS + MAX_SAM_EVENTS + sams.len(), "{keys} SamKeys retained");
assert!(keys - r.sam_events <= MAX_SAM_KEYS, "poses broke their own budget");
// The newest switch reads exactly; the oldest transitions were the ones let go.
let newest = r.sam_tracks[0].pose(f64::from(ticks - 1)).unwrap();
assert_eq!(newest.radar_on, (ticks - 1) % 2 == 0);
assert!(r.sam_tracks[0].keys.iter().any(|key| key.at == ticks - 1 && key.event));
let earliest = r.sam_tracks[0].keys.iter().position(|key| key.event);
assert!(earliest.is_none_or(|i| r.sam_tracks[0].keys[i].at > ticks / 2), "old transitions hold on to the budget");
}
#[test]
fn a_system_keeps_its_pose_through_stillness_and_moves_when_it_moved() {
let mut r = recording();
+27
View File
@@ -33,6 +33,33 @@
137346889/300M, command 129151/1B, failures=0. Лимит памяти 64 MiB не увеличивался. Это
синтетический host без GPU и не приёмка Windows GUI.
### Прореживание не съедает короткие переходы (#142)
Прореживание #122 не различало непрерывную позу и дискретный факт: при большом числе меняющихся
РЛС оно пропускало целиком открытие крышки ТПК (`launch::OPEN_TICKS = 6` тиков, короче шага
sampling) и могло убрать уже записанный переход — ракета в реплее вылетала с нарисованной
закрытой крышкой, а `spent_cells` менялось только на следующем общем сэмпле.
Теперь `Recording::note_sams` вызывается каждый тик: позы по-прежнему снимаются на адаптивной
сетке `sam_step` из прежнего бюджета 32768, а дискретные переходы (`cap_cell`, `spent_cells`,
`radar_on`, режим и роль) и кадры открытия крышки пишутся на том тике, когда произошли, и
помечаются как события. Начало открытия дотягивается отдельным ключом на тик раньше, поэтому
ramp занимает ровно `OPEN_TICKS`, а не «примерно». Прореживание поз половинит только позы и
сохраняет события, первую и последнюю позу.
У событий свой явный бюджет — 4096 ключей на запись поверх 32768 поз; общий бюджет поз не
поднимался. При переполнении старые события перестают быть критическими (прореживаются как
позы), новейшие сохраняются: под записью с «болтливым» датчиком реплей остаётся ограниченным,
а свежий пуск — точным.
Проверки: `airdef-core` `sim::record::tests::decimation_keeps_a_cold_launch_cover_ejection_and_the_radar_switch`
— 64 вращающихся РЛС + С-400 при `sam_step = 16`, выброс на тике 4103: за тик до выброса
`cap_open = 0.8333333` (как в контрольной записи без давления на бюджет), `spent_cells = 0`
до и `1` на тике выброса, отмена/закрытие и `radar_on` читаются на своих тиках, повторное
прореживание их не убирает;
`critical_transitions_have_their_own_explicit_budget` — 64 РЛС, переключающихся каждый тик,
1500 тиков: событий ровно 4096, позы в своём бюджете, новейшее переключение точное.
## Второй налёт из UI: событие, не тик
Точный лог Windows: `Horizon: mod airdef stopped in UI event (fuel budget 1000000000,