auto merge of #7193 : Thiez/rust/fixbench, r=cmr

This PR fixes a few problems with the benchmark, mentioned in #2913. Since I do not have a 4GB RAM machine (I run rust on a puny 2GB RAM VM) I can't test binarytrees with N=20. If it works we can close #2913.

Fixes: 1) binarytrees prints "long lived trees of depth" instead of "long lived tree of depth"
Fixes: 2) chameneosredux -- the whitespace printed by show_number should be the same as printed by show_color
Already fixed: 3) spectralnorm prints an extra 

Fixes: 4) threadring prints an extra 

Fixes: 5) fasta -- strangely, output stops half-way through line 169 -- with another 8166 lines still to do.
Could not test: 6) the latest binarytrees fails with input N=20 on a 4GB machine.

r?

src/libextra/arena.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.
 //
@@ -39,7 +39,7 @@ use core::prelude::*;
 use list::{MutList, MutCons, MutNil};
 
 use core::at_vec;
-use core::cast::{transmute, transmute_mut_region};
+use core::cast::{transmute, transmute_mut, transmute_mut_region};
 use core::cast;
 use core::libc::size_t;
 use core::ptr;
@@ -74,6 +74,7 @@ struct Chunk {
     is_pod: bool,
 }
 
+#[mutable]
 pub struct Arena {
     // The head is separated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to
@@ -269,23 +270,22 @@ impl Arena {
 
     // The external interface
     #[inline]
-    pub fn alloc<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
+    pub fn alloc<'a, T>(&'a self, op: &fn() -> T) -> &'a T {
         unsafe {
             // XXX: Borrow check
-            let this = transmute_mut_region(self);
-            if !intrinsics::needs_drop::<T>() {
-                return this.alloc_pod(op);
+            let this = transmute_mut(self);
+            if intrinsics::needs_drop::<T>() {
+                this.alloc_nonpod(op)
+            } else {
+                this.alloc_pod(op)
             }
-            // XXX: Borrow check
-            let this = transmute_mut_region(self);
-            this.alloc_nonpod(op)
         }
     }
 }
 
 #[test]
 fn test_arena_destructors() {
-    let mut arena = Arena();
+    let arena = Arena();
     for uint::range(0, 10) |i| {
         // Arena allocate something with drop glue to make sure it
         // doesn't leak.
@@ -300,7 +300,7 @@ fn test_arena_destructors() {
 #[should_fail]
 #[ignore(cfg(windows))]
 fn test_arena_destructors_fail() {
-    let mut arena = Arena();
+    let arena = Arena();
     // Put some stuff in the arena.
     for uint::range(0, 10) |i| {
         // Arena allocate something with drop glue to make sure it

src/test/bench/shootout-binarytrees.rs

@@ -1,8 +1,4 @@
-// xfail-test
-
-// Broken due to arena API problems.
-
-// 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.
 //
@@ -15,33 +11,35 @@
 extern mod extra;
 use extra::arena;
 
-enum tree<'self> {
-    nil,
-    node(&'self tree<'self>, &'self tree<'self>, int),
+enum Tree<'self> {
+    Nil,
+    Node(&'self Tree<'self>, &'self Tree<'self>, int),
 }
 
-fn item_check(t: &tree) -> int {
+fn item_check(t: &Tree) -> int {
     match *t {
-      nil => { return 0; }
-      node(left, right, item) => {
+      Nil => { return 0; }
+      Node(left, right, item) => {
         return item + item_check(left) - item_check(right);
       }
     }
 }
 
-fn bottom_up_tree<'r>(arena: &'r mut arena::Arena, item: int, depth: int)
-                   -> &'r tree<'r> {
+fn bottom_up_tree<'r>(arena: &'r arena::Arena, item: int, depth: int)
+                   -> &'r Tree<'r> {
     if depth > 0 {
         return arena.alloc(
-            || node(bottom_up_tree(arena, 2 * item - 1, depth - 1),
+            || Node(bottom_up_tree(arena, 2 * item - 1, depth - 1),
                     bottom_up_tree(arena, 2 * item, depth - 1),
                     item));
     }
-    return arena.alloc(|| nil);
+    return arena.alloc(|| Nil);
 }
 
 fn main() {
-    let args = os::args();
+    use std::os;
+    use std::int;
+    let args = std::os::args();
     let args = if os::getenv(~"RUST_BENCH").is_some() {
         ~[~"", ~"17"]
     } else if args.len() <= 1u {
@@ -59,34 +57,34 @@ fn main() {
         max_depth = n;
     }
 
-    let mut stretch_arena = arena::Arena();
+    let stretch_arena = arena::Arena();
     let stretch_depth = max_depth + 1;
-    let stretch_tree = bottom_up_tree(&mut stretch_arena, 0, stretch_depth);
+    let stretch_tree = bottom_up_tree(&stretch_arena, 0, stretch_depth);
 
-    io::println(fmt!("stretch tree of depth %d\t check: %d",
+    println(fmt!("stretch tree of depth %d\t check: %d",
                           stretch_depth,
                           item_check(stretch_tree)));
 
-    let mut long_lived_arena = arena::Arena();
-    let long_lived_tree = bottom_up_tree(&mut long_lived_arena, 0, max_depth);
+    let long_lived_arena = arena::Arena();
+    let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth);
     let mut depth = min_depth;
     while depth <= max_depth {
         let iterations = int::pow(2, (max_depth - depth + min_depth) as uint);
         let mut chk = 0;
         let mut i = 1;
         while i <= iterations {
-            let mut temp_tree = bottom_up_tree(&mut long_lived_arena, i, depth);
+            let mut temp_tree = bottom_up_tree(&long_lived_arena, i, depth);
             chk += item_check(temp_tree);
-            temp_tree = bottom_up_tree(&mut long_lived_arena, -i, depth);
+            temp_tree = bottom_up_tree(&long_lived_arena, -i, depth);
             chk += item_check(temp_tree);
             i += 1;
         }
-        io::println(fmt!("%d\t trees of depth %d\t check: %d",
+        println(fmt!("%d\t trees of depth %d\t check: %d",
                          iterations * 2, depth,
                          chk));
         depth += 2;
     }
-    io::println(fmt!("long lived trees of depth %d\t check: %d",
+    println(fmt!("long lived tree of depth %d\t check: %d",
                      max_depth,
                      item_check(long_lived_tree)));
 }

src/test/bench/shootout-chameneos-redux.rs

@@ -85,7 +85,7 @@ fn show_number(nn: uint) -> ~str {
         out = show_digit(dig) + " " + out;
     }
 
-    return out;
+    return ~" " + out;
 }
 
 fn transform(aa: color, bb: color) -> color {

src/test/bench/shootout-fasta.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.
 //
@@ -19,16 +19,14 @@ extern mod extra;
 
 use std::int;
 use std::io;
-use std::option;
 use std::os;
 use std::rand::Rng;
 use std::rand;
 use std::result;
 use std::str;
 use std::uint;
-use std::vec;
 
-fn LINE_LENGTH() -> uint { return 60u; }
+static LINE_LENGTH: uint = 60u;
 
 struct MyRandom {
     last: u32
@@ -81,7 +79,7 @@ fn make_random_fasta(wr: @io::Writer,
     for uint::range(0u, n as uint) |_i| {
         op.push_char(select_random(myrandom_next(rng, 100u32),
                                               copy genelist));
-        if op.len() >= LINE_LENGTH() {
+        if op.len() >= LINE_LENGTH {
             wr.write_line(op);
             op = ~"";
         }
@@ -90,18 +88,18 @@ fn make_random_fasta(wr: @io::Writer,
 }
 
 fn make_repeat_fasta(wr: @io::Writer, id: ~str, desc: ~str, s: ~str, n: int) {
-    unsafe {
-        wr.write_line(~">" + id + " " + desc);
-        let mut op: ~str = ~"";
-        let sl: uint = s.len();
-        for uint::range(0u, n as uint) |i| {
-            str::raw::push_byte(&mut op, s[i % sl]);
-            if op.len() >= LINE_LENGTH() {
-                wr.write_line(op);
-                op = ~"";
-            }
+    wr.write_line(~">" + id + " " + desc);
+    let mut op = str::with_capacity( LINE_LENGTH );
+    let sl = s.len();
+    for uint::range(0u, n as uint) |i| {
+        if (op.len() >= LINE_LENGTH) {
+            wr.write_line( op );
+            op = str::with_capacity( LINE_LENGTH );
         }
-        if op.len() > 0u { wr.write_line(op); }
+        op.push_char( s[i % sl] as char );
+    }
+    if op.len() > 0 {
+        wr.write_line(op)
     }
 }
 
@@ -111,7 +109,7 @@ fn acid(ch: char, prob: u32) -> AminoAcids {
 
 fn main() {
     let args = os::args();
-    let args = if os::getenv(~"RUST_BENCH").is_some() {
+    let args = if os::getenv("RUST_BENCH").is_some() {
         // alioth tests k-nucleotide with this data at 25,000,000
         ~[~"", ~"5000000"]
     } else if args.len() <= 1u {
@@ -120,9 +118,9 @@ fn main() {
         args
     };
 
-    let writer = if os::getenv(~"RUST_BENCH").is_some() {
+    let writer = if os::getenv("RUST_BENCH").is_some() {
         result::get(&io::file_writer(&Path("./shootout-fasta.data"),
-                                    ~[io::Truncate, io::Create]))
+                                    [io::Truncate, io::Create]))
     } else {
         io::stdout()
     };

src/test/bench/shootout-spectralnorm.rs

@@ -1,3 +1,13 @@
+// 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.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 use std::f64;
 use std::from_str::FromStr;
 use std::os;