Remove the global JavaThreadIteratorWithHandle

Author: qinsoon

mmtk/src/abi.rs

@@ -404,6 +404,38 @@ pub fn validate_memory_layouts() {
             ^ mem::size_of::<InstanceClassLoaderKlass>()
             ^ mem::size_of::<TypeArrayKlass>()
             ^ mem::size_of::<ObjArrayKlass>()
+            ^ mem::size_of::<JavaThreadIteratorWithHandle>()
     };
     assert_eq!(vm_checksum, binding_checksum);
 }
+
+// hotspot/share/runtime/threadSMR.hpp
+#[repr(C)]
+pub struct SafeThreadsListPtr {
+    _previous: *mut libc::c_void,
+    _thread: *mut libc::c_void,
+    _list: *mut libc::c_void,
+    _has_ref_count: bool,
+    _needs_release: bool,
+}
+
+#[repr(C)]
+pub struct ElapsedTimer {
+    _counter: i64,
+    _start_counter: i64,
+    _active: bool,
+}
+
+#[repr(C)]
+pub struct ThreadsListHandle {
+    vtable: *mut libc::c_void,
+    _list_ptr: SafeThreadsListPtr,
+    _timer: ElapsedTimer,
+}
+
+#[repr(C)]
+pub struct JavaThreadIteratorWithHandle {
+    vtable: *mut libc::c_void,
+    _tlh: ThreadsListHandle,
+    _index: u32,
+}

mmtk/src/active_plan.rs

@@ -1,31 +1,38 @@
 use crate::OpenJDK;
 use crate::SINGLETON;
 use crate::UPCALLS;
+use crate::abi::JavaThreadIteratorWithHandle;
 use mmtk::util::opaque_pointer::*;
 use mmtk::vm::ActivePlan;
 use mmtk::Mutator;
 use mmtk::Plan;
-use std::sync::{Mutex, MutexGuard};
+use std::marker::PhantomData;
+use std::mem::MaybeUninit;
 
 struct OpenJDKMutatorIterator<'a> {
