1 files changed, 9 insertions, 56 deletions

diff --git a/src/libstd/rt/sleeper_list.rs b/src/libstd/rt/sleeper_list.rs
index f4fdf15cda6..39c7431837f 100644
--- a/src/libstd/rt/sleeper_list.rs
+++ b/src/libstd/rt/sleeper_list.rs
@@ -11,84 +11,37 @@
 //! Maintains a shared list of sleeping schedulers. Schedulers
 //! use this to wake each other up.
 
-use container::Container;
-use vec::OwnedVector;
-use option::{Option, Some, None};
-use cell::Cell;
-use unstable::sync::{UnsafeArc, LittleLock};
 use rt::sched::SchedHandle;
+use rt::mpmc_bounded_queue::Queue;
+use option::*;
 use clone::Clone;
 
 pub struct SleeperList {
-    priv state: UnsafeArc<State>
-}
-
-struct State {
-    count: uint,
-    stack: ~[SchedHandle],
-    lock: LittleLock
+    priv q: Queue<SchedHandle>,
 }
 
 impl SleeperList {
     pub fn new() -> SleeperList {
-        SleeperList {
-            state: UnsafeArc::new(State {
-                count: 0,
-                stack: ~[],
-                lock: LittleLock::new()
-            })
-        }
+        SleeperList{q: Queue::with_capacity(8*1024)}
     }
 
-    pub fn push(&mut self, handle: SchedHandle) {
-        let handle = Cell::new(handle);
-        unsafe {
-            let state = self.state.get();
-            do (*state).lock.lock {
-                (*state).count += 1;
-                (*state).stack.push(handle.take());
-            }
-        }
+    pub fn push(&mut self, value: SchedHandle) {
+        assert!(self.q.push(value))
     }
 
     pub fn pop(&mut self) -> Option<SchedHandle> {
-        unsafe {
-            let state = self.state.get();
-            do (*state).lock.lock {
-                if !(*state).stack.is_empty() {
-                    (*state).count -= 1;
-                    Some((*state).stack.pop())
-                } else {
-                    None
-                }
-            }
-        }
+        self.q.pop()
     }
 
-    /// A pop that may sometimes miss enqueued elements, but is much faster
-    /// to give up without doing any synchronization
     pub fn casual_pop(&mut self) -> Option<SchedHandle> {
-        unsafe {
-            let state = self.state.get();
-            // NB: Unsynchronized check
-            if (*state).count == 0 { return None; }
-            do (*state).lock.lock {
-                if !(*state).stack.is_empty() {
-                    // NB: count is also protected by the lock
-                    (*state).count -= 1;
-                    Some((*state).stack.pop())
-                } else {
-                    None
-                }
-            }
-        }
+        self.q.pop()
     }
 }
 
 impl Clone for SleeperList {
     fn clone(&self) -> SleeperList {
         SleeperList {
-            state: self.state.clone()
+            q: self.q.clone()
         }
     }
 }