Merge pull request #119 from hdevalence/feature/criterion

Use `criterion.rs` instead of libtest for benchmarks.

.travis.yml

@@ -10,8 +10,8 @@ env:
   - TEST_COMMAND=test EXTRA_FLAGS='' FEATURES='serde'
   - TEST_COMMAND=test EXTRA_FLAGS='' FEATURES='nightly'
   - TEST_COMMAND=test EXTRA_FLAGS='' FEATURES='yolocrypto nightly'
-  - TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='nightly bench'
-  - TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='yolocrypto nightly bench'
+  - TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='nightly'
+  - TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='yolocrypto nightly'
   - TEST_COMMAND=build EXTRA_FLAGS=--no-default-features FEATURES='' 
 
 matrix:
@@ -21,13 +21,13 @@ matrix:
     # run benchmarks, which causes dalek not to build on stable.  See
     # https://github.com/isislovecruft/curve25519-dalek/pull/38#issuecomment-286027562
     - rust: stable
-      env: TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='nightly bench'
+      env: TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='nightly'
     - rust: beta
-      env: TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='nightly bench'
+      env: TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='nightly'
     - rust: stable
-      env: TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='yolocrypto nightly bench'
+      env: TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='yolocrypto nightly'
     - rust: beta
-      env: TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='yolocrypto nightly bench'
+      env: TEST_COMMAND=bench EXTRA_FLAGS='' FEATURES='yolocrypto nightly'
     # Test nightly features, such as radix_51, only on nightly.
     - rust: stable
       env: TEST_COMMAND=test EXTRA_FLAGS='' FEATURES='nightly'

Cargo.toml

