Object#hash: use the object address for T_OBJECT

Rather than to generate an object_id, we can use the object address.
However we have to record that we did, so that if the object is
later moved, we know to record its original address inline, so
that it keeps a stable hash.

We can't use the same strategy for other objects because they
delegate their fields to another IMEMO/fields object.
So if they don't yet have fields or if the fields object is
full, during compaction we'd need to allocate another one but
that not allowed during GC.

Author: byroot

ext/objspace/objspace_dump.c

@@ -820,6 +820,8 @@ shape_id_i(shape_id_t shape_id, void *data)
         break;
       case SHAPE_OBJ_ID:
         dump_append(dc, ", \"shape_type\":\"OBJ_ID\"");
+      case SHAPE_OLD_ADDRESS:
+        dump_append(dc, ", \"shape_type\":\"OLD_ADDRESS\"");
         break;
     }
 

gc.c

@@ -3320,13 +3320,19 @@ rb_gc_obj_optimal_size(VALUE obj)
         return rb_ary_size_as_embedded(obj);
 
       case T_OBJECT:
-        if (rb_shape_obj_too_complex_p(obj)) {
-            return sizeof(struct RObject);
-        }
-        else {
-            return rb_obj_embedded_size(ROBJECT_FIELDS_CAPACITY(obj));
+        {
+            shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
+            if (rb_shape_too_complex_p(shape_id)) {
+                return sizeof(struct RObject);
+            }
+            else {
+                attr_index_t fields_count = ROBJECT_FIELDS_COUNT(obj);
+                if (FL_TEST_RAW(obj, RUBY_FL_ADDRESS_SEEN) && !rb_shape_has_old_address(shape_id)) {
+                    fields_count++;
+                }
+                return rb_obj_embedded_size(fields_count);
+            }
         }
-
       case T_STRING:
         return rb_str_size_as_embedded(obj);
 
@@ -4139,6 +4145,18 @@ rb_gc_update_vm_references(void *objspace)
 #endif
 }
 
+void
+rb_gc_update_moved_object(void *objspace, VALUE dest, VALUE src)
+{
+    if (RB_TYPE_P(dest, T_IMEMO)) {
+        return;
+    }
+
+    if (FL_TEST_RAW(dest, RUBY_FL_ADDRESS_SEEN)) {
+        rb_obj_set_stable_address(dest, src);
+    }
+}
+
 void
 rb_gc_update_object_references(void *objspace, VALUE obj)
 {

gc/default/default.c

@@ -6122,7 +6122,7 @@ rb_gc_impl_writebarrier_remember(void *objspace_ptr, VALUE obj)
 struct rb_gc_object_metadata_names {
     // Must be ID only
     ID ID_wb_protected, ID_age, ID_old, ID_uncollectible, ID_marking,
-        ID_marked, ID_pinned, ID_object_id, ID_shareable;
+        ID_marked, ID_pinned, ID_object_id, ID_address_seen, ID_shareable;
 };
 
 #define RB_GC_OBJECT_METADATA_ENTRY_COUNT (sizeof(struct rb_gc_object_metadata_names) / sizeof(ID))
@@ -6145,6 +6145,7 @@ rb_gc_impl_object_metadata(void *objspace_ptr, VALUE obj)
         I(marked);
         I(pinned);
         I(object_id);
+        I(address_seen);
         I(shareable);
 #undef I
     }
@@ -6164,6 +6165,7 @@ rb_gc_impl_object_metadata(void *objspace_ptr, VALUE obj)
     if (RVALUE_MARKED(objspace, obj)) SET_ENTRY(marked, Qtrue);
     if (RVALUE_PINNED(objspace, obj)) SET_ENTRY(pinned, Qtrue);
     if (rb_obj_id_p(obj)) SET_ENTRY(object_id, rb_obj_id(obj));
+    if (FL_TEST_RAW(obj, RUBY_FL_ADDRESS_SEEN)) SET_ENTRY(address_seen, Qtrue);
     if (FL_TEST(obj, FL_SHAREABLE)) SET_ENTRY(shareable, Qtrue);
 
     object_metadata_entries[n].name = 0;
