---

yaml
---
r: 29843
b: refs/heads/incoming
c: f29f308
h: refs/heads/master
i:
  29841: e2f3c73
  29839: 207d73b
v: v3

Author: bblum

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: d1fc7368c858a8280f2463e81e074a2c699b0819
+refs/heads/incoming: f29f308c1c7c611cda6e1fc8a56179296868d144
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libstd/arc.rs

@@ -10,31 +10,55 @@ import unsafe::{SharedMutableState,
                 shared_mutable_state, clone_shared_mutable_state,
                 get_shared_mutable_state, get_shared_immutable_state};
 import sync;
-import sync::{mutex, rwlock};
+import sync::{mutex, mutex_with_condvars, rwlock, rwlock_with_condvars};
 
 export arc, clone, get;
-export condvar, mutex_arc, rw_arc, rw_write_mode, rw_read_mode;
+export condvar, mutex_arc, mutex_arc_with_condvars;
+export rw_arc, rw_arc_with_condvars, rw_write_mode, rw_read_mode;
 
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signalling.
 struct condvar { is_mutex: bool; failed: &mut bool; cond: &sync::condvar; }
 
 impl &condvar {
     /// Atomically exit the associated ARC and block until a signal is sent.
-    fn wait() {
+    #[inline(always)]
+    fn wait() { self.wait_on(0) }
+    /**
+     * Atomically exit the associated ARC and block on a specified condvar
+     * until a signal is sent on that same condvar (as sync::cond.wait_on).
+     *
+     * wait() is equivalent to wait_on(0).
+     */
+    #[inline(always)]
+    fn wait_on(condvar_id: uint) {
         assert !*self.failed;
-        self.cond.wait();
+        self.cond.wait_on(condvar_id);
         // This is why we need to wrap sync::condvar.
         check_poison(self.is_mutex, *self.failed);
     }
     /// Wake up a blocked task. Returns false if there was no blocked task.
-    fn signal() -> bool {
+    #[inline(always)]
+    fn signal() -> bool { self.signal_on(0) }
+    /**
+     * Wake up a blocked task on a specified condvar (as
+     * sync::cond.signal_on). Returns false if there was no blocked task.
+     */
+    #[inline(always)]
+    fn signal_on(condvar_id: uint) -> bool {
         assert !*self.failed;
-        self.cond.signal()
+        self.cond.signal_on(condvar_id)
     }
     /// Wake up all blocked tasks. Returns the number of tasks woken.
-    fn broadcast() -> uint {
+    #[inline(always)]
+    fn broadcast() -> uint { self.broadcast_on(0) }
+    /**
+     * Wake up all blocked tasks on a specified condvar (as
+     * sync::cond.broadcast_on). Returns Returns the number of tasks woken.
+     */
+    #[inline(always)]
+    fn broadcast_on(condvar_id: uint) -> uint {
         assert !*self.failed;
-        self.cond.broadcast()
+        self.cond.broadcast_on(condvar_id)
     }
 }
 
@@ -79,9 +103,17 @@ struct mutex_arc<T: send> { x: SharedMutableState<mutex_arc_inner<T>>; }
 
 /// Create a mutex-protected ARC with the supplied data.
 fn mutex_arc<T: send>(+user_data: T) -> mutex_arc<T> {
-    let data = mutex_arc_inner {
-        lock: mutex(), failed: false, data: user_data
-    };
+    mutex_arc_with_condvars(user_data, 1)
+}
+/**
+ * Create a mutex-protected ARC with the supplied data and a specified number
+ * of condvars (as sync::mutex_with_condvars).
+ */
+fn mutex_arc_with_condvars<T: send>(+user_data: T,
+                                    num_condvars: uint) -> mutex_arc<T> {
+    let data =
+        mutex_arc_inner { lock: mutex_with_condvars(num_condvars),
+                          failed: false, data: user_data };
     mutex_arc { x: unsafe { shared_mutable_state(data) } }
 }
 
@@ -187,9 +219,17 @@ struct rw_arc<T: const send> {
 
 /// Create a reader/writer ARC with the supplied data.
 fn rw_arc<T: const send>(+user_data: T) -> rw_arc<T> {
-    let data = rw_arc_inner {
-        lock: rwlock(), failed: false, data: user_data
-    };
+    rw_arc_with_condvars(user_data, 1)
+}
+/**
+ * Create a reader/writer ARC with the supplied data and a specified number
+ * of condvars (as sync::rwlock_with_condvars).
+ */
+fn rw_arc_with_condvars<T: const send>(+user_data: T,
+                                       num_condvars: uint) -> rw_arc<T> {
+    let data =
+        rw_arc_inner { lock: rwlock_with_condvars(num_condvars),
+                       failed: false, data: user_data };
     rw_arc { x: unsafe { shared_mutable_state(data) }, cant_nest: () }
 }
 

branches/incoming/src/libstd/sync.rs

@@ -8,7 +8,8 @@
  * in std.
  */
 
-export condvar, semaphore, mutex, rwlock, rwlock_write_mode, rwlock_read_mode;
+export condvar, semaphore, mutex, mutex_with_condvars;
+export rwlock, rwlock_with_condvars, rwlock_write_mode, rwlock_read_mode;
 
 // FIXME (#3119) This shouldn't be a thing exported from core.
 import unsafe::{Exclusive, exclusive};