Move macro_rules [T; N] definitions to const min [T; N].

benches/bench.rs

@@ -6,49 +6,107 @@ extern crate test;
 use abomonation::*;
 use test::Bencher;
 
-#[bench] fn empty_enc(bencher: &mut Bencher) { _bench_enc(bencher, vec![(); 1024]); }
-#[bench] fn empty_dec(bencher: &mut Bencher) { _bench_dec(bencher, vec![(); 1024]); }
+#[bench]
+fn empty_enc(bencher: &mut Bencher) {
+    _bench_enc(bencher, vec![(); 1024]);
+}
+#[bench]
+fn empty_dec(bencher: &mut Bencher) {
+    _bench_dec(bencher, vec![(); 1024]);
+}
 
-#[bench] fn u64_enc(bencher: &mut Bencher) { _bench_enc(bencher, vec![0u64; 1024]); }
-#[bench] fn u64_dec(bencher: &mut Bencher) { _bench_dec(bencher, vec![0u64; 1024]); }
+#[bench]
+fn u64_enc(bencher: &mut Bencher) {
+    _bench_enc(bencher, vec![0u64; 1024]);
+}
+#[bench]
+fn u64_dec(bencher: &mut Bencher) {
+    _bench_dec(bencher, vec![0u64; 1024]);
+}
 
-#[bench] fn u32x2_enc(bencher: &mut Bencher) { _bench_enc(bencher, vec![(0u32,0u32); 1024]); }
-#[bench] fn u32x2_dec(bencher: &mut Bencher) { _bench_dec(bencher, vec![(0u32,0u32); 1024]); }
+#[bench]
+fn u32x2_enc(bencher: &mut Bencher) {
+    _bench_enc(bencher, vec![(0u32, 0u32); 1024]);
+}
+#[bench]
+fn u32x2_dec(bencher: &mut Bencher) {
+    _bench_dec(bencher, vec![(0u32, 0u32); 1024]);
+}
 
-#[bench] fn u8_u64_enc(bencher: &mut Bencher) { _bench_enc(bencher, vec![(0u8, 0u64); 512]); }
-#[bench] fn u8_u64_dec(bencher: &mut Bencher) { _bench_dec(bencher, vec![(0u8, 0u64); 512]); }
+#[bench]
+fn u8_u64_enc(bencher: &mut Bencher) {
+    _bench_enc(bencher, vec![(0u8, 0u64); 512]);
+}
+#[bench]
+fn u8_u64_dec(bencher: &mut Bencher) {
+    _bench_dec(bencher, vec![(0u8, 0u64); 512]);
+}
 
-#[bench] fn string10_enc(bencher: &mut Bencher) { _bench_enc(bencher, vec![format!("grawwwwrr!"); 1024]); }
-#[bench] fn string10_dec(bencher: &mut Bencher) { _bench_dec(bencher, vec![format!("grawwwwrr!"); 1024]); }
+#[bench]
+fn string10_enc(bencher: &mut Bencher) {
+    _bench_enc(bencher, vec![format!("grawwwwrr!"); 1024]);
+}
+#[bench]
+fn string10_dec(bencher: &mut Bencher) {
+    _bench_dec(bencher, vec![format!("grawwwwrr!"); 1024]);
+}
 
-#[bench] fn string20_enc(bencher: &mut Bencher) { _bench_enc(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]); }
-#[bench] fn string20_dec(bencher: &mut Bencher) { _bench_dec(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]); }
+#[bench]
+fn string20_enc(bencher: &mut Bencher) {
+    _bench_enc(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]);
+}
+#[bench]
+fn string20_dec(bencher: &mut Bencher) {
+    _bench_dec(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]);
+}
 
-#[bench] fn vec_u_s_enc(bencher: &mut Bencher) { _bench_enc(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
-#[bench] fn vec_u_s_dec(bencher: &mut Bencher) { _bench_dec(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
+#[bench]
+fn vec_u_s_enc(bencher: &mut Bencher) {
+    _bench_enc(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]);
+}
+#[bench]
+fn vec_u_s_dec(bencher: &mut Bencher) {
+    _bench_dec(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]);
+}
 
