Turn rb_classext_t.fields into a T_IMEMO/class_fields

This behave almost exactly as a T_OBJECT, the layout is entirely
compatible.

This aims to solve two problems.

First, it solves the problem of namspaced classes having
a single `shape_id`. Now each namespaced classext
has an 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:

  - Right now the `RClass` shape_id is always synchronized,
    but with namespace we should likely mark classes that have
    multiple namespace with a specific shape flag.

Author: byroot

class.c

@@ -297,16 +297,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)) {
-        RUBY_ASSERT(!RB_TYPE_P(klass, T_ICLASS));
-        RCLASSEXT_FIELDS(ext) = (VALUE *)st_copy((st_table *)RCLASSEXT_FIELDS(orig));
-        rb_autoload_copy_table_for_namespace((st_table *)RCLASSEXT_FIELDS(ext), ns);
-    }
-    else {
-        if (!RB_TYPE_P(klass, T_ICLASS)) {
-            RCLASSEXT_FIELDS(ext) = (VALUE *)st_init_numtable();
-        }
+    if (orig->fields_obj) {
+        RB_OBJ_WRITE(klass, &ext->fields_obj, rb_imemo_class_fields_clone(orig->fields_obj));
     }
 
     if (RCLASSEXT_SHARED_CONST_TBL(orig)) {

common.mk

@@ -8117,6 +8117,7 @@ imemo.$(OBJEXT): $(top_srcdir)/internal/namespace.h
 imemo.$(OBJEXT): $(top_srcdir)/internal/sanitizers.h
 imemo.$(OBJEXT): $(top_srcdir)/internal/serial.h
 imemo.$(OBJEXT): $(top_srcdir)/internal/set_table.h
+imemo.$(OBJEXT): $(top_srcdir)/internal/st.h
 imemo.$(OBJEXT): $(top_srcdir)/internal/static_assert.h
 imemo.$(OBJEXT): $(top_srcdir)/internal/variable.h
 imemo.$(OBJEXT): $(top_srcdir)/internal/vm.h

debug_counter.h

@@ -315,6 +315,7 @@ RB_DEBUG_COUNTER(obj_imemo_parser_strterm)
 RB_DEBUG_COUNTER(obj_imemo_callinfo)
 RB_DEBUG_COUNTER(obj_imemo_callcache)
 RB_DEBUG_COUNTER(obj_imemo_constcache)
+RB_DEBUG_COUNTER(obj_imemo_class_fields)
 
 RB_DEBUG_COUNTER(opt_new_hit)
 RB_DEBUG_COUNTER(opt_new_miss)

ext/objspace/objspace.c

@@ -504,6 +504,7 @@ count_imemo_objects(int argc, VALUE *argv, VALUE self)
         INIT_IMEMO_TYPE_ID(imemo_callinfo);
         INIT_IMEMO_TYPE_ID(imemo_callcache);
         INIT_IMEMO_TYPE_ID(imemo_constcache);
+        INIT_IMEMO_TYPE_ID(imemo_class_fields);
 #undef INIT_IMEMO_TYPE_ID
     }
 

gc.c

@@ -1201,7 +1201,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_*
 };
 
@@ -1213,12 +1212,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);
     }
@@ -1292,8 +1285,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);
@@ -2305,18 +2296,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_LOCKING() {
-        count = rb_st_table_size((st_table *)RCLASSEXT_FIELDS(ext));
-    }
-    // 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)
 {
@@ -2354,15 +2333,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:
@@ -3135,10 +3105,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));
     }
@@ -3218,12 +3185,6 @@ rb_gc_mark_children(void *objspace, VALUE obj)
         foreach_args.objspace = objspace;
         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]);
-            }
-        }
         break;
 
       case T_ICLASS:
@@ -3849,7 +3810,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)) {
@@ -3858,16 +3818,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));
     }
@@ -4255,7 +4206,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;

imemo.c

@@ -3,6 +3,7 @@
 #include "id_table.h"
 #include "internal.h"
 #include "internal/imemo.h"
+#include "internal/st.h"
 #include "vm_callinfo.h"
 
 size_t rb_iseq_memsize(const rb_iseq_t *iseq);
@@ -29,10 +30,10 @@ rb_imemo_name(enum imemo_type type)
         IMEMO_NAME(svar);
         IMEMO_NAME(throw_data);
         IMEMO_NAME(tmpbuf);
+        IMEMO_NAME(class_fields);
 #undef IMEMO_NAME
-      default:
-        rb_bug("unreachable");
     }