@@ -7020,9 +7022,11 @@ gc_ref_update(void *vstart, void *vend, size_t stride, rb_objspace_t *objspace,
         asan_unpoisoning_object(v) {
             switch (BUILTIN_TYPE(v)) {
               case T_NONE:
-              case T_MOVED:
               case T_ZOMBIE:
                 break;
+              case T_MOVED:
+                rb_gc_update_moved_object(objspace, rb_gc_location(v), v);
+                break;
               default:
                 if (RVALUE_WB_UNPROTECTED(objspace, v)) {
                     page->flags.has_uncollectible_wb_unprotected_objects = TRUE;

gc/gc.h

@@ -75,6 +75,7 @@ MODULAR_GC_FN size_t rb_gc_obj_optimal_size(VALUE obj);
 MODULAR_GC_FN void rb_gc_mark_children(void *objspace, VALUE obj);
 MODULAR_GC_FN void rb_gc_vm_weak_table_foreach(vm_table_foreach_callback_func callback, vm_table_update_callback_func update_callback, void *data, bool weak_only, enum rb_gc_vm_weak_tables table);
 MODULAR_GC_FN void rb_gc_update_object_references(void *objspace, VALUE obj);
+MODULAR_GC_FN void rb_gc_update_moved_object(void *objspace, VALUE dest, VALUE src);
 MODULAR_GC_FN void rb_gc_update_vm_references(void *objspace);
 MODULAR_GC_FN void rb_gc_event_hook(VALUE obj, rb_event_flag_t event);
 MODULAR_GC_FN void *rb_gc_get_objspace(void);

hash.c

@@ -312,17 +312,25 @@ rb_objid_hash(st_index_t index)
 }
 
 static st_index_t
-objid_hash(VALUE obj)
+stable_obj_address_hash(VALUE obj)
 {
-    VALUE object_id = rb_obj_id(obj);
-    if (!FIXNUM_P(object_id))
-        object_id = rb_big_hash(object_id);
+    if (RB_TYPE_P(obj, T_OBJECT)) {
+        return (st_index_t)st_index_hash(rb_obj_stable_address(obj));
+    }
+    else {
+        VALUE object_id = rb_obj_id(obj);
+        if (UNLIKELY(!FIXNUM_P(object_id))) {
+            object_id = rb_big_hash(object_id);
+        }
 
 #if SIZEOF_LONG == SIZEOF_VOIDP
-    return (st_index_t)st_index_hash((st_index_t)NUM2LONG(object_id));
+        return (st_index_t)NUM2LONG(object_id);
 #elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
-    return (st_index_t)st_index_hash((st_index_t)NUM2LL(object_id));
+        return (st_index_t)NUM2LL(object_id);
+#else
+#error "Unexpected VALUE size"
 #endif
+    }
 }
 
 /**
@@ -363,7 +371,7 @@ objid_hash(VALUE obj)
 VALUE
 rb_obj_hash(VALUE obj)
 {
-    long hnum = any_hash(obj, objid_hash);
+    long hnum = any_hash(obj, stable_obj_address_hash);
     return ST2FIX(hnum);
 }
 

include/ruby/internal/core/rtypeddata.h

@@ -182,7 +182,7 @@ rbimpl_typeddata_flags {
     /**
      * This flag no longer in use
      */
-    RUBY_TYPED_UNUSED           = RUBY_FL_UNUSED6,
+    RUBY_TYPED_UNUSED           = 0,
 
     /**
      * This flag determines whether marking and compaction should be carried out

include/ruby/internal/fl_type.h

@@ -216,12 +216,15 @@ ruby_fl_type {
      */
     RUBY_FL_PROMOTED    = (1<<5),
 
-    /**
-     * This flag is no longer in use
-     *
-     * @internal
-     */
-    RUBY_FL_UNUSED6    = (1<<6),
+
+   /**
+    * This flag is used to mark when an object address has been observed by
+    * `rb_obj_hash` or similar. This indicates to the GC that the old address
+    * must be recorded inside the moved object to keep `rb_obj_hash` stable.
+    *
+    * @internal
+    */
+    RUBY_FL_ADDRESS_SEEN = (1<<6),
 
     /**
      * This flag has  something to do with finalisers.  A  ruby object can have

internal/variable.h

@@ -54,6 +54,8 @@ shape_id_t rb_evict_fields_to_hash(VALUE obj);
 VALUE rb_obj_field_get(VALUE obj, shape_id_t target_shape_id);
 void rb_ivar_set_internal(VALUE obj, ID id, VALUE val);
 void rb_obj_field_set(VALUE obj, shape_id_t target_shape_id, ID field_name, VALUE val);
+st_index_t rb_obj_stable_address(VALUE obj);
+void rb_obj_set_stable_address(VALUE obj, VALUE old_address);
 
 RUBY_SYMBOL_EXPORT_BEGIN
 /* variable.c (export) */

shape.c

@@ -33,7 +33,7 @@
 #define MAX_SHAPE_ID (SHAPE_BUFFER_SIZE - 1)
 #define ANCESTOR_SEARCH_MAX_DEPTH 2
 
-static ID id_object_id;
+static ID id_object_id, id_old_address;
 
 #define LEAF 0
 #define BLACK 0x0
@@ -504,6 +504,7 @@ rb_shape_alloc_new_child(ID id, rb_shape_t *shape, enum shape_type shape_type)
 
     switch (shape_type) {
       case SHAPE_OBJ_ID:
+      case SHAPE_OLD_ADDRESS:
       case SHAPE_IVAR:
         if (UNLIKELY(shape->next_field_index >= shape->capacity)) {
             RUBY_ASSERT(shape->next_field_index == shape->capacity);
@@ -725,6 +726,21 @@ rb_shape_transition_object_id(VALUE obj)
     return shape_transition_object_id(RBASIC_SHAPE_ID(obj));
 }
 
+shape_id_t
+rb_shape_transition_old_address(shape_id_t original_shape_id)
+{
+    RUBY_ASSERT(!rb_shape_has_old_address(original_shape_id));
+
+    bool dont_care;
+    rb_shape_t *shape = get_next_shape_internal(RSHAPE(original_shape_id), id_old_address, SHAPE_OLD_ADDRESS, &dont_care, true);
+    if (!shape) {
+        shape = RSHAPE(ROOT_SHAPE_WITH_OLD_ADDRESS);
+    }
+
+    RUBY_ASSERT(shape);
+    return shape_id(shape, original_shape_id) | SHAPE_ID_FL_HAS_OLD_ADDRESS;
+}
+
 shape_id_t
 rb_shape_object_id(shape_id_t original_shape_id)
 {
@@ -741,6 +757,22 @@ rb_shape_object_id(shape_id_t original_shape_id)
     return shape_id(shape, original_shape_id) | SHAPE_ID_FL_HAS_OBJECT_ID;
 }
 
+shape_id_t
+rb_shape_old_address(shape_id_t original_shape_id)
+{
+    RUBY_ASSERT(rb_shape_has_old_address(original_shape_id));
+
+    rb_shape_t *shape = RSHAPE(original_shape_id);
+    while (shape->type != SHAPE_OLD_ADDRESS) {
+        if (UNLIKELY(shape->parent_id == INVALID_SHAPE_ID)) {
+            rb_bug("Missing old_address in shape tree");
+        }
+        shape = RSHAPE(shape->parent_id);
+    }
+
+    return shape_id(shape, original_shape_id) | SHAPE_ID_FL_HAS_OLD_ADDRESS;
+}
+
 static inline shape_id_t
 transition_complex(shape_id_t shape_id)
 {
@@ -860,6 +892,7 @@ shape_get_iv_index(rb_shape_t *shape, ID id, attr_index_t *value)
               case SHAPE_ROOT:
                 return false;
               case SHAPE_OBJ_ID:
+              case SHAPE_OLD_ADDRESS:
                 rb_bug("Ivar should not exist on transition");
             }
         }
@@ -1111,6 +1144,7 @@ shape_rebuild(rb_shape_t *initial_shape, rb_shape_t *dest_shape)
         midway_shape = shape_get_next_iv_shape(midway_shape, dest_shape->edge_name);
         break;
       case SHAPE_OBJ_ID:
+      case SHAPE_OLD_ADDRESS:
       case SHAPE_ROOT:
         break;
     }
@@ -1242,11 +1276,16 @@ rb_shape_verify_consistency(VALUE obj, shape_id_t shape_id)
     rb_shape_t *shape = RSHAPE(shape_id);
 
     bool has_object_id = false;
+    bool has_old_address = false;
+
     while (shape->parent_id != INVALID_SHAPE_ID) {
         if (shape->type == SHAPE_OBJ_ID) {
             has_object_id = true;
-            break;
         }
+        else if (shape->type == SHAPE_OLD_ADDRESS) {
+            has_old_address = true;
+        }
+
         shape = RSHAPE(shape->parent_id);
     }
 
@@ -1263,6 +1302,19 @@ rb_shape_verify_consistency(VALUE obj, shape_id_t shape_id)
         }
     }
 