@@ -28,6 +28,11 @@ travis-ci = { repository = "dalek-cryptography/curve25519-dalek", branch = "mast
 [dev-dependencies]
 sha2 = "0.7"
 serde_cbor = "0.6"
+criterion = "0.2"
+
+[[bench]]
+name = "dalek_benchmarks"
+harness = false
 
 # Note: we generate precomputed tables by building the crate twice: once as
 # part of build.rs, and then once "for real".
@@ -60,7 +65,6 @@ default = ["std"]
 std = ["rand", "subtle/std"]
 alloc = []
 yolocrypto = ["avx2_backend"]
-bench = []
 # Radix-51 arithmetic using u128
 radix_51 = []
 # Include precomputed basepoint tables.  This is off by default so that build.rs can generate the tables, and then re-enabled by build.rs in the main-stage compilation.

README.md

@@ -66,13 +66,12 @@ Curve arithmetic is implemented using one of the following backends:
 * an experimental AVX2 backend, available using the `yolocrypto` feature when
   compiling for a target with `target_feature=+avx2`.
 
-By default, the benchmarks are not compiled without the `bench`
-feature.  Benchmarks can be run via:
+Benchmarks are run using [`criterion.rs`][criterion]:
 
 ```sh
-cargo bench --features="bench"                    # u32 backend
-cargo bench --features="bench nightly"            # u64 backend
-cargo bench --features="bench nightly yolocrypto" # u64 or avx2 if available
+cargo bench                                 # u32 backend
+cargo bench --features="nightly"            # u64 backend
+cargo bench --features="nightly yolocrypto" # u64 or avx2 if available
 ```
 
 The `yolocrypto` feature enables experimental features.  The name `yolocrypto`
@@ -120,3 +119,4 @@ contributions.
 [contributing]: https://github.com/dalek-cryptography/curve25519-dalek/blob/master/CONTRIBUTING.md
 [docs-external]: https://doc.dalek.rs/curve25519_dalek/
 [docs-internal]: https://doc-internal.dalek.rs/curve25519_dalek/
+[criterion]: https://github.com/japaric/criterion.rs

benches/dalek_benchmarks.rs

@@ -0,0 +1,207 @@
+#![allow(non_snake_case)]
+
+extern crate rand;
+use rand::OsRng;
+
+#[macro_use]
+extern crate criterion;
+
+use criterion::Criterion;
+
+extern crate curve25519_dalek;
+
+use curve25519_dalek::constants;
+use curve25519_dalek::scalar::Scalar;
+
+static MULTISCALAR_SIZES: [usize; 13] = [1, 2, 4, 8, 16, 32, 64, 128, 256, 384, 512, 768, 1024];
+
+mod edwards_benches {
+    use super::*;
+    use curve25519_dalek::edwards::{self, EdwardsPoint};
+
+    fn compress(c: &mut Criterion) {
+        let B = &constants::ED25519_BASEPOINT_POINT;
+        c.bench_function("EdwardsPoint compression", move |b| {
+            b.iter(|| B.compress())
+        });
+    }
+
+    fn decompress(c: &mut Criterion) {
+        let B_comp = &constants::ED25519_BASEPOINT_COMPRESSED;
+        c.bench_function("EdwardsPoint decompression", move |b| {
+            b.iter(|| B_comp.decompress().unwrap())
+        });
+    }
+
+    fn consttime_fixed_base_scalar_mul(c: &mut Criterion) {
+        let B = &constants::ED25519_BASEPOINT_TABLE;
+        let s = Scalar::from_u64(897987897).invert();
+        c.bench_function("Constant-time fixed-base scalar mul", move |b| {
+            b.iter(|| B * &s)
+        });
+    }
+
+    fn consttime_variable_base_scalar_mul(c: &mut Criterion) {
+        let B = &constants::ED25519_BASEPOINT_POINT;
+        let s = Scalar::from_u64(897987897).invert();
+        c.bench_function("Constant-time variable-base scalar mul", move |b| {
+            b.iter(|| B * &s)
+        });
+    }
+
+    fn vartime_double_base_scalar_mul(c: &mut Criterion) {
+        c.bench_function("Variable-time aA+bB, A variable, B fixed", |bench| {
+            let B = &constants::ED25519_BASEPOINT_POINT;
+            let a = Scalar::from_u64(298374928).invert();
+            let b = Scalar::from_u64(897987897).invert();
+            let A = B * (b * a);
+            bench.iter(|| edwards::vartime::double_scalar_mul_basepoint(&a, &A, &b));
+        });
+    }
+
+    fn consttime_multiscalar_mul(c: &mut Criterion) {
+        c.bench_function_over_inputs(
+            "Constant-time variable-base multiscalar multiplication",
+            |b, &&size| {
+                let mut rng = OsRng::new().unwrap();
+                let scalars: Vec<Scalar> = (0..size).map(|_| Scalar::random(&mut rng)).collect();
+                let points: Vec<EdwardsPoint> = scalars
+                    .iter()
+                    .map(|s| s * &constants::ED25519_BASEPOINT_TABLE)
+                    .collect();
+                b.iter(|| edwards::multiscalar_mul(&scalars, &points));
+            },
+            &MULTISCALAR_SIZES,
+        );
+    }
+
+    fn vartime_multiscalar_mul(c: &mut Criterion) {
+        c.bench_function_over_inputs(
+            "Variable-time variable-base multiscalar multiplication",
+            |b, &&size| {
+                let mut rng = OsRng::new().unwrap();
+                let scalars: Vec<Scalar> = (0..size).map(|_| Scalar::random(&mut rng)).collect();
+                let points: Vec<EdwardsPoint> = scalars
+                    .iter()
+                    .map(|s| s * &constants::ED25519_BASEPOINT_TABLE)
+                    .collect();
+                b.iter(|| edwards::vartime::multiscalar_mul(&scalars, &points));
+            },
+            &MULTISCALAR_SIZES,
+        );
+    }
+
+    criterion_group!{
+        name = edwards_benches;
+        config = Criterion::default();
+        targets =
+        compress,
+        decompress,
+        consttime_fixed_base_scalar_mul,
+        consttime_variable_base_scalar_mul,
+        vartime_double_base_scalar_mul,
+        consttime_multiscalar_mul,
+        vartime_multiscalar_mul,
+    }
+}
+
+mod ristretto_benches {
+    use super::*;
+    use curve25519_dalek::ristretto::RistrettoPoint;
+
+    fn compress(c: &mut Criterion) {
+        c.bench_function("RistrettoPoint compression", |b| {
+            let B = &constants::RISTRETTO_BASEPOINT_POINT;
+            b.iter(|| B.compress())
+        });
+    }
+
+    fn decompress(c: &mut Criterion) {
+        c.bench_function("RistrettoPoint decompression", |b| {
+            let B_comp = &constants::RISTRETTO_BASEPOINT_COMPRESSED;
+            b.iter(|| B_comp.decompress().unwrap())
+        });
+    }
+
+    fn double_and_compress_batch(c: &mut Criterion) {
+        c.bench_function_over_inputs(
+            "Batch Ristretto double-and-encode",
+            |b, &&size| {
+                let mut rng = OsRng::new().unwrap();
+                let points: Vec<RistrettoPoint> = (0..size)
+                    .map(|_| RistrettoPoint::random(&mut rng))
+                    .collect();
+                b.iter(|| RistrettoPoint::double_and_compress_batch(&points));
+            },
+            &MULTISCALAR_SIZES,
+        );
+    }
+
+    criterion_group!{
+        name = ristretto_benches;
+        config = Criterion::default();
+        targets =
+        compress,
+        decompress,
+        double_and_compress_batch,
+    }
+}
+
+mod montgomery_benches {
+    use super::*;
+
+    fn montgomery_ladder(c: &mut Criterion) {
+        c.bench_function("Montgomery pseudomultiplication", |b| {
+            let B = constants::X25519_BASEPOINT;
+            let s = Scalar::from_u64(897987897).invert();
+            b.iter(|| B * s);
+        });
+    }
+
+    criterion_group!{
+        name = montgomery_benches;
+        config = Criterion::default();
+        targets = montgomery_ladder,
+    }
+}
+
+mod scalar_benches {
+    use super::*;
+
+    fn scalar_inversion(c: &mut Criterion) {
+        c.bench_function("Scalar inversion", |b| {
+            let s = Scalar::from_u64(897987897).invert();
+            b.iter(|| s.invert());
+        });
+    }
+
+    fn batch_scalar_inversion(c: &mut Criterion) {
+        c.bench_function_over_inputs(
+            "Batch scalar inversion",
+            |b, &&size| {
+                let mut rng = OsRng::new().unwrap();
+                let scalars: Vec<Scalar> = (0..size).map(|_| Scalar::random(&mut rng)).collect();
+                b.iter(|| {
+                    let mut s = scalars.clone();
+                    Scalar::batch_invert(&mut s);
+                });
+            },
+            &MULTISCALAR_SIZES,
+        );
+    }
+
+    criterion_group!{
+        name = scalar_benches;
+        config = Criterion::default();
+        targets =
+        scalar_inversion,
+        batch_scalar_inversion,
+    }
+}
+
+criterion_main!(
+    scalar_benches::scalar_benches,
+    montgomery_benches::montgomery_benches,
+    ristretto_benches::ristretto_benches,
+    edwards_benches::edwards_benches,
+);

src/backend/avx2/edwards.rs

@@ -919,121 +919,3 @@ mod test {
         }
     }
 }