-    _guard: MutexGuard<'a, ()>,
+    handle: MaybeUninit<JavaThreadIteratorWithHandle>,
+    _p: PhantomData<&'a ()>
 }
 
 impl<'a> OpenJDKMutatorIterator<'a> {
-    fn new(guard: MutexGuard<'a, ()>) -> Self {
-        // Reset mutator iterator
+    fn new() -> Self {
+        let mut iter = Self {
+            handle: MaybeUninit::uninit(),
+            _p: PhantomData,
+        };
+        // Create JavaThreadIteratorWithHandle
         unsafe {
-            ((*UPCALLS).reset_mutator_iterator)();
+            ((*UPCALLS).new_java_thread_iterator)(iter.handle.as_mut_ptr());
         }
-        Self { _guard: guard }
+        iter
     }
 }
 
 impl<'a> Iterator for OpenJDKMutatorIterator<'a> {
     type Item = &'a mut Mutator<OpenJDK>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let next = unsafe { ((*UPCALLS).get_next_mutator)() };
+        let next = unsafe { ((*UPCALLS).java_thread_iterator_next)(self.handle.as_mut_ptr()) };
         if next.is_null() {
             None
         } else {
@@ -53,15 +60,11 @@ impl ActivePlan<OpenJDK> for VMActivePlan {
     }
 
     fn mutators<'a>() -> Box<dyn Iterator<Item = &'a mut Mutator<OpenJDK>> + 'a> {
-        let guard = MUTATOR_ITERATOR_LOCK.lock().unwrap();
-        Box::new(OpenJDKMutatorIterator::new(guard))
+        Box::new(OpenJDKMutatorIterator::new())
     }
 
     fn number_of_mutators() -> usize {
         unsafe { ((*UPCALLS).number_of_mutators)() }
     }
 }
 
-lazy_static! {
-    pub static ref MUTATOR_ITERATOR_LOCK: Mutex<()> = Mutex::new(());
-}

mmtk/src/lib.rs

@@ -62,8 +62,6 @@ pub struct OpenJDK_Upcalls {
     pub spawn_gc_thread: extern "C" fn(tls: VMThread, kind: libc::c_int, ctx: *mut libc::c_void),
     pub block_for_gc: extern "C" fn(),
     pub out_of_memory: extern "C" fn(tls: VMThread, err_kind: AllocationError),
-    pub get_next_mutator: extern "C" fn() -> *mut Mutator<OpenJDK>,
-    pub reset_mutator_iterator: extern "C" fn(),
     pub scan_object: extern "C" fn(trace: *mut c_void, object: ObjectReference, tls: OpaquePointer),
     pub dump_object: extern "C" fn(object: ObjectReference),
     pub get_object_size: extern "C" fn(object: ObjectReference) -> usize,
@@ -95,6 +93,8 @@ pub struct OpenJDK_Upcalls {
     pub schedule_finalizer: extern "C" fn(),
     pub prepare_for_roots_re_scanning: extern "C" fn(),
     pub enqueue_references: extern "C" fn(objects: *const ObjectReference, len: usize),
+    pub new_java_thread_iterator: extern "C" fn(iter: *mut abi::JavaThreadIteratorWithHandle),
+    pub java_thread_iterator_next: extern "C" fn(iter: *mut abi::JavaThreadIteratorWithHandle) -> *mut Mutator<OpenJDK>,
 }
 
 pub static mut UPCALLS: *const OpenJDK_Upcalls = null_mut();

openjdk/mmtk.h

@@ -149,8 +149,6 @@ typedef struct {
     void (*spawn_gc_thread) (void *tls, int kind, void *ctx);
     void (*block_for_gc) ();
     void (*out_of_memory) (void *tls, MMTkAllocationError err_kind);
-    void* (*get_next_mutator) ();
-    void (*reset_mutator_iterator) ();
     void (*scan_object) (void* trace, void* object, void* tls);
     void (*dump_object) (void* object);
     size_t (*get_object_size) (void* object);
@@ -182,6 +180,8 @@ typedef struct {
     void (*schedule_finalizer)();
     void (*prepare_for_roots_re_scanning)();
     void (*enqueue_references)(void** objects, size_t len);
+    void (*new_java_thread_iterator)(void*);
+    void* (*java_thread_iterator_next)(void*);
 } OpenJDK_Upcalls;
 
 extern void openjdk_gc_init(OpenJDK_Upcalls *calls);

openjdk/mmtkUpcalls.cpp

@@ -190,27 +190,18 @@ struct MaybeUninit {
   char _data[sizeof(T)];
 };
 
-static MaybeUninit<JavaThreadIteratorWithHandle> jtiwh;
-static bool mutator_iteration_start = true;
+static void mmtk_new_java_thread_iterator(void* iter) {
+  *(JavaThreadIteratorWithHandle*)iter = JavaThreadIteratorWithHandle();
+}
 
-static void* mmtk_get_next_mutator() {
-  if (mutator_iteration_start) {
-    *jtiwh = JavaThreadIteratorWithHandle();
-    mutator_iteration_start = false;
-  }
-  JavaThread *thr = jtiwh->next();
+static void* mmtk_java_thread_iterator_next(void* iter) {
+  JavaThread *thr = ((JavaThreadIteratorWithHandle*)iter)->next();
   if (thr == NULL) {
-    mutator_iteration_start = true;
     return NULL;
   }
   return (void*) &thr->third_party_heap_mutator;
 }
 
-static void mmtk_reset_mutator_iterator() {
-  mutator_iteration_start = true;
-}
-
-
 static void mmtk_scan_all_thread_roots(EdgesClosure closure) {
   MMTkRootsClosure2 cl(closure);
   MMTkHeap::heap()->scan_thread_roots(cl);
@@ -276,7 +267,8 @@ static size_t compute_klass_mem_layout_checksum() {
     ^ sizeof(InstanceMirrorKlass)
     ^ sizeof(InstanceClassLoaderKlass)
     ^ sizeof(TypeArrayKlass)
-    ^ sizeof(ObjArrayKlass);
+    ^ sizeof(ObjArrayKlass)
+    ^ sizeof(JavaThreadIteratorWithHandle);
 }
 
 static int referent_offset() {
@@ -347,8 +339,6 @@ OpenJDK_Upcalls mmtk_upcalls = {
   mmtk_spawn_gc_thread,
   mmtk_block_for_gc,
   mmtk_out_of_memory,
-  mmtk_get_next_mutator,
-  mmtk_reset_mutator_iterator,
   mmtk_scan_object,
   mmtk_dump_object,
   mmtk_get_object_size,
@@ -379,5 +369,7 @@ OpenJDK_Upcalls mmtk_upcalls = {
   mmtk_number_of_mutators,
   mmtk_schedule_finalizer,
   mmtk_prepare_for_roots_re_scanning,
-  mmtk_enqueue_references
+  mmtk_enqueue_references,
+  mmtk_new_java_thread_iterator,
+  mmtk_java_thread_iterator_next,
 };