wip

Author: etiennebarrie

hash.c

@@ -47,6 +47,7 @@
 #include "symbol.h"
 #include "ruby/thread_native.h"
 #include "ruby/ractor.h"
+#include "variable.h"
 #include "vm_sync.h"
 #include "builtin.h"
 

internal/struct.h

@@ -10,8 +10,10 @@
  */
 #include "ruby/internal/stdbool.h"     /* for bool */
 #include "ruby/ruby.h"          /* for struct RBasic */
+#include "internal/imemo.h"
 
 enum {
+    RSTRUCT_FL_GENIVAR = RUBY_FL_USER8,
     RSTRUCT_EMBED_LEN_MASK = RUBY_FL_USER7 | RUBY_FL_USER6 | RUBY_FL_USER5 | RUBY_FL_USER4 |
                                  RUBY_FL_USER3 | RUBY_FL_USER2 | RUBY_FL_USER1,
     RSTRUCT_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+1),
@@ -23,6 +25,7 @@ struct RStruct {
         struct {
             long len;
             const VALUE *ptr;
+            const VALUE fields_obj;
         } heap;
         /* This is a length 1 array because:
          *   1. GCC has a bug that does not optimize C flexible array members
@@ -116,4 +119,34 @@ RSTRUCT_GET(VALUE st, long k)
     return RSTRUCT_CONST_PTR(st)[k];
 }
 
+static inline VALUE
+RSTRUCT_FIELDS_OBJ(VALUE st)
+{
+    const long embed_len = RSTRUCT_EMBED_LEN(st);
+    VALUE fields_obj;
+    if (embed_len) {
+        RUBY_ASSERT(!FL_TEST_RAW(st, RSTRUCT_FL_GENIVAR));
+        fields_obj = RSTRUCT_GET(st, embed_len);
+    }
+    else {
+        fields_obj = RSTRUCT(st)->as.heap.fields_obj;
+    }
+    RUBY_ASSERT(!fields_obj || IMEMO_TYPE_P(fields_obj, imemo_fields));
+    return fields_obj;
+}
+
+static inline void
+RSTRUCT_SET_FIELDS_OBJ(VALUE st, VALUE fields_obj)
+{
+    RUBY_ASSERT(!fields_obj || IMEMO_TYPE_P(fields_obj, imemo_fields));
+    const long embed_len = RSTRUCT_EMBED_LEN(st);
+    if (embed_len) {
+        RUBY_ASSERT(!FL_TEST_RAW(st, RSTRUCT_FL_GENIVAR));
+        RSTRUCT_SET(st, embed_len, fields_obj);
+    }
+    else {
+        RB_OBJ_WRITE(st, &RSTRUCT(st)->as.heap.fields_obj, fields_obj);
+    }
+}
+
 #endif /* INTERNAL_STRUCT_H */

object.c

@@ -385,6 +385,9 @@ init_copy(VALUE dest, VALUE obj)
       case T_OBJECT:
         rb_obj_copy_ivar(dest, obj);
         break;
+      case T_STRUCT:
+        rb_copy_struct_ivar(dest, obj);
+        break;
       default:
         rb_copy_generic_ivar(dest, obj);
         break;

shape.h

@@ -413,22 +413,6 @@ rb_shape_obj_has_fields(VALUE obj)
     return rb_shape_has_fields(RBASIC_SHAPE_ID(obj));
 }
 
-static inline bool
-rb_obj_exivar_p(VALUE obj)
-{
-    switch (TYPE(obj)) {
-        case T_NONE:
-        case T_OBJECT:
-        case T_CLASS:
-        case T_MODULE:
-        case T_IMEMO:
-          return false;
-        default:
-          break;
-    }
-    return rb_shape_obj_has_fields(obj);
-}
-
 // For ext/objspace
 RUBY_SYMBOL_EXPORT_BEGIN
 typedef void each_shape_callback(shape_id_t shape_id, void *data);

string.c

@@ -47,6 +47,7 @@
 #include "ruby/util.h"
 #include "ruby_assert.h"
 #include "shape.h"
+#include "variable.h"
 #include "vm_sync.h"
 #include "ruby/internal/attr/nonstring.h"
 

struct.c

