Register PPPs

Register potential pinning parent types (PPPs) when created or when an
object becomes a PPP.

Author: wks

gc.c

@@ -2671,6 +2671,38 @@ maybe_register_finalizable(VALUE obj) {
                BUILTIN_TYPE(obj), (void*)obj, RBASIC(obj)->flags);
     }
 }
+
+static inline bool
+rb_mmtk_is_ppp(VALUE obj) {
+    RUBY_ASSERT(!rb_special_const_p(obj));
+
+    switch (RB_BUILTIN_TYPE(obj)) {
+      case T_DATA:
+        return true;
+      case T_IMEMO:
+        switch (imemo_type(obj)) {
+          case imemo_tmpbuf:
+          case imemo_ast:
+          case imemo_ifunc:
+          case imemo_memo:
+          case imemo_parser_strterm:
+            return true;
+          default:
+            return false;
+        }
+      default:
+        return false;
+    }
+}
+
+static inline void
+maybe_register_ppp(VALUE obj) {
+    RUBY_ASSERT(!rb_special_const_p(obj));
+
+    if (rb_mmtk_is_ppp(obj)) {
+        mmtk_register_ppp((MMTk_ObjectReference)obj);
+    }
+}
 #endif
 
 static inline VALUE
@@ -2689,6 +2721,7 @@ newobj_init(VALUE klass, VALUE flags, int wb_protected, rb_objspace_t *objspace,
 #if USE_MMTK
     if (rb_mmtk_enabled_p()) {
         maybe_register_finalizable(obj);
+        maybe_register_ppp(obj);
     }
 #endif
 
@@ -15806,6 +15839,8 @@ rb_mmtk_mark_and_move(VALUE *field)
     }
 }
 
+// This function is used to visit and update all fields during tracing.
+// It shall call both gc_mark_children and gc_update_object_references during copying GC.
 static inline void
 rb_mmtk_scan_object_ruby_style(MMTk_ObjectReference object)
 {
@@ -15820,6 +15855,27 @@ rb_mmtk_scan_object_ruby_style(MMTk_ObjectReference object)
 
     rb_objspace_t *objspace = &rb_objspace;
     gc_mark_children(objspace, obj);
+
+    // TODO: Enable the following line later.
+    //gc_update_object_references(objspace, obj);
+}
+
+// This is used to determine the pinning fields of potential pinning parents (PPPs).
+// It should only call gc_mark_children.
+static inline void
+rb_mmtk_call_gc_mark_children(MMTk_ObjectReference object)
+{
+    rb_mmtk_assert_mmtk_worker();
+
+    VALUE obj = (VALUE)object;
+
+    // TODO: When mmtk-core can clear the VO bit (a.k.a. alloc-bit), we can remove this.
+    if (RB_BUILTIN_TYPE(obj) == T_NONE) {
+        return;
+    }
+
+    rb_objspace_t *objspace = &rb_objspace;
+    gc_mark_children(objspace, obj);
 }
 
 static inline void
@@ -15838,7 +15894,7 @@ rb_mmtk_object_moved_p(VALUE value)
 {
     if (!SPECIAL_CONST_P(value)) {
         MMTk_ObjectReference object = (MMTk_ObjectReference)value;
-        return rb_mmtk_call_object_closure(object, false) == object;
+        return rb_mmtk_call_object_closure(object, false) != object;
     } else {
         return false;
     }
@@ -16127,6 +16183,7 @@ MMTk_RubyUpcalls ruby_upcalls = {
     rb_mmtk_scan_thread_roots,
     rb_mmtk_scan_thread_root,
     rb_mmtk_scan_object_ruby_style,
+    rb_mmtk_call_gc_mark_children,
     rb_mmtk_call_obj_free,
     rb_mmtk_update_global_weak_tables,
 };

hash.c

@@ -49,6 +49,10 @@
 #include "ruby/ractor.h"
 #include "vm_sync.h"
 
+#if USE_MMTK
+#include "mmtk.h" // For mmtk_register_ppp
+#endif
+
 #ifndef HASH_DEBUG
 #define HASH_DEBUG 0
 #endif
@@ -4410,6 +4414,12 @@ rb_hash_compare_by_id(VALUE hash)
     RHASH_ST_TABLE_SET(hash, identtable);
     RHASH_ST_CLEAR(tmp);
 
+#if USE_MMTK
+    if (rb_mmtk_enabled_p()) {
+        mmtk_register_ppp((MMTk_ObjectReference)hash);
+    }
+#endif
+
     return hash;
 }
 
@@ -4431,6 +4441,13 @@ rb_ident_hash_new(void)
 {
     VALUE hash = rb_hash_new();
     RHASH_ST_TABLE_SET(hash, st_init_table(&identhash));
+
+#if USE_MMTK
+    if (rb_mmtk_enabled_p()) {
+        mmtk_register_ppp((MMTk_ObjectReference)hash);
+    }
+#endif
+
     return hash;
 }
 
@@ -4439,6 +4456,13 @@ rb_ident_hash_new_with_size(st_index_t size)
 {
     VALUE hash = rb_hash_new();
     RHASH_ST_TABLE_SET(hash, st_init_table_with_size(&identhash, size));
+
+#if USE_MMTK
+    if (rb_mmtk_enabled_p()) {
+        mmtk_register_ppp((MMTk_ObjectReference)hash);
+    }
+#endif
+
     return hash;
 }
 

mmtk.h

@@ -67,6 +67,7 @@ typedef struct MMTk_RubyUpcalls {
     void (*scan_thread_roots)(void);
     void (*scan_thread_root)(MMTk_VMMutatorThread mutator_tls, MMTk_VMWorkerThread worker_tls);
     void (*scan_object_ruby_style)(MMTk_ObjectReference object);
+    void (*call_gc_mark_children)(MMTk_ObjectReference object);
     void (*call_obj_free)(MMTk_ObjectReference object);
     void (*update_global_weak_tables)(void);
 } MMTk_RubyUpcalls;
@@ -166,4 +167,6 @@ struct MMTk_RawVecOfObjRef mmtk_get_all_obj_free_candidates(void);
 
 void mmtk_free_raw_vec_of_obj_ref(struct MMTk_RawVecOfObjRef raw_vec);
 
+void mmtk_register_ppp(MMTk_ObjectReference object);
+
 #endif /* MMTK_H */