From 34f444de5d2fbab533eb523f8d8b0b75bf07217d Mon Sep 17 00:00:00 2001 From: Son Date: Sat, 4 Feb 2017 10:04:22 +1100 Subject: [PATCH] Extract libcore benchmarks to a separate folder --- src/libcore/Cargo.toml | 7 +- src/libcore/bench/any.rs | 22 +++ src/libcore/bench/hash/mod.rs | 11 ++ src/libcore/bench/hash/sip.rs | 151 ++++++++++++++++++ src/libcore/bench/iter.rs | 101 ++++++++++++ src/libcore/bench/lib.rs | 25 +++ src/libcore/bench/mem.rs | 70 ++++++++ src/libcore/bench/num/dec2flt/mod.rs | 68 ++++++++ src/libcore/bench/num/flt2dec/mod.rs | 24 +++ .../bench/num/flt2dec/strategy/dragon.rs | 70 ++++++++ .../bench/num/flt2dec/strategy/grisu.rs | 77 +++++++++ src/libcore/bench/num/mod.rs | 12 ++ src/libcore/bench/ops.rs | 30 ++++ src/libcoretest/any.rs | 13 +- src/libcoretest/hash/sip.rs | 130 --------------- src/libcoretest/iter.rs | 91 ----------- src/libcoretest/mem.rs | 60 +------ src/libcoretest/num/dec2flt/mod.rs | 57 ------- .../num/flt2dec/strategy/dragon.rs | 57 ------- src/libcoretest/num/flt2dec/strategy/grisu.rs | 58 +------ src/libcoretest/ops.rs | 19 --- 21 files changed, 667 insertions(+), 486 deletions(-) create mode 100644 src/libcore/bench/any.rs create mode 100644 src/libcore/bench/hash/mod.rs create mode 100644 src/libcore/bench/hash/sip.rs create mode 100644 src/libcore/bench/iter.rs create mode 100644 src/libcore/bench/lib.rs create mode 100644 src/libcore/bench/mem.rs create mode 100644 src/libcore/bench/num/dec2flt/mod.rs create mode 100644 src/libcore/bench/num/flt2dec/mod.rs create mode 100644 src/libcore/bench/num/flt2dec/strategy/dragon.rs create mode 100644 src/libcore/bench/num/flt2dec/strategy/grisu.rs create mode 100644 src/libcore/bench/num/mod.rs create mode 100644 src/libcore/bench/ops.rs diff --git a/src/libcore/Cargo.toml b/src/libcore/Cargo.toml index e0dbc096cd0d9..4f7cd7b016d66 100644 --- a/src/libcore/Cargo.toml +++ b/src/libcore/Cargo.toml @@ -13,7 +13,6 @@ bench = false name = "coretest" path = "../libcoretest/lib.rs" -# FIXME: need to extract benchmarks to a separate crate -#[[bench]] -#name = "coretest" -#path = "../libcoretest/lib.rs" +[[bench]] +name = "corebench" +path = "../libcore/bench/lib.rs" diff --git a/src/libcore/bench/any.rs b/src/libcore/bench/any.rs new file mode 100644 index 0000000000000..67e02cf9509b6 --- /dev/null +++ b/src/libcore/bench/any.rs @@ -0,0 +1,22 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use core::any::*; +use test::{Bencher, black_box}; + +#[bench] +fn bench_downcast_ref(b: &mut Bencher) { + b.iter(|| { + let mut x = 0; + let mut y = &mut x as &mut Any; + black_box(&mut y); + black_box(y.downcast_ref::() == Some(&0)); + }); +} diff --git a/src/libcore/bench/hash/mod.rs b/src/libcore/bench/hash/mod.rs new file mode 100644 index 0000000000000..55d9e3e091380 --- /dev/null +++ b/src/libcore/bench/hash/mod.rs @@ -0,0 +1,11 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +mod sip; diff --git a/src/libcore/bench/hash/sip.rs b/src/libcore/bench/hash/sip.rs new file mode 100644 index 0000000000000..3379c85bbec7d --- /dev/null +++ b/src/libcore/bench/hash/sip.rs @@ -0,0 +1,151 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(deprecated)] + +use core::hash::*; +use test::{Bencher, black_box}; + +fn hash_bytes(mut s: H, x: &[u8]) -> u64 { + Hasher::write(&mut s, x); + s.finish() +} + +fn hash_with(mut st: H, x: &T) -> u64 { + x.hash(&mut st); + st.finish() +} + +fn hash(x: &T) -> u64 { + hash_with(SipHasher::new(), x) +} + +#[bench] +fn bench_str_under_8_bytes(b: &mut Bencher) { + let s = "foo"; + b.iter(|| { + assert_eq!(hash(&s), 16262950014981195938); + }) +} + +#[bench] +fn bench_str_of_8_bytes(b: &mut Bencher) { + let s = "foobar78"; + b.iter(|| { + assert_eq!(hash(&s), 4898293253460910787); + }) +} + +#[bench] +fn bench_str_over_8_bytes(b: &mut Bencher) { + let s = "foobarbaz0"; + b.iter(|| { + assert_eq!(hash(&s), 10581415515220175264); + }) +} + +#[bench] +fn bench_long_str(b: &mut Bencher) { + let s = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor \ +incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud \ +exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute \ +irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla \ +pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui \ +officia deserunt mollit anim id est laborum."; + b.iter(|| { + assert_eq!(hash(&s), 17717065544121360093); + }) +} + +#[bench] +fn bench_u32(b: &mut Bencher) { + let u = 162629500u32; + let u = black_box(u); + b.iter(|| { + hash(&u) + }); + b.bytes = 8; +} + +#[bench] +fn bench_u32_keyed(b: &mut Bencher) { + let u = 162629500u32; + let u = black_box(u); + let k1 = black_box(0x1); + let k2 = black_box(0x2); + b.iter(|| { + hash_with(SipHasher::new_with_keys(k1, k2), &u) + }); + b.bytes = 8; +} + +#[bench] +fn bench_u64(b: &mut Bencher) { + let u = 16262950014981195938u64; + let u = black_box(u); + b.iter(|| { + hash(&u) + }); + b.bytes = 8; +} + +#[bench] +fn bench_bytes_4(b: &mut Bencher) { + let data = black_box([b' '; 4]); + b.iter(|| { + hash_bytes(SipHasher::default(), &data) + }); + b.bytes = 4; +} + +#[bench] +fn bench_bytes_7(b: &mut Bencher) { + let data = black_box([b' '; 7]); + b.iter(|| { + hash_bytes(SipHasher::default(), &data) + }); + b.bytes = 7; +} + +#[bench] +fn bench_bytes_8(b: &mut Bencher) { + let data = black_box([b' '; 8]); + b.iter(|| { + hash_bytes(SipHasher::default(), &data) + }); + b.bytes = 8; +} + +#[bench] +fn bench_bytes_a_16(b: &mut Bencher) { + let data = black_box([b' '; 16]); + b.iter(|| { + hash_bytes(SipHasher::default(), &data) + }); + b.bytes = 16; +} + +#[bench] +fn bench_bytes_b_32(b: &mut Bencher) { + let data = black_box([b' '; 32]); + b.iter(|| { + hash_bytes(SipHasher::default(), &data) + }); + b.bytes = 32; +} + +#[bench] +fn bench_bytes_c_128(b: &mut Bencher) { + let data = black_box([b' '; 128]); + b.iter(|| { + hash_bytes(SipHasher::default(), &data) + }); + b.bytes = 128; +} diff --git a/src/libcore/bench/iter.rs b/src/libcore/bench/iter.rs new file mode 100644 index 0000000000000..93d38a5bc83bb --- /dev/null +++ b/src/libcore/bench/iter.rs @@ -0,0 +1,101 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use core::iter::*; +use test::{Bencher, black_box}; + +#[bench] +fn bench_rposition(b: &mut Bencher) { + let it: Vec = (0..300).collect(); + b.iter(|| { + it.iter().rposition(|&x| x <= 150); + }); +} + +#[bench] +fn bench_skip_while(b: &mut Bencher) { + b.iter(|| { + let it = 0..100; + let mut sum = 0; + it.skip_while(|&x| { sum += x; sum < 4000 }).all(|_| true); + }); +} + +#[bench] +fn bench_multiple_take(b: &mut Bencher) { + let mut it = (0..42).cycle(); + b.iter(|| { + let n = it.next().unwrap(); + for _ in 0..n { + it.clone().take(it.next().unwrap()).all(|_| true); + } + }); +} + +fn scatter(x: i32) -> i32 { (x * 31) % 127 } + +#[bench] +fn bench_max_by_key(b: &mut Bencher) { + b.iter(|| { + let it = 0..100; + it.max_by_key(|&x| scatter(x)) + }) +} + +// http://www.reddit.com/r/rust/comments/31syce/using_iterators_to_find_the_index_of_the_min_or/ +#[bench] +fn bench_max_by_key2(b: &mut Bencher) { + fn max_index_iter(array: &[i32]) -> usize { + array.iter().enumerate().max_by_key(|&(_, item)| item).unwrap().0 + } + + let mut data = vec![0; 1638]; + data[514] = 9999; + + b.iter(|| max_index_iter(&data)); +} + +#[bench] +fn bench_max(b: &mut Bencher) { + b.iter(|| { + let it = 0..100; + it.map(scatter).max() + }) +} + +pub fn copy_zip(xs: &[u8], ys: &mut [u8]) { + for (a, b) in ys.iter_mut().zip(xs) { + *a = *b; + } +} + +pub fn add_zip(xs: &[f32], ys: &mut [f32]) { + for (a, b) in ys.iter_mut().zip(xs) { + *a += *b; + } +} + +#[bench] +fn bench_zip_copy(b: &mut Bencher) { + let source = vec![0u8; 16 * 1024]; + let mut dst = black_box(vec![0u8; 16 * 1024]); + b.iter(|| { + copy_zip(&source, &mut dst) + }) +} + +#[bench] +fn bench_zip_add(b: &mut Bencher) { + let source = vec![1.; 16 * 1024]; + let mut dst = vec![0.; 16 * 1024]; + b.iter(|| { + add_zip(&source, &mut dst) + }); +} diff --git a/src/libcore/bench/lib.rs b/src/libcore/bench/lib.rs new file mode 100644 index 0000000000000..d2db329da7999 --- /dev/null +++ b/src/libcore/bench/lib.rs @@ -0,0 +1,25 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![deny(warnings)] + +#![feature(flt2dec)] +#![feature(slice_patterns)] +#![feature(test)] + +extern crate core; +extern crate test; + +mod any; +mod hash; +mod iter; +mod mem; +mod num; +mod ops; diff --git a/src/libcore/bench/mem.rs b/src/libcore/bench/mem.rs new file mode 100644 index 0000000000000..8e541d92a7f17 --- /dev/null +++ b/src/libcore/bench/mem.rs @@ -0,0 +1,70 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use test::Bencher; + +// FIXME #13642 (these benchmarks should be in another place) +// Completely miscellaneous language-construct benchmarks. +// Static/dynamic method dispatch + +struct Struct { + field: isize +} + +trait Trait { + fn method(&self) -> isize; +} + +impl Trait for Struct { + fn method(&self) -> isize { + self.field + } +} + +#[bench] +fn trait_vtable_method_call(b: &mut Bencher) { + let s = Struct { field: 10 }; + let t = &s as &Trait; + b.iter(|| { + t.method() + }); +} + +#[bench] +fn trait_static_method_call(b: &mut Bencher) { + let s = Struct { field: 10 }; + b.iter(|| { + s.method() + }); +} + +// Overhead of various match forms + +#[bench] +fn match_option_some(b: &mut Bencher) { + let x = Some(10); + b.iter(|| { + match x { + Some(y) => y, + None => 11 + } + }); +} + +#[bench] +fn match_vec_pattern(b: &mut Bencher) { + let x = [1,2,3,4,5,6]; + b.iter(|| { + match x { + [1,2,3,..] => 10, + _ => 11, + } + }); +} diff --git a/src/libcore/bench/num/dec2flt/mod.rs b/src/libcore/bench/num/dec2flt/mod.rs new file mode 100644 index 0000000000000..562866e11777c --- /dev/null +++ b/src/libcore/bench/num/dec2flt/mod.rs @@ -0,0 +1,68 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::f64; +use test::Bencher; + +#[bench] +fn bench_0(b: &mut Bencher) { + b.iter(|| "0.0".parse::()); +} + +#[bench] +fn bench_42(b: &mut Bencher) { + b.iter(|| "42".parse::()); +} + +#[bench] +fn bench_huge_int(b: &mut Bencher) { + // 2^128 - 1 + b.iter(|| "170141183460469231731687303715884105727".parse::()); +} + +#[bench] +fn bench_short_decimal(b: &mut Bencher) { + b.iter(|| "1234.5678".parse::()); +} + +#[bench] +fn bench_pi_long(b: &mut Bencher) { + b.iter(|| "3.14159265358979323846264338327950288".parse::()); +} + +#[bench] +fn bench_pi_short(b: &mut Bencher) { + b.iter(|| "3.141592653589793".parse::()) +} + +#[bench] +fn bench_1e150(b: &mut Bencher) { + b.iter(|| "1e150".parse::()); +} + +#[bench] +fn bench_long_decimal_and_exp(b: &mut Bencher) { + b.iter(|| "727501488517303786137132964064381141071e-123".parse::()); +} + +#[bench] +fn bench_min_subnormal(b: &mut Bencher) { + b.iter(|| "5e-324".parse::()); +} + +#[bench] +fn bench_min_normal(b: &mut Bencher) { + b.iter(|| "2.2250738585072014e-308".parse::()); +} + +#[bench] +fn bench_max(b: &mut Bencher) { + b.iter(|| "1.7976931348623157e308".parse::()); +} diff --git a/src/libcore/bench/num/flt2dec/mod.rs b/src/libcore/bench/num/flt2dec/mod.rs new file mode 100644 index 0000000000000..1de2bf4921f58 --- /dev/null +++ b/src/libcore/bench/num/flt2dec/mod.rs @@ -0,0 +1,24 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +mod strategy { + mod dragon; + mod grisu; +} + +use core::num::flt2dec::{decode, DecodableFloat, FullDecoded, Decoded}; +use core::num::flt2dec::MAX_SIG_DIGITS; + +pub fn decode_finite(v: T) -> Decoded { + match decode(v).1 { + FullDecoded::Finite(decoded) => decoded, + full_decoded => panic!("expected finite, got {:?} instead", full_decoded) + } +} diff --git a/src/libcore/bench/num/flt2dec/strategy/dragon.rs b/src/libcore/bench/num/flt2dec/strategy/dragon.rs new file mode 100644 index 0000000000000..6824cf40ed2ae --- /dev/null +++ b/src/libcore/bench/num/flt2dec/strategy/dragon.rs @@ -0,0 +1,70 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::{i16, f64}; +use super::super::*; +use core::num::flt2dec::strategy::dragon::*; +use test::Bencher; + +#[bench] +fn bench_small_shortest(b: &mut Bencher) { + let decoded = decode_finite(3.141592f64); + let mut buf = [0; MAX_SIG_DIGITS]; + b.iter(|| format_shortest(&decoded, &mut buf)); +} + +#[bench] +fn bench_big_shortest(b: &mut Bencher) { + let decoded = decode_finite(f64::MAX); + let mut buf = [0; MAX_SIG_DIGITS]; + b.iter(|| format_shortest(&decoded, &mut buf)); +} + +#[bench] +fn bench_small_exact_3(b: &mut Bencher) { + let decoded = decode_finite(3.141592f64); + let mut buf = [0; 3]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_big_exact_3(b: &mut Bencher) { + let decoded = decode_finite(f64::MAX); + let mut buf = [0; 3]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_small_exact_12(b: &mut Bencher) { + let decoded = decode_finite(3.141592f64); + let mut buf = [0; 12]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_big_exact_12(b: &mut Bencher) { + let decoded = decode_finite(f64::MAX); + let mut buf = [0; 12]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_small_exact_inf(b: &mut Bencher) { + let decoded = decode_finite(3.141592f64); + let mut buf = [0; 1024]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_big_exact_inf(b: &mut Bencher) { + let decoded = decode_finite(f64::MAX); + let mut buf = [0; 1024]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} diff --git a/src/libcore/bench/num/flt2dec/strategy/grisu.rs b/src/libcore/bench/num/flt2dec/strategy/grisu.rs new file mode 100644 index 0000000000000..82e1a858fca9f --- /dev/null +++ b/src/libcore/bench/num/flt2dec/strategy/grisu.rs @@ -0,0 +1,77 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::{i16, f64}; +use super::super::*; +use core::num::flt2dec::strategy::grisu::*; +use test::Bencher; + +pub fn decode_finite(v: T) -> Decoded { + match decode(v).1 { + FullDecoded::Finite(decoded) => decoded, + full_decoded => panic!("expected finite, got {:?} instead", full_decoded) + } +} + +#[bench] +fn bench_small_shortest(b: &mut Bencher) { + let decoded = decode_finite(3.141592f64); + let mut buf = [0; MAX_SIG_DIGITS]; + b.iter(|| format_shortest(&decoded, &mut buf)); +} + +#[bench] +fn bench_big_shortest(b: &mut Bencher) { + let decoded = decode_finite(f64::MAX); + let mut buf = [0; MAX_SIG_DIGITS]; + b.iter(|| format_shortest(&decoded, &mut buf)); +} + +#[bench] +fn bench_small_exact_3(b: &mut Bencher) { + let decoded = decode_finite(3.141592f64); + let mut buf = [0; 3]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_big_exact_3(b: &mut Bencher) { + let decoded = decode_finite(f64::MAX); + let mut buf = [0; 3]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_small_exact_12(b: &mut Bencher) { + let decoded = decode_finite(3.141592f64); + let mut buf = [0; 12]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_big_exact_12(b: &mut Bencher) { + let decoded = decode_finite(f64::MAX); + let mut buf = [0; 12]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_small_exact_inf(b: &mut Bencher) { + let decoded = decode_finite(3.141592f64); + let mut buf = [0; 1024]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} + +#[bench] +fn bench_big_exact_inf(b: &mut Bencher) { + let decoded = decode_finite(f64::MAX); + let mut buf = [0; 1024]; + b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); +} diff --git a/src/libcore/bench/num/mod.rs b/src/libcore/bench/num/mod.rs new file mode 100644 index 0000000000000..55f0bdb57ec82 --- /dev/null +++ b/src/libcore/bench/num/mod.rs @@ -0,0 +1,12 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +mod flt2dec; +mod dec2flt; diff --git a/src/libcore/bench/ops.rs b/src/libcore/bench/ops.rs new file mode 100644 index 0000000000000..7f36a4b0771aa --- /dev/null +++ b/src/libcore/bench/ops.rs @@ -0,0 +1,30 @@ +// Copyright 2017 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use core::ops::*; +use test::Bencher; + +// Overhead of dtors + +struct HasDtor { + _x: isize +} + +impl Drop for HasDtor { + fn drop(&mut self) { + } +} + +#[bench] +fn alloc_obj_with_dtor(b: &mut Bencher) { + b.iter(|| { + HasDtor { _x : 10 }; + }) +} diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs index a9fc8913182b3..2d3e81aa131ed 100644 --- a/src/libcoretest/any.rs +++ b/src/libcoretest/any.rs @@ -7,9 +7,8 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. + use core::any::*; -use test::Bencher; -use test; #[derive(PartialEq, Debug)] struct Test; @@ -124,13 +123,3 @@ fn any_unsized() { fn is_any() {} is_any::<[i32]>(); } - -#[bench] -fn bench_downcast_ref(b: &mut Bencher) { - b.iter(|| { - let mut x = 0; - let mut y = &mut x as &mut Any; - test::black_box(&mut y); - test::black_box(y.downcast_ref::() == Some(&0)); - }); -} diff --git a/src/libcoretest/hash/sip.rs b/src/libcoretest/hash/sip.rs index fa3bfdea42df8..4a9657e03404a 100644 --- a/src/libcoretest/hash/sip.rs +++ b/src/libcoretest/hash/sip.rs @@ -10,8 +10,6 @@ #![allow(deprecated)] -use test::{Bencher, black_box}; - use core::hash::{Hash, Hasher}; use core::hash::{SipHasher, SipHasher13, SipHasher24}; use core::{slice, mem}; @@ -58,11 +56,6 @@ fn hash(x: &T) -> u64 { hash_with(SipHasher::new(), x) } -fn hash_bytes(mut s: H, x: &[u8]) -> u64 { - Hasher::write(&mut s, x); - s.finish() -} - #[test] #[allow(unused_must_use)] fn test_siphash_1_3() { @@ -347,126 +340,3 @@ fn test_write_short_works() { h2.write(&[0xFFu8, 0x01u8]); assert_eq!(h1.finish(), h2.finish()); } - -#[bench] -fn bench_str_under_8_bytes(b: &mut Bencher) { - let s = "foo"; - b.iter(|| { - assert_eq!(hash(&s), 16262950014981195938); - }) -} - -#[bench] -fn bench_str_of_8_bytes(b: &mut Bencher) { - let s = "foobar78"; - b.iter(|| { - assert_eq!(hash(&s), 4898293253460910787); - }) -} - -#[bench] -fn bench_str_over_8_bytes(b: &mut Bencher) { - let s = "foobarbaz0"; - b.iter(|| { - assert_eq!(hash(&s), 10581415515220175264); - }) -} - -#[bench] -fn bench_long_str(b: &mut Bencher) { - let s = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor \ -incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud \ -exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute \ -irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla \ -pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui \ -officia deserunt mollit anim id est laborum."; - b.iter(|| { - assert_eq!(hash(&s), 17717065544121360093); - }) -} - -#[bench] -fn bench_u32(b: &mut Bencher) { - let u = 162629500u32; - let u = black_box(u); - b.iter(|| { - hash(&u) - }); - b.bytes = 8; -} - -#[bench] -fn bench_u32_keyed(b: &mut Bencher) { - let u = 162629500u32; - let u = black_box(u); - let k1 = black_box(0x1); - let k2 = black_box(0x2); - b.iter(|| { - hash_with(SipHasher::new_with_keys(k1, k2), &u) - }); - b.bytes = 8; -} - -#[bench] -fn bench_u64(b: &mut Bencher) { - let u = 16262950014981195938u64; - let u = black_box(u); - b.iter(|| { - hash(&u) - }); - b.bytes = 8; -} - -#[bench] -fn bench_bytes_4(b: &mut Bencher) { - let data = black_box([b' '; 4]); - b.iter(|| { - hash_bytes(SipHasher::default(), &data) - }); - b.bytes = 4; -} - -#[bench] -fn bench_bytes_7(b: &mut Bencher) { - let data = black_box([b' '; 7]); - b.iter(|| { - hash_bytes(SipHasher::default(), &data) - }); - b.bytes = 7; -} - -#[bench] -fn bench_bytes_8(b: &mut Bencher) { - let data = black_box([b' '; 8]); - b.iter(|| { - hash_bytes(SipHasher::default(), &data) - }); - b.bytes = 8; -} - -#[bench] -fn bench_bytes_a_16(b: &mut Bencher) { - let data = black_box([b' '; 16]); - b.iter(|| { - hash_bytes(SipHasher::default(), &data) - }); - b.bytes = 16; -} - -#[bench] -fn bench_bytes_b_32(b: &mut Bencher) { - let data = black_box([b' '; 32]); - b.iter(|| { - hash_bytes(SipHasher::default(), &data) - }); - b.bytes = 32; -} - -#[bench] -fn bench_bytes_c_128(b: &mut Bencher) { - let data = black_box([b' '; 128]); - b.iter(|| { - hash_bytes(SipHasher::default(), &data) - }); - b.bytes = 128; -} diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index 6d02f76c33d16..89f59a9c2de76 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -12,9 +12,6 @@ use core::iter::*; use core::{i8, i16, isize}; use core::usize; -use test::Bencher; -use test::black_box; - #[test] fn test_lt() { let empty: [isize; 0] = []; @@ -1079,91 +1076,3 @@ fn test_chain_fold() { assert_eq!(&[2, 3, 1, 2, 0], &result[..]); } -#[bench] -fn bench_rposition(b: &mut Bencher) { - let it: Vec = (0..300).collect(); - b.iter(|| { - it.iter().rposition(|&x| x <= 150); - }); -} - -#[bench] -fn bench_skip_while(b: &mut Bencher) { - b.iter(|| { - let it = 0..100; - let mut sum = 0; - it.skip_while(|&x| { sum += x; sum < 4000 }).all(|_| true); - }); -} - -#[bench] -fn bench_multiple_take(b: &mut Bencher) { - let mut it = (0..42).cycle(); - b.iter(|| { - let n = it.next().unwrap(); - for _ in 0..n { - it.clone().take(it.next().unwrap()).all(|_| true); - } - }); -} - -fn scatter(x: i32) -> i32 { (x * 31) % 127 } - -#[bench] -fn bench_max_by_key(b: &mut Bencher) { - b.iter(|| { - let it = 0..100; - it.max_by_key(|&x| scatter(x)) - }) -} - -// http://www.reddit.com/r/rust/comments/31syce/using_iterators_to_find_the_index_of_the_min_or/ -#[bench] -fn bench_max_by_key2(b: &mut Bencher) { - fn max_index_iter(array: &[i32]) -> usize { - array.iter().enumerate().max_by_key(|&(_, item)| item).unwrap().0 - } - - let mut data = vec![0; 1638]; - data[514] = 9999; - - b.iter(|| max_index_iter(&data)); -} - -#[bench] -fn bench_max(b: &mut Bencher) { - b.iter(|| { - let it = 0..100; - it.map(scatter).max() - }) -} - -pub fn copy_zip(xs: &[u8], ys: &mut [u8]) { - for (a, b) in ys.iter_mut().zip(xs) { - *a = *b; - } -} - -pub fn add_zip(xs: &[f32], ys: &mut [f32]) { - for (a, b) in ys.iter_mut().zip(xs) { - *a += *b; - } -} - -#[bench] -fn bench_zip_copy(b: &mut Bencher) { - let source = vec![0u8; 16 * 1024]; - let mut dst = black_box(vec![0u8; 16 * 1024]); - b.iter(|| { - copy_zip(&source, &mut dst) - }) -} - -#[bench] -fn bench_zip_add(b: &mut Bencher) { - let source = vec![1.; 16 * 1024]; - let mut dst = vec![0.; 16 * 1024]; - b.iter(|| { - add_zip(&source, &mut dst) - }); -} diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs index 01bafe49a7acd..86e59c736ba4a 100644 --- a/src/libcoretest/mem.rs +++ b/src/libcoretest/mem.rs @@ -7,8 +7,8 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. + use core::mem::*; -use test::Bencher; #[test] fn size_of_basic() { @@ -121,61 +121,3 @@ fn test_transmute() { } } -// FIXME #13642 (these benchmarks should be in another place) -/// Completely miscellaneous language-construct benchmarks. -// Static/dynamic method dispatch - -struct Struct { - field: isize -} - -trait Trait { - fn method(&self) -> isize; -} - -impl Trait for Struct { - fn method(&self) -> isize { - self.field - } -} - -#[bench] -fn trait_vtable_method_call(b: &mut Bencher) { - let s = Struct { field: 10 }; - let t = &s as &Trait; - b.iter(|| { - t.method() - }); -} - -#[bench] -fn trait_static_method_call(b: &mut Bencher) { - let s = Struct { field: 10 }; - b.iter(|| { - s.method() - }); -} - -// Overhead of various match forms - -#[bench] -fn match_option_some(b: &mut Bencher) { - let x = Some(10); - b.iter(|| { - match x { - Some(y) => y, - None => 11 - } - }); -} - -#[bench] -fn match_vec_pattern(b: &mut Bencher) { - let x = [1,2,3,4,5,6]; - b.iter(|| { - match x { - [1,2,3,..] => 10, - _ => 11, - } - }); -} diff --git a/src/libcoretest/num/dec2flt/mod.rs b/src/libcoretest/num/dec2flt/mod.rs index fe6f52406fbc8..5d546c643e7ee 100644 --- a/src/libcoretest/num/dec2flt/mod.rs +++ b/src/libcoretest/num/dec2flt/mod.rs @@ -11,7 +11,6 @@ #![allow(overflowing_literals)] use std::{i64, f32, f64}; -use test; mod parse; mod rawfp; @@ -144,59 +143,3 @@ fn borderline_overflow() { // It makes no sense to enshrine that in a test, the important part is that it doesn't panic. let _ = s.parse::(); } - -#[bench] -fn bench_0(b: &mut test::Bencher) { - b.iter(|| "0.0".parse::()); -} - -#[bench] -fn bench_42(b: &mut test::Bencher) { - b.iter(|| "42".parse::()); -} - -#[bench] -fn bench_huge_int(b: &mut test::Bencher) { - // 2^128 - 1 - b.iter(|| "170141183460469231731687303715884105727".parse::()); -} - -#[bench] -fn bench_short_decimal(b: &mut test::Bencher) { - b.iter(|| "1234.5678".parse::()); -} - -#[bench] -fn bench_pi_long(b: &mut test::Bencher) { - b.iter(|| "3.14159265358979323846264338327950288".parse::()); -} - -#[bench] -fn bench_pi_short(b: &mut test::Bencher) { - b.iter(|| "3.141592653589793".parse::()) -} - -#[bench] -fn bench_1e150(b: &mut test::Bencher) { - b.iter(|| "1e150".parse::()); -} - -#[bench] -fn bench_long_decimal_and_exp(b: &mut test::Bencher) { - b.iter(|| "727501488517303786137132964064381141071e-123".parse::()); -} - -#[bench] -fn bench_min_subnormal(b: &mut test::Bencher) { - b.iter(|| "5e-324".parse::()); -} - -#[bench] -fn bench_min_normal(b: &mut test::Bencher) { - b.iter(|| "2.2250738585072014e-308".parse::()); -} - -#[bench] -fn bench_max(b: &mut test::Bencher) { - b.iter(|| "1.7976931348623157e308".parse::()); -} diff --git a/src/libcoretest/num/flt2dec/strategy/dragon.rs b/src/libcoretest/num/flt2dec/strategy/dragon.rs index 08c2cd0a7326f..4edb0f3df60c4 100644 --- a/src/libcoretest/num/flt2dec/strategy/dragon.rs +++ b/src/libcoretest/num/flt2dec/strategy/dragon.rs @@ -9,7 +9,6 @@ // except according to those terms. use std::prelude::v1::*; -use std::{i16, f64}; use super::super::*; use core::num::bignum::Big32x40 as Big; use core::num::flt2dec::strategy::dragon::*; @@ -53,62 +52,6 @@ fn exact_sanity_test() { f32_exact_sanity_test(format_exact); } -#[bench] -fn bench_small_shortest(b: &mut Bencher) { - let decoded = decode_finite(3.141592f64); - let mut buf = [0; MAX_SIG_DIGITS]; - b.iter(|| format_shortest(&decoded, &mut buf)); -} - -#[bench] -fn bench_big_shortest(b: &mut Bencher) { - let decoded = decode_finite(f64::MAX); - let mut buf = [0; MAX_SIG_DIGITS]; - b.iter(|| format_shortest(&decoded, &mut buf)); -} - -#[bench] -fn bench_small_exact_3(b: &mut Bencher) { - let decoded = decode_finite(3.141592f64); - let mut buf = [0; 3]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_big_exact_3(b: &mut Bencher) { - let decoded = decode_finite(f64::MAX); - let mut buf = [0; 3]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_small_exact_12(b: &mut Bencher) { - let decoded = decode_finite(3.141592f64); - let mut buf = [0; 12]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_big_exact_12(b: &mut Bencher) { - let decoded = decode_finite(f64::MAX); - let mut buf = [0; 12]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_small_exact_inf(b: &mut Bencher) { - let decoded = decode_finite(3.141592f64); - let mut buf = [0; 1024]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_big_exact_inf(b: &mut Bencher) { - let decoded = decode_finite(f64::MAX); - let mut buf = [0; 1024]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - #[test] fn test_to_shortest_str() { to_shortest_str_test(format_shortest); diff --git a/src/libcoretest/num/flt2dec/strategy/grisu.rs b/src/libcoretest/num/flt2dec/strategy/grisu.rs index 311bd252353c7..79e66ee669e14 100644 --- a/src/libcoretest/num/flt2dec/strategy/grisu.rs +++ b/src/libcoretest/num/flt2dec/strategy/grisu.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::{i16, f64}; +use std::i16; use super::super::*; use core::num::flt2dec::strategy::grisu::*; @@ -102,62 +102,6 @@ fn exact_f64_random_equivalence_test() { } } -#[bench] -fn bench_small_shortest(b: &mut Bencher) { - let decoded = decode_finite(3.141592f64); - let mut buf = [0; MAX_SIG_DIGITS]; - b.iter(|| format_shortest(&decoded, &mut buf)); -} - -#[bench] -fn bench_big_shortest(b: &mut Bencher) { - let decoded = decode_finite(f64::MAX); - let mut buf = [0; MAX_SIG_DIGITS]; - b.iter(|| format_shortest(&decoded, &mut buf)); -} - -#[bench] -fn bench_small_exact_3(b: &mut Bencher) { - let decoded = decode_finite(3.141592f64); - let mut buf = [0; 3]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_big_exact_3(b: &mut Bencher) { - let decoded = decode_finite(f64::MAX); - let mut buf = [0; 3]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_small_exact_12(b: &mut Bencher) { - let decoded = decode_finite(3.141592f64); - let mut buf = [0; 12]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_big_exact_12(b: &mut Bencher) { - let decoded = decode_finite(f64::MAX); - let mut buf = [0; 12]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_small_exact_inf(b: &mut Bencher) { - let decoded = decode_finite(3.141592f64); - let mut buf = [0; 1024]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - -#[bench] -fn bench_big_exact_inf(b: &mut Bencher) { - let decoded = decode_finite(f64::MAX); - let mut buf = [0; 1024]; - b.iter(|| format_exact(&decoded, &mut buf, i16::MIN)); -} - #[test] fn test_to_shortest_str() { to_shortest_str_test(format_shortest); diff --git a/src/libcoretest/ops.rs b/src/libcoretest/ops.rs index 33674a3abd870..1c6c13b0d02e8 100644 --- a/src/libcoretest/ops.rs +++ b/src/libcoretest/ops.rs @@ -8,27 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use test::Bencher; use core::ops::{Range, RangeFull, RangeFrom, RangeTo}; -// Overhead of dtors - -struct HasDtor { - _x: isize -} - -impl Drop for HasDtor { - fn drop(&mut self) { - } -} - -#[bench] -fn alloc_obj_with_dtor(b: &mut Bencher) { - b.iter(|| { - HasDtor { _x : 10 }; - }) -} - // Test the Range structs without the syntactic sugar. #[test]