add benchmark for fast field codecs

test tests::bench_fastfield_bitpack_create        ... bench:      57,628 ns/iter (+/- 23,486)
test tests::bench_fastfield_bitpack_get           ... bench:      43,323 ns/iter (+/- 4,286)
test tests::bench_fastfield_linearinterpol_create ... bench:     223,625 ns/iter (+/- 33,563)
test tests::bench_fastfield_linearinterpol_get    ... bench:      82,839 ns/iter (+/- 9,575)

fastfield_codecs/benches/bench.rs

@@ -0,0 +1,97 @@
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use fastfield_codecs::{
+        bitpacked::{BitpackedFastFieldReader, BitpackedFastFieldSerializer},
+        linearinterpol::{LinearInterpolFastFieldSerializer, LinearinterpolFastFieldReader},
+        *,
+    };
+
+    fn get_data() -> Vec<u64> {
+        let mut data: Vec<_> = (100..25000_u64).collect();
+        data.push(99_000);
+        data
+    }
+
+    use test::Bencher;
+    #[bench]
+    fn bench_fastfield_bitpack_create(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        b.iter(|| {
+            let mut out = vec![];
+            BitpackedFastFieldSerializer::create(
+                &mut out,
+                &data,
+                stats_from_vec(&data),
+                data.iter().cloned(),
+            )
+            .unwrap();
+            out
+        });
+    }
+    #[bench]
+    fn bench_fastfield_linearinterpol_create(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        b.iter(|| {
+            let mut out = vec![];
+            LinearInterpolFastFieldSerializer::create(
+                &mut out,
+                &data,
+                stats_from_vec(&data),
+                data.iter().cloned(),
+                data.iter().cloned(),
+            )
+            .unwrap();
+            out
+        });
+    }
+    #[bench]
+    fn bench_fastfield_bitpack_get(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        let mut bytes = vec![];
+        BitpackedFastFieldSerializer::create(
+            &mut bytes,
+            &data,
+            stats_from_vec(&data),
+            data.iter().cloned(),
+        )
+        .unwrap();
+        let reader = BitpackedFastFieldReader::open_from_bytes(&bytes).unwrap();
+        b.iter(|| {
+            for pos in 0..20_000 {
+                reader.get_u64(pos as u64, &bytes);
+            }
+        });
+    }
+    #[bench]
+    fn bench_fastfield_linearinterpol_get(b: &mut Bencher) {
+        let data: Vec<_> = get_data();
+        let mut bytes = vec![];
+        LinearInterpolFastFieldSerializer::create(
+            &mut bytes,
+            &data,
+            stats_from_vec(&data),
+            data.iter().cloned(),
+            data.iter().cloned(),
+        )
+        .unwrap();
+        let reader = LinearinterpolFastFieldReader::open_from_bytes(&bytes).unwrap();
+        b.iter(|| {
+            for pos in 0..20_000 {
+                reader.get_u64(pos as u64, &bytes);
+            }
+        });
+    }
+    pub fn stats_from_vec(data: &[u64]) -> FastFieldStats {
+        let min_value = data.iter().cloned().min().unwrap_or(0);
+        let max_value = data.iter().cloned().max().unwrap_or(0);
+        FastFieldStats {
+            min_value,
+            max_value,
+            num_vals: data.len() as u64,
+        }
+    }
+}