---

yaml
---
r: 64913
b: refs/heads/snap-stage3
c: 66a0b58
h: refs/heads/master
i:
  64911: f77e699
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: bc7cee7bbf816be7a712c06a93015dc3c6fd5611
+refs/heads/snap-stage3: 66a0b5870d7c1c436b197d744fba5ced2e5f6462
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/configure

@@ -371,6 +371,7 @@ opt docs     1 "build documentation"
 opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"
+opt llvm-assertions 1 "build LLVM with assertions"
 opt debug 0 "build with extra debug fun"
 opt ratchet-bench 0 "ratchet benchmarks"
 opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
@@ -793,10 +794,17 @@ do
             LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
             # Just use LLVM straight from its build directory to
             # avoid 'make install' time
-            LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts
+            LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug
         else
             LLVM_DBG_OPTS="--enable-optimized"
-            LLVM_INST_DIR=$LLVM_BUILD_DIR/Release+Asserts
+            LLVM_INST_DIR=$LLVM_BUILD_DIR/Release
+        fi
+        if [ ! -z "$CFG_DISABLE_LLVM_ASSERTIONS" ]
+        then
+            LLVM_ASSERTION_OPTS="--disable-assertions"
+        else
+            LLVM_ASSERTION_OPTS="--enable-assertions"
+            LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts
         fi
     else
         msg "not reconfiguring LLVM, external LLVM root"
@@ -836,7 +844,7 @@ do
         LLVM_TARGET="--target=$t"
 
         # Disable unused LLVM features
-        LLVM_OPTS="$LLVM_DBG_OPTS --disable-docs --enable-bindings=none"
+        LLVM_OPTS="$LLVM_DBG_OPTS $LLVM_ASSERTION_OPTS --disable-docs --enable-bindings=none"
 
         case "$CFG_C_COMPILER" in
             ("ccache clang")

branches/snap-stage3/src/libstd/rt/kill.rs

@@ -84,7 +84,7 @@ pub struct Death {
     on_exit:         Option<~fn(bool)>,
     // nesting level counter for task::unkillable calls (0 == killable).
     unkillable:      int,
-    // nesting level counter for unstable::atomically calls (0 == can yield).
+    // nesting level counter for task::atomically calls (0 == can yield).
     wont_sleep:      int,
     // A "spare" handle to the kill flag inside the kill handle. Used during
     // blocking/waking as an optimization to avoid two xadds on the refcount.

branches/snap-stage3/src/libstd/rt/mod.rs

@@ -316,14 +316,12 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
             // Just put an unpinned task onto one of the default schedulers.
             let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool, main);
             main_task.death.on_exit = Some(on_exit);
-            main_task.name = Some(~"main");
             scheds[0].enqueue_task(main_task);
         }
         Some(ref mut main_sched) => {
             let home = Sched(main_sched.make_handle());
             let mut main_task = ~Task::new_root_homed(&mut scheds[0].stack_pool, home, main);
             main_task.death.on_exit = Some(on_exit);
-            main_task.name = Some(~"main");
             main_sched.enqueue_task(main_task);
         }
     };

branches/snap-stage3/src/libstd/rt/task.rs

@@ -40,9 +40,7 @@ pub struct Task {
     taskgroup: Option<Taskgroup>,
     death: Death,
     destroyed: bool,
-    coroutine: Option<~Coroutine>,
-    // FIXME(#6874/#7599) use StringRef to save on allocations
-    name: Option<~str>,
+    coroutine: Option<~Coroutine>
 }
 
 pub struct Coroutine {
@@ -92,8 +90,7 @@ impl Task {
             taskgroup: None,
             death: Death::new(),
             destroyed: false,
-            coroutine: Some(~Coroutine::new(stack_pool, start)),
-            name: None,
+            coroutine: Some(~Coroutine::new(stack_pool, start))
         }
     }
 
@@ -112,8 +109,7 @@ impl Task {
             // FIXME(#7544) make watching optional
             death: self.death.new_child(),
             destroyed: false,
-            coroutine: Some(~Coroutine::new(stack_pool, start)),
-            name: None,
+            coroutine: Some(~Coroutine::new(stack_pool, start))
         }
     }
 

branches/snap-stage3/src/libstd/sys.rs

@@ -137,13 +137,12 @@ impl FailWithCause for &'static str {
 
 // FIXME #4427: Temporary until rt::rt_fail_ goes away
 pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
+    use cell::Cell;
     use either::Left;
-    use option::{Some, None};
     use rt::{context, OldTaskContext, TaskContext};
     use rt::task::Task;
     use rt::local::Local;
     use rt::logging::Logger;
