---

yaml
---
r: 107657
b: refs/heads/dist-snap
c: 75af1e5
h: refs/heads/master
i:
  107655: 779aa39
v: v3

Author: comex

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: b85fe01b94f876a5db698db10e43ffdf2116c0a3
+refs/heads/dist-snap: 75af1e504a5745ab7f05dbecd43f79cbef75a1c1
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/guide-ffi.md

@@ -303,15 +303,15 @@ which would call back to `callback()` in Rust.
 
 ## Targetting callbacks to Rust objects
 
-The former example showed how a global function can be called from C-Code.
+The former example showed how a global function can be called from C code.
 However it is often desired that the callback is targetted to a special
 Rust object. This could be the object that represents the wrapper for the
 respective C object. 
 
 This can be achieved by passing an unsafe pointer to the object down to the
 C library. The C library can then include the pointer to the Rust object in
-the notification. This will provide a unsafe possibility to access the 
-referenced Rust object in callback.
+the notification. This will allow the callback to unsafely access the
+referenced Rust object.
 
 Rust code:
 ~~~~ {.xfail-test}
@@ -364,25 +364,25 @@ void trigger_callback() {
 
 ## Asynchronous callbacks
 
-In the already given examples the callbacks are invoked as a direct reaction
+In the previously given examples the callbacks are invoked as a direct reaction
 to a function call to the external C library.
-The control over the current thread switched from Rust to C to Rust for the
+The control over the current thread is switched from Rust to C to Rust for the
 execution of the callback, but in the end the callback is executed on the
 same thread (and Rust task) that lead called the function which triggered
 the callback.
 
-Things get more complicated when the external library spawns it's own threads
+Things get more complicated when the external library spawns its own threads
 and invokes callbacks from there.
-In these cases access to Rust data structures inside he callbacks is
+In these cases access to Rust data structures inside the callbacks is
 especially unsafe and proper synchronization mechanisms must be used.
-Besides classical synchronization mechanisms like mutexes one possibility in
+Besides classical synchronization mechanisms like mutexes, one possibility in
 Rust is to use channels (in `std::comm`) to forward data from the C thread
 that invoked the callback into a Rust task.
 
 If an asychronous callback targets a special object in the Rust address space
 it is also absolutely necessary that no more callbacks are performed by the 
-C library after the respective Rust object get's destroyed. 
-This can be achieved by unregistering the callback it the object's
+C library after the respective Rust object gets destroyed. 
+This can be achieved by unregistering the callback in the object's
 destructor and designing the library in a way that guarantees that no
 callback will be performed after unregistration.
 

branches/dist-snap/src/libextra/sync.rs

@@ -27,8 +27,6 @@ use std::unstable::finally::Finally;
 use std::util;
 use std::util::NonCopyable;
 
-use arc::MutexArc;
-
 /****************************************************************************
  * Internals
  ****************************************************************************/
@@ -684,67 +682,6 @@ impl<'a> RWLockReadMode<'a> {
     pub fn read<U>(&self, blk: || -> U) -> U { blk() }
 }
 
-/// A barrier enables multiple tasks to synchronize the beginning
-/// of some computation.
-/// ```rust
-/// use extra::sync::Barrier;
-///
-/// let barrier = Barrier::new(10);
-/// 10.times(|| {
-///     let c = barrier.clone();
-///     // The same messages will be printed together.
-///     // You will NOT see any interleaving.
-///     do spawn {
-///         println!("before wait");
-///         c.wait();
-///         println!("after wait");
-///     }
-/// });
-/// ```
-#[deriving(Clone)]
-pub struct Barrier {
-    priv arc: MutexArc<BarrierState>,
-    priv num_tasks: uint,
-}
-
-// The inner state of a double barrier
-struct BarrierState {
-    priv count: uint,
-    priv generation_id: uint,
-}
-
-impl Barrier {
-    /// Create a new barrier that can block a given number of tasks.
-    pub fn new(num_tasks: uint) -> Barrier {
-        Barrier {
-            arc: MutexArc::new(BarrierState {
-                count: 0,
-                generation_id: 0,
-            }),
-            num_tasks: num_tasks,
-        }
-    }
-
-    /// Block the current task until a certain number of tasks is waiting.
-    pub fn wait(&self) {
-        self.arc.access_cond(|state, cond| {
-            let local_gen = state.generation_id;
-            state.count += 1;
-            if state.count < self.num_tasks {
-                // We need a while loop to guard against spurious wakeups.
-                // http://en.wikipedia.org/wiki/Spurious_wakeup
-                while local_gen == state.generation_id && state.count < self.num_tasks {
-                    cond.wait();
-                }
-            } else {
-                state.count = 0;
-                state.generation_id += 1;
-                cond.broadcast();
-            }
-        });
-    }
-}
-
 /****************************************************************************
  * Tests
  ****************************************************************************/
@@ -756,7 +693,6 @@ mod tests {
     use std::cast;
     use std::result;
     use std::task;
-    use std::comm::{SharedChan, Empty};
 
     /************************************************************************
      * Semaphore tests
@@ -1379,35 +1315,4 @@ mod tests {
             })
         })
     }
-
-    /************************************************************************
-     * Barrier tests
-     ************************************************************************/
-    #[test]
-    fn test_barrier() {
-        let barrier = Barrier::new(10);
-        let (port, chan) = SharedChan::new();
-
-        9.times(|| {
-            let c = barrier.clone();
-            let chan = chan.clone();
-            do spawn {
-                c.wait();
-                chan.send(true);
-            }
-        });
-
-        // At this point, all spawned tasks should be blocked,
-        // so we shouldn't get anything from the port
-        assert!(match port.try_recv() {
-            Empty => true,
-            _ => false,
-        });
-
-        barrier.wait();
-        // Now, the barrier is cleared and we should get data.
-        9.times(|| {
-            port.recv();
-        });
-    }
 }