Move benchmarks under benches/ so tests compile on stable

Closes #36.

benches/bls12_381/ec.rs

@@ -0,0 +1,115 @@
+mod g1 {
+    use rand::{Rand, SeedableRng, XorShiftRng};
+
+    use pairing::CurveProjective;
+    use pairing::bls12_381::*;
+
+    #[bench]
+    fn bench_g1_mul_assign(b: &mut ::test::Bencher) {
+        const SAMPLES: usize = 1000;
+
+        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+        let v: Vec<(G1, Fr)> = (0..SAMPLES).map(|_| (G1::rand(&mut rng), Fr::rand(&mut rng))).collect();
+
+        let mut count = 0;
+        b.iter(|| {
+            let mut tmp = v[count].0;
+            tmp.mul_assign(v[count].1);
+            count = (count + 1) % SAMPLES;
+            tmp
+        });
+    }
+
+    #[bench]
+    fn bench_g1_add_assign(b: &mut ::test::Bencher) {
+        const SAMPLES: usize = 1000;
+
+        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+        let v: Vec<(G1, G1)> = (0..SAMPLES).map(|_| (G1::rand(&mut rng), G1::rand(&mut rng))).collect();
+
+        let mut count = 0;
+        b.iter(|| {
+            let mut tmp = v[count].0;
+            tmp.add_assign(&v[count].1);
+            count = (count + 1) % SAMPLES;
+            tmp
+        });
+    }
+
+    #[bench]
+    fn bench_g1_add_assign_mixed(b: &mut ::test::Bencher) {
+        const SAMPLES: usize = 1000;
+
+        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+        let v: Vec<(G1, G1Affine)> = (0..SAMPLES).map(|_| (G1::rand(&mut rng), G1::rand(&mut rng).into())).collect();
+
+        let mut count = 0;
+        b.iter(|| {
+            let mut tmp = v[count].0;
+            tmp.add_assign_mixed(&v[count].1);
+            count = (count + 1) % SAMPLES;
+            tmp
+        });
+    }
+}
+
+mod g2 {
+    use rand::{Rand, SeedableRng, XorShiftRng};
+
+    use pairing::CurveProjective;
+    use pairing::bls12_381::*;
+
+    #[bench]
+    fn bench_g2_mul_assign(b: &mut ::test::Bencher) {
+        const SAMPLES: usize = 1000;
+
+        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+        let v: Vec<(G2, Fr)> = (0..SAMPLES).map(|_| (G2::rand(&mut rng), Fr::rand(&mut rng))).collect();
+
+        let mut count = 0;
+        b.iter(|| {
+            let mut tmp = v[count].0;
+            tmp.mul_assign(v[count].1);
+            count = (count + 1) % SAMPLES;
+            tmp
+        });
+    }
+
+    #[bench]
+    fn bench_g2_add_assign(b: &mut ::test::Bencher) {
+        const SAMPLES: usize = 1000;
+
+        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+        let v: Vec<(G2, G2)> = (0..SAMPLES).map(|_| (G2::rand(&mut rng), G2::rand(&mut rng))).collect();
+
+        let mut count = 0;
+        b.iter(|| {
+            let mut tmp = v[count].0;
+            tmp.add_assign(&v[count].1);
+            count = (count + 1) % SAMPLES;
+            tmp
+        });
+    }
+
+    #[bench]
+    fn bench_g2_add_assign_mixed(b: &mut ::test::Bencher) {
+        const SAMPLES: usize = 1000;
+
+        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+        let v: Vec<(G2, G2Affine)> = (0..SAMPLES).map(|_| (G2::rand(&mut rng), G2::rand(&mut rng).into())).collect();
+
+        let mut count = 0;
+        b.iter(|| {
+            let mut tmp = v[count].0;
+            tmp.add_assign_mixed(&v[count].1);
+            count = (count + 1) % SAMPLES;
+            tmp
+        });
+    }
+}

benches/bls12_381/fq.rs

