memory-profiler 1.4.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc8f56ebed50c8d591a542d81163ea09246a2661f4bd32124ea8d524f67ee940
-  data.tar.gz: 236d1bfdb3599fe908435f62a405ed6d0e21addc9cb1cac246b32e4513e55aac
+  metadata.gz: c1f0d854f80d796037192a81dfe2912291e0653510755e06d0a7e85e8b84a4ea
+  data.tar.gz: 11e5bbe54085baa3cc2c085c947b2ef9c74f3e85a44a59249ea2c5e41bc4a2bd
 SHA512:
-  metadata.gz: 42644bc37643d89de3e2fad38bc58fb374e5dbd213be7c1c47df4bfcf2f1ad6ffe579ae33933e69c44c8b844ff163b19511cbbade95aedd8767858deea8cb038
-  data.tar.gz: e18bffb078694246200f30b0d3199940e644eea56826dd86aef79787dfe79a96fddee09625f62c6fec88883c8ac3ae425fab38e838cded33ce98f7ae30903c70
+  metadata.gz: '05866071c2c1a20e868d8ca0c11f9951595bac35b86e051863ecde8c11e581d7c92780826c4816c087764f9cdc078859402e6d718e272f6a337dc59ab69d2b63'
+  data.tar.gz: e070faca1aa563faff377a56cb7287e1dbf369b65dc534c623425ad33c83e7d938925a25f470821e2134848ed2db7adce94408736e0fead52bba6cbc07ec5a9d

data/ext/extconf.rb

@@ -16,7 +16,7 @@ if ENV.key?("RUBY_DEBUG")
 	append_cflags(["-DRUBY_DEBUG", "-O0"])
 end
 
-$srcs = ["memory/profiler/profiler.c", "memory/profiler/capture.c", "memory/profiler/allocations.c", "memory/profiler/events.c"]
+$srcs = ["memory/profiler/profiler.c", "memory/profiler/capture.c", "memory/profiler/allocations.c", "memory/profiler/events.c", "memory/profiler/table.c"]
 $VPATH << "$(srcdir)/memory/profiler"
 
 # Check for required headers

data/ext/memory/profiler/capture.c

@@ -4,6 +4,7 @@
 #include "capture.h"
 #include "allocations.h"
 #include "events.h"
+#include "table.h"
 
 #include <ruby/debug.h>
 #include <ruby/st.h>
@@ -15,20 +16,10 @@ enum {
 };
 
 static VALUE Memory_Profiler_Capture = Qnil;
-static VALUE rb_mObjectSpace = Qnil;
-static ID id_id2ref = Qnil;
 
 // Event symbols:
 static VALUE sym_newobj, sym_freeobj;
 