-
-#[cfg(all(test, feature = "bench"))]
-mod bench {
-    use test::Bencher;
-    use rand::OsRng;
-    use super::*;
-
-    use constants;
-    use scalar::Scalar;
-
-    #[bench]
-    fn conversion_into__avx2_format(b: &mut Bencher) {
-        let B = constants::ED25519_BASEPOINT_POINT;
-
-        b.iter(|| ExtendedPoint::from(B));
-    }
-
-    #[bench]
-    fn conversion_outof_avx2_format(b: &mut Bencher) {
-        let B = constants::ED25519_BASEPOINT_POINT;
-        let B_avx2 = ExtendedPoint::from(B);
-
-        b.iter(|| edwards::EdwardsPoint::from(B_avx2));
-    }
-
-    #[bench]
-    fn point_readdition(b: &mut Bencher) {
-        let B = &constants::ED25519_BASEPOINT_TABLE;
-        let P = ExtendedPoint::from(B * &Scalar::from_u64(83973422));
-        let Q = ExtendedPoint::from(B * &Scalar::from_u64(98932328));
-        let Q_cached = CachedPoint::from(Q);
-
-        b.iter(|| &P + &Q_cached );
-    }
-
-    #[bench]
-    fn point_addition(b: &mut Bencher) {
-        let B = &constants::ED25519_BASEPOINT_TABLE;
-        let P = ExtendedPoint::from(B * &Scalar::from_u64(83973422));
-        let Q = ExtendedPoint::from(B * &Scalar::from_u64(98932328));
-
-        b.iter(|| &P + &Q );
-    }
-
-    #[bench]
-    fn point_doubling(b: &mut Bencher) {
-        let B = &constants::ED25519_BASEPOINT_TABLE;
-        let P = ExtendedPoint::from(B * &Scalar::from_u64(83973422));
-
-        b.iter(|| P.double() );
-    }
-
-    #[bench]
-    fn scalar_mul(b: &mut Bencher) {
-        let B = &constants::ED25519_BASEPOINT_TABLE;
-        let P = ExtendedPoint::from(B * &Scalar::from_u64(83973422));
-        let s = Scalar::from_bits([233, 1, 233, 147, 113, 78, 244, 120, 40, 45, 103, 51, 224, 199, 189, 218, 96, 140, 211, 112, 39, 194, 73, 216, 173, 33, 102, 93, 76, 200, 84, 12]);
-
-        b.iter(|| &P * &s );
-    }
-
-    #[bench]
-    fn basepoint_table_creation(b: &mut Bencher) {
-        let B = ExtendedPoint::from(constants::ED25519_BASEPOINT_POINT);
-
-        b.iter(|| EdwardsBasepointTable::create(&B) );
-    }
-
-    #[bench]
-    fn basepoint_mult(b: &mut Bencher) {
-        let B = ExtendedPoint::from(constants::ED25519_BASEPOINT_POINT);
-        let table = EdwardsBasepointTable::create(&B);
-        let s = Scalar::from_bits([233, 1, 233, 147, 113, 78, 244, 120, 40, 45, 103, 51, 224, 199, 189, 218, 96, 140, 211, 112, 39, 194, 73, 216, 173, 33, 102, 93, 76, 200, 84, 12]);
-
-        b.iter(|| &table * &s );
-    }
-
-    #[bench]
-    fn ten_fold_scalar_mul(b: &mut Bencher) {
-        let mut csprng: OsRng = OsRng::new().unwrap();
-        // Create 10 random scalars
-        let scalars: Vec<_> = (0..10).map(|_| Scalar::random(&mut csprng)).collect();
-        // Create 10 points (by doing scalar mults)
-        let B = &constants::ED25519_BASEPOINT_TABLE;
-        let points: Vec<_> = scalars.iter().map(|s| B * s).collect();
-
-        b.iter(|| multiscalar_mul(&scalars, &points));
-    }
-
-    mod vartime {
-        use super::super::*;
-        use super::{constants, Bencher, OsRng};
-
-        #[bench]
-        fn double_scalar_mul(b: &mut Bencher) {
-            let mut csprng: OsRng = OsRng::new().unwrap();
-            // Create 2 random scalars
-            let s1 = Scalar::random(&mut csprng);
-            let s2 = Scalar::random(&mut csprng);
-            let P = &s1 * &constants::ED25519_BASEPOINT_TABLE;
-
-            b.iter(|| vartime::double_scalar_mul_basepoint(&s2, &P, &s1) );
-        }
-
-        #[bench]
-        fn ten_fold_scalar_mul(b: &mut Bencher) {
-            let mut csprng: OsRng = OsRng::new().unwrap();
-            // Create 10 random scalars
-            let scalars: Vec<_> = (0..10).map(|_| Scalar::random(&mut csprng)).collect();
-            // Create 10 points (by doing scalar mults)
-            let B = &constants::ED25519_BASEPOINT_TABLE;
-            let points: Vec<_> = scalars.iter().map(|s| B * s).collect();
-
-            b.iter(|| vartime::multiscalar_mul(&scalars, &points));
-        }
-    }
-}
-

