Fix benches

crypto-primitives/benches/crypto_primitives/comm.rs

@@ -0,0 +1,57 @@
+use rand;
+
+#[macro_use]
+extern crate criterion;
+
+use algebra::{UniformRand, curves::edwards_bls12::EdwardsProjective as Edwards};
+use criterion::Criterion;
+use crypto_primitives::commitment::{pedersen::*, CommitmentScheme};
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct CommWindow;
+
+impl PedersenWindow for CommWindow {
+    const WINDOW_SIZE: usize = 250;
+    const NUM_WINDOWS: usize = 8;
+}
+
+fn pedersen_comm_setup(c: &mut Criterion) {
+    c.bench_function("Pedersen Commitment Setup", move |b| {
+        b.iter(|| {
+            let mut rng = &mut rand::thread_rng();
+            PedersenCommitment::<Edwards, CommWindow>::setup(&mut rng).unwrap()
+        })
+    });
+}
+
+fn pedersen_comm_eval(c: &mut Criterion) {
+    let mut rng = &mut rand::thread_rng();
+    let parameters = PedersenCommitment::<Edwards, CommWindow>::setup(&mut rng).unwrap();
+    let input = vec![5u8; 128];
+    c.bench_function("Pedersen Commitment Eval", move |b| {
+        b.iter(|| {
+            let rng = &mut rand::thread_rng();
+            let commitment_randomness = PedersenRandomness::rand(rng);
+            PedersenCommitment::<Edwards, CommWindow>::commit(
+                &parameters,
+                &input,
+                &commitment_randomness,
+            )
+            .unwrap();
+        })
+    });
+}
+
+criterion_group! {
+    name = comm_setup;
+    config = Criterion::default().sample_size(5);
+    targets = pedersen_comm_setup
+}
+
+criterion_group! {
+    name = comm_eval;
+    config = Criterion::default().sample_size(10);
+    targets = pedersen_comm_eval
+}
+
+criterion_main!(comm_setup, comm_eval);

crypto-primitives/benches/crypto_primitives/crh.rs

@@ -0,0 +1,50 @@
+use rand;
+
+#[macro_use]
+extern crate criterion;
+
+use algebra::curves::edwards_bls12::EdwardsProjective as Edwards;
+use criterion::Criterion;
+use crypto_primitives::crh::{pedersen::*, FixedLengthCRH};
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HashWindow;
+
+impl PedersenWindow for HashWindow {
+    const WINDOW_SIZE: usize = 250;
+    const NUM_WINDOWS: usize = 8;
+}
+
+fn pedersen_crh_setup(c: &mut Criterion) {
+    c.bench_function("Pedersen CRH Setup", move |b| {
+        b.iter(|| {
+            let mut rng = &mut rand::thread_rng();
+            PedersenCRH::<Edwards, HashWindow>::setup(&mut rng).unwrap()
+        })
+    });
+}
+
+fn pedersen_crh_eval(c: &mut Criterion) {
+    let mut rng = &mut rand::thread_rng();
+    let parameters = PedersenCRH::<Edwards, HashWindow>::setup(&mut rng).unwrap();
+    let input = vec![5u8; 128];
+    c.bench_function("Pedersen CRH Eval", move |b| {
+        b.iter(|| {
+            PedersenCRH::<Edwards, HashWindow>::evaluate(&parameters, &input).unwrap();
+        })
+    });
+}
+
+criterion_group! {
+    name = crh_setup;
+    config = Criterion::default().sample_size(5);
+    targets = pedersen_crh_setup
+}
+
+criterion_group! {
+    name = crh_eval;
+    config = Criterion::default().sample_size(10);
+    targets = pedersen_crh_eval
+}
+
+criterion_main!(crh_setup, crh_eval);

crypto-primitives/benches/crypto_primitives/prf.rs

