diff --git a/services/shellchat/src/cmds.rs b/services/shellchat/src/cmds.rs index 0879be558..dbed16db6 100644 --- a/services/shellchat/src/cmds.rs +++ b/services/shellchat/src/cmds.rs @@ -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, ]; diff --git a/services/shellchat/src/cmds/memtest.rs b/services/shellchat/src/cmds/memtest.rs new file mode 100644 index 000000000..e3284fa4c --- /dev/null +++ b/services/shellchat/src/cmds/memtest.rs @@ -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, +} +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>, 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::() { + 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>, 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)) + } +}