---

yaml
---
r: 141295
b: refs/heads/try2
c: c33258b
h: refs/heads/master
i:
  141293: e15b69a
  141291: 7055834
  141287: f29d134
  141279: 58cac24
v: v3

Author: bors

[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: 32c619916179ff373a145b3006c5c19362af9b15
+refs/heads/try2: c33258bee10590b2f388090d294e1720b2ebfb64
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -555,11 +555,11 @@ then
     CFG_CLANG_VERSION=$("$CFG_CLANG" \
                       --version \
                       | grep version \
-                      | sed 's/.*\(version .*\)/\1/' \
+                      | sed 's/.*\(version .*\)/\1/; s/.*based on \(LLVM .*\))/\1/' \
                       | cut -d ' ' -f 2)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 4.0* | 4.1* | 4.2*)
+        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3*)
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;

branches/try2/doc/tutorial-tasks.md

@@ -284,7 +284,7 @@ let result = ports.foldl(0, |accum, port| *accum + port.recv() );
 # fn some_expensive_computation(_i: uint) -> int { 42 }
 ~~~
 
-## Futures
+## Backgrounding computations: Futures
 With `extra::future`, rust has a mechanism for requesting a computation and getting the result
 later.
 
@@ -329,6 +329,77 @@ fn main() {
 }
 ~~~
 
+## Sharing immutable data without copy: ARC
+
+To share immutable data between tasks, a first approach would be to only use pipes as we have seen
+previously. A copy of the data to share would then be made for each task. In some cases, this would
+add up to a significant amount of wasted memory and would require copying the same data more than
+necessary.
+
+To tackle this issue, one can use an Atomically Reference Counted wrapper (`ARC`) as implemented in
+the `extra` library of Rust. With an ARC, the data will no longer be copied for each task. The ARC
+acts as a reference to the shared data and only this reference is shared and cloned.
+
+Here is a small example showing how to use ARCs. We wish to run concurrently several computations on
+a single large vector of floats. Each task needs the full vector to perform its duty.
+~~~
+use extra::arc::ARC;
+
+fn pnorm(nums: &~[float], p: uint) -> float {
+    (vec::foldl(0.0, *nums, |a,b| a+(*b).pow(p as float) )).pow(1f / (p as float))
+}
+
+fn main() {
+    let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
+    println(fmt!("Inf-norm = %?",  numbers.max()));
+
+    let numbers_arc = ARC(numbers);
+
+    for uint::range(1,10) |num| {
+        let (port, chan)  = stream();
+        chan.send(numbers_arc.clone());
+
+        do spawn {
+            let local_arc : ARC<~[float]> = port.recv();
+            let task_numbers = local_arc.get();
+            println(fmt!("%u-norm = %?", num, pnorm(task_numbers, num)));
+        }
+    }
+}
+~~~
+
+The function `pnorm` performs a simple computation on the vector (it computes the sum of its items
+at the power given as argument and takes the inverse power of this value). The ARC on the vector is
+created by the line
+~~~
+# use extra::arc::ARC;
+# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
+let numbers_arc=ARC(numbers);
+~~~
+and a clone of it is sent to each task
+~~~
+# use extra::arc::ARC;
+# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
+# let numbers_arc = ARC(numbers);
+# let (port, chan)  = stream();
+chan.send(numbers_arc.clone());
+~~~
+copying only the wrapper and not its contents.
+
+Each task recovers the underlying data by
+~~~
+# use extra::arc::ARC;
+# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
+# let numbers_arc=ARC(numbers);
+# let (port, chan)  = stream();
+# chan.send(numbers_arc.clone());
+# let local_arc : ARC<~[float]> = port.recv();
+let task_numbers = local_arc.get();
+~~~
+and can use it as if it were local.
+
+The `arc` module also implements ARCs around mutable data that are not covered here.
+
 # Handling task failure
 
 Rust has a built-in mechanism for raising exceptions. The `fail!()` macro

branches/try2/src/libextra/arc.rs

@@ -17,7 +17,7 @@
  * In this example, a large vector of floats is shared between several tasks.
  * With simple pipes, without ARC, a copy would have to be made for each task.
  *
