gc-alloc 0.2.0

A Rust library for garbage-collected memory allocation using libgc (bdwgc).
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

use std::{cell::Cell, ffi::c_void};

mod gc {
    #![allow(non_upper_case_globals, non_camel_case_types, non_snake_case, unused)]

    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
}

pub mod boxed;
pub mod cstring;
pub mod string;
pub mod vec;

thread_local! {
    static GC_REGISTERED: Cell<bool> = const { Cell::new(false) };
}

pub fn init() -> ThreadToken {
    unsafe {
        gc::GC_init();
        gc::GC_allow_register_threads();
    }

    GC_REGISTERED.set(true);

    ThreadToken {
        _non_send: std::marker::PhantomData,
    }
}

pub fn init_thread() -> ThreadGuard {
    assert!(
        !GC_REGISTERED.get() && unsafe { gc::GC_thread_is_registered() } == 0,
        "Thread is already registered with the GC. "
    );

    unsafe extern "C" fn do_register(sb: *mut gc::GC_stack_base, _: *mut c_void) -> *mut c_void {
        let result = unsafe { gc::GC_register_my_thread(sb) };
        assert!(
            result == gc::GC_SUCCESS as i32,
            "Failed to register thread with GC. Error code: {}",
            result
        );
        std::ptr::null_mut()
    }

    unsafe { gc::GC_call_with_stack_base(Some(do_register), std::ptr::null_mut()) };

    GC_REGISTERED.set(true);

    ThreadGuard {
        _non_send: std::marker::PhantomData,
    }
}

pub trait GcToken: private::Sealed {}

pub struct ThreadToken {
    _non_send: std::marker::PhantomData<*const ()>,
}

impl private::Sealed for ThreadToken {}
impl GcToken for ThreadToken {}

impl ThreadToken {
    pub fn get() -> Self {
        Self::try_get()
            .expect("Thread is not registered with the GC. Please call init_thread() first.")
    }

    pub fn try_get() -> Option<Self> {
        if GC_REGISTERED.get() {
            Some(ThreadToken {
                _non_send: std::marker::PhantomData,
            })
        } else {
            None
        }
    }
}

pub struct ThreadGuard {
    _non_send: std::marker::PhantomData<*const ()>,
}

impl private::Sealed for ThreadGuard {}
impl GcToken for ThreadGuard {}

impl Drop for ThreadGuard {
    fn drop(&mut self) {
        unsafe { gc::GC_unregister_my_thread() };
    }
}

mod private {
    pub trait Sealed {}
}