Timing main program for Arctic

src/arctic.rs

@@ -14,6 +14,12 @@ pub struct SecKey {
     rk: shine::PreprocKey,
 }
 
+impl SecKey {
+    pub fn delta(&self) -> usize {
+        self.rk.delta()
+    }
+}
+
 type Signature = (RistrettoPoint, Scalar);
 
 pub fn keygen(n: u32, t: u32) -> (PubKey, Vec<SecKey>) {

src/bin/arctic.rs

@@ -0,0 +1,110 @@
+use arctic::arctic;
+use curve25519_dalek::ristretto::RistrettoPoint;
+use curve25519_dalek::scalar::Scalar;
+use rand::RngCore;
+use std::env;
+use std::time::Instant;
+
+fn mean(vals: &[f64]) -> f64 {
+    let num = vals.len();
+    if num > 0 {
+        vals.iter().sum::<f64>() / (num as f64)
+    } else {
+        0f64
+    }
+}
+
+fn stddev(vals: &[f64]) -> f64 {
+    let num = vals.len();
+    if num < 2 {
+        return 0f64;
+    }
+    let avg = mean(vals);
+    (vals
+        .iter()
+        .map(|v| v - avg)
+        .map(|dev| dev * dev)
+        .sum::<f64>()
+        / ((num - 1) as f64))
+        .sqrt()
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 4 || args.len() > 5 {
+        println!("Usage: {} n t msglen [reps]", args[0]);
+        return;
+    }
+    let n: u32 = args[1].parse().unwrap();
+    let t: u32 = args[2].parse().unwrap();
+    let msglen: usize = args[3].parse().unwrap();
+    let mut reps = 1usize;
+    if args.len() > 4 {
+        reps = args[4].parse().unwrap();
+    }
+    let mut msg: Vec<u8> = Vec::new();
+    let mut rng = rand::thread_rng();
+    msg.resize(msglen, 0);
+
+    let (pubkey, seckeys) = arctic::keygen(n, t);
+    let delta = seckeys[0].delta();
+
+    let mut sign1_timings: Vec<f64> = Vec::new();
+    let mut sign2_timings: Vec<f64> = Vec::new();
+    let mut combine_timings: Vec<f64> = Vec::new();
+
+    let coalition = (1..=n).collect::<Vec<u32>>();
+
+    for _ in 0..reps {
+        rng.fill_bytes(&mut msg);
+        let (commits, sign1_iter_timings): (Vec<RistrettoPoint>, Vec<f64>) = seckeys
+            .iter()
+            .map(|key| {
+                let sign1start = Instant::now();
+                let commitment = arctic::sign1(&pubkey, key, &coalition, &msg);
+                let sign1dur = sign1start.elapsed().as_micros() as f64;
+                (commitment, sign1dur)
+            })
+            .unzip();
+        sign1_timings.extend(sign1_iter_timings);
+
+        let (sigshares, sign2_iter_timings): (Vec<Scalar>, Vec<f64>) = seckeys
+            .iter()
+            .map(|key| {
+                let sign2start = Instant::now();
+                let sigshare = arctic::sign2(&pubkey, key, &coalition, &msg, &commits).unwrap();
+                let sign2dur = sign2start.elapsed().as_micros() as f64;
+                (sigshare, sign2dur)
+            })
+            .unzip();
+        sign2_timings.extend(sign2_iter_timings);
+
+        let combinestart = Instant::now();
+        let sig = arctic::combine(&pubkey, t, &coalition, &msg, &commits, &sigshares).unwrap();
+        let combinedur = combinestart.elapsed().as_micros() as f64;
+        combine_timings.push(combinedur);
+
+        assert!(arctic::verify(&pubkey, &msg, &sig));
+    }
+
+    let sign1_mean = mean(&sign1_timings);
+    let sign1_stddev = stddev(&sign1_timings);
+    let sign2_mean = mean(&sign2_timings);
+    let sign2_stddev = stddev(&sign2_timings);
+    let combine_mean = mean(&combine_timings);
+    let combine_stddev = stddev(&combine_timings);
+    println!(
+        "{} {} {} {} {} {:.1} ± {:.1} {:.1} ± {:.1} {:.1} ± {:.1}",
+        n,
+        t,
+        msglen,
+        reps,
+        delta,
+        sign1_mean,
+        sign1_stddev,
+        sign2_mean,
+        sign2_stddev,
+        combine_mean,
+        combine_stddev,
+    );
+}