---

yaml
---
r: 141279
b: refs/heads/try2
c: 3c4ce79
h: refs/heads/master
i:
  141277: c86210c
  141275: 00c1a30
  141271: 98169f3
  141263: 0b3593d
  141247: 286968c
v: v3

Author: graydon

[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: 6d7d759129cbd8cb8014fa33f75a9445f1947405
+refs/heads/try2: 3c4ce7951868efb17ab02dcd452d969f8eb1bb12
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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 }
 ~~~
 
-## Backgrounding computations: Futures
+## Futures
 With `extra::future`, rust has a mechanism for requesting a computation and getting the result
 later.
 
@@ -329,77 +329,6 @@ 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/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(),