- * ~~~
+ * ~~~ {.rust}
  * extern mod std;
  * use std::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
@@ -370,7 +370,10 @@ pub impl<T:Const + Owned> RWARC<T> {
      * See sync::rwlock.write_downgrade(). The RWWriteMode token must be used
      * to obtain the &mut T, and can be transformed into a RWReadMode token by
      * calling downgrade(), after which a &T can be obtained instead.
-     * ~~~
+     *
+     * # Example
+     *
+     * ~~~ {.rust}
      * do arc.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...

branches/try2/src/libextra/base64.rs

@@ -28,17 +28,17 @@ impl<'self> ToBase64 for &'self [u8] {
     /**
      * Turn a vector of `u8` bytes into a base64 string.
      *
-     * *Example*:
+     * # Example
      *
-     * ~~~~
+     * ~~~ {.rust}
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
      *     println(fmt!("%s", str));
      * }
-     * ~~~~
+     * ~~~
      */
     fn to_base64(&self) -> ~str {
         let mut s = ~"";
@@ -91,17 +91,17 @@ impl<'self> ToBase64 for &'self str {
      * Convert any string (literal, `@`, `&`, or `~`) to base64 encoding.
      *
      *
-     * *Example*:
+     * # Example
      *
-     * ~~~~
+     * ~~~ {.rust}
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = "Hello, World".to_base64();
      *     println(fmt!("%s",str));
      * }
-     * ~~~~
+     * ~~~
      *
      */
     fn to_base64(&self) -> ~str {
@@ -118,9 +118,9 @@ impl FromBase64 for ~[u8] {
      * Convert base64 `u8` vector into u8 byte values.
      * Every 4 encoded characters is converted into 3 octets, modulo padding.
      *
-     * *Example*:
+     * # Example
      *
-     * ~~~~
+     * ~~~ {.rust}
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -131,7 +131,7 @@ impl FromBase64 for ~[u8] {
      *     let bytes = str.from_base64();
      *     println(fmt!("%?",bytes));
      * }
-     * ~~~~
+     * ~~~
      */
     fn from_base64(&self) -> ~[u8] {
         if self.len() % 4u != 0u { fail!("invalid base64 length"); }
@@ -196,11 +196,11 @@ impl FromBase64 for ~str {
      * You can use the `from_bytes` function in `core::str`
      * to turn a `[u8]` into a string with characters corresponding to those values.
      *
-     * *Example*:
+     * # Example
      *
      * This converts a string literal to base64 and back.
      *
-     * ~~~~
+     * ~~~ {.rust}
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -214,7 +214,7 @@ impl FromBase64 for ~str {
      *     let result_str = str::from_bytes(bytes);
      *     println(fmt!("%s",result_str));
      * }
-     * ~~~~
+     * ~~~
      */
     fn from_base64(&self) -> ~[u8] {
         str::to_bytes(*self).from_base64()

branches/try2/src/libextra/deque.rs

@@ -125,6 +125,31 @@ pub impl<T> Deque<T> {
         self.hi = (self.hi + 1u) % self.elts.len();
         self.nelts += 1u;
     }
+
+    /// Reserve capacity for exactly `n` elements in the given deque,
+    /// doing nothing if `self`'s capacity is already equal to or greater
+    /// than the requested capacity
+    ///
+    /// # Arguments
+    ///
+    /// * n - The number of elements to reserve space for
+    fn reserve(&mut self, n: uint) {
+        vec::reserve(&mut self.elts, n);
+    }
+
+    /// Reserve capacity for at least `n` elements in the given deque,
+    /// over-allocating in case the caller needs to reserve additional
+    /// space.
+    ///
+    /// Do nothing if `self`'s capacity is already equal to or greater
+    /// than the requested capacity.
+    ///
+    /// # Arguments
+    ///
+    /// * n - The number of elements to reserve space for
+    fn reserve_at_least(&mut self, n: uint) {
+        vec::reserve_at_least(&mut self.elts, n);
+    }
 }
 
 /// Grow is only called on full elts, so nelts is also len(elts), unlike
@@ -149,6 +174,7 @@ mod tests {
     use super::*;
     use core::cmp::Eq;
     use core::kinds::Copy;
+    use core::vec::capacity;
 
     #[test]
     fn test_simple() {
@@ -328,4 +354,29 @@ mod tests {
         }
 
     }
+
+    #[test]
+    fn test_reserve() {
+        let mut d = Deque::new();
+        d.add_back(0u64);
+        d.reserve(50);
+        assert_eq!(capacity(&mut d.elts), 50);
+        let mut d = Deque::new();
+        d.add_back(0u32);
+        d.reserve(50);
+        assert_eq!(capacity(&mut d.elts), 50);
+    }
+
+    #[test]
+    fn test_reserve_at_least() {
+        let mut d = Deque::new();
+        d.add_back(0u64);
+        d.reserve_at_least(50);
+        assert_eq!(capacity(&mut d.elts), 64);
+        let mut d = Deque::new();
+        d.add_back(0u32);
+        d.reserve_at_least(50);
+        assert_eq!(capacity(&mut d.elts), 64);
+    }
+
 }

branches/try2/src/libextra/flatpipes.rs

@@ -25,7 +25,7 @@ ports and channels.
 
 This example sends boxed integers across tasks using serialization.
 
-~~~
+~~~ {.rust}
 let (port, chan) = serial::pipe_stream();
 
 do task::spawn || {

branches/try2/src/libextra/future.rs

@@ -14,7 +14,7 @@
  *
  * # Example
  *
- * ~~~
+ * ~~~ {.rust}
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = std::future::spawn (|| fib(5000) );

branches/try2/src/libextra/net_tcp.rs

@@ -466,7 +466,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  * Here, the `new_conn` is used in conjunction with `accept` from within
  * a task spawned by the `new_connect_cb` passed into `listen`
  *
- * ~~~~~~~~~~~
+ * ~~~ {.rust}
  * do net::tcp::listen(remote_ip, remote_port, backlog, iotask,
  *     // this callback is ran once after the connection is successfully
  *     // set up
@@ -497,7 +497,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  *       None => ()
  *     }
  * };
- * ~~~~~~~~~~~
+ * ~~~
  *
  * # Arguments
  *

branches/try2/src/libextra/sync.rs

@@ -545,7 +545,10 @@ pub impl RWlock {
      * the meantime (such as unlocking and then re-locking as a reader would
      * do). The block takes a "write mode token" argument, which can be
      * transformed into a "read mode token" by calling downgrade(). Example:
-     * ~~~
+     *
+     * # Example
+     *
+     * ~~~ {.rust}
      * do lock.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |condvar| {
      *         ... exclusive access ...

branches/try2/src/libextra/time.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -22,11 +22,11 @@ pub mod rustrt {
         pub unsafe fn precise_time_ns(ns: &mut u64);
 
         pub unsafe fn rust_tzset();
-        // FIXME: The i64 values can be passed by-val when #2064 is fixed.
+
         pub unsafe fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
         pub unsafe fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
-        pub unsafe fn rust_timegm(tm: &Tm, sec: &mut i64);
-        pub unsafe fn rust_mktime(tm: &Tm, sec: &mut i64);
+        pub unsafe fn rust_timegm(tm: &Tm) -> i64;
+        pub unsafe fn rust_mktime(tm: &Tm) -> i64;
     }
 }
 
@@ -177,12 +177,11 @@ pub impl Tm {
     /// Convert time to the seconds from January 1, 1970
     fn to_timespec(&self) -> Timespec {
         unsafe {
-            let mut sec = 0i64;
-            if self.tm_gmtoff == 0_i32 {
-                rustrt::rust_timegm(self, &mut sec);
-            } else {
-                rustrt::rust_mktime(self, &mut sec);
-            }
+            let sec = match self.tm_gmtoff {
+                0_i32 => rustrt::rust_timegm(self),
+                _     => rustrt::rust_mktime(self)
+            };
+
             Timespec::new(sec, self.tm_nsec)
         }
     }