-#[bench] fn vec_u_vn_s_enc(bencher: &mut Bencher) { _bench_enc(bencher, vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32]); }
-#[bench] fn vec_u_vn_s_dec(bencher: &mut Bencher) { _bench_dec(bencher, vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32]); }
+#[bench]
+fn vec_u_vn_s_enc(bencher: &mut Bencher) {
+    _bench_enc(
+        bencher,
+        vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32],
+    );
+}
+#[bench]
+fn vec_u_vn_s_dec(bencher: &mut Bencher) {
+    _bench_dec(
+        bencher,
+        vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32],
+    );
+}
 
 fn _bench_enc<T: Abomonation>(bencher: &mut Bencher, record: T) {
-
     // prepare encoded data for bencher.bytes
     let mut bytes = Vec::new();
-    unsafe { encode(&record, &mut bytes).unwrap(); }
+    unsafe {
+        encode(&record, &mut bytes).unwrap();
+    }
 
     // repeatedly encode this many bytes
     bencher.bytes = bytes.len() as u64;
     bencher.iter(|| {
         bytes.clear();
-        unsafe { encode(&record, &mut bytes).unwrap(); }
+        unsafe {
+            encode(&record, &mut bytes).unwrap();
+        }
     });
 }
 
-fn _bench_dec<T: Abomonation+Eq>(bencher: &mut Bencher, record: T) {
-
+fn _bench_dec<T: Abomonation + Eq>(bencher: &mut Bencher, record: T) {
     // prepare encoded data
     let mut bytes = Vec::new();
-    unsafe { encode(&record, &mut bytes).unwrap(); }
+    unsafe {
+        encode(&record, &mut bytes).unwrap();
+    }
 
     // repeatedly decode (and validate)
     bencher.bytes = bytes.len() as u64;

benches/clone.rs

@@ -6,51 +6,101 @@ extern crate test;
 use abomonation::*;
 use test::Bencher;
 
-#[bench] fn empty_e_d(bencher: &mut Bencher) { _bench_e_d(bencher, vec![(); 1024]); }
-#[bench] fn empty_cln(bencher: &mut Bencher) { _bench_cln(bencher, vec![(); 1024]); }
+#[bench]
+fn empty_e_d(bencher: &mut Bencher) {
+    _bench_e_d(bencher, vec![(); 1024]);
+}
+#[bench]
+fn empty_cln(bencher: &mut Bencher) {
+    _bench_cln(bencher, vec![(); 1024]);
+}
 
-#[bench] fn u64_e_d(bencher: &mut Bencher) { _bench_e_d(bencher, vec![0u64; 1024]); }
-#[bench] fn u64_cln(bencher: &mut Bencher) { _bench_cln(bencher, vec![0u64; 1024]); }
+#[bench]
+fn u64_e_d(bencher: &mut Bencher) {
+    _bench_e_d(bencher, vec![0u64; 1024]);
+}
+#[bench]
+fn u64_cln(bencher: &mut Bencher) {
+    _bench_cln(bencher, vec![0u64; 1024]);
+}
 
-#[bench] fn u8_u64_e_d(bencher: &mut Bencher) { _bench_e_d(bencher, vec![(0u8, 0u64); 512]); }
-#[bench] fn u8_u64_cln(bencher: &mut Bencher) { _bench_cln(bencher, vec![(0u8, 0u64); 512]); }
+#[bench]
+fn u8_u64_e_d(bencher: &mut Bencher) {
+    _bench_e_d(bencher, vec![(0u8, 0u64); 512]);
+}
+#[bench]
+fn u8_u64_cln(bencher: &mut Bencher) {
+    _bench_cln(bencher, vec![(0u8, 0u64); 512]);
+}
 
-#[bench] fn string10_e_d(bencher: &mut Bencher) { _bench_e_d(bencher, vec![format!("grawwwwrr!"); 1024]); }
-#[bench] fn string10_cln(bencher: &mut Bencher) { _bench_cln(bencher, vec![format!("grawwwwrr!"); 1024]); }
+#[bench]
+fn string10_e_d(bencher: &mut Bencher) {
+    _bench_e_d(bencher, vec![format!("grawwwwrr!"); 1024]);
+}
+#[bench]
+fn string10_cln(bencher: &mut Bencher) {
+    _bench_cln(bencher, vec![format!("grawwwwrr!"); 1024]);
+}
 
-#[bench] fn string20_e_d(bencher: &mut Bencher) { _bench_e_d(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]); }
-#[bench] fn string20_cln(bencher: &mut Bencher) { _bench_cln(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]); }
+#[bench]
+fn string20_e_d(bencher: &mut Bencher) {
+    _bench_e_d(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]);
+}
+#[bench]
+fn string20_cln(bencher: &mut Bencher) {
+    _bench_cln(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]);
+}
 