-// State state stored in the central states table.
-// Maps object_id => state information.
-struct Memory_Profiler_Capture_State {
-	VALUE klass;  // The class of the allocated object
-	VALUE data;  // User-defined state from callback
-	VALUE allocations;  // The Allocations wrapper for this class
-};
-
 // Main capture state (per-instance).
 struct Memory_Profiler_Capture {
 	// Master switch - is tracking active? (set by start/stop).
@@ -40,10 +31,9 @@ struct Memory_Profiler_Capture {
 	// Tracked classes: class => VALUE (wrapped Memory_Profiler_Capture_Allocations).
 	st_table *tracked;
 	
-	// Central states table: object_id (Integer) => struct Memory_Profiler_Capture_State*
-	// This is the single source of truth for which objects are being tracked.
-	// FREEOBJ can have class=NULL, so we can't use per-class states tables.
-	st_table *states;
+	// Custom object table: object (address) => state hash
+	// Uses system malloc (GC-safe), updates addresses during compaction
+	struct Memory_Profiler_Object_Table *states;
 
 	// Total number of allocations and frees seen since tracking started.
 	size_t new_count;
@@ -65,20 +55,6 @@ static int Memory_Profiler_Capture_tracked_mark(st_data_t key, st_data_t value,
 	return ST_CONTINUE;
 }
 
-// GC mark callback for states table.
-static int Memory_Profiler_Capture_states_mark(st_data_t key, st_data_t value, st_data_t arg) {
-	// Key is object_id (Integer VALUE) - mark it as un-movable
-	rb_gc_mark((VALUE)key);
-	
-	// Value is struct Memory_Profiler_Capture_State* - mark its VALUEs
-	struct Memory_Profiler_Capture_State *state = (struct Memory_Profiler_Capture_State *)value;
-	rb_gc_mark(state->klass);  // Mark class as un-movable
-	rb_gc_mark_movable(state->data);  // State can move
-	rb_gc_mark_movable(state->allocations);  // Allocations wrapper can move
-	
-	return ST_CONTINUE;
-}
-
 static void Memory_Profiler_Capture_mark(void *ptr) {
 	struct Memory_Profiler_Capture *capture = ptr;
 	
@@ -86,16 +62,7 @@ static void Memory_Profiler_Capture_mark(void *ptr) {
 		st_foreach(capture->tracked, Memory_Profiler_Capture_tracked_mark, 0);
 	}
 	
-	if (capture->states) {
-		st_foreach(capture->states, Memory_Profiler_Capture_states_mark, 0);
-	}
-}
-
-// Helper to free state states in the states table
-static int Memory_Profiler_Capture_states_free_callback(st_data_t key, st_data_t value, st_data_t arg) {
-	struct Memory_Profiler_Capture_State *state = (struct Memory_Profiler_Capture_State *)value;
-	xfree(state);
-	return ST_CONTINUE;
+	Memory_Profiler_Object_Table_mark(capture->states);
 }
 
 static void Memory_Profiler_Capture_free(void *ptr) {
@@ -106,9 +73,7 @@ static void Memory_Profiler_Capture_free(void *ptr) {
 	}
 	
 	if (capture->states) {
-		// Free all states first
-		st_foreach(capture->states, Memory_Profiler_Capture_states_free_callback, 0);
-		st_free_table(capture->states);
+		Memory_Profiler_Object_Table_free(capture->states);
 	}
 	
 	xfree(capture);
@@ -142,31 +107,6 @@ static int Memory_Profiler_Capture_tracked_update(st_data_t *key, st_data_t *val
 	return ST_CONTINUE;
 }
 
-// Foreach callback for states table compaction (iteration logic).
-static int Memory_Profiler_Capture_states_foreach(st_data_t key, st_data_t value, st_data_t argp, int error) {
-	return ST_REPLACE;
-}
-
-// Replace callback for states table compaction (update logic).
-static int Memory_Profiler_Capture_states_update(st_data_t *key, st_data_t *value, st_data_t argp, int existing) {
-	// Update VALUEs in the state if they moved
-	struct Memory_Profiler_Capture_State *state = (struct Memory_Profiler_Capture_State *)*value;
-	
-	VALUE old_state = state->data;
-	VALUE new_state = rb_gc_location(old_state);
-	if (old_state != new_state) {
-		state->data = new_state;
-	}
-	
-	VALUE old_allocations = state->allocations;
-	VALUE new_allocations = rb_gc_location(old_allocations);
-	if (old_allocations != new_allocations) {
-		state->allocations = new_allocations;
-	}
-	
-	return ST_CONTINUE;
-}
-
 static void Memory_Profiler_Capture_compact(void *ptr) {
 	struct Memory_Profiler_Capture *capture = ptr;
 	
@@ -177,11 +117,9 @@ static void Memory_Profiler_Capture_compact(void *ptr) {
 		}
 	}
 	
-	// Update states table state VALUEs in-place:
-	if (capture->states && capture->states->num_entries > 0) {
-		if (st_foreach_with_replace(capture->states, Memory_Profiler_Capture_states_foreach, Memory_Profiler_Capture_states_update, 0)) {
-			rb_raise(rb_eRuntimeError, "states modified during GC compaction");
-		}
+	// Update custom object table (system malloc, safe during GC)
+	if (capture->states) {
+		Memory_Profiler_Object_Table_compact(capture->states);
 	}
 }
 
@@ -216,7 +154,9 @@ const char *event_flag_name(rb_event_flag_t event_flag) {
 
 // Process a NEWOBJ event. All allocation tracking logic is here.
 // object_id parameter is the Integer object_id, NOT the raw object.
-static void Memory_Profiler_Capture_process_newobj(VALUE self, VALUE klass, VALUE object_id) {
+// Process a NEWOBJ event. All allocation tracking logic is here.
+// object parameter is the actual object being allocated.
+static void Memory_Profiler_Capture_process_newobj(VALUE self, VALUE klass, VALUE object) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
@@ -249,52 +189,55 @@ static void Memory_Profiler_Capture_process_newobj(VALUE self, VALUE klass, VALU
 		RB_OBJ_WRITTEN(self, Qnil, allocations);
 	}
 	
-	// Get state from callback (if present)
 	VALUE data = Qnil;
 	if (!NIL_P(record->callback)) {
 		data = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
 	}
 	
-	// Create and store state state in central states table
-	struct Memory_Profiler_Capture_State *state = ALLOC(struct Memory_Profiler_Capture_State);
-	state->klass = klass;
-	state->data = data;
-	state->allocations = allocations;
-	
-	st_insert(capture->states, (st_data_t)object_id, (st_data_t)state);
+	struct Memory_Profiler_Object_Table_Entry *entry = Memory_Profiler_Object_Table_insert(capture->states, object);
+	RB_OBJ_WRITTEN(self, Qnil, object);
+	RB_OBJ_WRITE(self, &entry->klass, klass);
+	RB_OBJ_WRITE(self, &entry->data, data);
 	
-	// Write barriers for VALUEs we're storing
-	RB_OBJ_WRITTEN(self, Qnil, klass);
-	RB_OBJ_WRITTEN(self, Qnil, data);
-	RB_OBJ_WRITTEN(self, Qnil, allocations);
+	if (DEBUG) fprintf(stderr, "[NEWOBJ] Object inserted into table: %p\n", (void*)object);
 	
 	// Resume the capture:
 	capture->paused -= 1;
 }
 
 // Process a FREEOBJ event. All deallocation tracking logic is here.
-// object_id parameter is the Integer object_id, NOT the raw object.
-// NOTE: klass parameter can be NULL for FREEOBJ events, so we don't use it!
-static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE klass, VALUE object_id) {
+// freeobj_data parameter is [state_hash, object] array from event handler.
+static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE unused_klass, VALUE object) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(capture_value, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
 	// Pause the capture to prevent infinite loop:
 	capture->paused += 1;
 	
-	// Look up the object_id in the central states table
-	// We use object_id because klass can be NULL in FREEOBJ events!
-	st_data_t state_data;
-	if (!st_delete(capture->states, (st_data_t *)&object_id, &state_data)) {
-		// This object_id is not in our states table, so we're not tracking it
+	struct Memory_Profiler_Object_Table_Entry *entry = Memory_Profiler_Object_Table_lookup(capture->states, object);
+	
+	if (!entry) {
+		if (DEBUG) fprintf(stderr, "[FREEOBJ] Object not found in table: %p\n", (void*)object);
+		goto done;
+	} else {
+		if (DEBUG) fprintf(stderr, "[FREEOBJ] Object found in table: %p\n", (void*)object);
+	}
+	
+	VALUE klass = entry->klass;
+	VALUE data = entry->data;
+	
+	// Look up allocations from tracked table:
+	st_data_t allocations_data;
+	if (!st_lookup(capture->tracked, (st_data_t)klass, &allocations_data)) {
+		// Class not tracked - shouldn't happen, but be defensive:
+		if (DEBUG) fprintf(stderr, "[FREEOBJ] Class not found in tracked: %p\n", (void*)klass);
 		goto done;
 	}
+	VALUE allocations = (VALUE)allocations_data;
+	
+	// Delete by entry pointer (faster - no second lookup!)
+	Memory_Profiler_Object_Table_delete_entry(capture->states, entry);
 	
-	// Extract information from the state
-	struct Memory_Profiler_Capture_State *state = (struct Memory_Profiler_Capture_State *)state_data;
-	klass = state->klass;  // Use class from state, not parameter
-	VALUE data = state->data;
-	VALUE allocations = state->allocations;
 	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
 	
 	// Increment global free count
@@ -307,10 +250,7 @@ static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE k
 	if (!NIL_P(record->callback) && !NIL_P(data)) {
 		rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_freeobj, data);
 	}
-	
-	// Free the state struct
-	xfree(state);
-	
+
 done:
 	// Resume the capture:
 	capture->paused -= 1;
@@ -387,22 +327,17 @@ static void Memory_Profiler_Capture_event_callback(VALUE self, void *ptr) {
 		if (capture->paused) return;
 		
 		VALUE klass = rb_obj_class(object);
-		if (!klass) return;
-				
-		// Convert to object_id for storage (Integer VALUE).
-		// It's safe to unconditionally call rb_obj_id during NEWOBJ.
-		VALUE object_id = rb_obj_id(object);
 		
-		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_NEWOBJ, self, klass, object_id);
+		// Skip if klass is not a Class
+		if (rb_type(klass) != RUBY_T_CLASS) return;
+		
+		// Enqueue actual object (not object_id) - queue retains it until processed
+		// Ruby 3.5 compatible: no need for FL_SEEN_OBJ_ID or rb_obj_id
+		if (DEBUG) fprintf(stderr, "[NEWOBJ] Enqueuing event for object: %p\n", (void*)object);
+		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_NEWOBJ, self, klass, object);
 	} else if (event_flag == RUBY_INTERNAL_EVENT_FREEOBJ) {
-		// We only care about objects that have been seen before (i.e. have an object ID):
-		if (RB_FL_TEST(object, FL_SEEN_OBJ_ID)) {
-			// Convert to object_id for storage (Integer VALUE).
-			// It's only safe to call rb_obj_id if the object already has an object ID.
-			VALUE object_id = rb_obj_id(object);
-			
-			Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_FREEOBJ, self, Qnil, object_id);
-		}
+		if (DEBUG) fprintf(stderr, "[FREEOBJ] Enqueuing event for object: %p\n", (void*)object);
+		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_FREEOBJ, self, Qnil, object);
 	}
 }
 
