In with the new.

benches/curve.rs

@@ -0,0 +1,235 @@
+#![feature(test)]
+#![allow(unused_mut)]
+
+extern crate rand;
+extern crate bellman;
+extern crate test;
+
+use bellman::curves::*;
+use bellman::curves::bls381::*;
+
+const SAMPLES: usize = 30;
+
+macro_rules! benchmark(
+    ($name:ident, $engine:ident, $input:ident($rng:ident) = $pre:expr; $post:expr) => (
+        #[bench]
+        fn $name(b: &mut test::Bencher) {
+            let $rng = &mut rand::thread_rng();
+            let $engine = &Bls381::new();
+            let $input: Vec<_> = (0..SAMPLES).map(|_| $pre).collect();
+
+            let mut c = 0;
+
+            b.iter(|| {
+                c += 1;
+
+                let mut $input = $input[c % SAMPLES].clone();
+
+                $post
+            })
+        }
+    )
+);
+
+benchmark!(g1_multiexp, e,
+    input(rng) = {
+        let mut g = G1::random(e, rng);
+        let mut a = G1::random(e, rng);
+        (
+            (0..1000).map(|_| {
+                g.add_assign(e, &a);
+                a.double(e);
+                g.to_affine(e)
+            }).collect::<Vec<_>>(),
+            (0..1000).map(|_| Fr::random(e, rng)).collect::<Vec<_>>(),
+        )
+    };
+
+    e.multiexp::<G1>(&input.0, &input.1)
+);
+
+benchmark!(g2_multiexp, e,
+    input(rng) = {
+        let mut g = G2::random(e, rng);
+        let mut a = G2::random(e, rng);
+        (
+            (0..1000).map(|_| {
+                g.add_assign(e, &a);
+                a.double(e);
+                g.to_affine(e)
+            }).collect::<Vec<_>>(),
+            (0..1000).map(|_| Fr::random(e, rng)).collect::<Vec<_>>(),
+        )
+    };
+
+    e.multiexp::<G2>(&input.0, &input.1)
+);
+
+benchmark!(full_pairing, e,
+    input(rng) = (G1::random(e, rng), G2::random(e, rng));
+
+    e.pairing(&input.0, &input.1)
+);
+
+benchmark!(g1_pairing_preparation, e,
+    input(rng) = G1::random(e, rng);
+
+    input.prepare(e)
+);
+
+benchmark!(g2_pairing_preparation, e,
+    input(rng) = G2::random(e, rng);
+
+    input.prepare(e)
+);
+
+benchmark!(miller_loop, e,
+    input(rng) = (G1::random(e, rng).prepare(e), G2::random(e, rng).prepare(e));
+
+    e.miller_loop([(&input.0, &input.1)].into_iter())
+);
+
+benchmark!(double_miller_loop, e,
+    input(rng) = (G1::random(e, rng).prepare(e), G2::random(e, rng).prepare(e), G1::random(e, rng).prepare(e), G2::random(e, rng).prepare(e));
+
+    e.miller_loop([
+        (&input.0, &input.1),
+        (&input.2, &input.3),
+    ].into_iter())
+);
+
+benchmark!(final_exponentiation, e,
+    input(rng) = e.miller_loop([
+        (&G1::random(e, rng).prepare(e), &G2::random(e, rng).prepare(e)),
+    ].into_iter());
+
+    e.final_exponentiation(&input)
+);
+
+macro_rules! group_tests(
+    (
+        $name:ident,
+        $mul:ident,
+        $mul_mixed:ident,
+        $add:ident
+    ) => {
+        benchmark!($mul, e,
+            input(rng) = ($name::random(e, rng), Fr::random(e, rng));
+
+            {input.0.mul_assign(e, &input.1); input.0}
+        );
+
+        benchmark!($mul_mixed, e,
+            input(rng) = ($name::random(e, rng).to_affine(e), Fr::random(e, rng));
+
+            {input.0.mul(e, &input.1)}
+        );
+
+        benchmark!($add, e,
+            input(rng) = ($name::random(e, rng), $name::random(e, rng));
+
+            {input.0.add_assign(e, &input.1); input.0}
+        );
+    };
+);
+
+macro_rules! field_tests(
+    (
+        @nosqrt,
+        $name:ident,
+        $mul:ident,
+        $square:ident,
+        $add:ident,
+        $inverse:ident
+    ) => {
+        benchmark!($mul, e,
+            input(rng) = ($name::random(e, rng), $name::random(e, rng));
+
+            {input.0.mul_assign(e, &input.1); input.0}
+        );
+
+        benchmark!($square, e,
+            input(rng) = $name::random(e, rng);
+
+            {input.square(e); input}
+        );
+
+        benchmark!($add, e,
+            input(rng) = ($name::random(e, rng), $name::random(e, rng));
+
+            {input.0.add_assign(e, &input.1); input.0}
+        );
+
+        benchmark!($inverse, e,
+            input(rng) = $name::random(e, rng);
+
+            {input.inverse(e)}
+        );
+    };
+    (
+        $name:ident,
+        $mul:ident,
+        $square:ident,
+        $add:ident,
+        $inverse:ident,
+        $sqrt:ident
+    ) => {
+        field_tests!(@nosqrt, $name, $mul, $square, $add, $inverse);
+
+        benchmark!($sqrt, e,
+            input(rng) = {let mut tmp = $name::random(e, rng); tmp.square(e); tmp};
+
+            {input.sqrt(e)}
+        );
+    };
+);
+
+field_tests!(
+    Fr,
+    fr_multiplication,
+    fr_squaring,
+    fr_addition,
+    fr_inverse,
+    fr_sqrt
+);
+
+field_tests!(
+    Fq,
+    fq_multiplication,
+    fq_squaring,
+    fq_addition,
+    fq_inverse,
+    fq_sqrt
+);
+
+field_tests!(
+    Fq2,
+    fq2_multiplication,
+    fq2_squaring,
+    fq2_addition,
+    fq2_inverse,
+    fq2_sqrt
+);
+
+field_tests!(
+    @nosqrt,
+    Fq12,
+    fq12_multiplication,
+    fq12_squaring,
+    fq12_addition,
+    fq12_inverse
+);
+
+group_tests!(
+    G1,
+    g1_multiplication,
+    g1_multiplication_mixed,
+    g1_addition
+);
+
+group_tests!(
+    G2,
+    g2_multiplication,
+    g2_multiplication_mixed,
+    g2_addition
+);