drone-core 0.14.3

The core crate for Drone, an Embedded Operating System. 
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
112

#![feature(generators)]
#![no_implicit_prelude]

use ::drone_core::{
    fib, thr,
    thr::{prelude::*, Thread},
    token::Token,
};
use ::std::{
    assert_eq,
    clone::Clone,
    ops::Drop,
    sync::{
        atomic::{AtomicI8, Ordering::*},
        Arc,
    },
};

thr::pool! {
    /// Test doc attribute
    #[doc = "test attribute"]
    thread => Thr {
        #[allow(dead_code)]
        pub bar: isize = 1 - 2;
    };

    /// Test doc attribute
    #[doc = "test attribute"]
    local => ThrLocal {
        #[allow(dead_code)]
        pub foo: usize = 0;
    };

    /// Test doc attribute
    #[doc = "test attribute"]
    index => Thrs;

    threads => {
        thr0;
        thr1;
        thr2;
    }
}

struct Counter(Arc<AtomicI8>);

impl Drop for Counter {
    fn drop(&mut self) {
        self.0.fetch_xor(0xFFu8 as i8, Relaxed);
    }
}

#[test]
fn fiber() {
    let counter = Arc::new(AtomicI8::new(0));
    let inner = Counter(Arc::clone(&counter));
    unsafe {
        let thr = Thr0::take();
        thr.add(move || {
            while inner.0.fetch_add(1, Relaxed) < 2 {
                yield;
            }
        });
        assert_eq!(counter.load(Relaxed), 0);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), 1);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), 2);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), -4);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), -4);
    }
}

#[test]
fn fiber_fn() {
    let counter = Arc::new(AtomicI8::new(0));
    let inner = Counter(Arc::clone(&counter));
    unsafe {
        let thr = Thr1::take();
        thr.add_fn(move || {
            if inner.0.fetch_add(1, Relaxed) < 2 { fib::Yielded(()) } else { fib::Complete(()) }
        });
        assert_eq!(counter.load(Relaxed), 0);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), 1);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), 2);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), -4);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), -4);
    }
}

#[test]
fn fiber_once() {
    let counter = Arc::new(AtomicI8::new(0));
    let inner = Counter(Arc::clone(&counter));
    unsafe {
        let thr = Thr2::take();
        thr.add_once(move || {
            inner.0.fetch_add(1, Relaxed);
        });
        assert_eq!(counter.load(Relaxed), 0);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), -2);
        thr.to_thr().fib_chain().drain();
        assert_eq!(counter.load(Relaxed), -2);
    }
}