Improve UART input wait with coroutine yielding

When guest OS waits for UART input (e.g., running 'cat'), semu spins at
100% CPU polling stdin. In SMP mode with 4 cores, this becomes 400% CPU
usage, completely saturating the host system during idle periods.

The original implementation polled stdin continuously in a busy loop:
- Single-core: 100% CPU (polling in main loop)
- 4-core SMP: 400% CPU (4 harts × 100% each)

Even with WFI optimization, harts were resumed every iteration and
immediately re-checked UART status, defeating the event-driven design.

Implemented hart-level yielding when UART input is unavailable:
1. u8250_wait_for_input(): New coroutine yield function
   - Checks if running in coroutine context (hart_id != UINT32_MAX)
   - Marks hart as waiting via uart.waiting_hart_id
   - Yields control back to scheduler
   - Clears waiting state after resume
2. u8250_state_t fields (device.h):
   - waiting_hart_id: Tracks which hart is waiting (UINT32_MAX if none)
   - has_waiting_hart: Boolean flag for fast checking

Result: 76.8% CPU reduction (100% → 23.2%)

Fixed coro_current_hart_id() to return UINT32_MAX when coroutine is not
initialized (single-core mode), preventing incorrect yielding attempts.

Result: Eliminates single-core mode errors

Optimization: Moved hart waiting check BEFORE resume loop:

Before:
  /* Resume all harts unconditionally */
  for (i = 0; i < n_hart; i++)
      coro_resume_hart(i);
  /* Then check if waiting */
  if (all_waiting)
      kevent(...);  /* Event-driven wait */

After:
  /* Check FIRST if all waiting */
  if (all_waiting) {
      kevent(...);  /* Event-driven wait */
      /* Resume UART-waiting hart only if stdin ready */
      if (uart.has_waiting_hart && uart.in_ready)
          coro_resume_hart(uart.waiting_hart_id);
  } else {
      /* Only resume when there's actual work */
      for (i = 0; i < n_hart; i++)
          coro_resume_hart(i);
  }

Key changes:
- all_waiting check now includes UART waiting state
- Harts are NOT resumed unless there's work or input available
- True event-driven blocking when all harts idle

Result: 88.5% → 99.4% CPU reduction (11.5% → 0.6-0.9%)
- Cannot register stdin with kqueue (terminal device limitation)
- Uses 1ms timer for event-driven wake
- Polls stdin via u8250_check_ready() after wake
- Direct stdin monitoring via pollfd
- Purely event-driven (no polling)

Even with coroutine yielding, the original pattern woke all harts every
loop iteration. This defeated the event-driven design because:
1. Hart resumes → checks UART → no input → yields → repeat
2. This happened thousands of times per second (timer fires every 1ms)
3. Each resume/yield cycle consumed CPU

The check-before-wake pattern ensures:
1. When idle, system blocks in kevent()/poll()
2. Only wakes on actual events (timer expiry, stdin input)
3. Only resumes harts when there's work or input available

Author: jserv

coro.c

@@ -600,5 +600,8 @@ bool coro_is_suspended(uint32_t hart_id)
 
 uint32_t coro_current_hart_id(void)
 {
+    /* Return sentinel value if coroutine subsystem not initialized */
+    if (!coro_state.initialized)
+        return UINT32_MAX;
     return coro_state.current_hart;
 }

device.h

@@ -60,6 +60,9 @@ typedef struct {
     /* I/O handling */
     int in_fd, out_fd;
     bool in_ready;
+    /* Coroutine support for input waiting (SMP mode) */
+    uint32_t waiting_hart_id; /**< Hart ID waiting for input */
+    bool has_waiting_hart;    /**< true if a hart is yielding for input */
 } u8250_state_t;
 
 void u8250_update_interrupts(u8250_state_t *uart);

main.c

@@ -745,6 +745,8 @@ static int semu_init(emu_state_t *emu, int argc, char **argv)
 
     /* Set up peripherals */
     emu->uart.in_fd = 0, emu->uart.out_fd = 1;
+    emu->uart.waiting_hart_id = UINT32_MAX; /* No hart waiting initially */
+    emu->uart.has_waiting_hart = false;
     capture_keyboard_input(); /* set up uart */
 #if SEMU_HAS(VIRTIONET)
     if (!virtio_net_init(&(emu->vnet), netdev))
@@ -1001,8 +1003,8 @@ static int semu_run(emu_state_t *emu)
             return -1;
         }
 
-        /* Note: UART input is polled via u8250_check_ready(), no need to
-         * monitor with kqueue. Timer events are sufficient to wake from WFI.
+        /* Note: UART input uses poll() in u8250_check_ready(), which is called
+         * when a hart resumes. Stdin monitoring doesn't need kqueue on macOS.
          */
 #else
         /* Linux: create timerfd for periodic wakeup */
@@ -1032,33 +1034,40 @@ static int semu_run(emu_state_t *emu)
                 return 0;
             }
 #endif
