bench: Fix fallout in benchmarks

src/librustc_back/fs.rs

@@ -35,7 +35,7 @@ pub fn realpath(original: &Path) -> io::Result<PathBuf> {
         if ret == 0 {
             return Err(io::Error::last_os_error())
         }
-        assert!(ret as usize < v.capacit());
+        assert!(ret as usize < v.capacity());
         v.set_len(ret);
     }
     Ok(PathBuf::from(OsString::from_wide(&v)))

src/test/bench/core-map.rs

@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(unboxed_closures, std_misc, rand)]
+#![feature(std_misc, rand)]
 
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::env;
-use std::rand::{Rng, IsaacRng, SeedableRng};
+use std::__rand::{Rng, thread_rng};
 use std::time::Duration;
 
 fn timed<F>(label: &str, f: F) where F: FnMut() {
@@ -114,7 +114,7 @@ fn main() {
 
     {
         let seed: &[_] = &[1, 1, 1, 1, 1, 1, 1];
-        let mut rng: IsaacRng = SeedableRng::from_seed(seed);
+        let mut rng = thread_rng();
         let mut set = HashSet::new();
         while set.len() != n_keys {
             let next = rng.gen();

src/test/bench/core-std.rs

@@ -11,18 +11,14 @@
 // ignore-lexer-test FIXME #15679
 // Microbenchmarks for various functions in std and extra
 
-#![feature(unboxed_closures, rand, old_io, old_path, std_misc, collections)]
+#![feature(rand, collections, std_misc)]
 
-use std::old_io::*;
-use std::old_path::{Path, GenericPath};
 use std::iter::repeat;
 use std::mem::swap;
 use std::env;
-use std::rand::Rng;
+use std::__rand::{thread_rng, Rng};
-use std::rand;
 use std::str;
 use std::time::Duration;
-use std::vec;
 
 fn main() {
     let argv: Vec<String> = env::args().collect();
@@ -35,7 +31,6 @@ fn main() {
     }
 
     bench!(shift_push);
-    bench!(read_line);
     bench!(vec_plus);
     bench!(vec_append);
     bench!(vec_push_all);
@@ -70,21 +65,8 @@ fn shift_push() {
     }
 }
 
-fn read_line() {
-    use std::old_io::BufferedReader;
-
-    let mut path = Path::new(env!("CFG_SRC_DIR"));
-    path.push("src/test/bench/shootout-k-nucleotide.data");
-
-    for _ in 0..3 {
-        let mut reader = BufferedReader::new(File::open(&path).unwrap());
-        for _line in reader.lines() {
-        }
-    }
-}
-
 fn vec_plus() {
-    let mut r = rand::thread_rng();
+    let mut r = thread_rng();
 
     let mut v = Vec::new();
     let mut i = 0;
@@ -102,7 +84,7 @@ fn vec_plus() {
 }
 
 fn vec_append() {
-    let mut r = rand::thread_rng();
+    let mut r = thread_rng();
 
     let mut v = Vec::new();
     let mut i = 0;
@@ -123,7 +105,7 @@ fn vec_append() {
 }
 
 fn vec_push_all() {
-    let mut r = rand::thread_rng();
+    let mut r = thread_rng();
 
     let mut v = Vec::new();
     for i in 0..1500 {

src/test/bench/noise.rs

@@ -16,7 +16,7 @@
 
 use std::f32::consts::PI;
 use std::num::Float;
-use std::rand::{Rng, StdRng};
+use std::__rand::{Rng, thread_rng};
 
 #[derive(Copy, Clone)]
 struct Vec2 {
@@ -44,7 +44,7 @@ struct Noise2DContext {
 
 impl Noise2DContext {
     fn new() -> Noise2DContext {
-        let mut rng = StdRng::new().unwrap();
+        let mut rng = thread_rng();
 
         let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }; 256];
         for x in &mut rgradients[..] {

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

@@ -38,13 +38,11 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#![feature(core, old_io, io, core)]
-
 use std::cmp::min;
-use std::old_io::*;
-use std::iter::repeat;
 use std::env;
-use std::slice::bytes::copy_memory;
+use std::io;
+use std::io::prelude::*;
+use std::iter::repeat;
 
 const LINE_LEN: usize = 60;
 const LOOKUP_SIZE: usize = 4 * 1024;
@@ -116,27 +114,31 @@ struct RepeatFasta<'a, W:'a> {
     out: &'a mut W
 }
 
-impl<'a, W: Writer> RepeatFasta<'a, W> {
+impl<'a, W: Write> RepeatFasta<'a, W> {
     fn new(alu: &'static str, w: &'a mut W) -> RepeatFasta<'a, W> {
         RepeatFasta { alu: alu, out: w }
     }
 
-    fn make(&mut self, n: usize) -> IoResult<()> {
+    fn make(&mut self, n: usize) -> io::Result<()> {
         let alu_len = self.alu.len();
         let mut buf = repeat(0).take(alu_len + LINE_LEN).collect::<Vec<_>>();
         let alu: &[u8] = self.alu.as_bytes();
 
-        copy_memory(alu, &mut buf);
+        for (slot, val) in buf.iter_mut().zip(alu.iter()) {
+            *slot = *val;
+        }
         let buf_len = buf.len();
-        copy_memory(&alu[..LINE_LEN], &mut buf[alu_len..buf_len]);
+        for (slot, val) in buf[alu_len..buf_len].iter_mut().zip(alu[..LINE_LEN].iter()) {
+            *slot = *val;
+        }
 
         let mut pos = 0;
         let mut bytes;
         let mut n = n;
         while n > 0 {
             bytes = min(LINE_LEN, n);
-            try!(self.out.write(&buf[pos..pos + bytes]));
+            try!(self.out.write_all(&buf[pos..pos + bytes]));
-            try!(self.out.write_u8('\n' as u8));
+            try!(self.out.write_all(&[b'\n']));
             pos += bytes;
             if pos > alu_len {
                 pos -= alu_len;
@@ -165,7 +167,7 @@ struct RandomFasta<'a, W:'a> {
     out: &'a mut W,
 }
 
-impl<'a, W: Writer> RandomFasta<'a, W> {
+impl<'a, W: Write> RandomFasta<'a, W> {
     fn new(w: &'a mut W, a: &[AminoAcid]) -> RandomFasta<'a, W> {
         RandomFasta {
             seed: 42,
@@ -189,7 +191,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> {
         0
     }
 
-    fn make(&mut self, n: usize) -> IoResult<()> {
+    fn make(&mut self, n: usize) -> io::Result<()> {
         let lines = n / LINE_LEN;
         let chars_left = n % LINE_LEN;
         let mut buf = [0;LINE_LEN + 1];
@@ -204,7 +206,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> {
         for i in 0..chars_left {
             buf[i] = self.nextc();
         }
-        self.out.write(&buf[..chars_left])
+        self.out.write_all(&buf[..chars_left])
     }
 }
 
@@ -216,23 +218,23 @@ fn main() {
         5
     };
 
-    let mut out = stdout();
+    let mut out = io::stdout();
 
-    out.write_line(">ONE Homo sapiens alu").unwrap();
+    out.write_all(b">ONE Homo sapiens alu\n").unwrap();
     {
         let mut repeat = RepeatFasta::new(ALU, &mut out);
         repeat.make(n * 2).unwrap();
     }
 
-    out.write_line(">TWO IUB ambiguity codes").unwrap();
+    out.write_all(b">TWO IUB ambiguity codes\n").unwrap();
     let iub = sum_and_scale(&IUB);
     let mut random = RandomFasta::new(&mut out, &iub);
     random.make(n * 3).unwrap();
 
-    random.out.write_line(">THREE Homo sapiens frequency").unwrap();
+    random.out.write_all(b">THREE Homo sapiens frequency\n").unwrap();
     let homo_sapiens = sum_and_scale(&HOMO_SAPIENS);
     random.lookup = make_lookup(&homo_sapiens);
     random.make(n * 5).unwrap();
 
-    random.out.write_str("\n").unwrap();
+    random.out.write_all(b"\n").unwrap();
 }

src/test/bench/shootout-fasta.rs

@@ -38,14 +38,12 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#![feature(old_io, old_path, io, core)]
-
 use std::cmp::min;
-use std::old_io::*;
-use std::old_io;
-use std::old_path::Path;
-use std::num::Float;
 use std::env;
+use std::fs::File;
+use std::io::{self, BufWriter};
+use std::io::prelude::*;
+use std::num::Float;
 
 const LINE_LENGTH: usize = 60;
 const IM: u32 = 139968;
@@ -87,9 +85,9 @@ impl<'a> Iterator for AAGen<'a> {
     }
 }
 
-fn make_fasta<W: Writer, I: Iterator<Item=u8>>(
+fn make_fasta<W: Write, I: Iterator<Item=u8>>(
     wr: &mut W, header: &str, mut it: I, mut n: usize)
-    -> std::old_io::IoResult<()>
+    -> io::Result<()>
 {
     try!(wr.write(header.as_bytes()));
     let mut line = [0; LINE_LENGTH + 1];
@@ -105,7 +103,7 @@ fn make_fasta<W: Writer, I: Iterator<Item=u8>>(
     Ok(())
 }
 
-fn run<W: Writer>(writer: &mut W) -> std::old_io::IoResult<()> {
+fn run<W: Write>(writer: &mut W) -> io::Result<()> {
     let mut args = env::args();
     let n = if env::var_os("RUST_BENCH").is_some() {
         25000000
@@ -146,10 +144,10 @@ fn run<W: Writer>(writer: &mut W) -> std::old_io::IoResult<()> {
 
 fn main() {
     let res = if env::var_os("RUST_BENCH").is_some() {
-        let mut file = BufferedWriter::new(File::create(&Path::new("./shootout-fasta.data")));
+        let mut file = BufWriter::new(File::create("./shootout-fasta.data").unwrap());
         run(&mut file)
     } else {
-        run(&mut old_io::stdout())
+        run(&mut io::stdout())
     };
     res.unwrap()
 }

src/test/bench/shootout-k-nucleotide-pipes.rs

@@ -13,18 +13,17 @@
 
 // multi tasking k-nucleotide
 
-#![feature(box_syntax, std_misc, old_io, collections, os)]
+#![allow(bad_style)]
 
-use std::ascii::{AsciiExt, OwnedAsciiExt};
+use std::ascii::AsciiExt;
 use std::cmp::Ordering::{self, Less, Greater, Equal};
 use std::collections::HashMap;
 use std::mem::replace;
-use std::num::Float;
-use std::option;
-use std::os;
 use std::env;
 use std::sync::mpsc::{channel, Sender, Receiver};
 use std::thread;
+use std::io;
+use std::io::prelude::*;
 
 fn f64_cmp(x: f64, y: f64) -> Ordering {
     // arbitrarily decide that NaNs are larger than everything.
@@ -75,10 +74,10 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , usize>, total: usize) -> String {
 
 // given a map, search for the frequency of a pattern
 fn find(mm: &HashMap<Vec<u8> , usize>, key: String) -> usize {
-   let key = key.into_ascii_lowercase();
+   let key = key.to_ascii_lowercase();
    match mm.get(key.as_bytes()) {
-      option::Option::None      => { return 0; }
+      None => 0,
-      option::Option::Some(&num) => { return num; }
+      Some(&num) => num,
    }
 }
 
@@ -123,7 +122,7 @@ fn make_sequence_processor(sz: usize,
        line = from_parent.recv().unwrap();
        if line == Vec::new() { break; }
 
-       carry.push_all(&line);
+       carry.extend(line);
        carry = windows_with_carry(&carry, sz, |window| {
            update_freq(&mut freqs, window);
            total += 1;
@@ -147,15 +146,13 @@ fn make_sequence_processor(sz: usize,
 
 // given a FASTA file on stdin, process sequence THREE
 fn main() {
-    use std::old_io::*;
+    let input = io::stdin();
-
     let rdr = if env::var_os("RUST_BENCH").is_some() {
-        let foo = include_bytes!("shootout-k-nucleotide.data");
+        let foo: &[u8] = include_bytes!("shootout-k-nucleotide.data");
-        box MemReader::new(foo.to_vec()) as Box<Reader>
+        Box::new(foo) as Box<BufRead>
     } else {
-        box stdio::stdin() as Box<Reader>
+        Box::new(input.lock()) as Box<BufRead>
     };
-    let mut rdr = BufferedReader::new(rdr);
 
     // initialize each sequence sorter
     let sizes: Vec<usize> = vec!(1,2,3,4,6,12,18);

src/test/bench/shootout-mandelbrot.rs

@@ -38,13 +38,13 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#![feature(simd, old_io, core, io)]
+#![feature(simd, core)]
 
 // ignore-pretty very bad with line comments
 
-use std::old_io;
-use std::old_io::*;
 use std::env;
+use std::io::prelude::*;
+use std::io;
 use std::simd::f64x2;
 use std::sync::Arc;
 use std::thread;
@@ -53,8 +53,7 @@ const ITER: usize = 50;
 const LIMIT: f64 = 2.0;
 const WORKERS: usize = 16;
 
-#[inline(always)]
+fn mandelbrot<W: Write>(w: usize, mut out: W) -> io::Result<()> {
-fn mandelbrot<W: old_io::Writer>(w: usize, mut out: W) -> old_io::IoResult<()> {
     assert!(WORKERS % 2 == 0);
 
     // Ensure w and h are multiples of 8.
@@ -142,9 +141,9 @@ fn mandelbrot<W: old_io::Writer>(w: usize, mut out: W) -> old_io::IoResult<()> {
         })
     }).collect::<Vec<_>>();
 
-    try!(writeln!(&mut out as &mut Writer, "P4\n{} {}", w, h));
+    try!(writeln!(&mut out, "P4\n{} {}", w, h));
     for res in data {
-        try!(out.write(&res.join()));
+        try!(out.write_all(&res.join()));
     }
     out.flush()
 }
@@ -202,9 +201,9 @@ fn main() {
     let res = if args.len() < 2 {
         println!("Test mode: do not dump the image because it's not utf8, \
                   which interferes with the test runner.");
-        mandelbrot(1000, old_io::util::NullWriter)
+        mandelbrot(1000, io::sink())
     } else {
-        mandelbrot(args.nth(1).unwrap().parse().unwrap(), old_io::stdout())
+        mandelbrot(args.nth(1).unwrap().parse().unwrap(), io::stdout())
     };
     res.unwrap();
 }

src/test/bench/shootout-reverse-complement.rs

@@ -40,18 +40,18 @@
 
 // ignore-android see #10393 #13206
 
-#![feature(unboxed_closures, libc, old_io, collections, io, core)]
+#![feature(libc)]
 
 extern crate libc;
 
-use std::old_io::stdio::{stdin_raw, stdout_raw};
+use std::io;
-use std::old_io::*;
+use std::io::prelude::*;
-use std::ptr::{copy, Unique};
+use std::ptr::copy;
 use std::thread;
 
 struct Tables {
-    table8: [u8;1 << 8],
+    table8: [u8; 1 << 8],
-    table16: [u16;1 << 16]
+    table16: [u16; 1 << 16]
 }
 
 impl Tables {
@@ -101,36 +101,6 @@ impl Tables {
     }
 }
 
-/// Reads all remaining bytes from the stream.
-fn read_to_end<R: Reader>(r: &mut R) -> IoResult<Vec<u8>> {
-    // As reading the input stream in memory is a bottleneck, we tune
-    // Reader::read_to_end() with a fast growing policy to limit
-    // recopies.  If MREMAP_RETAIN is implemented in the linux kernel
-    // and jemalloc use it, this trick will become useless.
-    const CHUNK: usize = 64 * 1024;
-
-    let mut vec = Vec::with_capacity(CHUNK);
-    loop {
-        // workaround: very fast growing
-        let len = vec.len();
-        if vec.capacity() - len < CHUNK {
-            let cap = vec.capacity();
-            let mult = if cap < 256 * 1024 * 1024 {
-                16
-            } else {
-                2
-            };
-            vec.reserve_exact(mult * cap - len);
-        }
-        match r.push_at_least(1, CHUNK, &mut vec) {
-            Ok(_) => {}
-            Err(ref e) if e.kind == EndOfFile => break,
-            Err(e) => return Err(e)
-        }
-    }
-    Ok(vec)
-}
-
 /// Finds the first position at which `b` occurs in `s`.
 fn memchr(h: &[u8], n: u8) -> Option<usize> {
     use libc::{c_void, c_int, size_t};
@@ -175,7 +145,8 @@ const LINE_LEN: usize = 60;
 
 /// Compute the reverse complement.
 fn reverse_complement(seq: &mut [u8], tables: &Tables) {
-    let seq = seq.init_mut();// Drop the last newline
+    let len = seq.len();
+    let seq = &mut seq[..len - 1]; // Drop the last newline
     let len = seq.len();
     let off = LINE_LEN - len % (LINE_LEN + 1);
     let mut i = LINE_LEN;
@@ -222,26 +193,20 @@ fn reverse_complement(seq: &mut [u8], tables: &Tables) {
     }
 }
 
-
-struct Racy<T>(T);
-
-unsafe impl<T: 'static> Send for Racy<T> {}
-
 /// Executes a closure in parallel over the given iterator over mutable slice.
 /// The closure `f` is run in parallel with an element of `iter`.
-fn parallel<'a, I: Iterator, F>(iter: I, ref f: F)
+fn parallel<I: Iterator, F>(iter: I, ref f: F)
-        where I::Item: Send + 'a,
+        where I::Item: Send,
-              F: Fn(I::Item) + Sync + 'a {
+              F: Fn(I::Item) + Sync, {
     iter.map(|x| {
-        thread::scoped(move|| {
+        thread::scoped(move || f(x))
-            f(x)
-        })
     }).collect::<Vec<_>>();
 }
 
 fn main() {
-    let mut data = read_to_end(&mut stdin_raw()).unwrap();
+    let mut data = Vec::with_capacity(1024 * 1024);
+    io::stdin().read_to_end(&mut data);
     let tables = &Tables::new();
     parallel(mut_dna_seqs(&mut data), |seq| reverse_complement(seq, tables));
-    stdout_raw().write(&data).unwrap();
+    io::stdout().write_all(&data).unwrap();
 }

src/test/debuginfo/function-arg-initialization.rs

@@ -10,15 +10,15 @@
 
 // min-lldb-version: 310
 
-// This test case checks if function arguments already have the correct value when breaking at the
+// This test case checks if function arguments already have the correct value
-// first line of the function, that is if the function prologue has already been executed at the
+// when breaking at the first line of the function, that is if the function
-// first line. Note that because of the __morestack part of the prologue GDB incorrectly breaks at
+// prologue has already been executed at the first line. Note that because of
-// before the arguments have been properly loaded when setting the breakpoint via the function name.
+// the __morestack part of the prologue GDB incorrectly breaks at before the
+// arguments have been properly loaded when setting the breakpoint via the
+// function name.
 
 // compile-flags:-g
 
-#![feature(old_io)]
-
 // === GDB TESTS ===================================================================================
 
 // gdb-command:run
@@ -227,7 +227,7 @@
 #![omit_gdb_pretty_printer_section]
 
 fn immediate_args(a: isize, b: bool, c: f64) {
-    ::std::old_io::print("") // #break
+    println!("") // #break
 }
 
 struct BigStruct {
@@ -242,21 +242,21 @@ struct BigStruct {
 }
 
 fn non_immediate_args(a: BigStruct, b: BigStruct) {
-    ::std::old_io::print("") // #break
+    println!("") // #break
 }
 
 fn binding(a: i64, b: u64, c: f64) {
     let x = 0; // #break
-    ::std::old_io::print("")
+    println!("")
 }
 
 fn assignment(mut a: u64, b: u64, c: f64) {
     a = b; // #break
-    ::std::old_io::print("")
+    println!("")
 }
 
 fn function_call(x: u64, y: u64, z: f64) {
-    std::old_io::stdio::print("Hi!") // #break
+    println!("Hi!") // #break
 }
 
 fn identifier(x: u64, y: u64, z: f64) -> u64 {

src/test/debuginfo/function-prologue-stepping-no-stack-check.rs

@@ -11,17 +11,17 @@
 // ignore-android: FIXME(#10381)
 // min-lldb-version: 310
 
-// This test case checks if function arguments already have the correct value when breaking at the
+// This test case checks if function arguments already have the correct value
-// beginning of a function. Functions with the #[no_stack_check] attribute have the same prologue as
+// when breaking at the beginning of a function. Functions with the
-// regular C functions compiled with GCC or Clang and therefore are better handled by GDB. As a
+// #[no_stack_check] attribute have the same prologue as regular C functions
-// consequence, and as opposed to regular Rust functions, we can set the breakpoints via the
+// compiled with GCC or Clang and therefore are better handled by GDB. As a
-// function name (and don't have to fall back on using line numbers). For LLDB this shouldn't make
+// consequence, and as opposed to regular Rust functions, we can set the
-// a difference because it can handle both cases.
+// breakpoints via the function name (and don't have to fall back on using line
+// numbers). For LLDB this shouldn't make a difference because it can handle
+// both cases.
 
 // compile-flags:-g
 
-#![feature(old_io)]
-
 // === GDB TESTS ===================================================================================
 
 // gdb-command:rbreak immediate_args
@@ -251,7 +251,7 @@
 
 #[no_stack_check]
 fn immediate_args(a: isize, b: bool, c: f64) {
-    ::std::old_io::print("");
+    println!("");
 }
 
 struct BigStruct {
@@ -267,24 +267,24 @@ struct BigStruct {
 
 #[no_stack_check]
 fn non_immediate_args(a: BigStruct, b: BigStruct) {
-    ::std::old_io::print("");
+    println!("");
 }
 
 #[no_stack_check]
 fn binding(a: i64, b: u64, c: f64) {
     let x = 0;
-    ::std::old_io::print("");
+    println!("");
 }
 
 #[no_stack_check]
 fn assignment(mut a: u64, b: u64, c: f64) {
     a = b;
-    ::std::old_io::print("");
+    println!("");
 }
 
 #[no_stack_check]
 fn function_call(x: u64, y: u64, z: f64) {
-    std::old_io::stdio::print("Hi!")
+    println!("Hi!")
 }
 
 #[no_stack_check]

src/test/debuginfo/issue13213.rs

@@ -23,5 +23,5 @@ extern crate issue13213aux;
 // be available because they have been optimized out from the exporting crate.
 fn main() {
     let b: issue13213aux::S = issue13213aux::A;
-    ::std::old_io::println("Nothing to do here...");
+    println!("Nothing to do here...");
 }