Fix if a enqueued instant is first in a non-empty queue

4 files changed, 16 insertions, 13 deletions

diff --git a/rtic-time/CHANGELOG.md b/rtic-time/CHANGELOG.md
index 3a2fb91..9f6a409 100644
--- a/rtic-time/CHANGELOG.md
+++ b/rtic-time/CHANGELOG.md
@@ -15,4 +15,6 @@ For each category, *Added*, *Changed*, *Fixed* add new entries at the top!
 
 ### Fixed
 
+- If the queue was non-empty and a new instant was added that was earlier than `head`, then the queue would no pend the monotonic handler. This would cause the new `head` to be dequeued at the wrong time.
+
 ## [v1.0.0] - 2023-xx-xx
diff --git a/rtic-time/Cargo.toml b/rtic-time/Cargo.toml
index c7d13bb..462ad5d 100644
--- a/rtic-time/Cargo.toml
+++ b/rtic-time/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rtic-time"
-version = "1.0.0-alpha.0"
+version = "1.0.0-alpha.1"
 
 edition = "2021"
 authors = [
diff --git a/rtic-time/src/lib.rs b/rtic-time/src/lib.rs
index 9bf1485..1ed1e9d 100644
--- a/rtic-time/src/lib.rs
+++ b/rtic-time/src/lib.rs
@@ -25,7 +25,7 @@ mod monotonic;
 struct WaitingWaker<Mono: Monotonic> {
     waker: Waker,
     release_at: Mono::Instant,
-    was_poped: AtomicBool,
+    was_popped: AtomicBool,
 }
 
 impl<Mono: Monotonic> Clone for WaitingWaker<Mono> {
@@ -33,7 +33,7 @@ impl<Mono: Monotonic> Clone for WaitingWaker<Mono> {
         Self {
             waker: self.waker.clone(),
             release_at: self.release_at,
-            was_poped: AtomicBool::new(self.was_poped.load(Ordering::Relaxed)),
+            was_popped: AtomicBool::new(self.was_popped.load(Ordering::Relaxed)),
         }
     }
 }
@@ -132,7 +132,7 @@ impl<Mono: Monotonic> TimerQueue<Mono> {
                 release_at = Some(head.release_at);
 
                 let should_pop = Mono::should_dequeue_check(head.release_at);
-                head.was_poped.store(should_pop, Ordering::Relaxed);
+                head.was_popped.store(should_pop, Ordering::Relaxed);
 
                 should_pop
             });
@@ -234,7 +234,7 @@ impl<Mono: Monotonic> TimerQueue<Mono> {
                 let link_ref = link.insert(Link::new(WaitingWaker {
                     waker: cx.waker().clone(),
                     release_at: instant,
-                    was_poped: AtomicBool::new(false),
+                    was_popped: AtomicBool::new(false),
                 }));
 
                 // SAFETY(new_unchecked): The address to the link is stable as it is defined
@@ -243,13 +243,13 @@ impl<Mono: Monotonic> TimerQueue<Mono> {
                 // we make sure in `dropper` that the link is removed from the queue before
                 // dropping `link_ptr` AND `dropper` makes sure that the shadowed `link_ptr` lives
                 // until the end of the stack frame.
-                let (was_empty, addr) = unsafe { queue.insert(Pin::new_unchecked(link_ref)) };
+                let (head_updated, addr) = unsafe { queue.insert(Pin::new_unchecked(link_ref)) };
 
                 marker.store(addr, Ordering::Relaxed);
 
-                if was_empty {
-                    // Pend the monotonic handler if the queue was empty to setup the timer.
-                    Mono::pend_interrupt();
+                if head_updated {
+                    // Pend the monotonic handler if the queue head was updated.
+                    Mono::pend_interrupt()
                 }
             }
 
@@ -261,8 +261,8 @@ impl<Mono: Monotonic> TimerQueue<Mono> {
         // exited the `poll_fn` below in the `drop(dropper)` call. The other dereference
         // of this pointer is in the `poll_fn`.
         if let Some(link) = unsafe { link_ptr.get() } {
-            if link.val.was_poped.load(Ordering::Relaxed) {
-                // If it was poped from the queue there is no need to run delete
+            if link.val.was_popped.load(Ordering::Relaxed) {
+                // If it was popped from the queue there is no need to run delete
                 dropper.defuse();
             }
         } else {
diff --git a/rtic-time/src/linked_list.rs b/rtic-time/src/linked_list.rs
index d4256c9..c2a9967 100644
--- a/rtic-time/src/linked_list.rs
+++ b/rtic-time/src/linked_list.rs
@@ -92,7 +92,8 @@ impl<T: PartialOrd + Clone> LinkedList<T> {
     }
 
     /// Insert a new link into the linked list.
-    /// The return is (was_empty, address), where the address of the link is for use with `delete`.
+    /// The return is (updated head, address), where the address of the link is for use
+    /// with `delete`.
     ///
     /// SAFETY: The pinned link must live until it is removed from this list.
     pub unsafe fn insert(&self, val: Pin<&Link<T>>) -> (bool, usize) {
@@ -127,7 +128,7 @@ impl<T: PartialOrd + Clone> LinkedList<T> {
                 self.head
                     .store(val as *const _ as *mut _, Ordering::Relaxed);
 
-                return (false, addr);
+                return (true, addr);
             }
 
             // 3. search list for correct place