mii/merkle.rs
1
0
Fork 0
mirror of https://github.com/mii443/merkle.rs.git synced 2025-08-22 16:05:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix clippy warnings and disable benchmarks temporarily

Browse Source
This commit is contained in:
Romain Ruetschi
2019-07-23 10:44:41 +02:00
parent 3b374e5a43
commit c65560d9f4
4 changed files with 106 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -16,7 +16,6 @@ readme = "README.md"
keywords = ["merkle", "merkle-tree"]
categories = ["data-structures", "cryptography"]
[dependencies]
ring = "^0.16.1"
protobuf = { version = "^2.8.0", optional = true }

202
benches/lib.rs
View File

@ -1,128 +1,128 @@
#![feature(test)]
#![feature(rand)]
// #![feature(test)]
// #![feature(rand)]
extern crate rand;
extern crate test;
// extern crate rand;
// extern crate test;
extern crate merkle;
extern crate ring;
// extern crate merkle;
// extern crate ring;
use rand::Rng;
use test::Bencher;
// use rand::Rng;
// use test::Bencher;
use ring::digest::{Algorithm, SHA512};
// use ring::digest::{Algorithm, SHA512};
use merkle::MerkleTree;
// use merkle::MerkleTree;
#[allow(non_upper_case_globals)]
static digest: &'static Algorithm = &SHA512;
// #[allow(non_upper_case_globals)]
// static digest: &'static Algorithm = &SHA512;
#[bench]
fn bench_small_str_tree(b: &mut Bencher) {
let values = vec!["one", "two", "three", "four"];
// #[bench]
// fn bench_small_str_tree(b: &mut Bencher) {
// let values = vec!["one", "two", "three", "four"];
b.iter(|| MerkleTree::from_vec(digest, values.clone()));
}
// b.iter(|| MerkleTree::from_vec(digest, values.clone()));
// }
#[bench]
fn bench_small_str_proof_gen(b: &mut Bencher) {
let values = vec!["one", "two", "three", "four"];
let tree = MerkleTree::from_vec(digest, values.clone());
// #[bench]
// fn bench_small_str_proof_gen(b: &mut Bencher) {
// let values = vec!["one", "two", "three", "four"];
// let tree = MerkleTree::from_vec(digest, values.clone());
b.iter(|| {
for value in &values {
let proof = tree.gen_proof(value);
test::black_box(proof);
}
});
}
// b.iter(|| {
// for value in &values {
// let proof = tree.gen_proof(value);
// test::black_box(proof);
// }
// });
// }
#[bench]
fn bench_small_str_proof_check(b: &mut Bencher) {
let values = vec!["one", "two", "three", "four"];
let tree = MerkleTree::from_vec(digest, values.clone());
let proofs = values
.iter()
.map(|v| tree.gen_proof(v).unwrap())
.collect::<Vec<_>>();
// #[bench]
// fn bench_small_str_proof_check(b: &mut Bencher) {
// let values = vec!["one", "two", "three", "four"];
// let tree = MerkleTree::from_vec(digest, values.clone());
// let proofs = values
// .iter()
// .map(|v| tree.gen_proof(v).unwrap())
// .collect::<Vec<_>>();
b.iter(|| {
for proof in &proofs {
test::black_box(proof.validate(tree.root_hash()));
}
});
}
// b.iter(|| {
// for proof in &proofs {
// test::black_box(proof.validate(tree.root_hash()));
// }
// });
// }
#[bench]
fn bench_big_rnd_tree(b: &mut Bencher) {
let mut values = vec![vec![0u8; 256]; 160];
let mut rng = rand::IsaacRng::new_unseeded();
// #[bench]
// fn bench_big_rnd_tree(b: &mut Bencher) {
// let mut values = vec![vec![0u8; 256]; 160];
// let mut rng = rand::IsaacRng::new_unseeded();
for mut v in &mut values {
rng.fill_bytes(&mut v);
}
// for mut v in &mut values {
// rng.fill_bytes(&mut v);
// }
b.iter(|| {
let tree = MerkleTree::from_vec(digest, values.clone());
test::black_box(tree)
});
}
// b.iter(|| {
// let tree = MerkleTree::from_vec(digest, values.clone());
// test::black_box(tree)
// });
// }
#[bench]
fn bench_big_rnd_proof_gen(b: &mut Bencher) {
let mut values = vec![vec![0u8; 256]; 160];
let mut rng = rand::IsaacRng::new_unseeded();
// #[bench]
// fn bench_big_rnd_proof_gen(b: &mut Bencher) {
// let mut values = vec![vec![0u8; 256]; 160];
// let mut rng = rand::IsaacRng::new_unseeded();
for mut v in &mut values {
rng.fill_bytes(&mut v);
}
// for mut v in &mut values {
// rng.fill_bytes(&mut v);
// }
let tree = MerkleTree::from_vec(digest, values.clone());
// let tree = MerkleTree::from_vec(digest, values.clone());
b.iter(|| {
for value in &values {
let proof = tree.gen_proof(value.clone());
test::black_box(proof);
}
});
}
// b.iter(|| {
// for value in &values {
// let proof = tree.gen_proof(value.clone());
// test::black_box(proof);
// }
// });
// }
#[bench]
fn bench_big_rnd_proof_check(b: &mut Bencher) {
let mut values = vec![vec![0u8; 256]; 160];
let mut rng = rand::IsaacRng::new_unseeded();
// #[bench]
// fn bench_big_rnd_proof_check(b: &mut Bencher) {
// let mut values = vec![vec![0u8; 256]; 160];
// let mut rng = rand::IsaacRng::new_unseeded();
for mut v in &mut values {
rng.fill_bytes(&mut v);
}
// for mut v in &mut values {
// rng.fill_bytes(&mut v);
// }
let tree = MerkleTree::from_vec(digest, values.clone());
let proofs = values
.into_iter()
.map(|v| tree.gen_proof(v).unwrap())
.collect::<Vec<_>>();
// let tree = MerkleTree::from_vec(digest, values.clone());
// let proofs = values
// .into_iter()
// .map(|v| tree.gen_proof(v).unwrap())
// .collect::<Vec<_>>();
b.iter(|| {
for proof in &proofs {
test::black_box(proof.validate(tree.root_hash()));
}
});
}
// b.iter(|| {
// for proof in &proofs {
// test::black_box(proof.validate(tree.root_hash()));
// }
// });
// }
#[bench]
fn bench_big_rnd_iter(b: &mut Bencher) {
let mut values = vec![vec![0u8; 256]; 160];
let mut rng = rand::IsaacRng::new_unseeded();
// #[bench]
// fn bench_big_rnd_iter(b: &mut Bencher) {
// let mut values = vec![vec![0u8; 256]; 160];
// let mut rng = rand::IsaacRng::new_unseeded();
for mut v in &mut values {
rng.fill_bytes(&mut v);
}
// for mut v in &mut values {
// rng.fill_bytes(&mut v);
// }
let tree = MerkleTree::from_vec(digest, values.clone());
// let tree = MerkleTree::from_vec(digest, values.clone());
b.iter(|| {
for value in &tree {
test::black_box(value);
}
});
}
// b.iter(|| {
// for value in &tree {
// test::black_box(value);
// }
// });
// }