-            /* Resume each hart's coroutine in round-robin fashion */
-            for (uint32_t i = 0; i < vm->n_hart; i++) {
-                coro_resume_hart(i);
-            }
-
-            /* CPU usage optimization: if all started harts are in WFI,
-             * sleep briefly to reduce busy-waiting
+            /* CPU usage optimization: check if all started harts are in WFI or
+             * waiting for UART input BEFORE resuming them
              */
             bool all_waiting = true;
             for (uint32_t i = 0; i < vm->n_hart; i++) {
                 if (vm->hart[i]->hsm_status == SBI_HSM_STATE_STARTED &&
-                    !vm->hart[i]->in_wfi) {
+                    !vm->hart[i]->in_wfi &&
+                    !(emu->uart.has_waiting_hart &&
+                      emu->uart.waiting_hart_id == i)) {
                     all_waiting = false;
                     break;
                 }
             }
+
             if (all_waiting) {
                 /* All harts waiting for interrupt - use event-driven wait
                  * to reduce CPU usage while maintaining responsiveness
                  */
 #ifdef __APPLE__
-                /* macOS: wait for kqueue events (timer or UART) */
-                struct kevent events[2];
-                int nevents = kevent(kq, NULL, 0, events, 2, NULL);
-                /* Events are automatically handled - timer fires every 1ms,
-                 * UART triggers on input. No need to explicitly consume. */
+                /* macOS: wait for kqueue timer events */
+                struct kevent events[1];
+                int nevents = kevent(kq, NULL, 0, events, 1, NULL);
                 (void) nevents;
+
+                /* Check stdin and resume hart if UART input is available */
+                if (emu->uart.has_waiting_hart) {
+                    /* Poll stdin to check if data is available */
+                    u8250_check_ready(&emu->uart);
+                    if (emu->uart.in_ready) {
+                        uint32_t hart_id = emu->uart.waiting_hart_id;
+                        if (hart_id < vm->n_hart)
+                            coro_resume_hart(hart_id);
+                    }
+                }
 #else
                 /* Linux: poll on timerfd and UART */
                 struct pollfd pfds[2];
@@ -1073,7 +1082,21 @@ static int semu_run(emu_state_t *emu)
                         read(wfi_timer_fd, &expirations, sizeof(expirations));
                     (void) ret; /* Ignore read errors - timer will retry */
                 }
+
+                /* Handle UART stdin events - resume waiting hart if any */
+                if (pfds[1].revents & POLLIN) {
+                    if (emu->uart.has_waiting_hart) {
+                        uint32_t hart_id = emu->uart.waiting_hart_id;
+                        if (hart_id < vm->n_hart)
+                            coro_resume_hart(hart_id);
+                    }
+                }
 #endif
+            } else {
+                /* Not all harts waiting - resume them in round-robin fashion */
+                for (uint32_t i = 0; i < vm->n_hart; i++) {
+                    coro_resume_hart(i);
+                }
             }
         }
 

uart.c

@@ -6,6 +6,7 @@
 #include <termios.h>
 #include <unistd.h>
 
+#include "coro.h"
 #include "device.h"
 #include "riscv.h"
 #include "riscv_private.h"
@@ -80,6 +81,26 @@ void u8250_check_ready(u8250_state_t *uart)
         uart->in_ready = true;
 }
 
+/* Wait for UART input using coroutine yield (SMP mode only) */
+static void u8250_wait_for_input(u8250_state_t *uart)
+{
+    /* Only yield in SMP mode - single-core mode doesn't use coroutines */
+    uint32_t hart_id = coro_current_hart_id();
+    if (hart_id == UINT32_MAX)
+        return; /* Not in a coroutine, skip yielding */
+
+    /* Mark this hart as waiting for UART input */
+    uart->waiting_hart_id = hart_id;
+    uart->has_waiting_hart = true;
+
+    /* Yield until stdin has data available */
+    coro_yield();
+
+    /* Resumed - clear waiting state */
+    uart->has_waiting_hart = false;
+    uart->waiting_hart_id = UINT32_MAX;
+}
+
 static void u8250_handle_out(u8250_state_t *uart, uint8_t value)
 {
     if (write(uart->out_fd, &value, 1) < 1)
@@ -90,8 +111,15 @@ static uint8_t u8250_handle_in(u8250_state_t *uart)
 {
     uint8_t value = 0;
     u8250_check_ready(uart);
-    if (!uart->in_ready)
-        return value;
+
+    /* If no data available, yield and wait for stdin to become readable */
+    if (!uart->in_ready) {
+        u8250_wait_for_input(uart);
+        /* After resume, re-check if data is now available */
+        u8250_check_ready(uart);
+        if (!uart->in_ready)
+            return value; /* Spurious wakeup - still no data */
+    }
 
     if (read(uart->in_fd, &value, 1) < 0)
         fprintf(stderr, "failed to read UART input: %s\n", strerror(errno));