---

yaml
---
r: 139835
b: refs/heads/try2
c: ebefe07
h: refs/heads/master
i:
  139833: 64f1c29
  139831: 7ed3bc0
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: 473b4d19ad51529afb8f1391cf471a20053c781c
+refs/heads/try2: ebefe07792caf17c03c6f90fb1979d4e6c935001
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -43,7 +43,7 @@ pub fn take() -> ~Scheduler {
 /// # Safety Note
 /// Because this leaves the Scheduler in thread-local storage it is possible
 /// For the Scheduler pointer to be aliased
-pub unsafe fn borrow(f: &fn(&mut Scheduler)) {
+pub unsafe fn borrow() -> &mut Scheduler {
     unsafe {
         let key = tls_key();
         let mut void_sched: *mut c_void = tls::get(key);
@@ -54,7 +54,7 @@ pub unsafe fn borrow(f: &fn(&mut Scheduler)) {
                 transmute::<&mut *mut c_void, &mut ~Scheduler>(void_sched_ptr)
             };
             let sched: &mut Scheduler = &mut **sched;
-            f(sched);
+            return sched;
         }
     }
 }
@@ -93,8 +93,7 @@ fn borrow_smoke_test() {
     let scheduler = ~UvEventLoop::new_scheduler();
     put(scheduler);
     unsafe {
-        do borrow |_sched| {
-        }
+        let _scheduler = borrow();
     }
     let _scheduler = take();
 }

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

@@ -95,29 +95,33 @@ pub impl Scheduler {
         // Give ownership of the scheduler (self) to the thread
         local::put(self);
 
-        do Scheduler::unsafe_local |scheduler| {
-            fn run_scheduler_once() {
-                do Scheduler::unsafe_local |scheduler| {
-                    if scheduler.resume_task_from_queue() {
-                        // Ok, a task ran. Nice! We'll do it again later
-                        scheduler.event_loop.callback(run_scheduler_once);
-                    }
-                }
+        let scheduler = Scheduler::unsafe_local_borrow();
+        fn run_scheduler_once() {
+            let scheduler = Scheduler::unsafe_local_borrow();
+            if scheduler.resume_task_from_queue() {
+                // Ok, a task ran. Nice! We'll do it again later
+                scheduler.event_loop.callback(run_scheduler_once);
             }
-
-            scheduler.event_loop.callback(run_scheduler_once);
-            scheduler.event_loop.run();
         }
 
+        scheduler.event_loop.callback(run_scheduler_once);
+        scheduler.event_loop.run();
+
         return local::take();
     }
 
     /// Get a mutable pointer to the thread-local scheduler.
     /// # Safety Note
     /// This allows other mutable aliases to the scheduler, both in the current
     /// execution context and other execution contexts.
-    fn unsafe_local(f: &fn(&mut Scheduler)) {
-        unsafe { local::borrow(f) }
+    fn unsafe_local_borrow() -> &mut Scheduler {
+        unsafe { local::borrow() }
+    }
+
+    fn local_borrow(f: &fn(&mut Scheduler)) {
+        let mut sched = local::take();
+        f(sched);
+        local::put(sched);
     }
 
     // * Scheduler-context operations
@@ -208,9 +212,8 @@ pub impl Scheduler {
         }
 
         // We could be executing in a different thread now
-        do Scheduler::unsafe_local |sched| {
-            sched.run_cleanup_job();
-        }
+        let sched = Scheduler::unsafe_local_borrow();
+        sched.run_cleanup_job();
     }
 
     /// Switch directly to another task, without going through the scheduler.
@@ -232,9 +235,8 @@ pub impl Scheduler {
         }
 
         // We could be executing in a different thread now
-        do Scheduler::unsafe_local |sched| {
-            sched.run_cleanup_job();
-        }
+        let sched = Scheduler::unsafe_local_borrow();
+        sched.run_cleanup_job();
     }
 
     // * Other stuff
@@ -331,15 +333,13 @@ pub impl Task {
             // This is the first code to execute after the initial
             // context switch to the task. The previous context may
             // have asked us to do some cleanup.
-            do Scheduler::unsafe_local |sched| {
-                sched.run_cleanup_job();
-            }
+            let sched = Scheduler::unsafe_local_borrow();
+            sched.run_cleanup_job();
 
             start();
 
-            do Scheduler::unsafe_local |sched| {
-                sched.terminate_current_task();
-            }
+            let sched = Scheduler::unsafe_local_borrow();
+            sched.terminate_current_task();
         };
         return wrapper;
     }
@@ -398,13 +398,12 @@ fn test_swap_tasks() {
         let mut sched = ~UvEventLoop::new_scheduler();
         let task1 = ~do Task::new(&mut sched.stack_pool) {
             unsafe { *count_ptr = *count_ptr + 1; }
-            do Scheduler::unsafe_local |sched| {
-                let task2 = ~do Task::new(&mut sched.stack_pool) {
-                    unsafe { *count_ptr = *count_ptr + 1; }
-                };
-                // Context switch directly to the new task
-                sched.resume_task_from_running_task_direct(task2);
-            }
+            let sched = Scheduler::unsafe_local_borrow();
+            let task2 = ~do Task::new(&mut sched.stack_pool) {
+                unsafe { *count_ptr = *count_ptr + 1; }
+            };
+            // Context switch directly to the new task
+            sched.resume_task_from_running_task_direct(task2);
             unsafe { *count_ptr = *count_ptr + 1; }
         };
         sched.task_queue.push_back(task1);
@@ -431,7 +430,7 @@ fn test_run_a_lot_of_tasks_queued() {
         assert!(count == MAX);
 
         fn run_task(count_ptr: *mut int) {
-            do Scheduler::unsafe_local |sched| {
+            do Scheduler::local_borrow |sched| {
                 let task = ~do Task::new(&mut sched.stack_pool) {
                     unsafe {
                         *count_ptr = *count_ptr + 1;
@@ -464,18 +463,17 @@ fn test_run_a_lot_of_tasks_direct() {
         assert!(count == MAX);
 
         fn run_task(count_ptr: *mut int) {
-            do Scheduler::unsafe_local |sched| {
-                let task = ~do Task::new(&mut sched.stack_pool) {
-                    unsafe {
-                        *count_ptr = *count_ptr + 1;
-                        if *count_ptr != MAX {
-                            run_task(count_ptr);
-                        }
+            let sched = Scheduler::unsafe_local_borrow();
+            let task = ~do Task::new(&mut sched.stack_pool) {
+                unsafe {
+                    *count_ptr = *count_ptr + 1;
+                    if *count_ptr != MAX {
+                        run_task(count_ptr);
                     }
-                };
-                // Context switch directly to the new task
-                sched.resume_task_from_running_task_direct(task);
-            }
+                }
+            };
+            // Context switch directly to the new task
+            sched.resume_task_from_running_task_direct(task);
         };
     }
 }
@@ -485,12 +483,11 @@ fn test_block_task() {
     do run_in_bare_thread {
         let mut sched = ~UvEventLoop::new_scheduler();
         let task = ~do Task::new(&mut sched.stack_pool) {
-            do Scheduler::unsafe_local |sched| {
-                assert!(sched.in_task_context());
-                do sched.deschedule_running_task_and_then() |sched, task| {
-                    assert!(!sched.in_task_context());
-                    sched.task_queue.push_back(task);
-                }
+            let sched = Scheduler::unsafe_local_borrow();
+            assert!(sched.in_task_context());
+            do sched.deschedule_running_task_and_then() |sched, task| {
+                assert!(!sched.in_task_context());
+                sched.task_queue.push_back(task);
             }
         };
         sched.task_queue.push_back(task);