+    rb_bug("unreachable");
 }
 
 /* =========================================================================
@@ -109,6 +110,62 @@ rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt)
     return tmpbuf;
 }
 
+static VALUE
+imemo_class_fields_new(VALUE klass, size_t capa)
+{
+    size_t embedded_size = offsetof(struct rb_class_fields, as.embed) + capa * sizeof(VALUE);
+    if (rb_gc_size_allocatable_p(embedded_size)) {
+        VALUE fields = rb_imemo_new(imemo_class_fields, klass, embedded_size);
+        RUBY_ASSERT(IMEMO_TYPE_P(fields, imemo_class_fields));
+        return fields;
+    }
+    else {
+        VALUE fields = rb_imemo_new(imemo_class_fields, klass, sizeof(struct rb_class_fields));
+        FL_SET_RAW(fields, OBJ_FIELD_EXTERNAL);
+        IMEMO_OBJ_FIELDS(fields)->as.external.ptr = ALLOC_N(VALUE, capa);
+        return fields;
+    }
+}
+
+VALUE
+rb_imemo_class_fields_new(VALUE klass, size_t capa)
+{
+    return imemo_class_fields_new(rb_singleton_class(klass), capa);
+}
+
+static VALUE
+imemo_class_fields_new_complex(VALUE klass, size_t capa)
+{
+    VALUE fields = imemo_class_fields_new(klass, sizeof(struct rb_class_fields));
+    IMEMO_OBJ_FIELDS(fields)->as.complex.table = st_init_numtable_with_size(capa);
+    return fields;
+}
+
+VALUE
+rb_imemo_class_fields_new_complex(VALUE klass, size_t capa)
+{
+    return imemo_class_fields_new_complex(rb_singleton_class(klass), capa);
+}
+
+VALUE
+rb_imemo_class_fields_clone(VALUE fields_obj)
+{
+    shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);
+    VALUE clone;
+
+    if (rb_shape_too_complex_p(shape_id)) {
+        clone = rb_imemo_class_fields_new_complex(CLASS_OF(fields_obj), 0);
+        st_table *src_table = rb_imemo_class_fields_complex_tbl(fields_obj);
+        st_replace(rb_imemo_class_fields_complex_tbl(clone), src_table);
+    }
+    else {
+        clone = imemo_class_fields_new(CLASS_OF(fields_obj), RSHAPE_CAPACITY(shape_id));
+        MEMCPY(rb_imemo_class_fields_ptr(clone), rb_imemo_class_fields_ptr(fields_obj), VALUE, RSHAPE_LEN(shape_id));
+    }
+
+    return clone;
+}
+
 /* =========================================================================
  * memsize
  * ========================================================================= */
@@ -155,6 +212,14 @@ rb_imemo_memsize(VALUE obj)
       case imemo_tmpbuf:
         size += ((rb_imemo_tmpbuf_t *)obj)->cnt * sizeof(VALUE);
 
+        break;
+      case imemo_class_fields:
+        if (rb_shape_obj_too_complex_p(obj)) {
+            size += st_memsize(IMEMO_OBJ_FIELDS(obj)->as.complex.table);
+        }
+        else if (FL_TEST_RAW(obj, OBJ_FIELD_EXTERNAL)) {
+            size += RSHAPE_CAPACITY(RBASIC_SHAPE_ID(obj)) * sizeof(VALUE);
+        }
         break;
       default:
         rb_bug("unreachable");
@@ -420,6 +485,27 @@ rb_imemo_mark_and_move(VALUE obj, bool reference_updating)
 
         break;
       }
+      case imemo_class_fields: {
+        rb_gc_mark_and_move((VALUE *)&RBASIC(obj)->klass);
+
+        if (rb_shape_obj_too_complex_p(obj)) {
+            st_table *tbl = rb_imemo_class_fields_complex_tbl(obj);
+            if (reference_updating) {
+                rb_gc_ref_update_table_values_only(tbl);
+            }
+            else {
+                rb_mark_tbl_no_pin(tbl);
+            }
+        }
+        else {
+            VALUE *fields = rb_imemo_class_fields_ptr(obj);
+            attr_index_t len = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));
+            for (attr_index_t i = 0; i < len; i++) {
+                rb_gc_mark_and_move(&fields[i]);
+            }
+        }
+        break;
+      }
       default:
         rb_bug("unreachable");
     }
@@ -513,6 +599,17 @@ rb_cc_tbl_free(struct rb_id_table *cc_tbl, VALUE klass)
     rb_id_table_free(cc_tbl);
 }
 
+static inline void
+imemo_class_fields_free(struct rb_class_fields *fields)
+{
+    if (rb_shape_obj_too_complex_p((VALUE)fields)) {
+        st_free_table(fields->as.complex.table);
+    }
+    else if (FL_TEST_RAW((VALUE)fields, OBJ_FIELD_EXTERNAL)) {
+        xfree(fields->as.external.ptr);
+    }
+}
+
 void
 rb_imemo_free(VALUE obj)
 {
@@ -576,6 +673,7 @@ rb_imemo_free(VALUE obj)
         break;
       case imemo_svar:
         RB_DEBUG_COUNTER_INC(obj_imemo_svar);
+
         break;
       case imemo_throw_data:
         RB_DEBUG_COUNTER_INC(obj_imemo_throw_data);
@@ -585,6 +683,10 @@ rb_imemo_free(VALUE obj)
         xfree(((rb_imemo_tmpbuf_t *)obj)->ptr);
         RB_DEBUG_COUNTER_INC(obj_imemo_tmpbuf);
 
+        break;
+      case imemo_class_fields:
+        imemo_class_fields_free(IMEMO_OBJ_FIELDS(obj));
+        RB_DEBUG_COUNTER_INC(obj_imemo_class_fields);
         break;
       default:
         rb_bug("unreachable");