use super::*;
use std::time::{Duration, Instant};
#[derive(Clone, Copy, PartialEq, Eq)]
enum GuestArchitecture {
Classic,
PowerPc,
}
impl GuestArchitecture {
fn selected(variable: &str) -> Self {
match std::env::var(variable).as_deref() {
Ok("68k") => Self::Classic,
Ok("ppc") | Err(std::env::VarError::NotPresent) => Self::PowerPc,
_ => panic!("{variable} must be 68k or ppc"),
}
}
fn name(self) -> &'static str {
if self == Self::PowerPc {
"ppc"
} else {
"68k"
}
}
fn powerpc(self) -> bool {
self == Self::PowerPc
}
#[cfg(feature = "test-support")]
fn targets(self) -> &'static [i16] {
if self.powerpc() {
&[2, 1, 11, 14, 4]
} else {
&[2, 1, 11, 14]
}
}
#[cfg(feature = "test-support")]
fn requires(self, category: usize) -> bool {
category < 3 || self.powerpc()
}
}
pub(super) fn presentation_fixture(text: bool) -> systemless::memory::CompactPresentation {
let mut frame = systemless::memory::CompactPresentation {
width: 640,
height: 480,
scale: 4,
..Default::default()
};
for y in 0..frame.height {
for x in 0..frame.width {
if text && y % 20 < 12 && x % 9 < 6 {
frame.cells.push(0x80000000 | frame.detail.len() as u32);
frame
.detail
.extend((0..16).map(|s| if (x + y + s) % 3 == 0 { 0xffffff } else { 0 }));
} else {
frame.cells.push(if y < 20 || x % 160 < 2 {
0xcccccc
} else {
0xffffff
});
}
}
}
frame
}
#[test]
#[ignore = "optimized offscreen rendering benchmark; run alone"]
fn benchmark_presenters() {
let reverse = std::env::var_os("SYSTEMLESS_BENCH_REVERSE").is_some();
for text in [false, true] {
for gpu in if reverse {
[true, false]
} else {
[false, true]
} {
if gpu {
wgpu_compact::tests::benchmark_wgpu_presentation(text);
} else {
#[cfg(target_os = "macos")]
metal_present::tests::benchmark_default_presentation(text);
}
}
}
}
fn thread_cpu_time() -> Duration {
#[cfg(any(target_os = "macos", target_os = "linux"))]
{
let mut stamp = libc::timespec {
tv_sec: 0,
tv_nsec: 0,
};
let result = unsafe { libc::clock_gettime(libc::CLOCK_THREAD_CPUTIME_ID, &mut stamp) };
assert_eq!(
result,
0,
"thread CPU clock failed: {}",
std::io::Error::last_os_error()
);
assert!(stamp.tv_sec >= 0 && (0..1_000_000_000).contains(&stamp.tv_nsec));
Duration::new(stamp.tv_sec as u64, stamp.tv_nsec as u32)
}
#[cfg(target_os = "windows")]
{
use windows::Win32::{
Foundation::FILETIME,
System::Threading::{GetCurrentThread, GetThreadTimes},
};
let (mut created, mut exited, mut kernel, mut user) = (
FILETIME::default(),
FILETIME::default(),
FILETIME::default(),
FILETIME::default(),
);
unsafe {
GetThreadTimes(
GetCurrentThread(),
&mut created,
&mut exited,
&mut kernel,
&mut user,
)
}
.expect("thread CPU clock failed");
let ticks = |t: FILETIME| (u64::from(t.dwHighDateTime) << 32) | u64::from(t.dwLowDateTime);
let ticks = ticks(kernel)
.checked_add(ticks(user))
.expect("thread CPU accounting overflow");
Duration::new(ticks / 10_000_000, ((ticks % 10_000_000) * 100) as u32)
}
#[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
panic!("thread CPU diagnostics are unsupported on this platform");
}
fn thread_cpu_clock_name() -> &'static str {
if cfg!(target_os = "windows") {
"GetThreadTimes(user+kernel)"
} else {
"CLOCK_THREAD_CPUTIME_ID"
}
}
fn frames(runner: &mut FixtureRunner, count: usize) -> usize {
let mut exhausted = 0;
for _ in 0..count {
exhausted += usize::from(headless_time::frame(runner, 0).budget_exhausted);
assert!(!runner.is_halted());
}
exhausted
}
fn page(runner: &mut FixtureRunner, number: i16) -> usize {
runner.push_mouse_down(10, 64);
let mut exhausted = frames(runner, 2);
let y = 27 + (number - 1) * 16;
runner.set_mouse_position(y, 150);
exhausted += frames(runner, 2);
runner.push_mouse_up(y, 150);
exhausted + frames(runner, 20)
}
fn image(runner: &FixtureRunner) -> Vec<u32> {
let dispatcher = runner.dispatcher();
let mut pixels = Vec::new();
systemless::display::render_screen_argb_with_gamma(
runner.bus(),
dispatcher.screen_mode,
&dispatcher.device_clut,
&dispatcher.device_gamma(),
&mut pixels,
);
pixels
}
pub(super) fn report(name: &str, backend: &str, samples: &mut [Duration]) {
eprintln!(
"[RENDER-SAMPLES] {}",
serde_json::json!({
"case": name, "backend": backend,
"samples_us": samples.iter().map(|sample| sample.as_secs_f64() * 1e6).collect::<Vec<_>>(),
})
);
samples.sort_unstable();
eprintln!(
"[RENDER-BENCH] case={name} backend={backend} n={} p50_us={:.1} p95_us={:.1}",
samples.len(),
samples[samples.len() / 2].as_secs_f64() * 1e6,
samples[(samples.len() * 95).div_ceil(100) - 1].as_secs_f64() * 1e6,
);
}
#[test]
#[ignore = "optimized rendering benchmark; run alone with --nocapture --test-threads=1"]
fn benchmark_guest_renderers() {
let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/toolbox-showcase/toolbox-showcase.sit");
let architecture = GuestArchitecture::selected("SYSTEMLESS_BENCH_ARCHITECTURE");
let count = std::env::var("SYSTEMLESS_BENCH_SAMPLES")
.map(|value| value.parse::<usize>().unwrap())
.unwrap_or(15);
assert!(count >= 3);
let selected = std::env::var("SYSTEMLESS_BENCH_GUEST_CASE").ok();
assert!(
selected
.as_deref()
.is_none_or(|name| { matches!(name, "ui" | "drawing" | "text" | "3d" | "sprites") }),
"unknown guest benchmark case"
);
assert!(
architecture.powerpc() || selected.as_deref() != Some("3d"),
"QD3D benchmark requires PPC"
);
eprintln!("[RENDER-ARCHITECTURE] {}", architecture.name());
let record_cpu = std::env::var_os("SYSTEMLESS_BENCH_THREAD_CPU").is_some();
if record_cpu {
let _ = thread_cpu_time();
}
for (name, target) in [
("ui", 2),
("drawing", 1),
("text", 11),
("3d", 4),
("sprites", 14),
] {
if target == 4 && !architecture.powerpc() {
continue;
}
if selected.as_deref().is_some_and(|selected| selected != name) {
continue;
}
let mut dispatch = None;
let mut runners = [false, true].map(|gpu| {
let mut runner = game::new_runner_with_configuration(true, 8);
runner.set_prefer_powerpc_executables(architecture.powerpc());
if gpu {
dispatch = Some(forced_gpu_guest::install_adaptive(&mut runner));
}
runner.set_app_start_time(0);
let app = game::load_game_from_path(&mut runner, &fixture).unwrap();
game::init_game(&mut runner, &app);
assert_eq!(
runner.is_powerpc_app(),
architecture.powerpc(),
"wrong benchmark architecture"
);
configure_realtime_execution_rate(&mut runner);
frames(&mut runner, 40);
runner
});
let dispatch = dispatch.unwrap();
let mut dispatch_samples = Vec::new();
let reverse = usize::from(std::env::var_os("SYSTEMLESS_BENCH_REVERSE").is_some());
let mut samples: [Vec<Duration>; 2] = std::array::from_fn(|_| Vec::new());
let mut cpu_samples: [Vec<Duration>; 2] = std::array::from_fn(|_| Vec::new());
for iteration in 0..count + 3 {
let order = if (iteration + reverse) % 2 == 0 {
[0, 1]
} else {
[1, 0]
};
for index in order {
let runner = &mut runners[index];
page(runner, if target == 1 { 2 } else { 1 });
let before: [usize; 4] = std::array::from_fn(|i| dispatch[i].get());
let cpu_start = record_cpu.then(thread_cpu_time);
let start = Instant::now();
let exhausted = page(runner, target);
let elapsed = start.elapsed();
let cpu_elapsed = cpu_start.map(|start| {
thread_cpu_time()
.checked_sub(start)
.expect("thread CPU clock moved backwards")
});
if iteration >= 3 && index == 1 {
dispatch_samples.push(std::array::from_fn::<_, 4, _>(|i| {
dispatch[i].get() - before[i]
}));
}
assert_eq!(
exhausted, 0,
"{name} redraw exhausted its guest work budget"
);
if iteration >= 3 {
samples[index].push(elapsed);
if let Some(cpu) = cpu_elapsed {
cpu_samples[index].push(cpu);
}
}
}
}
eprintln!(
"[RENDER-ORDER] {}",
serde_json::json!({
"case": name, "pairs": count,
"first_measured_backend": if (3 + reverse) % 2 == 0 { "default" } else { "gpu" },
})
);
eprintln!(
"[RENDER-DISPATCH] {}",
serde_json::json!({ "case": name, "requests": dispatch_samples })
);
let mut reference: Option<Vec<u32>> = None;
for (index, runner) in runners.iter().enumerate() {
let gpu = index == 1;
let pixels = image(runner);
if let Some(root) = std::env::var_os("SYSTEMLESS_BENCH_OUTPUT") {
let root = PathBuf::from(root);
std::fs::create_dir_all(&root).unwrap();
let mode = runner.dispatcher().screen_mode;
let rgb = pixels
.iter()
.flat_map(|pixel| [(pixel >> 16) as u8, (pixel >> 8) as u8, *pixel as u8])
.collect();
image::RgbImage::from_raw(mode.2.into(), mode.3.into(), rgb)
.unwrap()
.save(root.join(format!(
"{name}-{}.png",
if gpu { "gpu" } else { "default" }
)))
.unwrap();
}
if let Some(reference) = &reference {
let tolerance = if target == 4 { 8 } else { 0 };
assert_eq!(pixels.len(), reference.len());
assert!(
pixels.iter().zip(reference).all(|(&a, &b)| {
[0, 8, 16].into_iter().all(|shift| {
((a >> shift) & 255).abs_diff((b >> shift) & 255) <= tolerance
})
}),
"{name} GPU output differs from the default renderer"
);
} else {
reference = Some(pixels);
}
if record_cpu {
eprintln!(
"[RENDER-CPU-SAMPLES] {}",
serde_json::json!({
"case":name, "backend":if gpu {"gpu"} else {"default"},
"clock":thread_cpu_clock_name(),
"samples_us":cpu_samples[index].iter().map(|t|t.as_secs_f64()*1e6).collect::<Vec<_>>(),
})
);
}
report(
name,
if gpu { "gpu" } else { "default" },
&mut samples[index],
);
}
}
}
mod forced_gpu_guest {
use super::*;
use std::{
cell::{Cell, RefCell},
rc::Rc,
};
use systemless::loader::ppc::{PpcQ3GpuFrame, PpcQ3GpuRenderer, PpcQ3RasterFrame};
use systemless::quickdraw::gpu::*;
pub(super) type Counts = Rc<[Cell<usize>; 4]>;
pub(super) fn install_adaptive(runner: &mut FixtureRunner) -> Counts {
let calls: Counts = Rc::new(std::array::from_fn(|_| Cell::new(0)));
runner.set_quickdraw_gpu_renderer(Box::new(QuickDraw {
renderer: Rc::new(RefCell::new(wgpu_quickdraw::QuickDrawRenderer::new())),
calls: calls.clone(),
adaptive: true,
}));
runner.set_q3_gpu_renderer(Box::new(Qd3d {
renderer: Rc::new(RefCell::new(wgpu_qd3d::Qd3dRenderer::new())),
calls: calls.clone(),
adaptive: true,
}));
calls
}
fn checked<T>(result: Result<T, String>, calls: &Cell<usize>) -> Result<T, String> {
assert!(
result.is_ok(),
"guest GPU request failed: {:?}",
result.as_ref().err()
);
calls.set(calls.get() + 1);
result
}
struct QuickDraw {
renderer: Rc<RefCell<wgpu_quickdraw::QuickDrawRenderer>>,
calls: Counts,
adaptive: bool,
}
impl QuickDrawGpuRenderer for QuickDraw {
fn prefers_precomputed_raster(&self) -> bool {
!self.adaptive || self.renderer.borrow().prefers_precomputed_raster()
}
fn prefers_raster(&self, command: &QuickDrawGpuCommand) -> bool {
!self.adaptive || self.renderer.borrow().prefers_raster(command)
}
fn prefers_blit(&self, pixels: usize, expensive_color: bool) -> bool {
!self.adaptive || self.renderer.borrow().prefers_blit(pixels, expensive_color)
}
fn render(
&mut self,
command: &QuickDrawGpuCommand,
background: &[u32],
) -> Result<Vec<QuickDrawGpuPixel>, String> {
let result = checked(
self.renderer.borrow_mut().render(command, background),
&self.calls[0],
);
if command.mask.is_some() {
self.calls[1].set(self.calls[1].get() + 1);
}
result
}
fn render_blit(&mut self, command: &QuickDrawGpuBlit) -> Result<Vec<u32>, String> {
checked(
self.renderer.borrow_mut().render_blit(command),
&self.calls[0],
)
}
fn render_blit_cells(
&mut self,
command: &QuickDrawGpuBlit,
) -> Result<Vec<QuickDrawGpuPixel>, String> {
let result = checked(
self.renderer.borrow_mut().render_blit_cells(command),
&self.calls[0],
);
if command.deep_mask.is_some() {
self.calls[2].set(self.calls[2].get() + 1);
}
result
}
fn render_packed_blit(
&mut self,
command: &QuickDrawGpuPackedCopy,
) -> Result<Vec<u8>, String> {
checked(
self.renderer.borrow_mut().render_packed_blit(command),
&self.calls[0],
)
}
}
struct Qd3d {
renderer: Rc<RefCell<wgpu_qd3d::Qd3dRenderer>>,
calls: Counts,
adaptive: bool,
}
impl PpcQ3GpuRenderer for Qd3d {
fn prefers_native(&self, frame: &PpcQ3RasterFrame) -> bool {
!self.adaptive || self.renderer.borrow().prefers_native(frame)
}
fn render(
&mut self,
frame: &PpcQ3GpuFrame,
background: &[u16],
) -> Result<Vec<u16>, String> {
checked(
self.renderer.borrow_mut().render(frame, background),
&self.calls[3],
)
}
fn render_native(
&mut self,
frame: &PpcQ3RasterFrame,
background: &[u16],
) -> Result<Vec<u16>, String> {
checked(
self.renderer.borrow_mut().render_native(frame, background),
&self.calls[3],
)
}
fn render_indexed(
&mut self,
frame: &PpcQ3RasterFrame,
background: &[u16],
clut: &[[u16; 3]; 256],
) -> Result<Vec<u16>, String> {
checked(
self.renderer
.borrow_mut()
.render_indexed(frame, background, clut),
&self.calls[3],
)
}
}
#[test]
fn wgpu_guest_raster_writeback_matches_default() {
guest_raster_writeback_matches_default(true);
}
#[test]
fn wgpu_classic_guest_raster_writeback_matches_default() {
guest_raster_writeback_matches_default(false);
}
fn guest_raster_writeback_matches_default(powerpc: bool) {
let instance = wgpu::Instance::default();
let adapter = match pollster::block_on(instance.request_adapter(&Default::default())) {
Ok(adapter) => adapter,
Err(error) => {
assert!(
std::env::var_os("SYSTEMLESS_REQUIRE_GPU").is_none(),
"GPU required: {error}"
);
return;
}
};
if let Err(error) = wgpu_present::request_device(&adapter) {
assert!(
std::env::var_os("SYSTEMLESS_REQUIRE_GPU").is_none(),
"GPU required: {error}"
);
return;
}
let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/toolbox-showcase/toolbox-showcase.sit");
let calls: Counts = Rc::new(std::array::from_fn(|_| Cell::new(0)));
let mut reference = Vec::new();
for gpu in [false, true] {
let mut runner = game::new_runner_with_configuration(true, 8);
runner.set_prefer_powerpc_executables(powerpc);
if gpu {
runner.set_quickdraw_gpu_renderer(Box::new(QuickDraw {
renderer: Rc::new(RefCell::new(wgpu_quickdraw::QuickDrawRenderer::new())),
calls: calls.clone(),
adaptive: false,
}));
runner.set_q3_gpu_renderer(Box::new(Qd3d {
renderer: Rc::new(RefCell::new(wgpu_qd3d::Qd3dRenderer::new())),
calls: calls.clone(),
adaptive: false,
}));
}
runner.set_app_start_time(0);
let app = game::load_game_from_path(&mut runner, &fixture).unwrap();
game::init_game(&mut runner, &app);
assert_eq!(runner.is_powerpc_app(), powerpc);
configure_realtime_execution_rate(&mut runner);
frames(&mut runner, 40);
let targets: &[i16] = if powerpc {
&[2, 1, 11, 14, 4]
} else {
&[2, 1, 11, 14]
};
for (index, &target) in targets.iter().enumerate() {
page(&mut runner, target);
let pixels = image(&runner);
if gpu {
let expected: &Vec<u32> = &reference[index];
assert_eq!(pixels.len(), expected.len());
let tolerance = if target == 4 { 8 } else { 0 };
assert!(
pixels.iter().zip(expected).all(|(&a, &b)| {
[0, 8, 16].into_iter().all(|shift| {
((a >> shift) & 255).abs_diff((b >> shift) & 255) <= tolerance
})
}),
"forced GPU guest page {target} differs from default rendering"
);
} else {
reference.push(pixels);
}
}
}
for (index, kind) in ["QuickDraw", "glyph masks", "deep masks", "3D"]
.into_iter()
.enumerate()
{
if index == 3 && !powerpc {
assert_eq!(calls[index].get(), 0, "classic guest submitted native QD3D");
} else {
assert!(calls[index].get() > 0, "no successful {kind} GPU writeback");
}
}
}
#[cfg(feature = "test-support")]
#[test]
#[ignore = "explicit-duration active GPU qualification; run through soak-gpu-compute.py"]
fn qualify_gpu_compute_resources() {
use std::io::Write;
let architecture = GuestArchitecture::selected("SYSTEMLESS_GPU_COMPUTE_ARCHITECTURE");
let cpu_only = match std::env::var("SYSTEMLESS_GPU_COMPUTE_SOAK_CPU_ONLY").as_deref() {
Ok("1") => true,
Err(std::env::VarError::NotPresent) => false,
_ => panic!("invalid CPU baseline selector"),
};
let seconds: u64 = std::env::var("SYSTEMLESS_GPU_COMPUTE_SOAK_SECONDS")
.expect("set an explicit compute soak duration")
.parse()
.expect("compute soak seconds");
assert!((1..=21600).contains(&seconds));
let report = std::env::var_os("SYSTEMLESS_GPU_COMPUTE_SOAK_REPORT")
.expect("set a compute resource report path");
let mut report = std::io::BufWriter::new(std::fs::File::create(report).unwrap());
let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/toolbox-showcase/toolbox-showcase.sit");
let calls: Counts = Rc::new(std::array::from_fn(|_| Cell::new(0)));
let quickdraw = Rc::new(RefCell::new(wgpu_quickdraw::QuickDrawRenderer::new()));
let qd3d = Rc::new(RefCell::new(wgpu_qd3d::Qd3dRenderer::new()));
let mut runners = [false, true].map(|gpu| {
let mut runner = game::new_runner_with_configuration(true, 8);
runner.set_prefer_powerpc_executables(architecture.powerpc());
if gpu && !cpu_only {
runner.set_quickdraw_gpu_renderer(Box::new(QuickDraw {
renderer: quickdraw.clone(),
calls: calls.clone(),
adaptive: false,
}));
runner.set_q3_gpu_renderer(Box::new(Qd3d {
renderer: qd3d.clone(),
calls: calls.clone(),
adaptive: false,
}));
}
runner.set_app_start_time(0);
let app = game::load_game_from_path(&mut runner, &fixture).unwrap();
game::init_game(&mut runner, &app);
assert_eq!(runner.is_powerpc_app(), architecture.powerpc());
configure_realtime_execution_rate(&mut runner);
frames(&mut runner, 40);
runner
});
let sweep = |runners: &mut [FixtureRunner; 2]| {
for &target in architecture.targets() {
for runner in runners.iter_mut() {
assert_eq!(
page(runner, target),
0,
"compute soak exhausted guest work budget"
);
}
let expected = image(&runners[0]);
let actual = image(&runners[1]);
let tolerance = if target == 4 { 8 } else { 0 };
assert_eq!(expected.len(), actual.len());
assert!(
actual.iter().zip(expected).all(|(&a, b)| {
[0, 8, 16].into_iter().all(|shift| {
((a >> shift) & 255).abs_diff((b >> shift) & 255) <= tolerance
})
}),
"active GPU page {target} differs from CPU writeback"
);
}
};
sweep(&mut runners);
assert!(
calls
.iter()
.enumerate()
.all(|(i, count)| if cpu_only || !architecture.requires(i) {
count.get() == 0
} else {
count.get() > 0
}),
"missing GPU workload coverage"
);
let started = Instant::now();
let mut cycles = 0u64;
let mut sampled = Instant::now();
loop {
let finished = cycles > 0 && started.elapsed() >= Duration::from_secs(seconds);
if cycles == 0 || finished || sampled.elapsed() >= Duration::from_secs(30) {
let quickdraw_resources = (!cpu_only).then(|| {
quickdraw
.borrow()
.qualification_snapshot()
.expect("healthy QuickDraw GPU")
});
let qd3d_resources = (!cpu_only && architecture.powerpc()).then(|| {
qd3d.borrow()
.qualification_snapshot()
.expect("healthy QD3D GPU")
});
let sample = serde_json::json!({
"architecture": architecture.name(),
"workload": if cpu_only { "cpu-baseline" } else { "gpu" },
"seconds": started.elapsed().as_secs_f64(), "cycles": cycles,
"gpu_writebacks": calls.iter().map(Cell::get).collect::<Vec<_>>(),
"quickdraw": quickdraw_resources,
"qd3d": qd3d_resources,
"complete": finished,
});
writeln!(report, "{sample}").unwrap();
report.flush().unwrap();
sampled = Instant::now();
}
if finished {
break;
}
let before = std::array::from_fn::<_, 4, _>(|i| calls[i].get());
sweep(&mut runners);
assert!(
calls
.iter()
.zip(before)
.enumerate()
.all(
|(i, (count, old))| if cpu_only || !architecture.requires(i) {
count.get() == 0 && old == 0
} else {
count.get() > old
}
),
"a compute workload stopped reaching the GPU"
);
cycles += 1;
}
assert!(cycles > 0);
fn teardown<T>(stage: &str, value: T) {
eprintln!("[GPU-SOAK-TEARDOWN] {stage}:begin");
drop(value);
eprintln!("[GPU-SOAK-TEARDOWN] {stage}:end");
}
teardown("runners", runners);
teardown("qd3d", qd3d);
teardown("quickdraw", quickdraw);
teardown("report", report);
}
}