Add cc tbl stats available through GC.stat

Author: luke-gruber

gc/default/default.c

@@ -7438,6 +7438,7 @@ enum gc_stat_sym {
 #endif
     gc_stat_sym_weak_references_count,
 
+    // Added by ractor team
     gc_stat_sym_barrier_time_taken_ns,
     gc_stat_sym_barrier_serial,
     gc_stat_sym_gc_barrier_time_taken_ns,
@@ -7449,6 +7450,17 @@ enum gc_stat_sym {
     gc_stat_sym_fstring_table_size,
     gc_stat_sym_fstring_table_capacity,
 
+#if CC_TBL_STATS
+    gc_stat_sym_cc_table_duplications,
+    gc_stat_sym_cc_table_creations,
+    gc_stat_sym_cc_invalidations,
+    gc_stat_sym_cc_table_cme_evictions,
+    gc_stat_sym_cc_table_frees,
+    gc_stat_sym_cc_table_duplications_unshareable_singletons,
+#endif
+
+    // /Added by ractor team
+
 #if RGENGC_PROFILE
     gc_stat_sym_total_generated_normal_object_count,
     gc_stat_sym_total_generated_shady_object_count,
@@ -7501,6 +7513,8 @@ setup_gc_stat_symbols(void)
 #endif
         S(weak_references_count);
 
+        // Added by ractor team
+
         S(barrier_time_taken_ns);
         S(barrier_serial);
         S(gc_barrier_time_taken_ns);
@@ -7511,6 +7525,17 @@ setup_gc_stat_symbols(void)
 
         S(fstring_table_size);
         S(fstring_table_capacity);
+
+#if CC_TBL_STATS
+        S(cc_table_duplications);
+        S(cc_table_creations);
+        S(cc_invalidations);
+        S(cc_table_cme_evictions);
+        S(cc_table_frees);
+        S(cc_table_duplications_unshareable_singletons);
+#endif
+        // /Added by ractor team
+
 #if RGENGC_PROFILE
         S(total_generated_normal_object_count);
         S(total_generated_shady_object_count);
@@ -7589,6 +7614,8 @@ rb_gc_impl_stat(void *objspace_ptr, VALUE hash_or_sym)
     SET(old_objects, objspace->rgengc.old_objects);
     SET(old_objects_limit, objspace->rgengc.old_objects_limit);
 
+    // Added by ractor team
+
     SET(barrier_time_taken_ns, rb_barrier_time_taken_ns);
     SET(barrier_serial, vm->ractor.sched.barrier_serial);
     SET(gc_barrier_time_taken_ns, rb_gc_barrier_time_taken_ns);
@@ -7600,6 +7627,17 @@ rb_gc_impl_stat(void *objspace_ptr, VALUE hash_or_sym)
     SET(fstring_table_size, rb_fstring_table_size());
     SET(fstring_table_capacity, rb_fstring_table_capacity());
 
+#if CC_TBL_STATS
+    SET(cc_table_duplications, rb_cc_tbl_duplications);
+    SET(cc_table_creations, rb_cc_tbl_creations);
+    SET(cc_invalidations, rb_cc_invalidations);
+    SET(cc_table_cme_evictions, rb_cc_tbl_cme_evictions);
+    SET(cc_table_frees, rb_cc_tbl_frees);
+    SET(cc_table_duplications_unshareable_singletons, rb_cc_tbl_duplications_unshareable_singletons);
+#endif
+
+    // /Added by ractor team
+
 #if RGENGC_ESTIMATE_OLDMALLOC
     SET(oldmalloc_increase_bytes, objspace->rgengc.oldmalloc_increase);
     SET(oldmalloc_increase_bytes_limit, objspace->rgengc.oldmalloc_increase_limit);

vm_callinfo.h

@@ -330,7 +330,7 @@ cc_check_class(VALUE klass)
 }
 
 VALUE rb_vm_cc_table_create(size_t capa);
-VALUE rb_vm_cc_table_dup(VALUE old_table);
+VALUE rb_vm_cc_table_dup(VALUE old_table, VALUE klass);
 void rb_vm_cc_table_delete(VALUE table, ID mid);
 
 static inline const struct rb_callcache *
@@ -570,6 +570,9 @@ vm_cc_invalidate(const struct rb_callcache *cc)
 
     *(VALUE *)&cc->klass = Qundef;
     RB_DEBUG_COUNTER_INC(cc_ent_invalidate);
+#ifndef NO_CC_TBL_STATS
+    RUBY_ATOMIC_INC(rb_cc_invalidations);
+#endif
 }
 
 /* calldata */

vm_core.h

@@ -841,6 +841,21 @@ RUBY_EXTERN unsigned int rb_gc_barrier_serial;
 RUBY_EXTERN unsigned int rb_concur_set_resize_serial;
 RUBY_EXTERN unsigned long long rb_concur_set_resize_time_taken_ns;
 
+#ifndef NO_CC_TBL_STATS
+#define CC_TBL_STATS 1
+#else
+#define CC_TBL_STATS 0
+#endif
+
+#if CC_TBL_STATS
+RUBY_EXTERN rb_atomic_t rb_cc_tbl_duplications; // rb_vm_cc_table_dup
+RUBY_EXTERN rb_atomic_t rb_cc_tbl_creations; // rb_vm_cc_table_create
+RUBY_EXTERN rb_atomic_t rb_cc_invalidations; // vm_cc_invalidate
+RUBY_EXTERN unsigned long long rb_cc_tbl_cme_evictions; // vm_evict_cc
+RUBY_EXTERN unsigned long long rb_cc_tbl_frees; // vm_cc_table_free
+RUBY_EXTERN rb_atomic_t rb_cc_tbl_duplications_unshareable_singletons; // vm_cc_table_dup
+#endif
+
 /* default values */
 
 #define RUBY_VM_SIZE_ALIGN 4096

