Remove the non-specific thread-mode executor

embassy-executor/src/arch/cortex_m.rs

@@ -1,122 +1,236 @@
-#[cfg(feature = "executor-thread")]
+const THREAD_PENDER: usize = usize::MAX;
-pub use thread::*;
 
-use crate::raw::PenderContext;
-
-#[cfg(feature = "executor-interrupt")]
-
-/// # Safety
-///
-/// `irq` must be a valid interrupt request number
-unsafe fn nvic_pend(irq: u16) {
-    use cortex_m::interrupt::InterruptNumber;
-
-    #[derive(Clone, Copy)]
-    struct Irq(u16);
-    unsafe impl InterruptNumber for Irq {
-        fn number(self) -> u16 {
-            self.0
-        }
-    }
-
-    let irq = Irq(irq);
-
-    // STIR is faster, but is only available in v7 and higher.
-    #[cfg(not(armv6m))]
-    {
-        let mut nvic: cortex_m::peripheral::NVIC = unsafe { core::mem::transmute(()) };
-        nvic.request(irq);
-    }
-
-    #[cfg(armv6m)]
-    cortex_m::peripheral::NVIC::pend(irq);
-}
-
-#[cfg(all(feature = "executor-thread", feature = "executor-interrupt"))]
 #[export_name = "__pender"]
