add SET_SHAREABLE macros

* `RB_OBJ_SET_SHAREABLE(obj)` makes obj shareable.
  All of reachable objects from `obj` should be shareable.
* `RB_OBJ_SET_FROZEN_SHAREABLE(obj)` same as above
  but freeze `obj` before making it shareable.

Also `rb_gc_verify_shareable(obj)` is introduced to check
the `obj` does not violate shareable rule (an shareable object
only refers shareable objects) strictly.

The rule has some exceptions (some shareable objects can refer to
unshareable objects, such as a Ractor object (which is a shareable
object) can refer to the Ractor local objects.
To handle such case, `check_shareable` flag is also introduced.

`STRICT_VERIFY_SHAREABLE` macro is also introduced to verify
the strict shareable rule at `SET_SHAREABLE`.

Author: ko1

gc/default/default.c

@@ -491,6 +491,7 @@ typedef struct rb_objspace {
         unsigned int during_minor_gc : 1;
         unsigned int during_incremental_marking : 1;
         unsigned int measure_gc : 1;
+        unsigned int check_shareable : 1;
     } flags;
 
     rb_event_flag_t hook_events;
@@ -1455,6 +1456,19 @@ RVALUE_WHITE_P(rb_objspace_t *objspace, VALUE obj)
     return !RVALUE_MARKED(objspace, obj);
 }
 
+bool
+rb_gc_impl_checking_shareable(void *objspace_ptr)
+{
+    rb_objspace_t *objspace = objspace_ptr;
+    return objspace->flags.check_shareable;
+}
+
+bool
+rb_gc_checking_shareable(void)
+{
+    return rb_gc_impl_checking_shareable(rb_gc_get_objspace());
+}
+
 bool
 rb_gc_impl_gc_enabled_p(void *objspace_ptr)
 {
@@ -4962,6 +4976,52 @@ check_children_i(const VALUE child, void *ptr)
     }
 }
 
+static void
+check_shareable_i(const VALUE child, void *ptr)
+{
+    struct verify_internal_consistency_struct *data = (struct verify_internal_consistency_struct *)ptr;
+
+    if (!RB_OBJ_SHAREABLE_P(child)) {
+        fprintf(stderr, "(a) ");
+        rp(data->parent);
+        fprintf(stderr, "(b) ");
+        rp(child);
+        fprintf(stderr, "check_shareable_i: shareable (a) -> unshareable (b)\n");
+
+        data->err_count++;
+        rb_bug("!! violate shareable constraint !!");
+    }
+}
+
+static void
+gc_verify_shareable(rb_objspace_t *objspace, VALUE obj, void *data)
+{
+    // while objspace->flags.check_shareable is true,
+    // other Ractors should not run the GC, until the flag is not local.
+    // TODO: remove VM locking if the flag is Ractor local
+    RB_VM_LOCKING() {
+        objspace->flags.check_shareable = true;
+        rb_objspace_reachable_objects_from(obj, check_shareable_i, (void *)data);
+        objspace->flags.check_shareable = false;
+    }
+}
+
+// TODO: only one level (non-recursive)
+void
+rb_gc_verify_shareable(VALUE obj)
+{
+    rb_objspace_t *objspace = rb_gc_get_objspace();
+    struct verify_internal_consistency_struct data = {
+        .parent = obj,
+        .err_count = 0,
+    };
+    gc_verify_shareable(objspace, obj, &data);
+
+    if (data.err_count > 0) {
+        rb_bug("rb_gc_verify_shareable");
+    }
+}
+
 static int
 verify_internal_consistency_i(void *page_start, void *page_end, size_t stride,
                               struct verify_internal_consistency_struct *data)
