bench: Fix fallout in benchmarks

Author: alexcrichton

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;
+use std::__rand::{thread_rng, Rng};
 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_u8('\n' as u8));
+            try!(self.out.write_all(&buf[pos..pos + bytes]));
+            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; }
-      option::Option::Some(&num) => { return num; }
+      None => 0,
+      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");
-        box MemReader::new(foo.to_vec()) as Box<Reader>
+        let foo: &[u8] = include_bytes!("shootout-k-nucleotide.data");
+        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);