src/backend/avx2/field.rs

@@ -671,20 +671,4 @@ mod test {
         assert_eq!(x2, splits[2]);
         assert_eq!(x3, splits[3]);
     }
-
 }
-
-#[cfg(all(test, feature = "bench"))]
-mod bench {
-    use test::Bencher;
-    use super::*;
-
-    #[bench]
-    fn multiply(b: &mut Bencher) {
-        let vec = FieldElement32x4::splat(&FieldElement64::zero());
-        let vecprime = vec.clone();
-
-        b.iter(|| &vec * &vecprime );
-    }
-}
-

src/backend/u32/scalar.rs

@@ -519,38 +519,3 @@ mod test {
         }
     }
 }
-
-
-#[cfg(all(test, feature = "bench"))]
-mod bench {
-    use test::Bencher;
-
-    use super::*;
-    use super::test::{X, Y};
-
-    #[bench]
-    fn square(b: &mut Bencher) {
-        b.iter(|| X.square());
-    }
-
-    #[bench]
-    fn mul(b: &mut Bencher) {
-        b.iter(|| Scalar32::mul(&X, &Y));
-    }
-
-    #[bench]
-    fn montgomery_square(b: &mut Bencher) {
-        b.iter(|| X.montgomery_square());
-    }
-
-    #[bench]
-    fn montgomery_mul(b: &mut Bencher) {
-        b.iter(|| Scalar32::montgomery_mul(&X, &Y));
-    }
-
-    #[bench]
-    fn from_bytes_wide(b: &mut Bencher) {
-        let bignum = [255u8; 64]; // 2^512 - 1
-        b.iter(|| Scalar32::from_bytes_wide(&bignum));
-    }
-}

