---

yaml
---
r: 144473
b: refs/heads/try2
c: 20567a0
h: refs/heads/master
i:
  144471: e3f598e
v: v3

Author: thestinger

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 3ab0561b00d2993706d11bfbbce4a357110195dd
+refs/heads/try2: 20567a0c3c306853180e428f83302add09b5cb8c
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/arc.rs

@@ -44,7 +44,7 @@ use sync;
 use sync::{Mutex, RWLock};
 
 use std::cast;
-use std::unstable::sync::UnsafeArc;
+use std::unstable::sync::UnsafeAtomicRcBox;
 use std::task;
 use std::borrow;
 
@@ -108,7 +108,7 @@ impl<'self> Condvar<'self> {
  ****************************************************************************/
 
 /// An atomically reference counted wrapper for shared immutable state.
-pub struct Arc<T> { priv x: UnsafeArc<T> }
+pub struct Arc<T> { priv x: UnsafeAtomicRcBox<T> }
 
 
 /**
@@ -118,7 +118,7 @@ pub struct Arc<T> { priv x: UnsafeArc<T> }
 impl<T:Freeze+Send> Arc<T> {
     /// Create an atomically reference counted wrapper.
     pub fn new(data: T) -> Arc<T> {
-        Arc { x: UnsafeArc::new(data) }
+        Arc { x: UnsafeAtomicRcBox::new(data) }
     }
 
     pub fn get<'a>(&'a self) -> &'a T {
@@ -160,7 +160,7 @@ impl<T:Freeze + Send> Clone for Arc<T> {
 #[doc(hidden)]
 struct MutexArcInner<T> { priv lock: Mutex, priv failed: bool, priv data: T }
 /// An Arc with mutable data protected by a blocking mutex.
-struct MutexArc<T> { priv x: UnsafeArc<MutexArcInner<T>> }
+struct MutexArc<T> { priv x: UnsafeAtomicRcBox<MutexArcInner<T>> }
 
 
 impl<T:Send> Clone for MutexArc<T> {
@@ -187,7 +187,7 @@ impl<T:Send> MutexArc<T> {
             lock: Mutex::new_with_condvars(num_condvars),
             failed: false, data: user_data
         };
-        MutexArc { x: UnsafeArc::new(data) }
+        MutexArc { x: UnsafeAtomicRcBox::new(data) }
     }
 
     /**
@@ -309,7 +309,7 @@ struct RWArcInner<T> { priv lock: RWLock, priv failed: bool, priv data: T }
  */
 #[no_freeze]
 struct RWArc<T> {
-    priv x: UnsafeArc<RWArcInner<T>>,
+    priv x: UnsafeAtomicRcBox<RWArcInner<T>>,
 }
 
 impl<T:Freeze + Send> Clone for RWArc<T> {
@@ -335,7 +335,7 @@ impl<T:Freeze + Send> RWArc<T> {
             lock: RWLock::new_with_condvars(num_condvars),
             failed: false, data: user_data
         };
-        RWArc { x: UnsafeArc::new(data), }
+        RWArc { x: UnsafeAtomicRcBox::new(data), }
     }
 
     /**

branches/try2/src/libextra/sync.rs

@@ -21,7 +21,7 @@ use std::comm;
 use std::comm::SendDeferred;
 use std::comm::{GenericPort, Peekable};
 use std::task;
-use std::unstable::sync::{Exclusive, UnsafeArc};
+use std::unstable::sync::{Exclusive, UnsafeAtomicRcBox};
 use std::unstable::atomics;
 use std::unstable::finally::Finally;
 use std::util;
@@ -135,7 +135,9 @@ impl<Q:Send> Sem<Q> {
         do task::unkillable {
             do (|| {
                 self.acquire();
-                do task::rekillable { blk() }
+                unsafe {
+                    do task::rekillable { blk() }
+                }
             }).finally {
                 self.release();
             }
@@ -232,8 +234,10 @@ impl<'self> Condvar<'self> {
                 // signaller already sent -- I mean 'unconditionally' in contrast
                 // with acquire().)
                 do (|| {
-                    do task::rekillable {
-                        let _ = WaitEnd.take_unwrap().recv();
+                    unsafe {
+                        do task::rekillable {
+                            let _ = WaitEnd.take_unwrap().recv();
+                        }
                     }
                 }).finally {
                     // Reacquire the condvar. Note this is back in the unkillable
@@ -444,7 +448,7 @@ struct RWLockInner {
 pub struct RWLock {
     priv order_lock:  Semaphore,
     priv access_lock: Sem<~[WaitQueue]>,
-    priv state:       UnsafeArc<RWLockInner>,
+    priv state:       UnsafeAtomicRcBox<RWLockInner>,
 }
 
 impl RWLock {
@@ -456,7 +460,7 @@ impl RWLock {
     * Similar to mutex_with_condvars.
     */
     pub fn new_with_condvars(num_condvars: uint) -> RWLock {
-        let state = UnsafeArc::new(RWLockInner {
+        let state = UnsafeAtomicRcBox::new(RWLockInner {
             read_mode:  false,
             read_count: atomics::AtomicUint::new(0),
         });
@@ -512,12 +516,14 @@ impl RWLock {
      * 'write' from other tasks will run concurrently with this one.
      */
     pub fn write<U>(&self, blk: &fn() -> U) -> U {
-        do task::unkillable {
-            (&self.order_lock).acquire();
-            do (&self.access_lock).access {
-                (&self.order_lock).release();
-                do task::rekillable {
-                    blk()
+        unsafe {
+            do task::unkillable {
+                (&self.order_lock).acquire();
+                do (&self.access_lock).access {
+                    (&self.order_lock).release();
+                    do task::rekillable {
+                        blk()
+                    }
                 }
             }
         }
@@ -556,14 +562,16 @@ impl RWLock {
         // which can't happen until T2 finishes the downgrade-read entirely.
         // The astute reader will also note that making waking writers use the
         // order_lock is better for not starving readers.
-        do task::unkillable {
-            (&self.order_lock).acquire();
-            do (&self.access_lock).access_cond |cond| {
-                (&self.order_lock).release();
-                do task::rekillable {
-                    let opt_lock = Just(&self.order_lock);
-                    blk(&Condvar { sem: cond.sem, order: opt_lock,
-                                   token: NonCopyable::new() })
+        unsafe {
+            do task::unkillable {
+                (&self.order_lock).acquire();
+                do (&self.access_lock).access_cond |cond| {
+                    (&self.order_lock).release();
+                    do task::rekillable {
+                        let opt_lock = Just(&self.order_lock);
+                        blk(&Condvar { sem: cond.sem, order: opt_lock,
+                                       token: NonCopyable::new() })
+                    }
                 }
             }
         }
@@ -598,8 +606,10 @@ impl RWLock {
             (&self.access_lock).acquire();
             (&self.order_lock).release();
             do (|| {
-                do task::rekillable {
-                    blk(RWLockWriteMode { lock: self, token: NonCopyable::new() })
+                unsafe {
+                    do task::rekillable {
+                        blk(RWLockWriteMode { lock: self, token: NonCopyable::new() })
+                    }
                 }
             }).finally {
                 let writer_or_last_reader;

branches/try2/src/libstd/option.rs

@@ -43,6 +43,7 @@ let unwrapped_msg = match msg {
 
 use clone::Clone;
 use cmp::{Eq,Ord};
+use ops::Add;
 use util;
 use num::Zero;
 use iterator;
@@ -76,6 +77,18 @@ impl<T: Eq + Ord> Ord for Option<T> {
     }
 }
 
+impl<T: Add<T, T>> Add<Option<T>, Option<T>> for Option<T> {
+    #[inline]
+    fn add(&self, other: &Option<T>) -> Option<T> {
+        match (&*self, &*other) {
+            (&None, &None) => None,
+            (_, &None) => None,
+            (&None, _) => None,
+            (&Some(ref lhs), &Some(ref rhs)) => Some(*lhs + *rhs)
+        }
+    }
+}
+
 // FIXME: #8242 implementing manually because deriving doesn't work for some reason
 impl<T: ToStr> ToStr for Option<T> {
     fn to_str(&self) -> ~str {

branches/try2/src/libstd/rt/comm.rs

@@ -21,7 +21,7 @@ use rt::local::Local;
 use rt::select::{SelectInner, SelectPortInner};
 use select::{Select, SelectPort};
 use unstable::atomics::{AtomicUint, AtomicOption, Acquire, Relaxed, SeqCst};
-use unstable::sync::UnsafeArc;
+use unstable::sync::UnsafeAtomicRcBox;
 use util::Void;
 use comm::{GenericChan, GenericSmartChan, GenericPort, Peekable};
 use cell::Cell;
@@ -567,14 +567,14 @@ impl<'self, T> SelectPort<T> for &'self Port<T> { }
 
 pub struct SharedChan<T> {
     // Just like Chan, but a shared AtomicOption instead of Cell
-    priv next: UnsafeArc<AtomicOption<StreamChanOne<T>>>
+    priv next: UnsafeAtomicRcBox<AtomicOption<StreamChanOne<T>>>
 }
 
 impl<T> SharedChan<T> {
     pub fn new(chan: Chan<T>) -> SharedChan<T> {
         let next = chan.next.take();
         let next = AtomicOption::new(~next);
-        SharedChan { next: UnsafeArc::new(next) }
+        SharedChan { next: UnsafeAtomicRcBox::new(next) }
     }
 }
 
@@ -620,7 +620,7 @@ impl<T> Clone for SharedChan<T> {
 
 pub struct SharedPort<T> {
     // The next port on which we will receive the next port on which we will receive T
-    priv next_link: UnsafeArc<AtomicOption<PortOne<StreamPortOne<T>>>>
+    priv next_link: UnsafeAtomicRcBox<AtomicOption<PortOne<StreamPortOne<T>>>>
 }
 
 impl<T> SharedPort<T> {
@@ -630,7 +630,7 @@ impl<T> SharedPort<T> {
         let (next_link_port, next_link_chan) = oneshot();
         next_link_chan.send(next_data_port);
         let next_link = AtomicOption::new(~next_link_port);
-        SharedPort { next_link: UnsafeArc::new(next_link) }
+        SharedPort { next_link: UnsafeAtomicRcBox::new(next_link) }
     }
 }
 

branches/try2/src/libstd/rt/kill.rs

@@ -159,7 +159,7 @@ use rt::task::Task;
 use task::spawn::Taskgroup;
 use to_bytes::IterBytes;
 use unstable::atomics::{AtomicUint, Relaxed};
-use unstable::sync::{UnsafeArc, LittleLock};
+use unstable::sync::{UnsafeAtomicRcBox, LittleLock};
 use util;
 
 static KILLED_MSG: &'static str = "killed by linked failure";
@@ -170,7 +170,7 @@ static KILL_KILLED:     uint = 1;
 static KILL_UNKILLABLE: uint = 2;
 
 struct KillFlag(AtomicUint);
-type KillFlagHandle = UnsafeArc<KillFlag>;
+type KillFlagHandle = UnsafeAtomicRcBox<KillFlag>;
 
 /// A handle to a blocked task. Usually this means having the ~Task pointer by
 /// ownership, but if the task is killable, a killer can steal it at any time.
@@ -211,7 +211,7 @@ struct KillHandleInner {
 
 /// State shared between tasks used for task killing during linked failure.
 #[deriving(Clone)]
-pub struct KillHandle(UnsafeArc<KillHandleInner>);
+pub struct KillHandle(UnsafeAtomicRcBox<KillHandleInner>);
 
 /// Per-task state related to task death, killing, failure, etc.
 pub struct Death {
@@ -317,7 +317,7 @@ impl BlockedTask {
         let handles = match self {
             Unkillable(task) => {
                 let flag = unsafe { KillFlag(AtomicUint::new(cast::transmute(task))) };
-                UnsafeArc::newN(flag, num_handles)
+                UnsafeAtomicRcBox::newN(flag, num_handles)
             }
             Killable(flag_arc) => flag_arc.cloneN(num_handles),
         };
@@ -380,8 +380,8 @@ impl Eq for KillHandle {
 impl KillHandle {
     pub fn new() -> (KillHandle, KillFlagHandle) {
         let (flag, flag_clone) =
-            UnsafeArc::new2(KillFlag(AtomicUint::new(KILL_RUNNING)));
-        let handle = KillHandle(UnsafeArc::new(KillHandleInner {
+            UnsafeAtomicRcBox::new2(KillFlag(AtomicUint::new(KILL_RUNNING)));
+        let handle = KillHandle(UnsafeAtomicRcBox::new(KillHandleInner {
             // Linked failure fields
             killed:     flag,
             unkillable: AtomicUint::new(KILL_RUNNING),
@@ -460,7 +460,7 @@ impl KillHandle {
     pub fn notify_immediate_failure(&mut self) {
         // A benign data race may happen here if there are failing sibling
         // tasks that were also spawned-watched. The refcount's write barriers
-        // in UnsafeArc ensure that this write will be seen by the
+        // in UnsafeAtomicRcBox ensure that this write will be seen by the
         // unwrapper/destructor, whichever task may unwrap it.
         unsafe { (*self.get()).any_child_failed = true; }
     }
@@ -647,11 +647,7 @@ impl Death {
     /// All calls must be paired with a preceding call to inhibit_kill.
     #[inline]
     pub fn allow_kill(&mut self, already_failing: bool) {
-        if self.unkillable == 0 {
-            // we need to decrement the counter before failing.
-            self.unkillable -= 1;
-            fail!("Cannot enter a rekillable() block without a surrounding unkillable()");
-        }
+        rtassert!(self.unkillable != 0);
         self.unkillable -= 1;
         if self.unkillable == 0 {
             rtassert!(self.kill_handle.is_some());

branches/try2/src/libstd/rt/message_queue.rs

@@ -16,11 +16,11 @@ use kinds::Send;
 use vec::OwnedVector;
 use cell::Cell;
 use option::*;
-use unstable::sync::{UnsafeArc, LittleLock};
+use unstable::sync::{UnsafeAtomicRcBox, LittleLock};
 use clone::Clone;
 
 pub struct MessageQueue<T> {
-    priv state: UnsafeArc<State<T>>
+    priv state: UnsafeAtomicRcBox<State<T>>
 }
 
 struct State<T> {
@@ -32,7 +32,7 @@ struct State<T> {
 impl<T: Send> MessageQueue<T> {
     pub fn new() -> MessageQueue<T> {
         MessageQueue {
-            state: UnsafeArc::new(State {
+            state: UnsafeAtomicRcBox::new(State {
                 count: 0,
                 queue: ~[],
                 lock: LittleLock::new()

branches/try2/src/libstd/rt/mod.rs

@@ -74,7 +74,7 @@ use rt::thread::Thread;
 use rt::work_queue::WorkQueue;
 use rt::uv::uvio::UvEventLoop;
 use unstable::atomics::{AtomicInt, SeqCst};
-use unstable::sync::UnsafeArc;
+use unstable::sync::UnsafeAtomicRcBox;
 use vec::{OwnedVector, MutableVector};
 
 /// The global (exchange) heap.
@@ -311,7 +311,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
 
     // Create a shared cell for transmitting the process exit
     // code from the main task to this function.
-    let exit_code = UnsafeArc::new(AtomicInt::new(0));
+    let exit_code = UnsafeAtomicRcBox::new(AtomicInt::new(0));
     let exit_code_clone = exit_code.clone();
 
     // When the main task exits, after all the tasks in the main

branches/try2/src/libstd/rt/sleeper_list.rs

@@ -15,12 +15,12 @@ use container::Container;
 use vec::OwnedVector;
 use option::{Option, Some, None};
 use cell::Cell;
-use unstable::sync::{UnsafeArc, LittleLock};
+use unstable::sync::{UnsafeAtomicRcBox, LittleLock};
 use rt::sched::SchedHandle;
 use clone::Clone;
 
 pub struct SleeperList {
-    priv state: UnsafeArc<State>
+    priv state: UnsafeAtomicRcBox<State>
 }
 
 struct State {
@@ -32,7 +32,7 @@ struct State {
 impl SleeperList {
     pub fn new() -> SleeperList {
         SleeperList {
-            state: UnsafeArc::new(State {
+            state: UnsafeAtomicRcBox::new(State {
                 count: 0,
                 stack: ~[],
                 lock: LittleLock::new()