From 33fb5bb004613a0da01c2be272480c06fb82d6dc Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 10 Apr 2015 13:39:51 -0700 Subject: [PATCH] bench: Fix fallout in benchmarks --- src/librustc_back/fs.rs | 2 +- src/test/bench/core-map.rs | 6 +- src/test/bench/core-std.rs | 28 ++------ src/test/bench/noise.rs | 4 +- src/test/bench/shootout-fasta-redux.rs | 40 ++++++------ src/test/bench/shootout-fasta.rs | 20 +++--- src/test/bench/shootout-k-nucleotide-pipes.rs | 27 ++++---- src/test/bench/shootout-mandelbrot.rs | 17 +++-- src/test/bench/shootout-reverse-complement.rs | 65 +++++-------------- .../debuginfo/function-arg-initialization.rs | 22 +++---- ...nction-prologue-stepping-no-stack-check.rs | 26 ++++---- src/test/debuginfo/issue13213.rs | 2 +- 12 files changed, 101 insertions(+), 158 deletions(-) diff --git a/src/librustc_back/fs.rs b/src/librustc_back/fs.rs index 2e4dedd2ad2..ea7f2446bf3 100644 --- a/src/librustc_back/fs.rs +++ b/src/librustc_back/fs.rs @@ -35,7 +35,7 @@ pub fn realpath(original: &Path) -> io::Result { 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))) diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index 0cff90d61ed..8f3e939f1f4 100644 --- a/src/test/bench/core-map.rs +++ b/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(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(); diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 0344d6a46ee..d910367afbf 100644 --- a/src/test/bench/core-std.rs +++ b/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 = 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 { diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs index 83c39b3f3fa..c21470d4bb3 100644 --- a/src/test/bench/noise.rs +++ b/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[..] { diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index effdd67027a..145ab714463 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/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::>(); 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(); } diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index 78d31faeb51..0474cfb6fc8 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/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>( +fn make_fasta>( 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>( Ok(()) } -fn run(writer: &mut W) -> std::old_io::IoResult<()> { +fn run(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(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() } diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index c190641bfbf..bcd8fbf8852 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/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 , usize>, total: usize) -> String { // given a map, search for the frequency of a pattern fn find(mm: &HashMap , 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 + let foo: &[u8] = include_bytes!("shootout-k-nucleotide.data"); + Box::new(foo) as Box } else { - box stdio::stdin() as Box + Box::new(input.lock()) as Box }; - let mut rdr = BufferedReader::new(rdr); // initialize each sequence sorter let sizes: Vec = vec!(1,2,3,4,6,12,18); diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index d248293103b..93a0a461746 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/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: usize, mut out: W) -> old_io::IoResult<()> { +fn mandelbrot(w: usize, mut out: W) -> io::Result<()> { assert!(WORKERS % 2 == 0); // Ensure w and h are multiples of 8. @@ -142,9 +141,9 @@ fn mandelbrot(w: usize, mut out: W) -> old_io::IoResult<()> { }) }).collect::>(); - 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(); } diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs index cda90c08f23..96ac1e064bf 100644 --- a/src/test/bench/shootout-reverse-complement.rs +++ b/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::old_io::*; -use std::ptr::{copy, Unique}; +use std::io; +use std::io::prelude::*; +use std::ptr::copy; use std::thread; struct Tables { - table8: [u8;1 << 8], - table16: [u16;1 << 16] + table8: [u8; 1 << 8], + table16: [u16; 1 << 16] } impl Tables { @@ -101,36 +101,6 @@ impl Tables { } } -/// Reads all remaining bytes from the stream. -fn read_to_end(r: &mut R) -> IoResult> { - // 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 { 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); - -unsafe impl Send for Racy {} - /// 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) - where I::Item: Send + 'a, - F: Fn(I::Item) + Sync + 'a { +fn parallel(iter: I, ref f: F) + where I::Item: Send, + F: Fn(I::Item) + Sync, { iter.map(|x| { - thread::scoped(move|| { - f(x) - }) + thread::scoped(move || f(x)) }).collect::>(); } 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(); } diff --git a/src/test/debuginfo/function-arg-initialization.rs b/src/test/debuginfo/function-arg-initialization.rs index d611e4a65a6..a1ca59caa33 100644 --- a/src/test/debuginfo/function-arg-initialization.rs +++ b/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 -// first line of the function, that is if the function prologue has already been executed at the -// first line. Note that because of 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. +// This test case checks if function arguments already have the correct value +// when breaking at the first line of the function, that is if the function +// prologue has already been executed at the first line. Note that because of +// 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 { diff --git a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs index 0608e49b28c..7e959a1e920 100644 --- a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs +++ b/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 -// beginning of a function. Functions with the #[no_stack_check] attribute have the same prologue as -// regular C functions compiled with GCC or Clang and therefore are better handled by GDB. As a -// consequence, and as opposed to regular Rust functions, we can set the 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. +// This test case checks if function arguments already have the correct value +// when breaking at the beginning of a function. Functions with the +// #[no_stack_check] attribute have the same prologue as regular C functions +// compiled with GCC or Clang and therefore are better handled by GDB. As a +// consequence, and as opposed to regular Rust functions, we can set the +// 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] diff --git a/src/test/debuginfo/issue13213.rs b/src/test/debuginfo/issue13213.rs index 38b149ef243..13dc0c6d120 100644 --- a/src/test/debuginfo/issue13213.rs +++ b/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..."); }