---

yaml
---
r: 60763
b: refs/heads/auto
c: 26fb16e
h: refs/heads/master
i:
  60761: 9dcbe48
  60759: 014943e
v: v3

Author: bors

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 4521c347757329d4166e1a1c0239de2fcdd508e9
+refs/heads/auto: 26fb16e36fe5843b745fa1f3a1b333352300798c
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/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/auto/src/libextra/smallintmap.rs

@@ -246,14 +246,7 @@ impl Set<uint> for SmallIntSet {
     fn symmetric_difference(&self,
                             other: &SmallIntSet,
                             f: &fn(&uint) -> bool) -> bool {
-        let len = cmp::max(self.map.v.len() ,other.map.v.len());
-
-        for uint::range(0, len) |i| {
-            if self.contains(&i) ^ other.contains(&i) {
-                if !f(&i) { return false; }
-            }
-        }
-        return true;
+        self.difference(other, f) && other.difference(self, f)
     }
 
     /// Visit the values representing the uintersection
@@ -263,14 +256,7 @@ impl Set<uint> for SmallIntSet {
 
     /// Visit the values representing the union
     fn union(&self, other: &SmallIntSet, f: &fn(&uint) -> bool) -> bool {
-        let len = cmp::max(self.map.v.len() ,other.map.v.len());
-
-        for uint::range(0, len) |i| {
-            if self.contains(&i) || other.contains(&i) {
-                if !f(&i) { return false; }
-            }
-        }
-        return true;
+        self.each(f) && other.each(|v| self.contains(v) || f(v))
     }
 }
 

branches/auto/src/librustc/middle/trans/base.rs

@@ -2339,9 +2339,7 @@ pub fn create_entry_wrapper(ccx: @CrateContext,
             llvm::LLVMPositionBuilderAtEnd(bld, llbb);
 
             let start_def_id = ccx.tcx.lang_items.start_fn();
-            if start_def_id.crate == ast::local_crate {
-                ccx.sess.bug("start lang item is never in the local crate")
-            } else {
+            if start_def_id.crate != ast::local_crate {
                 let start_fn_type = csearch::get_type(ccx.tcx,
                                                       start_def_id).ty;
                 trans_external_path(ccx, start_def_id, start_fn_type);
@@ -2358,8 +2356,7 @@ pub fn create_entry_wrapper(ccx: @CrateContext,
             let (start_fn, args) = if use_start_lang_item {
                 let start_def_id = ccx.tcx.lang_items.start_fn();
                 let start_fn = if start_def_id.crate == ast::local_crate {
-                    ccx.sess.bug("start lang item is never in the local \
-                                  crate")
+                    get_item_val(ccx, start_def_id.node)
                 } else {
                     let start_fn_type = csearch::get_type(ccx.tcx,
                             start_def_id).ty;

branches/auto/src/librustc/middle/ty.rs

@@ -907,7 +907,7 @@ type type_cache = @mut HashMap<ast::def_id, ty_param_bounds_and_ty>;
 
 type constness_cache = @mut HashMap<ast::def_id, const_eval::constness>;
 
-pub type node_type_table = @mut SmallIntMap<t>;
+pub type node_type_table = @mut HashMap<uint,t>;
 
 fn mk_rcache() -> creader_cache {
     return @mut HashMap::new();
@@ -934,7 +934,7 @@ pub fn mk_ctxt(s: session::Session,
         def_map: dm,
         region_maps: region_maps,
         region_paramd_items: region_paramd_items,
-        node_types: @mut SmallIntMap::new(),
+        node_types: @mut HashMap::new(),
         node_type_substs: @mut HashMap::new(),
         trait_refs: @mut HashMap::new(),
         trait_defs: @mut HashMap::new(),