Update to MMTk core PR #817 (#141)

Update for mmtk/mmtk-core#817.

Author: qinsoon

mmtk/Cargo.lock

@@ -28,7 +28,7 @@ log = {version = "0.4", features = ["max_level_trace", "release_max_level_off"]
 # - change branch/rev
 # - change repo name
 # But other changes including adding/removing whitespaces in commented lines may break the CI.
-mmtk = { git = "https://github.com/mmtk/mmtk-core.git", rev = "e309f9351dff9cd0c8f3f590002c6edafd158c82" }
+mmtk = { git = "https://github.com/mmtk/mmtk-core.git", rev = "de8bbfe623eee5e915f32870de8f81128df8ad41" }
 # Uncomment the following to build locally - if you change the path locally, do not commit the change in a PR
 # mmtk = { path = "../repos/mmtk-core" }
 

mmtk/Cargo.toml

@@ -6,28 +6,62 @@ use mmtk::vm::ActivePlan;
 use mmtk::Mutator;
 use mmtk::Plan;
 use std::mem;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use JikesRVM;
 use JTOC_BASE;
 use SINGLETON;
 
-static MUTATOR_COUNTER: AtomicUsize = AtomicUsize::new(0);
+use std::sync::{Mutex, MutexGuard};
+
+lazy_static! {
+    static ref MUTATOR_LOCK: Mutex<()> = Mutex::new(());
+}
+
+struct JikesRVMMutatorIterator<'a> {
+    _guard: MutexGuard<'a, ()>,
+    counter: usize,
+}
+
+impl<'a> JikesRVMMutatorIterator<'a> {
+    fn new(guard: MutexGuard<'a, ()>) -> Self {
+        Self {
+            _guard: guard,
+            counter: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for JikesRVMMutatorIterator<'a> {
+    type Item = &'a mut Mutator<JikesRVM>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // We don't need this in the loop for STW-GC
+        let num_threads = unsafe { (JTOC_BASE + NUM_THREADS_FIELD_OFFSET).load::<usize>() };
+        loop {
+            let idx = self.counter;
+            self.counter += 1;
+            if idx >= num_threads {
+                return None;
+            } else {
+                let t = unsafe { VMCollection::thread_from_index(idx) };
+                let is_mutator = unsafe { !(t + IS_COLLECTOR_FIELD_OFFSET).load::<bool>() };
+                if is_mutator {
+                    unsafe {
+                        let mutator = (t + MMTK_HANDLE_FIELD_OFFSET).load::<usize>();
+                        let ret = &mut *(mutator as *mut Mutator<JikesRVM>);
+                        return Some(ret);
+                    }
+                }
+            }
+        }
+    }
+}
 
 #[derive(Default)]
 pub struct VMActivePlan {}
 
 impl ActivePlan<JikesRVM> for VMActivePlan {
     fn number_of_mutators() -> usize {
-        let num_threads = unsafe { (JTOC_BASE + NUM_THREADS_FIELD_OFFSET).load::<usize>() };
-        let mut num_mutators = 0usize;
-        for idx in 0..num_threads {
-            let t = unsafe { VMCollection::thread_from_index(idx) };
-            let is_mutator = unsafe { !(t + IS_COLLECTOR_FIELD_OFFSET).load::<bool>() };
-            if is_mutator {
-                num_mutators += 1;
-            }
-        }
-        num_mutators
+        Self::mutators().count()
     }
 
     fn global() -> &'static dyn Plan<VM = JikesRVM> {
@@ -48,28 +82,8 @@ impl ActivePlan<JikesRVM> for VMActivePlan {
         }
     }
 
-    fn reset_mutator_iterator() {
-        MUTATOR_COUNTER.store(0, Ordering::Relaxed);
-    }
-
-    fn get_next_mutator() -> Option<&'static mut Mutator<JikesRVM>> {
-        // We don't need this in the loop for STW-GC
-        let num_threads = unsafe { (JTOC_BASE + NUM_THREADS_FIELD_OFFSET).load::<usize>() };
-        loop {
-            let idx = MUTATOR_COUNTER.fetch_add(1, Ordering::Relaxed);
-            if idx >= num_threads {
-                return None;
-            } else {
-                let t = unsafe { VMCollection::thread_from_index(idx) };
-                let is_mutator = unsafe { !(t + IS_COLLECTOR_FIELD_OFFSET).load::<bool>() };
-                if is_mutator {
-                    unsafe {
-                        let mutator = (t + MMTK_HANDLE_FIELD_OFFSET).load::<usize>();
-                        let ret = &mut *(mutator as *mut Mutator<JikesRVM>);
-                        return Some(ret);
-                    }
-                }
-            }
-        }
+    fn mutators<'a>() -> Box<dyn Iterator<Item = &'a mut Mutator<JikesRVM>> + 'a> {
+        let guard = MUTATOR_LOCK.lock().unwrap();
+        Box::new(JikesRVMMutatorIterator::new(guard))
     }
 }