M-Labs
/
artiq-zynq
9
1
Fork 16
Code Issues 14 Pull Requests 1 Releases Wiki Activity

runtime: run idle kernel on start-up

Simon Renblad 2023-11-01 10:28:02 +08:00
parent a08a42c954
commit 1ab13f5799
2 changed files with 74 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
src/runtime/src/comms.rs
View File

@ -638,6 +638,27 @@ async fn handle_connection(
}
}
async fn flash_kernel_worker(
control: &Rc<RefCell<kernel::Control>>,
up_destinations: &Rc<RefCell<[bool; drtio_routing::DEST_COUNT]>>,
aux_mutex: &Rc<Mutex<bool>>,
drtio_routing_table: &Rc<RefCell<drtio_routing::RoutingTable>>,
timer: GlobalTimer,
cfg: &Rc<Config>,
config_key: &str,
) {
if let Ok(buffer) = cfg.read(config_key) {
let routing_table = drtio_routing_table.borrow();
info!("Loading {}", config_key);
let _ = load_kernel(&buffer, &control, None)
.await.map_err(|_| warn!("Error loading {}", config_key));
info!("Running idle kernel");
let _ = handle_run_kernel(None, &control, &up_destinations, &aux_mutex, &routing_table, timer)
.await.map_err(|_| warn!("Error running {}", config_key));
info!("Terminating {}", config_key);
}
}
pub fn main(timer: GlobalTimer, cfg: Config) {
let net_addresses = net_settings::get_addresses(&cfg);
info!("network addresses: {}", net_addresses);
@ -699,31 +720,48 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
moninj::start(timer, &aux_mutex, &drtio_routing_table);
let control: Rc<RefCell<kernel::Control>> = Rc::new(RefCell::new(kernel::Control::start()));
let idle_kernel = Rc::new(cfg.read("idle_kernel").ok());
if let Ok(buffer) = cfg.read("startup_kernel") {
info!("Loading startup kernel...");
if let Ok(()) = task::block_on(load_kernel(&buffer, &control, None)) {
info!("Starting startup kernel...");
let routing_table = drtio_routing_table.borrow();
let _ = task::block_on(handle_run_kernel(
None,
&control,
&up_destinations,
&aux_mutex,
&routing_table,
timer,
));
info!("Startup kernel finished!");
} else {
error!("Error loading startup kernel!");
}
}
mgmt::start(cfg);
let cfg: Rc<Config> = Rc::new(cfg);
task::block_on(flash_kernel_worker(
&control,
&up_destinations,
&aux_mutex,
&drtio_routing_table,
timer,
&cfg,
"startup_kernel")
);
mgmt::start(cfg.clone());
task::spawn(async move {
let connection = Rc::new(Semaphore::new(1, 1));
let connection = Rc::new(Semaphore::new(0, 1));
let terminate = Rc::new(Semaphore::new(0, 1));
task::spawn({
let cfg = cfg.clone();
let control = control.clone();
let connection = connection.clone();
let terminate = terminate.clone();
let up_destinations = up_destinations.clone();
let aux_mutex = aux_mutex.clone();
let drtio_routing_table = drtio_routing_table.clone();
async move {
select_biased! {
_ = flash_kernel_worker(
&control,
&up_destinations,
&aux_mutex,
&drtio_routing_table,
timer,
&cfg,
"idle_kernel"
).fuse() => (),
_ = terminate.async_wait().fuse() => ()
}
connection.signal();
}
});
loop {
let mut stream = TcpStream::accept(1381, 0x10_000, 0x10_000).await.unwrap();
@ -732,33 +770,32 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
terminate.signal();
connection.async_wait().await;
}
let cfg = cfg.clone();
let control = control.clone();
let idle_kernel = idle_kernel.clone();
let connection = connection.clone();
let terminate = terminate.clone();
let up_destinations = up_destinations.clone();
let aux_mutex = aux_mutex.clone();
let routing_table = drtio_routing_table.clone();
let drtio_routing_table = drtio_routing_table.clone();
// we make sure the value of terminate is 0 before we start
let _ = terminate.try_wait();
task::spawn(async move {
let routing_table = routing_table.borrow();
let routing_table = drtio_routing_table.borrow();
select_biased! {
_ = (async {
let _ = handle_connection(&mut stream, control.clone(), &up_destinations, &aux_mutex, &routing_table, timer)
.await
.map_err(|e| warn!("connection terminated: {}", e));
if let Some(buffer) = &*idle_kernel {
info!("Loading idle kernel");
let _ = load_kernel(&buffer, &control, None)
.await.map_err(|_| warn!("error loading idle kernel"));
info!("Running idle kernel");
let _ = handle_run_kernel(None, &control, &up_destinations, &aux_mutex, &routing_table, timer)
.await.map_err(|_| warn!("error running idle kernel"));
info!("Idle kernel terminated");
}
flash_kernel_worker(
&control,
&up_destinations,
&aux_mutex,
&drtio_routing_table,
timer,
&cfg,
"idle_kernel").await;
}).fuse() => (),
_ = terminate.async_wait().fuse() => ()
}
@ -813,7 +850,7 @@ pub fn soft_panic_main(timer: GlobalTimer, cfg: Config) -> ! {
Sockets::init(32);
mgmt::start(cfg);
mgmt::start(Rc::new(cfg));
// getting eth settings disables the LED as it resets GPIO
// need to re-enable it here

3
src/runtime/src/mgmt.rs
View File

@ -229,10 +229,9 @@ async fn handle_connection(stream: &mut TcpStream, pull_id: Rc<RefCell<u32>>, cf
}
}
pub fn start(cfg: Config) {
pub fn start(cfg: Rc<Config>) {
task::spawn(async move {
let pull_id = Rc::new(RefCell::new(0u32));
let cfg = Rc::new(cfg);
loop {
let mut stream = TcpStream::accept(1380, 2048, 2048).await.unwrap();
let pull_id = pull_id.clone();