---

yaml
---
r: 52328
b: refs/heads/dist-snap
c: 4688033
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: ac435af73a0009daf22164ee2f081a7c98ca844c
+refs/heads/dist-snap: 46880337f497229e6c0ec0bf11d4af0e07c105e8
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/private.rs

@@ -28,9 +28,6 @@ use task;
 use task::{TaskBuilder, atomically};
 use uint;
 
-#[path = "private/at_exit.rs"]
-pub mod at_exit;
-
 extern mod rustrt {
     #[legacy_exports];
     unsafe fn rust_task_weaken(ch: rust_port_id);

branches/dist-snap/src/libcore/private/at_exit.rs

@@ -52,7 +52,7 @@ use prelude::*;
 use ptr;
 use result;
 use task::local_data_priv::{local_get, local_set};
-use task::rt::{task_id, sched_id, rust_task};
+use task::rt::{task_id, rust_task};
 use task;
 use util;
 use util::replace;
@@ -62,12 +62,6 @@ pub mod local_data;
 pub mod rt;
 pub mod spawn;
 
-/// A handle to a scheduler
-#[deriving_eq]
-pub enum Scheduler {
-    SchedulerHandle(sched_id)
-}
-
 /// A handle to a task
 #[deriving_eq]
 pub enum Task {
@@ -101,21 +95,7 @@ impl TaskResult : Eq {
 }
 
 /// Scheduler modes
-#[deriving_eq]
 pub enum SchedMode {
-    /// Run task on the default scheduler
-    DefaultScheduler,
-    /// Run task on the current scheduler
-    CurrentScheduler,
-    /// Run task on a specific scheduler
-    ExistingScheduler(Scheduler),
-    /**
-     * Tasks are scheduled on the main OS thread
-     *
-     * The main OS thread is the thread used to launch the runtime which,
-     * in most cases, is the process's initial thread as created by the OS.
-     */
-    PlatformThread,
     /// All tasks run in the same OS thread
     SingleThreaded,
     /// Tasks are distributed among available CPUs
@@ -124,6 +104,53 @@ pub enum SchedMode {
     ThreadPerTask,
     /// Tasks are distributed among a fixed number of OS threads
     ManualThreads(uint),
+    /**
+     * Tasks are scheduled on the main OS thread
+     *
+     * The main OS thread is the thread used to launch the runtime which,
+     * in most cases, is the process's initial thread as created by the OS.
+     */
+    PlatformThread
+}
+
+impl SchedMode : cmp::Eq {
+    pure fn eq(&self, other: &SchedMode) -> bool {
+        match (*self) {
+            SingleThreaded => {
+                match (*other) {
+                    SingleThreaded => true,
+                    _ => false
+                }
+            }
+            ThreadPerCore => {
+                match (*other) {
+                    ThreadPerCore => true,
+                    _ => false
+                }
+            }
+            ThreadPerTask => {
+                match (*other) {
+                    ThreadPerTask => true,
+                    _ => false
+                }
+            }
+            ManualThreads(e0a) => {
+                match (*other) {
+                    ManualThreads(e0b) => e0a == e0b,
+                    _ => false
+                }
+            }
+            PlatformThread => {
+                match (*other) {
+                    PlatformThread => true,
+                    _ => false
+                }
+            }
+        }
+    }
+    pure fn ne(&self, other: &SchedMode) -> bool {
+        !(*self).eq(other)
+    }
 }
 
 /**
@@ -177,7 +204,7 @@ pub type TaskOpts = {
     linked: bool,
     supervised: bool,
     mut notify_chan: Option<Chan<TaskResult>>,
-    sched: SchedOpts,
+    sched: Option<SchedOpts>,
 };
 
 /**
@@ -343,7 +370,7 @@ impl TaskBuilder {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
                 mut notify_chan: move notify_chan,
-                sched: { mode: mode, foreign_stack_size: None}
+                sched: Some({ mode: mode, foreign_stack_size: None})
             },
             can_not_copy: None,
             .. self.consume()
@@ -459,10 +486,7 @@ pub fn default_task_opts() -> TaskOpts {
         linked: true,
         supervised: false,
         mut notify_chan: None,
-        sched: {
-            mode: DefaultScheduler,
-            foreign_stack_size: None
-        }
+        sched: None
     }
 }
 
@@ -515,9 +539,10 @@ pub fn spawn_with<A:Owned>(arg: A, f: fn~(v: A)) {
 
 pub fn spawn_sched(mode: SchedMode, f: fn~()) {
     /*!
-     * Creates a new task on a new or existing scheduler
-
-     * When there are no more tasks to execute the
+     * Creates a new scheduler and executes a task on it
+     *
+     * Tasks subsequently spawned by that task will also execute on
+     * the new scheduler. When there are no more tasks to execute the
      * scheduler terminates.
      *
      * # Failure
@@ -565,10 +590,6 @@ pub fn get_task() -> Task {
     TaskHandle(rt::get_task_id())
 }
 
-pub fn get_scheduler() -> Scheduler {
-    SchedulerHandle(rt::rust_get_sched_id())
-}
-
 /**
  * Temporarily make the task unkillable
  *
@@ -906,19 +927,16 @@ fn test_spawn_sched() {
 }
 
 #[test]
-fn test_spawn_sched_childs_on_default_sched() {
+fn test_spawn_sched_childs_on_same_sched() {
     let po = oldcomm::Port();
     let ch = oldcomm::Chan(&po);
 
-    // Assuming tests run on the default scheduler
-    let default_id = rt::rust_get_sched_id();
-
     do spawn_sched(SingleThreaded) {
         let parent_sched_id = rt::rust_get_sched_id();
         do spawn {
             let child_sched_id = rt::rust_get_sched_id();
-            assert parent_sched_id != child_sched_id;
-            assert child_sched_id == default_id;
+            // This should be on the same scheduler
+            assert parent_sched_id == child_sched_id;
             oldcomm::send(ch, ());
         };
     };
@@ -1188,7 +1206,7 @@ fn test_spawn_thread_on_demand() {
 
         let (port2, chan2) = pipes::stream();
 
-        do spawn_sched(CurrentScheduler) |move chan2| {
+        do spawn() |move chan2| {
             chan2.send(());
         }
 

branches/dist-snap/src/libcore/task/mod.rs

@@ -88,7 +88,6 @@ use task::rt::rust_closure;
 use task::rt;
 use task::{Failure, ManualThreads, PlatformThread, SchedOpts, SingleThreaded};
 use task::{Success, TaskOpts, TaskResult, ThreadPerCore, ThreadPerTask};
-use task::{ExistingScheduler, SchedulerHandle};
 use task::{default_task_opts, unkillable};
 use uint;
 use util;
@@ -526,9 +525,9 @@ pub fn spawn_raw(opts: TaskOpts, f: fn~()) {
             // Agh. Get move-mode items into the closure. FIXME (#2829)
             let (child_tg, ancestors, f) = option::swap_unwrap(child_data);
             // Create child task.
-            let new_task = match opts.sched.mode {
-                DefaultScheduler => rt::new_task(),
-                _ => new_task_in_sched(opts.sched)
+            let new_task = match opts.sched {
+              None             => rt::new_task(),
+              Some(sched_opts) => new_task_in_new_sched(sched_opts)
             };
             assert !new_task.is_null();
             // Getting killed after here would leak the task.
@@ -632,16 +631,12 @@ pub fn spawn_raw(opts: TaskOpts, f: fn~()) {
         }
     }
 
-    fn new_task_in_sched(opts: SchedOpts) -> *rust_task {
+    fn new_task_in_new_sched(opts: SchedOpts) -> *rust_task {
         if opts.foreign_stack_size != None {
             fail ~"foreign_stack_size scheduler option unimplemented";
         }
 
         let num_threads = match opts.mode {
-          DefaultScheduler
-          | CurrentScheduler
-          | ExistingScheduler(*)
-          | PlatformThread => 0u, /* Won't be used */
           SingleThreaded => 1u,
           ThreadPerCore => rt::rust_num_threads(),
           ThreadPerTask => {
@@ -653,13 +648,13 @@ pub fn spawn_raw(opts: TaskOpts, f: fn~()) {
             }
             threads
           }
+          PlatformThread => 0u /* Won't be used */
         };
 
-        let sched_id = match opts.mode {
-            CurrentScheduler => rt::rust_get_sched_id(),
-            ExistingScheduler(SchedulerHandle(id)) => id,
-            PlatformThread => rt::rust_osmain_sched_id(),
-            _ => rt::rust_new_sched(num_threads)
+        let sched_id = if opts.mode != PlatformThread {
+            rt::rust_new_sched(num_threads)
+        } else {
+            rt::rust_osmain_sched_id()
         };
         rt::rust_new_task_in_sched(sched_id)
     }

branches/dist-snap/src/libcore/task/spawn.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -19,26 +19,18 @@ use core::str;
 
 pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
     let r = rand::Rng();
-    let mut i = 0u;
-    while (i < 1000u) {
-        let p = tmpdir.push(r.gen_str(16u) +
-                            str::from_slice(suffix));
-        if os::make_dir(&p, 0x1c0i32) {  // FIXME: u+rwx (#2349)
+    for 1000.times {
+        let p = tmpdir.push(r.gen_str(16) + suffix);
+        if os::make_dir(&p, 0x1c0) { // 700
             return Some(p);
         }
-        i += 1u;
     }
-    return None;
+    None
 }
 
 #[test]
 fn test_mkdtemp() {
-    let r = mkdtemp(&Path("."), "foobar");
-    match r {
-        Some(ref p) => {
-            os::remove_dir(p);
-            assert(str::ends_with(p.to_str(), "foobar"));
-        }
-        _ => assert(false)
-    }
+    let p = mkdtemp(&Path("."), "foobar").unwrap();
+    os::remove_dir(&p);
+    assert str::ends_with(p.to_str(), "foobar");
 }