triblespace-core 0.47.1

The triblespace core implementation.
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

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

use triblespace_core::patch::{Entry, IdentitySchema, PATCH};

type TestPatch = PATCH<16, IdentitySchema, ()>;

#[test]
fn concurrent_entry_first_use_observes_one_immutable_key() {
    const WORKERS: usize = 16;
    let barrier = Arc::new(Barrier::new(WORKERS));
    let key = [0xa5; 16];

    let threads: Vec<_> = (0..WORKERS)
        .map(|_| {
            let barrier = barrier.clone();
            thread::spawn(move || {
                barrier.wait();

                // Every worker deliberately constructs its Entry before its
                // first PATCH, racing the process-global initialization seam.
                let entry = Entry::new(&key);
                let mut patch = TestPatch::new();
                patch.insert(&entry);
                patch
            })
        })
        .collect();

    let patches: Vec<_> = threads
        .into_iter()
        .map(|thread| thread.join().expect("hash-initialization worker panicked"))
        .collect();

    let reference_entry = Entry::new(&key);
    let mut reference = TestPatch::new();
    reference.insert(&reference_entry);
    for patch in patches {
        assert_eq!(patch, reference);
    }
}