---

yaml
---
r: 65866
b: refs/heads/master
c: 2ef8774
h: refs/heads/master
v: v3

Author: bblum

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5bff471dde5350437c1bb51178ba6a2a903ec813
+refs/heads/master: 2ef8774ac5b56ae264224d46ffa0078f5d39ce6c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/RELEASES.txt

@@ -3,37 +3,12 @@ Version 0.7 (July 2013)
 
    * ??? changes, numerous bugfixes
 
-   * Syntax changes
-      * `#[deriving(Encodable)]`, `#[deriving(Decodable)]`      
-
    * Semantic changes
-      * The `self` parameter no longer implicitly means `&'self self`,
-        and can be explicitly marked with a lifetime.
-      * Structs with the `#[packed]` attribute have byte alignment and
-        no padding between fields.
+      * The `self` parameter no longer implicitly means `&'self self`, and can be explicitly marked
+        with a lifetime.
 
    * Libraries
-
-      **Note: in 0.7 `core` was renamed `std` and `std` to `extra.
-        These notes use the new crate names.**
-
-      * The `core` crate was renamed to `std`.
-      * The `std` crate was renamed to `extra`.
-      * `std::mut` removed.
-      * std: `iterator` module for external iterator objects.
-      * std: many types implement `Clone` - tuples, @, @mut. TODO
-      * std: `path` type renamed to `Path`.
-      * std: Many standalone functions removed in favor of methods in
-        `vec`, `str`, TODO. In the future methods will also work as functions.
-      * extra: `FileInput` implements `std::io::Reader`.
-      * extra: `Complex` number type and `complex` module.
-      * extra: `Rational` number type and `rational` module.
-      * extra: `BigInt`, `BigUint` implement numeric and comparison traits.
-
-   * Other
-      * `unused_unsafe` lint mode for detecting unnecessary `unsafe` blocks.
-      * More and improved library documentation.
-      * The `rusti` command has been rewritten and a number of bugs addressed.
+      * New `core::iterator` module for external iterator objects
 
 Version 0.6 (April 2013)
 ------------------------

trunk/mk/rt.mk

@@ -210,17 +210,6 @@ $$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
 		V=$$(VERBOSE)
 endif
 
-ifeq ($(OSTYPE_$(1)), linux-androideabi)
-$$(JEMALLOC_LIB_$(1)_$(2)):
-	cd $$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/jemalloc; $(S)src/rt/jemalloc/configure \
-		--disable-experimental --build=$(CFG_BUILD_TRIPLE) --host=$(1) --disable-tls \
-		EXTRA_CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
-		LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1)))" \
-		CC="$$(CC_$(1))" \
-		CXX="$$(CXX_$(1))" \
-		AR="$$(AR_$(1))"
-	$$(Q)$$(MAKE) -C $$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/jemalloc
-else
 $$(JEMALLOC_LIB_$(1)_$(2)):
 	cd $$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/jemalloc; $(S)src/rt/jemalloc/configure \
 		--disable-experimental --build=$(CFG_BUILD_TRIPLE) --host=$(1) \
@@ -230,7 +219,6 @@ $$(JEMALLOC_LIB_$(1)_$(2)):
 		CXX="$$(CXX_$(1))" \
 		AR="$$(AR_$(1))"
 	$$(Q)$$(MAKE) -C $$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/jemalloc
-endif
 
 
 # These could go in rt.mk or rustllvm.mk, they're needed for both.

trunk/src/libextra/arc.rs

@@ -281,7 +281,6 @@ struct RWARCInner<T> { lock: RWlock, failed: bool, data: T }
 #[mutable]
 struct RWARC<T> {
     x: UnsafeAtomicRcBox<RWARCInner<T>>,
-    cant_nest: ()
 }
 
 /// Create a reader/writer ARC with the supplied data.
@@ -299,15 +298,14 @@ pub fn rw_arc_with_condvars<T:Const + Owned>(
     let data =
         RWARCInner { lock: rwlock_with_condvars(num_condvars),
                      failed: false, data: user_data };
-    RWARC { x: UnsafeAtomicRcBox::new(data), cant_nest: () }
+    RWARC { x: UnsafeAtomicRcBox::new(data), }
 }
 
 impl<T:Const + Owned> RWARC<T> {
     /// Duplicate a rwlock-protected ARC, as arc::clone.
     pub fn clone(&self) -> RWARC<T> {
         RWARC {
             x: self.x.clone(),
-            cant_nest: (),
         }
     }
 
@@ -382,12 +380,12 @@ impl<T:Const + Owned> RWARC<T> {
      * # Example
      *
      * ~~~ {.rust}
-     * do arc.write_downgrade |write_mode| {
-     *     do (&write_mode).write_cond |state, condvar| {
+     * do arc.write_downgrade |mut write_token| {
+     *     do write_token.write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...
      *     }
-     *     let read_mode = arc.downgrade(write_mode);
-     *     do (&read_mode).read |state| {
+     *     let read_token = arc.downgrade(write_token);
+     *     do read_token.read |state| {
      *         ... shared access with immutable state ...
      *     }
      * }
@@ -815,4 +813,66 @@ mod tests {
 
         wp2.recv(); // complete handshake with writer
     }
+    #[cfg(test)]
+    fn test_rw_write_cond_downgrade_read_race_helper() {
+        // Tests that when a downgrader hands off the "reader cloud" lock
+        // because of a contending reader, a writer can't race to get it
+        // instead, which would result in readers_and_writers. This tests
+        // the sync module rather than this one, but it's here because an
+        // rwarc gives us extra shared state to help check for the race.
+        // If you want to see this test fail, go to sync.rs and replace the
+        // line in RWlock::write_cond() that looks like:
+        //     "blk(&Condvar { order: opt_lock, ..*cond })"
+        // with just "blk(cond)".
+        let x = ~RWARC(true);
+        let (wp, wc) = comm::stream();
+
+        // writer task
+        let xw = (*x).clone();
+        do task::spawn {
+            do xw.write_cond |state, c| {
+                wc.send(()); // tell downgrader it's ok to go
+                c.wait();
+                // The core of the test is here: the condvar reacquire path
+                // must involve order_lock, so that it cannot race with a reader
+                // trying to receive the "reader cloud lock hand-off".
+                *state = false;
+            }
+        }
+
+        wp.recv(); // wait for writer to get in
+
+        do x.write_downgrade |mut write_mode| {
+            do write_mode.write_cond |state, c| {
+                assert!(*state);
+                // make writer contend in the cond-reacquire path
+                c.signal();
+            }
+            // make a reader task to trigger the "reader cloud lock" handoff
+            let xr = (*x).clone();
+            let (rp, rc) = comm::stream();
+            do task::spawn {
+                rc.send(());
+                do xr.read |_state| { }
+            }
+            rp.recv(); // wait for reader task to exist
+
+            let read_mode = x.downgrade(write_mode);
+            do read_mode.read |state| {
+                // if writer mistakenly got in, make sure it mutates state
+                // before we assert on it
+                for 5.times { task::yield(); }
+                // make sure writer didn't get in.
+                assert!(*state);
+            }
+        }
+    }
+    #[test]
+    fn test_rw_write_cond_downgrade_read_race() {
+        // Ideally the above test case would have yield statements in it that
+        // helped to expose the race nearly 100% of the time... but adding
+        // yields in the intuitively-right locations made it even less likely,
+        // and I wasn't sure why :( . This is a mediocre "next best" option.
+        for 8.times { test_rw_write_cond_downgrade_read_race_helper() }
+    }
 }