threadpool: update crossbeam dependencies (#874)

tokio-threadpool/src/worker/entry.rs

@@ -9,9 +9,9 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::atomic::Ordering::{Acquire, AcqRel, Relaxed, Release};
 use std::time::Duration;
 
-use crossbeam::queue::SegQueue;
+use crossbeam_deque::{Steal, Stealer, Worker};
+use crossbeam_queue::SegQueue;
 use crossbeam_utils::CachePadded;
-use deque;
 use slab::Slab;
 
 // TODO: None of the fields should be public
@@ -29,10 +29,10 @@ pub(crate) struct WorkerEntry {
     next_sleeper: UnsafeCell<usize>,
 
     // Worker half of deque
-    worker: deque::Worker<Arc<Task>>,
+    pub worker: Worker<Arc<Task>>,
 
     // Stealer half of deque
-    stealer: deque::Stealer<Arc<Task>>,
+    stealer: Stealer<Arc<Task>>,
 
     // Thread parker
     park: UnsafeCell<Option<BoxPark>>,
@@ -53,7 +53,8 @@ pub(crate) struct WorkerEntry {
 
 impl WorkerEntry {
     pub fn new(park: BoxPark, unpark: BoxUnpark) -> Self {
-        let (w, s) = deque::fifo();
+        let w = Worker::new_fifo();
+        let s = w.stealer();
 
         WorkerEntry {
             state: CachePadded::new(AtomicUsize::new(State::default().into())),
@@ -187,7 +188,7 @@ impl WorkerEntry {
     /// This **must** only be called by the thread that owns the worker entry.
     /// This function is not `Sync`.
     #[inline]
-    pub fn pop_task(&self) -> deque::Pop<Arc<Task>> {
+    pub fn pop_task(&self) -> Option<Arc<Task>> {
         self.worker.pop()
     }
 
@@ -199,23 +200,15 @@ impl WorkerEntry {
     /// At the same time, this method steals some additional tasks and moves
     /// them into `dest` in order to balance the work distribution among
     /// workers.
-    pub fn steal_tasks(&self, dest: &Self) -> deque::Steal<Arc<Task>> {
-        self.stealer.steal_many(&dest.worker)
+    pub fn steal_tasks(&self, dest: &Self) -> Steal<Arc<Task>> {
+        self.stealer.steal_batch_and_pop(&dest.worker)
     }
 
     /// Drain (and drop) all tasks that are queued for work.
     ///
     /// This is called when the pool is shutting down.
     pub fn drain_tasks(&self) {
-        use deque::Pop::*;
-
-        loop {
-            match self.worker.pop() {
-                Data(_) => {}
-                Empty => break,
-                Retry => {}
-            }
-        }
+        while self.worker.pop().is_some() {}
     }
 
     /// Parks the worker thread.
@@ -284,7 +277,6 @@ impl WorkerEntry {
         }
         running_tasks.clear();
 
-        // Drop the parker.
         unsafe {
             *self.park.get() = None;
             *self.unpark.get() = None;
@@ -297,7 +289,7 @@ impl WorkerEntry {
         if self.needs_drain.compare_and_swap(true, false, Acquire) {
             let running_tasks = unsafe { &mut *self.running_tasks.get() };
 
-            while let Some(task) = self.remotely_completed_tasks.try_pop() {
+            while let Ok(task) = self.remotely_completed_tasks.pop() {
                 running_tasks.remove(task.reg_index.get());
             }
         }

tokio-threadpool/src/worker/mod.rs

@@ -386,16 +386,13 @@ impl Worker {
     ///
     /// Returns `true` if work was found.
     fn try_run_owned_task(&self, notify: &Arc<Notifier>) -> bool {
-        use deque::Pop;
-
         // Poll the internal queue for a task to run
         match self.entry().pop_task() {
-            Pop::Data(task) => {
+            Some(task) => {
                 self.run_task(task, notify);
                 true
             }
-            Pop::Empty => false,
-            Pop::Retry => true,
+            None => false,
         }
     }
 
@@ -403,7 +400,7 @@ impl Worker {
     ///
     /// Returns `true` if work was found
     fn try_steal_task(&self, notify: &Arc<Notifier>) -> bool {
-        use deque::Steal;
+        use crossbeam_deque::Steal;
 
         debug_assert!(!self.is_blocking.get());
 
@@ -415,7 +412,7 @@ impl Worker {
         loop {
             if idx < len {
                 match self.pool.workers[idx].steal_tasks(self.entry()) {
-                    Steal::Data(task) => {
+                    Steal::Success(task) => {
                         trace!("stole task from another worker");
 
                         self.run_task(task, notify);
@@ -701,15 +698,17 @@ impl Worker {
     ///
     /// Returns `true` if this worker has tasks in its queue.
     fn sleep_light(&self) {
-        const STEAL_COUNT: usize = 32;
-
         self.entry().park_timeout(Duration::from_millis(0));
 
-        for _ in 0..STEAL_COUNT {
-            if let Some(task) = self.pool.queue.pop() {
-                self.pool.submit(task, &self.pool);
-            } else {
-                break;
+        use crossbeam_deque::Steal;
+        loop {
+            match self.pool.queue.steal_batch(&self.entry().worker) {
+                Steal::Success(()) => {
+                    self.pool.signal_work(&self.pool);
+                    break;
+                }
+                Steal::Empty => break,
+                Steal::Retry => {}
             }
         }
     }