Reduce unsafe and support older Rust versions

Use waker-fn to reduce unsafe and to support older Rust versions before `Wake` was stabilized.

Author: sagebind

.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: "1.51.0"
+          toolchain: "1.46.0"
           default: true
 
       - run: cargo test

Cargo.toml

@@ -15,6 +15,7 @@ edition = "2018"
 crossbeam-channel = "0.5"
 num_cpus = "1"
 once_cell = "1"
+waker-fn = "1"
 
 [dev-dependencies]
 criterion = "0.3"

README.md

@@ -50,7 +50,7 @@ threadfin = "0.1"
 
 ### Minimum supported Rust version
 
-The minimum supported Rust version (or MSRV) for Threadfin is stable Rust 1.51 or greater, meaning we only guarantee that Threadfin will compile if you use a rustc version of at least 1.51. It might compile with older versions but that could change at any time.
+The minimum supported Rust version (or MSRV) for Threadfin is stable Rust 1.46 or greater, meaning we only guarantee that Threadfin will compile if you use a rustc version of at least 1.46. It might compile with older versions but that could change at any time.
 
 This version is explicitly tested in CI and may only be bumped in new minor versions. Any changes to the supported minimum version will be called out in the release notes.
 

src/wakers.rs

@@ -1,16 +1,15 @@
 use std::{
-    ptr,
-    sync::Arc,
-    task::{RawWaker, RawWakerVTable, Wake, Waker},
+    task::Waker,
     thread::{self, Thread},
 };
 
+use once_cell::sync::Lazy;
+
 /// Creates a dummy waker that does nothing.
 pub(crate) fn empty_waker() -> Waker {
-    const RAW_WAKER: RawWaker = RawWaker::new(ptr::null(), &VTABLE);
-    const VTABLE: RawWakerVTable = RawWakerVTable::new(|_| RAW_WAKER, |_| {}, |_| {}, |_| {});
+    static WAKER: Lazy<Waker> = Lazy::new(|| waker_fn::waker_fn(move || {}));
 
-    unsafe { Waker::from_raw(RAW_WAKER) }
+    WAKER.clone()
 }
 
 /// Creates a waker that unparks the current thread.
@@ -20,17 +19,5 @@ pub(crate) fn current_thread_waker() -> Waker {
 
 /// Creates a waker that unparks a thread.
 pub(crate) fn thread_waker(thread: Thread) -> Waker {
-    struct ThreadWaker(Thread);
-
-    impl Wake for ThreadWaker {
-        fn wake(self: Arc<Self>) {
-            self.0.unpark();
-        }
-
-        fn wake_by_ref(self: &Arc<Self>) {
-            self.0.unpark();
-        }
-    }
-
-    Arc::new(ThreadWaker(thread)).into()
+    waker_fn::waker_fn(move || thread.unpark())
 }

src/worker.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, sync::Arc, task::Wake, time::Duration};
+use std::{collections::HashMap, time::Duration};
 
 use crossbeam_channel::{unbounded, Receiver, Select, Sender};
 
@@ -142,21 +142,12 @@ impl<L: Listener> Worker<L> {
         // If it is possible for this task to yield, we need to prepare a new
         // waker to receive notifications with.
         if coroutine.might_yield() {
-            struct IdWaker(usize, Sender<usize>);
+            let sender = self.wake_notifications.0.clone();
+            let coroutine_addr = coroutine.addr();
 
-            impl Wake for IdWaker {
-                fn wake(self: Arc<Self>) {
-                    self.wake_by_ref();
-                }
-
-                fn wake_by_ref(self: &Arc<Self>) {
-                    let _ = self.1.send(self.0);
-                }
-            }
-
-            coroutine.set_waker(
-                Arc::new(IdWaker(coroutine.addr(), self.wake_notifications.0.clone())).into(),
-            );
+            coroutine.set_waker(waker_fn::waker_fn(move || {
+                let _ = sender.send(coroutine_addr);
+            }));
         }
 
         self.listener.on_task_started();