src/backend/u64/scalar.rs

@@ -441,38 +441,3 @@ mod test {
         }
     }
 }
-
-
-#[cfg(all(test, feature = "bench"))]
-mod bench {
-    use test::Bencher;
-
-    use super::*;
-    use super::test::{X, Y};
-
-    #[bench]
-    fn square(b: &mut Bencher) {
-        b.iter(|| X.square());
-    }
-
-    #[bench]
-    fn mul(b: &mut Bencher) {
-        b.iter(|| Scalar64::mul(&X, &Y));
-    }
-
-    #[bench]
-    fn montgomery_square(b: &mut Bencher) {
-        b.iter(|| X.montgomery_square());
-    }
-
-    #[bench]
-    fn montgomery_mul(b: &mut Bencher) {
-        b.iter(|| Scalar64::montgomery_mul(&X, &Y));
-    }
-
-    #[bench]
-    fn from_bytes_wide(b: &mut Bencher) {
-        let bignum = [255u8; 64]; // 2^512 - 1
-        b.iter(|| Scalar64::from_bytes_wide(&bignum));
-    }
-}

src/edwards.rs

@@ -1384,153 +1384,3 @@ mod test {
         assert!(parsed.is_err());
     }
 }
-
-// ------------------------------------------------------------------------
-// Benchmarks
-// ------------------------------------------------------------------------
-
-#[cfg(all(test, feature = "bench"))]
-mod bench {
-    use rand::OsRng;
-    use test::Bencher;
-    use constants;
-    use super::*;
-    use super::test::A_SCALAR;
-
-    #[bench]
-    fn edwards_decompress(b: &mut Bencher) {
-        let B = &constants::ED25519_BASEPOINT_COMPRESSED;
-        b.iter(|| B.decompress().unwrap());
-    }
-
-    #[bench]
-    fn edwards_compress(b: &mut Bencher) {
-        let B = &constants::ED25519_BASEPOINT_POINT;
-        b.iter(|| B.compress());
-    }
-
-    #[bench]
-    #[cfg(feature="precomputed_tables")]
-    fn basepoint_mult(b: &mut Bencher) {
-        let B = &constants::ED25519_BASEPOINT_TABLE;
-        b.iter(|| B * &A_SCALAR);
-    }
-
-    #[bench]
-    fn scalar_mul(b: &mut Bencher) {
-        let B = &constants::ED25519_BASEPOINT_POINT;
-        b.iter(|| B * &A_SCALAR);
-    }
-
-    #[bench]
-    #[cfg(feature="precomputed_tables")]
-    fn bench_select_precomputed_point(b: &mut Bencher) {
-        use test::black_box;
-        let table = &constants::ED25519_BASEPOINT_TABLE.0[0];
-        b.iter(|| table.select(black_box(5)) );
-    }
-
-    #[bench]
-    fn add_extended_and_projective_niels_output_completed(b: &mut Bencher) {
-        let p1 = constants::ED25519_BASEPOINT_POINT;
-        let p2 = constants::ED25519_BASEPOINT_POINT.to_projective_niels();
-
-        b.iter(|| &p1 + &p2);
-    }
-
-    #[bench]
-    fn add_extended_and_projective_niels_output_extended(b: &mut Bencher) {
-        let p1 = constants::ED25519_BASEPOINT_POINT;
-        let p2 = constants::ED25519_BASEPOINT_POINT.to_projective_niels();
-
-        b.iter(|| (&p1 + &p2).to_extended());
-    }
-
-    #[bench]
-    fn add_extended_and_affine_niels_output_completed(b: &mut Bencher) {
-        let p1 = constants::ED25519_BASEPOINT_POINT;
-        let p2 = constants::ED25519_BASEPOINT_POINT.to_affine_niels();
-
-        b.iter(|| &p1 + &p2);
-    }
-
-    #[bench]
-    fn add_extended_and_affine_niels_output_extended(b: &mut Bencher) {
-        let p1 = constants::ED25519_BASEPOINT_POINT;
-        let p2 = constants::ED25519_BASEPOINT_POINT.to_affine_niels();
-
-        b.iter(|| (&p1 + &p2).to_extended());
-    }
-
-    #[bench]
-    fn projective_double_output_completed(b: &mut Bencher) {
-        let p1 = constants::ED25519_BASEPOINT_POINT.to_projective();
-
-        b.iter(|| p1.double());
-    }
-
-    #[bench]
-    fn extended_double_output_extended(b: &mut Bencher) {
-        let p1 = constants::ED25519_BASEPOINT_POINT;
-
-        b.iter(|| p1.double());
-    }
-
-    #[bench]
-    fn mul_by_cofactor(b: &mut Bencher) {
-        let p1 = constants::ED25519_BASEPOINT_POINT;
-
-        b.iter(|| p1.mul_by_cofactor());
-    }
-
-    #[bench]
-    #[cfg(feature="precomputed_tables")]
-    fn create_basepoint_table(b: &mut Bencher) {
-        let aB = &constants::ED25519_BASEPOINT_TABLE * &A_SCALAR;
-        b.iter(|| EdwardsBasepointTable::create(&aB));
-    }
-
-    #[bench]
-    #[cfg(feature="precomputed_tables")]
-    fn ten_fold_scalar_mul(b: &mut Bencher) {
-        let mut csprng: OsRng = OsRng::new().unwrap();
-        // Create 10 random scalars
-        let scalars: Vec<_> = (0..10).map(|_| Scalar::random(&mut csprng)).collect();
-        // Create 10 points (by doing scalar mults)
-        let B = &constants::ED25519_BASEPOINT_TABLE;
-        let points: Vec<_> = scalars.iter().map(|s| B * &s).collect();
-
-        b.iter(|| multiscalar_mul(&scalars, &points));
-    }
-
-    mod vartime {
-        use super::super::*;
-        use super::super::test::{A_SCALAR, B_SCALAR, A_TIMES_BASEPOINT};
-        use super::{Bencher, OsRng};
-
-        #[bench]
-        fn bench_double_scalar_mul_basepoint(b: &mut Bencher) {
-            let A = A_TIMES_BASEPOINT.decompress().unwrap();
-            b.iter(|| vartime::double_scalar_mul_basepoint(&A_SCALAR, &A, &B_SCALAR));
-        }
-
-        #[bench]
-        #[cfg(feature="precomputed_tables")]
-        fn ten_fold_scalar_mul(b: &mut Bencher) {
-            let mut csprng: OsRng = OsRng::new().unwrap();
-            // Create 10 random scalars
-            let scalars: Vec<_> = (0..10).map(|_| Scalar::random(&mut csprng)).collect();
-            // Create 10 points (by doing scalar mults)
-            let B = &constants::ED25519_BASEPOINT_TABLE;
-            let points: Vec<_> = scalars.iter().map(|s| B * &s).collect();
-
-            // XXX Currently Rust's benchmarking implementation doesn't
-            // allow you to specify a sequence of random inputs, but only
-            // many trials of the same input.
-            //
-            // Since this is a variable-time function, this means the
-            // benchmark is only useful as a ballpark measurement.
-            b.iter(|| vartime::multiscalar_mul(&scalars, &points));
-        }
-    }
-}

