refactor(ax-task): make IRQ runtime mandatory

Cargo.toml

@@ -22,6 +22,7 @@ members = [
     "components/axtest/axtest_macros",
     "components/ax-lazyinit",
     "components/axbacktrace",
+    "components/bare-task",
     "components/axcpu",
     "components/axerrno",
     "components/axfs-ng-vfs",
@@ -187,6 +188,7 @@ ax-timer-list = { version = "0.3.5", path = "components/timer_list" }
 axaddrspace = { version = "0.5.15", path = "virtualization/axaddrspace" }
 axbacktrace = { version = "0.4.4", path = "components/axbacktrace" }
 axbuild = { version = "0.4.16", path = "scripts/axbuild" }
+bare-task = { version = "0.1.0", path = "components/bare-task" }
 axdevice = { version = "0.5.1", path = "virtualization/axdevice" }
 axdevice_base = { version = "0.6.0", path = "virtualization/axdevice_base" }
 axfs-ng-vfs = { version = "0.5.3", path = "components/axfs-ng-vfs" }

apps/arceos/thread_test/Cargo.toml

@@ -7,7 +7,7 @@ publish = false
 
 [features]
 default = []
-arceos = ["dep:ax-std", "ax-std/multitask", "ax-std/irq"]
+arceos = ["dep:ax-std", "ax-std/multitask"]
 
 [dependencies]
 ax-std = { workspace = true, optional = true }

apps/arceos/tokio_test/Cargo.toml

@@ -8,7 +8,7 @@ publish = false
 
 [features]
 default = []
-arceos = ["dep:ax-std", "ax-std/multitask", "ax-std/irq"]
+arceos = ["dep:ax-std", "ax-std/multitask"]
 
 [dependencies]
 ax-std = { workspace = true, optional = true }

apps/starry/orangepi-5-plus-uvc-rknn/build-aarch64-unknown-none-softfloat.toml

@@ -1,7 +1,6 @@
 # Build-time config for the Orange Pi 5 Plus UVC + RKNN Starry example.
 target = "aarch64-unknown-none-softfloat"
 features = [
-  "ax-driver/irq",
   "ax-driver/list-pci-devices",
   "ax-driver/rk3588-pcie",
   "ax-driver/realtek-rtl8125",

components/axpoll/src/lib.rs

@@ -5,7 +5,7 @@
 
 extern crate alloc;
 
-use alloc::{boxed::Box, vec::Vec};
+use alloc::vec::Vec;
 use core::{
     mem::MaybeUninit,
     task::{Context, Waker},
@@ -64,7 +64,7 @@ pub trait Pollable {
     fn register(&self, context: &mut Context<'_>, events: IoEvents);
 }
 
-const POLL_SET_CAPACITY: usize = 64;
+const IRQ_WAKE_BATCH: usize = 64;
 
 struct Entry {
     waker: Waker,
@@ -78,75 +78,73 @@ impl Entry {
 }
 
 struct Inner {
-    entries: Box<[MaybeUninit<Entry>]>,
-    cursor: usize,
+    entries: Vec<Entry>,
 }
 
 impl Inner {
     fn new() -> Self {
         Self {
-            entries: Box::new_uninit_slice(POLL_SET_CAPACITY),
-            cursor: 0,
+            entries: Vec::new(),
         }
     }
 
-    fn len(&self) -> usize {
-        self.cursor.min(POLL_SET_CAPACITY)
-    }
-
     fn is_empty(&self) -> bool {
-        self.cursor == 0
+        self.entries.is_empty()
     }
 
-    fn push_entry(&mut self, entry: Entry) {
-        debug_assert!(self.cursor < POLL_SET_CAPACITY);
-        let slot = self.cursor;
-        self.cursor += 1;
-        self.entries[slot].write(entry);
-    }
+    fn register(&mut self, waker: &Waker, interests: IoEvents) {
+        for entry in &mut self.entries {
+            if entry.waker.will_wake(waker) {
+                entry.waker = waker.clone();
+                entry.interests |= interests;
+                return;
+            }
+        }
 
-    fn register(&mut self, waker: &Waker, interests: IoEvents) -> Option<Entry> {
-        let slot = self.cursor % POLL_SET_CAPACITY;
-        let replaced = if self.cursor >= POLL_SET_CAPACITY {
-            let old = unsafe { self.entries[slot].assume_init_read() };
-            let replaced = (!old.waker.will_wake(waker)).then_some(old);
-            self.cursor = ((slot + 1) % POLL_SET_CAPACITY) + POLL_SET_CAPACITY;
-            replaced
-        } else {
-            self.cursor += 1;
-            None
-        };
-        self.entries[slot].write(Entry {
+        self.entries.push(Entry {
             waker: waker.clone(),
             interests,
         });
-        replaced
     }
 
     fn drain_ready(&mut self, ready: IoEvents, ready_entries: &mut Vec<Entry>) {
         if self.is_empty() {
             return;
         }
 
-        let mut old = Self::new();
-        core::mem::swap(&mut old, self);
+        let mut index = 0;
+        while index < self.entries.len() {
+            if self.entries[index].interests.intersects(ready) {
+                ready_entries.push(self.entries.swap_remove(index));
+            } else {
+                index += 1;
+            }
+        }
+    }
 
-        for i in 0..old.len() {
-            let entry = unsafe { old.entries[i].assume_init_read() };
-            if entry.interests.intersects(ready) {
-                ready_entries.push(entry);
+    fn drain_ready_batch(
+        &mut self,
+        ready: IoEvents,
+        ready_entries: &mut [MaybeUninit<Entry>],
+    ) -> usize {
+        let mut ready_len = 0;
+        let mut index = 0;
+        while index < self.entries.len() && ready_len < ready_entries.len() {
+            if self.entries[index].interests.intersects(ready) {
+                ready_entries[ready_len].write(self.entries.swap_remove(index));
+                ready_len += 1;
             } else {
-                self.push_entry(entry);
+                index += 1;
             }
         }
-        old.cursor = 0;
+        ready_len
     }
 }
 
 impl Drop for Inner {
     fn drop(&mut self) {
-        for i in 0..self.len() {
-            unsafe { self.entries[i].assume_init_read() }.wake();
+        for entry in self.entries.drain(..) {
+            entry.wake();
         }
     }
 }
@@ -174,15 +172,10 @@ impl PollSet {
     /// from hard IRQ, NMI, or trap callbacks, and must not hold locks that may
     /// be re-entered by the registered waker or by poll wakeup paths.
     pub unsafe fn register(&self, waker: &Waker, interests: IoEvents) {
-        let replaced = {
-            self.0
-                .call_once(|| SpinNoIrq::new(Inner::new()))
-                .lock()
-                .register(waker, interests)
-        };
-        if let Some(entry) = replaced {
-            entry.wake();
-        }
+        self.0
+            .call_once(|| SpinNoIrq::new(Inner::new()))
+            .lock()
+            .register(waker, interests);
     }
 
     /// Wakes up registered wakers whose interests intersect `ready`.
@@ -198,7 +191,7 @@ impl PollSet {
         let Some(inner) = self.0.get() else {
             return 0;
         };
-        let mut ready_entries = Vec::with_capacity(POLL_SET_CAPACITY);
+        let mut ready_entries = Vec::new();
         {
             inner.lock().drain_ready(ready, &mut ready_entries);
         }
@@ -211,42 +204,34 @@ impl PollSet {
 
     /// Wakes up registered wakers whose interests intersect `ready` from IRQ context.
     ///
-    /// Unlike [`wake`](Self::wake), this does not allocate a replacement
-    /// waiter buffer. It drains the already-initialized entries in place, so
-    /// device IRQ handlers can acknowledge the device and then wake matching
-    /// poll waiters without allocating in hard IRQ context.
+    /// This method is kept for legacy users only. New hard IRQ code should
+    /// publish state into the device/backend and wake a deferred worker via an
+    /// IRQ-safe task waker instead. Unlike [`wake`](Self::wake), this method
+    /// avoids allocation by draining matching entries in fixed-size batches.
     pub fn wake_from_irq(&self, ready: IoEvents) -> usize {
         let Some(inner) = self.0.get() else {
             return 0;
         };
-        let mut ready_entries = [const { MaybeUninit::<Entry>::uninit() }; POLL_SET_CAPACITY];
-        let ready_len = {
-            let mut inner = inner.lock();
-            let len = inner.len();
-            if len == 0 {
-                return 0;
-            }
 
-            let mut ready_len = 0;
-            let mut keep_len = 0;
-            for i in 0..len {
-                let entry = unsafe { inner.entries[i].assume_init_read() };
-                if entry.interests.intersects(ready) {
-                    ready_entries[ready_len].write(entry);
-                    ready_len += 1;
-                } else {
-                    inner.entries[keep_len].write(entry);
-                    keep_len += 1;
+        let mut woke = 0;
+        loop {
+            let mut ready_entries = [const { MaybeUninit::<Entry>::uninit() }; IRQ_WAKE_BATCH];
+            let ready_len = {
+                let mut inner = inner.lock();
+                if inner.is_empty() {
+                    return woke;
                 }
+                inner.drain_ready_batch(ready, &mut ready_entries)
+            };
+            if ready_len == 0 {
+                return woke;
             }
-            inner.cursor = keep_len;
-            ready_len
-        };
 
-        for entry in ready_entries.iter_mut().take(ready_len) {
-            unsafe { entry.assume_init_read() }.wake();
+            woke += ready_len;
+            for entry in ready_entries.iter_mut().take(ready_len) {
+                unsafe { entry.assume_init_read() }.wake();
+            }
         }
-        ready_len
     }
 }