---

yaml
---
r: 100863
b: refs/heads/snap-stage3
c: 836ffb5
h: refs/heads/master
i:
  100861: 9cd9b44
  100859: 043ef01
  100855: 7c568d5
  100847: 3e6b4cd
  100831: 4eef584
  100799: 18021f0
  100735: 2bd8997
  100607: 42991df
  100351: bd2855e
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: e3b1f3c443c048913e2d573fcc5a9c2be3484a78
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 5d4fd50af3c16ffe43c8035b929374e13bb76793
+refs/heads/snap-stage3: 836ffb528883225e036e506b3a8f112d81e096ff
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/platform.mk

@@ -350,7 +350,7 @@ CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabi := -Wl,--export-dynamic,--dynamic-
 CFG_GCCISH_PRE_LIB_FLAGS_arm-unknown-linux-gnueabi := -Wl,-whole-archive
 CFG_GCCISH_POST_LIB_FLAGS_arm-unknown-linux-gnueabi := -Wl,-no-whole-archive
 CFG_DEF_SUFFIX_arm-unknown-linux-gnueabi := .linux.def
-CFG_LLC_FLAGS_arm-unknown-linux-gnueabi :=
+CFG_LLC_FLAGS_arm-unknown-linux-gnueabi := -arm-enable-ehabi -arm-enable-ehabi-descriptors
 CFG_INSTALL_NAME_arm-unknown-linux-gnueabi =
 CFG_LIBUV_LINK_FLAGS_arm-unknown-linux-gnueabi =
 CFG_EXE_SUFFIX_arm-unknown-linux-gnueabi :=

branches/snap-stage3/src/doc/rustdoc.md

@@ -100,29 +100,34 @@ rustdoc --test crate.rs
 
 ## Defining tests
 
-Rust documentation currently uses the markdown format, and rustdoc treats all
-code blocks as testable-by-default. In order to not run a test over a block of
-code, the `ignore` string can be added to the three-backtick form of markdown
-code block.
+Rust documentation currently uses the markdown format, and code blocks can refer
+to any piece of code-related documentation, which isn't always rust. Because of
+this, only code blocks with the language of "rust" will be considered for
+testing.
 
 ~~~
-```
+```rust
 // This is a testable code block
 ```
 
-```ignore
+```
 // This is not a testable code block
 ```
 
-    // This is a testable code block (4-space indent)
+    // This is not a testable code block (4-space indent)
 ~~~
 
-In addition to the `ignore` directive, you can specify that the test's execution
-should fail with the `should_fail` directive.
+In addition to only testing "rust"-language code blocks, there are additional
+specifiers that can be used to dictate how a code block is tested:
 
 ~~~
-```should_fail
-// This code block is expected to generate a failure when run
+```rust,ignore
+// This code block is ignored by rustdoc, but is passed through to the test
+// harness
+```
+
+```rust,should_fail
+// This code block is expected to generate a failure
 ```
 ~~~
 
@@ -138,7 +143,7 @@ that one can still write things like `#[deriving(Eq)]`).
 # the doc-generating tool.  In order to display them anyway in this particular
 # case, the character following the leading '#' is not a usual space like in
 # these first five lines but a non breakable one.
-#
+# 
 # // showing 'fib' in this documentation would just be tedious and detracts from
 # // what's actualy being documented.
 # fn fib(n: int) { n + 2 }
@@ -164,6 +169,9 @@ rustdoc --test lib.rs --test-args 'foo'
 
 // See what's possible when running tests
 rustdoc --test lib.rs --test-args '--help'
+
+// Run all ignored tests
+rustdoc --test lib.rs --test-args '--ignored'
 ~~~
 
 When testing a library, code examples will often show how functions are used,

branches/snap-stage3/src/libextra/json.rs

@@ -30,7 +30,7 @@ An object is a series of string keys mapping to values, in `"key": value` format
 Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).
 A simple JSON document encoding a person, his/her age, address and phone numbers could look like:
 
