keccak-hash: switch benches to criterion

.travis.yml

@@ -36,6 +36,7 @@ script:
     cargo fmt -- --check;
     fi
   - cargo check --all --tests
+  - cargo check --all --benches
   - cargo build --all
   - cargo test --all --exclude uint --exclude fixed-hash
   - if [ "$TRAVIS_RUST_VERSION" == "nightly" ]; then

ethbloom/src/lib.rs

@@ -1,45 +1,42 @@
 //!
-//! ```rust
-//! extern crate ethbloom;
-//! #[macro_use] extern crate hex_literal;
+//! ```
+//! use hex_literal::hex;
 //! use ethbloom::{Bloom, Input};
 //!
-//! fn main() {
-//! 	use std::str::FromStr;
-//! 	let bloom = Bloom::from_str(
-//! 		"00000000000000000000000000000000\
-//! 		 00000000100000000000000000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000002020000000000000000000000\
-//! 		 00000000000000000000000800000000\
-//! 		 10000000000000000000000000000000\
-//! 		 00000000000000000000001000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000000000000000000000000000000\
-//! 		 00000000000000000000000000000000"
-//! 	).unwrap();
-//! 	let address = hex!("ef2d6d194084c2de36e0dabfce45d046b37d1106");
-//! 	let topic = hex!("02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc");
+//! use std::str::FromStr;
+//! let bloom = Bloom::from_str(
+//! 	"00000000000000000000000000000000\
+//! 	00000000100000000000000000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000002020000000000000000000000\
+//! 	00000000000000000000000800000000\
+//! 	10000000000000000000000000000000\
+//! 	00000000000000000000001000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000000000000000000000000000000\
+//! 	00000000000000000000000000000000"
+//! ).unwrap();
+//! let address = hex!("ef2d6d194084c2de36e0dabfce45d046b37d1106");
+//! let topic = hex!("02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc");
 //!
-//! 	let mut my_bloom = Bloom::default();
-//! 	assert!(!my_bloom.contains_input(Input::Raw(&address)));
-//! 	assert!(!my_bloom.contains_input(Input::Raw(&topic)));
+//! let mut my_bloom = Bloom::default();
+//! assert!(!my_bloom.contains_input(Input::Raw(&address)));
+//! assert!(!my_bloom.contains_input(Input::Raw(&topic)));
 //!
-//! 	my_bloom.accrue(Input::Raw(&address));
-//! 	assert!(my_bloom.contains_input(Input::Raw(&address)));
-//! 	assert!(!my_bloom.contains_input(Input::Raw(&topic)));
+//! my_bloom.accrue(Input::Raw(&address));
+//! assert!(my_bloom.contains_input(Input::Raw(&address)));
+//! assert!(!my_bloom.contains_input(Input::Raw(&topic)));
 //!
-//! 	my_bloom.accrue(Input::Raw(&topic));
-//! 	assert!(my_bloom.contains_input(Input::Raw(&address)));
-//! 	assert!(my_bloom.contains_input(Input::Raw(&topic)));
-//! 	assert_eq!(my_bloom, bloom);
-//! 	}
+//! my_bloom.accrue(Input::Raw(&topic));
+//! assert!(my_bloom.contains_input(Input::Raw(&address)));
+//! assert!(my_bloom.contains_input(Input::Raw(&topic)));
+//! assert_eq!(my_bloom, bloom);
 //! ```
 //!
 

fixed-hash/src/hash.rs

@@ -13,38 +13,30 @@
 /// Create a public unformatted hash type with 32 bytes size.
 ///
 /// ```
-/// # #[macro_use] extern crate fixed_hash;
+/// use fixed_hash::construct_fixed_hash;
+///
 /// construct_fixed_hash!{ pub struct H256(32); }
-/// # fn main() {
-/// # 	assert_eq!(std::mem::size_of::<H256>(), 32);
-/// # }
+/// assert_eq!(std::mem::size_of::<H256>(), 32);
 /// ```
 ///
 /// With additional attributes and doc comments.
 ///
 /// ```
-/// # #[macro_use] extern crate fixed_hash;
-/// // Add the below two lines to import serde and its derive
-/// // extern crate serde;
-/// // #[macro_use] extern crate serde_derive;
+/// use fixed_hash::construct_fixed_hash;
 /// construct_fixed_hash!{
 /// 	/// My unformatted 160 bytes sized hash type.
 /// 	#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
 /// 	pub struct H160(20);
 /// }
