Files
prometeu-runtime/crates/console/prometeu-system/src/services/memcard/transaction/tests.rs
T

1117 lines
43 KiB
Rust

use super::*;
use prometeu_hal::memcard::MemcardIoError;
use std::sync::{Arc, Mutex};
#[derive(Clone)]
struct Disk {
volatile: Vec<u8>,
durable: Vec<u8>,
calls: usize,
fail: Option<usize>,
sync_then_fail: bool,
}
struct Store(Arc<Mutex<Disk>>);
impl MemcardStorage for Store {
fn len(&self) -> std::result::Result<u64, MemcardIoError> {
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<Mutex<Disk>> {
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<Mutex<Disk>>) {
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<Mutex<Disk>>) -> 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<crate::AsyncWorkLane>) {
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<Arc<str>, 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<dyn MemcardStorage>,
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<u64, MemcardIoError> {
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<Mutex<Option<Instant>>>,
}
impl MemcardStorage for Timed {
fn len(&self) -> std::result::Result<u64, MemcardIoError> {
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<Mutex<Vec<(&'static str, thread::ThreadId)>>>;
struct ObservedLane {
lane: Arc<AsyncWorkLane>,
events: Events,
paused: mpsc::Sender<()>,
resume: Mutex<Option<mpsc::Receiver<()>>>,
}
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<u64, MemcardIoError> {
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::<prometeu_hal::tile::Tile>() 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::<Vec<_>>()
);
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<_>>(), 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");
}
}