gc-lite 0.6.0

A simple partitioned garbage collector
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

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) 2025-2026 John Ray <996351336@qq.com>

use std::{alloc::Layout, ptr::NonNull};

use crate::{GcHead, GcNode, GcTrace, trace::GcTraceCtx};

#[derive(Debug, Copy, Clone)]
#[allow(dead_code)]
pub struct GcTypeInfo {
    /// `std::mem::size_of::<T>()` — the Rust size of the payload type T
    pub size: usize,
    /// Byte offset from GcHead to the payload, equals `payload_offset_of::<T>()`
    pub payload_offset: usize,
    /// Total allocation size (GcHead + payload, aligned), equals `layout_size_of::<T>()`
    ///
    /// This value is compile-time constant, set by the `gc_type_table_internal` macro
    /// via `layout_size_of::<T>()`. It must match the Layout used in `alloc_node_mem`.
    pub layout_size: usize,
    /// Allocation alignment, equals `layout_align_of::<T>()`
    ///
    /// This value is compile-time constant, set by the `gc_type_table_internal` macro
    /// via `layout_align_of::<T>()`. It must match the Layout used in `alloc_node_mem`.
    pub layout_align: usize,
    pub trace_fn: fn(NonNull<GcHead>, &mut GcTraceCtx),
    pub drop_fn: Option<unsafe fn(*mut u8)>,
    pub drop_pass: u8,
}

impl GcTypeInfo {
    #[inline(always)]
    pub fn layout(&self) -> Layout {
        #[cfg(debug_assertions)]
        {
            Layout::from_size_align(self.layout_size, self.layout_align).unwrap()
        }

        #[cfg(not(debug_assertions))]
        unsafe {
            Layout::from_size_align_unchecked(self.layout_size, self.layout_align)
        }
    }

    #[inline(always)]
    pub fn payload_ptr(&self, node: NonNull<GcHead>) -> NonNull<u8> {
        unsafe { node.cast::<u8>().add(self.payload_offset) }
    }
}

#[inline(always)]
const fn align_up(value: usize, align: usize) -> usize {
    let mask = align - 1;
    (value + mask) & !mask
}

#[inline(always)]
pub const fn payload_offset_of<T>() -> usize {
    align_up(std::mem::size_of::<GcHead>(), std::mem::align_of::<T>())
}

/// Total allocation size for a GC node of type T: aligned size of (GcHead + payload).
///
/// This is a compile-time constant (`const fn`). The resulting value is stored in
/// `GcTypeInfo::layout_size` by the `gc_type_table_internal` macro, and must match
/// the Layout passed to `std::alloc::alloc` / `std::alloc::dealloc`.
#[inline(always)]
pub const fn layout_size_of<T>() -> usize {
    align_up(
        payload_offset_of::<T>() + std::mem::size_of::<T>(),
        layout_align_of::<T>(),
    )
}

/// Allocation alignment for a GC node of type T: max(GcHead alignment, T alignment).
///
/// This is a compile-time constant (`const fn`). The resulting value is stored in
/// `GcTypeInfo::layout_align` by the `gc_type_table_internal` macro, and must match
/// the Layout passed to `std::alloc::alloc` / `std::alloc::dealloc`.
#[inline(always)]
pub const fn layout_align_of<T>() -> usize {
    let head_align = std::mem::align_of::<GcHead>();
    let payload_align = std::mem::align_of::<T>();
    if head_align > payload_align {
        head_align
    } else {
        payload_align
    }
}

pub fn gctype_trace<T: GcTrace>(node: NonNull<GcHead>, gcx: &mut GcTraceCtx) {
    unsafe {
        node.cast::<u8>()
            .add(payload_offset_of::<T>())
            .cast::<T>()
            .as_ref()
            .trace(gcx);
    }
}

/// Generic dispose function, used to call drop_in_place of specific type
pub fn gctype_drop<T: GcNode>(data_ptr: *mut u8) {
    unsafe { std::ptr::drop_in_place(data_ptr.cast::<T>()) };
}

pub struct GcTypeRegistry {
    pub type_info_list: &'static [GcTypeInfo],
    pub drop_passes: &'static [u8],
}

impl GcTypeRegistry {
    pub const fn empty() -> &'static GcTypeRegistry {
        &GcTypeRegistry {
            type_info_list: &[],
            drop_passes: &[],
        }
    }
}