---

yaml
---
r: 142643
b: refs/heads/try2
c: ddbccec
h: refs/heads/master
i:
  142641: a46db5b
  142639: f159364
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: e65d0cbabebc73f2c9733a7ed158576c9702e71e
+refs/heads/try2: ddbccecc27e7a6be144c9c55d25a5b56cac0a179
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -267,11 +267,10 @@ pub fn run(main: ~fn()) -> int {
     };
 
     // Create and enqueue the main task.
-    let main_cell = Cell::new(main);
     let mut new_task = ~Task::new_root();
     new_task.on_exit = Some(on_exit);
     let main_task = ~Coroutine::with_task(&mut scheds[0].stack_pool,
-                                          new_task, main_cell.take());
+                                          new_task, main);
     scheds[0].enqueue_task(main_task);
 
     // Run each scheduler in a thread.

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

@@ -177,7 +177,7 @@ impl Scheduler {
 
         rtdebug!("run taking sched");
         let sched = Local::take::<Scheduler>();
-        // XXX: Reenable this once we're using a per-task queue. With a shared
+        // XXX: Reenable this once we're using a per-scheduler queue. With a shared
         // queue this is not true
         //assert!(sched.work_queue.is_empty());
         rtdebug!("scheduler metrics: %s\n", {
@@ -213,29 +213,29 @@ impl Scheduler {
         if sched.resume_task_from_queue() {
             // We performed a scheduling action. There may be other work
             // to do yet, so let's try again later.
-            let mut sched = Local::take::<Scheduler>();
-            sched.metrics.tasks_resumed_from_queue += 1;
-            sched.event_loop.callback(Scheduler::run_sched_once);
-            Local::put(sched);
+            do Local::borrow::<Scheduler, ()> |sched| {
+                sched.metrics.tasks_resumed_from_queue += 1;
+                sched.event_loop.callback(Scheduler::run_sched_once);
+            }
             return;
         }
 
         // If we got here then there was no work to do.
         // Generate a SchedHandle and push it to the sleeper list so
         // somebody can wake us up later.
         rtdebug!("no work to do");
-        let mut sched = Local::take::<Scheduler>();
-        sched.metrics.wasted_turns += 1;
-        if !sched.sleepy && !sched.no_sleep {
-            rtdebug!("sleeping");
-            sched.metrics.sleepy_times += 1;
-            sched.sleepy = true;
-            let handle = sched.make_handle();
-            sched.sleeper_list.push(handle);
-        } else {
-            rtdebug!("not sleeping");
+        do Local::borrow::<Scheduler, ()> |sched| {
+            sched.metrics.wasted_turns += 1;
+            if !sched.sleepy && !sched.no_sleep {
+                rtdebug!("sleeping");
+                sched.metrics.sleepy_times += 1;
+                sched.sleepy = true;
+                let handle = sched.make_handle();
+                sched.sleeper_list.push(handle);
+            } else {
+                rtdebug!("not sleeping");
+            }
         }
-        Local::put(sched);
     }
 
     pub fn make_handle(&mut self) -> SchedHandle {
@@ -462,8 +462,7 @@ impl Scheduler {
             // here we know we are home, execute now OR we know we
             // aren't homed, and that this sched doesn't care
             do this.switch_running_tasks_and_then(task) |sched, last_task| {
-                let last_task = Cell::new(last_task);
-                sched.enqueue_task(last_task.take());
+                sched.enqueue_task(last_task);
             }
         } else if !homed && !this.run_anything {
             // the task isn't homed, but it can't be run here