Introduce metadata-deadline and let the EDF scheduler use it

5 files changed, 36 insertions, 23 deletions

diff --git a/embassy-executor/Cargo.toml b/embassy-executor/Cargo.toml
index 290e67bce..2de36d22d 100644
--- a/embassy-executor/Cargo.toml
+++ b/embassy-executor/Cargo.toml
@@ -118,6 +118,8 @@ arch-spin = ["_arch"]
 
 ## Enable the `name` field in task metadata.
 metadata-name = ["embassy-executor-macros/metadata-name"]
+## Enable the `deadline` field in task metadata.
+metadata-deadline = []
 
 #! ### Executor
 
@@ -133,4 +135,4 @@ _any_trace = []
 
 ## Enable "Earliest Deadline First" Scheduler, using soft-realtime "deadlines" to prioritize
 ## tasks based on the remaining time before their deadline. Adds some overhead.
-edf-scheduler = ["dep:embassy-time-driver"]
+edf-scheduler = ["dep:embassy-time-driver", "metadata-deadline"]
diff --git a/embassy-executor/src/metadata.rs b/embassy-executor/src/metadata.rs
index f92c9b37c..fd8095629 100644
--- a/embassy-executor/src/metadata.rs
+++ b/embassy-executor/src/metadata.rs
@@ -12,6 +12,8 @@ use crate::raw;
 pub struct Metadata {
     #[cfg(feature = "metadata-name")]
     name: Mutex<Cell<Option<&'static str>>>,
+    #[cfg(feature = "metadata-deadline")]
+    deadline: raw::Deadline,
 }
 
 impl Metadata {
@@ -19,6 +21,10 @@ impl Metadata {
         Self {
             #[cfg(feature = "metadata-name")]
             name: Mutex::new(Cell::new(None)),
+            // NOTE: The deadline is set to zero to allow the initializer to reside in `.bss`. This
+            // will be lazily initalized in `initialize_impl`
+            #[cfg(feature = "metadata-deadline")]
+            deadline: raw::Deadline::new_unset(),
         }
     }
 
@@ -52,4 +58,11 @@ impl Metadata {
     pub fn set_name(&self, name: &'static str) {
         critical_section::with(|cs| self.name.borrow(cs).set(Some(name)))
     }
+
+    /// Earliest Deadline First scheduler Deadline. This field should not be accessed
+    /// outside the context of the task itself as it being polled by the executor.
+    #[cfg(feature = "metadata-deadline")]
+    pub fn deadline(&self) -> &raw::Deadline {
+        &self.deadline
+    }
 }
diff --git a/embassy-executor/src/raw/deadline.rs b/embassy-executor/src/raw/deadline.rs
index cbb379b82..5b585195d 100644
--- a/embassy-executor/src/raw/deadline.rs
+++ b/embassy-executor/src/raw/deadline.rs
@@ -62,7 +62,7 @@ impl Deadline {
     pub fn set_current_task_deadline(instant_ticks: u64) -> impl Future<Output = ()> {
         poll_fn(move |cx| {
             let task = super::task_from_waker(cx.waker());
-            task.header().deadline.set(instant_ticks);
+            task.header().metadata.deadline().set(instant_ticks);
             Poll::Ready(())
         })
     }
@@ -87,7 +87,7 @@ impl Deadline {
             // reasons later.
             let deadline = now.saturating_add(duration_ticks);
 
-            task.header().deadline.set(deadline);
+            task.header().metadata.deadline().set(deadline);
 
             Poll::Ready(Deadline::new(deadline))
         })
@@ -109,10 +109,10 @@ impl Deadline {
     #[must_use = "Setting deadline must be polled to be effective"]
     pub fn increment_current_task_deadline(increment_ticks: u64) -> impl Future<Output = Deadline> {
         poll_fn(move |cx| {
-            let task = super::task_from_waker(cx.waker());
+            let task_header = super::task_from_waker(cx.waker()).header();
 
             // Get the last value
-            let last = task.header().deadline.instant_ticks();
+            let last = task_header.metadata.deadline().instant_ticks();
 
             // Since ticks is a u64, saturating add is PROBABLY overly cautious, leave
             // it for now, we can probably make this wrapping_add for performance
@@ -120,7 +120,7 @@ impl Deadline {
             let deadline = last.saturating_add(increment_ticks);
 
             // Store the new value
-            task.header().deadline.set(deadline);
+            task_header.metadata.deadline().set(deadline);
 
             Poll::Ready(Deadline::new(deadline))
         })
@@ -134,7 +134,7 @@ impl Deadline {
         poll_fn(move |cx| {
             let task = super::task_from_waker(cx.waker());
 
-            let deadline = task.header().deadline.instant_ticks();
+            let deadline = task.header().metadata.deadline().instant_ticks();
             Poll::Ready(Self::new(deadline))
         })
     }
@@ -146,12 +146,12 @@ impl Deadline {
     #[must_use = "Clearing deadline must be polled to be effective"]
     pub fn clear_current_task_deadline() -> impl Future<Output = Self> {
         poll_fn(move |cx| {
-            let task = super::task_from_waker(cx.waker());
+            let task_header = super::task_from_waker(cx.waker()).header();
 
             // get the old value
-            let deadline = task.header().deadline.instant_ticks();
+            let deadline = task_header.metadata.deadline().instant_ticks();
             // Store the default value
-            task.header().deadline.set(Self::UNSET_DEADLINE_TICKS);
+            task_header.metadata.deadline().set(Self::UNSET_DEADLINE_TICKS);
 
             Poll::Ready(Self::new(deadline))
         })
diff --git a/embassy-executor/src/raw/mod.rs b/embassy-executor/src/raw/mod.rs
index be2c5ee28..f93bfdef9 100644
--- a/embassy-executor/src/raw/mod.rs
+++ b/embassy-executor/src/raw/mod.rs
@@ -26,7 +26,7 @@ pub(crate) mod util;
 #[cfg_attr(feature = "turbowakers", path = "waker_turbo.rs")]
 mod waker;
 
-#[cfg(feature = "edf-scheduler")]
+#[cfg(feature = "metadata-deadline")]
 mod deadline;
 
 use core::future::Future;
@@ -43,7 +43,7 @@ use embassy_executor_timer_queue::TimerQueueItem;
 #[cfg(feature = "arch-avr")]
 use portable_atomic::AtomicPtr;
 
-#[cfg(feature = "edf-scheduler")]
+#[cfg(feature = "metadata-deadline")]
 pub use deadline::Deadline;
 #[cfg(feature = "arch-avr")]
 use portable_atomic::AtomicPtr;
@@ -103,11 +103,6 @@ pub(crate) struct TaskHeader {
     pub(crate) state: State,
     pub(crate) run_queue_item: RunQueueItem,
 
-    /// Earliest Deadline First scheduler Deadline. This field should not be accessed
-    /// outside the context of the task itself as it being polled by the executor.
-    #[cfg(feature = "edf-scheduler")]
-    pub(crate) deadline: Deadline,
-
     pub(crate) executor: AtomicPtr<SyncExecutor>,
     poll_fn: SyncUnsafeCell<Option<unsafe fn(TaskRef)>>,
 
@@ -212,10 +207,6 @@ impl<F: Future + 'static> TaskStorage<F> {
             raw: TaskHeader {
                 state: State::new(),
                 run_queue_item: RunQueueItem::new(),
-                // NOTE: The deadline is set to zero to allow the initializer to reside in `.bss`. This
-                // will be lazily initalized in `initialize_impl`
-                #[cfg(feature = "edf-scheduler")]
-                deadline: Deadline::new_unset(),
                 executor: AtomicPtr::new(core::ptr::null_mut()),
                 // Note: this is lazily initialized so that a static `TaskStorage` will go in `.bss`
                 poll_fn: SyncUnsafeCell::new(None),
@@ -315,7 +306,11 @@ impl<F: Future + 'static> AvailableTask<F> {
             // By default, deadlines are set to the maximum value, so that any task WITH
             // a set deadline will ALWAYS be scheduled BEFORE a task WITHOUT a set deadline
             #[cfg(feature = "edf-scheduler")]
-            self.task.raw.deadline.set(deadline::Deadline::UNSET_DEADLINE_TICKS);
+            self.task
+                .raw
+                .metadata
+                .deadline()
+                .set(deadline::Deadline::UNSET_DEADLINE_TICKS);
 
             let task = TaskRef::new(self.task);
 
diff --git a/embassy-executor/src/raw/run_queue.rs b/embassy-executor/src/raw/run_queue.rs
index e8a046a48..978ca082a 100644
--- a/embassy-executor/src/raw/run_queue.rs
+++ b/embassy-executor/src/raw/run_queue.rs
@@ -109,7 +109,10 @@ impl RunQueue {
     #[cfg(feature = "edf-scheduler")]
     pub(crate) fn dequeue_all(&self, on_task: impl Fn(TaskRef)) {
         let mut sorted = SortedList::<TaskHeader>::new_with_cmp(|lhs, rhs| {
-            lhs.deadline.instant_ticks().cmp(&rhs.deadline.instant_ticks())
+            lhs.metadata
+                .deadline()
+                .instant_ticks()
+                .cmp(&rhs.metadata.deadline().instant_ticks())
         });
 
         loop {