-#[bench] fn vec_u_s_e_d(bencher: &mut Bencher) { _bench_e_d(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
-#[bench] fn vec_u_s_cln(bencher: &mut Bencher) { _bench_cln(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
+#[bench]
+fn vec_u_s_e_d(bencher: &mut Bencher) {
+    _bench_e_d(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]);
+}
+#[bench]
+fn vec_u_s_cln(bencher: &mut Bencher) {
+    _bench_cln(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]);
+}
 
-#[bench] fn vec_u_vn_s_e_d(bencher: &mut Bencher) { _bench_e_d(bencher, vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32]); }
-#[bench] fn vec_u_vn_s_cln(bencher: &mut Bencher) { _bench_cln(bencher, vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32]); }
+#[bench]
+fn vec_u_vn_s_e_d(bencher: &mut Bencher) {
+    _bench_e_d(
+        bencher,
+        vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32],
+    );
+}
+#[bench]
+fn vec_u_vn_s_cln(bencher: &mut Bencher) {
+    _bench_cln(
+        bencher,
+        vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32],
+    );
+}
 
 fn _bench_e_d<T: Abomonation>(bencher: &mut Bencher, record: T) {
-
     // prepare encoded data for bencher.bytes
     let mut bytes = Vec::new();
-    unsafe { encode(&record, &mut bytes).unwrap(); }
+    unsafe {
+        encode(&record, &mut bytes).unwrap();
+    }
 
     // repeatedly encode this many bytes
     bencher.bytes = bytes.len() as u64;
     bencher.iter(|| {
         bytes = vec![];
-        unsafe { encode(&record, &mut bytes).unwrap(); }
+        unsafe {
+            encode(&record, &mut bytes).unwrap();
+        }
         unsafe { decode::<T>(&mut bytes) }.is_some()
     });
 }
 
