ferroc 0.3.0

A fast & lock-free memory allocator library
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
112
113
114
115
116
117
118

#[cfg(feature = "libc")]
#[allow(unused_imports)]
pub use libc::{pthread_key_create, pthread_key_delete, pthread_setspecific};

#[macro_export]
#[doc(hidden)]
#[allow_internal_unsafe]
#[allow_internal_unstable(thread_local)]
macro_rules! thread_statics {
    () => {
        use core::mem::{ManuallyDrop, MaybeUninit};

        use super::{Context, Heap, ARENAS};

        #[thread_local]
        static mut CX: MaybeUninit<Context> = MaybeUninit::uninit();

        #[thread_local]
        static mut HEAP: ManuallyDrop<Heap> = ManuallyDrop::new(Heap::new_uninit());

        #[inline]
        pub fn with<T>(f: impl FnOnce(&Heap) -> T) -> T {
            if !unsafe { HEAP.is_init() } {
                unsafe {
                    init();
                    let cx = CX.write(Context::new(&ARENAS));
                    HEAP.init(cx);
                }
            }
            f(unsafe { &*core::ptr::addr_of!(HEAP) })
        }

        pub fn with_uninit<T>(f: impl FnOnce(&Heap) -> T) -> T {
            f(unsafe { &*core::ptr::addr_of!(HEAP) })
        }
    };
}

#[cfg(feature = "libc")]
#[macro_export]
#[doc(hidden)]
macro_rules! thread_init_pthread {
    () => {
        unsafe fn init() {
            unsafe extern "C" fn fini(_: *mut core::ffi::c_void) {
                if HEAP.is_init() {
                    ManuallyDrop::drop(&mut *core::ptr::addr_of_mut!(HEAP));
                    CX.assume_init_drop();
                }
            }

            register_thread_dtor(core::ptr::NonNull::dangling().as_ptr(), fini);
        }

        unsafe fn register_thread_dtor(
            data: *mut core::ffi::c_void,
            dtor: unsafe extern "C" fn(*mut core::ffi::c_void),
        ) {
            use core::sync::atomic::{AtomicUsize, Ordering::*};

            const VAL_INIT: usize = usize::MAX;
            static KEY_INIT: AtomicUsize = AtomicUsize::new(VAL_INIT);

            let mut key = KEY_INIT.load(Relaxed);
            if key == VAL_INIT {
                let mut new = 0;
                let ret = $crate::global::thread::pthread_key_create(&mut new, Some(dtor));
                assert_eq!(ret, 0);
                key = new as usize;

                if let Err(already_set) = KEY_INIT.compare_exchange(VAL_INIT, key, AcqRel, Acquire)
                {
                    let _ = $crate::global::thread::pthread_key_delete(key as _);
                    key = already_set;
                }
            }
            let ret = $crate::global::thread::pthread_setspecific(key as _, data);
            assert_eq!(ret, 0);
        }
    };
}

#[cfg(not(feature = "libc"))]
#[macro_export]
#[doc(hidden)]
macro_rules! thread_init_pthread {
    () => {
        $crate::thread_init!();
        compile_error!(
            "cannot use `pthread` thread-local destructors while not enabling feature `libc`"
        );
    };
}

#[macro_export]
#[doc(hidden)]
macro_rules! thread_init {
    () => {
        unsafe fn init() {}
    };
}

#[macro_export]
#[doc(hidden)]
macro_rules! thread_mod {
    () => {
        mod thread {
            $crate::thread_statics!();
            $crate::thread_init!();
        }
    };
    (pthread) => {
        mod thread {
            $crate::thread_statics!();
            $crate::thread_init_pthread!();
        }
    };
}