binlog 0.5.0

A binary data log library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::borrow::Cow;
use std::thread;

use crate::{Entry, Range, RangeableStore, Store};

use string_cache::DefaultAtom as Atom;
use test::Bencher;

/// Defines a benchmark function.
#[doc(hidden)]
#[macro_export]
macro_rules! define_bench {
    ($name:ident, $store_constructor:expr) => {
        #[bench]
        fn $name(b: &mut test::Bencher) {
            let store = $store_constructor;
            $crate::benches::$name(b, &store);
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! bench_store_impl {
    ($code:expr) => {
        define_bench!(push, $code);
        define_bench!(push_parallel, $code);
        define_bench!(latest, $code);
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! bench_rangeable_store_impl {
    ($code:expr) => {
        define_bench!(iter, $code);
    };
}

pub fn push<S: Store>(b: &mut Bencher, store: &S) {
    let entry = Entry::new_with_timestamp(1, "bench_push", vec![1, 2, 3]);
    b.iter(|| {
        store.push(Cow::Borrowed(&entry)).unwrap();
    });
}

pub fn push_parallel<S: Store + Clone + 'static>(b: &mut Bencher, store: &S) {
    b.iter(|| {
        let mut threads = Vec::default();
        for i in 1..11 {
            let store = store.clone();
            threads.push(thread::spawn(move || {
                let name = Atom::from("bench_push_parallel");
                for j in 1..101 {
                    let idx = i * j;
                    let entry = Entry::new_with_timestamp(idx, name.clone(), vec![1, 2, 3]);
                    store.push(Cow::Owned(entry)).unwrap();
                }
            }));
        }
        for thread in threads.into_iter() {
            thread.join().unwrap();
        }
    });
}

pub fn latest<S: Store + Clone + 'static>(b: &mut Bencher, store: &S) {
    let name = Atom::from("bench_latest");
    store
        .push(Cow::Owned(Entry::new_with_timestamp(1, name.clone(), vec![1, 2, 3])))
        .unwrap();

    b.iter(|| {
        store.latest(name.clone()).unwrap();
    });
}

pub fn iter<S: RangeableStore>(b: &mut Bencher, store: &S) {
    for i in 0..=255u8 {
        let entry = Entry::new_with_timestamp(i.into(), "bench_iter", vec![i]);
        store.push(Cow::Owned(entry)).unwrap();
    }
    b.iter(|| {
        assert_eq!(
            store.range(.., Option::<Atom>::None).unwrap().iter().unwrap().count(),
            256
        );
    });
}