Ractor: Fix moving embedded objects

`rb_obj_alloc(RBASIC_CLASS(obj))` will always allocate from the basic
40B pool, so if `obj` is larger than `40B`, we'll create a corrupted
object when we later copy the shape_id.

Instead we can use the same logic than ractor copy, which is
to use `rb_obj_clone`, and later ask the GC to free the original
object.

We then must turn it into a `T_OBJECT`, because otherwise
just changing its class to `RactorMoved` leaves a lot of
ways to keep using the object, e.g.:

```
a = [1, 2, 3]
Ractor.new{}.send(a, move: true)
[].concat(a) # Should raise, but wasn't.
```

If it turns out that `rb_obj_clone` isn't performant enough
for some uses, we can always have carefully crafted specialized
paths for the types that would benefit from it.

Author: byroot

bootstraptest/test_ractor.rb

@@ -1987,3 +1987,141 @@ def require feature
   GC.start
   :ok.itself
 }
+
+# moved objects being corrupted if embeded (String)
+assert_equal 'ok', %q{
+  ractor = Ractor.new do
+    Ractor.receive
+  end
+  obj = "foobarbazfoobarbazfoobarbazfoobarbaz"
+  ractor.send(obj.dup, move: true)
+  rountriped_obj = ractor.take
+  rountriped_obj == obj ? :ok : rountriped_obj
+}
+
+# moved objects being corrupted if embeded (Array)
+assert_equal 'ok', %q{
+  ractor = Ractor.new do
+    Ractor.receive
+  end
+  obj = Array.new(10, 42)
+  ractor.send(obj.dup, move: true)
+  rountriped_obj = ractor.take
+  rountriped_obj == obj ? :ok : rountriped_obj
+}
+
+# moved objects being corrupted if embeded (Hash)
+assert_equal 'ok', %q{
+  ractor = Ractor.new do
+    Ractor.receive
+  end
+  obj = { foo: 1, bar: 2 }
+  ractor.send(obj.dup, move: true)
+  rountriped_obj = ractor.take
+  rountriped_obj == obj ? :ok : rountriped_obj
+}
+
+# moved objects being corrupted if embeded (MatchData)
+assert_equal 'ok', %q{
+  ractor = Ractor.new do
+    Ractor.receive
+  end
+  obj = "foo".match(/o/)
+  ractor.send(obj.dup, move: true)
+  rountriped_obj = ractor.take
+  rountriped_obj == obj ? :ok : rountriped_obj
+}
+
+# moved objects being corrupted if embeded (Struct)
+assert_equal 'ok', %q{
+  ractor = Ractor.new do
+    Ractor.receive
+  end
+  obj = Struct.new(:a, :b, :c, :d, :e, :f).new(1, 2, 3, 4, 5, 6)
+  ractor.send(obj.dup, move: true)
+  rountriped_obj = ractor.take
+  rountriped_obj == obj ? :ok : rountriped_obj
+}
+
+# moved objects being corrupted if embeded (Object)
+assert_equal 'ok', %q{
+  ractor = Ractor.new do
+    Ractor.receive
+  end
+  class SomeObject
+    attr_reader :a, :b, :c, :d, :e, :f
+    def initialize
+      @a = @b = @c = @d = @e = @f = 1
+    end
+
+    def ==(o)
+      @a == o.a &&
+      @b == o.b &&
+      @c == o.c &&
+      @d == o.d &&
+      @e == o.e &&
+      @f == o.f
+    end
+  end
+
+  SomeObject.new # initial non-embeded
+
+  obj = SomeObject.new
+  ractor.send(obj.dup, move: true)
+  rountriped_obj = ractor.take
+  rountriped_obj == obj ? :ok : rountriped_obj
+}
+
+# moved arrays can't be used
+assert_equal 'ok', %q{
+  ractor = Ractor.new {}
+  obj = [1]
+  ractor.send(obj, move: true)
+  begin
+    [].concat(obj)
+  rescue TypeError
+    :ok
+  else
+    :fail
+  end
+}
+
+# moved strings can't be used
+assert_equal 'ok', %q{
+  ractor = Ractor.new {}
+  obj = "hello"
+  ractor.send(obj, move: true)
+  begin
+    "".replace(obj)
+  rescue TypeError
+    :ok
+  else
+    :fail
+  end
+}
+
+# moved hashes can't be used
+assert_equal 'ok', %q{
+  ractor = Ractor.new {}
+  obj = { a: 1 }
+  ractor.send(obj, move: true)
+  begin
+    {}.merge(obj)
+  rescue TypeError
+    :ok
+  else
+    :fail
+  end
+}
+
+# moved objects keep their object_id
+assert_equal 'ok', %q{
+  ractor = Ractor.new do
+    Ractor.receive
+  end
+  obj = Object.new
+  id = obj.object_id
+  ractor.send(obj, move: true)
+  rountriped_obj = ractor.take
+  rountriped_obj.object_id == id ? :ok : :fail
+}

gc.c

@@ -2659,6 +2659,32 @@ rb_gc_mark_roots(void *objspace, const char **categoryp)
 
 #define TYPED_DATA_REFS_OFFSET_LIST(d) (size_t *)(uintptr_t)RTYPEDDATA(d)->type->function.dmark
 