7
src/proof.rs
View File

@ -75,11 +75,12 @@ mod algorithm_serde {
serde_json::ser::PrettyFormatter::new(),
);
serialize(alg, &mut serializer).expect(&format!("{:?}", alg));
serialize(alg, &mut serializer).unwrap_or_else(|_| panic!("{:?}", alg));
let alg_ = deserialize(&mut serde_json::Deserializer::from_slice(
&serializer.into_inner()[..],
))
.expect(&format!("{:?}", alg));
.unwrap_or_else(|_| panic!("{:?}", alg));
assert_eq!(*alg, alg_);
}
@ -92,7 +93,7 @@ mod algorithm_serde {
{
let alg_str = "\"BLAKE2b\"";
let mut deserializer = serde_json::Deserializer::from_str(alg_str);
let _ = deserialize(&mut deserializer).expect(&format!("{:?}", alg_str));
let _ = deserialize(&mut deserializer).unwrap_or_else(|_| panic!("{:?}", alg_str));
}
}
}

2
src/tests.rs
View File

@ -154,7 +154,7 @@ fn test_wrong_proof() {
fn test_nth_proof() {
// Calculation depends on the total count. Try a few numbers: odd, even, powers of two...
for &count in &[1, 2, 3, 10, 15, 16, 17, 22] {
let values = (1..(count + 1)).map(|x| vec![x as u8]).collect::<Vec<_>>();
let values = (1..=count).map(|x| vec![x as u8]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone());
let root_hash = tree.root_hash();