move more crates into stardized formatting

This commit is contained in:
bunnie 2021-08-20 00:04:46 +08:00
parent fd4e047d62
commit 340048aac9
5 changed files with 108 additions and 54 deletions

View file

@ -1,12 +1,10 @@
# if you want to format 'em, then you maintain 'em!
ignore = [ ignore = [
"services/graphics-server", "services/graphics-server",
"services/com", "services/com",
"services/keyboard", "services/keyboard",
#"services/trng",
"services/gam", "services/gam",
"services/status", "services/status",
"services/benchmark",
"services/benchmark-target",
"services/ime-frontend", "services/ime-frontend",
"services/ime-plugin-shell", "services/ime-plugin-shell",
"services/shellchat", "services/shellchat",

View file

@ -4,13 +4,11 @@ pub struct TestStruct {
} }
impl TestStruct { impl TestStruct {
pub fn new() -> Self { pub fn new() -> Self {
TestStruct { TestStruct { challenge: [0; 8] }
challenge: [0; 8],
}
} }
} }
pub const SERVER_NAME_BENCHMARK: &str= "_Benchmark target_"; pub const SERVER_NAME_BENCHMARK: &str = "_Benchmark target_";
#[allow(dead_code)] #[allow(dead_code)]
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] #[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]

View file

