Be aware of key/value weakness and forwarding

Author: wks

mmtk/src/abi.rs

@@ -389,8 +389,14 @@ pub struct RubyUpcalls {
         entries_bound: *mut libc::size_t,
         bins_num: *mut libc::size_t,
     ),
-    pub st_update_entries_range:
-        extern "C" fn(table: *mut st_table, begin: libc::size_t, end: libc::size_t),
+    pub st_update_entries_range: extern "C" fn(
+        table: *mut st_table,
+        begin: libc::size_t,
+        end: libc::size_t,
+        weak_keys: bool,
+        weak_records: bool,
+        forward: bool,
+    ),
     pub st_update_bins_range:
         extern "C" fn(table: *mut st_table, begin: libc::size_t, end: libc::size_t),
 }

mmtk/src/utils.rs

@@ -55,6 +55,8 @@ pub struct AfterAll {
     packets: AtomicRefCell<Vec<Box<dyn GCWork<Ruby>>>>,
 }
 
+unsafe impl Sync for AfterAll {}
+
 impl AfterAll {
     pub fn new(stage: WorkBucketStage) -> Self {
         Self {

mmtk/src/weak_proc.rs

@@ -76,23 +76,34 @@ impl WeakProcessor {
             Box::new(UpdateWbUnprotectedObjectsList) as _,
         ]);
 
+        let forward = crate::mmtk().get_plan().current_gc_may_move_object();
+
         // Experimenting with frozen strings table
         Self::process_weak_table_chunked(
             "frozen strings",
             (upcalls().get_frozen_strings_table)(),
+            true,
+            false,
+            forward,
             worker,
         );
 
         Self::process_weak_table_chunked(
             "global symbols",
             (upcalls().get_global_symbols_table)(),
+            false,
+            true,
+            forward,
             worker,
         );
     }
 
     pub fn process_weak_table_chunked(
         name: &str,
         table: *mut st_table,
+        weak_keys: bool,
+        weak_values: bool,
+        forward: bool,
         worker: &mut GCWorker<Ruby>,
     ) {
         let mut entries_start = 0;
@@ -118,6 +129,9 @@ impl WeakProcessor {
                     table,
                     begin,
                     end,
+                    weak_keys,
+                    weak_values,
+                    forward,
                     after_all,
                 }) as _
             })
@@ -281,6 +295,9 @@ struct UpdateTableEntriesParallel {
     table: *mut st_table,
     begin: usize,
     end: usize,
+    weak_keys: bool,
+    weak_values: bool,
+    forward: bool,
     after_all: Arc<AfterAll>,
 }
 
@@ -291,7 +308,14 @@ impl UpdateTableEntriesParallel {}
 impl GCWork<Ruby> for UpdateTableEntriesParallel {
     fn do_work(&mut self, worker: &mut GCWorker<Ruby>, _mmtk: &'static mmtk::MMTK<Ruby>) {
         debug!("Updating entries of {} table", self.name);
-        (upcalls().st_update_entries_range)(self.table, self.begin, self.end);
+        (upcalls().st_update_entries_range)(
+            self.table,
+            self.begin,
+            self.end,
+            self.weak_keys,
+            self.weak_values,
+            self.forward,
+        );
         debug!("Done updating entries of {} table", self.name);
         self.after_all.count_down(worker);
     }