pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-18 03:41:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Run cargo fmt on the whole code base (#9394)

Browse Source 
* Run cargo fmt on the whole code base

* Second run

* Add CI check

* Fix compilation

* More unnecessary braces

* Handle weights

* Use --all

* Use correct attributes...

* Fix UI tests

* AHHHHHHHHH

* 🤦

* Docs

* Fix compilation

* 🤷

* Please stop

* 🤦 x 2

* More

* make rustfmt.toml consistent with polkadot

Co-authored-by: André Silva <andrerfosilva@gmail.com>
This commit is contained in:
Bastian Köcher
2021-07-21 16:32:32 +02:00
committed by GitHub
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/primitives/core/benches/bench.rs
+31 -50
View File
@@ -15,22 +15,21 @@
#[macro_use]
extern crate criterion;
use criterion::{Criterion, black_box, Bencher, BenchmarkId};
use sp_core::crypto::Pair as _;
use sp_core::hashing::{twox_128, blake2_128};
use criterion::{black_box, Bencher, BenchmarkId, Criterion};
use sp_core::{
crypto::Pair as _,
hashing::{blake2_128, twox_128},
};
const MAX_KEY_SIZE: u32 = 32;
fn get_key(key_size: u32) -> Vec<u8> {
use rand::SeedableRng;
use rand::Rng;
use rand::{Rng, SeedableRng};
let rnd: [u8; 32] = rand::rngs::StdRng::seed_from_u64(12).gen();
let mut rnd = rnd.iter().cycle();
(0..key_size)
.map(|_| *rnd.next().unwrap())
.collect()
(0..key_size).map(|_| *rnd.next().unwrap()).collect()
}
fn bench_blake2_128(b: &mut Bencher, key: &Vec<u8>) {
@@ -81,27 +80,21 @@ fn bench_ed25519(c: &mut Criterion) {
let mut group = c.benchmark_group("ed25519");
for msg_size in vec![32, 1024, 1024 * 1024] {
let msg = (0..msg_size)
.map(|_| rand::random::<u8>())
.collect::<Vec<_>>();
let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
let key = sp_core::ed25519::Pair::generate().0;
group.bench_function(
BenchmarkId::new("signing", format!("{}", msg_size)),
|b| b.iter(|| key.sign(&msg)),
);
group.bench_function(BenchmarkId::new("signing", format!("{}", msg_size)), |b| {
b.iter(|| key.sign(&msg))
});
}
for msg_size in vec![32, 1024, 1024 * 1024] {
let msg = (0..msg_size)
.map(|_| rand::random::<u8>())
.collect::<Vec<_>>();
let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
let key = sp_core::ed25519::Pair::generate().0;
let sig = key.sign(&msg);
let public = key.public();
group.bench_function(
BenchmarkId::new("verifying", format!("{}", msg_size)),
|b| b.iter(|| sp_core::ed25519::Pair::verify(&sig, &msg, &public)),
);
group.bench_function(BenchmarkId::new("verifying", format!("{}", msg_size)), |b| {
b.iter(|| sp_core::ed25519::Pair::verify(&sig, &msg, &public))
});
}
group.finish();
@@ -111,27 +104,21 @@ fn bench_sr25519(c: &mut Criterion) {
let mut group = c.benchmark_group("sr25519");
for msg_size in vec![32, 1024, 1024 * 1024] {
let msg = (0..msg_size)
.map(|_| rand::random::<u8>())
.collect::<Vec<_>>();
let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
let key = sp_core::sr25519::Pair::generate().0;
group.bench_function(
BenchmarkId::new("signing", format!("{}", msg_size)),
|b| b.iter(|| key.sign(&msg)),
);
group.bench_function(BenchmarkId::new("signing", format!("{}", msg_size)), |b| {
b.iter(|| key.sign(&msg))
});
}
for msg_size in vec![32, 1024, 1024 * 1024] {
let msg = (0..msg_size)
.map(|_| rand::random::<u8>())
.collect::<Vec<_>>();
let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
let key = sp_core::sr25519::Pair::generate().0;
let sig = key.sign(&msg);
let public = key.public();
group.bench_function(
BenchmarkId::new("verifying", format!("{}", msg_size)),
|b| b.iter(|| sp_core::sr25519::Pair::verify(&sig, &msg, &public)),
);
group.bench_function(BenchmarkId::new("verifying", format!("{}", msg_size)), |b| {
b.iter(|| sp_core::sr25519::Pair::verify(&sig, &msg, &public))
});
}
group.finish();
@@ -141,27 +128,21 @@ fn bench_ecdsa(c: &mut Criterion) {
let mut group = c.benchmark_group("ecdsa");
for msg_size in vec![32, 1024, 1024 * 1024] {
let msg = (0..msg_size)
.map(|_| rand::random::<u8>())
.collect::<Vec<_>>();
let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
let key = sp_core::ecdsa::Pair::generate().0;
group.bench_function(
BenchmarkId::new("signing", format!("{}", msg_size)),
|b| b.iter(|| key.sign(&msg)),
);
group.bench_function(BenchmarkId::new("signing", format!("{}", msg_size)), |b| {
b.iter(|| key.sign(&msg))
});
}
for msg_size in vec![32, 1024, 1024 * 1024] {
let msg = (0..msg_size)
.map(|_| rand::random::<u8>())
.collect::<Vec<_>>();
let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
let key = sp_core::ecdsa::Pair::generate().0;
let sig = key.sign(&msg);
let public = key.public();
group.bench_function(
BenchmarkId::new("verifying", format!("{}", msg_size)),
|b| b.iter(|| sp_core::ecdsa::Pair::verify(&sig, &msg, &public)),
);
group.bench_function(BenchmarkId::new("verifying", format!("{}", msg_size)), |b| {
b.iter(|| sp_core::ecdsa::Pair::verify(&sig, &msg, &public))
});
}
group.finish();