src/field.rs

@@ -497,50 +497,3 @@ mod test {
         }
     }
 }
-
-#[cfg(all(test, feature = "bench"))]
-mod bench {
-    use test::Bencher;
-
-    use super::*;
-    use super::test::A_BYTES;
-
-    #[bench]
-    fn fieldelement_a_mul_a(b: &mut Bencher) {
-        let a = FieldElement::from_bytes(&A_BYTES);
-        b.iter(|| &a * &a);
-    }
-
-    #[bench]
-    fn fieldelement_a_sq(b: &mut Bencher) {
-        let a = FieldElement::from_bytes(&A_BYTES);
-        b.iter(|| a.square());
-    }
-
-    #[bench]
-    fn fieldelement_a_inv(b: &mut Bencher) {
-        let a = FieldElement::from_bytes(&A_BYTES);
-        b.iter(|| a.invert());
-    }
-
-    #[bench]
-    fn batch_16_inv(b: &mut Bencher) {
-        let a = FieldElement::from_bytes(&A_BYTES);
-        let mut a_vec = vec![a; 16];
-        b.iter(|| FieldElement::batch_invert(&mut a_vec));
-    }
-
-    #[bench]
-    fn batch_128_inv(b: &mut Bencher) {
-        let a = FieldElement::from_bytes(&A_BYTES);
-        let mut a_vec = vec![a; 128];
-        b.iter(|| FieldElement::batch_invert(&mut a_vec));
-    }
-
-    #[bench]
-    fn batch_1024_inv(b: &mut Bencher) {
-        let a = FieldElement::from_bytes(&A_BYTES);
-        let mut a_vec = vec![a; 1024];
-        b.iter(|| FieldElement::batch_invert(&mut a_vec));
-    }
-}

