armdb 0.1.12

sharded bitcask key-value storage optimized for NVMe
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

#[cfg(feature = "var-collections")]
use armdb::VarTree;
use armdb::{Config, ConstTree};
use std::sync::Arc;
use std::thread;
use tempfile::tempdir;

#[test]
fn test_concurrent_writes() {
    let dir = tempdir().expect("failed to create tempdir");
    let config = Config::test();
    let tree = Arc::new(
        ConstTree::<[u8; 8], 8>::open(dir.path(), config).expect("failed to create const tree"),
    );

    let mut handles = Vec::new();

    for t in 0..4u64 {
        let tree = Arc::clone(&tree);
        let handle = thread::spawn(move || {
            let start = t * 250;
            let end = start + 250;
            for i in start..end {
                let key = i.to_be_bytes();
                let value = (i * 7).to_be_bytes();
                tree.put(&key, &value).expect("put failed");
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().expect("thread panicked");
    }

    assert_eq!(tree.len(), 1000);

    for i in 0..1000u64 {
        let key = i.to_be_bytes();
        let expected = (i * 7).to_be_bytes();
        let val = tree
            .get(&key)
            .unwrap_or_else(|| panic!("key {} not found", i));
        assert_eq!(val, expected, "value mismatch for key {}", i);
    }
}

#[test]
fn test_concurrent_read_write() {
    let dir = tempdir().expect("failed to create tempdir");
    let config = Config::test();
    let tree = Arc::new(
        ConstTree::<[u8; 8], 8>::open(dir.path(), config).expect("failed to create const tree"),
    );

    // Pre-populate with keys 0..100
    for i in 0..100u64 {
        let key = i.to_be_bytes();
        let value = (i * 7).to_be_bytes();
        tree.put(&key, &value).expect("pre-populate put failed");
    }

    let mut handles = Vec::new();

    // Writer thread: writes keys 100..1000
    {
        let tree = Arc::clone(&tree);
        let handle = thread::spawn(move || {
            for i in 100..1000u64 {
                let key = i.to_be_bytes();
                let value = (i * 7).to_be_bytes();
                tree.put(&key, &value).expect("writer put failed");
            }
        });
        handles.push(handle);
    }

    // 3 reader threads
    for _ in 0..3 {
        let tree = Arc::clone(&tree);
        let handle = thread::spawn(move || {
            for iter in 0..1000u64 {
                // Derive a key from the iteration to cover the full range deterministically
                let i = iter % 1000;
                let key = i.to_be_bytes();
                if let Some(val) = tree.get(&key) {
                    let expected = (i * 7).to_be_bytes();
                    assert_eq!(val, expected, "reader got wrong value for key {}", i);
                }
                // None is fine — the writer may not have reached this key yet
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().expect("thread panicked");
    }

    // Verify final state: all 1000 keys present
    assert_eq!(tree.len(), 1000);

    for i in 0..1000u64 {
        let key = i.to_be_bytes();
        let expected = (i * 7).to_be_bytes();
        let val = tree
            .get(&key)
            .unwrap_or_else(|| panic!("key {} not found after join", i));
        assert_eq!(val, expected, "final value mismatch for key {}", i);
    }
}

#[cfg(feature = "var-collections")]
#[test]
fn test_concurrent_var_writes() {
    let dir = tempdir().expect("failed to create tempdir");
    let config = Config::test();
    let tree =
        Arc::new(VarTree::<[u8; 8]>::open(dir.path(), config).expect("failed to create var tree"));

    let mut handles = Vec::new();

    for t in 0..4u64 {
        let tree = Arc::clone(&tree);
        let handle = thread::spawn(move || {
            let start = t * 250;
            let end = start + 250;
            for i in start..end {
                let key = i.to_be_bytes();
                let value = format!("val_{}", i).into_bytes();
                tree.put(&key, &value).expect("var put failed");
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().expect("thread panicked");
    }

    assert_eq!(tree.len(), 1000);

    for i in 0..1000u64 {
        let key = i.to_be_bytes();
        let expected = format!("val_{}", i).into_bytes();
        let val = tree
            .get(&key)
            .unwrap_or_else(|| panic!("var key {} not found", i));
        assert_eq!(
            val.as_ref(),
            expected.as_slice(),
            "var value mismatch for key {}",
            i
        );
    }
}