+void
+rb_gc_ractor_moved(VALUE dest, VALUE src)
+{
+    st_data_t id = 0;
+    if (UNLIKELY(FL_TEST_RAW(src, FL_SEEN_OBJ_ID))) {
+        /* If the source object's object_id has been seen, we need to update
+         * the object to object id mapping. */
+        rb_objspace_t *objspace = rb_gc_get_objspace();
+
+        unsigned int lev = rb_gc_vm_lock();
+        if (!st_lookup(objspace->obj_to_id_tbl, (st_data_t)src, &id)) {
+            rb_bug("gc_move: object ID seen, but not in mapping table: %s", rb_obj_info(src));
+        }
+        st_insert(objspace->obj_to_id_tbl, (st_data_t)dest, id);
+        rb_gc_vm_unlock(lev);
+        // rb_gc_obj_free will take care of deleting the src entry
+    }
+
+    rb_gc_obj_free(rb_gc_get_objspace(), src);
+    MEMZERO((void *)src, char, rb_gc_obj_slot_size(src));
+    RBASIC(src)->flags = T_OBJECT | FL_FREEZE; // Avoid mutations using bind_call, etc.
+    if (id) {
+        FL_SET_RAW(dest, FL_SEEN_OBJ_ID);
+    }
+}
+
 void
 rb_gc_mark_children(void *objspace, VALUE obj)
 {

internal/gc.h

@@ -183,6 +183,7 @@ struct rb_gc_object_metadata_entry {
 /* gc.c */
 RUBY_ATTR_MALLOC void *ruby_mimmalloc(size_t size);
 RUBY_ATTR_MALLOC void *ruby_mimcalloc(size_t num, size_t size);
+void rb_gc_ractor_moved(VALUE dest, VALUE src);
 void ruby_mimfree(void *ptr);
 void rb_gc_prepare_heap(void);
 void rb_objspace_set_event_hook(const rb_event_flag_t event);

ractor.c

@@ -12,6 +12,7 @@
 #include "internal/error.h"
 #include "internal/gc.h"
 #include "internal/hash.h"
+#include "internal/object.h"
 #include "internal/ractor.h"
 #include "internal/rational.h"
 #include "internal/struct.h"
@@ -3546,37 +3547,6 @@ rb_obj_traverse_replace(VALUE obj,
     }
 }
 
-struct RVALUE {
-    VALUE flags;
-    VALUE klass;
-    VALUE v1;
-    VALUE v2;
-    VALUE v3;
-};
-
-static const VALUE fl_users = FL_USER1  | FL_USER2  | FL_USER3  |
-                              FL_USER4  | FL_USER5  | FL_USER6  | FL_USER7  |
-                              FL_USER8  | FL_USER9  | FL_USER10 | FL_USER11 |
-                              FL_USER12 | FL_USER13 | FL_USER14 | FL_USER15 |
-                              FL_USER16 | FL_USER17 | FL_USER18 | FL_USER19;
-
-static void
-ractor_moved_bang(VALUE obj)
-{
-    // invalidate src object
-    struct RVALUE *rv = (void *)obj;
-
-    rv->klass = rb_cRactorMovedObject;
-    rv->v1 = 0;
-    rv->v2 = 0;
-    rv->v3 = 0;
-    rv->flags = rv->flags & ~fl_users;
-
-    if (BUILTIN_TYPE(obj) == T_OBJECT) ROBJECT_SET_SHAPE_ID(obj, ROOT_SHAPE_ID);
-
-    // TODO: record moved location
-}
-
 static enum obj_traverse_iterator_result
 move_enter(VALUE obj, struct obj_traverse_replace_data *data)
 {
@@ -3585,39 +3555,16 @@ move_enter(VALUE obj, struct obj_traverse_replace_data *data)
         return traverse_skip;
     }
     else {
-        VALUE moved = rb_obj_alloc(RBASIC_CLASS(obj));
-        rb_shape_set_shape(moved, rb_shape_get_shape(obj));
-        data->replacement = moved;
+        data->replacement = rb_obj_clone(obj);
         return traverse_cont;
     }
 }
 
-void rb_replace_generic_ivar(VALUE clone, VALUE obj); // variable.c
-
 static enum obj_traverse_iterator_result
 move_leave(VALUE obj, struct obj_traverse_replace_data *data)
 {
-    VALUE v = data->replacement;
-    struct RVALUE *dst = (struct RVALUE *)v;
-    struct RVALUE *src = (struct RVALUE *)obj;
-
-    dst->flags = (dst->flags & ~fl_users) | (src->flags & fl_users);
-
-    dst->v1 = src->v1;
-    dst->v2 = src->v2;
-    dst->v3 = src->v3;
-
-    if (UNLIKELY(FL_TEST_RAW(obj, FL_EXIVAR))) {
-        rb_replace_generic_ivar(v, obj);
-    }
-
-    if (OBJ_FROZEN(obj)) {
-        OBJ_FREEZE(v);
-    }
-
-    // TODO: generic_ivar
-
-    ractor_moved_bang(obj);
+    rb_gc_ractor_moved(data->replacement, obj);
+    RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
     return traverse_cont;
 }
 

variable.c

@@ -2157,27 +2157,6 @@ rb_copy_generic_ivar(VALUE clone, VALUE obj)
     }
 }
 
-void
-rb_replace_generic_ivar(VALUE clone, VALUE obj)
-{
-    RUBY_ASSERT(FL_TEST(obj, FL_EXIVAR));
-
-    RB_VM_LOCK_ENTER();
-    {
-        st_data_t ivtbl, obj_data = (st_data_t)obj;
-        if (st_lookup(generic_iv_tbl_, (st_data_t)obj, &ivtbl)) {
-            st_insert(generic_iv_tbl_, (st_data_t)clone, ivtbl);
-            st_delete(generic_iv_tbl_, &obj_data, NULL);
-        }
-        else {
-            rb_bug("unreachable");
-        }
-    }
-    RB_VM_LOCK_LEAVE();
-
-    FL_SET(clone, FL_EXIVAR);
-}
-
 void
 rb_ivar_foreach(VALUE obj, rb_ivar_foreach_callback_func *func, st_data_t arg)
 {