use std::process::ExitCode;
use et_abi::{CacheTestArgs, DeviceArgs, MINIONS_PER_SHIRE};
use et_soc1::{Device, DmaOptions, LaunchOptions};
const STAGING_BYTES: usize = 64 * 1024;
fn main() -> ExitCode {
match run() {
Ok(()) => ExitCode::SUCCESS,
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
fn run() -> et_soc1::Result<()> {
let kernel_path = std::env::args().nth(1).unwrap_or_else(|| {
eprintln!("usage: double_buffer <cache-test-rs.elf>");
std::process::exit(2);
});
let elf = std::fs::read(&kernel_path).map_err(|e| et_soc1::Error::io("read kernel ELF", e))?;
let device = Device::open(0)?;
let topo = device.topology()?;
let n_shires = topo.num_shires() as usize;
let n_minions = n_shires * MINIONS_PER_SHIRE as usize;
println!(
"Device: {} shires (mask {:#x}), {} Minions",
n_shires, topo.shire_mask, n_minions,
);
let kernel = device.load_kernel(&elf)?;
let out_a = device.alloc_padded::<u32>(n_minions)?;
let out_b = device.alloc_padded::<u32>(n_minions)?;
let staging = device.alloc(STAGING_BYTES as u64)?;
let staging_data = vec![0u8; STAGING_BYTES];
println!("\nPhase A: launch_async + wait_launch");
let args_a = CacheTestArgs {
output: out_a.addr(),
n_shires: n_shires as u64,
};
let opts_a = LaunchOptions::new(topo.shire_mask)
.without_barrier() .with_args(args_a.as_bytes().to_vec());
let pending_a = device.launch_async(&kernel, &opts_a)?;
println!(" kernel A fired (async, SQ 0)");
let _r = device.wait_launch(pending_a)?;
println!(" kernel A complete");
let results_a = device.download_padded(&out_a)?;
check("A", &results_a, n_minions)?;
println!("\nPhase B: kernel (SQ 0) overlapped with DMA (SQ 1)");
let args_b = CacheTestArgs {
output: out_b.addr(),
n_shires: n_shires as u64,
};
let opts_b = LaunchOptions::new(topo.shire_mask)
.with_args(args_b.as_bytes().to_vec());
let pending_b = device.launch_async(&kernel, &opts_b)?;
println!(" kernel B fired (async, SQ 0)");
device.memcpy_h2d_opts(&staging_data, staging.addr, &DmaOptions::new().on_sq(1))?;
println!(" {} KB staging DMA complete (SQ 1)", STAGING_BYTES / 1024);
let _r = device.wait_launch(pending_b)?;
println!(" kernel B complete");
let results_b = device.download_padded(&out_b)?;
check("B", &results_b, n_minions)?;
println!("\ndouble_buffer PASSED");
Ok(())
}
fn check(label: &str, results: &[u32], n_minions: usize) -> et_soc1::Result<()> {
let mut failures = 0_usize;
for (i, &val) in results.iter().enumerate() {
if val != i as u32 {
eprintln!(" FAIL out_{label}[{i}] = {val} (expected {i})");
failures += 1;
}
}
if failures == 0 {
println!(" output_{label}: all {n_minions} cells correct");
Ok(())
} else {
Err(et_soc1::Error::Protocol(format!(
"output_{label}: {failures}/{n_minions} cells incorrect"
)))
}
}