process-sync 0.2.2

Synchronization primitives for multiprocess environments
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

mod common;

use libc::fork;
pub use process_sync::private::SharedMemoryObject;
use process_sync::{private::check_libc_err, SharedCondvar, SharedMutex};

use common::{sleep, TestOutput};

fn child0(test_output: &mut TestOutput, mutex: &mut SharedMutex, condvar: &mut SharedCondvar) -> ! {
    test_output.write_line("child0 lock()");
    mutex.lock().expect("lock() failed");
    test_output.write_line("child0 wait()");
    condvar.wait(mutex).expect("wait() failed");
    mutex.unlock().expect("unlock() failed");
    test_output.write_line("child0 unlocked");
    sleep(5);

    test_output.write_line("child0 FIRST_TEST_END");
    sleep(100);

    test_output.write_line("child0 lock()");
    mutex.lock().expect("lock() failed");
    test_output.write_line("child0 wait()");
    condvar.wait(mutex).expect("wait() failed");
    test_output.write_line("child0 unlock()");
    mutex.unlock().expect("unlock() failed");
    test_output.write_line("child0 unlocked");

    std::process::exit(0);
}

fn child1(test_output: &mut TestOutput, mutex: &mut SharedMutex, condvar: &mut SharedCondvar) {
    sleep(10);
    test_output.write_line("child1 lock()");
    mutex.lock().expect("lock() failed");
    test_output.write_line("child1 wait()");
    condvar.wait(mutex).expect("wait() failed");
    mutex.unlock().expect("unlock() failed");
    sleep(10);
    test_output.write_line("child1 unlocked");

    test_output.write_line("child1 FIRST_TEST_END");
    sleep(50);

    test_output.write_line("child1 lock()");
    mutex.lock().expect("lock() failed");
    test_output.write_line("child1 wait()");
    condvar.wait(mutex).expect("wait() failed");
    test_output.write_line("child1 unlock()");
    mutex.unlock().expect("unlock() failed");
    test_output.write_line("child1 unlocked");

    std::process::exit(0);
}

fn parent(test_output: &mut TestOutput, _mutex: &mut SharedMutex, condvar: &mut SharedCondvar) {
    sleep(40);
    test_output.write_line("parent notify_all()");
    condvar.notify_all().expect("notify_all() failed");

    test_output.write_line("parent FIRST_TEST_END");
    sleep(300);

    test_output.write_line("parent notify_one()");
    condvar.notify_one().expect("notify_one() failed");
    sleep(10);
    test_output.write_line("parent notify_one()");
    condvar.notify_one().expect("notify_one() failed");

    sleep(40);
}

fn main() {
    let mut test_output = TestOutput::new(&[
        "child0 lock()",
        "child0 wait()",
        "child1 lock()",
        "child1 wait()",
        "parent notify_all()",
        "parent FIRST_TEST_END",
        "child0 unlocked",
        "child0 FIRST_TEST_END",
        "child1 unlocked",
        "child1 FIRST_TEST_END",
        "child1 lock()",
        "child1 wait()",
        "child0 lock()",
        "child0 wait()",
        "parent notify_one()",
        "child1 unlock()",
        "child1 unlocked",
        "parent notify_one()",
        "child0 unlock()",
        "child0 unlocked",
    ]);

    let mut mutex = SharedMutex::new().expect("cannot create SharedMutex");
    let mut condvar = SharedCondvar::new().expect("cannot create SharedCondvar");

    let pid = check_libc_err(unsafe { fork() }).expect("fork failed");
    if pid == 0 {
        child0(&mut test_output, &mut mutex, &mut condvar);
    } else {
        let pid = check_libc_err(unsafe { fork() }).expect("fork failed");
        if pid == 0 {
            child1(&mut test_output, &mut mutex, &mut condvar);
        } else {
            parent(&mut test_output, &mut mutex, &mut condvar);
        }
    }
}