---

yaml
---
r: 142582
b: refs/heads/try2
c: ed8c359
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: dec9db10da062b1c528d46426d9f62e201d39bc6
+refs/heads/try2: ed8c3594bc86dd366e729d02c34915c783e6ac81
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/rt/mod.rs

@@ -150,12 +150,14 @@ pub fn start(_argc: int, _argv: **u8, crate_map: *u8, main: ~fn()) -> int {
     use self::sched::{Scheduler, Coroutine};
     use self::work_queue::WorkQueue;
     use self::uv::uvio::UvEventLoop;
+    use self::sleeper_list::SleeperList;
 
     init(crate_map);
 
     let loop_ = ~UvEventLoop::new();
     let work_queue = WorkQueue::new();
-    let mut sched = ~Scheduler::new(loop_, work_queue);
+    let sleepers = SleeperList::new();
+    let mut sched = ~Scheduler::new(loop_, work_queue, sleepers);
     let main_task = ~Coroutine::new(&mut sched.stack_pool, main);
 
     sched.enqueue_task(main_task);

branches/try2/src/libcore/rt/sched.rs

@@ -13,6 +13,7 @@ use sys;
 use cast::transmute;
 use cell::Cell;
 
+use super::sleeper_list::SleeperList;
 use super::work_queue::WorkQueue;
 use super::stack::{StackPool, StackSegment};
 use super::rtio::{EventLoop, EventLoopObject, RemoteCallbackObject};
@@ -27,7 +28,12 @@ use rt::rtio::IoFactoryObject;
 /// thread local storage and the running task is owned by the
 /// scheduler.
 pub struct Scheduler {
+    /// A queue of available work. Under a work-stealing policy there
+    /// is one per Scheduler.
     priv work_queue: WorkQueue<~Coroutine>,
+    /// A shared list of sleeping schedulers. We'll use this to wake
+    /// up schedulers when pushing work onto the work queue.
+    priv sleeper_list: SleeperList,
     stack_pool: StackPool,
     /// The event loop used to drive the scheduler and perform I/O
     event_loop: ~EventLoopObject,
@@ -65,12 +71,16 @@ pub impl Scheduler {
 
     fn in_task_context(&self) -> bool { self.current_task.is_some() }
 
-    fn new(event_loop: ~EventLoopObject, work_queue: WorkQueue<~Coroutine>) -> Scheduler {
+    fn new(event_loop: ~EventLoopObject,
+           work_queue: WorkQueue<~Coroutine>,
+           sleeper_list: SleeperList)
+        -> Scheduler {
 
         // Lazily initialize the runtime TLS key
         local_ptr::init_tls_key();
 
         Scheduler {
+            sleeper_list: sleeper_list,
             event_loop: event_loop,
             work_queue: work_queue,
             stack_pool: StackPool::new(),
@@ -618,19 +628,23 @@ mod test {
         use container::Container;
         use vec::OwnedVector;
         use rt::rtio::RemoteCallback;
+        use rt::sleeper_list::SleeperList;
 
         do run_in_bare_thread {
+            let sleepers1 = SleeperList::new();
             let work_queue1 = WorkQueue::new();
+
+            let sleepers2 = sleepers1.clone();
             let work_queue2 = work_queue1.clone();
 
             let loop1 = ~UvEventLoop::new();
-            let mut sched1 = ~Scheduler::new(loop1, work_queue1.clone());
+            let mut sched1 = ~Scheduler::new(loop1, work_queue1.clone(), sleepers1);
             let handle1 = sched1.make_handle();
             let sched1_cell = Cell(sched1);
             let handle1_cell = Cell(handle1);
 
             let loop2 = ~UvEventLoop::new();
-            let mut sched2 = ~Scheduler::new(loop2, work_queue2.clone());
+            let mut sched2 = ~Scheduler::new(loop2, work_queue2.clone(), sleepers2);
             let handle2 = sched2.make_handle();
             let sched2_cell = Cell(sched2);
             let handle2_cell = Cell(handle2);

branches/try2/src/libcore/rt/sleeper_list.rs

@@ -17,6 +17,7 @@ use option::{Option, Some, None};
 use cell::Cell;
 use unstable::sync::{Exclusive, exclusive};
 use rt::sched::{Scheduler, SchedHandle};
+use clone::Clone;
 
 pub struct SleeperList {
     priv stack: ~Exclusive<~[SchedHandle]>
@@ -44,3 +45,11 @@ impl SleeperList {
         }
     }
 }
+
+impl Clone for SleeperList {
+    fn clone(&self) -> SleeperList {
+        SleeperList {
+            stack: self.stack.clone()
+        }
+    }
+}

branches/try2/src/libcore/rt/test.rs

@@ -21,8 +21,9 @@ use rt::sched::Scheduler;
 pub fn new_test_uv_sched() -> Scheduler {
     use rt::uv::uvio::UvEventLoop;
     use rt::work_queue::WorkQueue;
+    use rt::sleeper_list::SleeperList;
 
-    Scheduler::new(~UvEventLoop::new(), WorkQueue::new())
+    Scheduler::new(~UvEventLoop::new(), WorkQueue::new(), SleeperList::new())
 }
 
 /// Creates a new scheduler in a new thread and runs a task in it,