---

yaml
---
r: 47344
b: refs/heads/try
c: 4ecb672
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
-refs/heads/try: 916d1a9165846fd14b37f4a651e15d48ae913136
+refs/heads/try: 4ecb672d7f526cf2cda2d62c04106196ad57d7db
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/io.rs

@@ -504,7 +504,7 @@ pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> @Reader {
 
 pub fn stdin() -> @Reader {
     unsafe {
-        rustrt::rust_get_stdin() as @Reader
+        @rustrt::rust_get_stdin() as @Reader
     }
 }
 
@@ -642,11 +642,11 @@ impl Writer for *libc::FILE {
     }
 }
 
-pub fn FILE_writer(f: *libc::FILE, cleanup: bool) -> Writer {
+pub fn FILE_writer(f: *libc::FILE, cleanup: bool) -> @Writer {
     if cleanup {
-        Wrapper { base: f, cleanup: FILERes(f) } as Writer
+        @Wrapper { base: f, cleanup: FILERes(f) } as @Writer
     } else {
-        f as Writer
+        @f as @Writer
     }
 }
 
@@ -702,11 +702,11 @@ pub fn FdRes(fd: fd_t) -> FdRes {
     }
 }
 
-pub fn fd_writer(fd: fd_t, cleanup: bool) -> Writer {
+pub fn fd_writer(fd: fd_t, cleanup: bool) -> @Writer {
     if cleanup {
-        Wrapper { base: fd, cleanup: FdRes(fd) } as Writer
+        @Wrapper { base: fd, cleanup: FdRes(fd) } as @Writer
     } else {
-        fd as Writer
+        @fd as @Writer
     }
 }
 

branches/try/src/libcore/private.rs

@@ -107,9 +107,20 @@ fn compare_and_swap(address: &mut int, oldval: int, newval: int) -> bool {
  * Shared state & exclusive ARC
  ****************************************************************************/
 
+struct UnwrapProtoInner {
+    contents: Option<(comm::ChanOne<()>,  comm::PortOne<bool>)>,
+}
+
+// An unwrapper uses this protocol to communicate with the "other" task that
+// drops the last refcount on an arc. Unfortunately this can't be a proper
+// pipe protocol because the unwrapper has to access both stages at once.
+type UnwrapProto = ~UnwrapProtoInner;
+
 struct ArcData<T> {
     mut count:     libc::intptr_t,
-    // FIXME(#3224) should be able to make this non-option to save memory
+    mut unwrapper: int, // either a UnwrapProto or 0
+    // FIXME(#3224) should be able to make this non-option to save memory, and
+    // in unwrap() use "let ~ArcData { data: result, _ } = thing" to unwrap it
     mut data:      Option<T>,
 }
 
@@ -120,13 +131,37 @@ struct ArcDestruct<T> {
 impl<T> Drop for ArcDestruct<T>{
     fn finalize(&self) {
         unsafe {
+            if self.data.is_null() {
+                return; // Happens when destructing an unwrapper's handle.
+            }
             do task::unkillable {
                 let data: ~ArcData<T> = cast::reinterpret_cast(&self.data);
                 let new_count =
                     intrinsics::atomic_xsub(&mut data.count, 1) - 1;
                 assert new_count >= 0;
                 if new_count == 0 {
-                    // drop glue takes over.
+                    // Were we really last, or should we hand off to an
+                    // unwrapper? It's safe to not xchg because the unwrapper
+                    // will set the unwrap lock *before* dropping his/her
+                    // reference. In effect, being here means we're the only
+                    // *awake* task with the data.
+                    if data.unwrapper != 0 {
+                        let mut p: UnwrapProto =
+                            cast::reinterpret_cast(&data.unwrapper);
+                        let (message, response) =
+                            option::swap_unwrap(&mut p.contents);
+                        // Send 'ready' and wait for a response.
+                        comm::send_one(message, ());
+                        // Unkillable wait. Message guaranteed to come.
+                        if comm::recv_one(response) {
+                            // Other task got the data.
+                            cast::forget(data);
+                        } else {
+                            // Other task was killed. drop glue takes over.
+                        }
+                    } else {
+                        // drop glue takes over.
+                    }
                 } else {
                     cast::forget(data);
                 }
@@ -141,6 +176,79 @@ fn ArcDestruct<T>(data: *libc::c_void) -> ArcDestruct<T> {
     }
 }
 
+pub unsafe fn unwrap_shared_mutable_state<T:Owned>(rc: SharedMutableState<T>)
+        -> T {
+    struct DeathThroes<T> {
+        mut ptr:      Option<~ArcData<T>>,
+        mut response: Option<comm::ChanOne<bool>>,
+    }
+
+    impl<T> Drop for DeathThroes<T>{
+        fn finalize(&self) {
+            unsafe {
+                let response = option::swap_unwrap(&mut self.response);
+                // In case we get killed early, we need to tell the person who
+                // tried to wake us whether they should hand-off the data to
+                // us.
+                if task::failing() {
+                    comm::send_one(response, false);
+                    // Either this swap_unwrap or the one below (at "Got
+                    // here") ought to run.
+                    cast::forget(option::swap_unwrap(&mut self.ptr));
+                } else {
+                    assert self.ptr.is_none();
+                    comm::send_one(response, true);
+                }
+            }
+        }
+    }
+
+    do task::unkillable {
+        let ptr: ~ArcData<T> = cast::reinterpret_cast(&rc.data);
+        let (p1,c1) = comm::oneshot(); // ()
+        let (p2,c2) = comm::oneshot(); // bool
+        let mut server: UnwrapProto = ~UnwrapProtoInner {
+            contents: Some((c1,p2))
+        };
+        let serverp: int = cast::transmute(server);
+        // Try to put our server end in the unwrapper slot.
+        if compare_and_swap(&mut ptr.unwrapper, 0, serverp) {
+            // Got in. Step 0: Tell destructor not to run. We are now it.
+            rc.data = ptr::null();
+            // Step 1 - drop our own reference.
+            let new_count = intrinsics::atomic_xsub(&mut ptr.count, 1) - 1;
+            //assert new_count >= 0;
+            if new_count == 0 {
+                // We were the last owner. Can unwrap immediately.
+                // Also we have to free the server endpoints.
+                let _server: UnwrapProto = cast::transmute(serverp);
+                option::swap_unwrap(&mut ptr.data)
+                // drop glue takes over.
+            } else {
+                // The *next* person who sees the refcount hit 0 will wake us.
+                let end_result =
+                    DeathThroes { ptr: Some(ptr),
+                                  response: Some(c2) };
+                let mut p1 = Some(p1); // argh
+                do task::rekillable {
+                    comm::recv_one(option::swap_unwrap(&mut p1));
+                }
+                // Got here. Back in the 'unkillable' without getting killed.
+                // Recover ownership of ptr, then take the data out.
+                let ptr = option::swap_unwrap(&mut end_result.ptr);
+                option::swap_unwrap(&mut ptr.data)
+                // drop glue takes over.
+            }
+        } else {
+            // Somebody else was trying to unwrap. Avoid guaranteed deadlock.
+            cast::forget(ptr);
+            // Also we have to free the (rejected) server endpoints.
+            let _server: UnwrapProto = cast::transmute(serverp);
+            fail!(~"Another task is already unwrapping this ARC!");
+        }
+    }
+}
+
 /**
  * COMPLETELY UNSAFE. Used as a primitive for the safe versions in std::arc.
  *
@@ -151,7 +259,7 @@ pub type SharedMutableState<T> = ArcDestruct<T>;
 
 pub unsafe fn shared_mutable_state<T:Owned>(data: T) ->
         SharedMutableState<T> {
-    let data = ~ArcData { count: 1, data: Some(data) };
+    let data = ~ArcData { count: 1, unwrapper: 0, data: Some(data) };
     unsafe {
         let ptr = cast::transmute(data);
         ArcDestruct(ptr)
@@ -305,14 +413,22 @@ pub impl<T:Owned> Exclusive<T> {
     }
 }
 
+// FIXME(#3724) make this a by-move method on the exclusive
+pub fn unwrap_exclusive<T:Owned>(arc: Exclusive<T>) -> T {
+    let Exclusive { x: x } = arc;
+    let inner = unsafe { unwrap_shared_mutable_state(x) };
+    let ExData { data: data, _ } = inner;
+    data
+}
+
 #[cfg(test)]
 pub mod tests {
     use core::option::{None, Some};
 
     use cell::Cell;
     use comm;
     use option;
-    use private::exclusive;
+    use private::{exclusive, unwrap_exclusive};
     use result;
     use task;
     use uint;
@@ -363,4 +479,70 @@ pub mod tests {
             assert *one == 1;
         }
     }
+
+    #[test]
+    pub fn exclusive_unwrap_basic() {
+        let x = exclusive(~~"hello");
+        assert unwrap_exclusive(x) == ~~"hello";
+    }
+
+    #[test]
+    pub fn exclusive_unwrap_contended() {
+        let x = exclusive(~~"hello");
+        let x2 = Cell(x.clone());
+        do task::spawn {
+            let x2 = x2.take();
+            do x2.with |_hello| { }
+            task::yield();
+        }
+        assert unwrap_exclusive(x) == ~~"hello";
+
+        // Now try the same thing, but with the child task blocking.
+        let x = exclusive(~~"hello");
+        let x2 = Cell(x.clone());
+        let mut res = None;
+        do task::task().future_result(|+r| res = Some(r)).spawn {
+            let x2 = x2.take();
+            assert unwrap_exclusive(x2) == ~~"hello";
+        }
+        // Have to get rid of our reference before blocking.
+        { let _x = x; } // FIXME(#3161) util::ignore doesn't work here
+        let res = option::swap_unwrap(&mut res);
+        res.recv();
+    }
+
+    #[test] #[should_fail] #[ignore(cfg(windows))]
+    pub fn exclusive_unwrap_conflict() {
+        let x = exclusive(~~"hello");
+        let x2 = Cell(x.clone());
+        let mut res = None;
+        do task::task().future_result(|+r| res = Some(r)).spawn {
+            let x2 = x2.take();
+            assert unwrap_exclusive(x2) == ~~"hello";
+        }
+        assert unwrap_exclusive(x) == ~~"hello";
+        let res = option::swap_unwrap(&mut res);
+        // See #4689 for why this can't be just "res.recv()".
+        assert res.recv() == task::Success;
+    }
+
+    #[test] #[ignore(cfg(windows))]
+    pub fn exclusive_unwrap_deadlock() {
+        // This is not guaranteed to get to the deadlock before being killed,
+        // but it will show up sometimes, and if the deadlock were not there,
+        // the test would nondeterministically fail.
+        let result = do task::try {
+            // a task that has two references to the same exclusive will
+            // deadlock when it unwraps. nothing to be done about that.
+            let x = exclusive(~~"hello");
+            let x2 = x.clone();
+            do task::spawn {
+                for 10.times { task::yield(); } // try to let the unwrapper go
+                fail!(); // punt it awake from its deadlock
+            }
+            let _z = unwrap_exclusive(x);
+            do x2.with |_hello| { }
+        };
+        assert result.is_err();
+    }
 }

branches/try/src/libcore/rand.rs

@@ -412,8 +412,8 @@ pub fn Rng() -> Rng {
  * all other generators constructed with the same seed. The seed may be any
  * length.
  */
-pub fn seeded_rng(seed: &[u8]) -> Rng {
-    seeded_randres(seed) as Rng
+pub fn seeded_rng(seed: &[u8]) -> @Rng {
+    @seeded_randres(seed) as @Rng
 }
 
 fn seeded_randres(seed: &[u8]) -> @RandRes {
@@ -449,8 +449,8 @@ pub pure fn xorshift() -> Rng {
     seeded_xorshift(123456789u32, 362436069u32, 521288629u32, 88675123u32)
 }
 
-pub pure fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> Rng {
-    XorShiftState { x: x, y: y, z: z, w: w } as Rng
+pub pure fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> @Rng {
+    @XorShiftState { x: x, y: y, z: z, w: w } as @Rng
 }
 
 
@@ -472,10 +472,10 @@ pub fn task_rng() -> Rng {
             unsafe {
                 let rng = seeded_randres(seed());
                 task::local_data::local_data_set(tls_rng_state, rng);
-                rng as Rng
+                @rng as @Rng
             }
         }
-        Some(rng) => rng as Rng
+        Some(rng) => @rng as @Rng
     }
 }
 

branches/try/src/libcore/repr.rs

@@ -201,7 +201,7 @@ pub impl ReprVisitor {
         unsafe {
             let mut u = ReprVisitor(ptr, self.writer);
             let v = reflect::MovePtrAdaptor(u);
-            visit_tydesc(inner, (v) as @TyVisitor);
+            visit_tydesc(inner, @v as @TyVisitor);
             true
         }
     }
@@ -570,7 +570,7 @@ pub fn write_repr<T>(writer: @Writer, object: &T) {
         let tydesc = intrinsic::get_tydesc::<T>();
         let mut u = ReprVisitor(ptr, writer);
         let v = reflect::MovePtrAdaptor(u);
-        visit_tydesc(tydesc, (v) as @TyVisitor)
+        visit_tydesc(tydesc, @v as @TyVisitor)
     }
 }
 

branches/try/src/libcore/run.rs

@@ -288,7 +288,7 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
         finished: false,
     };
 
-    ProgRes(repr) as Program
+    @ProgRes(repr) as @Program
 }
 
 fn read_all(rd: io::Reader) -> ~str {

branches/try/src/libcore/task/local_data_priv.rs

@@ -155,7 +155,7 @@ pub unsafe fn local_set<T:Durable>(
     // does not have a reference associated with it, so it may become invalid
     // when the box is destroyed.
     let data_ptr = cast::reinterpret_cast(&data);
-    let data_box = data as LocalData;
+    let data_box = @data as @LocalData;
     // Construct new entry to store in the map.
     let new_entry = Some((keyval, data_ptr, data_box));
     // Find a place to put it.

branches/try/src/librustc/metadata/common.rs

@@ -132,9 +132,8 @@ pub enum astencode_tag { // Reserves 0x50 -- 0x6f
     tag_table_method_map = 0x60,
     tag_table_vtable_map = 0x61,
     tag_table_adjustments = 0x62,
-    tag_table_legacy_boxed_trait = 0x63,
-    tag_table_moves_map = 0x64,
-    tag_table_capture_map = 0x65
+    tag_table_moves_map = 0x63,
+    tag_table_capture_map = 0x64
 }
 
 pub const tag_item_trait_method_sort: uint = 0x70;

branches/try/src/librustc/metadata/filesearch.rs

@@ -71,11 +71,11 @@ pub fn mk_filesearch(maybe_sysroot: Option<Path>,
 
     let sysroot = get_sysroot(maybe_sysroot);
     debug!("using sysroot = %s", sysroot.to_str());
-    FileSearchImpl {
+    @FileSearchImpl {
         sysroot: sysroot,
         addl_lib_search_paths: addl_lib_search_paths,
         target_triple: str::from_slice(target_triple)
-    } as FileSearch
+    } as @FileSearch
 }
 
 pub fn search<T:Copy>(filesearch: FileSearch, pick: pick<T>) -> Option<T> {