@@ -0,0 +1,258 @@
+use rand::{Rand, SeedableRng, XorShiftRng};
+
+use pairing::{Field, PrimeField, PrimeFieldRepr, SqrtField};
+use pairing::bls12_381::*;
+
+#[bench]
+fn bench_fq_repr_add_nocarry(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(FqRepr, FqRepr)> = (0..SAMPLES).map(|_| {
+        let mut tmp1 = FqRepr::rand(&mut rng);
+        let mut tmp2 = FqRepr::rand(&mut rng);
+        // Shave a few bits off to avoid overflow.
+        for _ in 0..3 {
+            tmp1.div2();
+            tmp2.div2();
+        }
+        (tmp1, tmp2)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.add_nocarry(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_repr_sub_noborrow(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(FqRepr, FqRepr)> = (0..SAMPLES).map(|_| {
+        let tmp1 = FqRepr::rand(&mut rng);
+        let mut tmp2 = tmp1;
+        // Ensure tmp2 is smaller than tmp1.
+        for _ in 0..10 {
+            tmp2.div2();
+        }
+        (tmp1, tmp2)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.sub_noborrow(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_repr_num_bits(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<FqRepr> = (0..SAMPLES).map(|_| FqRepr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = v[count].num_bits();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_repr_mul2(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<FqRepr> = (0..SAMPLES).map(|_| FqRepr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.mul2();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_repr_div2(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<FqRepr> = (0..SAMPLES).map(|_| FqRepr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.div2();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_add_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq, Fq)> = (0..SAMPLES).map(|_| (Fq::rand(&mut rng), Fq::rand(&mut rng))).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.add_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_sub_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq, Fq)> = (0..SAMPLES).map(|_| (Fq::rand(&mut rng), Fq::rand(&mut rng))).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.sub_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_mul_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq, Fq)> = (0..SAMPLES).map(|_| (Fq::rand(&mut rng), Fq::rand(&mut rng))).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.mul_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_square(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq> = (0..SAMPLES).map(|_| Fq::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.square();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_inverse(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq> = (0..SAMPLES).map(|_| Fq::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        count = (count + 1) % SAMPLES;
+        v[count].inverse()
+    });
+}
+
+#[bench]
+fn bench_fq_negate(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq> = (0..SAMPLES).map(|_| Fq::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.negate();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq_sqrt(b: &mut ::test::Bencher) {
+	const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq> = (0..SAMPLES).map(|_| {
+        let mut tmp = Fq::rand(&mut rng);
+        tmp.square();
+        tmp
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        count = (count + 1) % SAMPLES;
+        v[count].sqrt()
+    });
+}
+
+#[bench]
+fn bench_fq_into_repr(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq> = (0..SAMPLES).map(|_| {
+        Fq::rand(&mut rng)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        count = (count + 1) % SAMPLES;
+        v[count].into_repr()
+    });
+}
+
+#[bench]
+fn bench_fq_from_repr(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<FqRepr> = (0..SAMPLES).map(|_| {
+        Fq::rand(&mut rng).into_repr()
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        count = (count + 1) % SAMPLES;
+        Fq::from_repr(v[count])
+    });
+}

benches/bls12_381/fq12.rs

@@ -0,0 +1,98 @@
+use rand::{Rand, SeedableRng, XorShiftRng};
+
+use pairing::Field;
+use pairing::bls12_381::*;
+
+#[bench]
+fn bench_fq12_add_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq12, Fq12)> = (0..SAMPLES).map(|_| {
+        (Fq12::rand(&mut rng), Fq12::rand(&mut rng))
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.add_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq12_sub_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq12, Fq12)> = (0..SAMPLES).map(|_| {
+        (Fq12::rand(&mut rng), Fq12::rand(&mut rng))
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.sub_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq12_mul_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq12, Fq12)> = (0..SAMPLES).map(|_| {
+        (Fq12::rand(&mut rng), Fq12::rand(&mut rng))
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.mul_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq12_squaring(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq12> = (0..SAMPLES).map(|_| {
+        Fq12::rand(&mut rng)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.square();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq12_inverse(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq12> = (0..SAMPLES).map(|_| {
+        Fq12::rand(&mut rng)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = v[count].inverse();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}

benches/bls12_381/fq2.rs

@@ -0,0 +1,116 @@
+use rand::{Rand, SeedableRng, XorShiftRng};
+
+use pairing::{Field, SqrtField};
+use pairing::bls12_381::*;
+
+#[bench]
+fn bench_fq2_add_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq2, Fq2)> = (0..SAMPLES).map(|_| {
+        (Fq2::rand(&mut rng), Fq2::rand(&mut rng))
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.add_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq2_sub_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq2, Fq2)> = (0..SAMPLES).map(|_| {
+        (Fq2::rand(&mut rng), Fq2::rand(&mut rng))
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.sub_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq2_mul_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fq2, Fq2)> = (0..SAMPLES).map(|_| {
+        (Fq2::rand(&mut rng), Fq2::rand(&mut rng))
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.mul_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq2_squaring(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq2> = (0..SAMPLES).map(|_| {
+        Fq2::rand(&mut rng)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.square();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq2_inverse(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq2> = (0..SAMPLES).map(|_| {
+        Fq2::rand(&mut rng)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = v[count].inverse();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fq2_sqrt(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq2> = (0..SAMPLES).map(|_| {
+        Fq2::rand(&mut rng)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = v[count].sqrt();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}

benches/bls12_381/fr.rs

@@ -0,0 +1,258 @@
+use rand::{Rand, SeedableRng, XorShiftRng};
+
+use pairing::{Field, PrimeField, PrimeFieldRepr, SqrtField};
+use pairing::bls12_381::*;
+
+#[bench]
+fn bench_fr_repr_add_nocarry(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(FrRepr, FrRepr)> = (0..SAMPLES).map(|_| {
+        let mut tmp1 = FrRepr::rand(&mut rng);
+        let mut tmp2 = FrRepr::rand(&mut rng);
+        // Shave a few bits off to avoid overflow.
+        for _ in 0..3 {
+            tmp1.div2();
+            tmp2.div2();
+        }
+        (tmp1, tmp2)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.add_nocarry(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_repr_sub_noborrow(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(FrRepr, FrRepr)> = (0..SAMPLES).map(|_| {
+        let tmp1 = FrRepr::rand(&mut rng);
+        let mut tmp2 = tmp1;
+        // Ensure tmp2 is smaller than tmp1.
+        for _ in 0..10 {
+            tmp2.div2();
+        }
+        (tmp1, tmp2)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.sub_noborrow(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_repr_num_bits(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<FrRepr> = (0..SAMPLES).map(|_| FrRepr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = v[count].num_bits();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_repr_mul2(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<FrRepr> = (0..SAMPLES).map(|_| FrRepr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.mul2();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_repr_div2(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<FrRepr> = (0..SAMPLES).map(|_| FrRepr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.div2();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_add_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fr, Fr)> = (0..SAMPLES).map(|_| (Fr::rand(&mut rng), Fr::rand(&mut rng))).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.add_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_sub_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fr, Fr)> = (0..SAMPLES).map(|_| (Fr::rand(&mut rng), Fr::rand(&mut rng))).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.sub_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_mul_assign(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(Fr, Fr)> = (0..SAMPLES).map(|_| (Fr::rand(&mut rng), Fr::rand(&mut rng))).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count].0;
+        tmp.mul_assign(&v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_square(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fr> = (0..SAMPLES).map(|_| Fr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.square();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_inverse(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fr> = (0..SAMPLES).map(|_| Fr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        count = (count + 1) % SAMPLES;
+        v[count].inverse()
+    });
+}
+
+#[bench]
+fn bench_fr_negate(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fr> = (0..SAMPLES).map(|_| Fr::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let mut tmp = v[count];
+        tmp.negate();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_fr_sqrt(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fr> = (0..SAMPLES).map(|_| {
+        let mut tmp = Fr::rand(&mut rng);
+        tmp.square();
+        tmp
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        count = (count + 1) % SAMPLES;
+        v[count].sqrt()
+    });
+}
+
+#[bench]
+fn bench_fr_into_repr(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fr> = (0..SAMPLES).map(|_| {
+        Fr::rand(&mut rng)
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        count = (count + 1) % SAMPLES;
+        v[count].into_repr()
+    });
+}
+
+#[bench]
+fn bench_fr_from_repr(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<FrRepr> = (0..SAMPLES).map(|_| {
+        Fr::rand(&mut rng).into_repr()
+    }).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        count = (count + 1) % SAMPLES;
+        Fr::from_repr(v[count])
+    });
+}

benches/bls12_381/mod.rs

@@ -0,0 +1,105 @@
+mod fq;
+mod fr;
+mod fq2;
+mod fq12;
+mod ec;
+
+use rand::{Rand, SeedableRng, XorShiftRng};
+
+use pairing::{Engine, CurveAffine};
+use pairing::bls12_381::*;
+
+#[bench]
+fn bench_pairing_g1_preparation(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<G1> = (0..SAMPLES).map(|_| G1::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = G1Affine::from(v[count]).prepare();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_pairing_g2_preparation(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<G2> = (0..SAMPLES).map(|_| G2::rand(&mut rng)).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = G2Affine::from(v[count]).prepare();
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_pairing_miller_loop(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(G1Prepared, G2Prepared)> = (0..SAMPLES).map(|_|
+        (
+            G1Affine::from(G1::rand(&mut rng)).prepare(),
+            G2Affine::from(G2::rand(&mut rng)).prepare()
+        )
+    ).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = Bls12::miller_loop(&[(&v[count].0, &v[count].1)]);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_pairing_final_exponentiation(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<Fq12> = (0..SAMPLES).map(|_|
+        (
+            G1Affine::from(G1::rand(&mut rng)).prepare(),
+            G2Affine::from(G2::rand(&mut rng)).prepare()
+        )
+    ).map(|(ref p, ref q)| Bls12::miller_loop(&[(p, q)])).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = Bls12::final_exponentiation(&v[count]);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}
+
+#[bench]
+fn bench_pairing_full(b: &mut ::test::Bencher) {
+    const SAMPLES: usize = 1000;
+
+    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+    let v: Vec<(G1, G2)> = (0..SAMPLES).map(|_|
+        (
+            G1::rand(&mut rng),
+            G2::rand(&mut rng)
+        )
+    ).collect();
+
+    let mut count = 0;
+    b.iter(|| {
+        let tmp = Bls12::pairing(v[count].0, v[count].1);
+        count = (count + 1) % SAMPLES;
+        tmp
+    });
+}

benches/pairing_benches.rs

@@ -0,0 +1,21 @@
+// `clippy` is a code linting tool for improving code quality by catching
+// common mistakes or strange code patterns. If the `clippy` feature is
+// provided, it is enabled and all compiler warnings are prohibited.
+#![cfg_attr(feature = "clippy", deny(warnings))]
+#![cfg_attr(feature = "clippy", feature(plugin))]
+#![cfg_attr(feature = "clippy", plugin(clippy))]
+#![cfg_attr(feature = "clippy", allow(inline_always))]
+#![cfg_attr(feature = "clippy", allow(too_many_arguments))]
+#![cfg_attr(feature = "clippy", allow(unreadable_literal))]
+
+// The compiler provides `test` (on nightly) for benchmarking tools, but
+// it's hidden behind a feature flag. Enable it if we're testing.
+#![cfg_attr(test, feature(test))]
+#[cfg(test)]
+extern crate test;
+
+extern crate rand;
+
+extern crate pairing;
+
+mod bls12_381;

src/bls12_381/ec.rs

@@ -1092,60 +1092,6 @@ pub mod g1 {
     fn g1_curve_tests() {
         ::tests::curve::curve_tests::<G1>();
     }
-
-    #[cfg(test)]
-    use rand::{SeedableRng, XorShiftRng};
-
-    #[bench]
-    fn bench_g1_mul_assign(b: &mut ::test::Bencher) {
-        const SAMPLES: usize = 1000;
-
-        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-        let v: Vec<(G1, Fr)> = (0..SAMPLES).map(|_| (G1::rand(&mut rng), Fr::rand(&mut rng))).collect();
-
-        let mut count = 0;
-        b.iter(|| {
-            let mut tmp = v[count].0;
-            tmp.mul_assign(v[count].1);
-            count = (count + 1) % SAMPLES;
-            tmp
-        });
-    }
-
-    #[bench]
-    fn bench_g1_add_assign(b: &mut ::test::Bencher) {
-        const SAMPLES: usize = 1000;
-
-        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-        let v: Vec<(G1, G1)> = (0..SAMPLES).map(|_| (G1::rand(&mut rng), G1::rand(&mut rng))).collect();
-
-        let mut count = 0;
-        b.iter(|| {
-            let mut tmp = v[count].0;
-            tmp.add_assign(&v[count].1);
-            count = (count + 1) % SAMPLES;
-            tmp
-        });
-    }
-
-    #[bench]
-    fn bench_g1_add_assign_mixed(b: &mut ::test::Bencher) {
-        const SAMPLES: usize = 1000;
-
-        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-        let v: Vec<(G1, G1Affine)> = (0..SAMPLES).map(|_| (G1::rand(&mut rng), G1::rand(&mut rng).into())).collect();
-
-        let mut count = 0;
-        b.iter(|| {
-            let mut tmp = v[count].0;
-            tmp.add_assign_mixed(&v[count].1);
-            count = (count + 1) % SAMPLES;
-            tmp
-        });
-    }
 }
 
 pub mod g2 {
@@ -1679,60 +1625,6 @@ pub mod g2 {
     fn g2_curve_tests() {
         ::tests::curve::curve_tests::<G2>();
     }
-
-    #[cfg(test)]
-    use rand::{SeedableRng, XorShiftRng};
-
-    #[bench]
-    fn bench_g2_mul_assign(b: &mut ::test::Bencher) {
-        const SAMPLES: usize = 1000;
-
-        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-        let v: Vec<(G2, Fr)> = (0..SAMPLES).map(|_| (G2::rand(&mut rng), Fr::rand(&mut rng))).collect();
-
-        let mut count = 0;
-        b.iter(|| {
-            let mut tmp = v[count].0;
-            tmp.mul_assign(v[count].1);
-            count = (count + 1) % SAMPLES;
-            tmp
-        });
-    }
-
-    #[bench]
-    fn bench_g2_add_assign(b: &mut ::test::Bencher) {
-        const SAMPLES: usize = 1000;
-
-        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-        let v: Vec<(G2, G2)> = (0..SAMPLES).map(|_| (G2::rand(&mut rng), G2::rand(&mut rng))).collect();
-
-        let mut count = 0;
-        b.iter(|| {
-            let mut tmp = v[count].0;
-            tmp.add_assign(&v[count].1);
-            count = (count + 1) % SAMPLES;
-            tmp
-        });
-    }
-
-    #[bench]
-    fn bench_g2_add_assign_mixed(b: &mut ::test::Bencher) {
-        const SAMPLES: usize = 1000;
-
-        let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-        let v: Vec<(G2, G2Affine)> = (0..SAMPLES).map(|_| (G2::rand(&mut rng), G2::rand(&mut rng).into())).collect();
-
-        let mut count = 0;
-        b.iter(|| {
-            let mut tmp = v[count].0;
-            tmp.add_assign_mixed(&v[count].1);
-            count = (count + 1) % SAMPLES;
-            tmp
-        });
-    }
 }
 
 pub use self::g1::*;

src/bls12_381/fq.rs

@@ -1138,107 +1138,6 @@ fn test_fq_repr_add_nocarry() {
     assert!(!x.add_nocarry(&FqRepr::from(1)));
 }
 
-#[bench]
-fn bench_fq_repr_add_nocarry(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(FqRepr, FqRepr)> = (0..SAMPLES).map(|_| {
-        let mut tmp1 = FqRepr::rand(&mut rng);
-        let mut tmp2 = FqRepr::rand(&mut rng);
-        // Shave a few bits off to avoid overflow.
-        for _ in 0..3 {
-            tmp1.div2();
-            tmp2.div2();
-        }
-        (tmp1, tmp2)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.add_nocarry(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq_repr_sub_noborrow(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(FqRepr, FqRepr)> = (0..SAMPLES).map(|_| {
-        let tmp1 = FqRepr::rand(&mut rng);
-        let mut tmp2 = tmp1;
-        // Ensure tmp2 is smaller than tmp1.
-        for _ in 0..10 {
-            tmp2.div2();
-        }
-        (tmp1, tmp2)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.sub_noborrow(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq_repr_num_bits(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<FqRepr> = (0..SAMPLES).map(|_| FqRepr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = v[count].num_bits();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq_repr_mul2(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<FqRepr> = (0..SAMPLES).map(|_| FqRepr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.mul2();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq_repr_div2(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<FqRepr> = (0..SAMPLES).map(|_| FqRepr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.div2();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn test_fq_is_valid() {
     let mut a = Fq(MODULUS);
@@ -1350,40 +1249,6 @@ fn test_fq_sub_assign() {
     }
 }
 
-#[bench]
-fn bench_fq_add_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq, Fq)> = (0..SAMPLES).map(|_| (Fq::rand(&mut rng), Fq::rand(&mut rng))).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.add_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq_sub_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq, Fq)> = (0..SAMPLES).map(|_| (Fq::rand(&mut rng), Fq::rand(&mut rng))).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.sub_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn test_fq_mul_assign() {
     let mut tmp = Fq(FqRepr([0xcc6200000020aa8a, 0x422800801dd8001a, 0x7f4f5e619041c62c, 0x8a55171ac70ed2ba, 0x3f69cc3a3d07d58b, 0xb972455fd09b8ef]));
@@ -1433,23 +1298,6 @@ fn test_fq_mul_assign() {
     }
 }
 
-#[bench]
-fn bench_fq_mul_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq, Fq)> = (0..SAMPLES).map(|_| (Fq::rand(&mut rng), Fq::rand(&mut rng))).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.mul_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn test_fq_squaring() {
     let mut a = Fq(FqRepr([0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x19ffffffffffffff]));
@@ -1473,23 +1321,6 @@ fn test_fq_squaring() {
     }
 }
 
-#[bench]
-fn bench_fq_square(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq> = (0..SAMPLES).map(|_| Fq::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.square();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn test_fq_inverse() {
     assert!(Fq::zero().inverse().is_none());
@@ -1507,21 +1338,6 @@ fn test_fq_inverse() {
     }
 }
 
-#[bench]
-fn bench_fq_inverse(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq> = (0..SAMPLES).map(|_| Fq::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        count = (count + 1) % SAMPLES;
-        v[count].inverse()
-    });
-}
-
 #[test]
 fn test_fq_double() {
     let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
@@ -1558,24 +1374,6 @@ fn test_fq_negate() {
     }
 }
 
-#[bench]
-fn bench_fq_negate(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq> = (0..SAMPLES).map(|_| Fq::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.negate();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-
 #[test]
 fn test_fq_pow() {
     let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
@@ -1631,25 +1429,6 @@ fn test_fq_sqrt() {
     }
 }
 
-#[bench]
-fn bench_fq_sqrt(b: &mut ::test::Bencher) {
-	const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq> = (0..SAMPLES).map(|_| {
-        let mut tmp = Fq::rand(&mut rng);
-        tmp.square();
-        tmp
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        count = (count + 1) % SAMPLES;
-        v[count].sqrt()
-    });
-}
-
 #[test]
 fn test_fq_from_into_repr() {
     // q + 1 should not be in the field
@@ -1684,40 +1463,6 @@ fn test_fq_from_into_repr() {
     }
 }
 
-#[bench]
-fn bench_fq_into_repr(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq> = (0..SAMPLES).map(|_| {
-        Fq::rand(&mut rng)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        count = (count + 1) % SAMPLES;
-        v[count].into_repr()
-    });
-}
-
-#[bench]
-fn bench_fq_from_repr(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<FqRepr> = (0..SAMPLES).map(|_| {
-        Fq::rand(&mut rng).into_repr()
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        count = (count + 1) % SAMPLES;
-        Fq::from_repr(v[count])
-    });
-}
-
 #[test]
 fn test_fq_repr_display() {
     assert_eq!(

src/bls12_381/fq12.rs

@@ -193,100 +193,6 @@ fn test_fq12_mul_by_014() {
     }
 }
 
-#[bench]
-fn bench_fq12_add_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq12, Fq12)> = (0..SAMPLES).map(|_| {
-        (Fq12::rand(&mut rng), Fq12::rand(&mut rng))
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.add_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq12_sub_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq12, Fq12)> = (0..SAMPLES).map(|_| {
-        (Fq12::rand(&mut rng), Fq12::rand(&mut rng))
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.sub_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq12_mul_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq12, Fq12)> = (0..SAMPLES).map(|_| {
-        (Fq12::rand(&mut rng), Fq12::rand(&mut rng))
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.mul_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq12_squaring(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq12> = (0..SAMPLES).map(|_| {
-        Fq12::rand(&mut rng)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.square();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq12_inverse(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq12> = (0..SAMPLES).map(|_| {
-        Fq12::rand(&mut rng)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = v[count].inverse();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn fq12_field_tests() {
     use ::PrimeField;

src/bls12_381/fq2.rs

@@ -463,118 +463,6 @@ fn test_fq2_mul_nonresidue() {
     }
 }
 
-#[bench]
-fn bench_fq2_add_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq2, Fq2)> = (0..SAMPLES).map(|_| {
-        (Fq2::rand(&mut rng), Fq2::rand(&mut rng))
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.add_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq2_sub_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq2, Fq2)> = (0..SAMPLES).map(|_| {
-        (Fq2::rand(&mut rng), Fq2::rand(&mut rng))
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.sub_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq2_mul_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fq2, Fq2)> = (0..SAMPLES).map(|_| {
-        (Fq2::rand(&mut rng), Fq2::rand(&mut rng))
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.mul_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq2_squaring(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq2> = (0..SAMPLES).map(|_| {
-        Fq2::rand(&mut rng)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.square();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq2_inverse(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq2> = (0..SAMPLES).map(|_| {
-        Fq2::rand(&mut rng)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = v[count].inverse();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fq2_sqrt(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq2> = (0..SAMPLES).map(|_| {
-        Fq2::rand(&mut rng)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = v[count].sqrt();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn fq2_field_tests() {
     use ::PrimeField;

src/bls12_381/fr.rs

@@ -854,107 +854,6 @@ fn test_fr_repr_add_nocarry() {
     assert!(!x.add_nocarry(&FrRepr::from(1)));
 }
 
-#[bench]
-fn bench_fr_repr_add_nocarry(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(FrRepr, FrRepr)> = (0..SAMPLES).map(|_| {
-        let mut tmp1 = FrRepr::rand(&mut rng);
-        let mut tmp2 = FrRepr::rand(&mut rng);
-        // Shave a few bits off to avoid overflow.
-        for _ in 0..3 {
-            tmp1.div2();
-            tmp2.div2();
-        }
-        (tmp1, tmp2)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.add_nocarry(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fr_repr_sub_noborrow(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(FrRepr, FrRepr)> = (0..SAMPLES).map(|_| {
-        let tmp1 = FrRepr::rand(&mut rng);
-        let mut tmp2 = tmp1;
-        // Ensure tmp2 is smaller than tmp1.
-        for _ in 0..10 {
-            tmp2.div2();
-        }
-        (tmp1, tmp2)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.sub_noborrow(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fr_repr_num_bits(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<FrRepr> = (0..SAMPLES).map(|_| FrRepr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = v[count].num_bits();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fr_repr_mul2(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<FrRepr> = (0..SAMPLES).map(|_| FrRepr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.mul2();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fr_repr_div2(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<FrRepr> = (0..SAMPLES).map(|_| FrRepr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.div2();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn test_fr_is_valid() {
     let mut a = Fr(MODULUS);
@@ -1066,40 +965,6 @@ fn test_fr_sub_assign() {
     }
 }
 
-#[bench]
-fn bench_fr_add_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fr, Fr)> = (0..SAMPLES).map(|_| (Fr::rand(&mut rng), Fr::rand(&mut rng))).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.add_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_fr_sub_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fr, Fr)> = (0..SAMPLES).map(|_| (Fr::rand(&mut rng), Fr::rand(&mut rng))).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.sub_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn test_fr_mul_assign() {
     let mut tmp = Fr(FrRepr([0x6b7e9b8faeefc81a, 0xe30a8463f348ba42, 0xeff3cb67a8279c9c, 0x3d303651bd7c774d]));
@@ -1149,23 +1014,6 @@ fn test_fr_mul_assign() {
     }
 }
 
-#[bench]
-fn bench_fr_mul_assign(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(Fr, Fr)> = (0..SAMPLES).map(|_| (Fr::rand(&mut rng), Fr::rand(&mut rng))).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count].0;
-        tmp.mul_assign(&v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
 #[test]
 fn test_fr_squaring() {
     let mut a = Fr(FrRepr([0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x73eda753299d7d47]));
@@ -1189,24 +1037,6 @@ fn test_fr_squaring() {
     }
 }
 
-#[bench]
-fn bench_fr_square(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fr> = (0..SAMPLES).map(|_| Fr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.square();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-
 #[test]
 fn test_fr_inverse() {
     assert!(Fr::zero().inverse().is_none());
@@ -1224,21 +1054,6 @@ fn test_fr_inverse() {
     }
 }
 
-#[bench]
-fn bench_fr_inverse(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fr> = (0..SAMPLES).map(|_| Fr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        count = (count + 1) % SAMPLES;
-        v[count].inverse()
-    });
-}
-
 #[test]
 fn test_fr_double() {
     let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
@@ -1275,24 +1090,6 @@ fn test_fr_negate() {
     }
 }
 
-#[bench]
-fn bench_fr_negate(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fr> = (0..SAMPLES).map(|_| Fr::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let mut tmp = v[count];
-        tmp.negate();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-
 #[test]
 fn test_fr_pow() {
     let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
@@ -1348,25 +1145,6 @@ fn test_fr_sqrt() {
     }
 }
 
-#[bench]
-fn bench_fr_sqrt(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fr> = (0..SAMPLES).map(|_| {
-        let mut tmp = Fr::rand(&mut rng);
-        tmp.square();
-        tmp
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        count = (count + 1) % SAMPLES;
-        v[count].sqrt()
-    });
-}
-
 #[test]
 fn test_fr_from_into_repr() {
     // r + 1 should not be in the field
@@ -1401,40 +1179,6 @@ fn test_fr_from_into_repr() {
     }
 }
 
-#[bench]
-fn bench_fr_into_repr(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fr> = (0..SAMPLES).map(|_| {
-        Fr::rand(&mut rng)
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        count = (count + 1) % SAMPLES;
-        v[count].into_repr()
-    });
-}
-
-#[bench]
-fn bench_fr_from_repr(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<FrRepr> = (0..SAMPLES).map(|_| {
-        Fr::rand(&mut rng).into_repr()
-    }).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        count = (count + 1) % SAMPLES;
-        Fr::from_repr(v[count])
-    });
-}
-
 #[test]
 fn test_fr_repr_display() {
     assert_eq!(

src/bls12_381/mod.rs

@@ -364,101 +364,3 @@ impl G2Prepared {
 fn bls12_engine_tests() {
     ::tests::engine::engine_tests::<Bls12>();
 }
-
-#[cfg(test)]
-use rand::{Rand, SeedableRng, XorShiftRng};
-
-#[bench]
-fn bench_pairing_g1_preparation(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<G1> = (0..SAMPLES).map(|_| G1::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = G1Affine::from(v[count]).prepare();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_pairing_g2_preparation(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<G2> = (0..SAMPLES).map(|_| G2::rand(&mut rng)).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = G2Affine::from(v[count]).prepare();
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_pairing_miller_loop(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(G1Prepared, G2Prepared)> = (0..SAMPLES).map(|_|
-        (
-            G1Affine::from(G1::rand(&mut rng)).prepare(),
-            G2Affine::from(G2::rand(&mut rng)).prepare()
-        )
-    ).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = Bls12::miller_loop(&[(&v[count].0, &v[count].1)]);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_pairing_final_exponentiation(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<Fq12> = (0..SAMPLES).map(|_|
-        (
-            G1Affine::from(G1::rand(&mut rng)).prepare(),
-            G2Affine::from(G2::rand(&mut rng)).prepare()
-        )
-    ).map(|(ref p, ref q)| Bls12::miller_loop(&[(p, q)])).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = Bls12::final_exponentiation(&v[count]);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}
-
-#[bench]
-fn bench_pairing_full(b: &mut ::test::Bencher) {
-    const SAMPLES: usize = 1000;
-
-    let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
-
-    let v: Vec<(G1, G2)> = (0..SAMPLES).map(|_|
-        (
-            G1::rand(&mut rng),
-            G2::rand(&mut rng)
-        )
-    ).collect();
-
-    let mut count = 0;
-    b.iter(|| {
-        let tmp = Bls12::pairing(v[count].0, v[count].1);
-        count = (count + 1) % SAMPLES;
-        tmp
-    });
-}

src/lib.rs

@@ -16,12 +16,6 @@
 // Force public structures to implement Debug
 #![deny(missing_debug_implementations)]
 
-// The compiler provides `test` (on nightly) for benchmarking tools, but
-// it's hidden behind a feature flag. Enable it if we're testing.
-#![cfg_attr(test, feature(test))]
-#[cfg(test)]
-extern crate test;
-
 extern crate rand;
 extern crate byteorder;