@@ -421,11 +356,11 @@ static VALUE Memory_Profiler_Capture_alloc(VALUE klass) {
 		rb_raise(rb_eRuntimeError, "Failed to initialize tracked hash table");
 	}
 	
-	// Initialize central states table (object_id => State_Tuple)
-	capture->states = st_init_numtable();
-	
+	// Initialize custom object table (uses system malloc, GC-safe)
+	capture->states = Memory_Profiler_Object_Table_new(1024);
 	if (!capture->states) {
-		rb_raise(rb_eRuntimeError, "Failed to initialize states hash table");
+		st_free_table(capture->tracked);
+		rb_raise(rb_eRuntimeError, "Failed to initialize object table");
 	}
 	
 	// Initialize allocation tracking counters
@@ -590,13 +525,13 @@ static VALUE Memory_Profiler_Capture_clear(VALUE self) {
 		rb_raise(rb_eRuntimeError, "Cannot clear while capture is running - call stop() first!");
 	}
 	
-	// Reset all counts to 0 (don't free, just reset) - pass self for write barriers:
+	// Reset all counts to 0 (don't free, just reset):
 	st_foreach(capture->tracked, Memory_Profiler_Capture_tracked_clear, 0);
 	
-	// Clear central states table - free all states and clear the table
+	// Clear custom object table by recreating it
 	if (capture->states) {
-		st_foreach(capture->states, Memory_Profiler_Capture_states_free_callback, 0);
-		st_clear(capture->states);
+		Memory_Profiler_Object_Table_free(capture->states);
+		capture->states = Memory_Profiler_Object_Table_new(1024);
 	}
 	
 	// Reset allocation tracking counters
