cesiumdb 0.1.0

Blazing fast, persistent key-value store for Rust
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

use std::{
    sync::Arc,
    thread,
};

use cesiumdb::{
    Db,
    DbOptions,
};

fn main() {
    let opts = DbOptions::new();
    let db = Db::open(opts);

    let key = vec![0u8; 32];
    let val = vec![0u8; 256];

    // Warmup
    for _ in 0..10000 {
        db.put(&key, &val).unwrap();
    }

    let num_threads = [1, 2, 4, 8];
    let ops_per_thread = 100000;

    for &n in &num_threads {
        let db = db.clone();
        let start = std::time::Instant::now();

        let handles: Vec<_> = (0..n)
            .map(|i| {
                let db = db.clone();
                let key = key.clone();
                let val = val.clone();
                thread::spawn(move || {
                    for j in 0..ops_per_thread {
                        let mut k = key.clone();
                        k[0..8].copy_from_slice(&(i as u64).to_le_bytes());
                        k[8..16].copy_from_slice(&(j as u64).to_le_bytes());
                        db.put(&k, &val).unwrap();
                    }
                })
            })
            .collect();

        for h in handles {
            h.join().unwrap();
        }

        let elapsed = start.elapsed();
        let total_ops = n * ops_per_thread;
        let ops_per_sec = total_ops as f64 / elapsed.as_secs_f64();
        println!(
            "{} threads: {:.0} ops/sec ({:?} total)",
            n, ops_per_sec, elapsed
        );
    }
}