Add wait/wake ptr funcs for Windows

Author: Grimeh

src/lib.rs

@@ -1,7 +1,7 @@
 #![no_std]
 #![doc = include_str!("../README.md")]
 
-use core::sync::atomic::AtomicU32;
+use core::sync::atomic::{AtomicPtr, AtomicU32};
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 #[path = "linux.rs"]
@@ -28,6 +28,14 @@ pub fn wait(atomic: &AtomicU32, value: u32) {
     platform::wait(atomic, value)
 }
 
+/// If the value is `value`, wait until woken up.
+///
+/// This function might also return spuriously,
+/// without a corresponding wake operation.
+pub fn wait_ptr<T>(atomic: *const AtomicPtr<T>, value: *mut T) {
+    platform::wait_ptr(atomic, value)
+}
+
 /// Wake one thread that is waiting on this atomic.
 ///
 /// It's okay if the pointer dangles or is null.
@@ -36,10 +44,25 @@ pub fn wake_one(atomic: *const AtomicU32) {
     platform::wake_one(atomic);
 }
 
+/// Wake one thread that is waiting on this atomic.
+///
+/// It's okay if the pointer dangles or is null.
+#[inline]
+pub fn wake_one_ptr<T>(atomic: *const AtomicPtr<T>) {
+    platform::wake_one_ptr(atomic);
+}
+
 /// Wake all threads that are waiting on this atomic.
 ///
 /// It's okay if the pointer dangles or is null.
 #[inline]
 pub fn wake_all(atomic: *const AtomicU32) {
     platform::wake_all(atomic);
 }
+
+/// Wake all threads that are waiting on this atomic.
+///
+/// It's okay if the pointer dangles or is null.
+pub fn wake_all_ptr<T>(atomic: *const AtomicPtr<T>) {
+    platform::wake_all_ptr(atomic);
+}

src/windows.rs

@@ -1,4 +1,4 @@
-use core::sync::atomic::AtomicU32;
+use core::sync::atomic::{AtomicPtr, AtomicU32};
 use windows_sys::Win32::System::{
     Threading::{WaitOnAddress, WakeByAddressAll, WakeByAddressSingle},
     WindowsProgramming::INFINITE,
@@ -11,12 +11,27 @@ pub fn wait(a: &AtomicU32, expected: u32) {
     unsafe { WaitOnAddress(ptr.cast(), expected_ptr.cast(), 4, INFINITE) };
 }
 
+pub fn wait_ptr<T>(a: *const AtomicPtr<T>, expected: *const T) {
+    let expected_ptr: *const *const T = &expected as _;
+    unsafe { WaitOnAddress(a.cast(), expected_ptr.cast(), 8, INFINITE )};
+}
+
 #[inline]
 pub fn wake_one(ptr: *const AtomicU32) {
     unsafe { WakeByAddressSingle(ptr.cast()) };
 }
 
+#[inline]
+pub fn wake_one_ptr<T>(ptr: *const AtomicPtr<T>) {
+    unsafe { WakeByAddressSingle(ptr.cast()) };
+}
+
 #[inline]
 pub fn wake_all(ptr: *const AtomicU32) {
     unsafe { WakeByAddressAll(ptr.cast()) };
 }
+
+#[inline]
+pub fn wake_all_ptr<T>(ptr: *const AtomicPtr<T>) {
+    unsafe { WakeByAddressAll(ptr.cast()) };
+}