Benchmarks for sign function (#5)

benches/public_key.rs

@@ -36,3 +36,17 @@ fn bench_public_key_serialize(b: &mut Bencher) {
         let _serialized = pubkey.serialize();
     });
 }
+
+#[bench]
+fn bench_public_key_serialize_compressed(b: &mut Bencher) {
+    let secp256k1 = Secp256k1::new();
+    let (_, secp_pubkey) = secp256k1.generate_keypair(&mut thread_rng()).unwrap();
+    let pubkey_arr = secp_pubkey.serialize_vec(&secp256k1, false);
+    assert!(pubkey_arr.len() == 65);
+    let mut pubkey_a = [0u8; 65];
+    pubkey_a[0..65].copy_from_slice(&pubkey_arr[0..65]);
+    let pubkey = PublicKey::parse(&pubkey_a).unwrap();
+    b.iter(|| {
+		let _serialized = pubkey.serialize_compressed();
+    });
+}

benches/sign.rs

@@ -0,0 +1,25 @@
+#![feature(test)]
+
+extern crate test;
+extern crate secp256k1;
+extern crate secp256k1_test;
+extern crate rand;
+#[macro_use]
+extern crate arrayref;
+
+use test::Bencher;
+use secp256k1::{sign, SecretKey, Message};
+use secp256k1_test::Secp256k1;
+use rand::thread_rng;
+
+#[bench]
+fn bench_sign_message(b: &mut Bencher) {
+    let secp256k1 = Secp256k1::new();
+    let message = Message::parse(&[5u8; 32]);
+    let (secp_privkey, _) = secp256k1.generate_keypair(&mut thread_rng()).unwrap();
+    let seckey = SecretKey::parse(array_ref!(secp_privkey, 0, 32)).unwrap();
+
+    b.iter(|| {
+        let _ = sign(&message, &seckey).unwrap();
+    });
+}

src/lib.rs

@@ -153,11 +153,7 @@ impl PublicKey {
 
         elem.x.normalize_var();
         elem.y.normalize_var();
-        let d = elem.x.b32();
-        for i in 0..32 {
-            ret[1+i] = d[i];
-        }
-
+        elem.x.fill_b32(array_mut_ref!(ret, 1, 32));
         ret[0] = if elem.y.is_odd() {
             TAG_PUBKEY_ODD
         } else {
@@ -299,27 +295,18 @@ pub fn sign(message: &Message, seckey: &SecretKey) -> Result<(Signature, Recover
 
     let mut drbg = HmacDRBG::<Sha256>::new(&seckey_b32, &message_b32, &[]);
     let generated = drbg.generate::<U32>(None);
-    let mut generated_arr = [0u8; 32];
-    for i in 0..32 {
-        generated_arr[i] = generated[i];
-    }
     let mut nonce = Scalar::default();
-    let mut overflow = nonce.set_b32(&generated_arr);
+    let mut overflow = nonce.set_b32(array_ref!(generated, 0, 32));
 
     while overflow || nonce.is_zero() {
         let generated = drbg.generate::<U32>(None);
-        let mut generated_arr = [0u8; 32];
-        for i in 0..32 {
-            generated_arr[i] = generated[i];
-        }
-        overflow = nonce.set_b32(&generated_arr);
+        overflow = nonce.set_b32(array_ref!(generated, 0, 32));
     }
 
     let result = ECMULT_GEN_CONTEXT.sign_raw(&seckey.0, &message.0, &nonce);
     #[allow(unused_assignments)]
     {
         nonce = Scalar::default();
-        generated_arr = [0u8; 32];
     }
     if let Ok((sigr, sigs, recid)) = result {
         return Ok((Signature {