Move ThreadFlags to embassy impl (#4383)

Author: bugadani

esp-rtos/src/embassy/mod.rs

@@ -1,15 +1,107 @@
 //! OS-aware embassy executors.
 
-use core::{cell::UnsafeCell, mem::MaybeUninit, sync::atomic::Ordering};
+use core::{cell::UnsafeCell, mem::MaybeUninit, ptr::NonNull, sync::atomic::Ordering};
 
 use embassy_executor::{SendSpawner, Spawner, raw};
-use esp_hal::interrupt::{InterruptHandler, Priority, software::SoftwareInterrupt};
-#[cfg(multi_core)]
-use esp_hal::system::Cpu;
+use esp_hal::{
+    interrupt::{InterruptHandler, Priority, software::SoftwareInterrupt},
+    system::Cpu,
+    time::{Duration, Instant},
+};
+use esp_sync::NonReentrantMutex;
 use macros::ram;
 use portable_atomic::AtomicPtr;
 
-use crate::task::flags::ThreadFlag;
+use crate::{
+    SCHEDULER,
+    task::{TaskExt, TaskPtr},
+};
+
+pub(crate) struct FlagsInner {
+    owner: TaskPtr,
+    waiting: Option<TaskPtr>,
+    set: bool,
+}
+impl FlagsInner {
+    fn take(&mut self) -> bool {
+        if self.set {
+            // The flag was set while we weren't looking.
+            self.set = false;
+            true
+        } else {
+            // `waiting` signals that the owner should be resumed when the flag is set. Copying
+            // the task pointer is an optimization that allows clearing the
+            // waiting state without computing the address of a separate field.
+            self.waiting = Some(self.owner);
+
+            false
+        }
+    }
+}
+
+/// A single event bit, optimized for the thread-mode embassy executor.
+///
+/// This takes shortcuts, which make it unsuitable for general purpose use (such as no wait
+/// queue, no timeout, assumes a single thread waits for the flag, there is only a single bit of
+/// flag information).
+struct ThreadFlag {
+    inner: NonReentrantMutex<FlagsInner>,
+}
+
+impl ThreadFlag {
+    fn new() -> Self {
+        let owner = SCHEDULER.with(|scheduler| {
+            let current_cpu = Cpu::current() as usize;
+            if let Some(current_task) = scheduler.per_cpu[current_cpu].current_task {
+                current_task
+            } else {
+                // We're cheating, the task hasn't been initialized yet.
+                NonNull::from(&scheduler.per_cpu[current_cpu].main_task)
+            }
+        });
+        Self {
+            inner: NonReentrantMutex::new(FlagsInner {
+                owner,
+                waiting: None,
+                set: false,
+            }),
+        }
+    }
+
+    fn with<R>(&self, f: impl FnOnce(&mut FlagsInner) -> R) -> R {
+        self.inner.with(|inner| f(inner))
+    }
+
+    fn set(&self) {
+        self.with(|inner| {
+            if let Some(waiting) = inner.waiting.take() {
+                // The task is waiting, there is no need to set the flag - resuming the thread
+                // is all the signal we need.
+                waiting.resume();
+            } else {
+                // The task isn't waiting, set the flag.
+                inner.set = true;
+            }
+        });
+    }
+
+    fn get(&self) -> bool {
+        self.with(|inner| inner.set)
+    }
+
+    fn wait(&self) {
+        self.with(|inner| {
+            if !inner.take() {
+                // SCHEDULER.sleep_until, but we know the current task's ID, and we know there
+                // is no timeout.
+                SCHEDULER.with(|scheduler| {
+                    scheduler.sleep_task_until(inner.owner, Instant::EPOCH + Duration::MAX);
+                    crate::task::yield_task();
+                });
+            }
+        });
+    }
+}
 
 #[unsafe(export_name = "__pender")]
 #[ram]

esp-rtos/src/task/mod.rs

@@ -319,108 +319,6 @@ impl<E: TaskListElement> TaskQueue<E> {
     }
 }
 
-#[cfg(feature = "embassy")]
-pub(crate) mod flags {
-    use core::ptr::NonNull;
-
-    use esp_hal::{
-        system::Cpu,
-        time::{Duration, Instant},
-    };
-    use esp_sync::NonReentrantMutex;
-
-    use crate::{
-        SCHEDULER,
-        task::{TaskExt, TaskPtr},
-    };
-
-    pub(crate) struct FlagsInner {
-        owner: TaskPtr,
-        waiting: Option<TaskPtr>,
-        set: bool,
-    }
-    impl FlagsInner {
-        fn take(&mut self) -> bool {
-            if self.set {
-                // The flag was set while we weren't looking.
-                self.set = false;
-                true
-            } else {
-                // `waiting` signals that the owner should be resumed when the flag is set. Copying
-                // the task pointer is an optimization that allows clearing the
-                // waiting state without computing the address of a separate field.
-                self.waiting = Some(self.owner);
-
-                false
-            }
-        }
-    }
-
-    /// A single event bit, optimized for the thread-mode embassy executor.
-    ///
-    /// This takes shortcuts, which make it unsuitable for general purpose use (such as no wait
-    /// queue, no timeout, assumes a single thread waits for the flag, there is only a single bit of
-    /// flag information).
-    pub(crate) struct ThreadFlag {
-        inner: NonReentrantMutex<FlagsInner>,
-    }
-
-    impl ThreadFlag {
-        pub(crate) fn new() -> Self {
-            let owner = SCHEDULER.with(|scheduler| {
-                let current_cpu = Cpu::current() as usize;
-                if let Some(current_task) = scheduler.per_cpu[current_cpu].current_task {
-                    current_task
-                } else {
-                    // We're cheating, the task hasn't been initialized yet.
-                    NonNull::from(&scheduler.per_cpu[current_cpu].main_task)
-                }
-            });
-            Self {
-                inner: NonReentrantMutex::new(FlagsInner {
-                    owner,
-                    waiting: None,
-                    set: false,
-                }),
-            }
-        }
-
-        fn with<R>(&self, f: impl FnOnce(&mut FlagsInner) -> R) -> R {
-            self.inner.with(|inner| f(inner))
-        }
-
-        pub(crate) fn set(&self) {
-            self.with(|inner| {
-                if let Some(waiting) = inner.waiting.take() {
-                    // The task is waiting, there is no need to set the flag - resuming the thread
-                    // is all the signal we need.
-                    waiting.resume();
-                } else {
-                    // The task isn't waiting, set the flag.
-                    inner.set = true;
-                }
-            });
-        }
-
-        pub(crate) fn get(&self) -> bool {
-            self.with(|inner| inner.set)
-        }
-
-        pub(crate) fn wait(&self) {
-            self.with(|inner| {
-                if !inner.take() {
-                    // SCHEDULER.sleep_until, but we know the current task's ID, and we know there
-                    // is no timeout.
-                    SCHEDULER.with(|scheduler| {
-                        scheduler.sleep_task_until(inner.owner, Instant::EPOCH + Duration::MAX);
-                        crate::task::yield_task();
-                    });
-                }
-            });
-        }
-    }
-}
-
 #[repr(C)]
 pub(crate) struct Task {
     pub cpu_context: CpuContext,