---

yaml
---
r: 139830
b: refs/heads/try2
c: 93757d8
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: a2e5827866876e9bafcf1f4e94f4e354e500420a
+refs/heads/try2: 93757d81853302408dd30a3ad1a4102eae26b7c5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -11,14 +11,11 @@
 use option::*;
 use sys;
 use cast::transmute;
-use libc::c_void;
-use ptr::mut_null;
 
 use super::work_queue::WorkQueue;
 use super::stack::{StackPool, StackSegment};
 use super::rtio::{EventLoop, EventLoopObject};
 use super::context::Context;
-use tls = super::thread_local_storage;
 
 #[cfg(test)] use super::uvio::UvEventLoop;
 #[cfg(test)] use unstable::run_in_bare_thread;
@@ -110,18 +107,13 @@ pub impl Scheduler {
     }
 
     fn install(~self, f: &fn(&mut Scheduler)) -> ~Scheduler {
-        let mut tlsched = ThreadLocalScheduler::new();
-        tlsched.put_scheduler(self);
-        {
-            let sched = tlsched.get_scheduler();
-            f(sched);
+        do local::install(self) {
+            local::borrow(f)
         }
-        return tlsched.take_scheduler();
     }
 
     fn local(f: &fn(&mut Scheduler)) {
-        let mut tlsched = ThreadLocalScheduler::new();
-        f(tlsched.get_scheduler());
+        local::borrow(f)
     }
 
     // * Scheduler-context operations
@@ -329,15 +321,15 @@ 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.
-            let mut sched = ThreadLocalScheduler::new();
-            let sched = sched.get_scheduler();
-            sched.run_cleanup_job();
+            do Scheduler::local |sched| {
+                sched.run_cleanup_job();
+            }
 
             start();
 
-            let mut sched = ThreadLocalScheduler::new();
-            let sched = sched.get_scheduler();
-            sched.terminate_current_task();
+            do Scheduler::local |sched| {
+                sched.terminate_current_task();
+            }
         };
         return wrapper;
     }
@@ -352,90 +344,103 @@ pub impl Task {
     }
 }
 
