use super::*; use prometeu_hal::memcard::MemcardIoError; use std::sync::{Arc, Mutex}; #[derive(Clone)] struct Disk { volatile: Vec, durable: Vec, calls: usize, fail: Option, sync_then_fail: bool, } struct Store(Arc>); impl MemcardStorage for Store { fn len(&self) -> std::result::Result { Ok(IMAGE_BYTES) } fn read_only(&self) -> bool { false } fn read_at(&mut self, offset: u64, out: &mut [u8]) -> std::result::Result<(), MemcardIoError> { let mut d = self.0.lock().unwrap(); d.calls += 1; if d.fail == Some(d.calls) { return Err(MemcardIoError::IoError); } out.copy_from_slice(&d.volatile[offset as usize..offset as usize + out.len()]); Ok(()) } fn write_at(&mut self, offset: u64, bytes: &[u8]) -> std::result::Result<(), MemcardIoError> { let mut d = self.0.lock().unwrap(); d.calls += 1; let start = offset as usize; if d.fail == Some(d.calls) { let half = bytes.len() / 2; d.volatile[start..start + half].copy_from_slice(&bytes[..half]); d.durable[start..start + half].copy_from_slice(&bytes[..half]); return Err(MemcardIoError::IoError); } d.volatile[start..start + bytes.len()].copy_from_slice(bytes); Ok(()) } fn sync(&mut self) -> std::result::Result<(), MemcardIoError> { let mut d = self.0.lock().unwrap(); d.calls += 1; let fail = d.fail == Some(d.calls); if !fail || d.sync_then_fail { d.durable = d.volatile.clone(); } if fail { Err(MemcardIoError::IoError) } else { Ok(()) } } } fn disk() -> Arc> { Arc::new(Mutex::new(Disk { volatile: vec![0; IMAGE_BYTES as usize], durable: vec![0; IMAGE_BYTES as usize], calls: 0, fail: None, sync_then_fail: false, })) } fn formatted() -> (Card, Arc>) { let d = disk(); Card::format(&mut Store(d.clone()), [7; 16]).unwrap(); (Card::mount(Box::new(Store(d.clone()))).unwrap(), d) } fn add(card: &mut Card, app: u32, n: usize) { let icon = [0; 560]; card.register( Game { app_id: app, title: "game".into(), data_format_version: 0, created_at: 0, slots: vec![0; n], icon: Icon { offset: 0, frames: 1, duration: 1, crc32c: crc32c(&icon) }, }, &icon, &PublicationControl::default(), ) .unwrap(); } fn reboot(d: &Arc>) -> Card { { let mut disk = d.lock().unwrap(); disk.volatile = disk.durable.clone(); disk.fail = None; } Card::mount(Box::new(Store(d.clone()))).unwrap() } #[test] fn full_pool_rotates_and_empty_keeps_ownership() { let (mut c, d) = formatted(); add(&mut c, 1, 64); for i in 0..64 { assert_eq!( c.commit(i, &[i as u8], 0, &PublicationControl::default()).durable, DurableResult::Success ); } let mut visited = std::collections::BTreeSet::new(); for i in 0..90 { assert_eq!( c.commit(0, &[i], 10, &PublicationControl::default()).durable, DurableResult::Success ); visited.insert(c.current().slots[0].block.unwrap()); } assert!(visited.len() >= 5); assert_eq!(c.commit(0, &[], 0, &PublicationControl::default()).durable, DurableResult::Success); let r = reboot(&d); assert!(r.current().slots[0].assigned); assert_eq!(r.current().slots[0].block, None); assert_eq!(r.current().slots[0].generation, 92); assert_eq!(r.current().slots[0].update_at, 0); } #[test] fn cut_every_commit_step_including_sync_that_persists_then_errors() { let (mut c, d) = formatted(); add(&mut c, 1, 1); c.commit(0, b"old", 7, &PublicationControl::default()); let initial = d.lock().unwrap().clone(); for persist in [false, true] { for cut in 1..=12 { let mut initial = initial.clone(); initial.calls = 0; initial.fail = None; initial.sync_then_fail = persist; let d = Arc::new(Mutex::new(initial)); let mut card = Card::mount(Box::new(Store(d.clone()))).unwrap(); { let mut disk = d.lock().unwrap(); disk.calls = 0; disk.fail = Some(cut); } let result = card.commit(0, b"new version", 1, &PublicationControl::default()); let mut recovered = reboot(&d); let mut bytes = [0; 64]; let n = recovered.read_slot(0, &mut bytes).unwrap(); match result.durable { DurableResult::Success => assert_eq!(&bytes[..n], b"new version"), DurableResult::Failure => assert_eq!(&bytes[..n], b"old"), DurableResult::Indeterminate => { assert!(&bytes[..n] == b"old" || &bytes[..n] == b"new version") } } } } } #[test] fn catalog_cuts_never_publish_partial_registration() { let (c, d) = formatted(); drop(c); let baseline = d.lock().unwrap().clone(); for cut in 1..=14 { let d = Arc::new(Mutex::new(baseline.clone())); let mut card = Card::mount(Box::new(Store(d.clone()))).unwrap(); { let mut state = d.lock().unwrap(); state.calls = 0; state.fail = Some(cut); state.sync_then_fail = true; } let icon = [0; 560]; let _ = card.register( Game { app_id: 3, title: "new".into(), data_format_version: 0, created_at: 0, slots: vec![0; 2], icon: Icon { offset: 0, frames: 1, duration: 1, crc32c: crc32c(&icon) }, }, &icon, &PublicationControl::default(), ); let recovered = reboot(&d); let n = recovered.catalog.games.len(); assert!(n <= 1); assert_eq!(recovered.current().slots.iter().filter(|s| s.assigned).count(), n * 2); } } #[test] fn corrupted_new_payload_recovers_old_map_with_diagnostic() { let (mut c, d) = formatted(); add(&mut c, 1, 1); c.commit(0, b"old", 7, &PublicationControl::default()); c.commit(0, b"new", 8, &PublicationControl::default()); let at = block_offset(c.current().slots[0].block.unwrap()).unwrap() as usize; { let mut disk = d.lock().unwrap(); disk.durable[at] ^= 1; } let mut r = reboot(&d); assert!(r.recovered); let mut out = [0; 8]; let n = r.read_slot(0, &mut out).unwrap(); assert_eq!(&out[..n], b"old"); } #[test] fn grow_shrink_removal_and_clean_reassignment() { let (mut c, d) = formatted(); add(&mut c, 1, 2); c.commit(1, b"private", 5, &PublicationControl::default()); c.grow(1, 4, &PublicationControl::default()).unwrap(); c.grow(1, 1, &PublicationControl::default()).unwrap(); assert_eq!(c.catalog.games[0].slots.len(), 4); c.remove_game(1, &PublicationControl::default()).unwrap(); add(&mut c, 2, 4); let r = reboot(&d); assert!( r.current().slots[..4].iter().all(|s| s.assigned && s.generation == 0 && s.block.is_none()) ); } #[test] fn cancellation_prevents_publication_and_generations_do_not_wrap() { let (mut c, d) = formatted(); add(&mut c, 1, 1); let token = PublicationControl::default(); token.cancel(); assert_eq!(c.commit(0, b"no", 1, &token).durable, DurableResult::Failure); assert_eq!(reboot(&d).current().slots[0].generation, 0); c.maps[c.active].as_mut().unwrap().slots[0].generation = u64::MAX; assert_eq!( c.commit(0, b"no", 1, &PublicationControl::default()).error, Some(Error::CounterExhausted) ); } #[test] fn quarantine_survives_remount_and_is_never_selected() { let (mut c, d) = formatted(); add(&mut c, 1, 1); c.quarantine(0, &PublicationControl::default()).unwrap(); let mut c = reboot(&d); assert!(c.degraded); c.commit(0, b"yes", 1, &PublicationControl::default()); assert_ne!(c.current().slots[0].block, Some(0)); assert!(reboot(&d).current().quarantine[0]); } #[test] fn async_commit_protects_only_source_and_retains_result_without_occupying_lane() { use crate::services::async_work::{ AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController, }; use crate::services::memcard::session::{RequestState, Session}; use std::time::{Duration, Instant}; let (mut card, _) = formatted(); add(&mut card, 4, 2); let mut session = Session::default(); let context = session.load_card(card, 4, 2, Session::required_bytes(2).unwrap()).unwrap(); session.write(context, 0, 0, b"save").unwrap(); let lane = Arc::new(AsyncWorkLane::default()); let now = Instant::now(); let id = session.commit(context, 0, 77, now, &lane).unwrap(); assert_eq!(session.write(context, 0, 0, b"bad"), Err(Error::Busy)); session.write(context, 1, 0, b"other").unwrap(); let mut bytes = [0; 4]; assert_eq!(session.read(context, 0, 0, &mut bytes), Ok(4)); assert_eq!(&bytes, b"save"); let mut controller = AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone()); let deadline = Instant::now() + Duration::from_secs(2); while session.query(context, id).unwrap().state == RequestState::Pending { assert!(Instant::now() < deadline); session.poll(Instant::now()); std::thread::yield_now(); } assert_eq!(session.query(context, id).unwrap().state, RequestState::Success); let (tx, rx) = std::sync::mpsc::channel(); lane.submit_asset_load(move |_| { tx.send(()).unwrap(); crate::services::async_work::AsyncWorkJobOutcome::Completed }) .unwrap(); rx.recv_timeout(Duration::from_secs(1)).unwrap(); assert_eq!(session.commit(context, 1, 78, Instant::now(), &lane), Err(Error::Busy)); assert_eq!(session.descriptor(context, 0).unwrap().0.update_at, 77); session.release_request(context, id).unwrap(); controller.stop().unwrap(); } // The sentinel executes after the save on the single lane. Wall time only bounds // a broken fixture; all watchdog observations use explicit simulated instants. fn finish_queued_save(lane: Arc) { let (tx, rx) = std::sync::mpsc::channel(); lane.submit_asset_load(move |_| { tx.send(()).unwrap(); crate::services::async_work::AsyncWorkJobOutcome::Completed }) .unwrap(); let mut controller = crate::AsyncWorkLaneController::start(crate::AsyncWorkLaneConfig::default(), lane); rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap(); controller.stop().unwrap(); } fn assert_guest_query( session: &mut super::super::session::Session, id: u64, state: i64, reason: i64, ) { use prometeu_bytecode::Value; use prometeu_hal::{ HostReturn, host_return::GuestStringAllocator, syscalls::Syscall, vm_fault::VmFault, }; struct NoStrings; impl GuestStringAllocator for NoStrings { fn byte_limit(&self) -> u64 { 0 } fn build( &mut self, _: usize, _: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result, ) -> std::result::Result, VmFault> { panic!("MemQuery must not allocate strings") } } let mut service = super::super::MemcardService::new(); std::mem::swap(session, &mut service.session); let args = [Value::Int64(service.session.context() as i64), Value::Int64(id as i64)]; let mut values = Vec::with_capacity(Syscall::MemQuery.results_count()); let mut strings = NoStrings; let mut ret = HostReturn::new(&mut values, Syscall::MemQuery.results_count(), &mut strings); service.guest(Syscall::MemQuery, &args, &mut ret, 4, 0, true).unwrap(); assert!(!ret.overflowed()); assert!(ret.failure().is_none()); assert_eq!(values, vec![Value::Int64(0), Value::Int64(state), Value::Int64(reason)]); std::mem::swap(session, &mut service.session); } #[test] fn queued_memcard_watchdog_preserves_timeout_and_guest_reason() { use super::super::session::{RequestReason, RequestState, Session}; use std::time::{Duration, Instant}; for bootstrap in [false, true] { let (mut card, disk) = formatted(); add(&mut card, 4, 1); let before = card.current().slots[0]; let mut s = Session::default(); let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap(); s.write(c, 0, 0, b"pending").unwrap(); let lane = Arc::new(crate::AsyncWorkLane::default()); let now = Instant::now(); if bootstrap { s.begin_boot(); } let id = s.commit(c, 0, 7, now, &lane).unwrap(); if bootstrap { s.finish_boot(true, &lane, now).unwrap(); } s.poll(now + Duration::from_millis(499)); assert_guest_query(&mut s, id, 0, 0); for _ in 0..2 { s.poll(now + Duration::from_millis(500)); } assert_guest_query(&mut s, id, 0, 0); assert_eq!(s.release_request(c, id), Err(Error::Busy)); assert_eq!(s.clear(c, 0), Err(Error::Busy)); finish_queued_save(lane); s.poll(now + Duration::from_millis(501)); let result = s.query(c, id).unwrap(); assert_eq!(result.state, RequestState::Failure); assert_eq!(result.reason, RequestReason::Timeout); assert_eq!(s.request_storage_error(c, id), Ok(Some(Error::Canceled))); assert_guest_query(&mut s, id, 2, 15); assert!(s.unsaved()); assert_eq!(reboot(&disk).current().slots[0], before); assert_eq!(s.query(c + 1, id), Err(Error::AccessDenied)); s.release_request(c, id).unwrap(); assert_eq!(s.query(c, id), Err(Error::InvalidRange)); s.clear(c, 0).unwrap(); } } #[test] fn lifecycle_cancellation_is_not_a_watchdog_timeout() { use super::super::session::{RequestReason, RequestState, Session}; use std::time::{Duration, Instant}; for end in [false, true] { let (mut card, _) = formatted(); add(&mut card, 4, 1); let mut s = Session::default(); let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap(); let lane = Arc::new(crate::AsyncWorkLane::default()); let now = Instant::now(); let id = s.commit(c, 0, 7, now, &lane).unwrap(); if end { s.end_session(); } else { s.notify_removal(); } s.poll(now + Duration::from_millis(500)); finish_queued_save(lane); s.poll(now + Duration::from_millis(501)); if end { assert_eq!(s.query(c, id), Err(Error::AccessDenied)); let card = s.take_idle_card().unwrap().unwrap(); let new = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap(); assert_ne!(new, c); assert_eq!(s.query(new, id), Err(Error::InvalidRange)); } else { assert_eq!(s.query(c, id).unwrap().state, RequestState::Failure); assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Storage(Error::Canceled)); assert_guest_query(&mut s, id, 2, 8); } } } #[test] fn deferred_boot_memcard_deadline_stays_timeout() { use super::super::session::{RequestReason, Session}; use std::time::{Duration, Instant}; let (mut card, _) = formatted(); add(&mut card, 4, 1); let mut s = Session::default(); let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap(); s.begin_boot(); let lane = crate::AsyncWorkLane::default(); let now = Instant::now(); let id = s.commit(c, 0, 7, now, &lane).unwrap(); s.poll(now + Duration::from_millis(500)); assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Timeout); assert_guest_query(&mut s, id, 2, 15); assert_eq!(lane.pending_depth(), 0); s.clear(c, 0).unwrap(); s.release_request(c, id).unwrap(); } #[test] fn blocked_host_memcard_watchdog_preserves_outcome_and_escalation() { use crate::services::async_work::{ AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController, }; use crate::services::memcard::session::{RequestReason, RequestState, Session}; use std::time::{Duration, Instant}; struct Blocked { store: Box, publication: bool, fail_publication: bool, entered: std::sync::mpsc::Sender<()>, resume: std::sync::mpsc::Receiver<()>, } impl MemcardStorage for Blocked { fn len(&self) -> std::result::Result { self.store.len() } fn read_only(&self) -> bool { false } fn read_at(&mut self, o: u64, b: &mut [u8]) -> std::result::Result<(), MemcardIoError> { self.store.read_at(o, b) } fn sync(&mut self) -> std::result::Result<(), MemcardIoError> { self.store.sync() } fn write_at(&mut self, o: u64, b: &[u8]) -> std::result::Result<(), MemcardIoError> { if if self.publication { b.starts_with(b"PMMAP1\0\0") } else { o >= DATA_OFFSET } { self.entered.send(()).unwrap(); self.resume.recv().unwrap(); if self.fail_publication { return Err(MemcardIoError::IoError); } } self.store.write_at(o, b) } } for (publication, fail_publication, escalate, release_early) in [ (false, false, false, false), (true, false, false, false), (true, true, false, false), (false, false, true, false), (true, false, true, false), (true, true, true, false), (false, false, true, true), (true, false, true, true), ] { let (mut card, disk) = formatted(); add(&mut card, 4, 1); let (et, er) = std::sync::mpsc::channel(); let (rt, rr) = std::sync::mpsc::channel(); let card = Card::mount(Box::new(Blocked { store: card.into_storage(), entered: et, resume: rr, publication, fail_publication, })) .unwrap(); let mut s = Session::default(); let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap(); s.write(c, 0, 0, b"pending").unwrap(); let lane = Arc::new(AsyncWorkLane::default()); let mut controller = AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone()); let admitted = Instant::now(); let id = s.commit(c, 0, 7, admitted, &lane).unwrap(); er.recv_timeout(Duration::from_secs(1)).unwrap(); s.poll(admitted + Duration::from_millis(500)); assert_guest_query(&mut s, id, 0, 0); let terminal = if escalate { s.poll(admitted + Duration::from_secs(1)); let result = s.query(c, id).unwrap(); assert_eq!( result.state, if publication { RequestState::Indeterminate } else { RequestState::Failure } ); assert_eq!(result.reason, RequestReason::RestartRequired); assert!(s.host_faulted()); if release_early { s.release_request(c, id).unwrap(); } Some(result) } else { None }; assert_eq!(s.write(c, 0, 0, b"unsafe"), Err(Error::Busy)); assert_eq!(s.commit(c, 0, 7, admitted, &lane), Err(Error::Busy)); rt.send(()).unwrap(); controller.stop().unwrap(); s.poll(admitted + Duration::from_millis(if escalate { 1001 } else { 501 })); if let Some(terminal) = terminal { if release_early { assert_eq!(s.query(c, id), Err(Error::InvalidRange)); } else { assert_eq!(s.query(c, id), Ok(terminal)); assert_guest_query(&mut s, id, if publication { 3 } else { 2 }, 15); s.release_request(c, id).unwrap(); } assert!(s.unsaved()); assert!(s.host_faulted()); assert_eq!(s.commit(c, 0, 7, admitted, &lane), Err(Error::ReadOnly)); } else { let expected = if fail_publication { RequestState::Indeterminate } else if publication { RequestState::Success } else { RequestState::Failure }; assert_eq!(s.query(c, id).unwrap().state, expected); assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Timeout); assert_guest_query( &mut s, id, if fail_publication { 3 } else if publication { 1 } else { 2 }, 15, ); assert_eq!( s.request_storage_error(c, id), Ok(if fail_publication { Some(Error::Io(MemcardIoError::IoError)) } else if publication { None } else { Some(Error::Canceled) }) ); assert_eq!(s.unsaved(), expected != RequestState::Success); assert_eq!(s.removal_pending(), fail_publication); assert!(!s.host_faulted()); s.release_request(c, id).unwrap(); } let mut durable = reboot(&disk); let mut bytes = [0; 7]; let n = durable.read_slot(0, &mut bytes).unwrap(); if publication && !fail_publication { assert_eq!(&bytes[..n], b"pending"); } else { assert_eq!(n, 0); } } } #[cfg(unix)] #[test] fn file_backend_allocates_full_image_and_reopens_verified_save_without_replacing_files() { use prometeu_drivers::memcard::FileMemcard; use std::os::unix::fs::MetadataExt; let root = std::env::temp_dir().join(format!( "prometeu-memcard-{}-{}", std::process::id(), std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() )); std::fs::create_dir(&root).unwrap(); let path = root.join("card.pmc"); let file = FileMemcard::create(&path, IMAGE_BYTES, |io, id| { Card::format(io, id).map_err(|_| MemcardIoError::IoError) }) .unwrap(); let metadata = std::fs::metadata(&path).unwrap(); assert_eq!(metadata.len(), IMAGE_BYTES); assert!(metadata.blocks() * 512 >= IMAGE_BYTES); let mut card = Card::mount(Box::new(file)).unwrap(); add(&mut card, 1, 1); assert_eq!( card.commit(0, &vec![17; SLOT_BYTES], 5, &PublicationControl::default()).durable, DurableResult::Success ); drop(card); assert!(FileMemcard::create(&path, IMAGE_BYTES, |_, _| Ok(())).is_err()); let mut card = Card::mount(Box::new(FileMemcard::open(&path, true).unwrap())).unwrap(); let mut out = vec![0; SLOT_BYTES]; assert_eq!(card.read_slot(0, &mut out), Ok(SLOT_BYTES)); assert!(out.iter().all(|&b| b == 17)); assert_eq!( card.commit(0, b"no", 6, &PublicationControl::default()).error, Some(Error::ReadOnly) ); drop(card); std::fs::remove_file(path).unwrap(); std::fs::remove_dir(root).unwrap(); } #[test] fn boot_commit_waits_for_ready_and_publishes_registration_before_payload() { use crate::services::async_work::{ AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController, }; use crate::services::memcard::session::{RequestState, Session}; use std::time::{Duration, Instant}; let (card, d) = formatted(); let mut s = Session::default(); let budget = Session::required_bytes(2).unwrap(); let c = s.prepare_new_card(card, 9, 2, 123, budget).unwrap(); let icon = [0; 560]; s.set_presentation(c, "new game", 2, 1, 1, &icon, 124).unwrap(); s.write(c, 0, 0, b"boot save").unwrap(); let lane = Arc::new(AsyncWorkLane::default()); let now = Instant::now(); let id = s.commit(c, 0, 124, now, &lane).unwrap(); assert_eq!(lane.pending_depth(), 0); assert_eq!(s.query(c, id).unwrap().state, RequestState::Pending); assert!(reboot(&d).catalog.games.is_empty()); s.finish_boot(true, &lane, now).unwrap(); assert_eq!(lane.pending_depth(), 1); let mut controller = AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane); let deadline = Instant::now() + Duration::from_secs(2); while s.query(c, id).unwrap().state == RequestState::Pending { assert!(Instant::now() < deadline); s.poll(Instant::now()); std::thread::yield_now(); } assert_eq!(s.query(c, id).unwrap().state, RequestState::Success); assert!(!s.boot_pending()); assert_eq!(s.boot_error(), None); controller.stop().unwrap(); let mut card = reboot(&d); assert_eq!(card.catalog.games[0].created_at, 123); let mut b = [0; 16]; let n = card.read_slot(0, &mut b).unwrap(); assert_eq!(&b[..n], b"boot save"); } #[test] fn explicit_revalidation_preserves_exclusions_until_separate_reintegration() { let (mut card, disk) = formatted(); add(&mut card, 8, 1); card.quarantine(67, &PublicationControl::default()).unwrap(); card.write_blocked = true; card.revalidate(&PublicationControl::default()).unwrap(); assert!(!card.write_blocked); assert!(card.current().quarantine[67]); let mut mounted = reboot(&disk); assert!(mounted.current().quarantine[67]); mounted.reintegrate(67, &PublicationControl::default()).unwrap(); assert!(!reboot(&disk).current().quarantine[67]); } #[test] fn reinsertion_retains_ram_and_different_card_requires_explicit_load() { use crate::memcard::session::Session; let (mut card, source_disk) = formatted(); add(&mut card, 9, 1); card.commit(0, b"on disk", 20, &PublicationControl::default()); let mut session = Session::default(); let context = session.load_card(card, 9, 1, 1024 * 1024).unwrap(); session.clear(context, 0).unwrap(); session.write(context, 0, 0, b"local").unwrap(); session .replace_storage(Box::new(Store(source_disk)), true, &PublicationControl::default()) .unwrap(); let mut bytes = [0; 7]; assert_eq!(session.read(context, 0, 0, &mut bytes).unwrap(), 5); assert_eq!(&bytes[..5], b"local"); assert!(session.unsaved()); let other = disk(); Card::format(&mut Store(other.clone()), [8; 16]).unwrap(); let mut target = Card::mount(Box::new(Store(other.clone()))).unwrap(); add(&mut target, 9, 1); target.commit(0, b"remote", 30, &PublicationControl::default()); drop(target); session.replace_storage(Box::new(Store(other)), true, &PublicationControl::default()).unwrap(); assert_eq!(session.read(context, 0, 0, &mut bytes).unwrap(), 6); assert_eq!(&bytes[..6], b"remote"); assert!(!session.unsaved()); } #[test] #[ignore = "manual file-host latency qualification; prints measurements for this host"] fn qualify_file_commits_with_production_asset_decoder() { use crate::memcard::session::{RequestState, Session}; use crate::{AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController}; use prometeu_drivers::{AssetManager, MemoryBanks, memcard::FileMemcard}; use prometeu_hal::{ AssetBridge, asset::{AssetCodec, AssetEntry, BankType}, cartridge::AssetsPayloadSource, }; use std::time::{Duration, Instant}; let path = std::env::temp_dir() .join(format!("prometeu-memcard-qualification-{}.pmc", std::process::id())); let file = FileMemcard::create(&path, IMAGE_BYTES, |io, id| { Card::format(io, id).map_err(|_| MemcardIoError::IoError) }) .unwrap(); struct Timed { file: FileMemcard, first: Arc>>, } impl MemcardStorage for Timed { fn len(&self) -> std::result::Result { self.file.len() } fn read_only(&self) -> bool { false } fn read_at(&mut self, o: u64, b: &mut [u8]) -> std::result::Result<(), MemcardIoError> { self.file.read_at(o, b) } fn write_at(&mut self, o: u64, b: &[u8]) -> std::result::Result<(), MemcardIoError> { self.first.lock().unwrap().get_or_insert_with(Instant::now); self.file.write_at(o, b) } fn sync(&mut self) -> std::result::Result<(), MemcardIoError> { self.file.sync() } } let first = Arc::new(Mutex::new(None)); let mut card = Card::mount(Box::new(Timed { file, first: first.clone() })).unwrap(); add(&mut card, 1, 1); let mut session = Session::default(); let context = session.load_card(card, 1, 1, 1024 * 1024).unwrap(); for offset in (0..SLOT_BYTES).step_by(4096) { session.write(context, 0, offset, &[0xa5; 4096]).unwrap(); } let lane = Arc::new(AsyncWorkLane::default()); let banks = Arc::new(MemoryBanks::new()); let mut assets = vec![0x12; 512 * 512 / 2]; assets.extend([255; 64]); let entries=(1..=20).map(|id|AssetEntry{asset_id:id,asset_name:format!("glyph-{id}"),bank_type:BankType::GLYPH, codec:AssetCodec::None,offset:0,size:assets.len() as u64,decoded_size:512*512+64, metadata:serde_json::json!({"tile_size":8,"width":512,"height":512,"palette_count":1,"palette_authored":1})}).collect(); let mut manager = AssetManager::new( entries, AssetsPayloadSource::from_bytes(assets), banks.clone(), banks.clone(), banks, ); assert!(manager.bind_background_work(lane.clone())); let mut controller = AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone()); let mut times = vec![]; let mut starts = vec![]; for sample in 1..=20 { let asset = manager.load(sample, 0).unwrap(); let asset_deadline = Instant::now() + Duration::from_secs(1); while matches!( manager.status(asset), prometeu_hal::asset::LoadStatus::QUEUED | prometeu_hal::asset::LoadStatus::PENDING ) { assert!(Instant::now() < asset_deadline); std::thread::yield_now(); } *first.lock().unwrap() = None; let start = Instant::now(); let request = session.commit(context, 0, sample as u64, start, &lane).unwrap(); loop { session.poll(Instant::now()); if session.query(context, request).unwrap().state != RequestState::Pending { break; } assert!(start.elapsed() < Duration::from_secs(2)); std::thread::yield_now(); } assert_eq!(session.query(context, request).unwrap().state, RequestState::Success); times.push(start.elapsed().as_micros()); starts.push(first.lock().unwrap().unwrap().duration_since(start).as_micros()); session.release_request(context, request).unwrap(); } times.sort(); starts.sort(); eprintln!( "file-host admission-to-first-IO: p50={}us p95={}us max={}us", starts[10], starts[18], starts[19] ); eprintln!( "file-host 64KiB commit + production asset load: samples={} p50={}us p95={}us max={}us", times.len(), times[10], times[18], times[19] ); controller.stop().unwrap(); drop(session); std::fs::remove_file(path).unwrap(); } #[test] fn full_card_admission_preserves_card_and_memory_only_can_extend_existing_data() { use crate::memcard::{ MemcardService, admission::{Choice, PreparationState}, session::Mode, }; use crate::{AsyncWorkLaneConfig, AsyncWorkLaneController}; use std::time::{Duration, Instant}; let (mut card, _) = formatted(); add(&mut card, 1, 1); add(&mut card, 2, 63); card.commit(0, b"prior", 10, &PublicationControl::default()); let mut service = MemcardService::new(); let mut controller = AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), service.lane.clone()); service.mount_card(card.into_storage()).unwrap(); let wait = |service: &mut MemcardService| { let deadline = Instant::now() + Duration::from_secs(2); while service.admission.state == PreparationState::Pending { service.poll(Instant::now()); assert!(Instant::now() < deadline); std::thread::yield_now(); } }; wait(&mut service); assert_eq!(service.admission.state, PreparationState::Ready); assert_eq!(service.choose_for_game(1, 2, Choice::Persistent, 12), Err(Error::NoSpace)); assert!(service.card_installed()); service.choose_for_game(1, 2, Choice::MemoryExisting, 12).unwrap(); wait(&mut service); assert_eq!(service.admission.state, PreparationState::Ready); let s = &mut service.session; let c = s.context(); assert_eq!(s.mode(), Some(Mode::MemoryOnly)); let mut bytes = [9; 5]; assert_eq!(s.read(c, 0, 0, &mut bytes).unwrap(), 5); assert_eq!(&bytes, b"prior"); assert_eq!(s.read(c, 1, 0, &mut bytes).unwrap(), 0); s.end_session(); service.poll(Instant::now()); assert!(service.card_installed()); controller.stop().unwrap(); } #[test] fn ending_a_session_releases_a_completed_unconsumed_request() { use crate::memcard::session::{RequestState, Session}; use crate::{AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController}; use std::time::{Duration, Instant}; let (mut card, _) = formatted(); add(&mut card, 1, 1); let mut s = Session::default(); let c = s.load_card(card, 1, 1, 1024 * 1024).unwrap(); s.write(c, 0, 0, b"saved").unwrap(); let lane = Arc::new(AsyncWorkLane::default()); let mut controller = AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone()); let start = Instant::now(); let id = s.commit(c, 0, 1, start, &lane).unwrap(); while s.query(c, id).unwrap().state == RequestState::Pending { s.poll(Instant::now()); assert!(start.elapsed() < Duration::from_secs(2)); std::thread::yield_now(); } s.end_session(); assert!(!s.has_in_flight()); assert!(s.take_idle_card().unwrap().is_some()); controller.stop().unwrap(); } #[test] fn persistent_save_preempts_real_multichunk_asset_decoders() { use crate::memcard::session::{RequestState, Session}; use crate::{AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController}; use prometeu_drivers::{ AssetManager, GlyphBankPoolAccess, MemoryBanks, SceneBankPoolAccess, SoundBankPoolAccess, }; use prometeu_hal::{ AssetBridge, asset::{AssetCodec, AssetEntry, AssetOpStatus, BankType, LoadStatus}, background_work::{AssetWork, BackgroundWork, WorkUnavailable}, cartridge::AssetsPayloadSource, }; use std::{ sync::mpsc, thread, time::{Duration, Instant}, }; type Events = Arc>>; struct ObservedLane { lane: Arc, events: Events, paused: mpsc::Sender<()>, resume: Mutex>>, } impl BackgroundWork for ObservedLane { fn submit_asset(&self, mut work: AssetWork) -> std::result::Result<(), WorkUnavailable> { let events = self.events.clone(); let paused = self.paused.clone(); let resume = self.resume.lock().unwrap().take().unwrap(); let mut step = 0; self.lane.submit_asset(Box::new(move |canceled| { let result = work(canceled); step += 1; events.lock().unwrap().push(("asset", thread::current().id())); if step == 4 { paused.send(()).unwrap(); resume.recv_timeout(Duration::from_secs(10)).unwrap(); } result })) } } struct ObservedStore { inner: Store, events: Events, } impl MemcardStorage for ObservedStore { fn len(&self) -> std::result::Result { self.inner.len() } fn read_only(&self) -> bool { false } fn read_at( &mut self, offset: u64, out: &mut [u8], ) -> std::result::Result<(), MemcardIoError> { self.inner.read_at(offset, out) } fn write_at( &mut self, offset: u64, bytes: &[u8], ) -> std::result::Result<(), MemcardIoError> { self.events.lock().unwrap().push(("save write", thread::current().id())); self.inner.write_at(offset, bytes) } fn sync(&mut self) -> std::result::Result<(), MemcardIoError> { self.events.lock().unwrap().push(("save sync", thread::current().id())); self.inner.sync() } } for kind in [BankType::GLYPH, BankType::SOUNDS, BankType::SCENE] { let (card, disk) = formatted(); drop(card); let events: Events = Arc::default(); let mut card = Card::mount(Box::new(ObservedStore { inner: Store(disk.clone()), events: events.clone(), })) .unwrap(); add(&mut card, 1, 1); let mut session = Session::default(); let context = session.load_card(card, 1, 1, 1024 * 1024).unwrap(); session.write(context, 0, 0, b"persistent under asset pressure").unwrap(); events.lock().unwrap().clear(); let (bytes, decoded_size, metadata) = match kind { BankType::GLYPH => { let mut bytes = vec![0x12; 16384]; bytes.extend([255; 64]); ( bytes, 32768 + 64, serde_json::json!({"tile_size":8,"width":256,"height":128,"palette_count":1,"palette_authored":1}), ) } BankType::SOUNDS => { (vec![0x12; 16385], 16385, serde_json::json!({"sample_rate":44100,"channels":1})) } BankType::SCENE => { let mut bytes = vec![0; 140]; bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]); for start in [12, 44, 76, 108] { bytes[start + 5] = 8; } bytes[12] = 1; bytes[28..32].copy_from_slice(&4097_u32.to_le_bytes()); bytes[32..36].copy_from_slice(&1_u32.to_le_bytes()); bytes[36..40].copy_from_slice(&4097_u32.to_le_bytes()); bytes.splice(44..44, std::iter::repeat_n([7, 3, 0x34, 0x12], 4097).flatten()); ( bytes, 64 + 4097 * size_of::() as u64, serde_json::json!({}), ) } }; let entry = AssetEntry { asset_id: 1, asset_name: "pressure".into(), bank_type: kind, offset: 0, size: bytes.len() as u64, decoded_size, codec: AssetCodec::None, metadata, }; let banks = Arc::new(MemoryBanks::new()); let mut manager = AssetManager::new( vec![entry], AssetsPayloadSource::from_bytes(bytes), banks.clone(), banks.clone(), banks.clone(), ); let lane = Arc::new(AsyncWorkLane::default()); let (paused_tx, paused_rx) = mpsc::channel(); let (resume_tx, resume_rx) = mpsc::channel(); let observed = Arc::new(ObservedLane { lane: lane.clone(), events: events.clone(), paused: paused_tx, resume: Mutex::new(Some(resume_rx)), }); assert!(manager.bind_background_work(observed)); let mut controller = AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone()); let handle = manager.load(1, 0).unwrap(); paused_rx.recv_timeout(Duration::from_secs(10)).unwrap(); assert_eq!(manager.status(handle), LoadStatus::LOADING); assert!( banks.glyph_bank_slot(0).is_none() && banks.sound_bank_slot(0).is_none() && banks.scene_bank_slot(0).is_none() ); let request = session.commit(context, 0, 7, Instant::now(), &lane).unwrap(); resume_tx.send(()).unwrap(); let deadline = Instant::now() + Duration::from_secs(10); loop { session.poll(Instant::now()); if session.query(context, request).unwrap().state != RequestState::Pending && manager.status(handle) == LoadStatus::READY { break; } assert!(Instant::now() < deadline, "save/asset did not complete for {kind:?}"); thread::yield_now(); } assert_eq!(session.query(context, request).unwrap().state, RequestState::Success); assert!( banks.glyph_bank_slot(0).is_none() && banks.sound_bank_slot(0).is_none() && banks.scene_bank_slot(0).is_none() ); assert_eq!(manager.commit(handle), AssetOpStatus::Ok); manager.apply_commits(); match kind { BankType::GLYPH => { let bank = banks.glyph_bank_slot(0).unwrap(); assert_eq!((bank.width, bank.height), (256, 128)); assert_eq!( bank.pixel_indices, (0..32768).map(|i| 1 + (i % 2) as u8).collect::>() ); assert!(bank.palettes[0].iter().all(|c| c.raw() == 0xffffffff)); } BankType::SOUNDS => { let bank = banks.sound_bank_slot(0).unwrap(); assert_eq!(bank.samples[0].sample_rate, 44100); assert_eq!(bank.samples[0].data, vec![0x1212; 8192]); } BankType::SCENE => { let bank = banks.scene_bank_slot(0).unwrap(); assert_eq!( (bank.layers[0].tilemap.width, bank.layers[0].tilemap.height), (4097, 1) ); assert!(bank.layers[0].active); assert_eq!(bank.layers[0].tilemap.tiles.len(), 4097); assert!(bank.layers[0].tilemap.tiles.iter().all(|t| t.active && t.flip_x && t.flip_y && t.glyph.glyph_id == 0x1234 && t.glyph.palette_id == 3)); assert!(bank.layers[1..].iter().all(|l| l.tilemap.tiles.is_empty())); } } controller.stop().unwrap(); let observed = events.lock().unwrap(); assert_eq!(observed[..4].iter().map(|e| e.0).collect::>(), vec!["asset"; 4]); assert_eq!(observed[4].0, "save write"); let resumed = observed[4..].iter().position(|e| e.0 == "asset").unwrap() + 4; assert_eq!(observed[resumed - 1].0, "save sync"); assert!(observed[resumed..].iter().all(|e| e.0 == "asset")); let worker = observed[0].1; assert_ne!(worker, thread::current().id()); assert!(observed.iter().all(|e| e.1 == worker)); drop(observed); drop(session); let mut recovered = Session::default(); let c = recovered.load_card(reboot(&disk), 1, 1, 1024 * 1024).unwrap(); let mut saved = [0; 64]; let n = recovered.read(c, 0, 0, &mut saved).unwrap(); assert_eq!(&saved[..n], b"persistent under asset pressure"); } }