---

yaml
---
r: 141277
b: refs/heads/try2
c: dea6677
h: refs/heads/master
i:
  141275: 00c1a30
v: v3

Author: Olivier Saut

[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: 2061ce9affd01d2dfb3d1e5836cfda4006ea8290
+refs/heads/try2: dea667725137368dd9c928bae3c091b9ccf42e67
 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/; s/.*based on \(LLVM .*\))/\1/' \
+                      | sed 's/.*\(version .*\)/\1/' \
                       | cut -d ' ' -f 2)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3*)
+        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 4.0* | 4.1* | 4.2*)
         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/compiletest/procsrv.rs

@@ -10,6 +10,8 @@
 
 use core::prelude::*;
 
+use core::libc::c_int;
+use core::run::spawn_process;
 use core::run;
 
 #[cfg(target_os = "win32")]
@@ -36,35 +38,86 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "freebsd")]
 fn target_env(_lib_path: &str, _prog: &str) -> ~[(~str,~str)] {
-    os::env()
+    ~[]
 }
 
 pub struct Result {status: int, out: ~str, err: ~str}
 
+// FIXME (#2659): This code is duplicated in core::run::program_output
 pub fn run(lib_path: &str,
            prog: &str,
            args: &[~str],
            env: ~[(~str, ~str)],
            input: Option<~str>) -> Result {
+    let pipe_in = os::pipe();
+    let pipe_out = os::pipe();
+    let pipe_err = os::pipe();
+    let pid = spawn_process(prog, args,
+                            &Some(env + target_env(lib_path, prog)),
+                            &None, pipe_in.in, pipe_out.out, pipe_err.out);
+
+    os::close(pipe_in.in);
+    os::close(pipe_out.out);
+    os::close(pipe_err.out);
+    if pid == -1i32 {
+        os::close(pipe_in.out);
+        os::close(pipe_out.in);
+        os::close(pipe_err.in);
+        fail!();
+    }
 
-    let env = env + target_env(lib_path, prog);
-    let mut proc = run::Process::new(prog, args, run::ProcessOptions {
-        env: Some(env.slice(0, env.len())),
-        dir: None,
-        in_fd: None,
-        out_fd: None,
-        err_fd: None
-    });
 
-    for input.each |input| {
-        proc.input().write_str(*input);
+    writeclose(pipe_in.out, input);
+    let p = comm::PortSet::new();
+    let ch = p.chan();
+    do task::spawn_sched(task::SingleThreaded) || {
+        let errput = readclose(pipe_err.in);
+        ch.send((2, errput));
     }
-    let output = proc.finish_with_output();
+    let ch = p.chan();
+    do task::spawn_sched(task::SingleThreaded) || {
+        let output = readclose(pipe_out.in);
+        ch.send((1, output));
+    }
+    let status = run::waitpid(pid);
+    let mut errs = ~"";
+    let mut outs = ~"";
+    let mut count = 2;
+    while count > 0 {
+        match p.recv() {
+          (1, s) => {
+            outs = s;
+          }
+          (2, s) => {
+            errs = s;
+          }
+          _ => { fail!() }
+        };
+        count -= 1;
+    };
+    return Result {status: status, out: outs, err: errs};
+}
 
-    Result {
-        status: output.status,
-        out: str::from_bytes(output.output),
-        err: str::from_bytes(output.error)
+fn writeclose(fd: c_int, s: Option<~str>) {
+    if s.is_some() {
+        let writer = io::fd_writer(fd, false);
+        writer.write_str(s.get());
     }
+
+    os::close(fd);
 }
 
+fn readclose(fd: c_int) -> ~str {
+    unsafe {
+        // Copied from run::program_output
+        let file = os::fdopen(fd);
+        let reader = io::FILE_reader(file, false);
+        let mut buf = ~"";
+        while !reader.eof() {
+            let bytes = reader.read_bytes(4096u);
+            str::push_str(&mut buf, str::from_bytes(bytes));
+        }
+        os::fclose(file);
+        return buf;
+    }
+}

branches/try2/src/etc/ctags.rust

@@ -4,7 +4,9 @@
 --regex-rust=/[ \t]*type[ \t]+([a-zA-Z0-9_]+)/\1/T,types/
 --regex-rust=/[ \t]*enum[ \t]+([a-zA-Z0-9_]+)/\1/T,types/
 --regex-rust=/[ \t]*struct[ \t]+([a-zA-Z0-9_]+)/\1/m,types/
+--regex-rust=/[ \t]*class[ \t]+([a-zA-Z0-9_]+)/\1/m,types/
 --regex-rust=/[ \t]*mod[ \t]+([a-zA-Z0-9_]+)/\1/m,modules/
---regex-rust=/[ \t]*static[ \t]+([a-zA-Z0-9_]+)/\1/m,consts/
+--regex-rust=/[ \t]*const[ \t]+([a-zA-Z0-9_]+)/\1/m,consts/
 --regex-rust=/[ \t]*trait[ \t]+([a-zA-Z0-9_]+)/\1/m,traits/
 --regex-rust=/[ \t]*impl[ \t]+([a-zA-Z0-9_]+)/\1/m,impls/
+--regex-rust=/[ \t]*impl[ \t]+of[ \t]([a-zA-Z0-9_]+)/\1/m,impls/

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/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)]
+#[doc(hidden)] // FIXME #3538
 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)]
+#[doc(hidden)] // FIXME #3538
 pub mod extra {
     pub use serialize;
     pub use test;

branches/try2/src/libextra/workcache.rs

@@ -415,7 +415,7 @@ fn test() {
         prep.declare_input("file", pth.to_str(), digest_file(&pth));
         do prep.exec |_exe| {
             let out = Path("foo.o");
-            run::process_status("gcc", [~"foo.c", ~"-o", out.to_str()]);
+            run::run_program("gcc", [~"foo.c", ~"-o", out.to_str()]);
             out.to_str()
         }
     };