@@ -629,35 +564,72 @@ static VALUE Memory_Profiler_Capture_each(VALUE self) {
 	return self;
 }
 
-// Struct for filtering states by allocations wrapper during iteration
-struct Memory_Profiler_Each_Object_Args {
-	VALUE allocations;  // The allocations wrapper to filter by (Qnil = no filter)
+// Struct for filtering states during each_object iteration
+struct Memory_Profiler_Each_Object_Arguments {
+	VALUE self;
+	
+	// The allocations wrapper to filter by (Qnil = no filter).
+	VALUE allocations;
 };
 
-// Iterator callback for each_object - yields object and state
-static int Memory_Profiler_Capture_each_object_callback(st_data_t key, st_data_t value, st_data_t arg) {
-	VALUE object_id = (VALUE)key;
-	struct Memory_Profiler_Capture_State *state = (struct Memory_Profiler_Capture_State *)value;
-	struct Memory_Profiler_Each_Object_Args *args = (struct Memory_Profiler_Each_Object_Args *)arg;
+// Cleanup function to ensure table is made weak again
+static VALUE Memory_Profiler_Capture_each_object_ensure(VALUE arg) {
+	struct Memory_Profiler_Each_Object_Arguments *arguments = (struct Memory_Profiler_Each_Object_Arguments *)arg;
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(arguments->self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	// Filter by allocations if specified
-	if (!NIL_P(args->allocations) && state->allocations != args->allocations) {
-		return ST_CONTINUE;
-	}
+	// Make table weak again
+	Memory_Profiler_Object_Table_decrement_strong(capture->states);
 	
-	// Convert object_id to object using _id2ref
-	VALUE object = rb_funcall(rb_mObjectSpace, id_id2ref, 1, object_id);
+	return Qnil;
+}
+
+// Main iteration function
+static VALUE Memory_Profiler_Capture_each_object_body(VALUE arg) {
+	struct Memory_Profiler_Each_Object_Arguments *arguments = (struct Memory_Profiler_Each_Object_Arguments *)arg;
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(arguments->self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	// Yield object and state
-	rb_yield_values(2, object, state->data);
+	// Iterate custom object table entries
+	if (capture->states) {
+		if (DEBUG) fprintf(stderr, "[ITER] Iterating table, capacity=%zu, count=%zu\n", capture->states->capacity, capture->states->count);
+		
+		for (size_t i = 0; i < capture->states->capacity; i++) {
+			struct Memory_Profiler_Object_Table_Entry *entry = &capture->states->entries[i];
+			
+			// Skip empty or deleted slots (0 = not set)
+			if (entry->object == 0) {
+				continue;
+			}
+			
+			// Look up allocations from klass
+			st_data_t allocations_data;
+			VALUE allocations = Qnil;
+			if (st_lookup(capture->tracked, (st_data_t)entry->klass, &allocations_data)) {
+				allocations = (VALUE)allocations_data;
+			}
+			
+			// Filter by allocations if specified
+			if (!NIL_P(arguments->allocations)) {
+				if (allocations != arguments->allocations) continue;
+			}
+			
+			rb_yield_values(2, entry->object, allocations);
+		}
+	}
 	
-	return ST_CONTINUE;
+	return arguments->self;
 }
 
-// Iterate over tracked objects, optionally filtered by class
+// Iterate over tracked object IDs, optionally filtered by class
 // Called as: 
-//   capture.each_object(String) { |object, state| ... }  # Specific class
-//   capture.each_object { |object, state| ... }          # All objects
+//   capture.each_object(String) { |object_id, state| ... }  # Specific class
+//   capture.each_object { |object_id, state| ... }          // All objects
+// 
+// Yields object_id as Integer. Caller can:
+//   - Format as hex: "0x%x" % object_id
+//   - Convert to object with ObjectSpace._id2ref (may raise RangeError if recycled)
+// Future-proof for Ruby 3.5 where _id2ref is deprecated
 static VALUE Memory_Profiler_Capture_each_object(int argc, VALUE *argv, VALUE self) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
@@ -667,10 +639,10 @@ static VALUE Memory_Profiler_Capture_each_object(int argc, VALUE *argv, VALUE se
 	
 	RETURN_ENUMERATOR(self, argc, argv);
 	
-	// Process all pending events and run GC to clean up stale object_ids
-	Memory_Profiler_Events_process_all();
-	rb_gc_start();
-	VALUE was_enabled = rb_gc_disable();
+	// Make table strong so objects won't be collected during iteration
+	Memory_Profiler_Object_Table_increment_strong(capture->states);
+	
+	// Process all pending events and run GC to clean up stale objects:
 	Memory_Profiler_Events_process_all();
 	
 	// If class provided, look up its allocations wrapper
@@ -681,25 +653,22 @@ static VALUE Memory_Profiler_Capture_each_object(int argc, VALUE *argv, VALUE se
 			allocations = (VALUE)allocations_data;
 		} else {
 			// Class not tracked - nothing to iterate
-			if (RTEST(was_enabled)) {
-				rb_gc_enable();
-			}
+			Memory_Profiler_Object_Table_decrement_strong(capture->states);
 			return self;
 		}
 	}
 	
-	// Iterate states table, optionally filtering by allocations wrapper
-	struct Memory_Profiler_Each_Object_Args args = { .allocations = allocations };
-	
-	if (capture->states) {
-		st_foreach(capture->states, Memory_Profiler_Capture_each_object_callback, (st_data_t)&args);
-	}
-	
-	if (RTEST(was_enabled)) {
-		rb_gc_enable();
-	}
+	// Setup arguments for iteration
+	struct Memory_Profiler_Each_Object_Arguments arguments = {
+		.self = self,
+		.allocations = allocations
+	};
 	
-	return self;
+	// Use rb_ensure to guarantee cleanup even if exception is raised
+	return rb_ensure(
+		Memory_Profiler_Capture_each_object_body, (VALUE)&arguments,
+		Memory_Profiler_Capture_each_object_ensure, (VALUE)&arguments
+	);
 }
 
 // Get allocations for a specific class
@@ -721,23 +690,6 @@ struct Memory_Profiler_Allocations_Statistics {
 	VALUE per_class_counts;
 };
 
-// Iterator callback to count states per class (from central states table)
-static int Memory_Profiler_Capture_count_states(st_data_t key, st_data_t value, st_data_t argument) {
-	struct Memory_Profiler_Allocations_Statistics *statistics = (struct Memory_Profiler_Allocations_Statistics *)argument;
-	struct Memory_Profiler_Capture_State *state = (struct Memory_Profiler_Capture_State *)value;
-	VALUE klass = state->klass;
-	
-	// Increment total count
-	statistics->total_tracked_objects++;
-	
-	// Increment per-class count
-	VALUE current_count = rb_hash_lookup(statistics->per_class_counts, klass);
-	size_t count = NIL_P(current_count) ? 1 : NUM2SIZET(current_count) + 1;
-	rb_hash_aset(statistics->per_class_counts, klass, SIZET2NUM(count));
-	
-	return ST_CONTINUE;
-}
-
 // Get internal statistics for debugging
 // Returns hash with internal state sizes
 static VALUE Memory_Profiler_Capture_statistics(VALUE self) {
@@ -749,22 +701,9 @@ static VALUE Memory_Profiler_Capture_statistics(VALUE self) {
 	// Tracked classes count
 	rb_hash_aset(statistics, ID2SYM(rb_intern("tracked_count")), SIZET2NUM(capture->tracked->num_entries));
 	
-	// Total states table size
-	size_t states_table_size = capture->states ? capture->states->num_entries : 0;
-	rb_hash_aset(statistics, ID2SYM(rb_intern("states_table_size")), SIZET2NUM(states_table_size));
-		
-	// Count states entries for each class (iterate central states table)
-	struct Memory_Profiler_Allocations_Statistics allocations_statistics = {
-		.total_tracked_objects = 0,
-		.per_class_counts = rb_hash_new()
-	};
-	
-	if (capture->states) {
-		st_foreach(capture->states, Memory_Profiler_Capture_count_states, (st_data_t)&allocations_statistics);
-	}
-	
-	rb_hash_aset(statistics, ID2SYM(rb_intern("total_tracked_objects")), SIZET2NUM(allocations_statistics.total_tracked_objects));
-	rb_hash_aset(statistics, ID2SYM(rb_intern("tracked_objects_per_class")), allocations_statistics.per_class_counts);
+	// Custom object table size
+	size_t states_size = capture->states ? Memory_Profiler_Object_Table_size(capture->states) : 0;
+	rb_hash_aset(statistics, ID2SYM(rb_intern("object_table_size")), SIZET2NUM(states_size));
 	
 	return statistics;
 }
@@ -822,11 +761,6 @@ void Init_Memory_Profiler_Capture(VALUE Memory_Profiler)
 	rb_define_method(Memory_Profiler_Capture, "free_count", Memory_Profiler_Capture_free_count, 0);
 	rb_define_method(Memory_Profiler_Capture, "retained_count", Memory_Profiler_Capture_retained_count, 0);
 	
-	// Cache ObjectSpace module for _id2ref calls
-	rb_mObjectSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
-	rb_gc_register_mark_object(rb_mObjectSpace);
-	id_id2ref = rb_intern("_id2ref");
-	
 	// Initialize Allocations class
 	Init_Memory_Profiler_Allocations(Memory_Profiler);
 }

data/ext/memory/profiler/events.c

@@ -104,7 +104,10 @@ static void Memory_Profiler_Events_mark_queue(struct Memory_Profiler_Queue *queu
 		
 		rb_gc_mark_movable(event->capture);
 		rb_gc_mark_movable(event->klass);
-		rb_gc_mark_movable(event->object);
+		
+		if (event->type == MEMORY_PROFILER_EVENT_TYPE_NEWOBJ) {
+			rb_gc_mark_movable(event->object);
+		}
 	}
 }
 
@@ -129,7 +132,10 @@ static void Memory_Profiler_Events_compact_queue(struct Memory_Profiler_Queue *q
 		
 		event->capture = rb_gc_location(event->capture);
 		event->klass = rb_gc_location(event->klass);
-		event->object = rb_gc_location(event->object);
+
+		if (event->type == MEMORY_PROFILER_EVENT_TYPE_NEWOBJ) {
+			event->object = rb_gc_location(event->object);
+		}
 	}
 }
 
@@ -175,7 +181,7 @@ int Memory_Profiler_Events_enqueue(
 	enum Memory_Profiler_Event_Type type,
 	VALUE capture,
 	VALUE klass,
-	VALUE object_id
+	VALUE object
 ) {
 	struct Memory_Profiler_Events *events = Memory_Profiler_Events_instance();
 	
@@ -187,7 +193,7 @@ int Memory_Profiler_Events_enqueue(
 		// Use write barriers when storing VALUEs (required for RUBY_TYPED_WB_PROTECTED):
 		RB_OBJ_WRITE(events->self, &event->capture, capture);
 		RB_OBJ_WRITE(events->self, &event->klass, klass);
-		RB_OBJ_WRITE(events->self, &event->object, object_id);
+		RB_OBJ_WRITE(events->self, &event->object, object);
 		
 		if (DEBUG) fprintf(stderr, "Queued %s to available queue, size: %zu\n", 
 			Memory_Profiler_Event_Type_name(type), events->available->count);

data/ext/memory/profiler/events.h

@@ -20,11 +20,10 @@ struct Memory_Profiler_Event {
 	// Which Capture instance this event belongs to:
 	VALUE capture;
 	
-	// The class of the object:
+	// The class of the allocated object (Qnil for FREEOBJ):
 	VALUE klass;
 
-	// The object_id (Integer VALUE) - NOT the raw object.
-	// We store object_id to avoid referencing objects that should be freed.
+	// The object pointer being alllocated or freed.
 	VALUE object;
 };
 
@@ -33,13 +32,16 @@ struct Memory_Profiler_Events;
 struct Memory_Profiler_Events* Memory_Profiler_Events_instance(void);
 
 // Enqueue an event to the global queue.
-// object parameter should be the object_id (Integer), not the raw object.
+// object parameter semantics:
+//   - NEWOBJ: the actual object being allocated (queue retains it)
+//   - FREEOBJ: Array with state data for postponed processing
 // Returns non-zero on success, zero on failure.
+// Ruby 3.5 compatible: no FL_SEEN_OBJ_ID or object_id needed
 int Memory_Profiler_Events_enqueue(
 	enum Memory_Profiler_Event_Type type,
 	VALUE capture,
 	VALUE klass,
-	VALUE object_id
+	VALUE object
 );
 
 // Process all queued events immediately (flush the queue)

data/ext/memory/profiler/profiler.c

@@ -3,15 +3,26 @@
 
 #include "capture.h"
 
+// Return the memory address of an object as a hex string
+// This matches the format used by ObjectSpace.dump_all
+static VALUE Memory_Profiler_address_of(VALUE module, VALUE object) {
+	char buffer[32];
+	snprintf(buffer, sizeof(buffer), "0x%lx", (unsigned long)object);
+	return rb_str_new_cstr(buffer);
+}
+
 void Init_Memory_Profiler(void)
 {
 #ifdef HAVE_RB_EXT_RACTOR_SAFE
-    rb_ext_ractor_safe(true);
+	rb_ext_ractor_safe(true);
 #endif
-    
-    VALUE Memory = rb_const_get(rb_cObject, rb_intern("Memory"));
-    VALUE Memory_Profiler = rb_define_module_under(Memory, "Profiler");
-    
-    Init_Memory_Profiler_Capture(Memory_Profiler);
+	
+	VALUE Memory = rb_const_get(rb_cObject, rb_intern("Memory"));
+	VALUE Memory_Profiler = rb_define_module_under(Memory, "Profiler");
+	
+	// Add Memory::Profiler.address_of(object) module function:
+	rb_define_module_function(Memory_Profiler, "address_of", Memory_Profiler_address_of, 1);
+	
+	Init_Memory_Profiler_Capture(Memory_Profiler);
 }