safa-api 0.4.3

A high-level API over SafaOS's syscalls
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

use core::{
    cell::UnsafeCell,
    marker::PhantomData,
    ops::Deref,
    sync::atomic::{AtomicBool, Ordering},
};

use crate::syscalls;

enum LazyData<T, F: FnOnce() -> T> {
    Uninitialized(F),
    Initialized(T),
    Initializing,
}

impl<T, F: FnOnce() -> T> LazyData<T, F> {
    fn get_value(&self) -> Option<&T> {
        match self {
            LazyData::Initialized(ref value) => Some(value),
            _ => None,
        }
    }

    fn start_initialize(&mut self) -> F {
        match self {
            LazyData::Uninitialized(_) => {
                let LazyData::Uninitialized(res) = core::mem::replace(self, LazyData::Initializing)
                else {
                    unreachable!()
                };
                res
            }
            _ => panic!("LazyData::start_initialize called on initialized data"),
        }
    }
}

/// Synchronous Lazily initialized value
pub struct LazyCell<T> {
    running_init: AtomicBool,
    value: UnsafeCell<LazyData<T, fn() -> T>>,
    _marker: PhantomData<T>,
}

impl<T> LazyCell<T> {
    pub const fn new(call: fn() -> T) -> Self {
        Self {
            running_init: AtomicBool::new(false),
            value: UnsafeCell::new(LazyData::Uninitialized(call)),
            _marker: PhantomData,
        }
    }

    /// Gets the value or initializes it synchronously if not already initialized.
    pub fn get(&self) -> &T {
        let wait_for_init = || {
            while self.running_init.load(Ordering::Acquire) {
                syscalls::thread::yield_now();
            }

            unsafe {
                (&*self.value.get())
                    .get_value()
                    .expect("Lazy awaited initialization but the value was never initialized")
            }
        };

        match unsafe { &*self.value.get() } {
            LazyData::Initialized(ref value) => value,
            LazyData::Initializing => wait_for_init(),
            LazyData::Uninitialized(_) => {
                if self
                    .running_init
                    .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
                    .is_err()
                {
                    wait_for_init()
                } else {
                    let f = unsafe { (*self.value.get()).start_initialize() };
                    let value = (f)();
                    unsafe {
                        *self.value.get() = LazyData::Initialized(value);
                    }

                    self.running_init.store(false, Ordering::Release);
                    unsafe { (&*self.value.get()).get_value().unwrap() }
                }
            }
        }
    }
}

impl<T> Deref for LazyCell<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        self.get()
    }
}

unsafe impl<T: Send> Send for LazyCell<T> {}
unsafe impl<T: Sync> Sync for LazyCell<T> {}