Merge pull request #15 from PopcornPaws/more-benchmarks

More benchmarks

benches/elgamal-plot.txt

@@ -1,5 +1,10 @@
 KZG-ELGAMAL - all units are [ms]
-gen 154.86,87.448,50.783,34.127,25.760,21.619,19.509,19.157,20.204,22.213,24.984,30.279,38.948
-vfy 27.796,31.336,43.210,77.583,136.80,264.56,511.48,1014.4,2119.5,4383.4,8630.0,17055.0,34149.0
+proof-gen 154.86,87.448,50.783,34.127,25.760,21.619,19.509,19.157,20.204,22.213,24.984,30.279,38.948
+proof-vfy 6.03,7.64,7.69,7.97,8.19,8.75,9.42,10.68,12.25,15.28,19.86,28.90,42.23
+
+range-proof-vfy 11.77,21.79,34.44,68.23,127.09,253.12,500.32,1004.9,1991.1,4020.1,8039.2,16084.0,32133.0
+split-scalar-encryption-vfy 1.92,3.64,5.66,10.92,40.83,80.35,160.01,319.60,639.45,1277.1,2550.7
+
+total-proof-vfy 27.796,31.336,43.210,77.583,136.80,264.56,511.48,1014.4,2119.5,4383.4,8630.0,17055.0,34149.0
 
 range proofs + encryptions are pre-computed in 89 seconds

benches/elgamal.rs

@@ -14,19 +14,26 @@ type Scalar = <BlsCurve as Pairing>::ScalarField;
 type SplitScalar = fde::encrypt::elgamal::SplitScalar<{ N }, Scalar>;
 type Elgamal = fde::encrypt::elgamal::ExponentialElgamal<<BlsCurve as Pairing>::G1>;
 
+// NOTE in case of 4096 scalars, we have 4096 * N split scalars
 fn bench_elgamal(c: &mut Criterion) {
     let mut group = c.benchmark_group("split-elgamal");
+    group.sample_size(10);
 
     let rng = &mut test_rng();
     let encryption_sk = Scalar::rand(rng);
     let encryption_pk = (G1Affine::generator() * encryption_sk).into_affine();
 
-    let scalars: Vec<Scalar> = (0..4096).map(|_| Scalar::rand(rng)).collect();
+    let scalars: Vec<Scalar> = (0..4096 * N).map(|_| Scalar::rand(rng)).collect();
 
     let mut ciphers = Vec::with_capacity(scalars.len());
     let mut split_ciphers = Vec::with_capacity(scalars.len());
 
-    scalars.iter().for_each(|scalar| {
+    println!("GENERATING ENCRYPTIONS...");
+    let now = std::time::Instant::now();
+    scalars.iter().enumerate().for_each(|(i, scalar)| {
+        if i % 256 == 0 {
+            println!("{}/{}", i, 4096 * N);
+        }
         let split_scalar = SplitScalar::from(*scalar);
         let (split_cipher, randomness) = split_scalar.encrypt::<Elgamal, _>(&encryption_pk, rng);
         let long_cipher = <Elgamal as EncryptionEngine>::encrypt_with_randomness(
@@ -38,22 +45,8 @@ fn bench_elgamal(c: &mut Criterion) {
         ciphers.push(long_cipher);
         split_ciphers.push(split_cipher);
     });
-
-    group.bench_function("encrypt-scalars", |b| {
-        b.iter(|| {
-            #[cfg(not(feature = "parallel"))]
-            scalars.iter().for_each(|scalar| {
-                let split_scalar = SplitScalar::from(*scalar);
-                split_scalar.encrypt::<Elgamal, _>(&encryption_pk, rng);
-            });
-            #[cfg(feature = "parallel")]
-            scalars.par_iter().for_each(|scalar| {
-                let rng = &mut test_rng();
-                let split_scalar = SplitScalar::from(*scalar);
-                split_scalar.encrypt::<Elgamal, _>(&encryption_pk, rng);
-            });
-        })
-    });
+    let elapsed = std::time::Instant::now().duration_since(now).as_secs();
+    println!("ELAPSED: {} [s]", elapsed);
 
     for i in 0..=12 {
         let subset_size = 1 << i;
@@ -63,15 +56,15 @@ fn bench_elgamal(c: &mut Criterion) {
                 #[cfg(not(feature = "parallel"))]
                 ciphers
                     .iter()
-                    .take(subset_size)
+                    .take(subset_size * N)
                     .zip(&split_ciphers)
                     .for_each(|(cipher, split_cipher)| {
                         assert!(cipher.check_encrypted_sum(split_cipher));
                     });
                 #[cfg(feature = "parallel")]
                 ciphers
                     .par_iter()
-                    .take(subset_size)
+                    .take(subset_size * N)
                     .zip(&split_ciphers)
                     .for_each(|(long_cipher, split_cipher)| {
                         assert!(long_cipher.check_encrypted_sum(split_cipher));

benches/range_proof.rs

@@ -1,9 +1,13 @@
 use ark_ec::pairing::Pairing;
-use ark_std::{test_rng, UniformRand};
+use ark_ff::PrimeField;
+use ark_std::{rand::RngCore, test_rng, UniformRand};
 use criterion::{criterion_group, criterion_main, Criterion};
 use fde::commit::kzg::Powers;
+#[cfg(feature = "parallel")]
+use rayon::prelude::*;
 
-const LOG_2_UPPER_BOUND: usize = 8; // 2^8
+const LOG_2_UPPER_BOUND: usize = 32;
+const N: usize = Scalar::MODULUS_BIT_SIZE as usize / fde::encrypt::elgamal::MAX_BITS + 1;
 
 type TestCurve = ark_bls12_381::Bls12_381;
 type TestHash = sha3::Keccak256;
@@ -33,5 +37,49 @@ fn bench_proof(c: &mut Criterion) {
     group.finish();
 }
 
-criterion_group!(benches, bench_proof);
+// NOTE in case of 4096 scalars, we need 4096 * N range proofs for each smaller split scalar
+fn bench_multiple_proofs(c: &mut Criterion) {
+    let mut group = c.benchmark_group("range-proof");
+    group.sample_size(10);
+
+    let rng = &mut test_rng();
+    let tau = Scalar::rand(rng);
+    let powers = Powers::<TestCurve>::unsafe_setup(tau, 4 * LOG_2_UPPER_BOUND);
+
+    let scalars: Vec<Scalar> = (0..4096 * N)
+        .map(|_| Scalar::from(rng.next_u32()))
+        .collect();
+    println!("GENERATING RANGE PROOFS...");
+    let now = std::time::Instant::now();
+    let proofs = scalars
+        .into_iter()
+        .enumerate()
+        .inspect(|(i, _)| {
+            if i % 256 == 0 {
+                println!("{}/{}", i, 4096 * N);
+            }
+        })
+        .map(|(_, z)| RangeProof::new(z, LOG_2_UPPER_BOUND, &powers, rng).unwrap())
+        .collect::<Vec<RangeProof>>();
+
+    let elapsed = std::time::Instant::now().duration_since(now).as_secs();
+    println!("ELAPSED: {} [s]", elapsed);
+
+    for i in 0..=12 {
+        let subset_size = 1 << i;
+        let range_proof_vfy_name = format!("range-proof-vfy-{}", subset_size);
+        group.bench_function(range_proof_vfy_name, |b| {
+            b.iter(|| {
+                #[cfg(not(feature = "parallel"))]
+                unimplemented!();
+                #[cfg(feature = "parallel")]
+                proofs.par_iter().take(subset_size * N).for_each(|proof| {
+                    assert!(proof.verify(LOG_2_UPPER_BOUND, &powers).is_ok());
+                });
+            })
+        });
+    }
+}
+
+criterion_group!(benches, bench_multiple_proofs, bench_proof);
 criterion_main!(benches);