std::rt: Some cleanup

diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index bbf1cf0d9b797caceb68160f80914f6d2156bef0..97a0285ea196e55fa435207fc749a07317e62935 100644 (file)
--- a/src/libstd/rt/mod.rs
+++ b/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.

diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index bbe4aa25e2967d5eb01a31d59cec5b2285e21d63..26956c49a629a59cf294fa60a8544465386d6982 100644 (file)
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -177,7 +177,7 @@ pub fn run(~self) -> ~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,10 +213,10 @@ fn run_sched_once() {
         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;
         }
 
@@ -224,18 +224,18 @@ fn run_sched_once() {
         // 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 @@ pub fn schedule_task(~self, task: ~Coroutine) {
             // 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