Make the notify() function return notified count

notgull · notgull · commit 6345794547b1 · 2023-05-17T15:12:13.000-07:00
Fix off-by-one error in implementation
diff --git a/src/lib.rs b/src/lib.rs
@@ -360,7 +360,7 @@ impl<T> Event<T> {
     /// event.notify(1.additional().relaxed());
     /// ```
     #[inline]
-    pub fn notify(&self, notify: impl IntoNotification<Tag = T>) {
+    pub fn notify(&self, notify: impl IntoNotification<Tag = T>) -> usize {
         let notify = notify.into_notification();
 
         // Make sure the notification comes after whatever triggered it.
@@ -376,9 +376,11 @@ impl<T> Event<T> {
             // Notify if there is at least one unnotified listener and the number of notified
             // listeners is less than `limit`.
             if inner.notified.load(Ordering::Acquire) < limit {
-                inner.notify(notify);
+                return inner.notify(notify);
             }
         }
+
+        0
     }
 
     /// Return a reference to the inner state if it has been initialized.
@@ -489,7 +491,7 @@ impl Event<()> {
     /// event.notify_relaxed(2);
     /// ```
     #[inline]
-    pub fn notify_relaxed(&self, n: usize) {
+    pub fn notify_relaxed(&self, n: usize) -> usize {
         self.notify(n.relaxed())
     }
 
@@ -538,7 +540,7 @@ impl Event<()> {
     /// event.notify_additional(1);
     /// ```
     #[inline]
-    pub fn notify_additional(&self, n: usize) {
+    pub fn notify_additional(&self, n: usize) -> usize {
         self.notify(n.additional())
     }
 
@@ -592,7 +594,7 @@ impl Event<()> {
     /// event.notify_additional_relaxed(1);
     /// ```
     #[inline]
-    pub fn notify_additional_relaxed(&self, n: usize) {
+    pub fn notify_additional_relaxed(&self, n: usize) -> usize {
         self.notify(n.additional().relaxed())
     }
 }
diff --git a/src/no_std.rs b/src/no_std.rs
@@ -110,11 +110,11 @@ impl<T> crate::Inner<T> {
 
     /// Notifies a number of entries.
     #[cold]
-    pub(crate) fn notify(&self, mut notify: impl Notification<Tag = T>) {
+    pub(crate) fn notify(&self, mut notify: impl Notification<Tag = T>) -> usize {
         match self.try_lock() {
             Some(mut guard) => {
                 // Notify the listeners.
-                guard.notify(notify);
+                guard.notify(notify)
             }
 
             None => {
@@ -140,6 +140,9 @@ impl<T> crate::Inner<T> {
                 ));
 
                 self.list.queue.push(node);
+
+                // We haven't notified anyone yet.
+                0
             }
         }
     }
@@ -556,23 +559,24 @@ impl<T> ListenerSlab<T> {
 
     /// Notifies a number of listeners.
     #[cold]
-    pub(crate) fn notify(&mut self, mut notify: impl Notification<Tag = T>) {
+    pub(crate) fn notify(&mut self, mut notify: impl Notification<Tag = T>) -> usize {
         let mut n = notify.count(Internal::new());
         let is_additional = notify.is_additional(Internal::new());
         if !is_additional {
             // Make sure we're not notifying more than we have.
             if n <= self.notified {
-                return;
+                return 0;
             }
             n -= self.notified;
         }
 
+        let original_count = n;
         while n > 0 {
             n -= 1;
 
             // Notify the next entry.
             match self.start {
-                None => break,
+                None => return original_count - n - 1,
 
                 Some(e) => {
                     // Get the entry and move the pointer forwards.
@@ -593,6 +597,8 @@ impl<T> ListenerSlab<T> {
                 }
             }
         }
+
+        original_count - n
     }
 
     /// Register a task to be notified when the event is triggered.
diff --git a/src/std.rs b/src/std.rs
@@ -110,7 +110,7 @@ impl<T> crate::Inner<T> {
 
     /// Notifies a number of entries.
     #[cold]
-    pub(crate) fn notify(&self, notify: impl Notification<Tag = T>) {
+    pub(crate) fn notify(&self, notify: impl Notification<Tag = T>) -> usize {
         self.lock().notify(notify)
     }
 
@@ -236,23 +236,24 @@ impl<T> Inner<T> {
     }
 
     #[cold]
-    fn notify(&mut self, mut notify: impl Notification<Tag = T>) {
+    fn notify(&mut self, mut notify: impl Notification<Tag = T>) -> usize {
         let mut n = notify.count(Internal::new());
         let is_additional = notify.is_additional(Internal::new());
 
         if !is_additional {
             if n < self.notified {
-                return;
+                return 0;
             }
             n -= self.notified;
         }
 
+        let original_count = n;
         while n > 0 {
             n -= 1;
 
             // Notify the next entry.
             match self.next {
-                None => break,
+                None => return original_count - n - 1,
 
                 Some(e) => {
                     // Get the entry and move the pointer forwards.
@@ -273,6 +274,8 @@ impl<T> Inner<T> {
                 }
             }
         }
+
+        original_count - n
     }
 }
 
diff --git a/tests/notify.rs b/tests/notify.rs
@@ -24,8 +24,8 @@ fn notify() {
     assert!(!is_notified(l2.as_mut()));
     assert!(!is_notified(l3.as_mut()));
 
-    event.notify(2);
-    event.notify(1);
+    assert_eq!(event.notify(2), 2);
+    assert_eq!(event.notify(1), 0);
 
     assert!(is_notified(l1.as_mut()));
     assert!(is_notified(l2.as_mut()));
@@ -40,9 +40,9 @@ fn notify_additional() {
     let mut l2 = event.listen();
     let mut l3 = event.listen();
 
-    event.notify_additional(1);
-    event.notify(1);
-    event.notify_additional(1);
+    assert_eq!(event.notify_additional(1), 1);
+    assert_eq!(event.notify(1), 0);
+    assert_eq!(event.notify_additional(1), 1);
 
     assert!(is_notified(l1.as_mut()));
     assert!(is_notified(l2.as_mut()));
@@ -59,11 +59,11 @@ fn notify_one() {
     assert!(!is_notified(l1.as_mut()));
     assert!(!is_notified(l2.as_mut()));
 
-    event.notify(1);
+    assert_eq!(event.notify(1), 1);
     assert!(is_notified(l1.as_mut()));
     assert!(!is_notified(l2.as_mut()));
 
-    event.notify(1);
+    assert_eq!(event.notify(1), 1);
     assert!(is_notified(l2.as_mut()));
 }
 
@@ -77,7 +77,7 @@ fn notify_all() {
     assert!(!is_notified(l1.as_mut()));
     assert!(!is_notified(l2.as_mut()));
 
-    event.notify(usize::MAX);
+    assert_eq!(event.notify(usize::MAX), 2);
     assert!(is_notified(l1.as_mut()));
     assert!(is_notified(l2.as_mut()));
 }
@@ -90,7 +90,7 @@ fn drop_notified() {
     let mut l2 = event.listen();
     let mut l3 = event.listen();
 
-    event.notify(1);
+    assert_eq!(event.notify(1), 1);
     drop(l1);
     assert!(is_notified(l2.as_mut()));
     assert!(!is_notified(l3.as_mut()));
@@ -104,7 +104,7 @@ fn drop_notified2() {
     let mut l2 = event.listen();
     let mut l3 = event.listen();
 
-    event.notify(2);
+    assert_eq!(event.notify(2), 2);
     drop(l1);
     assert!(is_notified(l2.as_mut()));
     assert!(!is_notified(l3.as_mut()));
@@ -119,8 +119,8 @@ fn drop_notified_additional() {
     let mut l3 = event.listen();
     let mut l4 = event.listen();
 
-    event.notify_additional(1);
-    event.notify(2);
+    assert_eq!(event.notify_additional(1), 1);
+    assert_eq!(event.notify(2), 1);
     drop(l1);
     assert!(is_notified(l2.as_mut()));
     assert!(is_notified(l3.as_mut()));
@@ -135,7 +135,7 @@ fn drop_non_notified() {
     let mut l2 = event.listen();
     let l3 = event.listen();
 
-    event.notify(1);
+    assert_eq!(event.notify(1), 1);
     drop(l3);
     assert!(is_notified(l1.as_mut()));
     assert!(!is_notified(l2.as_mut()));
@@ -173,7 +173,7 @@ fn notify_all_fair() {
         .poll(&mut Context::from_waker(&waker3))
         .is_pending());
 
-    event.notify(usize::MAX);
+    assert_eq!(event.notify(usize::MAX), 3);
     assert_eq!(&*v.lock().unwrap(), &[1, 2, 3]);
 
     assert!(Pin::new(&mut l1)

Original file line number	Diff line number	Diff line change
`@@ -110,11 +110,11 @@ impl<T> crate::Inner<T> {`
`110`	`110`
`111`	`111`	`/// Notifies a number of entries.`
`112`	`112`	`#[cold]`
`113`		`- pub(crate) fn notify(&self, mut notify: impl Notification<Tag = T>) {`
	`113`	`+ pub(crate) fn notify(&self, mut notify: impl Notification<Tag = T>) -> usize {`
`114`	`114`	`match self.try_lock() {`
`115`	`115`	`Some(mut guard) => {`
`116`	`116`	`// Notify the listeners.`
`117`		`- guard.notify(notify);`
	`117`	`+ guard.notify(notify)`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`None => {`
`@@ -140,6 +140,9 @@ impl<T> crate::Inner<T> {`
`140`	`140`	`));`
`141`	`141`
`142`	`142`	`self.list.queue.push(node);`
	`143`	`+`
	`144`	`+ // We haven't notified anyone yet.`
	`145`	`+ 0`
`143`	`146`	`}`
`144`	`147`	`}`
`145`	`148`	`}`
`@@ -556,23 +559,24 @@ impl<T> ListenerSlab<T> {`
`556`	`559`
`557`	`560`	`/// Notifies a number of listeners.`
`558`	`561`	`#[cold]`
`559`		`- pub(crate) fn notify(&mut self, mut notify: impl Notification<Tag = T>) {`
	`562`	`+ pub(crate) fn notify(&mut self, mut notify: impl Notification<Tag = T>) -> usize {`
`560`	`563`	`let mut n = notify.count(Internal::new());`
`561`	`564`	`let is_additional = notify.is_additional(Internal::new());`
`562`	`565`	`if !is_additional {`
`563`	`566`	`// Make sure we're not notifying more than we have.`
`564`	`567`	`if n <= self.notified {`
`565`		`- return;`
	`568`	`+ return 0;`
`566`	`569`	`}`
`567`	`570`	`n -= self.notified;`
`568`	`571`	`}`
`569`	`572`
	`573`	`+ let original_count = n;`
`570`	`574`	`while n > 0 {`
`571`	`575`	`n -= 1;`
`572`	`576`
`573`	`577`	`// Notify the next entry.`
`574`	`578`	`match self.start {`
`575`		`- None => break,`
	`579`	`+ None => return original_count - n - 1,`
`576`	`580`
`577`	`581`	`Some(e) => {`
`578`	`582`	`// Get the entry and move the pointer forwards.`
`@@ -593,6 +597,8 @@ impl<T> ListenerSlab<T> {`
`593`	`597`	`}`
`594`	`598`	`}`
`595`	`599`	`}`
	`600`	`+`
	`601`	`+ original_count - n`
`596`	`602`	`}`
`597`	`603`
`598`	`604`	`/// Register a task to be notified when the event is triggered.`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ impl<T> crate::Inner<T> {`
`110`	`110`
`111`	`111`	`/// Notifies a number of entries.`
`112`	`112`	`#[cold]`
`113`		`- pub(crate) fn notify(&self, notify: impl Notification<Tag = T>) {`
	`113`	`+ pub(crate) fn notify(&self, notify: impl Notification<Tag = T>) -> usize {`
`114`	`114`	`self.lock().notify(notify)`
`115`	`115`	`}`
`116`	`116`
`@@ -236,23 +236,24 @@ impl<T> Inner<T> {`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`#[cold]`
`239`		`- fn notify(&mut self, mut notify: impl Notification<Tag = T>) {`
	`239`	`+ fn notify(&mut self, mut notify: impl Notification<Tag = T>) -> usize {`
`240`	`240`	`let mut n = notify.count(Internal::new());`
`241`	`241`	`let is_additional = notify.is_additional(Internal::new());`
`242`	`242`
`243`	`243`	`if !is_additional {`
`244`	`244`	`if n < self.notified {`
`245`		`- return;`
	`245`	`+ return 0;`
`246`	`246`	`}`
`247`	`247`	`n -= self.notified;`
`248`	`248`	`}`
`249`	`249`
	`250`	`+ let original_count = n;`
`250`	`251`	`while n > 0 {`
`251`	`252`	`n -= 1;`
`252`	`253`
`253`	`254`	`// Notify the next entry.`
`254`	`255`	`match self.next {`
`255`		`- None => break,`
	`256`	`+ None => return original_count - n - 1,`
`256`	`257`
`257`	`258`	`Some(e) => {`
`258`	`259`	`// Get the entry and move the pointer forwards.`
`@@ -273,6 +274,8 @@ impl<T> Inner<T> {`
`273`	`274`	`}`
`274`	`275`	`}`
`275`	`276`	`}`
	`277`	`+`
	`278`	`+ original_count - n`
`276`	`279`	`}`
`277`	`280`	`}`
`278`	`281`