-fn _bench_cln<T: Abomonation+Clone>(bencher: &mut Bencher, record: T) {
-
+fn _bench_cln<T: Abomonation + Clone>(bencher: &mut Bencher, record: T) {
     // prepare encoded data
     let mut bytes = Vec::new();
-    unsafe { encode(&record, &mut bytes).unwrap(); }
+    unsafe {
+        encode(&record, &mut bytes).unwrap();
+    }
 
     // repeatedly decode (and validate)
     bencher.bytes = bytes.len() as u64;
-    bencher.iter(|| {
-        record.clone()
-    });
+    bencher.iter(|| record.clone());
 }

benches/recycler.rs

@@ -1,52 +1,95 @@
 #![feature(test)]
 
-extern crate recycler;
 extern crate abomonation;
+extern crate recycler;
 extern crate test;
 
-use recycler::{Recyclable, Recycler, make_recycler};
 use abomonation::*;
+use recycler::{make_recycler, Recyclable, Recycler};
 use test::Bencher;
 // use std::io::Read;
 
-#[bench] fn empty_own(bencher: &mut Bencher) { _bench_own(bencher, vec![(); 1024]); }
-#[bench] fn u64_own(bencher: &mut Bencher) { _bench_own(bencher, vec![0u64; 1024]); }
-#[bench] fn u8_u64_own(bencher: &mut Bencher) { _bench_own(bencher, vec![(0u8, 0u64); 512]); }
-#[bench] fn string10_own(bencher: &mut Bencher) { _bench_own(bencher, vec![format!("grawwwwrr!"); 1024]); }
-#[bench] fn string20_own(bencher: &mut Bencher) { _bench_own(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]); }
-#[bench] fn vec_u_s_own(bencher: &mut Bencher) { _bench_own(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
-#[bench] fn vec_u_vn_s_own(bencher: &mut Bencher) { _bench_own(bencher, vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32]); }
-
-#[bench] fn empty_rec(bencher: &mut Bencher) { _bench_rec(bencher, vec![(); 1024]); }
-#[bench] fn u64_rec(bencher: &mut Bencher) { _bench_rec(bencher, vec![0u64; 1024]); }
-#[bench] fn u8_u64_rec(bencher: &mut Bencher) { _bench_rec(bencher, vec![(0u8, 0u64); 512]); }
-#[bench] fn string10_rec(bencher: &mut Bencher) { _bench_rec(bencher, vec![format!("grawwwwrr!"); 1024]); }
-#[bench] fn string20_rec(bencher: &mut Bencher) { _bench_rec(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]); }
-#[bench] fn vec_u_s_rec(bencher: &mut Bencher) { _bench_rec(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
+#[bench]
+fn empty_own(bencher: &mut Bencher) {
+    _bench_own(bencher, vec![(); 1024]);
+}
+#[bench]
+fn u64_own(bencher: &mut Bencher) {
+    _bench_own(bencher, vec![0u64; 1024]);
+}
+#[bench]
+fn u8_u64_own(bencher: &mut Bencher) {
+    _bench_own(bencher, vec![(0u8, 0u64); 512]);
+}
+#[bench]
+fn string10_own(bencher: &mut Bencher) {
+    _bench_own(bencher, vec![format!("grawwwwrr!"); 1024]);
+}
+#[bench]
+fn string20_own(bencher: &mut Bencher) {
+    _bench_own(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]);
+}
+#[bench]
+fn vec_u_s_own(bencher: &mut Bencher) {
+    _bench_own(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]);
+}
+#[bench]
+fn vec_u_vn_s_own(bencher: &mut Bencher) {
+    _bench_own(
+        bencher,
+        vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32],
+    );
+}
+
+#[bench]
+fn empty_rec(bencher: &mut Bencher) {
+    _bench_rec(bencher, vec![(); 1024]);
+}
+#[bench]
+fn u64_rec(bencher: &mut Bencher) {
+    _bench_rec(bencher, vec![0u64; 1024]);
+}
+#[bench]
+fn u8_u64_rec(bencher: &mut Bencher) {
+    _bench_rec(bencher, vec![(0u8, 0u64); 512]);
+}
+#[bench]
+fn string10_rec(bencher: &mut Bencher) {
+    _bench_rec(bencher, vec![format!("grawwwwrr!"); 1024]);
+}
+#[bench]
+fn string20_rec(bencher: &mut Bencher) {
+    _bench_rec(bencher, vec![format!("grawwwwrr!!!!!!!!!!!"); 512]);
+}
+#[bench]
+fn vec_u_s_rec(bencher: &mut Bencher) {
+    _bench_rec(bencher, vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]);
+}
 
 // TODO : this reveals that working with a `vec![(); 1 << 40]` does not get optimized away.
 // #[bench] fn vec_u_vn_s_rec(bencher: &mut Bencher) { _bench_rec(bencher, vec![vec![(0u64, vec![(); 1 << 40], format!("grawwwwrr!")); 32]; 32]); }
 
-fn _bench_own<T: Abomonation+Clone>(bencher: &mut Bencher, record: T) {
-
+fn _bench_own<T: Abomonation + Clone>(bencher: &mut Bencher, record: T) {
     // prepare encoded data
     let mut bytes = Vec::new();
-    unsafe { encode(&record, &mut bytes).unwrap(); }
+    unsafe {
+        encode(&record, &mut bytes).unwrap();
+    }
 
     // repeatedly decode (and validate)
     bencher.bytes = bytes.len() as u64;
     bencher.iter(|| {
-        (*unsafe {decode::<T>(&mut bytes[..]) }.unwrap().0).clone()
+        (*unsafe { decode::<T>(&mut bytes[..]) }.unwrap().0).clone()
         // assert!(record == result);
     });
 }
 
-
-fn _bench_rec<T: Abomonation+Recyclable>(bencher: &mut Bencher, record: T) {
-
+fn _bench_rec<T: Abomonation + Recyclable>(bencher: &mut Bencher, record: T) {
     // prepare encoded data
     let mut bytes = Vec::new();
-    unsafe { encode(&record, &mut bytes).unwrap(); }
+    unsafe {
+        encode(&record, &mut bytes).unwrap();
+    }
     let mut recycler = make_recycler::<T>();
     recycler.recycle(record);