+    if (rb_shape_has_old_address(shape_id)) {
+        if (!has_old_address) {
+            rb_p(obj);
+            rb_bug("shape_id claim having has_old_address but doesn't shape_id=%u, obj=%s", shape_id, rb_obj_info(obj));
+        }
+    }
+    else {
+        if (has_old_address) {
+            rb_p(obj);
+            rb_bug("shape_id claim not having has_old_address but it does shape_id=%u, obj=%s", shape_id, rb_obj_info(obj));
+        }
+    }
+
     // Make sure SHAPE_ID_HAS_IVAR_MASK is valid.
     if (rb_shape_too_complex_p(shape_id)) {
         RUBY_ASSERT(shape_id & SHAPE_ID_HAS_IVAR_MASK);
@@ -1272,6 +1324,11 @@ rb_shape_verify_consistency(VALUE obj, shape_id_t shape_id)
         if (has_object_id) {
             ivar_count--;
         }
+
+        if (has_old_address) {
+            ivar_count--;
+        }
+
         if (ivar_count) {
             RUBY_ASSERT(shape_id & SHAPE_ID_HAS_IVAR_MASK);
         }
@@ -1543,6 +1600,7 @@ Init_default_shapes(void)
     }
 
     id_object_id = rb_make_internal_id();
+    id_old_address = rb_make_internal_id();
 
 #ifdef HAVE_MMAP
     size_t shape_cache_mmap_size = rb_size_mul_or_raise(REDBLACK_CACHE_SIZE, sizeof(redblack_node_t), rb_eRuntimeError);