@@ -811,12 +811,18 @@ struct_alloc(VALUE klass)
 {
     long n = num_members(klass);
     size_t embedded_size = offsetof(struct RStruct, as.ary) + (sizeof(VALUE) * n);
+    if (RCLASS_MAX_IV_COUNT(klass) > 0) {
+        embedded_size += sizeof(VALUE);
+    }
     VALUE flags = T_STRUCT | (RGENGC_WB_PROTECTED_STRUCT ? FL_WB_PROTECTED : 0);
 
     if (n > 0 && rb_gc_size_allocatable_p(embedded_size)) {
         flags |= n << RSTRUCT_EMBED_LEN_SHIFT;
 
         NEWOBJ_OF(st, struct RStruct, klass, flags, embedded_size, 0);
+        if (RCLASS_MAX_IV_COUNT(klass) == 0 && embedded_size == rb_gc_obj_slot_size((VALUE)st)) {
+            FL_SET_RAW((VALUE)st, RSTRUCT_FL_GENIVAR);
+        }
 
         rb_mem_clear((VALUE *)st->as.ary, n);
 

test/ruby/test_object_id.rb

@@ -252,3 +252,19 @@ def initialize
     end;
   end
 end
+
+class TestObjectIdStruct < TestObjectId
+  EmbeddedStruct = Struct.new(:embedded_field)
+
+  def setup
+    @obj = EmbeddedStruct.new
+  end
+end
+
+class TestObjectIdStructGenIvar < TestObjectId
+  GenIvarStruct = Struct.new(:a, :b, :c)
+
+  def setup
+    @obj = GenIvarStruct.new
+  end
+end

variable.c

@@ -29,6 +29,7 @@
 #include "internal/object.h"
 #include "internal/gc.h"
 #include "internal/re.h"
+#include "internal/struct.h"
 #include "internal/symbol.h"
 #include "internal/thread.h"
 #include "internal/variable.h"
@@ -1189,6 +1190,7 @@ static inline struct st_table *
 generic_fields_tbl(VALUE obj, ID id, bool force_check_ractor)
 {
     ASSERT_vm_locking();
+    RUBY_ASSERT(!RB_TYPE_P(obj, T_STRUCT) || FL_TEST_RAW(obj, RSTRUCT_FL_GENIVAR));
 
     if ((force_check_ractor || LIKELY(rb_is_instance_id(id)) /* not internal ID */ )  &&
         !RB_OBJ_FROZEN_RAW(obj) &&
@@ -1421,6 +1423,19 @@ rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
             ivar_list = ROBJECT_FIELDS(obj);
             break;
         }
+      case T_STRUCT:
+        {
+            if (!FL_TEST_RAW(obj, RSTRUCT_FL_GENIVAR)) {
+                VALUE fields_obj = RSTRUCT_FIELDS_OBJ(obj);
+                if (fields_obj) {
+                    return rb_ivar_lookup(fields_obj, id, undef);
+                }
+                else {
+                    return undef;
+                }
+            }
+            // fallthrough gen fields
+        }
       default:
         shape_id = RBASIC_SHAPE_ID(obj);
         if (rb_obj_exivar_p(obj)) {
@@ -2080,6 +2095,43 @@ void rb_obj_freeze_inline(VALUE x)
     }
 }
 
+static void
+struct_field_set(VALUE obj, shape_id_t target_shape_id, ID field_name, VALUE val)
+{
+    if (FL_TEST_RAW(obj, RSTRUCT_FL_GENIVAR)) {
+        generic_field_set(obj, target_shape_id, field_name, val);
+        return;
+    }
+
+    const VALUE original_fields_obj = RSTRUCT_FIELDS_OBJ(obj);
+    VALUE fields_obj = imemo_fields_set(rb_obj_class(obj), original_fields_obj, target_shape_id, field_name, val, false);
+    if (fields_obj != original_fields_obj) {
+        RSTRUCT_SET_FIELDS_OBJ(obj, fields_obj);
+        if (original_fields_obj) {
+            // Clear root shape to avoid triggering cleanup such as free_object_id.
+            rb_imemo_fields_clear(original_fields_obj);
+        }
+    }
+
+    if (RBASIC_SHAPE_ID(fields_obj) == target_shape_id) {
+        RBASIC_SET_SHAPE_ID(obj, target_shape_id);
+    }
+
+    RUBY_ASSERT(RBASIC_SHAPE_ID(obj) == RBASIC_SHAPE_ID(fields_obj));
+}
+
+static void
+struct_ivar_set(VALUE obj, ID id, VALUE val)
+{
+    if (FL_TEST_RAW(obj, RSTRUCT_FL_GENIVAR)) {
+        generic_ivar_set(obj, id, val);
+        return;
+    }
+    bool dontcare;
+    shape_id_t target_shape_id = generic_shape_ivar(obj, id, &dontcare);
+    struct_field_set(obj, target_shape_id, id, val);
+}
+
 static void
 ivar_set(VALUE obj, ID id, VALUE val)
 {
@@ -2096,6 +2148,9 @@ ivar_set(VALUE obj, ID id, VALUE val)
         IVAR_ACCESSOR_SHOULD_BE_MAIN_RACTOR(id);
         rb_class_ivar_set(obj, id, val);
 
+        break;
+      case T_STRUCT:
+        struct_ivar_set(obj, id, val);
         break;
       default:
         generic_ivar_set(obj, id, val);
@@ -2132,6 +2187,9 @@ rb_obj_field_set(VALUE obj, shape_id_t target_shape_id, ID field_name, VALUE val
         // The only field is object_id and T_CLASS handle it differently.
         rb_bug("Unreachable");
         break;
+      case T_STRUCT:
+        struct_field_set(obj, target_shape_id, field_name, val);
+        break;
       default:
         generic_field_set(obj, target_shape_id, field_name, val);
         break;
@@ -2365,6 +2423,65 @@ rb_copy_generic_ivar(VALUE dest, VALUE obj)
     rb_free_generic_ivar(dest);
 }
 
+void
+rb_copy_struct_ivar(VALUE dest, VALUE obj)
+{
+    if (FL_TEST_RAW(obj, RSTRUCT_FL_GENIVAR)) {
+        rb_copy_generic_ivar(dest, obj);
+        return;
+    }
+
+    VALUE fields_obj = RSTRUCT_FIELDS_OBJ(obj);
+    VALUE new_fields_obj;
+
+    rb_check_frozen(dest);
+
+    shape_id_t src_shape_id = rb_obj_shape_id(obj);
+
+    if (fields_obj) {
+        unsigned long src_num_ivs = rb_ivar_count(fields_obj);
+        if (!src_num_ivs) {
+            return;
+        }
+
+        if (rb_shape_too_complex_p(src_shape_id)) {
+            rb_shape_copy_complex_ivars(dest, obj, src_shape_id, rb_imemo_fields_complex_tbl(fields_obj));
+            return;
+        }
+
+        shape_id_t dest_shape_id = src_shape_id;
+        shape_id_t initial_shape_id = rb_obj_shape_id(dest);
+
+        if (!rb_shape_canonical_p(src_shape_id)) {
+            RUBY_ASSERT(RSHAPE_TYPE_P(initial_shape_id, SHAPE_ROOT));
+
+            dest_shape_id = rb_shape_rebuild(initial_shape_id, src_shape_id);
+            if (UNLIKELY(rb_shape_too_complex_p(dest_shape_id))) {
+                st_table *table = rb_st_init_numtable_with_size(src_num_ivs);
+                rb_obj_copy_ivs_to_hash_table(obj, table);
+                rb_obj_init_too_complex(dest, table);
+                return;
+            }
+        }
+
+        if (!RSHAPE_LEN(dest_shape_id)) {
+            rb_obj_set_shape_id(dest, dest_shape_id);
+            return;
+        }
+
+        new_fields_obj = rb_imemo_fields_new(rb_obj_class(dest), RSHAPE_CAPACITY(dest_shape_id));
+        VALUE *src_buf = rb_imemo_fields_ptr(fields_obj);
+        VALUE *dest_buf = rb_imemo_fields_ptr(new_fields_obj);
+        rb_shape_copy_fields(new_fields_obj, dest_buf, dest_shape_id, src_buf, src_shape_id);
+        RBASIC_SET_SHAPE_ID(new_fields_obj, dest_shape_id);
+
+        RSTRUCT_SET_FIELDS_OBJ(dest, new_fields_obj);
+
+        RBASIC_SET_SHAPE_ID(dest, dest_shape_id);
+    }
+    return;
+}
+
 void
 rb_replace_generic_ivar(VALUE clone, VALUE obj)
 {
@@ -2403,6 +2520,15 @@ rb_field_foreach(VALUE obj, rb_ivar_foreach_callback_func *func, st_data_t arg,
             }
         }
         break;
+      case T_STRUCT:
+        if (!FL_TEST_RAW(obj, RSTRUCT_FL_GENIVAR)) {
+            VALUE fields_obj = RSTRUCT_FIELDS_OBJ(obj);
+            if (fields_obj) {
+                imemo_fields_each(fields_obj, func, arg, ivar_only);
+            }
+            break;
+        }
+        // fallthrough gen fields
       default:
         if (rb_obj_exivar_p(obj)) {
             VALUE fields_obj = 0;

variable.h

@@ -11,9 +11,32 @@
 /* per-object */
 
 #include "shape.h"
+#include "internal/struct.h"
+
+static inline bool
+rb_obj_exivar_p(VALUE obj)
+{
+    switch (TYPE(obj)) {
+        case T_NONE:
+        case T_OBJECT:
+        case T_CLASS:
+        case T_MODULE:
+        case T_IMEMO:
+          return false;
+        case T_STRUCT:
+          if (!FL_TEST_RAW(obj, RSTRUCT_FL_GENIVAR)) {
+              return false;
+          }
+          break;
+        default:
+          break;
+    }
+    return rb_shape_obj_has_fields(obj);
+}
 
 int rb_ivar_generic_fields_tbl_lookup(VALUE obj, VALUE *);
 void rb_copy_complex_ivars(VALUE dest, VALUE obj, shape_id_t src_shape_id, st_table *fields_table);
+void rb_copy_struct_ivar(VALUE dest, VALUE obj);
 
 void rb_free_rb_global_tbl(void);
 void rb_free_generic_fields_tbl_(void);

vm_insnhelper.c

@@ -1265,6 +1265,18 @@ vm_getivar(VALUE obj, ID id, const rb_iseq_t *iseq, IVC ic, const struct rb_call
 
             break;
         }
+      case T_STRUCT:
+        {
+            if (!FL_TEST_RAW(obj, RSTRUCT_FL_GENIVAR)) {
+                fields_obj = RSTRUCT_FIELDS_OBJ(obj);
+                if (!fields_obj) {
+                    return default_value;
+                }
+                ivar_list = rb_imemo_fields_ptr(fields_obj);
+                goto general_path;
+            }
+            // fallthrough gen fields
+        }
       default:
         if (rb_obj_exivar_p(obj)) {
             VALUE fields_obj = 0;