thread_safety 0.1.2 → 0.1.3

data/ext/{gc → gc-3.4/gc}/default/default.c

@@ -15,11 +15,8 @@
 # include <sys/user.h>
 #endif
 
-#ifdef BUILDING_MODULAR_GC
-# define nlz_int64(x) (x == 0 ? 64 : (unsigned int)__builtin_clzll((unsigned long long)x))
-#else
-# include "internal/bits.h"
-#endif
+#include "internal/bits.h"
+#include "internal/hash.h"
 
 #include "ruby/ruby.h"
 #include "ruby/atomic.h"
@@ -37,26 +34,8 @@
 # include "probes.h"
 #endif
 
-#ifdef BUILDING_MODULAR_GC
-# define RB_DEBUG_COUNTER_INC(_name) ((void)0)
-# define RB_DEBUG_COUNTER_INC_IF(_name, cond) (!!(cond))
-#else
-# include "debug_counter.h"
-#endif
-
-#ifdef BUILDING_MODULAR_GC
-# define rb_asan_poison_object(_obj) (0)
-# define rb_asan_unpoison_object(_obj, _newobj_p) (0)
-# define asan_unpoisoning_object(_obj) if (true)
-# define asan_poison_memory_region(_ptr, _size) (0)
-# define asan_unpoison_memory_region(_ptr, _size, _malloc_p) (0)
-# define asan_unpoisoning_memory_region(_ptr, _size) if (true)
-
-# define VALGRIND_MAKE_MEM_DEFINED(_ptr, _size) (0)
-# define VALGRIND_MAKE_MEM_UNDEFINED(_ptr, _size) (0)
-#else
-# include "internal/sanitizers.h"
-#endif
+#include "debug_counter.h"
+#include "internal/sanitizers.h"
 
 /* MALLOC_HEADERS_BEGIN */
 #ifndef HAVE_MALLOC_USABLE_SIZE
