initial cut of test

This commit is contained in:
bunnie 2021-04-13 05:10:00 +08:00
parent 82dd9f2a91
commit 5a6956d6de
13 changed files with 222 additions and 200 deletions

2
Cargo.lock generated
View file

@ -168,6 +168,7 @@ checksum = "ae44d1a3d5a19df61dd0c8beb138458ac2a53a7ac09eba97d55592540004306b"
name = "cb-test-c1"
version = "0.1.0"
dependencies = [
"cb-test-srv",
"heapless",
"log",
"log-server",
@ -185,6 +186,7 @@ dependencies = [
name = "cb-test-c2"
version = "0.1.0"
dependencies = [
"cb-test-srv",
"heapless",
"log",
"log-server",

View file

@ -128,6 +128,8 @@ pub(crate) const MY_SERVER_NAME: &str = "_Example server_"; // the underscores a
Client state is held in an object defined in lib.rs.
```rust
#![cfg_attr(target_os = "none", no_std)]
pub mod api;
use api::{Callback, Opcode}; // if you prefer to map the api into your local namespace
use xous::{send_message, Error, CID, Message, msg_scalar_unpack};
use xous_ipc::{String, Buffer};
@ -287,6 +289,8 @@ a memory message with return value).
Note that all message types block the caller until they are returned.
```rust
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]
use num_traits::FromPrimitive;
use xous_ipc::{String, Buffer};
use api::Opcode;

View file

@ -13,6 +13,7 @@ ticktimer-server = { path = "../ticktimer-server" }
xous-names = { path = "../xous-names" }
log = "0.4"
xous-ipc = {path = "../../xous-ipc"}
cb-test-srv = {path = "../cb-test-srv"}
rkyv = {version = "0.4.3", default-features = false, features = ["const_generics"]}
num-derive = {version = "0.3", default-features = false}

View file

@ -1,8 +0,0 @@
pub(crate) const SERVER_NAME_TRNG: &str = "_Callback test client 1_";
#[allow(dead_code)]
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
pub(crate) enum Opcode {
/// Get one or two 32-bit words of TRNG data
GetTrng,
}

View file

@ -1,5 +0,0 @@
#![cfg_attr(target_os = "none", no_std)]
pub mod api;
use xous::{CID, send_message};
use num_traits::ToPrimitive;

View file

@ -1,39 +1,62 @@
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]
mod api;
use num_traits::{FromPrimitive, ToPrimitive};
use cb_test_srv::*;
use num_traits::FromPrimitive;
const SERVER_NAME: &str = "_CB test client 1_";
use log::info;
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
enum Opcode {
Tick,
Sum,
}
use core::sync::atomic::{AtomicU32, Ordering};
static CB_TO_MAIN_CONN: AtomicU32 = AtomicU32::new(0);
fn do_add(sum: u32) {
let cb_to_main_conn = CB_TO_MAIN_CONN.load(Ordering::Relaxed);
if cb_to_main_conn != 0 {
xous::send_message(cb_to_main_conn,
xous::Message::new_scalar(Opcode::Sum.to_usize().unwrap(), sum as usize, 0, 0, 0)
).unwrap();
}
}
#[xous::xous_main]
fn xmain() -> ! {
log_server::init_wait().unwrap();
log::set_max_level(log::LevelFilter::Info);
info!("my PID is {}", xous::process::id());
log::set_max_level(log::LevelFilter::Trace);
log::info!("my PID is {}", xous::process::id());
let xns = xous_names::XousNames::new().unwrap();
let trng_sid = xns.register_name(api::SERVER_NAME_TRNG).expect("can't register server");
log::trace!("registered with NS -- {:?}", trng_sid);
let sid = xns.register_name(SERVER_NAME).expect("can't register server");
log::trace!("registered with NS -- {:?}", sid);
#[cfg(target_os = "none")]
let trng = Trng::new();
CB_TO_MAIN_CONN.store(xous::connect(sid).unwrap(), Ordering::Relaxed);
#[cfg(not(target_os = "none"))]
let mut trng = Trng::new();
let mut cb_serv = CbTestServer::new(&xns).unwrap();
let tick_cid = xous::connect(sid).unwrap();
cb_serv.hook_tick_callback(Opcode::Tick.to_u32().unwrap(), tick_cid).unwrap();
// pump the TRNG hardware to clear the first number out, sometimes it is 0 due to clock-sync issues on the fifo
trng.get_trng(2);
log::trace!("ready to accept requests");
let mut state = 0;
loop {
let msg = xous::receive_message(trng_sid).unwrap();
let msg = xous::receive_message(sid).unwrap();
match FromPrimitive::from_usize(msg.body.id()) {
Some(api::Opcode::GetTrng) => xous::msg_blocking_scalar_unpack!(msg, count, _, _, _, {
let val: [u32; 2] = trng.get_trng(count);
xous::return_scalar2(msg.sender, val[0] as _, val[1] as _)
.expect("couldn't return GetTrng request");
Some(Opcode::Tick) => xous::msg_scalar_unpack!(msg, _, _, _, _, {
if (state % 2) == 0 {
log::trace!("hook1");
cb_serv.hook_add_callback(do_add).unwrap();
cb_serv.add(1).unwrap();
} else {
log::trace!("unhook1");
cb_serv.unhook_add_callback().unwrap();
}
state += 1;
}),
Some(Opcode::Sum) => xous::msg_scalar_unpack!(msg, s, _, _, _, {
log::info!("C1 sum: {}", s);
}),
None => {
log::error!("couldn't convert opcode");
@ -43,8 +66,8 @@ fn xmain() -> ! {
}
// clean up our program
log::trace!("main loop exit, destroying servers");
xns.unregister_server(trng_sid).unwrap();
xous::destroy_server(trng_sid).unwrap();
xns.unregister_server(sid).unwrap();
xous::destroy_server(sid).unwrap();
log::trace!("quitting");
xous::terminate_process(); loop {}
}

View file

@ -13,6 +13,7 @@ ticktimer-server = { path = "../ticktimer-server" }
xous-names = { path = "../xous-names" }
log = "0.4"
xous-ipc = {path = "../../xous-ipc"}
cb-test-srv = {path = "../cb-test-srv"}
rkyv = {version = "0.4.3", default-features = false, features = ["const_generics"]}
num-derive = {version = "0.3", default-features = false}

View file

@ -1,8 +0,0 @@
pub(crate) const SERVER_NAME_TRNG: &str = "_Callback test client 2_";
#[allow(dead_code)]
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
pub(crate) enum Opcode {
/// Get one or two 32-bit words of TRNG data
GetTrng,
}

View file

@ -1,5 +0,0 @@
#![cfg_attr(target_os = "none", no_std)]
pub mod api;
use xous::{CID, send_message};
use num_traits::ToPrimitive;

View file

@ -1,39 +1,64 @@
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]
mod api;
use num_traits::{FromPrimitive, ToPrimitive};
use cb_test_srv::*;
use num_traits::FromPrimitive;
const SERVER_NAME: &str = "_CB test client 2_";
use log::info;
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
enum Opcode {
Tick,
Sum,
}
use core::sync::atomic::{AtomicU32, Ordering};
static CB_TO_MAIN_CONN: AtomicU32 = AtomicU32::new(0);
fn do_add(sum: u32) {
let cb_to_main_conn = CB_TO_MAIN_CONN.load(Ordering::Relaxed);
if cb_to_main_conn != 0 {
xous::send_message(cb_to_main_conn,
xous::Message::new_scalar(Opcode::Sum.to_usize().unwrap(), sum as usize, 0, 0, 0)
).unwrap();
}
}
#[xous::xous_main]
fn xmain() -> ! {
log_server::init_wait().unwrap();
log::set_max_level(log::LevelFilter::Info);
info!("my PID is {}", xous::process::id());
log::set_max_level(log::LevelFilter::Trace);
log::info!("my PID is {}", xous::process::id());
let xns = xous_names::XousNames::new().unwrap();
let trng_sid = xns.register_name(api::SERVER_NAME_TRNG).expect("can't register server");
log::trace!("registered with NS -- {:?}", trng_sid);
let sid = xns.register_name(SERVER_NAME).expect("can't register server");
log::trace!("registered with NS -- {:?}", sid);
#[cfg(target_os = "none")]
let trng = Trng::new();
CB_TO_MAIN_CONN.store(xous::connect(sid).unwrap(), Ordering::Relaxed);
#[cfg(not(target_os = "none"))]
let mut trng = Trng::new();
let mut cb_serv = CbTestServer::new(&xns).unwrap();
let tick_cid = xous::connect(sid).unwrap();
cb_serv.hook_tick_callback(Opcode::Tick.to_u32().unwrap(), tick_cid).unwrap();
// pump the TRNG hardware to clear the first number out, sometimes it is 0 due to clock-sync issues on the fifo
trng.get_trng(2);
log::trace!("ready to accept requests");
let mut state = 0;
loop {
let msg = xous::receive_message(trng_sid).unwrap();
let msg = xous::receive_message(sid).unwrap();
match FromPrimitive::from_usize(msg.body.id()) {
Some(api::Opcode::GetTrng) => xous::msg_blocking_scalar_unpack!(msg, count, _, _, _, {
let val: [u32; 2] = trng.get_trng(count);
xous::return_scalar2(msg.sender, val[0] as _, val[1] as _)
.expect("couldn't return GetTrng request");
Some(Opcode::Tick) => xous::msg_scalar_unpack!(msg, _, _, _, _, {
if (state % 3) == 0 {
log::trace!("hook2");
cb_serv.hook_add_callback(do_add).unwrap();
cb_serv.add(1).unwrap();
} else if (state % 3) == 2 {
log::trace!("unhook2");
cb_serv.unhook_add_callback().unwrap();
} else {
log::trace!("idle2");
}
state += 1;
}),
Some(Opcode::Sum) => xous::msg_scalar_unpack!(msg, s, _, _, _, {
log::info!("C2 sum: {}", s);
}),
None => {
log::error!("couldn't convert opcode");
@ -43,8 +68,8 @@ fn xmain() -> ! {
}
// clean up our program
log::trace!("main loop exit, destroying servers");
xns.unregister_server(trng_sid).unwrap();
xous::destroy_server(trng_sid).unwrap();
xns.unregister_server(sid).unwrap();
xous::destroy_server(sid).unwrap();
log::trace!("quitting");
xous::terminate_process(); loop {}
}

View file

@ -1,10 +1,28 @@
use num_traits::{ToPrimitive, FromPrimitive};
pub(crate) const SERVER_NAME: &str = "_Callback test server_";
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub enum Opcode {
RegisterListener,
UnregisterListener,
pub(crate) enum Opcode {
RegisterTickListener,
RegisterAddListener,
Tick,
Add,
}
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub enum TickCallback {
Tick,
Drop,
}
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub enum AddCallback {
Sum,
Drop,
}
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone)]
pub(crate) struct ScalarHook {
pub sid: (u32, u32, u32, u32),
pub id: u32, // ID of the scalar message to send through (e.g. the discriminant of the Enum on the caller's side API)
pub cid: xous::CID, // caller-side connection ID for the scalar message to route to. Created by the caller before hooking.
}

View file

@ -4,6 +4,18 @@
mod api;
use api::*;
use num_traits::{ToPrimitive, FromPrimitive};
use xous_ipc::*;
use api::Opcode;
use xous::{CID, msg_scalar_unpack};
#[derive(Copy, Clone, Debug)]
struct ScalarCallback {
server_to_cb_cid: CID,
cb_to_client_cid: CID,
cb_to_client_id: u32,
}
fn pump_thread() {
log::info!("starting pump thread");
@ -11,141 +23,109 @@ fn pump_thread() {
let xns = xous_names::XousNames::new().unwrap();
let server_conn = xns.request_connection_blocking(api::SERVER_NAME).expect("can't connect to main program");
let mut last_time: u64 = ticktimer.elapsed_ms();
let mut start_sent = false;
loop {
let elapsed_time = ticktimer.elapsed_ms();
if false {
if elapsed_time - last_time > 500 && !start_sent {
last_time = elapsed_time;
xous::send_message(shell_conn,
xous::Message::new_scalar(Opcode::Start.to_usize().unwrap(), 0, 0, 0, 0)).expect("BENCHMARK|stopwatch: couldn't send Start message");
start_sent = true;
} else if elapsed_time - last_time > 10_000 && start_sent {
last_time = elapsed_time;
start_sent = false;
xous::send_message(shell_conn,
xous::Message::new_scalar(Opcode::Stop.to_usize().unwrap(), 0, 0, 0, 0)).expect("BENCHMARK|stopwatch: couldn't send Start message");
}
} else {
// send a start loop message
xous::send_message(shell_conn,
xous::Message::new_scalar(Opcode::Start.to_usize().unwrap(), 0, 0, 0, 0)).expect("BENCHMARK|stopwatch: couldn't send Start message");
ticktimer.sleep_ms(10_000).expect("couldn't sleep");
// send a stop loop message
xous::send_message(shell_conn,
xous::Message::new_scalar(Opcode::Stop.to_usize().unwrap(), 0, 0, 0, 0)).expect("BENCHMARK|stopwatch: couldn't send Start message");
// give a moment for the result to update
ticktimer.sleep_ms(500).expect("couldn't sleep");
}
xous::yield_slice();
xous::send_message(server_conn,
xous::Message::new_scalar(Opcode::Tick.to_usize().unwrap(), 0, 0, 0, 0)).expect("couldn't send Tick message");
ticktimer.sleep_ms(2_000).expect("couldn't sleep");
}
}
#[xous::xous_main]
fn shell_main() -> ! {
log_server::init_wait().unwrap();
info!("BENCHMARK: my PID is {}", xous::process::id());
info!("BENCHMARK: ticktimer");
let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer");
log::info!("my PID is {}", xous::process::id());
let xns = xous_names::XousNames::new().unwrap();
let shell_server = xns.register_name(SERVER_NAME_SHELL).expect("BENCHMARK: can't register server");
let server = xns.register_name(api::SERVER_NAME).expect("can't register server");
let gfx = graphics_server::Gfx::new(&xns).unwrap();
let target_conn = xns.request_connection_blocking(benchmark_target::api::SERVER_NAME_BENCHMARK).expect("BENCHMARK: can't connect to COM");
xous::create_thread_0(pump_thread).unwrap();
log::info!("pump thread started");
xous::create_thread_0(stopwatch_thread).unwrap();
info!("BENCHMARK: stopwatch thread started");
let mut tick_cb: [Option<ScalarCallback>; 32] = [None; 32];
let mut add_cb: [Option<CID>; 32] = [None; 32];
let screensize = gfx.screen_size().expect("Couldn't get screen size");
let font_h: i16 = gfx.glyph_height_hint(GlyphStyle::Small).expect("couldn't get glyph height") as i16;
let status_clipregion =
Rectangle::new_coords_with_style(4, 0, screensize.x, font_h as i16 * 4, DrawStyle::new(PixelColor::Light, PixelColor::Light, 1));
gfx.draw_rectangle(Rectangle::new_with_style(Point::new(0, 0), screensize,
DrawStyle::new(PixelColor::Light, PixelColor::Light, 0)
))
.expect("unable to clear region");
let mut result_tv = TextView::new(graphics_server::Gid::new([0, 0, 0, 0]),
TextBounds::BoundingBox(Rectangle::new(Point::new(0,0),
Point::new(screensize.x, screensize.y - 1))));
result_tv.set_op(TextOp::Render);
result_tv.clip_rect = Some(status_clipregion.into());
result_tv.untrusted = false;
result_tv.style = blitstr::GlyphStyle::Small;
result_tv.draw_border = false;
result_tv.margin = Point::new(3, 0);
write!(result_tv, "Initializing...").expect("couldn't init text");
gfx.draw_textview(&mut result_tv).unwrap();
gfx.flush().expect("unable to draw to screen");
let mut start_time: u64 = 0;
let mut stop_time: u64 = 0;
let mut update_result: bool = false;
let mut count: u32 = 0;
let mut check_count: u32 = 0;
let mut sum = 0;
loop {
let maybe_env = xous::try_receive_message(shell_server).unwrap();
match maybe_env {
Some(envelope) => {
info!("BENCHMARK: Message: {:?}", envelope);
match FromPrimitive::from_usize(envelope.body.id()) {
Some(Opcode::Start) => {
start_time = ticktimer.elapsed_ms();
},
Some(Opcode::Stop) => {
stop_time = ticktimer.elapsed_ms();
update_result = true;
},
None => {
error!("BENCHMARK: couldn't convert opcode");
let msg = xous::receive_message(server).unwrap();
log::trace!("Message: {:?}", msg);
match FromPrimitive::from_usize(msg.body.id()) {
Some(Opcode::Tick) => {
// pump the tick callbacks
for maybe_conn in tick_cb.iter_mut() {
if let Some(scb) = maybe_conn {
match xous::send_message(scb.server_to_cb_cid,
xous::Message::new_scalar(api::TickCallback::Tick.to_usize().unwrap(),
scb.cb_to_client_cid as usize, scb.cb_to_client_id as usize, 0, 0)) {
Err(xous::Error::ServerNotFound) => {
*maybe_conn = None // automatically de-allocate callbacks for clients that have dropped
},
Ok(xous::Result::Ok) => {}
_ => panic!("unhandled error or result in callback processing")
}
}
}
},
Some(Opcode::RegisterTickListener) => {
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
do_hook(hookdata, &mut tick_cb);
},
Some(Opcode::RegisterAddListener) => msg_scalar_unpack!(msg, sid0, sid1, sid2, sid3, {
let sid = xous::SID::from_u32(sid0 as _, sid1 as _, sid2 as _, sid3 as _);
let cid = Some(xous::connect(sid).unwrap());
let mut found = false;
for entry in add_cb.iter_mut() {
if *entry == None {
*entry = cid;
found = true;
break;
}
}
if !found {
log::error!("RegisterTickListener ran out of space registering callback");
}
}),
Some(Opcode::Add) => msg_scalar_unpack!(msg, s, _, _, _, {
sum += s;
// send results to add listeners
for maybe_conn in add_cb.iter_mut() {
if let Some(conn) = maybe_conn {
match xous::send_message(*conn,
xous::Message::new_scalar(api::AddCallback::Sum.to_usize().unwrap(), sum, 0, 0, 0)) {
Err(xous::Error::ServerNotFound) => {
*maybe_conn = None // automatically de-allocate callbacks for clients that have dropped
},
Ok(xous::Result::Ok) => {}
_ => panic!("unhandled error or result in callback processing")
}
}
}
}),
None => {
log::error!("couldn't convert opcode");
}
None => (), // don't yield, we are trying to run the loop as fast as we can...
}
// actual benchmark
// get a scalar message
if true {
// measured at 1479.2 iterations per second in this loop (hardware); 55/s (hosted)
// xous v0.8
// 29729 per 10s = 2972.9/s (hardware)
// 485 per 10s = 48.5/s (hosted)
count = benchmark_target::test_scalar(target_conn, count).expect("BENCHMARK: couldn't send test message");
check_count = check_count + 1;
} else {
// works on hosted mode, 35/s (hosted)
// measured at 762.6 iterations per second (hardware)
// xous v0.8
// 9,928 per 10s = 992.8/s (hardware)
// 243 per 10s = 24.3/s (hosted)
count = benchmark_target::test_memory(target_conn, count).expect("BENCHMARK: couldn't send test message");
check_count = check_count + 1;
}
if update_result {
update_result = false;
gfx.draw_rectangle(status_clipregion)
.expect("unable to clear region");
result_tv.clear_str();
write!(&mut result_tv, "Elapsed: {}, count: {}, check: {}",
stop_time - start_time, count, check_count).unwrap();
gfx.draw_textview(&mut result_tv).unwrap();
gfx.flush().expect("unable to draw to screen");
count = 0;
check_count = 0;
}
}
}
fn do_hook(hookdata: ScalarHook, cb_conns: &mut [Option<ScalarCallback>; 32]) {
let (s0, s1, s2, s3) = hookdata.sid;
let sid = xous::SID::from_u32(s0, s1, s2, s3);
let server_to_cb_cid = xous::connect(sid).unwrap();
let cb_dat = Some(ScalarCallback {
server_to_cb_cid,
cb_to_client_cid: hookdata.cid,
cb_to_client_id: hookdata.id,
});
let mut found = false;
for entry in cb_conns.iter_mut() {
if entry.is_none() {
*entry = cb_dat;
found = true;
break;
}
}
if !found {
log::error!("ran out of space registering callback");
}
}

View file

@ -95,16 +95,10 @@ fn try_main() -> Result<(), DynError> {
Some("renode-image") => renode_image(false, &hw_pkgs)?,
Some("renode-test") => renode_image(
false,
&[
"ticktimer-server",
"log-server",
"xous-names",
"rkyv-test-client",
"rkyv-test-server",
],
&cbtest_pkgs,
)?,
Some("renode-image-debug") => renode_image(true, &hw_pkgs)?,
Some("run") => run(false, &hw_pkgs)?,
Some("run") => run(false, &cbtest_pkgs)?,
Some("hw-image") => build_hw_image(false, env::args().nth(2), &hw_pkgs)?,
Some("benchmark") => build_hw_image(false, env::args().nth(2), &benchmark_pkgs)?,
Some("fcc-agent") => build_hw_image(false, env::args().nth(2), &fcc_pkgs)?,