changing to semaphore heavy solution

src/runtime/src/comms.rs

@@ -4,9 +4,7 @@ use core::{cell::RefCell, fmt, slice, str};
 use core_io::Error as IoError;
 use cslice::CSlice;
 use dyld::elf;
-use futures::{future::FutureExt, select_biased};
+use futures::{future::FutureExt, select_biased}; #[cfg(has_drtio)] use io::Cursor;
-#[cfg(has_drtio)]
-use io::Cursor;
 #[cfg(has_drtio)]
 use ksupport::rpc;
 use ksupport::{kernel, resolve_channel_name};
@@ -807,89 +805,82 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
     let restart_idle = Rc::new(Semaphore::new(0, 1));
     mgmt::start(cfg.clone(), restart_idle.clone());
     
-    task::spawn(async move {
+    let semaphores = Rc::new(
-        let terminate = Rc::new(Semaphore::new(0, 1));
+        (Semaphore::new(0, 1), 
-        let running = Rc::new(Mutex::new(false));
+         Semaphore::new(1, 1),
-        let repeat_lock = Rc::new(Mutex::new(false));
+         Semaphore::new(1, 1),
-        let restart_idle = restart_idle.clone();
+         Semaphore::new(1, 1)));
-        let cfg = cfg.clone();
-        let control = control.clone();
-        let up_destinations = up_destinations.clone();
-        let aux_mutex = aux_mutex.clone();
-        let routing_table = drtio_routing_table.clone();
     
-        select_biased! {
+    // handle connects
-            _ = (async {
+    task::spawn(async move {
         loop {
-                        let cfg = cfg.clone();
+            clone_mult!(semaphores, control, up_destinations, aux_mutex, routing_table);
-                        let control = control.clone();
+            semaphores.0.async_wait().await;
-                        let up_destinations = up_destinations.clone();
+            semaphores.1.try_wait();
-                        let aux_mutex = aux_mutex.clone();
+            let _ = task_lock.async_lock().await;
-                        let routing_table = drtio_routing_table.clone();
-                        let terminate = terminate.clone();
-                        let running = running.clone();
-                        let repeat_lock = repeat_lock.clone();
-
-                        info!("awaiting connection");
-                        if let Ok(mut stream) = TcpStream::accept(1381, 0x10_000, 0x10_000).await {
-                            info!("accepted connection");
-                            task::spawn(async move {
-                                info!("awaiting lock");
-                                let _rep_lock = repeat_lock.async_lock().await;
-                                terminate.signal();
-                                let _lock = running.async_lock().await;
-                                drop(_rep_lock);
-                                info!("lock achieved");
-                                let routing_table = routing_table.borrow();
             select_biased! {
                 _ = (async {
-                                        info!("pre handling connection");
+                    // run connection
+                    let mut stream = stream_opt.borrow_mut()?;
                     let _ = handle_connection(&mut stream, control.clone(), &up_destinations, &aux_mutex, &routing_table, timer)
                         .await
                         .map_err(|e| warn!("connection terminated: {}", e));
-                                    }).fuse() => (),
+                }).fuse() => {
-                                    _ = terminate.async_wait().fuse() => ()
+                    semaphores.2.signal();
+                },
+                _ = semaphores.1.async_wait().fuse() => (),
+            }
         }
-                                drop(_lock);
-                                let _ = stream.flush().await;
-                                let _ = stream.abort().await;
     });
-                        } else {
-                            info!("failed to accept connection");
-                        }
-                    }
-            }).fuse() => (),
-            _ = (async {
-                    loop {
-                        let cfg = cfg.clone();
-                        let control = control.clone();
-                        let up_destinations = up_destinations.clone();
-                        let aux_mutex = aux_mutex.clone();
-                        let routing_table = drtio_routing_table.clone();
-                        let terminate = terminate.clone();
-                        let running = running.clone();
-                        let repeat_lock = repeat_lock.clone();
-                        let restart_idle = restart_idle.clone();
     
-                        let _rep_lock = repeat_lock.async_lock().await;
+    // handle idle
-                        drop(_rep_lock);
+    task::spawn(async move {
-                        info!("getting lock idle kernel");
+        loop {
-                        let _lock = running.async_lock().await;
+            clone_mult!(semaphores, control, up_destinations, aux_mutex, routing_table);
-                        info!("locked idle kernel");
+            semaphores.2.async_wait().await;
-                        let routing_table = routing_table.borrow();
+            semaphores.3.try_wait();
+            let _ = task_lock.async_lock().await;
             select_biased! {
                 _ = (async {
                     if let Some(buffer) = cfg.read("idle_kernel").ok() {
                         load_and_run_idle_kernel(&buffer, &control, &up_destinations, &aux_mutex, &routing_table, timer).await;
                     }
                 }).fuse() => (),
-                                _ = terminate.async_wait().fuse() => (),
+                _ = semaphores.3.async_wait().fuse() => (),
-                                _ = restart_idle.async_wait().fuse() => ()
+            }
+        }
+    });
+
+    task::spawn(async move {
+        loop {
+            select_biased! {
+                _ = (async {
+                        let temp_s = Some(TcpStream::accept(1381, 0x10_000, 0x10_000).await.unwrap()); // ALT: implement dummy
+                    // tcp stream that is empty (another reason the priv construct is annoying)
+                        if let Some(&stream) = stream_opt {
+                           let _ = stream.flush().await;
+                           let _ = stream.abort().await;
+                        }
+                        stream_opt.replace(temp_s);
+                    }).fuse() => {
+                        if semaphore.1.try_wait().is_none() {
+                            semaphore.1.signal(); // STOP KERNEL
+                        }
+                        if semaphore.3.try_wait().is_none() {
+                            semaphore.3.signal(); // STOP IDLE
+                        }
+                        // if the other stream exists -> flush it and replace with the new stream
+                        semaphore.0.signal(); // NEW KERNEL
+                    }
+                _ = (async {
+                        restart_idle.wait_async().await;
+                    }).fuse() => {
+                        if semaphore.3.try_wait().is_none() {
+                            semaphore.3.signal(); // STOP IDLE
+                            semaphore.2.signal(); // NEW IDLE
+                        }
                     }
-                        info!("supposed to drop idle kernel");
-                        drop(_lock);
             }
-            }).fuse() => (),
         }
     });
 
@@ -950,3 +941,15 @@ pub fn soft_panic_main(timer: GlobalTimer, cfg: Config) -> ! {
 
     Sockets::run(&mut iface, || Instant::from_millis(timer.get_time().0 as i32));
 }
+
+macro_rules! clone_mult {
+    ($id:ident) => {
+        let $id = $id.clone();
+    };
+
+    // Decompose multiple `eval`s recursively
+    ($id:ident, $($ids:ident),+) => {
+        clone_mult!($id)
+        clone_mult!($($ids),+)
+    };
+}

src/runtime/src/mgmt.rs

@@ -201,10 +201,11 @@ async fn handle_connection(stream: &mut TcpStream, pull_id: Rc<RefCell<u32>>, cf
                 let value = cfg.write(&key, buffer);
                 if value.is_ok() {
                     debug!("write success");
-                    write_i8(stream, Reply::Success as i8).await?;
                     if key == "idle_kernel" {
-                        restart_idle.signal();
+                        restart_idle.1.async_wait().await?;
+                        restart_idle.0.signal();
                     }
+                    write_i8(stream, Reply::Success as i8).await?;
                 } else {
                     // this is an error because we do not expect write to fail
                     error!("failed to write: {:?}", value);