-/// # fn main() {
-/// # 	assert_eq!(std::mem::size_of::<H160>(), 20);
-/// # }
+/// assert_eq!(std::mem::size_of::<H160>(), 20);
 /// ```
 ///
 /// The visibility modifier is optional and you can create a private hash type.
 ///
 /// ```
-/// # #[macro_use] extern crate fixed_hash;
+/// use fixed_hash::construct_fixed_hash;
 /// construct_fixed_hash!{ struct H512(64); }
-/// # fn main() {
-/// # 	assert_eq!(std::mem::size_of::<H512>(), 64);
-/// # }
+/// assert_eq!(std::mem::size_of::<H512>(), 64);
 /// ```
 #[macro_export(local_inner_macros)]
 macro_rules! construct_fixed_hash {
@@ -761,15 +753,13 @@ macro_rules! impl_ops_for_hash {
 /// # Example
 ///
 /// ```
-/// #[macro_use] extern crate fixed_hash;
+/// use fixed_hash::{construct_fixed_hash, impl_fixed_hash_conversions};
 /// construct_fixed_hash!{ struct H160(20); }
 /// construct_fixed_hash!{ struct H256(32); }
 /// impl_fixed_hash_conversions!(H256, H160);
 /// // now use it!
-/// # fn main() {
 /// assert_eq!(H256::from(H160::zero()), H256::zero());
 /// assert_eq!(H160::from(H256::zero()), H160::zero());
-/// # }
 /// ```
 #[macro_export(local_inner_macros)]
 macro_rules! impl_fixed_hash_conversions {

fixed-hash/src/lib.rs

@@ -54,9 +54,6 @@ pub use rand;
 #[doc(hidden)]
 pub use quickcheck;
 
-#[cfg(test)]
-extern crate rand_xorshift;
-
 #[macro_use]
 mod hash;
 

keccak-hash/Cargo.toml

@@ -14,6 +14,7 @@ primitive-types = { path = "../primitive-types", version = "0.6", default-featur
 
 [dev-dependencies]
 tempdir = "0.3.7"
+criterion = "0.3.0"
 
 [features]
 default = ["std"]

keccak-hash/benches/keccak_256.rs

@@ -14,37 +14,36 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-#![feature(test)]
-
-extern crate test;
-
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use keccak_hash::keccak;
-use test::Bencher;
 
-#[bench]
-fn bench_keccak_256_with_empty_input(b: &mut Bencher) {
+criterion_group!(keccak_256, keccak_256_with_empty_input, keccak_256_with_typical_input, keccak_256_with_large_input,);
+criterion_main!(keccak_256);
+
+pub fn keccak_256_with_empty_input(c: &mut Criterion) {
 	let empty = [0u8; 0];
-	b.bytes = empty.len() as u64;
-	b.iter(|| {
-		let _out = keccak(empty);
-	})
+	c.bench_function("keccak_256_with_empty_input", |b| {
+		b.iter(|| {
+			let _out = keccak(black_box(empty));
+		})
+	});
 }
 
-#[bench]
-fn bench_keccak_256_with_typical_input(b: &mut Bencher) {
+pub fn keccak_256_with_typical_input(c: &mut Criterion) {
 	let data: Vec<u8> = From::from("some medum length string with important information");
-	b.bytes = data.len() as u64;
-	b.iter(|| {
-		let _out = keccak(&data);
-	})
+	c.bench_function("keccak_256_with_typical_input", |b| {
+		b.iter(|| {
+			let _out = keccak(black_box(&data));
+		})
+	});
 }
 
-#[bench]
-fn bench_keccak_256_with_large_input(b: &mut Bencher) {
+pub fn keccak_256_with_large_input(c: &mut Criterion) {
 	// 4096 chars
 	let data: Vec<u8> = From::from("IGxcKBr1Qp7tuqtpSVhAbvt7UgWLEi7mCA6Wa185seLSIJLFS8K1aAFO9AwtO9b3n9SM3Qg136JMmy9Mj9gZ84IaUm8XioPtloabFDU5ZR1wvauJT6jNTkvBVBpUigIsyU7C1u3s99vKP64LpXqvo1hwItZKtISxmUAgzzjv5q14V4G9bkKAnmc4M5xixgLsDGZmnj6HcOMY3XRkWtxN3RscSKwPA0bfpgtz27ZVHplbXwloYRgRLpjRhZJc7sqO8RFnTHKasVkxVRcUoDBvWNJK27TbLvQQcfxETI2Q1H6c2cBAchi8unSiuxqy5rIvVxcl9rsmmRY4IXLEG9qKntUGbiIRLjEffIP9ODoWog0GbWLmMtfvtf24hWVwXz6Ap5oUAR0kLgb7HYIYrOwKjvfV25iEF7GW8cjhl8yowXx1zcgW4t6NJNqJlGzRKx8MvRWQXvHz8h8JxcHl7S64i6PAkxI9eCLXLvs8cpbEQQHt05Zu6GKm6IInjc9mSh52WFuGhgjbno69XzfkBufJs6c9tZuBf6ErVPj4UxmT82ajCruDusk79Tlvb8oQMLjoplQc1alQaLQwSsMac9iVp9MiE3PeYnTTepJ1V10tp79fciDAnNPJgPcRfDYv0REcSFgR9Q7yWhbpPpyBjO7HwOykDQVGtV0ZbDFrFRygLAXagAIkOPc9HDfcBNID1Q2MGk8ijVWMyvmGz1wzbpNfFcQaSOm8olhwoLyHUGvkyXegh44iNsPBUvSicNxTTDowtMqO5azleuWEjzxCobYbASDopvl6JeJjRtEBBO5YCQJiHsYjlXh9QR5Q543GsqhzRLgcHNRSZYLMZqDmIABXZi8VRNJMZyWXDRKHOGDmcHWe55uZomW6FnyU0uSRKxxz66K0JWfxuFzzxAR0vR4ZZCTemgDRQuDwL1loC3KUMjDpU13jUgoPc4UJUVfwQ4f4BUY3X51Cfw9FLw4oX39KoFoiCP2Z6z27gZUY1IlE59WoXGLj4KjTp4C16ZihG080gfDIWlXnDEk3VwBuBFyKWARB63sGLrGnn27b1gHWMaop6sPvkQgWxkEKIqsxDIvXLZJg2s23V8Gqtt0FeA7R3RCvBysF4jNjQ7NiQTIQWQZ8G9gO4mEsftolSZv6FlSpNeBKIIwYWSO2R6vkgeiz06euE9bwwnenOjwPNGTGk8WHIOZBJ1hIP0ejVU2i2ca9ON0phSAnewqjo5W3PtZf2Q7mDvp9imuVWoy4t8XcZq8I2Un9jVjes9Xi0FLN2t71vLFWLWZmGDzwXxpqEgkARS1WjtJoYXCBmRnXEPj6jQfwMZWKPYSIrmOogxMVoWvA8wrof6utfJna9JezyTnrBJSCuGTSNmwwAXRLoFYxF1RITyN8mI2KmHSfvLXBrbE6kmAkjsm4XJb6kria7oUQQ1gzJuCyB7oNHjZTBFNhNa7VeQ1s1xLOwZXLOAjZ4MDTYKnF7giGJGyswb5KQxkOV9orbuAu6pJsjtql6h1UD3BcNUkG3oz8kJNepbuCN3vNCJcZOX1VrQi0PWkDwyvECrQ2E1CgbU6GpWatpg2sCTpo9W62pCcWBK2FKUFWqU3qo2T7T1Mk2ZtM6hE9I8op0M7xlGE91Mn7ea6aq93MWp7nvFlBvbaMIoeU4MpDx0BeOSkROY03ZBJ0x7K8nJrNUhAtvxp17c9oFk0VxLiuRbAAcwDUormOmpVXZNIcqnap4twEVYaSIowfcNojyUSrFL5nPc8ZG93WgNNl9rpUPZhssVml3DvXghI80A9SW3QauzohTQAX2bkWelFBHnuG2LKrsJ8en51N6CkjcS5b87y1DVMZELcZ1n5s8PCAA1wyn7OSZlgw00GRzch1YwMoHzBBgIUtMO9HrMyuhgqIPJP7KcKbQkKhtvBXKplX8SCfSlOwUkLwHNKm3HYVE0uVfJ91NAsUrGoCOjYiXYpoRT8bjAPWTm6fDlTq2sbPOyTMoc4xRasmiOJ7B0PT6UxPzCPImM4100sPFxp7Kofv4okKZWTPKTefeYiPefI3jRgfDtEIP9E6a35LZD75lBNMXYlAqL3qlnheUQD1WQimFTHiDsW6bmURptNvtkMjEXzXzpWbnyxBskUGTvP2YQjtSAhWliDXkv6t1x71cYav7TQbqvbIzMRQQsguSGYMbs8YIC4DC9ep5reWAfanlTxcxksbEhQ7FGzXOvcufeGnDl2C85gWfryVzwN7kOZiSEktFMOQ1ngRC23y1fCOiHQVQJ2nLnaW7GILb9wkN1mBTRuHsOefRJST0TnRxcn4bBq4MIibIitVyjPRy7G5XvPEcL4pFaW1HCPGm6pUOEEwTer32JObNGCyTFB1BI2cRLJu5BHPjgG3mmb0gGkGlIfh8D2b2amogpivqEn2r9Y1KOKQ8ufJvG2mYfkevco9DuEZ9Nmzkm6XkCTZaFMNHqbfQaKqsEYK7i2N1KfkBct1leW2H9MQ9QO7AHCqXHK47b1kWVIm6pSJA1yV4funzCqXnIJCEURQgHiKf38YpN7ylLhe1J4UvSG3KeesZNeFFIZOEP9HZUSFMpnN1MOrwejojK0D4qzwucYWtXrTQ8I7UP5QhlijIsCKckUa9C1Osjrq8cgSclYNGt19wpy0onUbX1rOQBUlAAUJs4CyXNU0wmVUjw7tG1LUC8my4s9KZDUj4R5UcPz3VaZRrx1RqYu6YxjroJW70I1LyG4WEiQbOkCoLmaiWo9WzbUS2cErlOo2RPymlkWHxbNnZawX2Bc872ivRHSWqNpRHyuR5QewXmcyghH3EhESBAxTel5E2xuQXfLCEVK0kEk0Mj22KPsckKKyH7sVYC1F4YItQh5hj9Titb7KflQb9vnXQ44UHxY3zBhTQT5PSYv1Kv8HxXCsnpmhZCiBru16iX9oEB33icBVB2KKcZZEEKnCGPVxJlM9RTlyNyQmjHf7z4GeTDuMAUrsMO31WvgZBnWcAOtn6ulBTUCAaqxJiWqzlMx2FSANAlyAjAxqzmQjzPLvQRjskUnBFN3woKB1m2bSo2c5thwA1fKiPvN5LW8tl1rnfNy3rJ0GJpK8nZjkzHMztYrKYAe56pX4SvplpTyibTIiRXLyEVsmuByTHCZhO3fvGoFsav3ZuRhe9eAAWeqAh13eKDTcA0ufME3ZnmJheXEZ3OwrxnFjSf3U0clkWYVont3neh77ODKHhYnX0bOmnJJlr4RqFoLBitskY0kcGMKcZlaej21SENjDcFgaka3CfHbAH5vIFqnoX1JZrZPkQ65PZqQWImP79U3gXWKvz96lElyJZAFqn0Mbltllqw4MhlI766AvHraOmMsJoNvjv1QR7pCSnC0iX6nbqW1eVPaUSZDuZRtRIxfLA8HC9VbxufT2KZV3qG0l7wrZna5Di2MNcBE9uthuVLZcqp8vCmEhINDhRRlipR7tC2iRBHecS5WtxBCpbEm1y1kgNG5o60UKgAswxxuJ3RQ9Y49mPIApBMmp4LFpuKRfcrZb4UJnCfR3pNbQ70nnZ6Be2M7tuJUCoFfHrhqHXNz5A0uWMgxUS50c60zLl6QAELxHaCGba4WCMOHIo5nSKcUuYtDyDoDlrezALW5mZR4PRPRxnjrXxbJI14qrpymRReC3QgFDJp6sT5TLwvSHaavPlEbt2Eu0Kh5SXklGHXP9YuF3glGuJzSob3NakW1RXF5786U1MHhtJby64LyGWvNn4QXie3VjeL3QQu4C9crEAxSSiOJOfnL3DYIVOY4ipUkKFlF7Rp2q6gZazDvcUCp1cbcr7T7B4s22rXzjN7mHYWOyWuZGwlImeorY3aVKi7BaXbhgOFw6BUmIc1HeGFELHIEnPE9MwOjZam3LOm0rhBHlvJJZkXvJKmDUJrGlyqC5GtC5lDWLfXewyDWDqq7PY0atVQily5GWqib6wub6u6LZ3HZDNP8gK64Nf4kC259AE4V2hCohDnSsXAIoOkehwXyp6CkDT42NJb6sXHUv2N6cm292MiKA22PKWrwUGsan599KI2V67YRDfcfiB4ZHRDiSe62MBE0fGLIgXLIWw1xTWYbPQ9YAj3xovBvmewbJ1De4k6uS");
-	b.bytes = data.len() as u64;
-	b.iter(|| {
-		let _out = keccak(&data);
-	})
+	c.bench_function("keccak_256_with_large_input", |b| {
+		b.iter(|| {
+			let _out = keccak(black_box(&data));
+		})
+	});
 }

kvdb-rocksdb/Cargo.toml

@@ -27,6 +27,7 @@ parity-util-mem = { path = "../parity-util-mem", version = "0.4", default-featur
 [dev-dependencies]
 alloc_counter = "0.0.4"
 criterion = "0.3"
+ethereum-types = { path = "../ethereum-types" }
 kvdb-shared-tests = { path = "../kvdb-shared-tests", version = "0.1" }
 rand = "0.7.2"
 tempdir = "0.3.7"

parity-crypto/benches/bench.rs

@@ -14,11 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-#[macro_use]
-extern crate criterion;
-
 use crate::parity_crypto::publickey::Generator;
-use criterion::{Bencher, Criterion};
+use criterion::{criterion_group, criterion_main, Bencher, Criterion};
 
 criterion_group!(benches, input_len, ecdh_agree,);
 

primitive-types/impls/serde/src/serialize.rs

@@ -78,7 +78,7 @@ pub enum FromHexError {
 impl std::error::Error for FromHexError {}
 
 impl fmt::Display for FromHexError {
-	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+	fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
 		match *self {
 			Self::MissingPrefix => write!(fmt, "0x prefix is missing"),
 			Self::InvalidHex { character, index } => write!(fmt, "invalid hex character: {}, at {}", character, index),
@@ -186,7 +186,7 @@ pub enum ExpectedLen<'a> {
 }
 
 impl<'a> fmt::Display for ExpectedLen<'a> {
-	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+	fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
 		match *self {
 			ExpectedLen::Exact(ref v) => write!(fmt, "length of {}", v.len() * 2),
 			ExpectedLen::Between(min, ref v) => write!(fmt, "length between ({}; {}]", min * 2, v.len() * 2),
@@ -205,7 +205,7 @@ where
 	impl<'b> de::Visitor<'b> for Visitor {
 		type Value = Vec<u8>;
 
-		fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 			write!(formatter, "a 0x-prefixed hex string")
 		}
 
@@ -234,7 +234,7 @@ where
 	impl<'a, 'b> de::Visitor<'b> for Visitor<'a> {
 		type Value = usize;
 
-		fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 			write!(formatter, "a 0x-prefixed hex string with {}", self.len)
 		}
 
@@ -272,7 +272,7 @@ where
 #[cfg(test)]
 mod tests {
 	use super::*;
-	extern crate serde_derive;
+	use serde_derive;
 
 	use self::serde_derive::{Deserialize, Serialize};
 

rlp/src/lib.rs

@@ -59,14 +59,10 @@ pub const EMPTY_LIST_RLP: [u8; 1] = [0xC0; 1];
 
 /// Shortcut function to decode trusted rlp
 ///
-/// ```rust
-/// extern crate rlp;
-///
-/// fn main () {
-/// 	let data = vec![0x83, b'c', b'a', b't'];
-/// 	let animal: String = rlp::decode(&data).expect("could not decode");
-/// 	assert_eq!(animal, "cat".to_owned());
-/// }
+/// ```
+/// let data = vec![0x83, b'c', b'a', b't'];
+/// let animal: String = rlp::decode(&data).expect("could not decode");
+/// assert_eq!(animal, "cat".to_owned());
 /// ```
 pub fn decode<T>(bytes: &[u8]) -> Result<T, DecoderError>
 where
@@ -86,14 +82,10 @@ where
 
 /// Shortcut function to encode structure into rlp.
 ///
-/// ```rust
-/// extern crate rlp;
-///
-/// fn main () {
-/// 	let animal = "cat";
-/// 	let out = rlp::encode(&animal);
-/// 	assert_eq!(out, vec![0x83, b'c', b'a', b't']);
-/// }
+/// ```
+/// let animal = "cat";
+/// let out = rlp::encode(&animal);
+/// assert_eq!(out, vec![0x83, b'c', b'a', b't']);
 /// ```
 pub fn encode<E>(object: &E) -> Vec<u8>
 where