diff --git a/Cargo.lock b/Cargo.lock index 5f706f43a..557f24006 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -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", diff --git a/RELEASE-v0.8.md b/RELEASE-v0.8.md index 8bf81f8c8..bad750985 100644 --- a/RELEASE-v0.8.md +++ b/RELEASE-v0.8.md @@ -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; diff --git a/services/cb-test-c1/Cargo.toml b/services/cb-test-c1/Cargo.toml index c730febf4..00cb5be6b 100644 --- a/services/cb-test-c1/Cargo.toml +++ b/services/cb-test-c1/Cargo.toml @@ -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} diff --git a/services/cb-test-c1/src/api.rs b/services/cb-test-c1/src/api.rs deleted file mode 100644 index 8883033c6..000000000 --- a/services/cb-test-c1/src/api.rs +++ /dev/null @@ -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, -} diff --git a/services/cb-test-c1/src/lib.rs b/services/cb-test-c1/src/lib.rs deleted file mode 100644 index 619c5225d..000000000 --- a/services/cb-test-c1/src/lib.rs +++ /dev/null @@ -1,5 +0,0 @@ -#![cfg_attr(target_os = "none", no_std)] - -pub mod api; -use xous::{CID, send_message}; -use num_traits::ToPrimitive; diff --git a/services/cb-test-c1/src/main.rs b/services/cb-test-c1/src/main.rs index c7cbc0660..a650f5853 100644 --- a/services/cb-test-c1/src/main.rs +++ b/services/cb-test-c1/src/main.rs @@ -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 {} } diff --git a/services/cb-test-c2/Cargo.toml b/services/cb-test-c2/Cargo.toml index 9617b8b4b..f109ec081 100644 --- a/services/cb-test-c2/Cargo.toml +++ b/services/cb-test-c2/Cargo.toml @@ -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} diff --git a/services/cb-test-c2/src/api.rs b/services/cb-test-c2/src/api.rs deleted file mode 100644 index 0121d7b2d..000000000 --- a/services/cb-test-c2/src/api.rs +++ /dev/null @@ -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, -} diff --git a/services/cb-test-c2/src/lib.rs b/services/cb-test-c2/src/lib.rs deleted file mode 100644 index 619c5225d..000000000 --- a/services/cb-test-c2/src/lib.rs +++ /dev/null @@ -1,5 +0,0 @@ -#![cfg_attr(target_os = "none", no_std)] - -pub mod api; -use xous::{CID, send_message}; -use num_traits::ToPrimitive; diff --git a/services/cb-test-c2/src/main.rs b/services/cb-test-c2/src/main.rs index c7cbc0660..bda98fcc6 100644 --- a/services/cb-test-c2/src/main.rs +++ b/services/cb-test-c2/src/main.rs @@ -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 {} } diff --git a/services/cb-test-srv/src/api.rs b/services/cb-test-srv/src/api.rs index bbeb8036a..deaae6d49 100644 --- a/services/cb-test-srv/src/api.rs +++ b/services/cb-test-srv/src/api.rs @@ -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. } diff --git a/services/cb-test-srv/src/main.rs b/services/cb-test-srv/src/main.rs index 16132c4b4..dd9eaac3f 100644 --- a/services/cb-test-srv/src/main.rs +++ b/services/cb-test-srv/src/main.rs @@ -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; 32] = [None; 32]; + let mut add_cb: [Option; 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::().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; 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"); + } +} \ No newline at end of file diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 38ddb3439..22de200d8 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -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)?,