-```ignore
+```
 {
     "FirstName": "John",
     "LastName": "Doe",

branches/snap-stage3/src/libextra/stats.rs

@@ -341,7 +341,7 @@ pub fn write_5_number_summary(w: &mut io::Writer,
 /// As an example, the summary with 5-number-summary `(min=15, q1=17, med=20, q3=24, max=31)` might
 /// display as:
 ///
-/// ~~~~ignore
+/// ~~~~
 ///   10 |        [--****#******----------]          | 40
 /// ~~~~
 

branches/snap-stage3/src/libglob/lib.rs

@@ -67,7 +67,7 @@ pub struct Paths {
 ///
 /// The above code will print:
 ///
-/// ```ignore
+/// ```
 /// /media/pictures/kittens.jpg
 /// /media/pictures/puppies.jpg
 /// ```

branches/snap-stage3/src/libgreen/sched.rs

@@ -15,7 +15,7 @@ use std::rt::rtio::{RemoteCallback, PausableIdleCallback, Callback, EventLoop};
 use std::rt::task::BlockedTask;
 use std::rt::task::Task;
 use std::sync::deque;
-use std::unstable::mutex::NativeMutex;
+use std::unstable::mutex::Mutex;
 use std::unstable::raw;
 
 use TaskState;
@@ -669,7 +669,8 @@ impl Scheduler {
         // is acquired here. This is the resumption points and the "bounce"
         // that it is referring to.
         unsafe {
-            let _guard = current_task.nasty_deschedule_lock.lock();
+            current_task.nasty_deschedule_lock.lock();
+            current_task.nasty_deschedule_lock.unlock();
         }
         return current_task;
     }
@@ -764,11 +765,10 @@ impl Scheduler {
         // to it, but we're guaranteed that the task won't exit until we've
         // unlocked the lock so there's no worry of this memory going away.
         let cur = self.change_task_context(cur, next, |sched, mut task| {
-            let lock: *mut NativeMutex = &mut task.nasty_deschedule_lock;
-            unsafe {
-                let _guard = (*lock).lock();
-                f(sched, BlockedTask::block(task.swap()));
-            }
+            let lock: *mut Mutex = &mut task.nasty_deschedule_lock;
+            unsafe { (*lock).lock() }
+            f(sched, BlockedTask::block(task.swap()));
+            unsafe { (*lock).unlock() }
         });
         cur.put();
     }
@@ -1453,8 +1453,8 @@ mod test {
 
     #[test]
     fn test_spawn_sched_blocking() {
-        use std::unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
-        static mut LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
+        use std::unstable::mutex::{Mutex, MUTEX_INIT};
+        static mut LOCK: Mutex = MUTEX_INIT;
 
         // Testing that a task in one scheduler can block in foreign code
         // without affecting other schedulers
@@ -1466,11 +1466,12 @@ mod test {
             let mut handle = pool.spawn_sched();
             handle.send(PinnedTask(pool.task(TaskOpts::new(), proc() {
                 unsafe {
-                    let mut guard = LOCK.lock();
+                    LOCK.lock();
 
                     start_ch.send(());
-                    guard.wait();   // block the scheduler thread
-                    guard.signal(); // let them know we have the lock
+                    LOCK.wait();   // block the scheduler thread
+                    LOCK.signal(); // let them know we have the lock
+                    LOCK.unlock();
                 }
 
                 fin_ch.send(());
@@ -1502,9 +1503,10 @@ mod test {
                 child_ch.send(20);
                 pingpong(&parent_po, &child_ch);
                 unsafe {
-                    let mut guard = LOCK.lock();
-                    guard.signal();   // wakeup waiting scheduler
-                    guard.wait();     // wait for them to grab the lock
+                    LOCK.lock();
+                    LOCK.signal();   // wakeup waiting scheduler
+                    LOCK.wait();     // wait for them to grab the lock
+                    LOCK.unlock();
                 }
             })));
             drop(handle);

branches/snap-stage3/src/libgreen/simple.rs

@@ -17,10 +17,10 @@ use std::rt::local::Local;
 use std::rt::rtio;
 use std::rt::task::{Task, BlockedTask};
 use std::task::TaskOpts;
-use std::unstable::mutex::NativeMutex;
+use std::unstable::sync::LittleLock;
 
 struct SimpleTask {
-    lock: NativeMutex,
+    lock: LittleLock,
     awoken: bool,
 }
 
@@ -59,9 +59,9 @@ impl Runtime for SimpleTask {
         to_wake.put_runtime(self as ~Runtime);
         unsafe {
             cast::forget(to_wake);
-            let mut guard = (*me).lock.lock();
+            let _l = (*me).lock.lock();
             (*me).awoken = true;
-            guard.signal();
+            (*me).lock.signal();
         }
     }
 
@@ -83,7 +83,7 @@ impl Runtime for SimpleTask {
 pub fn task() -> ~Task {
     let mut task = ~Task::new();
     task.put_runtime(~SimpleTask {
-        lock: unsafe {NativeMutex::new()},
+        lock: LittleLock::new(),
         awoken: false,
     } as ~Runtime);
     return task;

branches/snap-stage3/src/libgreen/task.rs

@@ -25,7 +25,7 @@ use std::rt::local::Local;
 use std::rt::rtio;
 use std::rt::task::{Task, BlockedTask, SendMessage};
 use std::task::TaskOpts;
-use std::unstable::mutex::NativeMutex;
+use std::unstable::mutex::Mutex;
 use std::unstable::raw;
 
 use context::Context;
@@ -65,7 +65,7 @@ pub struct GreenTask {
     pool_id: uint,
 
     // See the comments in the scheduler about why this is necessary
-    nasty_deschedule_lock: NativeMutex,
+    nasty_deschedule_lock: Mutex,
 }
 
 pub enum TaskType {
@@ -163,7 +163,7 @@ impl GreenTask {
             task_type: task_type,
             sched: None,
             handle: None,
-            nasty_deschedule_lock: unsafe { NativeMutex::new() },
+            nasty_deschedule_lock: unsafe { Mutex::new() },
             task: Some(~Task::new()),
         }
     }
@@ -322,10 +322,11 @@ impl GreenTask {
     // uncontended except for when the task is rescheduled).
     fn reawaken_remotely(mut ~self) {
         unsafe {
-            let mtx = &mut self.nasty_deschedule_lock as *mut NativeMutex;
+            let mtx = &mut self.nasty_deschedule_lock as *mut Mutex;
             let handle = self.handle.get_mut_ref() as *mut SchedHandle;
-            let _guard = (*mtx).lock();
+            (*mtx).lock();
             (*handle).send(RunOnce(self));
+            (*mtx).unlock();
         }
     }
 }
@@ -478,6 +479,12 @@ impl Runtime for GreenTask {
     fn wrap(~self) -> ~Any { self as ~Any }
 }
 
+impl Drop for GreenTask {
+    fn drop(&mut self) {
+        unsafe { self.nasty_deschedule_lock.destroy(); }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::rt::Runtime;

branches/snap-stage3/src/libnative/bookkeeping.rs

@@ -17,10 +17,10 @@
 //! The green counterpart for this is bookkeeping on sched pools.
 
 use std::sync::atomics;
-use std::unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
+use std::unstable::mutex::{Mutex, MUTEX_INIT};
 
 static mut TASK_COUNT: atomics::AtomicUint = atomics::INIT_ATOMIC_UINT;
-static mut TASK_LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
+static mut TASK_LOCK: Mutex = MUTEX_INIT;
 
 pub fn increment() {
     let _ = unsafe { TASK_COUNT.fetch_add(1, atomics::SeqCst) };
@@ -29,8 +29,9 @@ pub fn increment() {
 pub fn decrement() {
     unsafe {
         if TASK_COUNT.fetch_sub(1, atomics::SeqCst) == 1 {
-            let mut guard = TASK_LOCK.lock();
-            guard.signal();
+            TASK_LOCK.lock();
+            TASK_LOCK.signal();
+            TASK_LOCK.unlock();
         }
     }
 }
@@ -39,12 +40,11 @@ pub fn decrement() {
 /// the entry points of native programs
 pub fn wait_for_other_tasks() {
     unsafe {
-        {
-            let mut guard = TASK_LOCK.lock();
-            while TASK_COUNT.load(atomics::SeqCst) > 0 {
-                guard.wait();
-            }
+        TASK_LOCK.lock();
+        while TASK_COUNT.load(atomics::SeqCst) > 0 {
+            TASK_LOCK.wait();
         }
+        TASK_LOCK.unlock();
         TASK_LOCK.destroy();
     }
 }

branches/snap-stage3/src/libnative/io/net.rs

@@ -218,18 +218,19 @@ pub fn init() {
     }
 
     unsafe {
-        use std::unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
+        use std::unstable::mutex::{Mutex, MUTEX_INIT};
         static mut INITIALIZED: bool = false;
-        static mut LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
+        static mut LOCK: Mutex = MUTEX_INIT;
 
-        let _guard = LOCK.lock();
+        LOCK.lock();
         if !INITIALIZED {
             let mut data: WSADATA = mem::init();
             let ret = WSAStartup(0x202,      // version 2.2
                                  &mut data);
             assert_eq!(ret, 0);
             INITIALIZED = true;
         }
+        LOCK.unlock();
     }
 }
 

branches/snap-stage3/src/libnative/io/timer_helper.rs

@@ -22,7 +22,7 @@
 
 use std::cast;
 use std::rt;
-use std::unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
+use std::unstable::mutex::{Mutex, MUTEX_INIT};
 
 use bookkeeping;
 use io::timer::{Req, Shutdown};
@@ -37,11 +37,11 @@ static mut HELPER_CHAN: *mut Chan<Req> = 0 as *mut Chan<Req>;
 static mut HELPER_SIGNAL: imp::signal = 0 as imp::signal;
 
 pub fn boot(helper: fn(imp::signal, Port<Req>)) {
-    static mut LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
+    static mut LOCK: Mutex = MUTEX_INIT;
     static mut INITIALIZED: bool = false;
 
     unsafe {
-        let mut _guard = LOCK.lock();
+        LOCK.lock();
         if !INITIALIZED {
             let (msgp, msgc) = Chan::new();
             // promote this to a shared channel
@@ -58,6 +58,7 @@ pub fn boot(helper: fn(imp::signal, Port<Req>)) {
             rt::at_exit(proc() { shutdown() });
             INITIALIZED = true;
         }
+        LOCK.unlock();
     }
 }