@@ -0,0 +1,25 @@
+use rand;
+
+#[macro_use]
+extern crate criterion;
+
+use criterion::Criterion;
+use crypto_primitives::prf::*;
+use rand::Rng;
+
+fn blake2s_prf_eval(c: &mut Criterion) {
+    let rng = &mut rand::thread_rng();
+    let input: [u8; 32] = rng.gen();
+    let seed: [u8; 32] = rng.gen();
+    c.bench_function("Blake2s PRF Eval", move |b| {
+        b.iter(|| Blake2s::evaluate(&seed, &input).unwrap())
+    });
+}
+
+criterion_group! {
+    name = prf_eval;
+    config = Criterion::default().sample_size(50);
+    targets = blake2s_prf_eval
+}
+
+criterion_main!(prf_eval);

crypto-primitives/benches/crypto_primitives/signature.rs

@@ -0,0 +1,180 @@
+#[macro_use]
+extern crate criterion;
+
+mod affine {
+    use algebra::curves::edwards_bls12::EdwardsAffine as Edwards;
+    use blake2::Blake2s;
+    use criterion::Criterion;
+    use crypto_primitives::signature::{schnorr::*, SignatureScheme};
+    use rand::{self, Rng};
+
+    type SchnorrEdwards = SchnorrSignature<Edwards, Blake2s>;
+    fn schnorr_signature_setup(c: &mut Criterion) {
+        c.bench_function("SchnorrEdwardsAffine: Setup", move |b| {
+            b.iter(|| {
+                let mut rng = &mut rand::thread_rng();
+                SchnorrEdwards::setup(&mut rng).unwrap()
+            })
+        });
+    }
+
+    fn schnorr_signature_keygen(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+
+        c.bench_function("SchnorrEdwardsAffine: KeyGen", move |b| {
+            b.iter(|| {
+                let mut rng = &mut rand::thread_rng();
+                SchnorrEdwards::keygen(&parameters, &mut rng).unwrap()
+            })
+        });
+    }
+
+    fn schnorr_signature_sign(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+        let (_, sk) = SchnorrEdwards::keygen(&parameters, &mut rng).unwrap();
+        let message = [100u8; 128];
+
+        c.bench_function("SchnorrEdwardsAffine: Sign", move |b| {
+            b.iter(|| {
+                let mut rng = &mut rand::thread_rng();
+                SchnorrEdwards::sign(&parameters, &sk, &message, &mut rng).unwrap()
+            })
+        });
+    }
+
+    fn schnorr_signature_verify(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+        let (pk, sk) = SchnorrEdwards::keygen(&parameters, &mut rng).unwrap();
+        let message = [100u8; 128];
+        let signature = SchnorrEdwards::sign(&parameters, &sk, &message, &mut rng).unwrap();
+
+        c.bench_function("SchnorrEdwardsAffine: Verify", move |b| {
+            b.iter(|| SchnorrEdwards::verify(&parameters, &pk, &message, &signature).unwrap())
+        });
+    }
+
+    fn schnorr_signature_randomize_pk(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+        let (pk, _) = SchnorrEdwards::keygen(&parameters, &mut rng).unwrap();
+        let randomness: [u8; 32] = rng.gen();
+
+        c.bench_function("SchnorrEdwardsAffine: Randomize PubKey", move |b| {
+            b.iter(|| SchnorrEdwards::randomize_public_key(&parameters, &pk, &randomness).unwrap())
+        });
+    }
+
+    fn schnorr_signature_randomize_signature(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+        let (_, sk) = SchnorrEdwards::keygen(&parameters, &mut rng).unwrap();
+        let randomness: [u8; 32] = rng.gen();
+        let message = [100u8; 128];
+        let signature = SchnorrEdwards::sign(&parameters, &sk, &message, &mut rng).unwrap();
+
+        c.bench_function("SchnorrEdwardsAffine: Randomize Signature", move |b| {
+            b.iter(|| {
+                SchnorrEdwards::randomize_signature(&parameters, &signature, &randomness).unwrap()
+            })
+        });
+    }
+    criterion_group! {
+        name = schnorr_sig_affine;
+        config = Criterion::default().sample_size(20);
+        targets = schnorr_signature_setup, schnorr_signature_keygen, schnorr_signature_sign,
+                  schnorr_signature_verify, schnorr_signature_randomize_pk, schnorr_signature_randomize_signature
+    }
+}
+
+mod projective {
+    use algebra::curves::edwards_bls12::EdwardsProjective as Edwards;
+    use blake2::Blake2s;
+    use criterion::Criterion;
+    use crypto_primitives::signature::{schnorr::*, SignatureScheme};
+    use rand::{self, Rng};
+
+    type SchnorrEdwards = SchnorrSignature<Edwards, Blake2s>;
+    fn schnorr_signature_setup(c: &mut Criterion) {
+        c.bench_function("SchnorrEdwardsProjective: Setup", move |b| {
+            b.iter(|| {
+                let mut rng = &mut rand::thread_rng();
+                SchnorrEdwards::setup(&mut rng).unwrap()
+            })
+        });
+    }
+
+    fn schnorr_signature_keygen(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+
+        c.bench_function("SchnorrEdwardsProjective: KeyGen", move |b| {
+            b.iter(|| {
+                let mut rng = &mut rand::thread_rng();
+                SchnorrEdwards::keygen(&parameters, &mut rng).unwrap()
+            })
+        });
+    }
+
+    fn schnorr_signature_sign(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+        let (_, sk) = SchnorrEdwards::keygen(&parameters, &mut rng).unwrap();
+        let message = [100u8; 128];
+
+        c.bench_function("SchnorrEdwardsProjective: Sign", move |b| {
+            b.iter(|| {
+                let mut rng = &mut rand::thread_rng();
+                SchnorrEdwards::sign(&parameters, &sk, &message, &mut rng).unwrap()
+            })
+        });
+    }
+
+    fn schnorr_signature_verify(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+        let (pk, sk) = SchnorrEdwards::keygen(&parameters, &mut rng).unwrap();
+        let message = [100u8; 128];
+        let signature = SchnorrEdwards::sign(&parameters, &sk, &message, &mut rng).unwrap();
+
+        c.bench_function("SchnorrEdwardsProjective: Verify", move |b| {
+            b.iter(|| SchnorrEdwards::verify(&parameters, &pk, &message, &signature).unwrap())
+        });
+    }
+
+    fn schnorr_signature_randomize_pk(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+        let (pk, _) = SchnorrEdwards::keygen(&parameters, &mut rng).unwrap();
+        let randomness: [u8; 32] = rng.gen();
+
+        c.bench_function("SchnorrEdwardsProjective: Randomize PubKey", move |b| {
+            b.iter(|| SchnorrEdwards::randomize_public_key(&parameters, &pk, &randomness).unwrap())
+        });
+    }
+
+    fn schnorr_signature_randomize_signature(c: &mut Criterion) {
+        let mut rng = &mut rand::thread_rng();
+        let parameters = SchnorrEdwards::setup(&mut rng).unwrap();
+        let (_, sk) = SchnorrEdwards::keygen(&parameters, &mut rng).unwrap();
+        let randomness: [u8; 32] = rng.gen();
+        let message = [100u8; 128];
+        let signature = SchnorrEdwards::sign(&parameters, &sk, &message, &mut rng).unwrap();
+
+        c.bench_function("SchnorrEdwardsProjective: Randomize Signature", move |b| {
+            b.iter(|| {
+                SchnorrEdwards::randomize_signature(&parameters, &signature, &randomness).unwrap()
+            })
+        });
+    }
+    criterion_group! {
+        name = schnorr_sig_projective;
+        config = Criterion::default().sample_size(20);
+        targets = schnorr_signature_setup, schnorr_signature_keygen, schnorr_signature_sign,
+                  schnorr_signature_verify, schnorr_signature_randomize_pk, schnorr_signature_randomize_signature
+    }
+}
+use crate::{affine::schnorr_sig_affine, projective::schnorr_sig_projective};
+criterion_main!(schnorr_sig_affine, schnorr_sig_projective);