Move key generation and signing from transaction benchmark

Key generation, signing and verification are not the performance
bottleneck. Something is probably wrong here.

src/accountant_skel.rs

@@ -42,11 +42,15 @@ impl AccountantSkel {
     pub fn process_request(self: &mut Self, msg: Request) -> Option<Response> {
         match msg {
             Request::Deposit { key, val, sig } => {
-                let _ = self.obj.deposit_signed(key, val, sig);
+                if let Err(err) = self.obj.deposit_signed(key, val, sig) {
+                    println!("Deposit error: {:?}", err);
+                }
                 None
             }
             Request::Transfer { from, to, val, sig } => {
-                let _ = self.obj.transfer_signed(from, to, val, sig);
+                if let Err(err) = self.obj.transfer_signed(from, to, val, sig) {
+                    println!("Transfer error: {:?}", err);
+                }
                 None
             }
             Request::GetBalance { key } => {

src/accountant_stub.rs

@@ -23,7 +23,7 @@ impl AccountantStub {
     }
 
     pub fn deposit_signed(
-        self: &mut Self,
+        self: &Self,
         key: PublicKey,
         val: u64,
         sig: Signature,
@@ -33,15 +33,15 @@ impl AccountantStub {
         self.socket.send_to(&data, &self.addr)
     }
 
-    pub fn deposit(self: &mut Self, n: u64, keypair: &Ed25519KeyPair) -> io::Result<Signature> {
+    pub fn deposit(self: &Self, n: u64, keypair: &Ed25519KeyPair) -> io::Result<Signature> {
         use event::{get_pubkey, sign_claim_data};
         let key = get_pubkey(keypair);
         let sig = sign_claim_data(&n, keypair);
         self.deposit_signed(key, n, sig).map(|_| sig)
     }
 
     pub fn transfer_signed(
-        self: &mut Self,
+        self: &Self,
         from: PublicKey,
         to: PublicKey,
         val: u64,
@@ -53,7 +53,7 @@ impl AccountantStub {
     }
 
     pub fn transfer(
-        self: &mut Self,
+        self: &Self,
         n: u64,
         keypair: &Ed25519KeyPair,
         to: PublicKey,
@@ -64,7 +64,7 @@ impl AccountantStub {
         self.transfer_signed(from, to, n, sig).map(|_| sig)
     }
 
-    pub fn get_balance(self: &mut Self, pubkey: &PublicKey) -> io::Result<u64> {
+    pub fn get_balance(self: &Self, pubkey: &PublicKey) -> io::Result<u64> {
         let req = Request::GetBalance { key: *pubkey };
         let data = serialize(&req).expect("serialize GetBalance");
         self.socket.send_to(&data, &self.addr)?;
@@ -78,7 +78,7 @@ impl AccountantStub {
         Ok(0)
     }
 
-    pub fn wait_on_signature(self: &mut Self, wait_sig: &Signature) -> io::Result<()> {
+    pub fn wait_on_signature(self: &Self, wait_sig: &Signature) -> io::Result<()> {
         let req = Request::Wait { sig: *wait_sig };
         let data = serialize(&req).unwrap();
         self.socket.send_to(&data, &self.addr).map(|_| ())?;
@@ -117,7 +117,7 @@ mod tests {
         sleep(Duration::from_millis(30));
 
         let socket = UdpSocket::bind(send_addr).unwrap();
-        let mut acc = AccountantStub::new(addr, socket);
+        let acc = AccountantStub::new(addr, socket);
         let alice_keypair = generate_keypair();
         let bob_keypair = generate_keypair();
         acc.deposit(10_000, &alice_keypair).unwrap();

src/bin/client-demo.rs

@@ -4,12 +4,12 @@ fn main() {
     use silk::accountant_stub::AccountantStub;
     use std::time::Instant;
     use std::net::UdpSocket;
-    use silk::event::{generate_keypair, get_pubkey};
+    use silk::event::{generate_keypair, get_pubkey, sign_transaction_data};
 
     let addr = "127.0.0.1:8000";
     let send_addr = "127.0.0.1:8001";
     let socket = UdpSocket::bind(send_addr).unwrap();
-    let mut acc = AccountantStub::new(addr, socket);
+    let acc = AccountantStub::new(addr, socket);
     let alice_keypair = generate_keypair();
     let alice_pubkey = get_pubkey(&alice_keypair);
     let txs = 2_000;
@@ -19,13 +19,30 @@ fn main() {
     assert_eq!(acc.get_balance(&alice_pubkey).unwrap(), txs);
     println!("Done.");
 
+    let one = 1;
+    println!("Signing transactions...");
+    let now = Instant::now();
+    let sigs = (0..txs).map(|_| {
+        let rando_keypair = generate_keypair();
+        let rando_pubkey = get_pubkey(&rando_keypair);
+        let sig = sign_transaction_data(&one, &alice_keypair, &rando_pubkey);
+        (rando_pubkey, sig)
+    });
+    let duration = now.elapsed();
+    let ns = duration.as_secs() * 1_000_000_000 + duration.subsec_nanos() as u64;
+    let bsps = txs as f64 / ns as f64;
+    let nsps = ns as f64 / txs as f64;
+    println!(
+        "Done. {} billion signatures per second, {}ns per signature",
+        bsps, spus
+    );
+
     println!("Transferring 1 unit {} times...", txs);
     let now = Instant::now();
     let mut sig = sig;
-    for _ in 0..txs {
-        let bob_keypair = generate_keypair();
-        let bob_pubkey = get_pubkey(&bob_keypair);
-        sig = acc.transfer(1, &alice_keypair, bob_pubkey).unwrap();
+    for (k, s) in sigs {
+        acc.transfer_signed(alice_pubkey, k, one, s).unwrap();
+        sig = s;
     }
     println!("Waiting for last transaction to be confirmed...",);
     acc.wait_on_signature(&sig).unwrap();