@@ -6645,6 +6705,7 @@ gc_enter(rb_objspace_t *objspace, enum gc_enter_event event, unsigned int *lock_
     gc_enter_count(event);
     if (RB_UNLIKELY(during_gc != 0)) rb_bug("during_gc != 0");
     if (RGENGC_CHECK_MODE >= 3) gc_verify_internal_consistency(objspace);
+    GC_ASSERT(!objspace->flags.check_shareable);
 
     during_gc = TRUE;
     RUBY_DEBUG_LOG("%s (%s)",gc_enter_event_cstr(event), gc_current_status(objspace));
@@ -6658,6 +6719,7 @@ static inline void
 gc_exit(rb_objspace_t *objspace, enum gc_enter_event event, unsigned int *lock_lev)
 {
     GC_ASSERT(during_gc != 0);
+    GC_ASSERT(!objspace->flags.check_shareable);
 
     rb_gc_event_hook(0, RUBY_INTERNAL_EVENT_GC_EXIT);
 

include/ruby/ractor.h

@@ -261,4 +261,18 @@ rb_ractor_shareable_p(VALUE obj)
     }
 }
 
+// TODO: optimize on interpreter core
+#ifndef RB_OBJ_SET_SHAREABLE
+VALUE rb_obj_set_shareable(VALUE obj); // ractor.c
+#define RB_OBJ_SET_SHAREABLE(obj) rb_obj_set_shareable(obj)
+#endif
+
+static inline VALUE
+RB_OBJ_SET_FROZEN_SHAREABLE(VALUE obj)
+{
+    RB_OBJ_FREEZE(obj);
+    RB_OBJ_SET_SHAREABLE(obj);
+    return obj;
+}
+
 #endif /* RUBY_RACTOR_H */

internal/gc.h

@@ -351,4 +351,7 @@ ruby_sized_realloc_n(void *ptr, size_t new_count, size_t element_size, size_t ol
 #define ruby_sized_xrealloc ruby_sized_xrealloc_inlined
 #define ruby_sized_xrealloc2 ruby_sized_xrealloc2_inlined
 #define ruby_sized_xfree ruby_sized_xfree_inlined
+
+void rb_gc_verify_shareable(VALUE);
+
 #endif /* INTERNAL_GC_H */

ractor.c

@@ -1113,6 +1113,44 @@ rb_ractor_hooks(rb_ractor_t *cr)
     return &cr->pub.hooks;
 }
 
+static void
+rb_obj_set_shareable_no_assert(VALUE obj)
+{
+    FL_SET_RAW(obj, FL_SHAREABLE);
+
+    if (rb_obj_exivar_p(obj)) {
+        VALUE fields = rb_obj_fields_no_ractor_check(obj);
+        if (imemo_type_p(fields, imemo_fields)) {
+            // no recursive mark
+            FL_SET_RAW(fields, FL_SHAREABLE);
+        }
+    }
+}
+
+#ifndef STRICT_VERIFY_SHAREABLE
+#define STRICT_VERIFY_SHAREABLE 0
+#endif
+
+bool
+rb_ractor_verify_shareable(VALUE obj)
+{
+#if STRICT_VERIFY_SHAREABLE
+    rb_gc_verify_shareable(obj);
+#endif
+    return true;
+}
+
+VALUE
+rb_obj_set_shareable(VALUE obj)
+{
+    RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));
+
+    rb_obj_set_shareable_no_assert(obj);
+    RUBY_ASSERT(rb_ractor_verify_shareable(obj));
+
+    return obj;
+}
+
 /// traverse function
 
 // 2: stop search
@@ -1239,6 +1277,8 @@ obj_traverse_i(VALUE obj, struct obj_traverse_data *data)
 
       case T_ARRAY:
         {
+            rb_ary_cancel_sharing(obj);
+
             for (int i = 0; i < RARRAY_LENINT(obj); i++) {
                 VALUE e = rb_ary_entry(obj, i);
                 if (obj_traverse_i(e, data)) return 1;
@@ -1422,7 +1462,7 @@ make_shareable_check_shareable(VALUE obj)
 static enum obj_traverse_iterator_result
 mark_shareable(VALUE obj)
 {
-    FL_SET_RAW(obj, RUBY_FL_SHAREABLE);
+    rb_obj_set_shareable_no_assert(obj);
     return traverse_cont;
 }