vm_insnhelper.c

@@ -2075,6 +2075,10 @@ vm_ccs_verify(struct rb_class_cc_entries *ccs, ID mid, VALUE klass)
 
 const rb_callable_method_entry_t *rb_check_overloaded_cme(const rb_callable_method_entry_t *cme, const struct rb_callinfo * const ci);
 
+#if CC_TBL_STATS
+unsigned long long rb_cc_tbl_cme_evictions;
+#endif
+
 static void
 vm_evict_cc(VALUE klass, VALUE cc_tbl, ID mid)
 {
@@ -2095,12 +2099,14 @@ vm_evict_cc(VALUE klass, VALUE cc_tbl, ID mid)
             return;
         }
 
-        VALUE new_table = rb_vm_cc_table_dup(cc_tbl);
+        VALUE new_table = rb_vm_cc_table_dup(cc_tbl, klass);
         rb_vm_cc_table_delete(new_table, mid);
         RB_OBJ_ATOMIC_WRITE(klass, &RCLASS_WRITABLE_CC_TBL(klass), new_table);
+        rb_cc_tbl_cme_evictions+=1;
     }
     else {
         rb_vm_cc_table_delete(cc_tbl, mid);
+        rb_cc_tbl_cme_evictions+=1;
     }
 }
 
@@ -2117,7 +2123,7 @@ vm_populate_cc(VALUE klass, const struct rb_callinfo * const ci, ID mid)
         cc_tbl = rb_vm_cc_table_create(1);
     }
     else if (rb_multi_ractor_p()) {
-        cc_tbl = rb_vm_cc_table_dup(cc_tbl);
+        cc_tbl = rb_vm_cc_table_dup(cc_tbl, klass);
     }
 
     RB_DEBUG_COUNTER_INC(cc_not_found_in_ccs);

vm_method.c

@@ -11,6 +11,14 @@ static int vm_redefinition_check_flag(VALUE klass);
 static void rb_vm_check_redefinition_opt_method(const rb_method_entry_t *me, VALUE klass);
 static inline rb_method_entry_t *lookup_method_table(VALUE klass, ID id);
 
+#if CC_TBL_STATS
+rb_atomic_t rb_cc_tbl_duplications;
+rb_atomic_t rb_cc_tbl_creations;
+rb_atomic_t rb_cc_invalidations;
+unsigned long long rb_cc_tbl_frees;
+rb_atomic_t rb_cc_tbl_duplications_unshareable_singletons;
+#endif
+
 #define object_id           idObject_id
 #define added               idMethod_added
 #define singleton_added     idSingleton_method_added
@@ -83,6 +91,9 @@ vm_cc_table_free(void *data)
 
     rb_id_table_foreach_values(tbl, cc_table_free_i, NULL);
     rb_managed_id_table_type.function.dfree(data);
+#if CC_TBL_STATS
+    rb_cc_tbl_frees++;
+#endif
 }
 
 static enum rb_id_table_iterator_result
@@ -141,6 +152,9 @@ static const rb_data_type_t cc_table_type = {
 VALUE
 rb_vm_cc_table_create(size_t capa)
 {
+#if CC_TBL_STATS
+    RUBY_ATOMIC_INC(rb_cc_tbl_creations);
+#endif
     return rb_managed_id_table_create(&cc_table_type, capa);
 }
 
@@ -167,10 +181,20 @@ vm_cc_table_dup_i(ID key, VALUE old_ccs_ptr, void *data)
 }
 
 VALUE
-rb_vm_cc_table_dup(VALUE old_table)
+rb_vm_cc_table_dup(VALUE old_table, VALUE klass)
 {
     VALUE new_table = rb_vm_cc_table_create(rb_managed_id_table_size(old_table));
     rb_managed_id_table_foreach(old_table, vm_cc_table_dup_i, (void *)new_table);
+#if CC_TBL_STATS
+    RUBY_ATOMIC_INC(rb_cc_tbl_duplications);
+    if (RCLASS_SINGLETON_P(klass)) {
+        VALUE obj = RCLASS_ATTACHED_OBJECT(klass);
+        // it could still be shareable through `Ractor.shareable?` but that's too expensive to call
+        if (!RB_OBJ_SHAREABLE_P(obj)) {
+            RUBY_ATOMIC_INC(rb_cc_tbl_duplications_unshareable_singletons);
+        }
+    }
+#endif
     return new_table;
 }
 
@@ -1787,7 +1811,7 @@ cache_callable_method_entry(VALUE klass, ID mid, const rb_callable_method_entry_
     }
     else {
         if (rb_multi_ractor_p()) {
-            VALUE new_cc_tbl = rb_vm_cc_table_dup(cc_tbl);
+            VALUE new_cc_tbl = rb_vm_cc_table_dup(cc_tbl, klass);
             vm_ccs_create(klass, new_cc_tbl, mid, cme);
             RB_OBJ_ATOMIC_WRITE(klass, &RCLASSEXT_CC_TBL(RCLASS_EXT_WRITABLE(klass)), new_cc_tbl);
         }