-    use str::Str;
 
     let context = context();
     match context {
@@ -160,26 +159,20 @@ pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
                 let msg = str::raw::from_c_str(msg);
                 let file = str::raw::from_c_str(file);
 
+                let outmsg = fmt!("task failed at '%s', %s:%i",
+                                  msg, file, line as int);
+
                 // XXX: Logging doesn't work correctly in non-task context because it
                 // invokes the local heap
                 if context == TaskContext {
                     // XXX: Logging doesn't work here - the check to call the log
                     // function never passes - so calling the log function directly.
+                    let outmsg = Cell::new(outmsg);
                     do Local::borrow::<Task, ()> |task| {
-                        let msg = match task.name {
-                            Some(ref name) =>
-                                fmt!("task '%s' failed at '%s', %s:%i",
-                                     name.as_slice(), msg, file, line as int),
-                            None =>
-                                fmt!("task <unnamed> failed at '%s', %s:%i",
-                                     msg, file, line as int)
-                        };
-
-                        task.logger.log(Left(msg));
+                        task.logger.log(Left(outmsg.take()));
                     }
                 } else {
-                    rterrln!("failed in non-task context at '%s', %s:%i",
-                             msg, file, line as int);
+                    rterrln!("%s", outmsg);
                 }
 
                 gc::cleanup_stack_for_failure();

branches/snap-stage3/src/libstd/task/mod.rs

@@ -120,8 +120,6 @@ pub struct SchedOpts {
  *
  * * notify_chan - Enable lifecycle notifications on the given channel
  *
- * * name - A name for the task-to-be, for identification in failure messages.
- *
  * * sched - Specify the configuration of a new scheduler to create the task
  *           in
  *
@@ -141,7 +139,6 @@ pub struct TaskOpts {
     watched: bool,
     indestructible: bool,
     notify_chan: Option<Chan<TaskResult>>,
-    name: Option<~str>,
     sched: SchedOpts
 }
 
@@ -188,23 +185,23 @@ impl TaskBuilder {
         self.consumed = true;
         let gen_body = self.gen_body.take();
         let notify_chan = self.opts.notify_chan.take();
-        let name = self.opts.name.take();
         TaskBuilder {
             opts: TaskOpts {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
                 watched: self.opts.watched,
                 indestructible: self.opts.indestructible,
                 notify_chan: notify_chan,
-                name: name,
                 sched: self.opts.sched
             },
             gen_body: gen_body,
             can_not_copy: None,
             consumed: false
         }
     }
+}
 
+impl TaskBuilder {
     /// Decouple the child task's failure from the parent's. If either fails,
     /// the other will not be killed.
     pub fn unlinked(&mut self) {
@@ -284,12 +281,6 @@ impl TaskBuilder {
         self.opts.notify_chan = Some(notify_pipe_ch);
     }
 
-    /// Name the task-to-be. Currently the name is used for identification
-    /// only in failure messages.
-    pub fn name(&mut self, name: ~str) {
-        self.opts.name = Some(name);
-    }
-
     /// Configure a custom scheduler mode for the task.
     pub fn sched_mode(&mut self, mode: SchedMode) {
         self.opts.sched.mode = mode;
@@ -342,15 +333,13 @@ impl TaskBuilder {
     pub fn spawn(&mut self, f: ~fn()) {
         let gen_body = self.gen_body.take();
         let notify_chan = self.opts.notify_chan.take();
-        let name = self.opts.name.take();
         let x = self.consume();
         let opts = TaskOpts {
             linked: x.opts.linked,
             supervised: x.opts.supervised,
             watched: x.opts.watched,
             indestructible: x.opts.indestructible,
             notify_chan: notify_chan,
-            name: name,
             sched: x.opts.sched
         };
         let f = match gen_body {
@@ -419,7 +408,6 @@ pub fn default_task_opts() -> TaskOpts {
         watched: true,
         indestructible: false,
         notify_chan: None,
-        name: None,
         sched: SchedOpts {
             mode: DefaultScheduler,
         }
@@ -519,21 +507,6 @@ pub fn try<T:Send>(f: ~fn() -> T) -> Result<T,()> {
 
 /* Lifecycle functions */
 
-/// Read the name of the current task.
-pub fn with_task_name<U>(blk: &fn(Option<&str>) -> U) -> U {
-    use rt::task::Task;
-
-    match context() {
-        TaskContext => do Local::borrow::<Task, U> |task| {
-            match task.name {
-                Some(ref name) => blk(Some(name.as_slice())),
-                None => blk(None)
-            }
-        },
-        _ => fail!("no task name exists in %?", context()),
-    }
-}
-
 pub fn yield() {
     //! Yield control to the task scheduler
 
@@ -655,6 +628,44 @@ pub unsafe fn rekillable<U>(f: &fn() -> U) -> U {
     }
 }
 
+/**
+ * A stronger version of unkillable that also inhibits scheduling operations.
+ * For use with exclusive Arcs, which use pthread mutexes directly.
+ */
+pub unsafe fn atomically<U>(f: &fn() -> U) -> U {
+    use rt::task::Task;
+
+    match context() {
+        OldTaskContext => {
+            let t = rt::rust_get_task();
+            do (|| {
+                rt::rust_task_inhibit_kill(t);
+                rt::rust_task_inhibit_yield(t);
+                f()
+            }).finally {
+                rt::rust_task_allow_yield(t);
+                rt::rust_task_allow_kill(t);
+            }
+        }
+        TaskContext => {
+            let t = Local::unsafe_borrow::<Task>();
+            do (|| {
+                // It's important to inhibit kill after inhibiting yield, because
+                // inhibit-kill might fail if we were already killed, and the
+                // inhibit-yield must happen to match the finally's allow-yield.
+                (*t).death.inhibit_yield();
+                (*t).death.inhibit_kill((*t).unwinder.unwinding);
+                f()
+            }).finally {
+                (*t).death.allow_kill((*t).unwinder.unwinding);
+                (*t).death.allow_yield();
+            }
+        }
+        // FIXME(#3095): As in unkillable().
+        _ => f()
+    }
+}
+
 #[test] #[should_fail] #[ignore(cfg(windows))]
 fn test_cant_dup_task_builder() {
     let mut builder = task();
@@ -794,34 +805,6 @@ fn test_spawn_linked_sup_propagate_sibling() {
     fail!();
 }
 
-#[test]
-fn test_unnamed_task() {
-    use rt::test::run_in_newsched_task;
-
-    do run_in_newsched_task {
-        do spawn {
-            do with_task_name |name| {
-                assert!(name.is_none());
-            }
-        }
-    }
-}
-
-#[test]
-fn test_named_task() {
-    use rt::test::run_in_newsched_task;
-
-    do run_in_newsched_task {
-        let mut t = task();
-        t.name(~"ada lovelace");
-        do t.spawn {
-            do with_task_name |name| {
-                assert!(name.get() == "ada lovelace");
-            }
-        }
-    }
-}
-
 #[test]
 fn test_run_basic() {
     let (po, ch) = stream::<()>();
@@ -1139,6 +1122,21 @@ fn test_unkillable_nested() {
     po.recv();
 }
 
+#[test] #[should_fail] #[ignore(cfg(windows))]
+fn test_atomically() {
+    unsafe { do atomically { yield(); } }
+}
+
+#[test]
+fn test_atomically2() {
+    unsafe { do atomically { } } yield(); // shouldn't fail
+}
+
+#[test] #[should_fail] #[ignore(cfg(windows))]
+fn test_atomically_nested() {
+    unsafe { do atomically { do atomically { } yield(); } }
+}
+
 #[test]
 fn test_child_doesnt_ref_parent() {
     // If the child refcounts the parent task, this will stack overflow when

branches/snap-stage3/src/libstd/task/spawn.rs

@@ -726,8 +726,6 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
         task.death.on_exit = Some(on_exit);
     }
 
-    task.name = opts.name.take();
-
     rtdebug!("spawn about to take scheduler");
 
     let sched = Local::take::<Scheduler>();

branches/snap-stage3/src/libstd/unstable/dynamic_lib.rs

@@ -105,7 +105,7 @@ mod dl {
     use path;
     use ptr;
     use str;
-    use unstable::sync::atomically;
+    use task;
     use result::*;
 
     pub unsafe fn open_external(filename: &path::Path) -> *libc::c_void {
@@ -120,7 +120,7 @@ mod dl {
 
     pub fn check_for_errors_in<T>(f: &fn()->T) -> Result<T, ~str> {
         unsafe {
-            do atomically {
+            do task::atomically {
                 let _old_error = dlerror();
 
                 let result = f();
@@ -164,7 +164,7 @@ mod dl {
     use libc;
     use path;
     use ptr;
-    use unstable::sync::atomically;
+    use task;
     use result::*;
 
     pub unsafe fn open_external(filename: &path::Path) -> *libc::c_void {
@@ -181,7 +181,7 @@ mod dl {
 
     pub fn check_for_errors_in<T>(f: &fn()->T) -> Result<T, ~str> {
         unsafe {
-            do atomically {
+            do task::atomically {
                 SetLastError(0);
 
                 let result = f();