Enable copying GC for MMTk

Author: wks

gc.c

@@ -1346,11 +1346,24 @@ static inline void gc_prof_sweep_timer_stop(rb_objspace_t *);
 static inline void gc_prof_set_malloc_info(rb_objspace_t *);
 static inline void gc_prof_set_heap_info(rb_objspace_t *);
 
+
+#if USE_MMTK
+static inline VALUE rb_mmtk_maybe_forward(VALUE object);
+
+#define TYPED_UPDATE_IF_MOVED(_objspace, _type, _thing) do { \
+    if (rb_mmtk_enabled_p()) { \
+        *(_type *)&(_thing) = (_type)rb_mmtk_maybe_forward((VALUE)(_thing)); \
+    } else if (gc_object_moved_p((_objspace), (VALUE)(_thing))) {    \
+        *(_type *)&(_thing) = (_type)RMOVED(_thing)->destination; \
+    } \
+} while (0)
+#else
 #define TYPED_UPDATE_IF_MOVED(_objspace, _type, _thing) do { \
     if (gc_object_moved_p((_objspace), (VALUE)(_thing))) {    \
         *(_type *)&(_thing) = (_type)RMOVED(_thing)->destination; \
     } \
 } while (0)
+#endif
 
 #define UPDATE_IF_MOVED(_objspace, _thing) TYPED_UPDATE_IF_MOVED(_objspace, VALUE, _thing)
 
@@ -3607,15 +3620,40 @@ cc_table_mark_i(ID id, VALUE ccs_ptr, void *data_ptr)
     VM_ASSERT(id == ccs->cme->called_id);
 
     if (METHOD_ENTRY_INVALIDATED(ccs->cme)) {
+#if USE_MMTK
+        if (!rb_mmtk_enabled_p()) {
+        // NOTE:
+        // Vanilla Ruby assumes no objects are moved during marking phase,
+        // and attempts to clean-up invalidated method entries during marking.
+        // This doesn't work with MMTk.
+        // With an evacuating GC algorithm (such as Immix),
+        // children of `ccs` may have been moved during tracing.
+        // But the code in `rb_vm_ccs_free` reads many VALUE fields without calling `gc_location`
+        // which obviously isn't needed for the non-moving marking phase.
+        // We temporarily disable this call for now.
+        // FIXME: Clean up method entries properly using the weak reference processing mechanism.
+#endif
         rb_vm_ccs_free(ccs);
+#if USE_MMTK
+        }
+#endif
         return ID_TABLE_DELETE;
     }
     else {
         gc_mark(data->objspace, (VALUE)ccs->cme);
 
         for (int i=0; i<ccs->len; i++) {
+#if USE_MMTK
+            if (!rb_mmtk_enabled_p()) {
+            // Type info are stored on the heap, too.
+            // With evacuating GC, they may have been moved, too.
+            // It is not safe to inspect reference fields during tracing.
+#endif
             VM_ASSERT(data->klass == ccs->entries[i].cc->klass);
             VM_ASSERT(vm_cc_check_cme(ccs->entries[i].cc, ccs->cme));
+#if USE_MMTK
+            }
+#endif
 
             gc_mark(data->objspace, (VALUE)ccs->entries[i].ci);
             gc_mark(data->objspace, (VALUE)ccs->entries[i].cc);
@@ -11046,10 +11084,6 @@ check_id_table_move(VALUE value, void *data)
     return ID_TABLE_CONTINUE;
 }
 
-#if USE_MMTK
-static inline VALUE rb_mmtk_maybe_forward(VALUE object);
-#endif
-
 /* Returns the new location of an object, if it moved.  Otherwise returns
  * the existing location. */
 VALUE
@@ -15855,9 +15889,7 @@ 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);
+    gc_update_object_references(objspace, obj);
 }
 
 // This is used to determine the pinning fields of potential pinning parents (PPPs).
@@ -16173,6 +16205,7 @@ rb_mmtk_update_global_weak_tables(void)
 MMTk_RubyUpcalls ruby_upcalls = {
     rb_mmtk_init_gc_worker_thread,
     rb_mmtk_get_gc_thread_tls,
+    rb_mmtk_is_mutator,
     rb_mmtk_stop_the_world,
     rb_mmtk_resume_mutators,
     rb_mmtk_block_for_gc,

iseq.c

@@ -312,7 +312,24 @@ rb_iseq_mark_and_move(rb_iseq_t *iseq, bool reference_updating)
 
                 const struct rb_callcache *cc = cds[i].cc;
                 if (cc) {
+#if USE_MMTK
+                    // vm_empty_cc is an off-heap object, but has the layout of a heap object.
+                    // In vanilla Ruby, rb_gc_location looks at the header to see if it is T_MOVED.
+                    // Since vm_empty_cc is not T_MOVED, it treats it like an un-moved object.
+                    // But MMTk will think it is not a heap object and will crash.
+                    // We simply skip it if cc is vm_empty_cc.
+                    if (!rb_mmtk_enabled_p() || cc != rb_vm_empty_cc()) {
+#endif
+#if USE_MMTK
+                    if (rb_mmtk_enabled_p() || reference_updating) {
+                        // Note: With an evacuating collector (such as Immix),
+                        // the object (for example, the `cc` below) is moved whenever we trace it,
+                        // and there is not any distinct "mark phase" where objects do not move.
+                        // So because we look at the contents of `cc` below,
+                        // we must always prepare for the possibility that `cc` may be moved.
+#else
                     if (reference_updating) {
+#endif
                         cc = (const struct rb_callcache *)rb_gc_location((VALUE)cc);
                     }
 
@@ -331,6 +348,9 @@ rb_iseq_mark_and_move(rb_iseq_t *iseq, bool reference_updating)
                             cds[i].cc = rb_vm_empty_cc();
                         }
                     }
+#if USE_MMTK
+                    }
+#endif
                 }
             }
         }

mmtk.h

@@ -57,6 +57,7 @@ typedef struct MMTk_GCThreadTLS {
 typedef struct MMTk_RubyUpcalls {
     void (*init_gc_worker_thread)(struct MMTk_GCThreadTLS *gc_worker_tls);
     struct MMTk_GCThreadTLS *(*get_gc_thread_tls)(void);
+    bool (*is_mutator)(void);
     void (*stop_the_world)(MMTk_VMWorkerThread tls);
     void (*resume_mutators)(MMTk_VMWorkerThread tls);
     void (*block_for_gc)(MMTk_VMMutatorThread tls);

vm.c

@@ -3132,6 +3132,11 @@ rb_execution_context_update(rb_execution_context_t *ec)
 
         while (cfp != limit_cfp) {
             const VALUE *ep = cfp->ep;
+
+#if USE_MMTK
+            if (!rb_mmtk_enabled_p() || VM_FRAME_TYPE(cfp) != VM_FRAME_MAGIC_DUMMY) {
+#endif
+
             cfp->self = rb_gc_location(cfp->self);
             cfp->iseq = (rb_iseq_t *)rb_gc_location((VALUE)cfp->iseq);
             cfp->block_code = (void *)rb_gc_location((VALUE)cfp->block_code);
@@ -3148,6 +3153,10 @@ rb_execution_context_update(rb_execution_context_t *ec)
                 }
             }
 
+#if USE_MMTK
+            }
+#endif
+
             cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
         }
     }