mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
add a memory stress tester
This commit is contained in:
parent
2c6ba2f127
commit
d846c5ad0e
2 changed files with 205 additions and 0 deletions
|
|
@ -95,6 +95,7 @@ mod aes; use aes::*;
|
|||
mod trng_cmd; use trng_cmd::*;
|
||||
mod engine; use engine::*;
|
||||
mod console; use console::*;
|
||||
mod memtest; use memtest::*;
|
||||
|
||||
//mod fcc; use fcc::*;
|
||||
//mod pds; // dependency of the FCC file
|
||||
|
|
@ -117,6 +118,7 @@ pub struct CmdEnv {
|
|||
aes_cmd: Aes,
|
||||
trng_cmd: TrngCmd,
|
||||
engine_cmd: Engine,
|
||||
memtest_cmd: Memtest,
|
||||
|
||||
//fcc_cmd: Fcc,
|
||||
}
|
||||
|
|
@ -137,6 +139,7 @@ impl CmdEnv {
|
|||
let aes = Aes::new(&xns, &mut common);
|
||||
let ecup = EcUpdate::new(&mut common);
|
||||
let engine = Engine::new(&xns, &mut common);
|
||||
let memtest = Memtest::new(&xns, &mut common);
|
||||
|
||||
// print our version info
|
||||
let (maj, min, rev, extra, gitrev) = common.llio.soc_gitrev().unwrap();
|
||||
|
|
@ -165,6 +168,7 @@ impl CmdEnv {
|
|||
aes_cmd: aes,
|
||||
trng_cmd: TrngCmd::new(),
|
||||
engine_cmd: engine,
|
||||
memtest_cmd: memtest,
|
||||
|
||||
//fcc_cmd: fcc,
|
||||
}
|
||||
|
|
@ -198,6 +202,7 @@ impl CmdEnv {
|
|||
&mut self.trng_cmd,
|
||||
&mut self.engine_cmd,
|
||||
&mut console_cmd,
|
||||
&mut self.memtest_cmd,
|
||||
|
||||
//&mut self.fcc_cmd,
|
||||
];
|
||||
|
|
|
|||
200
services/shellchat/src/cmds/memtest.rs
Normal file
200
services/shellchat/src/cmds/memtest.rs
Normal file
|
|
@ -0,0 +1,200 @@
|
|||
use crate::{ShellCmdApi, CommonEnv};
|
||||
use xous_ipc::String;
|
||||
use num_traits::*;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Memtest {
|
||||
memtest_cid: xous::CID,
|
||||
start_time: Option<u64>,
|
||||
}
|
||||
impl Memtest {
|
||||
pub fn new(_xns: &xous_names::XousNames, env: &mut CommonEnv) -> Self {
|
||||
let sid = xous::create_server().unwrap();
|
||||
let sid_tuple = sid.to_u32();
|
||||
|
||||
let cb_id = env.register_handler(String::<256>::from_str("memtest"));
|
||||
CB_ID.store(cb_id, Ordering::Relaxed);
|
||||
|
||||
xous::create_thread_4(test_thread, sid_tuple.0 as usize, sid_tuple.1 as usize, sid_tuple.2 as usize, sid_tuple.3 as usize).unwrap();
|
||||
|
||||
Memtest {
|
||||
memtest_cid: xous::connect(sid).unwrap(),
|
||||
start_time: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
use core::sync::atomic::{AtomicU32, Ordering};
|
||||
static CB_ID: AtomicU32 = AtomicU32::new(0);
|
||||
|
||||
|
||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||
pub(crate) enum TestOp {
|
||||
StartBasic,
|
||||
Quit,
|
||||
}
|
||||
|
||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||
pub(crate) enum TestResult {
|
||||
EngineDone,
|
||||
DhDone,
|
||||
}
|
||||
|
||||
pub fn test_thread(sid0: usize, sid1: usize, sid2: usize, sid3: usize) {
|
||||
let sid = xous::SID::from_u32(sid0 as u32, sid1 as u32, sid2 as u32, sid3 as u32);
|
||||
let xns = xous_names::XousNames::new().unwrap();
|
||||
let callback_conn = xns.request_connection_blocking(crate::SERVER_NAME_SHELLCHAT).unwrap();
|
||||
|
||||
let trng = trng::Trng::new(&xns).unwrap();
|
||||
|
||||
loop {
|
||||
let msg = xous::receive_message(sid).unwrap();
|
||||
log::debug!("memtest got msg {:?}", msg);
|
||||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(TestOp::StartBasic) => xous::msg_scalar_unpack!(msg, iters, _, _, _, {
|
||||
let testsrc = xous::syscall::map_memory(
|
||||
None,
|
||||
None,
|
||||
256 * 1024, // min 128k so we are working through the L2 cache
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W | xous::MemoryFlags::RESERVE,
|
||||
).expect("couldn't allocate RAM for testing");
|
||||
let testdst = xous::syscall::map_memory(
|
||||
None,
|
||||
None,
|
||||
256 * 1024,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W | xous::MemoryFlags::RESERVE,
|
||||
).expect("couldn't allocate RAM for testing");
|
||||
|
||||
let testsrc_slice: &mut [u32] = testsrc.as_slice_mut();
|
||||
let testdst_slice: &mut [u32] = testdst.as_slice_mut();
|
||||
let chunks_page = testsrc_slice.chunks_exact_mut(1024);
|
||||
for buf in chunks_page.into_iter() {
|
||||
let mut incoming: [u32; 1024] = [0; 1024];
|
||||
trng.fill_buf(&mut incoming).unwrap();
|
||||
for (&src, dst) in incoming.iter().zip(buf.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
}
|
||||
|
||||
let mut errs = 0;
|
||||
let mut dummy = 0; // this prevents things from being optimized out
|
||||
for i in 0..iters {
|
||||
// pick two random offsets to report data, just to make sure the test is going as expected
|
||||
let c1 = trng.get_u32().unwrap() & ((256 * 1024 / 4) - 1);
|
||||
let c2 = trng.get_u32().unwrap() & ((256 * 1024 / 4) - 1);
|
||||
log::info!("starting memory test iter {}", i);
|
||||
// copy random data into destination
|
||||
for (&src, dst) in testsrc_slice.iter().zip(testdst_slice.iter_mut()) {
|
||||
*dst = src;
|
||||
dummy += *dst;
|
||||
}
|
||||
// compare random data once
|
||||
let mut offset = 0;
|
||||
for (&src, &dst) in testsrc_slice.iter().zip(testdst_slice.iter()) {
|
||||
dummy += dst;
|
||||
if dst != src {
|
||||
dummy += src;
|
||||
log::error!("* {:<4} | 0x{:08x}: e:0x{:08x} o:0x{:08x}", i, offset * 4, src, dst);
|
||||
errs += 1;
|
||||
}
|
||||
if offset == c1 {
|
||||
log::info!(" {:<4} | 0x{:08x}: e:0x{:08x} o:0x{:08x}", i, offset * 4, src, dst);
|
||||
}
|
||||
offset += 1;
|
||||
}
|
||||
// compare random data twice -- if read error, error locs will differ; if write error, errors locs are identical
|
||||
offset = 0;
|
||||
for (&src, &dst) in testsrc_slice.iter().zip(testdst_slice.iter()) {
|
||||
dummy += src;
|
||||
if dst != src {
|
||||
dummy += dst;
|
||||
log::error!("* {:<4} | 0x{:08x}: e:0x{:08x} o:0x{:08x}", i, offset * 4, src, dst);
|
||||
errs += 1;
|
||||
}
|
||||
if offset == c2 {
|
||||
log::info!(" {:<4} | 0x{:08x}: e:0x{:08x} o:0x{:08x}", i, offset * 4, src, dst);
|
||||
}
|
||||
offset += 1;
|
||||
}
|
||||
// reseed
|
||||
let reseed = trng.get_u32().unwrap();
|
||||
for dat in testsrc_slice.iter_mut() {
|
||||
*dat = *dat ^ reseed;
|
||||
dummy += *dat;
|
||||
}
|
||||
}
|
||||
log::info!("test completed, {} errors", errs);
|
||||
|
||||
xous::syscall::unmap_memory(testsrc).expect("couldn't de-allocate test region");
|
||||
xous::syscall::unmap_memory(testdst).expect("couldn't de-allocate test region");
|
||||
|
||||
xous::send_message(callback_conn,
|
||||
xous::Message::new_scalar(CB_ID.load(Ordering::Relaxed) as usize,
|
||||
errs as usize, iters as usize, dummy as usize, 0,)
|
||||
).unwrap();
|
||||
}),
|
||||
Some(TestOp::Quit) => {
|
||||
log::info!("quitting memtest thread");
|
||||
break;
|
||||
},
|
||||
None => {
|
||||
log::error!("received unknown opcode");
|
||||
}
|
||||
}
|
||||
}
|
||||
xous::destroy_server(sid).unwrap();
|
||||
}
|
||||
|
||||
impl<'a> ShellCmdApi<'a> for Memtest {
|
||||
cmd_api!(memtest); // inserts boilerplate for command API
|
||||
|
||||
fn process(&mut self, args: String::<1024>, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
|
||||
use core::fmt::Write;
|
||||
let mut ret = String::<1024>::new();
|
||||
let helpstring = "memest [test [iters]]";
|
||||
|
||||
let mut tokens = args.as_str().unwrap().split(' ');
|
||||
|
||||
if let Some(sub_cmd) = tokens.next() {
|
||||
match sub_cmd {
|
||||
"test" => {
|
||||
let iters = if let Some(iter_str) = tokens.next() {
|
||||
match iter_str.parse::<u32>() {
|
||||
Ok(i) => i,
|
||||
Err(_) => 10,
|
||||
}
|
||||
} else {
|
||||
10
|
||||
};
|
||||
let start = env.ticktimer.elapsed_ms();
|
||||
self.start_time = Some(start);
|
||||
xous::send_message(self.memtest_cid,
|
||||
xous::Message::new_scalar(TestOp::StartBasic.to_usize().unwrap(), iters as usize, 0, 0, 0)
|
||||
).unwrap();
|
||||
write!(ret, "Starting memtest with {} iters", iters).unwrap();
|
||||
}
|
||||
_ => {
|
||||
write!(ret, "{}", helpstring).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
write!(ret, "{}", helpstring).unwrap();
|
||||
}
|
||||
Ok(Some(ret))
|
||||
}
|
||||
|
||||
fn callback(&mut self, msg: &xous::MessageEnvelope, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
|
||||
use core::fmt::Write;
|
||||
|
||||
let mut ret = String::<1024>::new();
|
||||
|
||||
xous::msg_scalar_unpack!(msg, errs, iters, dummy, _, {
|
||||
let end = env.ticktimer.elapsed_ms();
|
||||
let elapsed: f64 = ((end - self.start_time.unwrap()) as f64) / iters as f64;
|
||||
write!(ret, "memtest finished: {} errs, {}ms/iter", errs, elapsed).unwrap();
|
||||
log::info!("dummy var: {}", dummy); // just make sure it's not optimized out for any reason!
|
||||
});
|
||||
Ok(Some(ret))
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue