Adding benchmark and Weighted Alba

.github/workflows/rust-ci.yml

@@ -0,0 +1,70 @@
+name: Rust CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+      - name: Uninstall pre-installed tools
+        run: |
+          rm -f ~/.cargo/bin/rust-analyzer
+          rm -f ~/.cargo/bin/rustfmt
+          rm -f ~/.cargo/bin/cargo-fmt
+
+      - name: Update Rust toolchain and components
+        run: |
+          rustup update
+          rustup component add rustfmt
+          rustup component add clippy
+
+      - name: Build
+        run: cargo build --verbose
+        working-directory: caledonia
+
+      - name: Verify target directory exists
+        run: |
+          echo "Checking if target directory exists and is not empty"
+          ls -la caledonia/target
+
+      - name: Run tests
+        run: cargo test --verbose
+        working-directory: caledonia
+
+#      - name: Run Clippy
+#        run: cargo clippy -- -D warnings
+#        working-directory: caledonia
+
+      - name: Check format
+        run: cargo fmt -- --check
+        working-directory: caledonia
+
+      - name: Build and test documentation
+        run: cargo doc --no-deps --verbose
+        working-directory: caledonia
+
+      - name: Cache Cargo registry
+        uses: actions/cache@v3
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-registry-
+
+      - name: Cache Cargo build
+        uses: actions/cache@v3
+        with:
+          path: caledonia/target
+          key: ${{ runner.os }}-cargo-build-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-build-

caledonia/.gitignore

@@ -0,0 +1 @@
+target/

caledonia/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "caledonia"
+version = "0.1.0"
+edition = "2021"
+description = "A Rust implementation of Approximate Lower Bound Arguments (ALBAs)."
+categories = ["cryptography"]
+include = ["**/*.rs", "Cargo.toml", "README.md", ".gitignore"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+vrf_dalek = {path = "./vrf"}
+blake2 = "0.10.6"
+rand_core = "0.6.4"
+rayon = "1.10.0"
+
+[dev-dependencies]
+rand = "0.8.5"
+rand_chacha = "0.3.1"
+criterion = { version = "0.5.1", features = ["html_reports"] }
+
+[[bench]]
+name = "bounded_time"
+harness = false
+
+[[bench]]
+name = "bounded_step"
+harness = false
+
+[[bench]]
+name = "decentralised_time"
+harness = false
+
+[[bench]]
+name = "weighted_time"
+harness = false

caledonia/benches/bounded_repetition.rs

@@ -0,0 +1,76 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
+use std::time::Duration;
+
+use caledonia::bounded::Proof;
+
+pub mod utils;
+
+fn prepetitions(
+    c: &mut Criterion<utils::Repetitions>,
+    lambdas: &[usize],
+    s_p: &[usize],
+    n_p: &[usize],
+    _hash_size: usize,
+) {
+    let mut group = c.benchmark_group("Alba Bounded".to_string());
+
+    fn prove_repetitions(l: usize, sp: usize, np: usize, truncate_size: usize, n: u64) -> u64 {
+        let mut rng = ChaCha20Rng::from_entropy();
+        let mut total_repetitions = 0;
+        for _ in 0..n {
+            // Setup
+            let (mut dataset, bench_setup) = utils::setup_bounded_wrapper(&mut rng, l, sp, np);
+            dataset.truncate(truncate_size);
+            // Bench
+            black_box({
+                let (_, r, _) = Proof::bench(&bench_setup, &dataset);
+                total_repetitions += 1 + r;
+            });
+        }
+        total_repetitions as u64
+    }
+
+    for &l in lambdas {
+        for &sp in s_p {
+            for &np in n_p {
+                // Bench with all of Sp
+                let high = sp;
+
+                // Bench with all of np% of Sp
+                let low = (high * np).div_ceil(100);
+
+                // Bench with  (100+np)/2 percent of Sp
+                let mean = (100 + np).div_ceil(2);
+                let mid = (high + low).div_ceil(2);
+
+                group.bench_function(
+                    utils::bench_id("Proving repetitions", np, l, sp, np),
+                    move |b| b.iter_custom(|n| prove_repetitions(l, sp, np, low, n)),
+                );
+                group.bench_function(
+                    utils::bench_id("Proving repetitions", mean, l, sp, np),
+                    move |b| b.iter_custom(|n| prove_repetitions(l, sp, np, mid, n)),
+                );
+                group.bench_function(
+                    utils::bench_id("Proving repetitions", 100, l, sp, np),
+                    move |b| b.iter_custom(|n| prove_repetitions(l, sp, np, high, n)),
+                );
+            }
+        }
+    }
+    group.finish();
+}
+
+fn prove_step_benches(c: &mut Criterion<utils::Repetitions>) {
+    prepetitions(c, &[50], &[100], &[60, 66, 80], 256);
+}
+
+criterion_group!(name = benches;
+                 config = Criterion::default().sample_size(500).nresamples(1000).measurement_time(Duration::from_secs(30)).with_measurement(utils::Repetitions);
+                 targets =
+    prove_step_benches
+);
+
+criterion_main!(benches);

caledonia/benches/bounded_step.rs

@@ -0,0 +1,74 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
+
+use caledonia::bounded::Proof;
+
+pub mod utils;
+
+fn psteps(
+    c: &mut Criterion<utils::Steps>,
+    lambdas: &[usize],
+    s_p: &[usize],
+    n_p: &[usize],
+    _hash_size: usize,
+) {
+    let mut group = c.benchmark_group("Alba Bounded".to_string());
+
+    fn prove_steps(l: usize, sp: usize, np: usize, truncate_size: usize, n: u64) -> u64 {
+        let mut rng = ChaCha20Rng::from_entropy();
+        let mut total_steps = 0;
+        for _ in 0..n {
+            // Setup
+            let (mut dataset, bench_setup) = utils::setup_bounded_wrapper(&mut rng, l, sp, np);
+            dataset.truncate(truncate_size);
+            // Bench
+            black_box({
+                let (steps, _, _) = Proof::bench(&bench_setup, &dataset);
+                total_steps += steps;
+            });
+        }
+        total_steps as u64
+    }
+
+    for &l in lambdas {
+        for &sp in s_p {
+            for &np in n_p {
+                // Bench with all of Sp
+                let high = sp;
+
+                // Bench with all of np% of Sp
+                let low = (high * np).div_ceil(100);
+
+                // Bench with  (100+np)/2 percent of Sp
+                let mean = (100 + np).div_ceil(2);
+                let mid = (high + low).div_ceil(2);
+
+                group.bench_function(utils::bench_id("Proving steps", np, l, sp, np), move |b| {
+                    b.iter_custom(|n| prove_steps(l, sp, np, low, n))
+                });
+                group.bench_function(
+                    utils::bench_id("Proving steps", mean, l, sp, np),
+                    move |b| b.iter_custom(|n| prove_steps(l, sp, np, mid, n)),
+                );
+                group.bench_function(utils::bench_id("Proving steps", 100, l, sp, np), move |b| {
+                    b.iter_custom(|n| prove_steps(l, sp, np, high, n))
+                });
+            }
+        }
+    }
+    group.finish();
+}
+
+fn prove_step_benches(c: &mut Criterion<utils::Steps>) {
+    // prove(c, &[128], &[1000, 5000], &[60, 66, 80], 256);
+    psteps(c, &[10], &[1000], &[60, 66, 80], 256);
+}
+
+criterion_group!(name = benches;
+                 config = Criterion::default().nresamples(1000).with_measurement(utils::Steps);
+                 targets =
+    prove_step_benches
+);
+
+criterion_main!(benches);

caledonia/benches/bounded_time.rs

@@ -0,0 +1,127 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
+use std::time::{Duration, Instant};
+
+use caledonia::bounded::Proof;
+
+pub mod utils;
+
+fn prove(c: &mut Criterion, lambdas: &[usize], s_p: &[usize], n_p: &[usize], _hash_size: usize) {
+    let mut group = c.benchmark_group("Alba Bounded".to_string());
+
+    fn prove_duration(l: usize, sp: usize, np: usize, truncate_size: usize, n: u64) -> Duration {
+        let mut rng = ChaCha20Rng::from_entropy();
+        let mut total_duration = Duration::ZERO;
+        for _ in 0..n {
+            // Setup
+            let (mut dataset, bench_setup) = utils::setup_bounded_wrapper(&mut rng, l, sp, np);
+            dataset.truncate(truncate_size);
+            // Bench
+            let start = Instant::now();
+            black_box({
+                Proof::prove(&bench_setup, &dataset);
+            });
+            total_duration = total_duration.saturating_add(start.elapsed());
+        }
+        total_duration
+    }
+
+    for &l in lambdas {
+        for &sp in s_p {
+            for &np in n_p {
+                // Bench with all of Sp
+                let high = sp;
+
+                // Bench with all of np% of Sp
+                let low = (high * np).div_ceil(100);
+
+                // Bench with  (100+np)/2 percent of Sp
+                let mean = (100 + np).div_ceil(2);
+                let mid = (high + low).div_ceil(2);
+
+                group.bench_function(utils::bench_id("Proving time", np, l, sp, np), move |b| {
+                    b.iter_custom(|n| prove_duration(l, sp, np, low, n))
+                });
+                group.bench_function(utils::bench_id("Proving time", mean, l, sp, np), move |b| {
+                    b.iter_custom(|n| prove_duration(l, sp, np, mid, n))
+                });
+                group.bench_function(utils::bench_id("Proving time", 100, l, sp, np), move |b| {
+                    b.iter_custom(|n| prove_duration(l, sp, np, high, n))
+                });
+            }
+        }
+    }
+    group.finish();
+}
+
+fn verify(c: &mut Criterion, lambdas: &[usize], s_p: &[usize], n_p: &[usize], _hash_size: usize) {
+    let mut group = c.benchmark_group("Alba".to_string());
+
+    fn verify_duration(l: usize, sp: usize, np: usize, truncate_size: usize, n: u64) -> Duration {
+        let mut rng = ChaCha20Rng::from_entropy();
+        let mut total_duration = Duration::ZERO;
+        for _ in 0..n {
+            // Setup
+            let (mut dataset, bench_setup) = utils::setup_bounded_wrapper(&mut rng, l, sp, np);
+            dataset.truncate(truncate_size);
+            // Prove
+            let proof = Proof::prove(&bench_setup, &dataset);
+            // Bench
+            let start = Instant::now();
+            black_box({
+                Proof::verify(&bench_setup, proof);
+            });
+            total_duration = total_duration.saturating_add(start.elapsed());
+        }
+        total_duration
+    }
+
+    for &l in lambdas {
+        for &sp in s_p {
+            for &np in n_p {
+                // Bench with all of Sp
+                let high = sp;
+
+                // Bench with all of np% of Sp
+                let low = (high * np).div_ceil(100);
+
+                // Bench with  (100+np)/2 percent of Sp
+                let mean = (100 + np).div_ceil(2);
+                let mid = (high + low).div_ceil(2);
+
+                group.bench_function(
+                    utils::bench_id("Verification time", np, l, sp, np),
+                    move |b| b.iter_custom(|n| verify_duration(l, sp, np, low, n)),
+                );
+                group.bench_function(
+                    utils::bench_id("Verification time", mean, l, sp, np),
+                    move |b| b.iter_custom(|n| verify_duration(l, sp, np, mid, n)),
+                );
+                group.bench_function(
+                    utils::bench_id("Verification time", 100, l, sp, np),
+                    move |b| b.iter_custom(|n| verify_duration(l, sp, np, high, n)),
+                );
+            }
+        }
+    }
+    group.finish();
+}
+
+fn prove_benches(c: &mut Criterion) {
+    // prove(c, &[128], &[1000, 5000], &[60, 66, 80], 256);
+    prove(c, &[128], &[1_000_000], &[60, 66, 80], 256);
+}
+
+fn verify_benches(c: &mut Criterion) {
+    verify(c, &[10], &[1000], &[60, 66, 80], 256);
+}
+
+criterion_group!(name = benches;
+                 config = Criterion::default().nresamples(1000);
+                 targets =
+    prove_benches,
+    verify_benches
+);
+
+criterion_main!(benches);