src/lib.rs

@@ -11,7 +11,6 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 #![cfg_attr(feature = "alloc", feature(alloc))]
-#![cfg_attr(feature = "bench", feature(test))]
 
 #![cfg_attr(feature = "nightly", feature(i128_type))]
 #![cfg_attr(feature = "nightly", feature(cfg_target_feature))]
@@ -41,9 +40,6 @@ extern crate alloc;
 
 extern crate clear_on_drop;
 
-#[cfg(all(test, feature = "bench"))]
-extern crate test;
-
 #[cfg(feature = "yolocrypto")]
 extern crate stdsimd;
 

src/montgomery.rs

@@ -347,22 +347,3 @@ mod test {
         assert_eq!(result, expected.to_montgomery())
     }
 }
-
-#[cfg(all(test, feature = "bench"))]
-#[cfg(feature="precomputed_tables")]
-mod bench {
-    use rand::OsRng;
-    use constants::ED25519_BASEPOINT_TABLE;
-    use constants::X25519_BASEPOINT;
-    use test::Bencher;
-    use super::*;
-
-    #[bench]
-    fn montgomery_ladder(b: &mut Bencher) {
-        let mut csprng: OsRng = OsRng::new().unwrap();
-        let s: Scalar = Scalar::random(&mut csprng);
-        let P: MontgomeryPoint = (&Scalar::random(&mut csprng) * &ED25519_BASEPOINT_TABLE).to_montgomery();
-
-        b.iter(|| s * P);
-    }
-}

