mmtk 0.3.2

MMTk is a framework for the design and implementation of high-performance and portable memory managers.
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

//! The GC controller thread.

use crate::scheduler::gc_work::ScheduleCollection;
use crate::scheduler::*;
use crate::util::OpaquePointer;
use crate::vm::VMBinding;
use std::marker::PhantomData;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::RwLock;
use std::sync::{Arc, Condvar, Mutex};

struct RequestSync {
    tls: OpaquePointer,
    request_count: isize,
    last_request_count: isize,
}

pub struct ControllerCollectorContext<VM: VMBinding> {
    request_sync: Mutex<RequestSync>,
    request_condvar: Condvar,
    scheduler: RwLock<Option<Arc<MMTkScheduler<VM>>>>,
    request_flag: AtomicBool,
    phantom: PhantomData<VM>,
}

unsafe impl<VM: VMBinding> Sync for ControllerCollectorContext<VM> {}

// Clippy says we need this...
impl<VM: VMBinding> Default for ControllerCollectorContext<VM> {
    fn default() -> Self {
        Self::new()
    }
}

impl<VM: VMBinding> ControllerCollectorContext<VM> {
    pub fn new() -> Self {
        ControllerCollectorContext {
            request_sync: Mutex::new(RequestSync {
                tls: OpaquePointer::UNINITIALIZED,
                request_count: 0,
                last_request_count: -1,
            }),
            request_condvar: Condvar::new(),
            scheduler: RwLock::new(None),
            request_flag: AtomicBool::new(false),
            phantom: PhantomData,
        }
    }

    pub fn init(&self, scheduler: &Arc<MMTkScheduler<VM>>) {
        let mut scheduler_guard = self.scheduler.write().unwrap();
        debug_assert!(scheduler_guard.is_none());
        *scheduler_guard = Some(scheduler.clone());
    }

    pub fn run(&self, tls: OpaquePointer) {
        {
            self.request_sync.lock().unwrap().tls = tls;
        }

        loop {
            debug!("[STWController: Waiting for request...]");
            self.wait_for_request();
            debug!("[STWController: Request recieved.]");

            // For heap growth logic
            // FIXME: This is not used. However, we probably want to set a 'user_triggered' flag
            // when GC is requested.
            // let user_triggered_collection: bool = SelectedPlan::is_user_triggered_collection();

            let scheduler = self.scheduler.read().unwrap();
            let scheduler = scheduler.as_ref().unwrap();
            scheduler.initialize_worker(tls);
            scheduler.set_initializer(Some(ScheduleCollection));
            scheduler.wait_for_completion();
            debug!("[STWController: Worker threads complete!]");
        }
    }

    pub fn request(&self) {
        if self.request_flag.load(Ordering::Relaxed) {
            return;
        }

        let mut guard = self.request_sync.lock().unwrap();
        if !self.request_flag.load(Ordering::Relaxed) {
            self.request_flag.store(true, Ordering::Relaxed);
            guard.request_count += 1;
            self.request_condvar.notify_all();
        }
    }

    pub fn clear_request(&self) {
        let guard = self.request_sync.lock().unwrap();
        self.request_flag.store(false, Ordering::Relaxed);
        drop(guard);
    }

    fn wait_for_request(&self) {
        let mut guard = self.request_sync.lock().unwrap();
        guard.last_request_count += 1;
        while guard.last_request_count == guard.request_count {
            guard = self.request_condvar.wait(guard).unwrap();
        }
    }
}