@ -3,13 +3,21 @@
pub mod api; pub mod api;
use api::*; use api::*;
use xous::{CID, send_message}; use num_traits::ToPrimitive;
use xous::{send_message, CID};
use xous_ipc::Buffer; use xous_ipc::Buffer;
use num_traits::{ToPrimitive};
pub fn test_scalar(cid: CID, testvar: u32) -> Result<u32, xous::Error> { pub fn test_scalar(cid: CID, testvar: u32) -> Result<u32, xous::Error> {
let response = send_message(cid, let response = send_message(
xous::Message::new_blocking_scalar(Opcode::TestScalar.to_usize().unwrap(), testvar as usize, 0, 0, 0))?; cid,
xous::Message::new_blocking_scalar(
Opcode::TestScalar.to_usize().unwrap(),
testvar as usize,
0,
0,
0,
),
)?;
if let xous::Result::Scalar1(r) = response { if let xous::Result::Scalar1(r) = response {
Ok(r as u32) Ok(r as u32)
} else { } else {
@ -22,7 +30,8 @@ pub fn test_memory(cid: CID, testvar: u32) -> Result<u32, xous::Error> {
reg.challenge[0] = testvar; reg.challenge[0] = testvar;
let mut buf = Buffer::into_buf(reg).or(Err(xous::Error::InternalError))?; let mut buf = Buffer::into_buf(reg).or(Err(xous::Error::InternalError))?;
buf.lend_mut(cid, Opcode::TestMemory.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; buf.lend_mut(cid, Opcode::TestMemory.to_u32().unwrap())
.or(Err(xous::Error::InternalError))?;
let result = buf.as_flat::<TestStruct, _>().unwrap(); let result = buf.as_flat::<TestStruct, _>().unwrap();
Ok(result.challenge[0]) Ok(result.challenge[0])
@ -33,6 +42,7 @@ pub fn test_memory_send(cid: CID, testvar: u32) -> Result<u32, xous::Error> {
reg.challenge[0] = testvar; reg.challenge[0] = testvar;
let mut buf = Buffer::into_buf(reg).or(Err(xous::Error::InternalError))?; let mut buf = Buffer::into_buf(reg).or(Err(xous::Error::InternalError))?;
buf.send(cid, Opcode::TestMemorySend.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; buf.send(cid, Opcode::TestMemorySend.to_u32().unwrap())
Ok(testvar+2) .or(Err(xous::Error::InternalError))?;
Ok(testvar + 2)
} }

View file

@ -7,8 +7,8 @@ use xous::msg_blocking_scalar_unpack;
use log::{error, info}; use log::{error, info};
use num_traits::FromPrimitive;
use xous_ipc::Buffer; use xous_ipc::Buffer;
use num_traits::{FromPrimitive};
#[xous::xous_main] #[xous::xous_main]
fn xmain() -> ! { fn xmain() -> ! {
@ -16,7 +16,9 @@ fn xmain() -> ! {
info!("BENCHTARGET: my PID is {}", xous::process::id()); info!("BENCHTARGET: my PID is {}", xous::process::id());
let xns = xous_names::XousNames::new().unwrap(); let xns = xous_names::XousNames::new().unwrap();
let bench_sid = xns.register_name(api::SERVER_NAME_BENCHMARK, None).expect("BENCHTARGET: can't register server"); let bench_sid = xns
.register_name(api::SERVER_NAME_BENCHMARK, None)
.expect("BENCHTARGET: can't register server");
info!("BENCHTARGET: registered with NS -- {:?}", bench_sid); info!("BENCHTARGET: registered with NS -- {:?}", bench_sid);
let mut state: u32 = 0; let mut state: u32 = 0;
@ -25,22 +27,28 @@ fn xmain() -> ! {
match FromPrimitive::from_usize(envelope.body.id()) { match FromPrimitive::from_usize(envelope.body.id()) {
Some(Opcode::TestScalar) => msg_blocking_scalar_unpack!(envelope, val, _, _, _, { Some(Opcode::TestScalar) => msg_blocking_scalar_unpack!(envelope, val, _, _, _, {
xous::return_scalar(envelope.sender, (val + 1) as usize) xous::return_scalar(envelope.sender, (val + 1) as usize)
.expect("BENCHTARGET: couldn't return TestScalar request"); .expect("BENCHTARGET: couldn't return TestScalar request");
}), }),
Some(Opcode::TestMemory) => { Some(Opcode::TestMemory) => {
let mut buffer = unsafe { Buffer::from_memory_message_mut(envelope.body.memory_message_mut().unwrap()) }; let mut buffer = unsafe {
Buffer::from_memory_message_mut(envelope.body.memory_message_mut().unwrap())
};
let reg = buffer.to_original::<TestStruct, _>().unwrap(); let reg = buffer.to_original::<TestStruct, _>().unwrap();
let mut ret = TestStruct::new(); let mut ret = TestStruct::new();
ret.challenge[0] = reg.challenge[0] + 1; ret.challenge[0] = reg.challenge[0] + 1;
buffer.replace(ret).unwrap(); buffer.replace(ret).unwrap();
}, }
Some(Opcode::TestMemorySend) => { Some(Opcode::TestMemorySend) => {
let mut buffer = unsafe { Buffer::from_memory_message_mut(envelope.body.memory_message_mut().unwrap()) }; let mut buffer = unsafe {
Buffer::from_memory_message_mut(envelope.body.memory_message_mut().unwrap())
};
let reg = buffer.to_original::<TestStruct, _>().unwrap(); let reg = buffer.to_original::<TestStruct, _>().unwrap();
state += reg.challenge[0]; state += reg.challenge[0];
} }
None => {error!("BENCHTARGET: couldn't convert opcode");} None => {
error!("BENCHTARGET: couldn't convert opcode");
}
} }
} }
} }

View file

@ -5,13 +5,13 @@
NOTE: this assumes that you turn off the watchdog timer. This code does not include enough sleeps to reset the WDT NOTE: this assumes that you turn off the watchdog timer. This code does not include enough sleeps to reset the WDT
Do this by removing the watchdog feature in the ticktimer-server Cargo.toml crate Do this by removing the watchdog feature in the ticktimer-server Cargo.toml crate
****************/ ****************/
use blitstr::GlyphStyle;
use blitstr_ref as blitstr; use blitstr_ref as blitstr;
use blitstr::{GlyphStyle};
use core::fmt::Write; use core::fmt::Write;
use graphics_server::{DrawStyle, PixelColor, Point, Rectangle, TextView, TextBounds, TextOp}; use graphics_server::{DrawStyle, PixelColor, Point, Rectangle, TextBounds, TextOp, TextView};
use log::{error, info}; use log::{error, info};
use num_traits::{ToPrimitive, FromPrimitive}; use num_traits::{FromPrimitive, ToPrimitive};
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] #[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub enum Opcode { pub enum Opcode {
@ -19,7 +19,7 @@ pub enum Opcode {
Stop, Stop,
} }
const SERVER_NAME_SHELL: &str = "_Shell_"; const SERVER_NAME_SHELL: &str = "_Shell_";
fn stopwatch_thread() { fn stopwatch_thread() {
info!("BENCHMARK|stopwatch: starting"); info!("BENCHMARK|stopwatch: starting");
@ -27,7 +27,9 @@ fn stopwatch_thread() {
let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer"); let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer");
let xns = xous_names::XousNames::new().unwrap(); let xns = xous_names::XousNames::new().unwrap();
let shell_conn = xns.request_connection_blocking(SERVER_NAME_SHELL).expect("BENCHMARK|stopwatch: can't connect to main program"); let shell_conn = xns
.request_connection_blocking(SERVER_NAME_SHELL)
.expect("BENCHMARK|stopwatch: can't connect to main program");
let mut last_time: u64 = ticktimer.elapsed_ms(); let mut last_time: u64 = ticktimer.elapsed_ms();
let mut start_sent = false; let mut start_sent = false;
loop { loop {
@ -35,23 +37,35 @@ fn stopwatch_thread() {
if false { if false {
if elapsed_time - last_time > 500 && !start_sent { if elapsed_time - last_time > 500 && !start_sent {
last_time = elapsed_time; last_time = elapsed_time;
xous::send_message(shell_conn, xous::send_message(
xous::Message::new_scalar(Opcode::Start.to_usize().unwrap(), 0, 0, 0, 0)).expect("BENCHMARK|stopwatch: couldn't send Start 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; start_sent = true;
} else if elapsed_time - last_time > 10_000 && start_sent { } else if elapsed_time - last_time > 10_000 && start_sent {
last_time = elapsed_time; last_time = elapsed_time;
start_sent = false; start_sent = false;
xous::send_message(shell_conn, xous::send_message(
xous::Message::new_scalar(Opcode::Stop.to_usize().unwrap(), 0, 0, 0, 0)).expect("BENCHMARK|stopwatch: couldn't send Start 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 { } else {
// send a start loop message // send a start loop message
xous::send_message(shell_conn, xous::send_message(
xous::Message::new_scalar(Opcode::Start.to_usize().unwrap(), 0, 0, 0, 0)).expect("BENCHMARK|stopwatch: couldn't send Start 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"); ticktimer.sleep_ms(10_000).expect("couldn't sleep");
// send a stop loop message // send a stop loop message
xous::send_message(shell_conn, xous::send_message(
xous::Message::new_scalar(Opcode::Stop.to_usize().unwrap(), 0, 0, 0, 0)).expect("BENCHMARK|stopwatch: couldn't send Start 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 // give a moment for the result to update
ticktimer.sleep_ms(500).expect("couldn't sleep"); ticktimer.sleep_ms(500).expect("couldn't sleep");
} }
@ -68,29 +82,46 @@ fn shell_main() -> ! {
let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer"); let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer");
let xns = xous_names::XousNames::new().unwrap(); let xns = xous_names::XousNames::new().unwrap();
let shell_server = xns.register_name(SERVER_NAME_SHELL, None).expect("BENCHMARK: can't register server"); let shell_server = xns
.register_name(SERVER_NAME_SHELL, None)
.expect("BENCHMARK: can't register server");
let gfx = graphics_server::Gfx::new(&xns).unwrap(); 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"); let target_conn = xns
.request_connection_blocking(benchmark_target::api::SERVER_NAME_BENCHMARK)
.expect("BENCHMARK: can't connect to COM");
xous::create_thread_0(stopwatch_thread).unwrap(); xous::create_thread_0(stopwatch_thread).unwrap();
info!("BENCHMARK: stopwatch thread started"); info!("BENCHMARK: stopwatch thread started");
let screensize = gfx.screen_size().expect("Couldn't get screen size"); 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 font_h: i16 = gfx
.glyph_height_hint(GlyphStyle::Small)
.expect("couldn't get glyph height") as i16;
let status_clipregion = let status_clipregion = Rectangle::new_coords_with_style(
Rectangle::new_coords_with_style(4, 0, screensize.x, font_h as i16 * 4, DrawStyle::new(PixelColor::Light, PixelColor::Light, 1)); 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, gfx.draw_rectangle(Rectangle::new_with_style(
DrawStyle::new(PixelColor::Light, PixelColor::Light, 0) Point::new(0, 0),
)) screensize,
.expect("unable to clear region"); 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]), let mut result_tv = TextView::new(
TextBounds::BoundingBox(Rectangle::new(Point::new(0,0), graphics_server::Gid::new([0, 0, 0, 0]),
Point::new(screensize.x, screensize.y - 1)))); TextBounds::BoundingBox(Rectangle::new(
Point::new(0, 0),
Point::new(screensize.x, screensize.y - 1),
)),
);
result_tv.set_op(TextOp::Render); result_tv.set_op(TextOp::Render);
result_tv.clip_rect = Some(status_clipregion.into()); result_tv.clip_rect = Some(status_clipregion.into());
result_tv.untrusted = false; result_tv.untrusted = false;
@ -115,11 +146,11 @@ fn shell_main() -> ! {
match FromPrimitive::from_usize(envelope.body.id()) { match FromPrimitive::from_usize(envelope.body.id()) {
Some(Opcode::Start) => { Some(Opcode::Start) => {
start_time = ticktimer.elapsed_ms(); start_time = ticktimer.elapsed_ms();
}, }
Some(Opcode::Stop) => { Some(Opcode::Stop) => {
stop_time = ticktimer.elapsed_ms(); stop_time = ticktimer.elapsed_ms();
update_result = true; update_result = true;
}, }
None => { None => {
error!("BENCHMARK: couldn't convert opcode"); error!("BENCHMARK: couldn't convert opcode");
} }
@ -136,7 +167,8 @@ fn shell_main() -> ! {
// xous v0.8 // xous v0.8
// 29729 per 10s = 2972.9/s (hardware) // 29729 per 10s = 2972.9/s (hardware)
// 485 per 10s = 48.5/s (hosted) // 485 per 10s = 48.5/s (hosted)
count = benchmark_target::test_scalar(target_conn, count).expect("BENCHMARK: couldn't send test message"); count = benchmark_target::test_scalar(target_conn, count)
.expect("BENCHMARK: couldn't send test message");
check_count = check_count + 1; check_count = check_count + 1;
} else { } else {
if false { if false {
@ -146,11 +178,13 @@ fn shell_main() -> ! {
// xous v0.8 // xous v0.8
// 9,928 per 10s = 992.8/s (hardware) // 9,928 per 10s = 992.8/s (hardware)
// 243 per 10s = 24.3/s (hosted) // 243 per 10s = 24.3/s (hosted)
count = benchmark_target::test_memory(target_conn, count).expect("BENCHMARK: couldn't send test message"); count = benchmark_target::test_memory(target_conn, count)
.expect("BENCHMARK: couldn't send test message");
check_count = check_count + 1; check_count = check_count + 1;
} else { } else {
// simple send benchmark, instead of lend // simple send benchmark, instead of lend
count = benchmark_target::test_memory_send(target_conn, count).expect("BENCHMARK: couldn't send test message"); count = benchmark_target::test_memory_send(target_conn, count)
.expect("BENCHMARK: couldn't send test message");
check_count = check_count + 1; check_count = check_count + 1;
} }
} }
@ -159,11 +193,17 @@ fn shell_main() -> ! {
update_result = false; update_result = false;
gfx.draw_rectangle(status_clipregion) gfx.draw_rectangle(status_clipregion)
.expect("unable to clear region"); .expect("unable to clear region");
result_tv.clear_str(); result_tv.clear_str();
write!(&mut result_tv, "Elapsed: {}, count: {}, check: {}", write!(
stop_time - start_time, count, check_count).unwrap(); &mut result_tv,
"Elapsed: {}, count: {}, check: {}",
stop_time - start_time,
count,
check_count
)
.unwrap();
gfx.draw_textview(&mut result_tv).unwrap(); gfx.draw_textview(&mut result_tv).unwrap();
gfx.flush().expect("unable to draw to screen"); gfx.flush().expect("unable to draw to screen");