raw_sync 0.1.5

Lightweight wrapper around OS synchronization primitives
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

use std::thread;
use std::time;

use env_logger::Env;
use log::*;
use raw_sync::{locks::*, Timeout};

type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;

fn test_timeout(id: u8, lock: &dyn LockImpl) {
    info!("[{}] Waiting for lock for 1 second", id);
    let guard = lock.try_lock(Timeout::Val(time::Duration::from_secs(1)));
    if guard.is_err() {
        info!("[{}] Timed out !", id);
    } else {
        info!("[{}] Holding lock for 2s", id);
        thread::sleep(time::Duration::from_secs(2))
    }
}

fn increment_val(id: u8, lock: Box<dyn LockImpl>) {
    loop {
        info!("[{}] Waiting for lock...", id);
        //Read value
        {
            let data_ptr = lock.rlock().unwrap();
            info!("[{}]\t READ LOCKED", id);
            let data = unsafe { &*(*data_ptr as *const usize) };
            if *data >= 5 {
                info!("[{}]\t READ RELEASED", id);
                break;
            }
            thread::sleep(time::Duration::from_secs(1));
            info!("[{}]\t READ RELEASED", id);
        }

        // Write to value
        {
            let data_ptr = lock.lock().unwrap();
            info!("[{}]\t WRITE LOCKED", id);
            let data = unsafe { &mut *(*data_ptr as *mut usize) };
            *data += 1;
            thread::sleep(time::Duration::from_secs(1));
            info!("[{}]\t WRITE RELEASED", id);
        }
    }
    info!("[{}] Done !", id);
}

fn main() -> Result<()> {
    env_logger::from_env(Env::default().default_filter_or("info")).init();
    let mut mem = [0u8; 64];

    test_mutex(mem.as_mut_ptr())?;

    #[cfg(not(windows))]
    test_rwlock(mem.as_mut_ptr())?;

    Ok(())
}

fn test_mutex(mem: *mut u8) -> Result<()> {
    info!("-----------");
    info!("Mutex");
    info!("-----------");
    let mut some_data: usize = 0;

    let mem_ptr = mem as usize;
    let data_ptr = &mut some_data as *mut _ as usize;

    let (lock, _) = unsafe { Mutex::new(mem, data_ptr as _)? };

    let child = thread::spawn(move || {
        let (lock, _) = unsafe { Mutex::from_existing(mem_ptr as _, data_ptr as _).unwrap() };
        test_timeout(2, &*lock);
        increment_val(2, lock);
    });

    test_timeout(1, &*lock);
    increment_val(1, lock);
    let _ = child.join();
    Ok(())
}

#[cfg(not(windows))]
fn test_rwlock(mem: *mut u8) -> Result<()> {
    info!("-----------");
    info!("RwLock");
    info!("-----------");

    let mut some_data: usize = 0;

    let mem_ptr = mem as usize;
    let data_ptr = &mut some_data as *mut _ as usize;

    let (lock, _) = unsafe { RwLock::new(mem, data_ptr as _)? };

    let child = thread::spawn(move || {
        let (lock, _) = unsafe { RwLock::from_existing(mem_ptr as _, data_ptr as _).unwrap() };
        test_timeout(2, &*lock);
        increment_val(2, lock);
    });

    test_timeout(1, &*lock);
    increment_val(1, lock);
    let _ = child.join();
    Ok(())
}