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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::thread::Thread;
use atomic::Ordering;
use std::{
    marker::PhantomData,
    ptr::{null_mut, NonNull},
    sync::atomic::AtomicPtr,
};

use super::{
    object::{Allocation, Handle},
    traits::Object,
};

static mut HEAD_REF: AtomicPtr<u8> = AtomicPtr::new(null_mut());
unsafe impl<T: ?Sized + Object> Send for WeakReference<T> {}
unsafe impl<T: ?Sized + Object> Sync for WeakReference<T> {}

/// This structs implements weak references.
///
/// When a new weak references is allocated it is atomically linked
/// onto a singly linked list of weak references.
///
/// During a garbage collection this chain is traversed and references
/// are updated or cleared.
///
/// There are two modes of processing weak references.
///
///     1. Ignoring 'Long' References that track resurrection and
///        only updating references that should be cleared when the
///        object is finalized.
///     2. Updating all reference types.
///    
/// In any collection at least the second method must be called to
/// ensure no dangling pointers are created.
pub struct WeakReference<T: ?Sized + Object> {
    ptr: *mut u8,
    next: AtomicPtr<u8>,
    _marker: PhantomData<T>,
}

impl<T: ?Sized + Object> WeakReference<T> {
    pub fn new(thread: &mut Thread, target: Handle<T>) -> Handle<WeakReference<T>>
    where
        T: 'static,
    {
        unsafe {
            let this = thread.allocate(WeakReference {
                ptr: target.as_ptr(),
                next: AtomicPtr::new(null_mut()),
                _marker: PhantomData,
            });

            let this_ptr = this.as_ptr();
            let mut old_val = HEAD_REF.load(Ordering::Relaxed);
            loop {
                this.next.store(old_val, Ordering::Relaxed);
                match HEAD_REF.compare_exchange_weak(
                    old_val,
                    this_ptr,
                    Ordering::Relaxed,
                    Ordering::Relaxed,
                ) {
                    Ok(_) => break,
                    Err(val) => old_val = val,
                }
            }

            this
        }
    }

    pub(crate) unsafe fn process(mut update_reference: impl FnMut(*mut u8) -> *mut u8) {
        let mut wr = HEAD_REF.load(Ordering::Relaxed);
        let mut tail = null_mut::<WeakReference<dyn Object>>();

        while !wr.is_null() {
            let weak = wr as *mut WeakReference<dyn Object>;
            let next = (*weak).next.load(Ordering::Relaxed);
            wr = update_reference(wr);
            if wr.is_null() {
                println!("unlinking weak reference {:p}", weak);
                wr = next;
                if !tail.is_null() {
                    (*tail).next = AtomicPtr::new(wr);
                } else {
                    HEAD_REF.store(wr, Ordering::Relaxed);
                }
            } else {
                let target = update_reference((*weak).ptr);

                (*weak).ptr = target;

                if tail.is_null() {
                    HEAD_REF.store(wr, Ordering::Relaxed);
                } else {
                    (*tail).next = AtomicPtr::new(wr);
                }

                tail = weak;
                wr = next;
            }
        }
    }

    pub fn upgrade(&self) -> Option<Handle<T>> {
        unsafe {
            let ptr = self.ptr;
            if ptr.is_null() {
                return None;
            }

            Some(Handle::from_raw(ptr))
        }
    }
}

unsafe impl<T: ?Sized + Object> Object for WeakReference<T> {}
unsafe impl<T: ?Sized + Object> Allocation for WeakReference<T> {}

pub struct WeakMapping<K: ?Sized + Object, V: ?Sized + Object> {
    key: *mut u8,
    value: Handle<V>,
    next: AtomicPtr<u8>,
    marker: PhantomData<K>,
}