divbuf 0.4.1

Buffer object that can be recursively divided into smaller buffers
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

// vim: tw=80

use std::{
    sync::atomic::{AtomicBool, Ordering::Relaxed},
    thread,
    time,
};

use divbuf::*;
use lazy_static::lazy_static;

lazy_static! {
    pub static ref DBS: DivBufShared = DivBufShared::from(vec![0; 4096]);
    pub static ref SHUTDOWN: AtomicBool = AtomicBool::new(false);
}

fn readfunc() {
    let mut losses: u64 = 0;
    let mut wins: u64 = 0;
    while !SHUTDOWN.load(Relaxed) {
        if let Ok(db) = (DBS).try_const() {
            let mut db0 = db.slice(0, 1024);
            let db1 = db.slice(1024, 2048);
            db0.unsplit(db1).unwrap();
            wins += 1;
        } else {
            losses += 1;
        }
    }
    println!("reader won {} races and lost {}", wins, losses);
}

fn writefunc() {
    let mut losses: u64 = 0;
    let mut wins: u64 = 0;
    while !SHUTDOWN.load(Relaxed) {
        if let Ok(mut dbm) = (DBS).try_mut() {
            let dbm1 = dbm.split_off(2048);
            dbm.unsplit(dbm1).unwrap();
            wins += 1;
        } else {
            losses += 1;
        }
    }
    println!("writer won {} races and lost {}", wins, losses);
}

/// Create a multitude of threads that each try to divide a common static
/// buffer.  They run for a fixed time.  Success happens if nobody panics.
#[test]
fn test_thread_race() {
    let reader0 = thread::spawn(readfunc);
    let reader1 = thread::spawn(readfunc);
    let writer0 = thread::spawn(writefunc);
    let writer1 = thread::spawn(writefunc);
    thread::sleep(time::Duration::from_secs(1));
    SHUTDOWN.store(true, Relaxed);
    reader0.join().unwrap();
    reader1.join().unwrap();
    writer0.join().unwrap();
    writer1.join().unwrap();
}