Turn rb_classext_t.fields into a T_OBJECT

This aims to solve two problems.

First, it solves the problem of namspaced classes having
a single `shape_id`. Now each namespaced classext
has a `T_OBJECT` that can hold the namespace specific
shape.

Second, it open the door to later make class instance variable
writes atomics, hence be able to read class variables
without locking the VM.
In the future, in multi-ractor mode, we can do the write
on a copy of the `fields_obj` and then atomically swap it.

Considerations:

  - T_OBJECT isn't ideal, it probably should be a `T_IMEMO`
    but this require a very large refatoring.
  - Right now the `RClass` shape_id is always synchronized,
    but with namespace we should likely mark classes that have
    multiple namespace with `INVALID_SHAPE`.

Author: byroot

class.c

@@ -317,13 +317,8 @@ rb_class_duplicate_classext(rb_classext_t *orig, VALUE klass, const rb_namespace
 
     RCLASSEXT_M_TBL(ext) = duplicate_classext_m_tbl(RCLASSEXT_M_TBL(orig), klass, dup_iclass);
 
-    // TODO: consider shapes for performance
-    if (RCLASSEXT_FIELDS(orig)) {
-        RCLASSEXT_FIELDS(ext) = (VALUE *)st_copy((st_table *)RCLASSEXT_FIELDS(orig));
-        rb_autoload_copy_table_for_namespace((st_table *)RCLASSEXT_FIELDS(ext), ns);
-    }
-    else {
-        RCLASSEXT_FIELDS(ext) = (VALUE *)st_init_numtable();
+    if (orig->fields_obj) {
+        ext->fields_obj = rb_obj_clone(orig->fields_obj);
     }
 
     if (RCLASSEXT_SHARED_CONST_TBL(orig)) {

gc.c

@@ -1212,7 +1212,6 @@ rb_data_free(void *objspace, VALUE obj)
 
 struct classext_foreach_args {
     VALUE klass;
-    bool obj_too_complex;
     rb_objspace_t *objspace; // used for update_*
 };
 
@@ -1224,12 +1223,6 @@ classext_free(rb_classext_t *ext, bool is_prime, VALUE namespace, void *arg)
 
     rb_id_table_free(RCLASSEXT_M_TBL(ext));
     rb_cc_tbl_free(RCLASSEXT_CC_TBL(ext), args->klass);
-    if (args->obj_too_complex) {
-        st_free_table((st_table *)RCLASSEXT_FIELDS(ext));
-    }
-    else {
-        xfree(RCLASSEXT_FIELDS(ext));
-    }
     if (!RCLASSEXT_SHARED_CONST_TBL(ext) && (tbl = RCLASSEXT_CONST_TBL(ext)) != NULL) {
         rb_free_const_table(tbl);
     }
@@ -1302,8 +1295,6 @@ rb_gc_obj_free(void *objspace, VALUE obj)
       case T_MODULE:
       case T_CLASS:
         args.klass = obj;
-        args.obj_too_complex = rb_shape_obj_too_complex_p(obj) ? true : false;
-
         rb_class_classext_foreach(obj, classext_free, (void *)&args);
         if (RCLASS(obj)->ns_classext_tbl) {
             st_free_table(RCLASS(obj)->ns_classext_tbl);
@@ -1495,6 +1486,8 @@ internal_object_p(VALUE obj)
                 return rb_singleton_class_internal_p(obj);
             }
             return 0;
+          case T_OBJECT:
+            if (FL_TEST_RAW(obj, ROBJECT_HIDDEN)) break;
           default:
             if (!RBASIC(obj)->klass) break;
             return 0;
@@ -2274,20 +2267,6 @@ classext_memsize(rb_classext_t *ext, bool prime, VALUE namespace, void *arg)
     *size += s;
 }
 
-static void
-classext_fields_hash_memsize(rb_classext_t *ext, bool prime, VALUE namespace, void *arg)
-{
-    size_t *size = (size_t *)arg;
-    size_t count;
-    RB_VM_LOCK_ENTER();
-    {
-        count = rb_st_table_size((st_table *)RCLASSEXT_FIELDS(ext));
-    }
-    RB_VM_LOCK_LEAVE();
-    // class IV sizes are allocated as powers of two
-    *size += SIZEOF_VALUE << bit_length(count);
-}
-
 static void
 classext_superclasses_memsize(rb_classext_t *ext, bool prime, VALUE namespace, void *arg)
 {
@@ -2326,15 +2305,6 @@ rb_obj_memsize_of(VALUE obj)
       case T_MODULE:
       case T_CLASS:
         rb_class_classext_foreach(obj, classext_memsize, (void *)&size);
-
-        if (rb_shape_obj_too_complex_p(obj)) {
-            rb_class_classext_foreach(obj, classext_fields_hash_memsize, (void *)&size);
-        }
-        else {
-            // class IV sizes are allocated as powers of two
-            size += SIZEOF_VALUE << bit_length(RCLASS_FIELDS_COUNT(obj));
-        }
-
         rb_class_classext_foreach(obj, classext_superclasses_memsize, (void *)&size);
         break;
       case T_ICLASS:
@@ -3107,10 +3077,7 @@ gc_mark_classext_module(rb_classext_t *ext, bool prime, VALUE namespace, void *a
         gc_mark_internal(RCLASSEXT_SUPER(ext));
     }
     mark_m_tbl(objspace, RCLASSEXT_M_TBL(ext));
-    if (rb_shape_obj_too_complex_p(obj)) {
-        gc_mark_tbl_no_pin((st_table *)RCLASSEXT_FIELDS(ext));
-        // for the case ELSE is written in rb_gc_mark_children() because it's per RClass, not classext
-    }
+    gc_mark_internal(RCLASSEXT_FIELDS_OBJ(ext));
     if (!RCLASSEXT_SHARED_CONST_TBL(ext) && RCLASSEXT_CONST_TBL(ext)) {
         mark_const_tbl(objspace, RCLASSEXT_CONST_TBL(ext));
     }
@@ -3191,11 +3158,7 @@ rb_gc_mark_children(void *objspace, VALUE obj)
         foreach_args.obj = obj;
         rb_class_classext_foreach(obj, gc_mark_classext_module, (void *)&foreach_args);
 
-        if (!rb_shape_obj_too_complex_p(obj)) {
-            for (attr_index_t i = 0; i < RCLASS_FIELDS_COUNT(obj); i++) {
-                gc_mark_internal(RCLASS_PRIME_FIELDS(obj)[i]);
-            }
-        }
+        gc_mark_internal(RCLASS_PRIME_FIELDS_OBJ(obj));
         break;
 
       case T_ICLASS:
@@ -3827,7 +3790,6 @@ static void
 update_classext(rb_classext_t *ext, bool is_prime, VALUE namespace, void *arg)
 {
     struct classext_foreach_args *args = (struct classext_foreach_args *)arg;
-    VALUE klass = args->klass;
     rb_objspace_t *objspace = args->objspace;
 
     if (RCLASSEXT_SUPER(ext)) {
@@ -3836,16 +3798,7 @@ update_classext(rb_classext_t *ext, bool is_prime, VALUE namespace, void *arg)
 
     update_m_tbl(objspace, RCLASSEXT_M_TBL(ext));
 
-    if (args->obj_too_complex) {
-        gc_ref_update_table_values_only((st_table *)RCLASSEXT_FIELDS(ext));
-    }
-    else {
-        // Classext is not copied in this case
-        for (attr_index_t i = 0; i < RCLASS_FIELDS_COUNT(klass); i++) {
-            UPDATE_IF_MOVED(objspace, RCLASSEXT_FIELDS(RCLASS_EXT_PRIME(klass))[i]);
-        }
-    }
-
+    UPDATE_IF_MOVED(objspace, ext->fields_obj);
     if (!RCLASSEXT_SHARED_CONST_TBL(ext)) {
         update_const_tbl(objspace, RCLASSEXT_CONST_TBL(ext));
     }
@@ -4202,7 +4155,6 @@ rb_gc_update_object_references(void *objspace, VALUE obj)
         // Continue to the shared T_CLASS/T_MODULE
       case T_MODULE:
         args.klass = obj;
-        args.obj_too_complex = rb_shape_obj_too_complex_p(obj);
         args.objspace = objspace;
         rb_class_classext_foreach(obj, update_classext, (void *)&args);
         break;

include/ruby/internal/core/robject.h

@@ -71,7 +71,9 @@ enum ruby_robject_flags {
      * 3rd parties must  not be aware that  there even is more than  one way to
      * store instance variables.  Might better be hidden.
      */
-    ROBJECT_EMBED = RUBY_FL_USER1
+    ROBJECT_EMBED = RUBY_FL_USER1,
+
+    ROBJECT_HIDDEN = RUBY_FL_USER2, // HACK
 };
 
 struct st_table;

internal/class.h

@@ -10,6 +10,7 @@
  */
 #include "id.h"
 #include "id_table.h"           /* for struct rb_id_table */
+#include "internal/object.h"    /* for rb_class_allocate_instance */
 #include "internal/namespace.h" /* for rb_current_namespace */
 #include "internal/serial.h"    /* for rb_serial_t */
 #include "internal/static_assert.h"
@@ -79,7 +80,7 @@ struct rb_cvar_class_tbl_entry {
 struct rb_classext_struct {
     const rb_namespace_t *ns;
     VALUE super;
-    VALUE *fields; // Fields are either ivar or other internal properties stored inline
+    VALUE fields_obj; // Fields are either ivar or other internal properties stored inline
     struct rb_id_table *m_tbl;
     struct rb_id_table *const_tbl;
     struct rb_id_table *callable_m_tbl;
@@ -176,7 +177,8 @@ static inline rb_classext_t * RCLASS_EXT_WRITABLE(VALUE obj);
 
 #define RCLASSEXT_NS(ext) (ext->ns)
 #define RCLASSEXT_SUPER(ext) (ext->super)
-#define RCLASSEXT_FIELDS(ext) (ext->fields)
+#define RCLASSEXT_FIELDS(ext) (ext->fields_obj ? ROBJECT_FIELDS(ext->fields_obj) : NULL)
+#define RCLASSEXT_FIELDS_OBJ(ext) (ext->fields_obj)
 #define RCLASSEXT_M_TBL(ext) (ext->m_tbl)
 #define RCLASSEXT_CONST_TBL(ext) (ext->const_tbl)
 #define RCLASSEXT_CALLABLE_M_TBL(ext) (ext->callable_m_tbl)
@@ -209,7 +211,7 @@ static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE
 #define RCLASS_PRIME_NS(c) (RCLASS_EXT_PRIME(c)->ns)
 // To invalidate CC by inserting&invalidating method entry into tables containing the target cme
 // See clear_method_cache_by_id_in_class()
-#define RCLASS_PRIME_FIELDS(c) (RCLASS_EXT_PRIME(c)->fields)
+#define RCLASS_PRIME_FIELDS_OBJ(c) (RCLASS_EXT_PRIME(c)->fields_obj)
 #define RCLASS_PRIME_M_TBL(c) (RCLASS_EXT_PRIME(c)->m_tbl)
 #define RCLASS_PRIME_CONST_TBL(c) (RCLASS_EXT_PRIME(c)->const_tbl)
 #define RCLASS_PRIME_CALLABLE_M_TBL(c) (RCLASS_EXT_PRIME(c)->callable_m_tbl)
@@ -255,9 +257,7 @@ static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE
 
 static inline void RCLASS_SET_SUPER(VALUE klass, VALUE super);
 static inline void RCLASS_WRITE_SUPER(VALUE klass, VALUE super);
-static inline st_table * RCLASS_FIELDS_HASH(VALUE obj);
 static inline st_table * RCLASS_WRITABLE_FIELDS_HASH(VALUE obj);
-static inline uint32_t RCLASS_FIELDS_COUNT(VALUE obj);
 static inline void RCLASS_SET_FIELDS_HASH(VALUE obj, const st_table *table);
 static inline void RCLASS_WRITE_FIELDS_HASH(VALUE obj, const st_table *table);
 // TODO: rename RCLASS_SET_M_TBL_WORKAROUND (and _WRITE_) to RCLASS_SET_M_TBL with write barrier
@@ -531,58 +531,67 @@ RCLASS_WRITE_SUPER(VALUE klass, VALUE super)
     RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT_WRITABLE(klass)), super);
 }
 
-static inline st_table *
-RCLASS_FIELDS_HASH(VALUE obj)
+static inline VALUE
+RCLASS_FIELDS_OBJ(VALUE obj)
 {
     RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
-    RUBY_ASSERT(rb_shape_obj_too_complex_p(obj));
-    return (st_table *)RCLASSEXT_FIELDS(RCLASS_EXT_READABLE(obj));
+    return RCLASSEXT_FIELDS_OBJ(RCLASS_EXT_READABLE(obj));
+}
+
+static inline VALUE
+rb_allocate_fields_obj(VALUE klass)
+{
+    VALUE fields_obj = rb_class_allocate_instance(rb_singleton_class(klass));
+    FL_SET_RAW(fields_obj, ROBJECT_HIDDEN); // HACK
+    return fields_obj;
+}
+
+static inline VALUE
+RCLASS_ENSURE_FIELDS_OBJ(VALUE obj)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
+    rb_classext_t *ext = RCLASS_EXT_READABLE(obj);
+    if (!ext->fields_obj) {
+        RB_OBJ_WRITE(obj, &ext->fields_obj, rb_allocate_fields_obj(obj));
+    }
+    return ext->fields_obj;
 }
 
-static inline st_table *
-RCLASS_WRITABLE_FIELDS_HASH(VALUE obj)
+static inline VALUE
+RCLASS_WRITABLE_FIELDS_OBJ(VALUE obj)
 {
     RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
-    RUBY_ASSERT(rb_shape_obj_too_complex_p(obj));
-    return (st_table *)RCLASSEXT_FIELDS(RCLASS_EXT_WRITABLE(obj));
+    return RCLASSEXT_FIELDS_OBJ(RCLASS_EXT_WRITABLE(obj));
 }
 
 static inline void
-RCLASS_SET_FIELDS_HASH(VALUE obj, const st_table *tbl)
+RCLASSEXT_SET_FIELDS_HASH(VALUE obj, rb_classext_t *ext, const st_table *tbl)
 {
     RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
     RUBY_ASSERT(rb_shape_obj_too_complex_p(obj));
-    RCLASSEXT_FIELDS(RCLASS_EXT_PRIME(obj)) = (VALUE *)tbl;
+
+    if (!ext->fields_obj) {
+        // FIXME: We can trigger GC here and `*tbl` may not be marked
+        RB_OBJ_WRITE(obj, &ext->fields_obj, rb_allocate_fields_obj(obj));
+    }
+    ROBJECT_SET_FIELDS_HASH(ext->fields_obj, tbl);
 }
 
 static inline void
-RCLASS_WRITE_FIELDS_HASH(VALUE obj, const st_table *tbl)
+RCLASS_SET_FIELDS_HASH(VALUE obj, const st_table *tbl)
 {
     RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
     RUBY_ASSERT(rb_shape_obj_too_complex_p(obj));
-    RCLASSEXT_FIELDS(RCLASS_EXT_WRITABLE(obj)) = (VALUE *)tbl;
+
+    RCLASSEXT_SET_FIELDS_HASH(obj, RCLASS_EXT_PRIME(obj), tbl);
 }
 
-static inline uint32_t
-RCLASS_FIELDS_COUNT(VALUE obj)
+static inline void
+RCLASS_WRITE_FIELDS_HASH(VALUE obj, const st_table *tbl)
 {
     RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
-    if (rb_shape_obj_too_complex_p(obj)) {
-        uint32_t count;
-
-        // "Too complex" classes could have their IV hash mutated in
-        // parallel, so lets lock around getting the hash size.
-        RB_VM_LOCK_ENTER();
-        {
-            count = (uint32_t)rb_st_table_size(RCLASS_FIELDS_HASH(obj));
-        }
-        RB_VM_LOCK_LEAVE();
-
-        return count;
-    }
-    else {
-        return RSHAPE(RCLASS_SHAPE_ID(obj))->next_field_index;
-    }
+    RUBY_ASSERT(rb_shape_obj_too_complex_p(obj));
+    RCLASSEXT_SET_FIELDS_HASH(obj, RCLASS_EXT_WRITABLE(obj), tbl);
 }
 
 #define RCLASS_SET_M_TBL_EVEN_WHEN_PROMOTED(klass, table) RCLASS_SET_M_TBL_WORKAROUND(klass, table, false)

shape.c

@@ -359,15 +359,27 @@ rb_obj_shape_id(VALUE obj)
     }
 
 #if SHAPE_IN_BASIC_FLAGS
+    if (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE) {
+        VALUE fields_obj = RCLASS_FIELDS_OBJ(obj);
+        if (fields_obj) {
+            return ROBJECT_SHAPE_ID(fields_obj);
+        }
+        return ROOT_SHAPE_ID;
+    }
     return RBASIC_SHAPE_ID(obj);
 #else
     switch (BUILTIN_TYPE(obj)) {
       case T_OBJECT:
         return ROBJECT_SHAPE_ID(obj);
         break;
       case T_CLASS:
-      case T_MODULE:
-        return RCLASS_SHAPE_ID(obj);
+      case T_MODULE: {
+        VALUE fields_obj = RCLASS_FIELDS_OBJ(obj);
+        if (fields_obj) {
+            ROBJECT_SHAPE_ID(fields_obj);
+        }
+        return ROOT_SHAPE_ID;
+      }
       default:
         return rb_generic_shape_id(obj);
     }
@@ -635,6 +647,19 @@ remove_shape_recursive(rb_shape_t *shape, ID id, rb_shape_t **removed_shape)
 bool
 rb_shape_transition_remove_ivar(VALUE obj, ID id, VALUE *removed)
 {
+    switch(BUILTIN_TYPE(obj)) {
+      case T_CLASS:
+      case T_MODULE: {
+        VALUE fields_obj = RCLASS_PRIME_FIELDS_OBJ(obj);
+        if (fields_obj) {
+            return rb_shape_transition_remove_ivar(fields_obj, id, removed);
+        }
+        return false;
+      }
+      default:
+        break;
+    }
+
     rb_shape_t *shape = rb_obj_shape(obj);
 
     if (UNLIKELY(rb_shape_too_complex_p(shape))) {
@@ -656,7 +681,7 @@ rb_shape_transition_remove_ivar(VALUE obj, ID id, VALUE *removed)
         switch(BUILTIN_TYPE(obj)) {
           case T_CLASS:
           case T_MODULE:
-            fields = RCLASS_PRIME_FIELDS(obj);
+            rb_bug("Unreacheable");
             break;
           case T_OBJECT:
             fields = ROBJECT_FIELDS(obj);

shape.h

@@ -95,6 +95,8 @@ get_shape_id_from_flags(VALUE obj)
 {
     RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));
     RUBY_ASSERT(!RB_TYPE_P(obj, T_IMEMO));
+    RUBY_ASSERT(!RB_TYPE_P(obj, T_CLASS) && !RB_TYPE_P(obj, T_MODULE));
+
     return (shape_id_t)((RBASIC(obj)->flags) >> SHAPE_FLAG_SHIFT);
 }