---

yaml
---
r: 141289
b: refs/heads/try2
c: 7ee329e
h: refs/heads/master
i:
  141287: f29d134
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: c9c4d92889ed1b147368a31127c0aa2e4db76cd5
+refs/heads/try2: 7ee329e97a24d259f76c1a6e910f32aa11e07862
 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/bitv.rs

@@ -462,7 +462,7 @@ pub impl Bitv {
      */
      fn to_str(&self) -> ~str {
        let mut rs = ~"";
-       for self.each() |i| { if i { rs += ~"1"; } else { rs += ~"0"; } };
+       for self.each() |i| { if i { rs += "1"; } else { rs += "0"; } };
        rs
      }
 

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/getopts.rs

@@ -193,19 +193,19 @@ pub enum Fail_ {
 pub fn fail_str(f: Fail_) -> ~str {
     return match f {
         ArgumentMissing(ref nm) => {
-            ~"Argument to option '" + *nm + ~"' missing."
+            ~"Argument to option '" + *nm + "' missing."
         }
         UnrecognizedOption(ref nm) => {
-            ~"Unrecognized option: '" + *nm + ~"'."
+            ~"Unrecognized option: '" + *nm + "'."
         }
         OptionMissing(ref nm) => {
-            ~"Required option '" + *nm + ~"' missing."
+            ~"Required option '" + *nm + "' missing."
         }
         OptionDuplicated(ref nm) => {
-            ~"Option '" + *nm + ~"' given more than once."
+            ~"Option '" + *nm + "' given more than once."
         }
         UnexpectedArgument(ref nm) => {
-            ~"Option " + *nm + ~" does not take an argument."
+            ~"Option " + *nm + " does not take an argument."
         }
     };
 }
@@ -618,7 +618,7 @@ pub mod groups {
             row += match hasarg {
                 No    => ~"",
                 Yes   => hint,
-                Maybe => ~"[" + hint + ~"]",
+                Maybe => ~"[" + hint + "]",
             };
 
             // FIXME: #5516
@@ -650,10 +650,10 @@ pub mod groups {
             row
         });
 
-        return str::to_owned(brief)    +
-               ~"\n\nOptions:\n"         +
+        return str::to_owned(brief) +
+               "\n\nOptions:\n" +
                str::connect(rows, "\n") +
-               ~"\n\n";
+               "\n\n";
     }
 } // end groups module
 

branches/try2/src/libextra/json.rs

@@ -47,18 +47,18 @@ fn escape_str(s: &str) -> ~str {
     let mut escaped = ~"\"";
     for str::each_char(s) |c| {
         match c {
-          '"' => escaped += ~"\\\"",
-          '\\' => escaped += ~"\\\\",
-          '\x08' => escaped += ~"\\b",
-          '\x0c' => escaped += ~"\\f",
-          '\n' => escaped += ~"\\n",
-          '\r' => escaped += ~"\\r",
-          '\t' => escaped += ~"\\t",
+          '"' => escaped += "\\\"",
+          '\\' => escaped += "\\\\",
+          '\x08' => escaped += "\\b",
+          '\x0c' => escaped += "\\f",
+          '\n' => escaped += "\\n",
+          '\r' => escaped += "\\r",
+          '\t' => escaped += "\\t",
           _ => escaped += str::from_char(c)
         }
     };
 
-    escaped += ~"\"";
+    escaped += "\"";
 
     escaped
 }

branches/try2/src/libextra/md4.rs

@@ -115,7 +115,7 @@ pub fn md4_str(msg: &[u8]) -> ~str {
         let mut i = 0u32;
         while i < 4u32 {
             let byte = (u >> (i * 8u32)) as u8;
-            if byte <= 16u8 { result += ~"0"; }
+            if byte <= 16u8 { result += "0"; }
             result += uint::to_str_radix(byte as uint, 16u);
             i += 1u32;
         }

branches/try2/src/libextra/std.rc

@@ -123,7 +123,7 @@ pub mod serialize;
 // A curious inner-module that's not exported that contains the binding
 // 'extra' so that macro-expanded references to std::serialize and such
 // can be resolved within libextra.
-#[doc(hidden)] // FIXME #3538
+#[doc(hidden)]
 pub mod std {
     pub use serialize;
     pub use test;
@@ -134,7 +134,7 @@ pub mod std {
     pub use core::cmp;
     pub use core::sys;
 }
-#[doc(hidden)] // FIXME #3538
+#[doc(hidden)]
 pub mod extra {
     pub use serialize;
     pub use test;

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)
         }
     }

branches/try2/src/librustc/back/arm.rs

@@ -22,42 +22,42 @@ pub fn get_target_strs(target_os: session::os) -> target_strs::t {
         data_layout: match target_os {
           session::os_macos => {
             ~"e-p:32:32:32" +
-                ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
-                ~"-f32:32:32-f64:64:64" +
-                ~"-v64:64:64-v128:64:128" +
-                ~"-a0:0:64-n32"
+                "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
+                "-f32:32:32-f64:64:64" +
+                "-v64:64:64-v128:64:128" +
+                "-a0:0:64-n32"
           }
 
           session::os_win32 => {
             ~"e-p:32:32:32" +
-                ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
-                ~"-f32:32:32-f64:64:64" +
-                ~"-v64:64:64-v128:64:128" +
-                ~"-a0:0:64-n32"
+                "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
+                "-f32:32:32-f64:64:64" +
+                "-v64:64:64-v128:64:128" +
+                "-a0:0:64-n32"
           }
 
           session::os_linux => {
             ~"e-p:32:32:32" +
-                ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
-                ~"-f32:32:32-f64:64:64" +
-                ~"-v64:64:64-v128:64:128" +
-                ~"-a0:0:64-n32"
+                "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
+                "-f32:32:32-f64:64:64" +
+                "-v64:64:64-v128:64:128" +
+                "-a0:0:64-n32"
           }
 
           session::os_android => {
             ~"e-p:32:32:32" +
-                ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
-                ~"-f32:32:32-f64:64:64" +
-                ~"-v64:64:64-v128:64:128" +
-                ~"-a0:0:64-n32"
+                "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
+                "-f32:32:32-f64:64:64" +
+                "-v64:64:64-v128:64:128" +
+                "-a0:0:64-n32"
           }
 
           session::os_freebsd => {
             ~"e-p:32:32:32" +
-                ~"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
-                ~"-f32:32:32-f64:64:64" +
-                ~"-v64:64:64-v128:64:128" +
-                ~"-a0:0:64-n32"
+                "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
+                "-f32:32:32-f64:64:64" +
+                "-v64:64:64-v128:64:128" +
+                "-a0:0:64-n32"
           }
         },