Cleanup

Author: qinsoon

julia/mmtk_julia.c

@@ -348,6 +348,7 @@ size_t get_so_size(void* obj_raw)
 
 extern void run_finalizers(jl_task_t *ct);
 
+// Called after GC to run finalizers
 void mmtk_jl_run_finalizers(void* ptls_raw) {
     jl_ptls_t ptls = (jl_ptls_t) ptls_raw;
     if (!ptls->finalizers_inhibited && ptls->locks.len == 0) {
@@ -356,10 +357,12 @@ void mmtk_jl_run_finalizers(void* ptls_raw) {
     }
 }
 
+// We implement finalization in the binding side. These functions
+// returns some pointers so MMTk can manipulate finalizer lists.
+
 extern jl_mutex_t finalizers_lock;
 extern arraylist_t to_finalize;
 extern arraylist_t finalizer_list_marked;
-extern int prev_sweep_full;
 
 void* get_thread_finalizer_list(void* ptls_raw) {
     jl_ptls_t ptls = (jl_ptls_t) ptls_raw;
@@ -374,6 +377,10 @@ void* get_marked_finalizers_list(void) {
     return (void*)&finalizer_list_marked;
 }
 
+int* get_jl_gc_have_pending_finalizers(void) {
+    return (int*)&jl_gc_have_pending_finalizers;
+}
+
 // add the initial root set to mmtk roots
 static void queue_roots(void)
 {
@@ -894,10 +901,6 @@ uintptr_t get_abi_structs_checksum_c(void) {
     return sizeof(MMTkMutatorContext);
 }
 
-int* get_jl_gc_have_pending_finalizers(void) {
-    return (int*)&jl_gc_have_pending_finalizers;
-}
-
 Julia_Upcalls mmtk_upcalls = (Julia_Upcalls) {
     .scan_julia_obj = scan_julia_obj,
     .scan_julia_exc_obj = scan_julia_exc_obj,

mmtk/api/mmtk.h

@@ -57,8 +57,6 @@ extern int mmtk_object_is_managed_by_mmtk(void* addr);
 extern void mmtk_runtime_panic(void);
 extern void mmtk_unreachable(void);
 
-extern uint8_t mmtk_is_current_gc_nursery(void);
-
 extern void mmtk_set_vm_space(void* addr, size_t size);
 extern void mmtk_immortal_region_post_alloc(void* addr, size_t size);
 
@@ -83,7 +81,6 @@ typedef struct {
     void (* scan_julia_exc_obj) (void* obj, closure_pointer closure, ProcessEdgeFn process_edge);
     void* (* get_stackbase) (int16_t tid);
     void (* calculate_roots) (void* tls);
-    // void (* run_finalizer_function) (void* obj, void* function, bool is_ptr);
     int (* get_jl_last_err) (void);
     void (* set_jl_last_err) (int e);
     size_t (* get_lo_size) (void* obj);

mmtk/src/api.rs

@@ -599,11 +599,3 @@ pub extern "C" fn mmtk_get_obj_size(obj: ObjectReference) -> usize {
         addr_size.load::<u64>() as usize
     }
 }
-
-#[no_mangle]
-pub extern "C" fn mmtk_is_current_gc_nursery() -> bool {
-    match SINGLETON.get_plan().generational() {
-        Some(gen) => gen.is_current_gc_nursery(),
-        None => false,
-    }
-}

mmtk/src/collection.rs

@@ -140,3 +140,10 @@ impl Collection<JuliaVM> for VMCollection {
     ) {
     }
 }
+
+pub fn is_current_gc_nursery() -> bool {
+    match crate::SINGLETON.get_plan().generational() {
+        Some(gen) => gen.is_current_gc_nursery(),
+        None => false,
+    }
+}

mmtk/src/finalizer.rs renamed to mmtk/src/julia_finalizer.rs

@@ -16,8 +16,10 @@ pub fn scan_finalizers_in_rust<T: ObjectTracer>(tracer: &mut T) {
     let jl_gc_have_pending_finalizers: *mut i32 =
         unsafe { ((*UPCALLS).get_jl_gc_have_pending_finalizers)() };
 
+    // Current length of marked list: we only need to trace objects after this length if this is a nursery GC.
     let mut orig_marked_len = marked_finalizers_list.len;
 
+    // Sweep thread local list: if they are not alive, move to to_finalize.
     for mutator in <JuliaVM as VMBinding>::VMActivePlan::mutators() {
         let list = ArrayListT::thread_local_finalizer_list(mutator);
         sweep_finalizer_list(
@@ -28,7 +30,8 @@ pub fn scan_finalizers_in_rust<T: ObjectTracer>(tracer: &mut T) {
         );
     }
 
-    if !crate::api::mmtk_is_current_gc_nursery() {
+    // If this is a full heap GC, we also sweep marked list.
+    if !crate::collection::is_current_gc_nursery() {
         sweep_finalizer_list(
             marked_finalizers_list,
             to_finalize,
@@ -38,12 +41,14 @@ pub fn scan_finalizers_in_rust<T: ObjectTracer>(tracer: &mut T) {
         orig_marked_len = 0;
     }
 
+    // Go through thread local list again and trace objects
     for mutator in <JuliaVM as VMBinding>::VMActivePlan::mutators() {
         let list = ArrayListT::thread_local_finalizer_list(mutator);
         mark_finlist(list, 0, tracer);
     }
-
+    // Trace new objects in marked list
     mark_finlist(marked_finalizers_list, orig_marked_len, tracer);
+    // Trace objects in to_finalize (which are just pushed in sweeping thread local list)
     mark_finlist(to_finalize, 0, tracer);
 }
 
@@ -105,11 +110,20 @@ impl ArrayListT {
     }
 }
 
+fn gc_ptr_clear_tag(addr: Address, tag: usize) -> ObjectReference {
+    ObjectReference::from_raw_address(unsafe { Address::from_usize(addr & !tag) })
+}
+
+fn gc_ptr_tag(addr: Address, tag: usize) -> bool {
+    addr & tag != 0
+}
+
 // sweep_finalizer_list in gc.c
-// finalizer_list_marked is None if list is finalizer_list_marked.
 fn sweep_finalizer_list(
     list: &mut ArrayListT,
     to_finalize: &mut ArrayListT,
+    // finalizer_list_marked is None if list (1st parameter) is finalizer_list_marked.
+    // Rust does not allow sending the same mutable reference as two different arguments (cannot borrow __ as mutable more than once at a time)
     mut finalizer_list_marked: Option<&mut ArrayListT>,
     jl_gc_have_pending_finalizers: *mut i32,
 ) {
@@ -121,19 +135,20 @@ fn sweep_finalizer_list(
     let mut j = 0;
     while i < list.len {
         let v0: Address = list.get(i);
-        let v = unsafe { ObjectReference::from_raw_address(Address::from_usize(v0 & (!3usize))) };
+        let v = gc_ptr_clear_tag(v0, 3);
         if v0.is_zero() {
             i += 2;
             // remove from this list
             continue;
         }
 
         let fin = list.get(i + 1);
-        let (isfreed, isold) = if v0 & 2usize != 0 {
+        let (isfreed, isold) = if gc_ptr_tag(v0, 2) {
             (true, false)
         } else {
             let isfreed = !memory_manager::is_live_object(v);
-            (isfreed, finalizer_list_marked.is_some() && !isfreed)
+            let isold = finalizer_list_marked.is_some() && !isfreed;
+            (isfreed, isold)
         };
         if isfreed || isold {
             // remove from this list
@@ -176,22 +191,22 @@ fn mark_finlist<T: ObjectTracer>(list: &mut ArrayListT, start: usize, tracer: &m
             continue;
         }
 
-        let obj = if cur & 1usize != 0 {
+        let new_obj = if gc_ptr_tag(cur, 1) {
             // Skip next
             i += 1;
             debug_assert!(i < list.len);
-            ObjectReference::from_raw_address(unsafe { Address::from_usize(cur & (!1usize)) })
+            gc_ptr_clear_tag(cur, 1)
         } else {
             ObjectReference::from_raw_address(cur)
         };
-        if cur & 2usize != 0 {
+        if gc_ptr_tag(cur, 2) {
             i += 1;
             continue;
         }
 
-        let traced = tracer.trace_object(obj);
+        let traced = tracer.trace_object(new_obj);
         debug_assert_eq!(
-            traced, obj,
+            traced, new_obj,
             "Object is moved -- we need to save the new object back to the finalizer list"
         );
         i += 1;

mmtk/src/lib.rs

@@ -24,12 +24,12 @@ pub mod active_plan;
 pub mod api;
 pub mod collection;
 pub mod edges;
-pub mod finalizer;
 pub mod object_model;
 pub mod reference_glue;
 pub mod scanning;
 pub mod util;
 
+pub mod julia_finalizer;
 pub mod julia_scanning;
 #[allow(non_camel_case_types)]
 #[allow(improper_ctypes_definitions)]

mmtk/src/scanning.rs

@@ -89,37 +89,13 @@ impl Scanning<JuliaVM> for VMScanning {
         _worker: &mut GCWorker<JuliaVM>,
         tracer_context: impl ObjectTracerContext<JuliaVM>,
     ) -> bool {
-        // use crate::mmtk::vm::ActivePlan;
-
         let single_thread_process_finalizer = ScanFinalizersSingleThreaded { tracer_context };
         memory_manager::add_work_packet(
             &SINGLETON,
             WorkBucketStage::VMRefClosure,
             single_thread_process_finalizer,
         );
 
-        // let process_to_finalize = ScanToFinalizeList {
-        //     tracer_context: tracer_context.clone(),
-        // };
-        // memory_manager::add_work_packet(
-        //     &SINGLETON,
-        //     WorkBucketStage::VMRefClosure,
-        //     process_to_finalize,
-        // );
-
-        // for mutator in <JuliaVM as VMBinding>::VMActivePlan::mutators() {
-        //     info!("Create ScanFinalizers: {:?}", mutator.mutator_tls);
-        //     let process_finalizer = ScanFinalizers {
-        //         tls: mutator.mutator_tls,
-        //         tracer_context: tracer_context.clone(),
-        //     };
-        //     memory_manager::add_work_packet(
-        //         &SINGLETON,
-        //         WorkBucketStage::VMRefClosure,
-        //         process_finalizer,
-        //     );
-        // }
-
         // We have pushed work. No need to repeat this method.
         false
     }
@@ -167,7 +143,7 @@ pub struct ScanFinalizersSingleThreaded<C: ObjectTracerContext<JuliaVM>> {
 impl<C: ObjectTracerContext<JuliaVM>> GCWork<JuliaVM> for ScanFinalizersSingleThreaded<C> {
     fn do_work(&mut self, worker: &mut GCWorker<JuliaVM>, _mmtk: &'static MMTK<JuliaVM>) {
         self.tracer_context.with_tracer(worker, |tracer| {
-            crate::finalizer::scan_finalizers_in_rust(tracer);
+            crate::julia_finalizer::scan_finalizers_in_rust(tracer);
         });
     }
 }