src/ristretto.rs

@@ -1499,54 +1499,3 @@ mod test {
         }
     }
 }
-
-#[cfg(all(test, feature = "bench"))]
-mod bench {
-    use rand::OsRng;
-    use test::Bencher;
-
-    use super::*;
-
-    #[bench]
-    #[cfg(feature="precomputed_tables")]
-    fn decompression(b: &mut Bencher) {
-        let mut rng = OsRng::new().unwrap();
-        let B = &constants::RISTRETTO_BASEPOINT_TABLE;
-        let P = B * &Scalar::random(&mut rng);
-        let P_compressed = P.compress();
-        b.iter(|| P_compressed.decompress().unwrap());
-    }
-
-    #[bench]
-    #[cfg(feature="precomputed_tables")]
-    fn compression(b: &mut Bencher) {
-        let mut rng = OsRng::new().unwrap();
-        let B = &constants::RISTRETTO_BASEPOINT_TABLE;
-        let P = B * &Scalar::random(&mut rng);
-        b.iter(|| P.compress());
-    }
-
-    fn double_and_compress_n_random_points(n: usize, b: &mut Bencher) {
-        let mut rng = OsRng::new().unwrap();
-
-        let points: Vec<RistrettoPoint> =
-            (0..n).map(|_| RistrettoPoint::random(&mut rng)).collect();
-
-        b.iter(|| RistrettoPoint::double_and_compress_batch(&points) );
-    }
-
-    #[bench]
-    fn double_and_compress_16_random_points(b: &mut Bencher) {
-        double_and_compress_n_random_points(16, b);
-    }
-
-    #[bench]
-    fn double_and_compress_128_random_points(b: &mut Bencher) {
-        double_and_compress_n_random_points(128, b);
-    }
-
-    #[bench]
-    fn double_and_compress_1024_random_points(b: &mut Bencher) {
-        double_and_compress_n_random_points(1024, b);
-    }
-}

src/scalar.rs

@@ -972,32 +972,3 @@ mod test {
         Scalar::batch_invert(&mut xs);
     }
 }
-
-#[cfg(all(test, feature = "bench"))]
-mod bench {
-    use rand::OsRng;
-    use test::Bencher;
-
-    use super::*;
-    use super::test::{X};
-
-    #[bench]
-    fn reduce(b: &mut Bencher) {
-        let unreduced = Scalar::from_bits([0xff; 32]);
-
-        b.iter(|| unreduced.reduce());
-    }
-
-    #[bench]
-    fn scalar_random(b: &mut Bencher) {
-        let mut csprng: OsRng = OsRng::new().unwrap();
-
-        b.iter(|| Scalar::random(&mut csprng));
-    }
-
-    #[bench]
-    fn invert(b: &mut Bencher) {
-        let x = X.unpack();
-        b.iter(|| x.invert());
-    }
-}