@@ -1581,6 +1639,22 @@ Init_default_shapes(void)
     RUBY_ASSERT(root_with_obj_id->next_field_index == 1);
     RUBY_ASSERT(!(raw_shape_id(root_with_obj_id) & SHAPE_ID_HAS_IVAR_MASK));
     (void)root_with_obj_id;
+
+    rb_shape_t *root_with_old_address = get_next_shape_internal(root, id_old_address, SHAPE_OLD_ADDRESS, &dontcare, true);
+    RUBY_ASSERT(raw_shape_id(root_with_old_address) == ROOT_SHAPE_WITH_OLD_ADDRESS);
+    RUBY_ASSERT(root_with_old_address->type == SHAPE_OLD_ADDRESS);
+    RUBY_ASSERT(root_with_old_address->edge_name == id_old_address);
+    RUBY_ASSERT(root_with_old_address->next_field_index == 1);
+    RUBY_ASSERT(!(raw_shape_id(root_with_obj_id) & SHAPE_ID_HAS_IVAR_MASK));
+    (void)root_with_old_address;
+
+    rb_shape_t *root_with_obj_id_and_old_address = get_next_shape_internal(root_with_obj_id, id_old_address, SHAPE_OLD_ADDRESS, &dontcare, true);
+    RUBY_ASSERT(raw_shape_id(root_with_obj_id_and_old_address) == ROOT_SHAPE_WITH_OBJ_ID_AND_OLD_ADDRESS);
+    RUBY_ASSERT(root_with_obj_id_and_old_address->type == SHAPE_OLD_ADDRESS);
+    RUBY_ASSERT(root_with_obj_id_and_old_address->edge_name == id_old_address);
+    RUBY_ASSERT(root_with_obj_id_and_old_address->next_field_index == 2);
+    RUBY_ASSERT(!(raw_shape_id(root_with_obj_id_and_old_address) & SHAPE_ID_HAS_IVAR_MASK));
+    (void)root_with_obj_id_and_old_address;
 }
 
 void