@@ -182,7 +161,6 @@
 typedef struct ractor_newobj_heap_cache {
     struct free_slot *freelist;
     struct heap_page *using_page;
-    size_t allocated_objects_count;
 } rb_ractor_newobj_heap_cache_t;
 
 typedef struct ractor_newobj_cache {
@@ -305,7 +283,7 @@ int ruby_rgengc_debug;
 #endif
 
 #ifndef GC_DEBUG_STRESS_TO_CLASS
-# define GC_DEBUG_STRESS_TO_CLASS 1
+# define GC_DEBUG_STRESS_TO_CLASS RUBY_DEBUG
 #endif
 
 typedef enum {
@@ -494,6 +472,7 @@ typedef struct rb_objspace {
     } flags;
 
     rb_event_flag_t hook_events;
+    unsigned long long next_object_id;
 
     rb_heap_t heaps[HEAP_COUNT];
     size_t empty_pages_count;
@@ -612,6 +591,9 @@ typedef struct rb_objspace {
         size_t step_slots;
     } rincgc;
 
+    st_table *id_to_obj_tbl;
+    st_table *obj_to_id_tbl;
+
 #if GC_DEBUG_STRESS_TO_CLASS
     VALUE stress_to_class;
 #endif
@@ -648,9 +630,7 @@ struct rvalue_overhead {
 size_t rb_gc_impl_obj_slot_size(VALUE obj);
 # define GET_RVALUE_OVERHEAD(obj) ((struct rvalue_overhead *)((uintptr_t)obj + rb_gc_impl_obj_slot_size(obj)))
 #else
-# ifndef RVALUE_OVERHEAD
-#  define RVALUE_OVERHEAD 0
-# endif
+# define RVALUE_OVERHEAD 0
 #endif
 
 #define BASE_SLOT_SIZE (sizeof(struct RBasic) + sizeof(VALUE[RBIMPL_RVALUE_EMBED_LEN_MAX]) + RVALUE_OVERHEAD)
@@ -824,6 +804,8 @@ heap_page_in_global_empty_pages_pool(rb_objspace_t *objspace, struct heap_page *
 #define GET_HEAP_WB_UNPROTECTED_BITS(x) (&GET_HEAP_PAGE(x)->wb_unprotected_bits[0])
 #define GET_HEAP_MARKING_BITS(x)        (&GET_HEAP_PAGE(x)->marking_bits[0])
 
+#define GC_SWEEP_PAGES_FREEABLE_PER_STEP 3
+
 #define RVALUE_AGE_BITMAP_INDEX(n)  (NUM_IN_PAGE(n) / (BITS_BITLENGTH / RVALUE_AGE_BIT_COUNT))
 #define RVALUE_AGE_BITMAP_OFFSET(n) ((NUM_IN_PAGE(n) % (BITS_BITLENGTH / RVALUE_AGE_BIT_COUNT)) * RVALUE_AGE_BIT_COUNT)
 
@@ -868,8 +850,8 @@ RVALUE_AGE_SET(VALUE obj, int age)
 #define stress_to_class         objspace->stress_to_class
 #define set_stress_to_class(c)  (stress_to_class = (c))
 #else
-#define stress_to_class         ((void)objspace, 0)
-#define set_stress_to_class(c)  ((void)objspace, (c))
+#define stress_to_class         (objspace, 0)
+#define set_stress_to_class(c)  (objspace, (c))
 #endif
 
 #if 0
@@ -1001,9 +983,9 @@ struct RZombie {
 
 #define RZOMBIE(o) ((struct RZombie *)(o))
 
-static bool ruby_enable_autocompact = false;
+int ruby_enable_autocompact = 0;
 #if RGENGC_CHECK_MODE
-static gc_compact_compare_func ruby_autocompact_compare_func;
+gc_compact_compare_func ruby_autocompact_compare_func;
 #endif
 
 static void init_mark_stack(mark_stack_t *stack);
@@ -1532,6 +1514,31 @@ minimum_slots_for_heap(rb_objspace_t *objspace, rb_heap_t *heap)
     return gc_params.heap_init_slots[heap_idx];
 }
 
+static int
+object_id_cmp(st_data_t x, st_data_t y)
+{
+    if (RB_TYPE_P(x, T_BIGNUM)) {
+        return !rb_big_eql(x, y);
+    }
+    else {
+        return x != y;
+    }
+}
+
+static st_index_t
+object_id_hash(st_data_t n)
+{
+    return FIX2LONG(rb_hash((VALUE)n));
+}
+
+#define OBJ_ID_INCREMENT (RUBY_IMMEDIATE_MASK + 1)
+#define OBJ_ID_INITIAL (OBJ_ID_INCREMENT)
+
+static const struct st_hash_type object_id_hash_type = {
+    object_id_cmp,
+    object_id_hash,
+};
+
 /* garbage objects will be collected soon. */
 bool
 rb_gc_impl_garbage_object_p(void *objspace_ptr, VALUE ptr)
@@ -1557,6 +1564,56 @@ rb_gc_impl_garbage_object_p(void *objspace_ptr, VALUE ptr)
         !RVALUE_MARKED(objspace, ptr);
 }
 
+VALUE
+rb_gc_impl_object_id_to_ref(void *objspace_ptr, VALUE object_id)
+{
+    rb_objspace_t *objspace = objspace_ptr;
+
+    VALUE obj;
+    if (st_lookup(objspace->id_to_obj_tbl, object_id, &obj) &&
+            !rb_gc_impl_garbage_object_p(objspace, obj)) {
+        return obj;
+    }
+
+    if (rb_funcall(object_id, rb_intern(">="), 1, ULL2NUM(objspace->next_object_id))) {
+        rb_raise(rb_eRangeError, "%+"PRIsVALUE" is not id value", rb_funcall(object_id, rb_intern("to_s"), 1, INT2FIX(10)));
+    }
+    else {
+        rb_raise(rb_eRangeError, "%+"PRIsVALUE" is recycled object", rb_funcall(object_id, rb_intern("to_s"), 1, INT2FIX(10)));
+    }
+}
+
+VALUE
+rb_gc_impl_object_id(void *objspace_ptr, VALUE obj)
+{
+    VALUE id;
+    rb_objspace_t *objspace = objspace_ptr;
+
+    unsigned int lev = rb_gc_vm_lock();
+    if (FL_TEST(obj, FL_SEEN_OBJ_ID)) {
+        st_data_t val;
+        if (st_lookup(objspace->obj_to_id_tbl, (st_data_t)obj, &val)) {
+            id = (VALUE)val;
+        }
+        else {
+            rb_bug("rb_gc_impl_object_id: FL_SEEN_OBJ_ID flag set but not found in table");
+        }
+    }
+    else {
+        GC_ASSERT(!st_lookup(objspace->obj_to_id_tbl, (st_data_t)obj, NULL));
+
+        id = ULL2NUM(objspace->next_object_id);
+        objspace->next_object_id += OBJ_ID_INCREMENT;
+
+        st_insert(objspace->obj_to_id_tbl, (st_data_t)obj, (st_data_t)id);
+        st_insert(objspace->id_to_obj_tbl, (st_data_t)id, (st_data_t)obj);
+        FL_SET(obj, FL_SEEN_OBJ_ID);
+    }
+    rb_gc_vm_unlock(lev);
+
+    return id;
+}
+
 static void free_stack_chunks(mark_stack_t *);
 static void mark_stack_free_cache(mark_stack_t *);
 static void heap_page_free(rb_objspace_t *objspace, struct heap_page *page);
@@ -1714,7 +1771,13 @@ heap_page_free(rb_objspace_t *objspace, struct heap_page *page)
 static void
 heap_pages_free_unused_pages(rb_objspace_t *objspace)
 {
-    if (objspace->empty_pages != NULL && heap_pages_freeable_pages > 0) {
+    size_t pages_to_keep_count =
+        // Get number of pages estimated for the smallest size pool
+        CEILDIV(objspace->heap_pages.allocatable_slots, HEAP_PAGE_OBJ_LIMIT) *
+            // Estimate the average slot size multiple
+            (1 << (HEAP_COUNT / 2));
+
+    if (objspace->empty_pages != NULL && objspace->empty_pages_count > pages_to_keep_count) {
         GC_ASSERT(objspace->empty_pages_count > 0);
         objspace->empty_pages = NULL;
         objspace->empty_pages_count = 0;
@@ -1723,15 +1786,15 @@ heap_pages_free_unused_pages(rb_objspace_t *objspace)
         for (i = j = 0; i < rb_darray_size(objspace->heap_pages.sorted); i++) {
             struct heap_page *page = rb_darray_get(objspace->heap_pages.sorted, i);
 
-            if (heap_page_in_global_empty_pages_pool(objspace, page) && heap_pages_freeable_pages > 0) {
+            if (heap_page_in_global_empty_pages_pool(objspace, page) && pages_to_keep_count == 0) {
                 heap_page_free(objspace, page);
-                heap_pages_freeable_pages--;
             }
             else {
-                if (heap_page_in_global_empty_pages_pool(objspace, page)) {
+                if (heap_page_in_global_empty_pages_pool(objspace, page) && pages_to_keep_count > 0) {
                     page->free_next = objspace->empty_pages;
                     objspace->empty_pages = page;
                     objspace->empty_pages_count++;
+                    pages_to_keep_count--;
                 }
 
                 if (i != j) {
@@ -1898,7 +1961,7 @@ heap_page_allocate(rb_objspace_t *objspace)
         }
     }
 
-    rb_darray_insert_without_gc(&objspace->heap_pages.sorted, hi, page);
+    rb_darray_insert(&objspace->heap_pages.sorted, hi, page);
 
     if (heap_pages_lomem == 0 || heap_pages_lomem > start) heap_pages_lomem = start;
     if (heap_pages_himem < end) heap_pages_himem = end;
@@ -1963,33 +2026,29 @@ heap_add_page(rb_objspace_t *objspace, rb_heap_t *heap, struct heap_page *page)
 static int
 heap_page_allocate_and_initialize(rb_objspace_t *objspace, rb_heap_t *heap)
 {
-    gc_report(1, objspace, "heap_page_allocate_and_initialize: rb_darray_size(objspace->heap_pages.sorted): %"PRIdSIZE", "
+    if (objspace->heap_pages.allocatable_slots > 0) {
+        gc_report(1, objspace, "heap_page_allocate_and_initialize: rb_darray_size(objspace->heap_pages.sorted): %"PRIdSIZE", "
                   "allocatable_slots: %"PRIdSIZE", heap->total_pages: %"PRIdSIZE"\n",
                   rb_darray_size(objspace->heap_pages.sorted), objspace->heap_pages.allocatable_slots, heap->total_pages);
 
-    bool allocated = false;
-    struct heap_page *page = heap_page_resurrect(objspace);
-
-    if (page == NULL && objspace->heap_pages.allocatable_slots > 0) {
-        page = heap_page_allocate(objspace);
-        allocated = true;
-    }
-
-    if (page != NULL) {
+        struct heap_page *page = heap_page_resurrect(objspace);
+        if (page == NULL) {
+            page = heap_page_allocate(objspace);
+        }
         heap_add_page(objspace, heap, page);
         heap_add_freepage(heap, page);
 
-        if (allocated) {
-            if (objspace->heap_pages.allocatable_slots > (size_t)page->total_slots) {
-                objspace->heap_pages.allocatable_slots -= page->total_slots;
-            }
-            else {
-                objspace->heap_pages.allocatable_slots = 0;
-            }
+        if (objspace->heap_pages.allocatable_slots > (size_t)page->total_slots) {
+            objspace->heap_pages.allocatable_slots -= page->total_slots;
         }
+        else {
+            objspace->heap_pages.allocatable_slots = 0;
+        }
+
+        return true;
     }
 
-    return page != NULL;
+    return false;
 }
 
 static void
@@ -2091,10 +2150,10 @@ heap_prepare(rb_objspace_t *objspace, rb_heap_t *heap)
 static inline VALUE
 newobj_fill(VALUE obj, VALUE v1, VALUE v2, VALUE v3)
 {
-    VALUE *p = (VALUE *)(obj + sizeof(struct RBasic));
-    p[0] = v1;
-    p[1] = v2;
-    p[2] = v3;
+    VALUE *p = (VALUE *)obj;
+    p[2] = v1;
+    p[3] = v2;
+    p[4] = v3;
     return obj;
 }
 
@@ -2119,13 +2178,12 @@ rb_gc_impl_source_location_cstr(int *ptr)
 static inline VALUE
 newobj_init(VALUE klass, VALUE flags, int wb_protected, rb_objspace_t *objspace, VALUE obj)
 {
+#if !__has_feature(memory_sanitizer)
     GC_ASSERT(BUILTIN_TYPE(obj) == T_NONE);
     GC_ASSERT((flags & FL_WB_PROTECTED) == 0);
+#endif
     RBASIC(obj)->flags = flags;
     *((VALUE *)&RBASIC(obj)->klass) = klass;
-#if RBASIC_SHAPE_ID_FIELD
-    RBASIC(obj)->shape_id = 0;
-#endif
 
     int t = flags & RUBY_T_MASK;
     if (t == T_CLASS || t == T_MODULE || t == T_ICLASS) {
@@ -2180,7 +2238,7 @@ newobj_init(VALUE klass, VALUE flags, int wb_protected, rb_objspace_t *objspace,
 
     gc_report(5, objspace, "newobj: %s\n", rb_obj_info(obj));
 
-    // RUBY_DEBUG_LOG("obj:%p (%s)", (void *)obj, rb_obj_info(obj));
+    RUBY_DEBUG_LOG("obj:%p (%s)", (void *)obj, rb_obj_info(obj));
     return obj;
 }
 
@@ -2213,8 +2271,6 @@ rb_gc_impl_size_allocatable_p(size_t size)
     return size <= heap_slot_size(HEAP_COUNT - 1);
 }
 
-static const size_t ALLOCATED_COUNT_STEP = 1024;
-
 static inline VALUE
 ractor_cache_allocate_slot(rb_objspace_t *objspace, rb_ractor_newobj_cache_t *cache,
                            size_t heap_idx)
@@ -2237,22 +2293,6 @@ ractor_cache_allocate_slot(rb_objspace_t *objspace, rb_ractor_newobj_cache_t *ca
         VALUE obj = (VALUE)p;
         rb_asan_unpoison_object(obj, true);
         heap_cache->freelist = p->next;
-
-        if (rb_gc_multi_ractor_p()) {
-            heap_cache->allocated_objects_count++;
-            rb_heap_t *heap = &heaps[heap_idx];
-            if (heap_cache->allocated_objects_count >= ALLOCATED_COUNT_STEP) {
-                RUBY_ATOMIC_SIZE_ADD(heap->total_allocated_objects, heap_cache->allocated_objects_count);
-                heap_cache->allocated_objects_count = 0;
-            }
-        }
-        else {
-            rb_heap_t *heap = &heaps[heap_idx];
-            heap->total_allocated_objects++;
-            GC_ASSERT(heap->total_slots >=
-                    (heap->total_allocated_objects - heap->total_freed_objects - heap->final_slots_count));
-        }
-
 #if RGENGC_CHECK_MODE
         GC_ASSERT(rb_gc_impl_obj_slot_size(obj) == heap_slot_size(heap_idx));
         // zero clear
@@ -2364,6 +2404,7 @@ newobj_cache_miss(rb_objspace_t *objspace, rb_ractor_newobj_cache_t *cache, size
 
     if (!vm_locked) {
         lev = rb_gc_cr_lock();
+        vm_locked = true;
         unlock_vm = true;
     }
 
@@ -2405,6 +2446,12 @@ newobj_alloc(rb_objspace_t *objspace, rb_ractor_newobj_cache_t *cache, size_t he
         obj = newobj_cache_miss(objspace, cache, heap_idx, vm_locked);
     }
 
+    rb_heap_t *heap = &heaps[heap_idx];
+    heap->total_allocated_objects++;
+    GC_ASSERT(rb_gc_multi_ractor_p() ||
+        heap->total_slots >=
+            (heap->total_allocated_objects - heap->total_freed_objects - heap->final_slots_count));
+
     return obj;
 }
 
@@ -2470,8 +2517,9 @@ rb_gc_impl_new_obj(void *objspace_ptr, void *cache_ptr, VALUE klass, VALUE flags
     (void)RB_DEBUG_COUNTER_INC_IF(obj_newobj_wb_unprotected, !wb_protected);
 
     if (RB_UNLIKELY(stress_to_class)) {
-        if (rb_hash_lookup2(stress_to_class, klass, Qundef) != Qundef) {
-            rb_memerror();
+        long cnt = RARRAY_LEN(stress_to_class);
+        for (long i = 0; i < cnt; i++) {
+            if (klass == RARRAY_AREF(stress_to_class, i)) rb_memerror();
         }
     }
 
@@ -2570,7 +2618,7 @@ rb_gc_impl_pointer_to_heap_p(void *objspace_ptr, const void *ptr)
     return is_pointer_to_heap(objspace_ptr, ptr);
 }
 
-#define ZOMBIE_OBJ_KEPT_FLAGS (FL_FINALIZE)
+#define ZOMBIE_OBJ_KEPT_FLAGS (FL_SEEN_OBJ_ID | FL_FINALIZE)
 
 void
 rb_gc_impl_make_zombie(void *objspace_ptr, VALUE obj, void (*dfree)(void *), void *data)
@@ -2592,6 +2640,23 @@ rb_gc_impl_make_zombie(void *objspace_ptr, VALUE obj, void (*dfree)(void *), voi
     page->heap->final_slots_count++;
 }
 
+static void
+obj_free_object_id(rb_objspace_t *objspace, VALUE obj)
+{
+    st_data_t o = (st_data_t)obj, id;
+
+    GC_ASSERT(BUILTIN_TYPE(obj) == T_NONE || FL_TEST(obj, FL_SEEN_OBJ_ID));
+    FL_UNSET(obj, FL_SEEN_OBJ_ID);
+
+    if (st_delete(objspace->obj_to_id_tbl, &o, &id)) {
+        GC_ASSERT(id);
+        st_delete(objspace->id_to_obj_tbl, &id, NULL);
+    }
+    else {
+        rb_bug("Object ID seen, but not in mapping table: %s", rb_obj_info(obj));
+    }
+}
+
 typedef int each_obj_callback(void *, void *, size_t, void *);
 typedef int each_page_callback(struct heap_page *, void *);
 
@@ -2753,8 +2818,6 @@ rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block)
 
     RBASIC(obj)->flags |= FL_FINALIZE;
 
-    int lev = rb_gc_vm_lock();
-
     if (st_lookup(finalizer_table, obj, &data)) {
         table = (VALUE)data;
 
@@ -2766,7 +2829,6 @@ rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block)
             for (i = 0; i < len; i++) {
                 VALUE recv = RARRAY_AREF(table, i);
                 if (rb_equal(recv, block)) {
-                    rb_gc_vm_unlock(lev);
                     return recv;
                 }
             }
@@ -2775,13 +2837,11 @@ rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block)
         rb_ary_push(table, block);
     }
     else {
-        table = rb_ary_new3(2, rb_obj_id(obj), block);
+        table = rb_ary_new3(1, block);
         rb_obj_hide(table);
         st_add_direct(finalizer_table, obj, table);
     }
 
-    rb_gc_vm_unlock(lev);
-
     return block;
 }
 
@@ -2793,11 +2853,7 @@ rb_gc_impl_undefine_finalizer(void *objspace_ptr, VALUE obj)
     GC_ASSERT(!OBJ_FROZEN(obj));
 
     st_data_t data = obj;
-
-    int lev = rb_gc_vm_lock();
     st_delete(finalizer_table, &data, 0);
-    rb_gc_vm_unlock(lev);
-
     FL_UNSET(obj, FL_FINALIZE);
 }
 
@@ -2810,17 +2866,27 @@ rb_gc_impl_copy_finalizer(void *objspace_ptr, VALUE dest, VALUE obj)
 
     if (!FL_TEST(obj, FL_FINALIZE)) return;
 
-    int lev = rb_gc_vm_lock();
     if (RB_LIKELY(st_lookup(finalizer_table, obj, &data))) {
-        table = rb_ary_dup((VALUE)data);
-        RARRAY_ASET(table, 0, rb_obj_id(dest));
+        table = (VALUE)data;
         st_insert(finalizer_table, dest, table);
         FL_SET(dest, FL_FINALIZE);
     }
     else {
         rb_bug("rb_gc_copy_finalizer: FL_FINALIZE set but not found in finalizer_table: %s", rb_obj_info(obj));
     }
-    rb_gc_vm_unlock(lev);
+}
+
+static VALUE
+get_object_id_in_finalizer(rb_objspace_t *objspace, VALUE obj)
+{
+    if (FL_TEST(obj, FL_SEEN_OBJ_ID)) {
+        return rb_gc_impl_object_id(objspace, obj);
+    }
+    else {
+        VALUE id = ULL2NUM(objspace->next_object_id);
+        objspace->next_object_id += OBJ_ID_INCREMENT;
+        return id;
+    }
 }
 
 static VALUE
@@ -2828,7 +2894,7 @@ get_final(long i, void *data)
 {
     VALUE table = (VALUE)data;
 
-    return RARRAY_AREF(table, i + 1);
+    return RARRAY_AREF(table, i);
 }
 
 static void
@@ -2843,7 +2909,7 @@ run_final(rb_objspace_t *objspace, VALUE zombie)
         FL_UNSET(zombie, FL_FINALIZE);
         st_data_t table;
         if (st_delete(finalizer_table, &key, &table)) {
-            rb_gc_run_obj_finalizer(RARRAY_AREF(table, 0), RARRAY_LEN(table) - 1, get_final, (void *)table);
+            rb_gc_run_obj_finalizer(get_object_id_in_finalizer(objspace, zombie), RARRAY_LEN(table), get_final, (void *)table);
         }
         else {
             rb_bug("FL_FINALIZE flag is set, but finalizers are not found");
@@ -2864,11 +2930,15 @@ finalize_list(rb_objspace_t *objspace, VALUE zombie)
         next_zombie = RZOMBIE(zombie)->next;
         page = GET_HEAP_PAGE(zombie);
 
-        int lev = rb_gc_vm_lock();
-
         run_final(objspace, zombie);
+
+        int lev = rb_gc_vm_lock();
         {
             GC_ASSERT(BUILTIN_TYPE(zombie) == T_ZOMBIE);
+            if (FL_TEST(zombie, FL_SEEN_OBJ_ID)) {
+                obj_free_object_id(objspace, zombie);
+            }
+
             GC_ASSERT(page->heap->final_slots_count > 0);
             GC_ASSERT(page->final_slots > 0);
 
@@ -2980,15 +3050,16 @@ rb_gc_impl_shutdown_free_objects(void *objspace_ptr)
 }
 
 static int
-rb_gc_impl_shutdown_call_finalizer_i(st_data_t key, st_data_t val, st_data_t _data)
+rb_gc_impl_shutdown_call_finalizer_i(st_data_t key, st_data_t val, st_data_t data)
 {
+    rb_objspace_t *objspace = (rb_objspace_t *)data;
     VALUE obj = (VALUE)key;
     VALUE table = (VALUE)val;
 
     GC_ASSERT(RB_FL_TEST(obj, FL_FINALIZE));
     GC_ASSERT(RB_BUILTIN_TYPE(val) == T_ARRAY);
 
-    rb_gc_run_obj_finalizer(RARRAY_AREF(table, 0), RARRAY_LEN(table) - 1, get_final, (void *)table);
+    rb_gc_run_obj_finalizer(rb_gc_impl_object_id(objspace, obj), RARRAY_LEN(table), get_final, (void *)table);
 
     FL_UNSET(obj, FL_FINALIZE);
 
@@ -3015,7 +3086,7 @@ rb_gc_impl_shutdown_call_finalizer(void *objspace_ptr)
     }
 
     while (finalizer_table->num_entries) {
-        st_foreach(finalizer_table, rb_gc_impl_shutdown_call_finalizer_i, 0);
+        st_foreach(finalizer_table, rb_gc_impl_shutdown_call_finalizer_i, (st_data_t)objspace);
     }
 
     /* run finalizers */
@@ -3130,10 +3201,6 @@ protect_page_body(struct heap_page_body *body, DWORD protect)
     DWORD old_protect;
     return VirtualProtect(body, HEAP_PAGE_SIZE, protect, &old_protect) != 0;
 }
-#elif defined(__wasi__)
-// wasi-libc's mprotect emulation does not support PROT_NONE
-enum {HEAP_PAGE_LOCK, HEAP_PAGE_UNLOCK};
-#define protect_page_body(body, protect) 1
 #else
 enum {HEAP_PAGE_LOCK = PROT_NONE, HEAP_PAGE_UNLOCK = PROT_READ | PROT_WRITE};
 #define protect_page_body(body, protect) !mprotect((body), HEAP_PAGE_SIZE, (protect))
@@ -3472,8 +3539,12 @@ gc_sweep_plane(rb_objspace_t *objspace, rb_heap_t *heap, uintptr_t p, bits_t bit
 
                 rb_gc_event_hook(vp, RUBY_INTERNAL_EVENT_FREEOBJ);
 
+                bool has_object_id = FL_TEST(vp, FL_SEEN_OBJ_ID);
                 rb_gc_obj_free_vm_weak_references(vp);
                 if (rb_gc_obj_free(objspace, vp)) {
+                    if (has_object_id) {
+                        obj_free_object_id(objspace, vp);
+                    }
                     // always add free slots back to the swept pages freelist,
                     // so that if we're compacting, we can re-use the slots
                     (void)VALGRIND_MAKE_MEM_UNDEFINED((void*)p, BASE_SLOT_SIZE);
@@ -3685,19 +3756,13 @@ static int compare_pinned_slots(const void *left, const void *right, void *d);
 static void
 gc_ractor_newobj_cache_clear(void *c, void *data)
 {
-    rb_objspace_t *objspace = rb_gc_get_objspace();
     rb_ractor_newobj_cache_t *newobj_cache = c;
 
     newobj_cache->incremental_mark_step_allocated_slots = 0;
 
     for (size_t heap_idx = 0; heap_idx < HEAP_COUNT; heap_idx++) {
-
         rb_ractor_newobj_heap_cache_t *cache = &newobj_cache->heap_caches[heap_idx];
 
-        rb_heap_t *heap = &heaps[heap_idx];
-        RUBY_ATOMIC_SIZE_ADD(heap->total_allocated_objects, cache->allocated_objects_count);
-        cache->allocated_objects_count = 0;
-
         struct heap_page *page = cache->using_page;
         struct free_slot *freelist = cache->freelist;
         RUBY_DEBUG_LOG("ractor using_page:%p freelist:%p", (void *)page, (void *)freelist);
@@ -3714,6 +3779,7 @@ gc_sweep_start(rb_objspace_t *objspace)
 {
     gc_mode_transition(objspace, gc_mode_sweeping);
     objspace->rincgc.pooled_slots = 0;
+    objspace->heap_pages.allocatable_slots = 0;
 
 #if GC_CAN_COMPILE_COMPACTION
     if (objspace->flags.during_compacting) {
@@ -3750,7 +3816,7 @@ gc_sweep_finish_heap(rb_objspace_t *objspace, rb_heap_t *heap)
 
     if (swept_slots < min_free_slots &&
             /* The heap is a growth heap if it freed more slots than had empty slots. */
-            ((heap->empty_slots == 0 && total_slots > 0) || heap->freed_slots > heap->empty_slots)) {
+            (heap->empty_slots == 0 || heap->freed_slots > heap->empty_slots)) {
         /* If we don't have enough slots and we have pages on the tomb heap, move
         * pages from the tomb heap to the eden heap. This may prevent page
         * creation thrashing (frequently allocating and deallocting pages) and
@@ -3766,12 +3832,10 @@ gc_sweep_finish_heap(rb_objspace_t *objspace, rb_heap_t *heap)
 
         if (swept_slots < min_free_slots) {
             /* Grow this heap if we are in a major GC or if we haven't run at least
-             * RVALUE_OLD_AGE minor GC since the last major GC. */
+            * RVALUE_OLD_AGE minor GC since the last major GC. */
             if (is_full_marking(objspace) ||
                     objspace->profile.count - objspace->rgengc.last_major_gc < RVALUE_OLD_AGE) {
-                if (objspace->heap_pages.allocatable_slots < min_free_slots) {
-                    heap_allocatable_slots_expand(objspace, heap, swept_slots, heap->total_slots);
-                }
+                heap_allocatable_slots_expand(objspace, heap, swept_slots, heap->total_slots);
             }
             else {
                 gc_needs_major_flags |= GPR_FLAG_MAJOR_BY_NOFREE;
@@ -3821,6 +3885,7 @@ static int
 gc_sweep_step(rb_objspace_t *objspace, rb_heap_t *heap)
 {
     struct heap_page *sweep_page = heap->sweeping_page;
+    int unlink_limit = GC_SWEEP_PAGES_FREEABLE_PER_STEP;
     int swept_slots = 0;
     int pooled_slots = 0;
 
@@ -3844,7 +3909,11 @@ gc_sweep_step(rb_objspace_t *objspace, rb_heap_t *heap)
 
         heap->sweeping_page = ccan_list_next(&heap->pages, sweep_page, page_node);
 
-        if (free_slots == sweep_page->total_slots) {
+        if (free_slots == sweep_page->total_slots &&
+                heap_pages_freeable_pages > 0 &&
+                unlink_limit > 0) {
+            heap_pages_freeable_pages--;
+            unlink_limit--;
             /* There are no living objects, so move this page to the global empty pages. */
             heap_unlink_page(objspace, heap, sweep_page);
 
@@ -3923,7 +3992,9 @@ gc_sweep_continue(rb_objspace_t *objspace, rb_heap_t *sweep_heap)
     for (int i = 0; i < HEAP_COUNT; i++) {
         rb_heap_t *heap = &heaps[i];
         if (!gc_sweep_step(objspace, heap)) {
-            if (heap == sweep_heap && objspace->empty_pages_count == 0 && objspace->heap_pages.allocatable_slots == 0) {
+            /* sweep_heap requires a free slot but sweeping did not yield any
+             * and we cannot allocate a new page. */
+            if (heap == sweep_heap && objspace->heap_pages.allocatable_slots == 0) {
                 /* Not allowed to create a new page so finish sweeping. */
                 gc_sweep_rest(objspace);
                 break;
@@ -4491,7 +4562,11 @@ rb_gc_impl_mark_weak(void *objspace_ptr, VALUE *ptr)
 
     rgengc_check_relation(objspace, obj);
 
-    rb_darray_append_without_gc(&objspace->weak_references, ptr);
+    DURING_GC_COULD_MALLOC_REGION_START();
+    {
+        rb_darray_append(&objspace->weak_references, ptr);
+    }
+    DURING_GC_COULD_MALLOC_REGION_END();
 
     objspace->profile.weak_references_count++;
 }
@@ -4539,6 +4614,8 @@ mark_roots(rb_objspace_t *objspace, const char **categoryp)
         st_foreach(finalizer_table, pin_value, (st_data_t)objspace);
     }
 
+    st_foreach(objspace->obj_to_id_tbl, gc_mark_tbl_no_pin_i, (st_data_t)objspace);
+
     if (stress_to_class) rb_gc_mark(stress_to_class);
 
     rb_gc_save_machine_context();
@@ -5304,7 +5381,11 @@ gc_update_weak_references(rb_objspace_t *objspace)
     objspace->profile.retained_weak_references_count = retained_weak_references_count;
 
     rb_darray_clear(objspace->weak_references);
-    rb_darray_resize_capa_without_gc(&objspace->weak_references, retained_weak_references_count);
+    DURING_GC_COULD_MALLOC_REGION_START();
+    {
+        rb_darray_resize_capa(&objspace->weak_references, retained_weak_references_count);
+    }
+    DURING_GC_COULD_MALLOC_REGION_END();
 }
 
 static void
@@ -5387,10 +5468,6 @@ gc_marks_finish(rb_objspace_t *objspace)
                     gc_needs_major_flags |= GPR_FLAG_MAJOR_BY_NOFREE;
                 }
             }
-
-            if (full_marking) {
-                heap_allocatable_slots_expand(objspace, NULL, sweep_slots, total_slots);
-            }
         }
 
         if (full_marking) {
@@ -6006,10 +6083,9 @@ rb_gc_impl_writebarrier(void *objspace_ptr, VALUE a, VALUE b)
 
     if (RGENGC_CHECK_MODE) {
         if (SPECIAL_CONST_P(a)) rb_bug("rb_gc_writebarrier: a is special const: %"PRIxVALUE, a);
+        if (SPECIAL_CONST_P(b)) rb_bug("rb_gc_writebarrier: b is special const: %"PRIxVALUE, b);
     }
 
-    if (SPECIAL_CONST_P(b)) return;
-
     GC_ASSERT(RB_BUILTIN_TYPE(a) != T_NONE);
     GC_ASSERT(RB_BUILTIN_TYPE(a) != T_MOVED);
     GC_ASSERT(RB_BUILTIN_TYPE(a) != T_ZOMBIE);
@@ -6119,58 +6195,33 @@ 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;
-};
-
-#define RB_GC_OBJECT_METADATA_ENTRY_COUNT (sizeof(struct rb_gc_object_metadata_names) / sizeof(ID))
-static struct rb_gc_object_metadata_entry object_metadata_entries[RB_GC_OBJECT_METADATA_ENTRY_COUNT + 1];
-
-struct rb_gc_object_metadata_entry *
-rb_gc_impl_object_metadata(void *objspace_ptr, VALUE obj)
+// TODO: rearchitect this function to work for a generic GC
+size_t
+rb_gc_impl_obj_flags(void *objspace_ptr, VALUE obj, ID* flags, size_t max)
 {
     rb_objspace_t *objspace = objspace_ptr;
     size_t n = 0;
-    static struct rb_gc_object_metadata_names names;
+    static ID ID_marked;
+    static ID ID_wb_protected, ID_old, ID_marking, ID_uncollectible, ID_pinned;
 
-    if (!names.ID_marked) {
-#define I(s) names.ID_##s = rb_intern(#s)
+    if (!ID_marked) {
+#define I(s) ID_##s = rb_intern(#s);
+        I(marked);
         I(wb_protected);
-        I(age);
         I(old);
-        I(uncollectible);
         I(marking);
-        I(marked);
+        I(uncollectible);
         I(pinned);
-        I(object_id);
-        I(shareable);
 #undef I
     }
 
-#define SET_ENTRY(na, v) do { \
-    GC_ASSERT(n <= RB_GC_OBJECT_METADATA_ENTRY_COUNT); \
-    object_metadata_entries[n].name = names.ID_##na; \
-    object_metadata_entries[n].val = v; \
-    n++; \
-} while (0)
-
-    if (!RVALUE_WB_UNPROTECTED(objspace, obj)) SET_ENTRY(wb_protected, Qtrue);
-    SET_ENTRY(age, INT2FIX(RVALUE_AGE_GET(obj)));
-    if (RVALUE_OLD_P(objspace, obj)) SET_ENTRY(old, Qtrue);
-    if (RVALUE_UNCOLLECTIBLE(objspace, obj)) SET_ENTRY(uncollectible, Qtrue);
-    if (RVALUE_MARKING(objspace, obj)) SET_ENTRY(marking, Qtrue);
-    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(obj, FL_SHAREABLE)) SET_ENTRY(shareable, Qtrue);
-
-    object_metadata_entries[n].name = 0;
-    object_metadata_entries[n].val = 0;
-#undef SET_ENTRY
-
-    return object_metadata_entries;
+    if (RVALUE_WB_UNPROTECTED(objspace, obj) == 0 && n < max)                   flags[n++] = ID_wb_protected;
+    if (RVALUE_OLD_P(objspace, obj) && n < max)                                 flags[n++] = ID_old;
+    if (RVALUE_UNCOLLECTIBLE(objspace, obj) && n < max)                         flags[n++] = ID_uncollectible;
+    if (RVALUE_MARKING(objspace, obj) && n < max) flags[n++] = ID_marking;
+    if (RVALUE_MARKED(objspace, obj) && n < max)    flags[n++] = ID_marked;
+    if (RVALUE_PINNED(objspace, obj) && n < max)  flags[n++] = ID_pinned;
+    return n;
 }
 
 void *
@@ -6189,6 +6240,7 @@ rb_gc_impl_ractor_cache_free(void *objspace_ptr, void *cache)
     rb_objspace_t *objspace = objspace_ptr;
 
     objspace->live_ractor_cache_count--;
+
     gc_ractor_newobj_cache_clear(cache, NULL);
     free(cache);
 }
@@ -6388,6 +6440,7 @@ gc_start(rb_objspace_t *objspace, unsigned int reason)
               reason,
               do_full_mark, !is_incremental_marking(objspace), objspace->flags.immediate_sweep);
 
+#if USE_DEBUG_COUNTER
     RB_DEBUG_COUNTER_INC(gc_count);
 
     if (reason & GPR_FLAG_MAJOR_MASK) {
@@ -6406,6 +6459,7 @@ gc_start(rb_objspace_t *objspace, unsigned int reason)
         (void)RB_DEBUG_COUNTER_INC_IF(gc_minor_capi,   reason & GPR_FLAG_CAPI);
         (void)RB_DEBUG_COUNTER_INC_IF(gc_minor_stress, reason & GPR_FLAG_STRESS);
     }
+#endif
 
     objspace->profile.count++;
     objspace->profile.latest_gc_info = reason;
@@ -6779,9 +6833,7 @@ rb_gc_impl_prepare_heap(void *objspace_ptr)
     gc_params.heap_free_slots_max_ratio = orig_max_free_slots;
 
     objspace->heap_pages.allocatable_slots = 0;
-    heap_pages_freeable_pages = objspace->empty_pages_count;
     heap_pages_free_unused_pages(objspace_ptr);
-    GC_ASSERT(heap_pages_freeable_pages == 0);
     GC_ASSERT(objspace->empty_pages_count == 0);
     objspace->heap_pages.allocatable_slots = orig_allocatable_slots;
 
@@ -6830,7 +6882,7 @@ gc_is_moveable_obj(rb_objspace_t *objspace, VALUE obj)
       case T_RATIONAL:
       case T_NODE:
       case T_CLASS:
-        if (FL_TEST_RAW(obj, FL_FINALIZE)) {
+        if (FL_TEST(obj, FL_FINALIZE)) {
             /* The finalizer table is a numtable. It looks up objects by address.
              * We can't mark the keys in the finalizer table because that would
              * prevent the objects from being collected.  This check prevents
@@ -6883,6 +6935,36 @@ gc_move(rb_objspace_t *objspace, VALUE src, VALUE dest, size_t src_slot_size, si
     CLEAR_IN_BITMAP(GET_HEAP_UNCOLLECTIBLE_BITS(src), src);
     CLEAR_IN_BITMAP(GET_HEAP_PAGE(src)->remembered_bits, src);
 
+    if (FL_TEST(src, FL_EXIVAR)) {
+        /* Resizing the st table could cause a malloc */
+        DURING_GC_COULD_MALLOC_REGION_START();
+        {
+            rb_mv_generic_ivar(src, dest);
+        }
+        DURING_GC_COULD_MALLOC_REGION_END();
+    }
+
+    if (FL_TEST(src, FL_SEEN_OBJ_ID)) {
+        /* If the source object's object_id has been seen, we need to update
+         * the object to object id mapping. */
+        st_data_t srcid = (st_data_t)src, id;
+
+        gc_report(4, objspace, "Moving object with seen id: %p -> %p\n", (void *)src, (void *)dest);
+        /* Resizing the st table could cause a malloc */
+        DURING_GC_COULD_MALLOC_REGION_START();
+        {
+            if (!st_delete(objspace->obj_to_id_tbl, &srcid, &id)) {
+                rb_bug("gc_move: object ID seen, but not in mapping table: %s", rb_obj_info((VALUE)src));
+            }
+
+            st_insert(objspace->obj_to_id_tbl, (st_data_t)dest, id);
+        }
+        DURING_GC_COULD_MALLOC_REGION_END();
+    }
+    else {
+        GC_ASSERT(!st_lookup(objspace->obj_to_id_tbl, (st_data_t)src, NULL));
+    }
+
     /* Move the object */
     memcpy((void *)dest, (void *)src, MIN(src_slot_size, slot_size));
 
@@ -7045,24 +7127,6 @@ gc_ref_update(void *vstart, void *vend, size_t stride, rb_objspace_t *objspace,
     return 0;
 }
 
-static int
-gc_update_references_weak_table_i(VALUE obj, void *data)
-{
-    int ret;
-    asan_unpoisoning_object(obj) {
-        ret = BUILTIN_TYPE(obj) == T_MOVED ? ST_REPLACE : ST_CONTINUE;
-    }
-    return ret;
-}
-
-static int
-gc_update_references_weak_table_replace_i(VALUE *obj, void *data)
-{
-    *obj = rb_gc_location(*obj);
-
-    return ST_CONTINUE;
-}
-
 static void
 gc_update_references(rb_objspace_t *objspace)
 {
@@ -7087,21 +7151,12 @@ gc_update_references(rb_objspace_t *objspace)
             }
         }
     }
-
+    gc_ref_update_table_values_only(objspace->obj_to_id_tbl);
+    gc_update_table_refs(objspace->id_to_obj_tbl);
     gc_update_table_refs(finalizer_table);
 
     rb_gc_update_vm_references((void *)objspace);
 
-    for (int table = 0; table < RB_GC_VM_WEAK_TABLE_COUNT; table++) {
-        rb_gc_vm_weak_table_foreach(
-            gc_update_references_weak_table_i,
-            gc_update_references_weak_table_replace_i,
-            NULL,
-            false,
-            table
-        );
-    }
-
     objspace->flags.during_reference_updating = false;
 }
 
@@ -7662,7 +7717,7 @@ rb_gc_impl_config_get(void *objspace_ptr)
 }
 
 static int
-gc_config_set_key(VALUE key, VALUE value, VALUE data)
+gc_config_set_key(st_data_t key, st_data_t value, st_data_t data)
 {
     rb_objspace_t *objspace = (rb_objspace_t *)data;
     if (rb_sym2id(key) == rb_intern("rgengc_allow_full_mark")) {
@@ -7681,7 +7736,7 @@ rb_gc_impl_config_set(void *objspace_ptr, VALUE hash)
         rb_raise(rb_eArgError, "expected keyword arguments");
     }
 
-    rb_hash_foreach(hash, gc_config_set_key, (st_data_t)objspace);
+    rb_hash_stlike_foreach(hash, gc_config_set_key, (st_data_t)objspace);
 }
 
 VALUE
@@ -7889,11 +7944,10 @@ static inline size_t
 objspace_malloc_size(rb_objspace_t *objspace, void *ptr, size_t hint)
 {
 #ifdef HAVE_MALLOC_USABLE_SIZE
-    if (!hint) {
-        hint = malloc_usable_size(ptr);
-    }
-#endif
+    return malloc_usable_size(ptr);
+#else
     return hint;
+#endif
 }
 
 enum memop_type {
@@ -9191,7 +9245,7 @@ rb_gc_impl_objspace_free(void *objspace_ptr)
     for (size_t i = 0; i < rb_darray_size(objspace->heap_pages.sorted); i++) {
         heap_page_free(objspace, rb_darray_get(objspace->heap_pages.sorted, i));
     }
-    rb_darray_free_without_gc(objspace->heap_pages.sorted);
+    rb_darray_free(objspace->heap_pages.sorted);
     heap_pages_lomem = 0;
     heap_pages_himem = 0;
 
@@ -9201,10 +9255,13 @@ rb_gc_impl_objspace_free(void *objspace_ptr)
         heap->total_slots = 0;
     }
 
+    st_free_table(objspace->id_to_obj_tbl);
+    st_free_table(objspace->obj_to_id_tbl);
+
     free_stack_chunks(&objspace->mark_stack);
     mark_stack_free_cache(&objspace->mark_stack);
 
-    rb_darray_free_without_gc(objspace->weak_references);
+    rb_darray_free(objspace->weak_references);
 
     free(objspace);
 }
@@ -9244,63 +9301,7 @@ gc_malloc_allocations(VALUE self)
 #endif
 
 void rb_gc_impl_before_fork(void *objspace_ptr) { /* no-op */ }
-void rb_gc_impl_after_fork(void *objspace_ptr, rb_pid_t pid) {
-    if (pid == 0) { /* child process */
-        rb_gc_ractor_newobj_cache_foreach(gc_ractor_newobj_cache_clear, NULL);
-    }
-}
-
-VALUE rb_ident_hash_new_with_size(st_index_t size);
-
-/*
- *  call-seq:
- *    GC.add_stress_to_class(class[, ...])
- *
- *  Raises NoMemoryError when allocating an instance of the given classes.
- *
- */
-static VALUE
-rb_gcdebug_add_stress_to_class(int argc, VALUE *argv, VALUE self)
-{
-    rb_objspace_t *objspace = rb_gc_get_objspace();
-
-    if (!stress_to_class) {
-        set_stress_to_class(rb_ident_hash_new_with_size(argc));
-    }
-
-    for (int i = 0; i < argc; i++) {
-        VALUE klass = argv[i];
-        rb_hash_aset(stress_to_class, klass, Qtrue);
-    }
-
-    return self;
-}
-
-/*
- *  call-seq:
- *    GC.remove_stress_to_class(class[, ...])
- *
- *  No longer raises NoMemoryError when allocating an instance of the
- *  given classes.
- *
- */
-static VALUE
-rb_gcdebug_remove_stress_to_class(int argc, VALUE *argv, VALUE self)
-{
-    rb_objspace_t *objspace = rb_gc_get_objspace();
-
-    if (stress_to_class) {
-        for (int i = 0; i < argc; ++i) {
-            rb_hash_delete(stress_to_class, argv[i]);
-        }
-
-        if (rb_hash_size(stress_to_class) == 0) {
-            stress_to_class = 0;
-        }
-    }
-
-    return Qnil;
-}
+void rb_gc_impl_after_fork(void *objspace_ptr, rb_pid_t pid) { /* no-op */ }
 
 void *
 rb_gc_impl_objspace_alloc(void)
@@ -9332,8 +9333,8 @@ rb_gc_impl_objspace_init(void *objspace_ptr)
         ccan_list_head_init(&heap->pages);
     }
 
-    rb_darray_make_without_gc(&objspace->heap_pages.sorted, 0);
-    rb_darray_make_without_gc(&objspace->weak_references, 0);
+    rb_darray_make(&objspace->heap_pages.sorted, 0);
+    rb_darray_make(&objspace->weak_references, 0);
 
     // TODO: debug why on Windows Ruby crashes on boot when GC is on.
 #ifdef _WIN32
@@ -9344,6 +9345,9 @@ rb_gc_impl_objspace_init(void *objspace_ptr)
     /* Need to determine if we can use mmap at runtime. */
     heap_page_alloc_use_mmap = INIT_HEAP_PAGE_ALLOC_USE_MMAP;
 #endif
+    objspace->next_object_id = OBJ_ID_INITIAL;
+    objspace->id_to_obj_tbl = st_init_table(&object_id_hash_type);
+    objspace->obj_to_id_tbl = st_init_numtable();
 #if RGENGC_ESTIMATE_OLDMALLOC
     objspace->rgengc.oldmalloc_increase_limit = gc_params.oldmalloc_limit_min;
 #endif
@@ -9365,7 +9369,6 @@ rb_gc_impl_init(void)
     VALUE gc_constants = rb_hash_new();
     rb_hash_aset(gc_constants, ID2SYM(rb_intern("DEBUG")), GC_DEBUG ? Qtrue : Qfalse);
     rb_hash_aset(gc_constants, ID2SYM(rb_intern("BASE_SLOT_SIZE")), SIZET2NUM(BASE_SLOT_SIZE - RVALUE_OVERHEAD));
-    rb_hash_aset(gc_constants, ID2SYM(rb_intern("RBASIC_SIZE")), SIZET2NUM(sizeof(struct RBasic)));
     rb_hash_aset(gc_constants, ID2SYM(rb_intern("RVALUE_OVERHEAD")), SIZET2NUM(RVALUE_OVERHEAD));
     rb_hash_aset(gc_constants, ID2SYM(rb_intern("HEAP_PAGE_OBJ_LIMIT")), SIZET2NUM(HEAP_PAGE_OBJ_LIMIT));
     rb_hash_aset(gc_constants, ID2SYM(rb_intern("HEAP_PAGE_BITMAP_SIZE")), SIZET2NUM(HEAP_PAGE_BITMAP_SIZE));
@@ -9395,11 +9398,6 @@ rb_gc_impl_init(void)
         rb_define_singleton_method(rb_mGC, "verify_compaction_references", rb_f_notimplement, -1);
     }
 
-    if (GC_DEBUG_STRESS_TO_CLASS) {
-        rb_define_singleton_method(rb_mGC, "add_stress_to_class", rb_gcdebug_add_stress_to_class, -1);
-        rb_define_singleton_method(rb_mGC, "remove_stress_to_class", rb_gcdebug_remove_stress_to_class, -1);
-    }
-
     /* internal methods */
     rb_define_singleton_method(rb_mGC, "verify_internal_consistency", gc_verify_internal_consistency_m, 0);