rsgc 1.1.0

Concurrent GC library for Rust
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

use std::mem::size_of;
use std::ptr::null_mut;
use std::sync::atomic::AtomicUsize;

use super::heap::{heap, Heap};
use super::mark::STWMark;
use super::marking_context::MarkingContext;
use super::safepoint;
use crate::heap::concurrent_gc::PrepareUnsweptRegions;
use crate::heap::controller::GCMode;
use crate::heap::safepoint::SafepointSynchronize;
use crate::heap::sweeper::SweepGarbageClosure;
use crate::heap::thread::Thread;
use crate::heap::PausePhase;
use crate::system::finalizer::finalize;
use crate::system::object::HeapObjectHeader;
use crate::system::traits::{Object, Visitor};
use crate::system::weak_reference::WeakReference;
use parking_lot::lock_api::RawMutex;
use parking_lot::MutexGuard;

/// This implements Full GC (e.g. when invoking [Heap::request_gc](crate::heap::heap::Heap::request_gc)) using a mark-and-sweep algorithm.
///
/// It is done in fully stop-the-world.
pub struct FullGC {
    heap: &'static mut Heap,
    mark_stack: Vec<*mut HeapObjectHeader>,
    mark_ctx: &'static MarkingContext,
}

impl FullGC {
    pub fn new() -> Self {
        Self {
            heap: heap(),
            mark_ctx: heap().marking_context(),
            mark_stack: Vec::with_capacity(128),
        }
    }

    pub unsafe fn do_collect(&mut self) {
        let start = std::time::Instant::now();
        let threads = SafepointSynchronize::begin();
        log::debug!(target: "gc-safepoint", "stopped the world ({} thread(s)) in {} ms", threads.len(), start.elapsed().as_millis());
        let phase = PausePhase::new("Init Mark");
        self.heap.prepare_gc();
        self.heap.clear_cancelled_gc();
        // Phase 0: retire TLABs
        for thread in threads.iter().copied() {
            (*thread).tlab.retire((*thread).id);
        }
        drop(phase);
        {
            let phase = PausePhase::new("Marking");
            // Phase 1: Mark
            self.do_mark(&threads);
            drop(phase);
        }

        {
            let phase = PausePhase::new("Clean up weak references & Finalize");
            WeakReference::<dyn Object>::process(|pointer| {
                let header = pointer.cast::<HeapObjectHeader>().sub(1);

                if self.heap.marking_context().is_marked(header) {
                    pointer
                } else {
                    println!("NULL");
                    null_mut()
                }
            });
            finalize();
            drop(phase);
        }
        

        let phase = PausePhase::new("Sweep");

        let prep = PrepareUnsweptRegions {};

        self.heap.heap_region_iterate(&prep);

        // Phase 3: Sweep
        let closure = SweepGarbageClosure {
            concurrent: false,
            heap: heap(),
            live: AtomicUsize::new(0),
            freed: AtomicUsize::new(0),
        };

        if self.heap.options().parallel_sweep {
            self.heap.parallel_heap_region_iterate(&closure);
        } else {
            self.heap.heap_region_iterate(&closure);
        }

        self.heap.lock.lock();
        self.heap.free_set_mut().rebuild();
        self.heap.lock.unlock();
        drop(phase);
        log::debug!(target: "gc", "STW Mark-and-Sweep done in {} ms, {} live regions after sweep", start.elapsed().as_millis(), closure.live.load(std::sync::atomic::Ordering::Relaxed));
        SafepointSynchronize::end(threads);
    }

    unsafe fn do_mark(&mut self, _threads: &[*mut Thread]) {
        let mark = STWMark::new();
        mark.mark();
    }
}