-// NB: This is a type so we can use make use of the &self region.
-struct ThreadLocalScheduler(tls::Key);
+mod local {
+
+    //! Access to the thread-local Scheduler
+
+    use ptr::mut_null;
+    use libc::c_void;
+    use cast::transmute;
+
+    use super::Scheduler;
+    use tls = super::super::thread_local_storage;
+    #[cfg(test)] use super::super::uvio::UvEventLoop;
 
-impl ThreadLocalScheduler {
-    fn new() -> ThreadLocalScheduler {
+    /// Give the Scheduler to thread-local storage
+    pub fn put(sched: ~Scheduler) {
         unsafe {
-            // NB: This assumes that the TLS key has been created prior.
-            // Currently done in rust_start.
-            let key: *mut c_void = rust_get_sched_tls_key();
-            let key: &mut tls::Key = transmute(key);
-            ThreadLocalScheduler(*key)
+            let key = tls_key();
+            let void_sched: *mut c_void = transmute::<~Scheduler, *mut c_void>(sched);
+            tls::set(key, void_sched);
         }
     }
 
-    fn put_scheduler(&mut self, scheduler: ~Scheduler) {
+    /// Take ownership of the Scheduler from thread-local storage
+    pub fn take() -> ~Scheduler {
         unsafe {
-            let key = match self { &ThreadLocalScheduler(key) => key };
-            let value: *mut c_void = transmute::<~Scheduler, *mut c_void>(scheduler);
-            tls::set(key, value);
+            let key = tls_key();
+            let void_sched: *mut c_void = tls::get(key);
+            assert!(void_sched.is_not_null());
+            let sched = transmute::<*mut c_void, ~Scheduler>(void_sched);
+            tls::set(key, mut_null());
+            return sched;
         }
     }
 
-    fn get_scheduler(&mut self) -> &'self mut Scheduler {
+    /// Give the Scheduler to thread-local storage for the duration of the block
+    pub fn install(sched: ~Scheduler, f: &fn()) -> ~Scheduler {
+        put(sched);
+        f();
+        return take();
+    }
+
+    /// Borrow a mutable reference to the thread-local Scheduler
+    /// # Safety Note
+    /// Because this leaves the Scheduler in thread-local storage it is possible
+    /// For the Scheduler pointer to be aliased
+    pub fn borrow(f: &fn(&mut Scheduler)) {
         unsafe {
-            let key = match self { &ThreadLocalScheduler(key) => key };
-            let mut value: *mut c_void = tls::get(key);
-            assert!(value.is_not_null());
+            let key = tls_key();
+            let mut void_sched: *mut c_void = tls::get(key);
+            assert!(void_sched.is_not_null());
             {
-                let value_ptr = &mut value;
+                let void_sched_ptr = &mut void_sched;
                 let sched: &mut ~Scheduler = {
-                    transmute::<&mut *mut c_void, &mut ~Scheduler>(value_ptr)
+                    transmute::<&mut *mut c_void, &mut ~Scheduler>(void_sched_ptr)
                 };
                 let sched: &mut Scheduler = &mut **sched;
-                return sched;
+                f(sched);
             }
         }
     }
 
-    fn take_scheduler(&mut self) -> ~Scheduler {
+    fn tls_key() -> tls::Key {
         unsafe {
-            let key = match self { &ThreadLocalScheduler(key) => key };
-            let value: *mut c_void = tls::get(key);
-            assert!(value.is_not_null());
-            let sched = transmute(value);
-            tls::set(key, mut_null());
-            return sched;
+            let key: *mut c_void = rust_get_sched_tls_key();
+            let key: &mut tls::Key = transmute(key);
+            return *key;
         }
     }
-}
-
-extern {
-    fn rust_get_sched_tls_key() -> *mut c_void;
-}
-
-#[test]
-fn thread_local_scheduler_smoke_test() {
-    let scheduler = ~UvEventLoop::new_scheduler();
-    let mut tls_scheduler = ThreadLocalScheduler::new();
-    tls_scheduler.put_scheduler(scheduler);
-    {
-        let _scheduler = tls_scheduler.get_scheduler();
-    }
-    let _scheduler = tls_scheduler.take_scheduler();
-}
 
-#[test]
-fn thread_local_scheduler_two_instances() {
-    let scheduler = ~UvEventLoop::new_scheduler();
-    let mut tls_scheduler = ThreadLocalScheduler::new();
-    tls_scheduler.put_scheduler(scheduler);
-    {
+    extern {
+        fn rust_get_sched_tls_key() -> *mut c_void;
+    }
 
-        let _scheduler = tls_scheduler.get_scheduler();
+    #[test]
+    fn thread_local_scheduler_smoke_test() {
+        let scheduler = ~UvEventLoop::new_scheduler();
+        put(scheduler);
+        let _scheduler = take();
     }
-    {
-        let scheduler = tls_scheduler.take_scheduler();
-        tls_scheduler.put_scheduler(scheduler);
+
+    #[test]
+    fn thread_local_scheduler_two_instances() {
+        let scheduler = ~UvEventLoop::new_scheduler();
+        put(scheduler);
+        let _scheduler = take();
+        let scheduler = ~UvEventLoop::new_scheduler();
+        put(scheduler);
+        let _scheduler = take();
     }
 
-    let mut tls_scheduler = ThreadLocalScheduler::new();
-    {
-        let _scheduler = tls_scheduler.get_scheduler();
+    #[test]
+    fn install_borrow_smoke_test() {
+        let scheduler = ~UvEventLoop::new_scheduler();
+        let _scheduler = do install(scheduler) {
+            do borrow |_sched| {
+            }
+        };
     }
-    let _scheduler = tls_scheduler.take_scheduler();
 }
 
 #[test]