-fn __pender(context: PenderContext) {
+#[cfg(any(feature = "executor-thread", feature = "executor-interrupt"))]
+fn __pender(context: crate::raw::PenderContext) {
     unsafe {
-        let context: usize = core::mem::transmute(context);
         // Safety: `context` is either `usize::MAX` created by `Executor::run`, or a valid interrupt
         // request number given to `InterruptExecutor::start`.
-        if context as usize == usize::MAX {
+
-            core::arch::asm!("sev")
+        let context: usize = core::mem::transmute(context);
-        } else {
+
-            nvic_pend(context as u16)
+        #[cfg(feature = "executor-thread")]
+        if context == THREAD_PENDER {
+            core::arch::asm!("sev");
+            return;
+        }
+
+        #[cfg(feature = "executor-interrupt")]
+        {
+            use cortex_m::interrupt::InterruptNumber;
+            use cortex_m::peripheral::NVIC;
+
+            #[derive(Clone, Copy)]
+            struct Irq(u16);
+            unsafe impl InterruptNumber for Irq {
+                fn number(self) -> u16 {
+                    self.0
+                }
+            }
+
+            let irq = Irq(context as u16);
+
+            // STIR is faster, but is only available in v7 and higher.
+            #[cfg(not(armv6m))]
+            {
+                let mut nvic: NVIC = core::mem::transmute(());
+                nvic.request(irq);
+            }
+
+            #[cfg(armv6m)]
+            NVIC::pend(irq);
         }
     }
 }
 
-#[cfg(all(feature = "executor-thread", not(feature = "executor-interrupt")))]
+#[cfg(feature = "executor-thread")]
-#[export_name = "__pender"]
+pub use thread::*;
-fn __pender(_context: PenderContext) {
-    unsafe { core::arch::asm!("sev") }
-}
-
-#[cfg(all(not(feature = "executor-thread"), feature = "executor-interrupt"))]
-#[export_name = "__pender"]
-fn __pender(context: PenderContext) {
-    unsafe {
-        let context: usize = core::mem::transmute(context);
-        // Safety: `context` is the same value we passed to `InterruptExecutor::start`, which must
-        // be a valid interrupt request number.
-        nvic_pend(context as u16)
-    }
-}
-
 #[cfg(feature = "executor-thread")]
 mod thread {
+    use core::arch::asm;
+    use core::marker::PhantomData;
 
     #[cfg(feature = "nightly")]
     pub use embassy_macros::main_cortex_m as main;
 
-    use crate::raw::PenderContext;
+    use crate::arch::THREAD_PENDER;
-    use crate::thread::ThreadContext;
+    use crate::{raw, Spawner};
 
-    /// TODO
+    /// Thread mode executor, using WFE/SEV.
-    // Name pending
+    ///
-    #[derive(Default)] // Default enables Executor::new
+    /// This is the simplest and most common kind of executor. It runs on
-    pub struct Context;
+    /// thread mode (at the lowest priority level), and uses the `WFE` ARM instruction
-
+    /// to sleep when it has no more work to do. When a task is woken, a `SEV` instruction
-    impl ThreadContext for Context {
+    /// is executed, to make the `WFE` exit from sleep and poll the task.
-        fn context(&self) -> PenderContext {
+    ///
-            unsafe { core::mem::transmute(usize::MAX) }
+    /// This executor allows for ultra low power consumption for chips where `WFE`
-        }
+    /// triggers low-power sleep without extra steps. If your chip requires extra steps,
-
+    /// you may use [`raw::Executor`] directly to program custom behavior.
-        fn wait(&mut self) {
+    pub struct Executor {
-            unsafe { core::arch::asm!("wfe") }
+        inner: raw::Executor,
-        }
+        not_send: PhantomData<*mut ()>,
     }
 
-    /// TODO
+    impl Executor {
-    // Type alias for backwards compatibility
+        /// Create a new Executor.
-    pub type Executor = crate::thread::ThreadModeExecutor<Context>;
+        pub fn new() -> Self {
+            Self {
+                inner: raw::Executor::new(unsafe { core::mem::transmute(THREAD_PENDER) }),
+                not_send: PhantomData,
+            }
+        }
+
+        /// Run the executor.
+        ///
+        /// The `init` closure is called with a [`Spawner`] that spawns tasks on
+        /// this executor. Use it to spawn the initial task(s). After `init` returns,
+        /// the executor starts running the tasks.
+        ///
+        /// To spawn more tasks later, you may keep copies of the [`Spawner`] (it is `Copy`),
+        /// for example by passing it as an argument to the initial tasks.
+        ///
+        /// This function requires `&'static mut self`. This means you have to store the
+        /// Executor instance in a place where it'll live forever and grants you mutable
+        /// access. There's a few ways to do this:
+        ///
+        /// - a [StaticCell](https://docs.rs/static_cell/latest/static_cell/) (safe)
+        /// - a `static mut` (unsafe)
+        /// - a local variable in a function you know never returns (like `fn main() -> !`), upgrading its lifetime with `transmute`. (unsafe)
+        ///
+        /// This function never returns.
+        pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
+            init(self.inner.spawner());
+
+            loop {
+                unsafe {
+                    self.inner.poll();
+                    asm!("wfe");
+                };
+            }
+        }
+    }
 }
 
 #[cfg(feature = "executor-interrupt")]
 pub use interrupt::*;
 #[cfg(feature = "executor-interrupt")]
 mod interrupt {
+    use core::cell::UnsafeCell;
+    use core::mem::MaybeUninit;
+
+    use atomic_polyfill::{AtomicBool, Ordering};
     use cortex_m::interrupt::InterruptNumber;
     use cortex_m::peripheral::NVIC;
 
-    use crate::interrupt::InterruptContext;
+    use crate::raw;
-    use crate::raw::PenderContext;
 
-    impl<T> InterruptContext for T
+    /// Interrupt mode executor.
-    where
+    ///
-        T: InterruptNumber,
+    /// This executor runs tasks in interrupt mode. The interrupt handler is set up
-    {
+    /// to poll tasks, and when a task is woken the interrupt is pended from software.
-        fn context(&self) -> PenderContext {
+    ///
-            unsafe { core::mem::transmute(self.number() as usize) }
+    /// This allows running async tasks at a priority higher than thread mode. One
-        }
+    /// use case is to leave thread mode free for non-async tasks. Another use case is
-
+    /// to run multiple executors: one in thread mode for low priority tasks and another in
-        fn enable(&self) {
+    /// interrupt mode for higher priority tasks. Higher priority tasks will preempt lower
-            unsafe { NVIC::unmask(*self) }
+    /// priority ones.
-        }
+    ///
+    /// It is even possible to run multiple interrupt mode executors at different priorities,
+    /// by assigning different priorities to the interrupts. For an example on how to do this,
+    /// See the 'multiprio' example for 'embassy-nrf'.
+    ///
+    /// To use it, you have to pick an interrupt that won't be used by the hardware.
+    /// Some chips reserve some interrupts for this purpose, sometimes named "software interrupts" (SWI).
+    /// If this is not the case, you may use an interrupt from any unused peripheral.
+    ///
+    /// It is somewhat more complex to use, it's recommended to use the thread-mode
+    /// [`Executor`] instead, if it works for your use case.
+    pub struct InterruptExecutor {
+        started: AtomicBool,
+        executor: UnsafeCell<MaybeUninit<raw::Executor>>,
     }
 
-    /// TODO
+    unsafe impl Send for InterruptExecutor {}
-    // Type alias for backwards compatibility
+    unsafe impl Sync for InterruptExecutor {}
-    pub type InterruptExecutor = crate::interrupt::InterruptModeExecutor;
+
+    impl InterruptExecutor {
+        /// Create a new, not started `InterruptExecutor`.
+        #[inline]
+        pub const fn new() -> Self {
+            Self {
+                started: AtomicBool::new(false),
+                executor: UnsafeCell::new(MaybeUninit::uninit()),
+            }
+        }
+
+        /// Executor interrupt callback.
+        ///
+        /// # Safety
+        ///
+        /// You MUST call this from the interrupt handler, and from nowhere else.
+        pub unsafe fn on_interrupt(&'static self) {
+            let executor = unsafe { (&*self.executor.get()).assume_init_ref() };
+            executor.poll();
+        }
+
+        /// Start the executor.
+        ///
+        /// This initializes the executor, enables the interrupt, and returns.
+        /// The executor keeps running in the background through the interrupt.
+        ///
+        /// This returns a [`SendSpawner`] you can use to spawn tasks on it. A [`SendSpawner`]
+        /// is returned instead of a [`Spawner`](embassy_executor::Spawner) because the executor effectively runs in a
+        /// different "thread" (the interrupt), so spawning tasks on it is effectively
+        /// sending them.
+        ///
+        /// To obtain a [`Spawner`](embassy_executor::Spawner) for this executor, use [`Spawner::for_current_executor()`](embassy_executor::Spawner::for_current_executor()) from
+        /// a task running in it.
+        ///
+        /// # Interrupt requirements
+        ///
+        /// You must write the interrupt handler yourself, and make it call [`on_interrupt()`](Self::on_interrupt).
+        ///
+        /// This method already enables (unmasks) the interrupt, you must NOT do it yourself.
+        ///
+        /// You must set the interrupt priority before calling this method. You MUST NOT
+        /// do it after.
+        ///
+        pub fn start(&'static self, irq: impl InterruptNumber) -> crate::SendSpawner {
+            if self
+                .started
+                .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+                .is_err()
+            {
+                panic!("InterruptExecutor::start() called multiple times on the same executor.");
+            }
+
+            unsafe {
+                let context = core::mem::transmute(irq.number() as usize);
+                (&mut *self.executor.get())
+                    .as_mut_ptr()
+                    .write(raw::Executor::new(context))
+            }
+
+            let executor = unsafe { (&*self.executor.get()).assume_init_ref() };
+
+            unsafe { NVIC::unmask(irq) }
+
+            executor.spawner().make_send()
+        }
+
+        /// Get a SendSpawner for this executor
+        ///
+        /// This returns a [`SendSpawner`] you can use to spawn tasks on this
+        /// executor.
+        ///
+        /// This MUST only be called on an executor that has already been spawned.
+        /// The function will panic otherwise.
+        pub fn spawner(&'static self) -> crate::SendSpawner {
+            if !self.started.load(Ordering::Acquire) {
+                panic!("InterruptExecutor::spawner() called on uninitialized executor.");
+            }
+            let executor = unsafe { (&*self.executor.get()).assume_init_ref() };
+            executor.spawner().make_send()
+        }
+    }
 }

embassy-executor/src/arch/riscv32.rs

@@ -5,53 +5,77 @@ compile_error!("`executor-interrupt` is not supported with `arch-riscv32`.");
 pub use thread::*;
 #[cfg(feature = "executor-thread")]
 mod thread {
+    use core::marker::PhantomData;
     use core::sync::atomic::{AtomicBool, Ordering};
 
     #[cfg(feature = "nightly")]
     pub use embassy_macros::main_riscv as main;
 
-    use crate::raw::PenderContext;
+    use crate::{raw, Spawner};
-    use crate::thread::ThreadContext;
 
     /// global atomic used to keep track of whether there is work to do since sev() is not available on RISCV
     static SIGNAL_WORK_THREAD_MODE: AtomicBool = AtomicBool::new(false);
 
     #[export_name = "__pender"]
-    fn __thread_mode_pender(_context: PenderContext) {
+    fn __thread_mode_pender(_context: crate::raw::PenderContext) {
         SIGNAL_WORK_THREAD_MODE.store(true, Ordering::SeqCst);
     }
 
-    /// TODO
+    /// RISCV32 Executor
-    // Name pending
+    pub struct Executor {
-    #[derive(Default)] // Default enables Executor::new
+        inner: raw::Executor,
-    pub struct Context;
+        not_send: PhantomData<*mut ()>,
-
-    impl ThreadContext for Context {
-        fn context(&self) -> PenderContext {
-            unsafe { core::mem::transmute(0) }
-        }
-
-        fn wait(&mut self) {
-            // We do not care about race conditions between the load and store operations,
-            // interrupts will only set this value to true.
-            critical_section::with(|_| {
-                // if there is work to do, loop back to polling
-                // TODO can we relax this?
-                if SIGNAL_WORK_THREAD_MODE.load(Ordering::SeqCst) {
-                    SIGNAL_WORK_THREAD_MODE.store(false, Ordering::SeqCst);
-                }
-                // if not, wait for interrupt
-                else {
-                    unsafe {
-                        core::arch::asm!("wfi");
-                    }
-                }
-            });
-            // if an interrupt occurred while waiting, it will be serviced here
-        }
     }
 
-    /// TODO
+    impl Executor {
-    // Type alias for backwards compatibility
+        /// Create a new Executor.
-    pub type Executor = crate::thread::ThreadModeExecutor<Context>;
+        pub fn new() -> Self {
+            Self {
+                inner: raw::Executor::new(unsafe { core::mem::transmute(0) }),
+                not_send: PhantomData,
+            }
+        }
+
+        /// Run the executor.
+        ///
+        /// The `init` closure is called with a [`Spawner`] that spawns tasks on
+        /// this executor. Use it to spawn the initial task(s). After `init` returns,
+        /// the executor starts running the tasks.
+        ///
+        /// To spawn more tasks later, you may keep copies of the [`Spawner`] (it is `Copy`),
+        /// for example by passing it as an argument to the initial tasks.
+        ///
+        /// This function requires `&'static mut self`. This means you have to store the
+        /// Executor instance in a place where it'll live forever and grants you mutable
+        /// access. There's a few ways to do this:
+        ///
+        /// - a [StaticCell](https://docs.rs/static_cell/latest/static_cell/) (safe)
+        /// - a `static mut` (unsafe)
+        /// - a local variable in a function you know never returns (like `fn main() -> !`), upgrading its lifetime with `transmute`. (unsafe)
+        ///
+        /// This function never returns.
+        pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
+            init(self.inner.spawner());
+
+            loop {
+                unsafe {
+                    self.inner.poll();
+                    // we do not care about race conditions between the load and store operations, interrupts
+                    //will only set this value to true.
+                    critical_section::with(|_| {
+                        // if there is work to do, loop back to polling
+                        // TODO can we relax this?
+                        if SIGNAL_WORK_THREAD_MODE.load(Ordering::SeqCst) {
+                            SIGNAL_WORK_THREAD_MODE.store(false, Ordering::SeqCst);
+                        }
+                        // if not, wait for interrupt
+                        else {
+                            core::arch::asm!("wfi");
+                        }
+                    });
+                    // if an interrupt occurred while waiting, it will be serviced here
+                }
+            }
+        }
+    }
 }

embassy-executor/src/arch/std.rs

@@ -5,42 +5,64 @@ compile_error!("`executor-interrupt` is not supported with `arch-std`.");
 pub use thread::*;
 #[cfg(feature = "executor-thread")]
 mod thread {
+    use std::marker::PhantomData;
     use std::sync::{Condvar, Mutex};
 
     #[cfg(feature = "nightly")]
     pub use embassy_macros::main_std as main;
 
-    use crate::raw::PenderContext;
+    use crate::{raw, Spawner};
-    use crate::thread::ThreadContext;
 
-    /// TODO
+    #[export_name = "__pender"]
-    // Name pending
+    fn __pender(context: crate::raw::PenderContext) {
-    pub struct Context {
+        let signaler: &'static Signaler = unsafe { std::mem::transmute(context) };
+        signaler.signal()
+    }
+
+    /// Single-threaded std-based executor.
+    pub struct Executor {
+        inner: raw::Executor,
+        not_send: PhantomData<*mut ()>,
         signaler: &'static Signaler,
     }
 
-    impl Default for Context {
+    impl Executor {
-        fn default() -> Self {
+        /// Create a new Executor.
+        pub fn new() -> Self {
+            let signaler = &*Box::leak(Box::new(Signaler::new()));
             Self {
-                signaler: &*Box::leak(Box::new(Signaler::new())),
+                inner: raw::Executor::new(unsafe { std::mem::transmute(signaler) }),
+                not_send: PhantomData,
+                signaler,
             }
         }
-    }
 
-    impl ThreadContext for Context {
+        /// Run the executor.
-        fn context(&self) -> PenderContext {
+        ///
-            unsafe { core::mem::transmute(self.signaler) }
+        /// The `init` closure is called with a [`Spawner`] that spawns tasks on
+        /// this executor. Use it to spawn the initial task(s). After `init` returns,
+        /// the executor starts running the tasks.
+        ///
+        /// To spawn more tasks later, you may keep copies of the [`Spawner`] (it is `Copy`),
+        /// for example by passing it as an argument to the initial tasks.
+        ///
+        /// This function requires `&'static mut self`. This means you have to store the
+        /// Executor instance in a place where it'll live forever and grants you mutable
+        /// access. There's a few ways to do this:
+        ///
+        /// - a [StaticCell](https://docs.rs/static_cell/latest/static_cell/) (safe)
+        /// - a `static mut` (unsafe)
+        /// - a local variable in a function you know never returns (like `fn main() -> !`), upgrading its lifetime with `transmute`. (unsafe)
+        ///
+        /// This function never returns.
+        pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
+            init(self.inner.spawner());
+
+            loop {
+                unsafe { self.inner.poll() };
+                self.signaler.wait()
+            }
         }
-
-        fn wait(&mut self) {
-            self.signaler.wait()
-        }
-    }
-
-    #[export_name = "__pender"]
-    fn __pender(context: PenderContext) {
-        let signaler: &'static Signaler = unsafe { std::mem::transmute(context) };
-        signaler.signal()
     }
 
     struct Signaler {
@@ -70,8 +92,4 @@ mod thread {
             self.condvar.notify_one();
         }
     }
-
-    /// TODO
-    // Type alias for backwards compatibility
-    pub type Executor = crate::thread::ThreadModeExecutor<Context>;
 }

embassy-executor/src/arch/xtensa.rs

@@ -8,56 +8,80 @@ mod thread {
     use core::marker::PhantomData;
     use core::sync::atomic::{AtomicBool, Ordering};
 
-    use crate::raw::PenderContext;
+    use crate::{raw, Spawner};
-    use crate::thread::ThreadContext;
 
     /// global atomic used to keep track of whether there is work to do since sev() is not available on Xtensa
     static SIGNAL_WORK_THREAD_MODE: AtomicBool = AtomicBool::new(false);
 
     #[export_name = "__thread_mode_pender"]
-    fn __thread_mode_pender(_context: PenderContext) {
+    fn __thread_mode_pender(_context: crate::raw::PenderContext) {
         SIGNAL_WORK_THREAD_MODE.store(true, Ordering::SeqCst);
     }
 
-    /// TODO
+    /// Xtensa Executor
-    // Name pending
+    pub struct Executor {
-    #[derive(Default)] // Default enables Executor::new
+        inner: raw::Executor,
-    pub struct Context;
+        not_send: PhantomData<*mut ()>,
+    }
 
-    impl ThreadContext for Context {
+    impl Executor {
-        fn context(&self) -> PenderContext {
+        /// Create a new Executor.
-            unsafe { core::mem::transmute(0) }
+        pub fn new() -> Self {
+            Self {
+                inner: raw::Executor::new(unsafe { core::mem::transmute(0) }),
+                not_send: PhantomData,
+            }
         }
 
-        fn wait(&mut self) {
+        /// Run the executor.
-            unsafe {
+        ///
-                // Manual critical section implementation that only masks interrupts handlers.
+        /// The `init` closure is called with a [`Spawner`] that spawns tasks on
-                // We must not acquire the cross-core on dual-core systems because that would
+        /// this executor. Use it to spawn the initial task(s). After `init` returns,
-                // prevent the other core from doing useful work while this core is sleeping.
+        /// the executor starts running the tasks.
-                let token: critical_section::RawRestoreState;
+        ///
-                core::arch::asm!("rsil {0}, 5", out(reg) token);
+        /// To spawn more tasks later, you may keep copies of the [`Spawner`] (it is `Copy`),
+        /// for example by passing it as an argument to the initial tasks.
+        ///
+        /// This function requires `&'static mut self`. This means you have to store the
+        /// Executor instance in a place where it'll live forever and grants you mutable
+        /// access. There's a few ways to do this:
+        ///
+        /// - a [StaticCell](https://docs.rs/static_cell/latest/static_cell/) (safe)
+        /// - a `static mut` (unsafe)
+        /// - a local variable in a function you know never returns (like `fn main() -> !`), upgrading its lifetime with `transmute`. (unsafe)
+        ///
+        /// This function never returns.
+        pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
+            init(self.inner.spawner());
 
-                // we do not care about race conditions between the load and store operations,
+            loop {
-                // interrupts will only set this value to true.
+                unsafe {
-                // if there is work to do, loop back to polling
+                    self.inner.poll();
-                if SIGNAL_WORK_THREAD_MODE.load(Ordering::SeqCst) {
-                    SIGNAL_WORK_THREAD_MODE.store(false, Ordering::SeqCst);
 
-                    core::arch::asm!(
+                    // Manual critical section implementation that only masks interrupts handlers.
-                            "wsr.ps {0}",
+                    // We must not acquire the cross-core on dual-core systems because that would
-                            "rsync", in(reg) token)
+                    // prevent the other core from doing useful work while this core is sleeping.
-                } else {
+                    let token: critical_section::RawRestoreState;
-                    // waiti sets the PS.INTLEVEL when slipping into sleep
+                    core::arch::asm!("rsil {0}, 5", out(reg) token);
-                    // because critical sections in Xtensa are implemented via increasing
+
-                    // PS.INTLEVEL the critical section ends here
+                    // we do not care about race conditions between the load and store operations, interrupts
-                    // take care not add code after `waiti` if it needs to be inside the CS
+                    // will only set this value to true.
-                    core::arch::asm!("waiti 0"); // critical section ends here
+                    // if there is work to do, loop back to polling
+                    if SIGNAL_WORK_THREAD_MODE.load(Ordering::SeqCst) {
+                        SIGNAL_WORK_THREAD_MODE.store(false, Ordering::SeqCst);
+
+                        core::arch::asm!(
+                        "wsr.ps {0}",
+                        "rsync", in(reg) token)
+                    } else {
+                        // waiti sets the PS.INTLEVEL when slipping into sleep
+                        // because critical sections in Xtensa are implemented via increasing
+                        // PS.INTLEVEL the critical section ends here
+                        // take care not add code after `waiti` if it needs to be inside the CS
+                        core::arch::asm!("waiti 0"); // critical section ends here
+                    }
                 }
             }
         }
     }
-
-    /// TODO
-    // Type alias for backwards compatibility
-    pub type Executor = crate::thread::ThreadModeExecutor<Context>;
 }

embassy-executor/src/interrupt.rs

@@ -41,7 +41,7 @@ pub trait InterruptContext {
 /// If this is not the case, you may use an interrupt from any unused peripheral.
 ///
 /// It is somewhat more complex to use, it's recommended to use the
-/// [`crate::thread::ThreadModeExecutor`] instead, if it works for your use case.
+/// thread-mode executor instead, if it works for your use case.
 pub struct InterruptModeExecutor {
     started: AtomicBool,
     executor: UnsafeCell<MaybeUninit<raw::Executor>>,

embassy-executor/src/lib.rs

@@ -39,8 +39,8 @@ pub mod raw;
 
 #[cfg(feature = "executor-interrupt")]
 pub mod interrupt;
-#[cfg(feature = "executor-thread")]
+#[cfg(feature = "executor-interrupt")]
-pub mod thread;
+pub use interrupt::*;
 
 mod spawner;
 pub use spawner::*;

embassy-executor/src/thread.rs

@@ -1,87 +0,0 @@
-//! Thread-mode executor.
-
-use core::marker::PhantomData;
-
-use crate::raw::{self, PenderContext};
-use crate::Spawner;
-
-/// Architecture-specific interface for a thread-mode executor. This trait describes what the
-/// executor should do when idle, and what data should be passed to its pender.
-// TODO: Name pending
-pub trait ThreadContext: Sized {
-    /// A pointer-sized piece of data that is passed to the pender function.
-    ///
-    /// For example, on multi-core systems, this can be used to store the ID of the core that
-    /// should be woken up.
-    fn context(&self) -> PenderContext;
-
-    /// Waits for the executor to be waken.
-    ///
-    /// While it is valid for this function can be empty, it is recommended to use a WFE instruction
-    /// or equivalent to let the CPU sleep.
-    fn wait(&mut self);
-}
-
-/// Thread mode executor, using WFE/SEV.
-///
-/// This is the simplest and most common kind of executor. It runs on
-/// thread mode (at the lowest priority level), and uses the `WFE` ARM instruction
-/// to sleep when it has no more work to do. When a task is woken, a `SEV` instruction
-/// is executed, to make the `WFE` exit from sleep and poll the task.
-///
-/// This executor allows for ultra low power consumption for chips where `WFE`
-/// triggers low-power sleep without extra steps. If your chip requires extra steps,
-/// you may use [`raw::Executor`] directly to program custom behavior.
-pub struct ThreadModeExecutor<C: ThreadContext> {
-    inner: raw::Executor,
-    context: C,
-    not_send: PhantomData<*mut ()>,
-}
-
-impl<C: ThreadContext> ThreadModeExecutor<C> {
-    /// Create a new Executor.
-    pub fn new() -> Self
-    where
-        C: Default,
-    {
-        Self::with_context(C::default())
-    }
-
-    /// Create a new Executor using the given thread context.
-    pub fn with_context(context: C) -> Self {
-        Self {
-            inner: raw::Executor::new(context.context()),
-            context,
-            not_send: PhantomData,
-        }
-    }
-
-    /// Run the executor.
-    ///
-    /// The `init` closure is called with a [`Spawner`] that spawns tasks on
-    /// this executor. Use it to spawn the initial task(s). After `init` returns,
-    /// the executor starts running the tasks.
-    ///
-    /// To spawn more tasks later, you may keep copies of the [`Spawner`] (it is `Copy`),
-    /// for example by passing it as an argument to the initial tasks.
-    ///
-    /// This function requires `&'static mut self`. This means you have to store the
-    /// Executor instance in a place where it'll live forever and grants you mutable
-    /// access. There's a few ways to do this:
-    ///
-    /// - a [StaticCell](https://docs.rs/static_cell/latest/static_cell/) (safe)
-    /// - a `static mut` (unsafe)
-    /// - a local variable in a function you know never returns (like `fn main() -> !`), upgrading its lifetime with `transmute`. (unsafe)
-    ///
-    /// This function never returns.
-    pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
-        init(self.inner.spawner());
-
-        loop {
-            unsafe {
-                self.inner.poll();
-                self.context.wait();
-            };
-        }
-    }
-}