rt 0.19.1

A real-time operating system capable of full preemption
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

#![no_main]
#![cfg_attr(target_os = "none", no_std)]

use core::sync::atomic::{AtomicI32, Ordering};

const MAX_SEQ: i32 = 9;

static SEQ: AtomicI32 = AtomicI32::new(0);

rt::mutex!(MUTEX0);
rt::mutex!(MUTEX1);
rt::mutex!(MUTEX2);

fn sequence(s: i32) {
    assert_eq!(s, SEQ.load(Ordering::Relaxed), "sequence out of order");
    if SEQ.fetch_add(1, Ordering::Relaxed) == MAX_SEQ {
        rt::exit();
    }
}

fn locker0() {
    rt::task::drop_privilege();
    sequence(3);
    {
        let _guard0 = MUTEX0.lock();
        let guard1 = MUTEX1.lock();
        sequence(5);
        drop(guard1);
    }
    sequence(-1);
}

fn locker1() {
    rt::task::drop_privilege();
    sequence(2);
    let guard1 = MUTEX1.lock();
    rt::task::sleep(20);
    sequence(4);
    let _guard2 = MUTEX2.lock();
    drop(guard1);
    sequence(8);
    rt::task::sleep(20);
    sequence(-1);
}

fn spinner() -> ! {
    rt::task::drop_privilege();
    sequence(1);
    rt::task::sleep(10);
    loop {
        rt::task::yield_now();
    }
}

fn donator() {
    rt::task::drop_privilege();
    sequence(0);
    rt::task::sleep(30);
    {
        let _guard0 = MUTEX0.lock();
        sequence(6);
    }
    sequence(7);
    assert!(
        MUTEX2.timed_lock(10).is_none(),
        "donator timedlock succeeded"
    );
    sequence(9);
}

const STACK_SIZE: usize = rt::stack::MIN * 8;

rt::task!(locker0, STACK_SIZE, 3);
rt::task!(locker1, STACK_SIZE, 2);
rt::task!(spinner, STACK_SIZE, 1);
rt::task!(donator, STACK_SIZE, 0);