feat(runtime): implement shared transactional memcard with async saves
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
This commit is contained in:
@@ -0,0 +1,662 @@
|
||||
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();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blocked_host_timeout_release_keeps_source_and_prevents_replacement_work() {
|
||||
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,
|
||||
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();
|
||||
}
|
||||
self.store.write_at(o, b)
|
||||
}
|
||||
}
|
||||
for publication in [false, true] {
|
||||
let (mut card, _) = 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,
|
||||
}))
|
||||
.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));
|
||||
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());
|
||||
s.release_request(c, id).unwrap();
|
||||
assert_eq!(s.write(c, 0, 0, b"unsafe"), Err(Error::Busy));
|
||||
assert_eq!(s.commit(c, 0, 7, Instant::now(), &lane), Err(Error::Busy));
|
||||
rt.send(()).unwrap();
|
||||
controller.stop().unwrap();
|
||||
s.poll(Instant::now());
|
||||
assert!(s.unsaved());
|
||||
assert!(s.host_faulted());
|
||||
}
|
||||
}
|
||||
|
||||
#[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();
|
||||
}
|
||||
Reference in New Issue
Block a user