memory-profiler 1.1.9 → 1.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85589b15e3229992f9afefb5333efebaa07d7e25da717a46b3db5846e14af63d
-  data.tar.gz: 82986a841e9964aed258e1d7d94f2af7719f350f517423ca49ffb496237e497c
+  metadata.gz: '05249db4d71f31bfdaa1e8eb0814d7c44688aa9b576a6df40e48bb2b0505c802'
+  data.tar.gz: 3c39173cf151e64ca8ae17790dc4453f337091f973ba25e5db54f2917e0b3bf1
 SHA512:
-  metadata.gz: ed056829d3a27ca9b2cc681107a7254e798338c77bbe539f91332d915be126665a19550c5533db8fe751531f12c66963cdfe692232d3f5d3a5f409dd66e31cab
-  data.tar.gz: cd44bca86e0db7a75413492a694dad3d202359f6cbe2d386ff71dd08d74adcc13557181565694679d3da1978c58664beff442b54e3a4b2512ef83d16cf96fce8
+  metadata.gz: a6aa1342bd86d5dd8dfcdb80497bb50c07937182a60dfb9d296d84e88fbd72f0ebdc4dd6c82fb396a4067b2adc129572f556d8545328a4dd04516bd0ffedf613
+  data.tar.gz: 819cb8882b506f4341faa8095469279ec0d053c67392fa1d7d0e6a689b80bf037f196743280e91e4fb70987ea89cfcd492f3f0f39a8a9fcb6bafa7de3c4e4cb1

data/ext/memory/profiler/allocations.c

@@ -10,39 +10,33 @@
 
 static VALUE Memory_Profiler_Allocations = Qnil;
 
-// Helper to mark object_states table values
-static int Memory_Profiler_Allocations_object_states_mark(st_data_t key, st_data_t value, st_data_t arg) {
-	// Don't mark the object, we use it as a key but we never use it as an object, and we don't want to retain it.
-	// VALUE object = (VALUE)key;
-	// rb_gc_mark_movable(object);
-
+// Helper to mark states table (object => state)
+static int Memory_Profiler_Allocations_states_mark(st_data_t key, st_data_t value, st_data_t arg) {
+	// Don't mark the object key (weak reference - don't keep objects alive)
+	// Mark the state value
 	VALUE state = (VALUE)value;
-	if (!NIL_P(state)) {
-		rb_gc_mark_movable(state);
-	}
+	rb_gc_mark_movable(state);
 	return ST_CONTINUE;
 }
 
 // Foreach callback for st_foreach_with_replace (iteration logic)
-static int Memory_Profiler_Allocations_object_states_foreach(st_data_t key, st_data_t value, st_data_t argp, int error) {
+static int Memory_Profiler_Allocations_states_foreach(st_data_t key, st_data_t value, st_data_t argp, int error) {
 	// Return ST_REPLACE to trigger the replace callback for each entry
 	return ST_REPLACE;
 }
 
-// Replace callback for st_foreach_with_replace to update object_states keys and values during compaction
-static int Memory_Profiler_Allocations_object_states_compact(st_data_t *key, st_data_t *value, st_data_t data, int existing) {
-	VALUE old_object = (VALUE)*key;
+// Replace callback for st_foreach_with_replace to update states during compaction
+static int Memory_Profiler_Allocations_states_compact(st_data_t *key, st_data_t *value, st_data_t data, int existing) {
+	// Key is object (VALUE) - we can't update if it moved (would require rehashing/allocation)
 	VALUE old_state = (VALUE)*value;
-	
-	VALUE new_object = rb_gc_location(old_object);
 	VALUE new_state = rb_gc_location(old_state);
 	
-	// Update key if it moved
-	if (old_object != new_object) {
-		*key = (st_data_t)new_object;
-	}
+	// NOTE: We can't update object keys if they moved (would require rehashing/allocation).
+	// This means lookups may fail after compaction for moved objects.
+	// This is acceptable - FREEOBJ will simply not find the state and skip the callback.
+	// The state will be cleaned up when Allocations is freed/cleared.
 	
-	// Update value if it moved
+	// Update state value if it moved (this is safe, doesn't rehash)
 	if (old_state != new_state) {
 		*value = (st_data_t)new_state;
 	}
@@ -50,7 +44,6 @@ static int Memory_Profiler_Allocations_object_states_compact(st_data_t *key, st_
 	return ST_CONTINUE;
 }
 
-// GC mark function for Allocations
 static void Memory_Profiler_Allocations_mark(void *ptr) {
 	struct Memory_Profiler_Capture_Allocations *record = ptr;
 	
@@ -58,22 +51,19 @@ static void Memory_Profiler_Allocations_mark(void *ptr) {
 		return;
 	}
 	
-	if (!NIL_P(record->callback)) {
-		rb_gc_mark_movable(record->callback);
-	}
+	rb_gc_mark_movable(record->callback);
 	
-	// Mark object_states table if it exists
-	if (record->object_states) {
-		st_foreach(record->object_states, Memory_Profiler_Allocations_object_states_mark, 0);
+	// Mark states table if it exists
+	if (record->states) {
+		st_foreach(record->states, Memory_Profiler_Allocations_states_mark, 0);
 	}
 }
 
-// GC free function for Allocations
 static void Memory_Profiler_Allocations_free(void *ptr) {
 	struct Memory_Profiler_Capture_Allocations *record = ptr;
 	
-	if (record->object_states) {
-		st_free_table(record->object_states);
+	if (record->states) {
+		st_free_table(record->states);
 	}
 	
 	xfree(record);
@@ -84,14 +74,12 @@ static void Memory_Profiler_Allocations_compact(void *ptr) {
 	struct Memory_Profiler_Capture_Allocations *record = ptr;
 	
 	// Update callback if it moved
-	if (!NIL_P(record->callback)) {
-		record->callback = rb_gc_location(record->callback);
-	}
+	record->callback = rb_gc_location(record->callback);
 	
-	// Update object_states table if it exists
-	if (record->object_states && record->object_states->num_entries > 0) {
-		if (st_foreach_with_replace(record->object_states, Memory_Profiler_Allocations_object_states_foreach, Memory_Profiler_Allocations_object_states_compact, 0)) {
-			rb_raise(rb_eRuntimeError, "object_states modified during GC compaction");
+	// Update states table if it exists
+	if (record->states && record->states->num_entries > 0) {
+		if (st_foreach_with_replace(record->states, Memory_Profiler_Allocations_states_foreach, Memory_Profiler_Allocations_states_compact, 0)) {
+			rb_raise(rb_eRuntimeError, "states modified during GC compaction");
 		}
 	}
 }
@@ -158,10 +146,11 @@ void Memory_Profiler_Allocations_clear(VALUE allocations) {
 	record->free_count = 0;  // Reset free count
 	RB_OBJ_WRITE(allocations, &record->callback, Qnil); // Clear callback with write barrier
 	
-	// Clear object states
-	if (record->object_states) {
-		st_free_table(record->object_states);
-		record->object_states = NULL;
+	// Clear states - either clear the table or reinitialize
+	if (record->states) {
+		st_clear(record->states);
+	} else {
+		record->states = st_init_numtable();
 	}
 }
 

data/ext/memory/profiler/allocations.h

@@ -17,9 +17,9 @@ struct Memory_Profiler_Capture_Allocations {
 	size_t free_count;
 	// Live count = new_count - free_count.
 	
-	// For detailed tracking: map object (VALUE) => state (VALUE).
-	// State is returned from callback on `newobj` and passed back on `freeobj`.
-	st_table *object_states;
+	// Map object (VALUE) => state (VALUE).
+	// Object keys need compaction updates when they move.
+	st_table *states;
 };
 
 // Wrap an allocations record in a VALUE.

data/ext/memory/profiler/capture.c

@@ -13,7 +13,6 @@
 
 enum {
 	DEBUG = 0,
-	DEBUG_STATE = 0,
 };
 
 static VALUE Memory_Profiler_Capture = Qnil;
@@ -23,19 +22,25 @@ static VALUE sym_newobj, sym_freeobj;
 
 // Main capture state (per-instance).
 struct Memory_Profiler_Capture {
-	// Tracked classes: class => VALUE (wrapped Memory_Profiler_Capture_Allocations).
-	st_table *tracked_classes;
-
 	// Master switch - is tracking active? (set by start/stop).
 	int running;
 	
 	// Should we queue callbacks? (temporarily disabled during queue processing).
 	int enabled;
+
+	// Tracked classes: class => VALUE (wrapped Memory_Profiler_Capture_Allocations).
+	st_table *tracked_classes;
+
+	// Total number of allocations and frees seen since tracking started.
+	size_t new_count;
+	size_t free_count;
 };
 
 // GC mark callback for tracked_classes table.
 static int Memory_Profiler_Capture_tracked_classes_mark(st_data_t key, st_data_t value, st_data_t arg) {
 	// Mark class as un-movable:
+	// - We don't want to re-index the table if the class moves.
+	// - We don't want objects in `freeobj` to have invalid class pointers (maybe helps).
 	VALUE klass = (VALUE)key;
 	rb_gc_mark(klass);
 	
@@ -82,13 +87,6 @@ static int Memory_Profiler_Capture_tracked_classes_foreach(st_data_t key, st_dat
 
 // Replace callback for st_foreach_with_replace (update logic).
 static int Memory_Profiler_Capture_tracked_classes_update(st_data_t *key, st_data_t *value, st_data_t argp, int existing) {
-	// Update class key if it moved:
-	VALUE old_klass = (VALUE)*key;
-	VALUE new_klass = rb_gc_location(old_klass);
-	if (old_klass != new_klass) {
-		*key = (st_data_t)new_klass;
-	}
-	
 	// Update wrapped Allocations VALUE if it moved:
 	VALUE old_allocations = (VALUE)*value;
 	VALUE new_allocations = rb_gc_location(old_allocations);
@@ -139,70 +137,98 @@ const char *event_flag_name(rb_event_flag_t event_flag) {
 	}
 }
 
-// Process a NEWOBJ event. Handles both callback and non-callback cases, stores appropriate state.
-static void Memory_Profiler_Capture_process_newobj(VALUE capture_value, VALUE klass, VALUE allocations, VALUE object) {
+// Process a NEWOBJ event. All allocation tracking logic is here.
+static void Memory_Profiler_Capture_process_newobj(VALUE capture_value, VALUE klass, VALUE object) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(capture_value, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
+	// Increment global new count:
+	capture->new_count++;
 	
-	// Ensure object_states table exists:
-	if (!record->object_states) {
-		record->object_states = st_init_numtable();
-	}
+	// Look up or create allocations record for this class:
+	st_data_t allocations_data;
+	VALUE allocations;
+	struct Memory_Profiler_Capture_Allocations *record;
 	
-	VALUE state;
+	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
+		// Existing record
+		allocations = (VALUE)allocations_data;
+		record = Memory_Profiler_Allocations_get(allocations);
+		record->new_count++;
+	} else {
+		// First time seeing this class, create record automatically
+		record = ALLOC(struct Memory_Profiler_Capture_Allocations);
+		record->callback = Qnil;
+		record->new_count = 1;
+		record->free_count = 0;
+		record->states = st_init_numtable();
+		
+		allocations = Memory_Profiler_Allocations_wrap(record);
+		st_insert(capture->tracked_classes, (st_data_t)klass, (st_data_t)allocations);
+		RB_OBJ_WRITTEN(capture_value, Qnil, klass);
+		RB_OBJ_WRITTEN(capture_value, Qnil, allocations);
+	}
 	
+	// Only store state if there's a callback
 	if (!NIL_P(record->callback)) {
-		// Temporarily disable queueing to prevent infinite loop:
+		// Temporarily disable queueing to prevent infinite loop
 		int was_enabled = capture->enabled;
 		capture->enabled = 0;
 		
-		state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
+		VALUE state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
 		
 		capture->enabled = was_enabled;
 		
-		if (DEBUG_STATE) fprintf(stderr, "Storing callback state for object: %p\n", (void *)object);
+		// Store state using object as key (works because object is alive):
+		st_insert(record->states, (st_data_t)object, (st_data_t)state);
 	} else {
-		// No callback, store sentinel (Qnil):
-		state = Qnil;
-		
-		if (DEBUG_STATE) fprintf(stderr, "Storing sentinel (Qnil) for object: %p\n", (void *)object);
+		// Store state as nil:
+		st_insert(record->states, (st_data_t)object, (st_data_t)Qnil);
 	}
-	
-	// Always store something to maintain NEWOBJ/FREEOBJ symmetry:
-	st_insert(record->object_states, (st_data_t)object, (st_data_t)state);
 }
 
-// Process a FREEOBJ event. Looks up and deletes state, optionally calls callback.
-static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE klass, VALUE allocations, VALUE object) {
+// Process a FREEOBJ event. All deallocation tracking logic is here.
+static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE klass, VALUE object) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(capture_value, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
+	// Look up allocations record for this class
+	st_data_t allocations_data;
+	if (!st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
+		// The class is not tracked, so we are not tracking this object.
+		return;
+	}
+	
+	VALUE allocations = (VALUE)allocations_data;
 	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
 	
-	// Try to look up and delete state:
-	if (record->object_states) {
-		st_data_t state_data;
-		if (st_delete(record->object_states, (st_data_t *)&object, &state_data)) {
-			VALUE state = (VALUE)state_data;
-			
-			if (DEBUG_STATE) fprintf(stderr, "Freed tracked object: %p, state=%s\n", 
-				(void *)object, NIL_P(state) ? "Qnil (sentinel)" : "real state");
-			
-			// Only call callback if we have both callback AND real state (not Qnil sentinel):
-			if (!NIL_P(record->callback) && !NIL_P(state)) {
-				// Temporarily disable queueing to prevent infinite loop:
-				int was_enabled = capture->enabled;
-				capture->enabled = 0;
-				
-				rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_freeobj, state);
-				
-				capture->enabled = was_enabled;
-			}
-		} else {
-			if (DEBUG_STATE) fprintf(stderr, "Freed pre-existing object: %p (not tracked)\n", (void *)object);
-		}
+	if (!record->states) {
+		// There is no state table for this class, so we are not tracking it.
+		return;
+	}
+	
+	st_data_t state_data;
+	if (!st_delete(record->states, (st_data_t *)&object, &state_data)) {
+		// There is no state for this object, so we are not tracking it.
+		return;
+	}
+
+	VALUE state = (VALUE)state_data;
+
+	// Increment global free count
+	capture->free_count++;
+	
+	// Increment per-class free count
+	record->free_count++;
+	
+	if (!NIL_P(record->callback) && !NIL_P(state)) {
+		// Temporarily disable queueing to prevent infinite loop
+		int was_enabled = capture->enabled;
+		capture->enabled = 0;
+		
+		rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_freeobj, state);
+		
+		capture->enabled = was_enabled;
 	}
 }
 
@@ -210,58 +236,16 @@ static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE k
 void Memory_Profiler_Capture_process_event(struct Memory_Profiler_Event *event) {
 	switch (event->type) {
 		case MEMORY_PROFILER_EVENT_TYPE_NEWOBJ:
-			Memory_Profiler_Capture_process_newobj(event->capture, event->klass, event->allocations, event->object);
+			Memory_Profiler_Capture_process_newobj(event->capture, event->klass, event->object);
 			break;
 		case MEMORY_PROFILER_EVENT_TYPE_FREEOBJ:
-			Memory_Profiler_Capture_process_freeobj(event->capture, event->klass, event->allocations, event->object);
+			Memory_Profiler_Capture_process_freeobj(event->capture, event->klass, event->object);
 			break;
 	}
 }
 
 #pragma mark - Event Handlers
 
-// NEWOBJ event handler. Automatically tracks ALL allocations (creates records on demand).
-static void Memory_Profiler_Capture_newobj_handler(VALUE self, struct Memory_Profiler_Capture *capture, VALUE klass, VALUE object) {
-	st_data_t allocations_data;
-	VALUE allocations;
-	
-	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
-		// Existing record, increment count:
-		allocations = (VALUE)allocations_data;
-		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
-		record->new_count++;
-	} else {
-		// First time seeing this class, create record automatically:
-		struct Memory_Profiler_Capture_Allocations *record = ALLOC(struct Memory_Profiler_Capture_Allocations);
-		record->callback = Qnil;
-		record->new_count = 1;
-		record->free_count = 0;
-		record->object_states = NULL;
-		
-		allocations = Memory_Profiler_Allocations_wrap(record);
-		st_insert(capture->tracked_classes, (st_data_t)klass, (st_data_t)allocations);
-		RB_OBJ_WRITTEN(self, Qnil, klass);
-		RB_OBJ_WRITTEN(self, Qnil, allocations);
-	}
-	
-	// Enqueue to global event queue:
-	Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_NEWOBJ, self, klass, allocations, object);
-}
-
-// FREEOBJ event handler. Increments count and enqueues for processing.
-static void Memory_Profiler_Capture_freeobj_handler(VALUE self, struct Memory_Profiler_Capture *capture, VALUE klass, VALUE object) {
-	st_data_t allocations_data;
-	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
-		VALUE allocations = (VALUE)allocations_data;
-		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
-		
-		record->free_count++;
-		
-		// Enqueue to global event queue:
-		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_FREEOBJ, self, klass, allocations, object);
-	}
-}
-
 // Check if object type is trackable. Excludes internal types (T_IMEMO, T_NODE, T_ICLASS, etc.) that don't have normal classes.
 int Memory_Profiler_Capture_trackable_p(VALUE object) {
 	switch (rb_type(object)) {
@@ -305,30 +289,22 @@ static void Memory_Profiler_Capture_event_callback(VALUE data, void *ptr) {
 	TypedData_Get_Struct(data, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
 	VALUE object = rb_tracearg_object(trace_arg);
-
+	
 	// We don't want to track internal non-Object allocations:
 	if (!Memory_Profiler_Capture_trackable_p(object)) return;
-
+	
 	rb_event_flag_t event_flag = rb_tracearg_event_flag(trace_arg);
 	VALUE klass = rb_class_of(object);
 	if (!klass) return;
 	
-	if (DEBUG) {
-		// In events other than NEWOBJ, we are unable to allocate objects (due to GC), so we simply say "ignored":
-		const char *klass_name = "ignored";
-		if (event_flag == RUBY_INTERNAL_EVENT_NEWOBJ) {
-			klass_name = rb_class2name(klass);
-		}
-		
-		fprintf(stderr, "Memory_Profiler_Capture_event_callback: %s, Object: %p, Class: %p (%s)\n", event_flag_name(event_flag), (void *)object, (void *)klass, klass_name);
-	}
-	
 	if (event_flag == RUBY_INTERNAL_EVENT_NEWOBJ) {
-		// self is the newly allocated object
-		Memory_Profiler_Capture_newobj_handler(data, capture, klass, object);
+		// Skip NEWOBJ if disabled (during callback) to prevent infinite recursion
+		if (!capture->enabled) return;
+		
+		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_NEWOBJ, data, klass, object);
 	} else if (event_flag == RUBY_INTERNAL_EVENT_FREEOBJ) {
-		// self is the object being freed
-		Memory_Profiler_Capture_freeobj_handler(data, capture, klass, object);
+		// Always process FREEOBJ to ensure state cleanup
+		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_FREEOBJ, data, klass, object);
 	}
 }
 
@@ -347,6 +323,10 @@ static VALUE Memory_Profiler_Capture_alloc(VALUE klass) {
 		rb_raise(rb_eRuntimeError, "Failed to initialize hash table");
 	}
 	
+	// Initialize allocation tracking counters
+	capture->new_count = 0;
+	capture->free_count = 0;
+	
 	// Initialize state flags - not running, callbacks disabled
 	capture->running = 0;
 	capture->enabled = 0;
@@ -431,7 +411,7 @@ static VALUE Memory_Profiler_Capture_track(int argc, VALUE *argv, VALUE self) {
 		record->callback = callback;  // Initial assignment, no write barrier needed
 		record->new_count = 0;
 		record->free_count = 0;
-		record->object_states = st_init_numtable();
+		record->states = st_init_numtable();
 		
 		// Wrap the record in a VALUE
 		allocations = Memory_Profiler_Allocations_wrap(record);
@@ -481,13 +461,9 @@ static VALUE Memory_Profiler_Capture_count_for(VALUE self, VALUE klass) {
 	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
 		VALUE allocations = (VALUE)allocations_data;
 		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
-		// Return net live count (new_count - free_count)
-		// Handle case where more objects freed than allocated (allocated before tracking started)
-		if (record->free_count > record->new_count) {
-			return INT2FIX(0);  // Can't have negative live count
+		if (record->free_count <= record->new_count) {
+			return SIZET2NUM(record->new_count - record->free_count);
 		}
-		size_t live_count = record->new_count - record->free_count;
-		return SIZET2NUM(live_count);
 	}
 	
 	return INT2FIX(0);
@@ -507,9 +483,21 @@ static VALUE Memory_Profiler_Capture_clear(VALUE self) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	// Reset all counts to 0 (don't free, just reset) - pass self for write barriers
+	// SAFETY: Don't allow clearing while running - there may be:
+	// - Event handlers firing (adding to object_allocations).
+	// - Events queued that haven't been processed yet.
+	// - Processors trying to access the states table.
+	if (capture->running) {
+		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:
 	st_foreach(capture->tracked_classes, Memory_Profiler_Capture_tracked_classes_clear, 0);
 	
+	// Reset allocation tracking counters
+	capture->new_count = 0;
+	capture->free_count = 0;
+	
 	return self;
 }
 
@@ -555,17 +543,17 @@ struct Memory_Profiler_Allocations_Statistics {
 	VALUE per_class_counts;
 };
 
-// Iterator callback to count object_states per class
-static int Memory_Profiler_Capture_count_object_states(st_data_t key, st_data_t value, st_data_t argument) {
+// Iterator callback to count states per class
+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;
 	VALUE klass = (VALUE)key;
 	VALUE allocations = (VALUE)value;
 	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
 	
-	size_t object_states_count = record->object_states ? record->object_states->num_entries : 0;
-	statistics->total_tracked_objects += object_states_count;
+	size_t states_count = record->states ? record->states->num_entries : 0;
+	statistics->total_tracked_objects += states_count;
 	
-	rb_hash_aset(statistics->per_class_counts, klass, SIZET2NUM(object_states_count));
+	rb_hash_aset(statistics->per_class_counts, klass, SIZET2NUM(states_count));
 	return ST_CONTINUE;
 }
 
@@ -579,16 +567,14 @@ static VALUE Memory_Profiler_Capture_statistics(VALUE self) {
 	
 	// Tracked classes count
 	rb_hash_aset(statistics, ID2SYM(rb_intern("tracked_classes_count")), SIZET2NUM(capture->tracked_classes->num_entries));
-	
-	// Note: Global event queue stats are internal to the events module
-	
-	// Count object_states entries for each tracked class
+		
+	// Count states entries for each tracked class
 	struct Memory_Profiler_Allocations_Statistics allocations_statistics = {
 		.total_tracked_objects = 0,
 		.per_class_counts = rb_hash_new()
 	};
 	
-	st_foreach(capture->tracked_classes, Memory_Profiler_Capture_count_object_states, (st_data_t)&allocations_statistics);
+	st_foreach(capture->tracked_classes, 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);
@@ -596,6 +582,32 @@ static VALUE Memory_Profiler_Capture_statistics(VALUE self) {
 	return statistics;
 }
 
+// Get total new count across all classes
+static VALUE Memory_Profiler_Capture_new_count(VALUE self) {
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
+	
+	return SIZET2NUM(capture->new_count);
+}
+
+// Get total free count across all classes
+static VALUE Memory_Profiler_Capture_free_count(VALUE self) {
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
+	
+	return SIZET2NUM(capture->free_count);
+}
+
+// Get total retained count (new - free) across all classes
+static VALUE Memory_Profiler_Capture_retained_count(VALUE self) {
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
+	
+	// Handle underflow if free_count > new_count (shouldn't happen but be safe)
+	size_t retained = capture->free_count > capture->new_count ? 0 : capture->new_count - capture->free_count;
+	return SIZET2NUM(retained);
+}
+
 void Init_Memory_Profiler_Capture(VALUE Memory_Profiler)
 {
 	// Initialize event symbols
@@ -618,6 +630,9 @@ void Init_Memory_Profiler_Capture(VALUE Memory_Profiler)
 	rb_define_method(Memory_Profiler_Capture, "[]", Memory_Profiler_Capture_aref, 1);
 	rb_define_method(Memory_Profiler_Capture, "clear", Memory_Profiler_Capture_clear, 0);
 	rb_define_method(Memory_Profiler_Capture, "statistics", Memory_Profiler_Capture_statistics, 0);
+	rb_define_method(Memory_Profiler_Capture, "new_count", Memory_Profiler_Capture_new_count, 0);
+	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);
 	
 	// Initialize Allocations class
 	Init_Memory_Profiler_Allocations(Memory_Profiler);

data/ext/memory/profiler/events.c

@@ -96,13 +96,12 @@ static void Memory_Profiler_Events_mark(void *ptr) {
 	for (size_t i = 0; i < events->queue.count; i++) {
 		struct Memory_Profiler_Event *event = Memory_Profiler_Queue_at(&events->queue, i);
 		
-		// Mark the Capture instance this event belongs to:
+		// Mark the Capture instance and class:
 		rb_gc_mark_movable(event->capture);
 		rb_gc_mark_movable(event->klass);
-		rb_gc_mark_movable(event->allocations);
 		
-		// For NEWOBJ, mark the object (it's alive).
-		// For FREEOBJ, DON'T mark (it's being freed - just used as key for lookup).
+		// For NEWOBJ: mark the object to keep it alive until processor runs
+		// For FREEOBJ: DON'T mark (object is being freed)
 		if (event->type == MEMORY_PROFILER_EVENT_TYPE_NEWOBJ) {
 			rb_gc_mark_movable(event->object);
 		}
@@ -120,10 +119,9 @@ static void Memory_Profiler_Events_compact(void *ptr) {
 		// Update all VALUEs if they moved during compaction:
 		event->capture = rb_gc_location(event->capture);
 		event->klass = rb_gc_location(event->klass);
-		event->allocations = rb_gc_location(event->allocations);
 		
-		// For NEWOBJ, update the object pointer.
-		// For FREEOBJ, DON'T update (it's being freed, pointer is stale).
+		// For NEWOBJ: update object pointer if it moved
+		// For FREEOBJ: DON'T update (object is being freed, pointer is stale)
 		if (event->type == MEMORY_PROFILER_EVENT_TYPE_NEWOBJ) {
 			event->object = rb_gc_location(event->object);
 		}
@@ -147,7 +145,6 @@ int Memory_Profiler_Events_enqueue(
 	enum Memory_Profiler_Event_Type type,
 	VALUE capture,
 	VALUE klass,
-	VALUE allocations,
 	VALUE object
 ) {
 	struct Memory_Profiler_Events *events = Memory_Profiler_Events_instance();
@@ -159,7 +156,6 @@ 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->allocations, allocations);
 		RB_OBJ_WRITE(events->self, &event->object, object);
 		
 		const char *type_name = (type == MEMORY_PROFILER_EVENT_TYPE_NEWOBJ) ? "NEWOBJ" : "FREEOBJ";

data/ext/memory/profiler/events.h

@@ -22,10 +22,7 @@ struct Memory_Profiler_Event {
 	// The class of the object:
 	VALUE klass;
 
-	// The Allocations wrapper:
-	VALUE allocations;
-
-	// The object itself:
+	// The object itself (for NEWOBJ and FREEOBJ):
 	VALUE object;
 };
 
@@ -39,7 +36,6 @@ int Memory_Profiler_Events_enqueue(
 	enum Memory_Profiler_Event_Type type,
 	VALUE capture,
 	VALUE klass,
-	VALUE allocations,
 	VALUE object
 );
 

data/lib/memory/profiler/version.rb

@@ -7,7 +7,7 @@
 module Memory
 	# @namespace
 	module Profiler
-		VERSION = "1.1.9"
+		VERSION = "1.1.10"
 	end
 end
 

data/readme.md

@@ -22,6 +22,15 @@ Please see the [project documentation](https://socketry.github.io/memory-profile
 
 Please see the [project releases](https://socketry.github.io/memory-profiler/releases/index) for all releases.
 
+### v1.1.10
+
+  - Added `Capture#new_count` - returns total number of allocations tracked across all classes.
+  - Added `Capture#free_count` - returns total number of objects freed across all classes.
+  - Added `Capture#retained_count` - returns retained object count (new\_count - free\_count).
+  - **Critical:** Fixed GC crash during compaction caused by missing write barriers in event queue.
+  - Fixed allocation/deallocation counts being inaccurate when objects are allocated during callbacks or freed after compaction.
+  - `Capture#clear` now raises `RuntimeError` if called while capture is running. Call `stop()` before `clear()`.
+
 ### v1.1.9
 
   - More write barriers...

data/releases.md

@@ -1,5 +1,14 @@
 # Releases
 
+## v1.1.10
+
+  - Added `Capture#new_count` - returns total number of allocations tracked across all classes.
+  - Added `Capture#free_count` - returns total number of objects freed across all classes.
+  - Added `Capture#retained_count` - returns retained object count (new\_count - free\_count).
+  - **Critical:** Fixed GC crash during compaction caused by missing write barriers in event queue.
+  - Fixed allocation/deallocation counts being inaccurate when objects are allocated during callbacks or freed after compaction.
+  - `Capture#clear` now raises `RuntimeError` if called while capture is running. Call `stop()` before `clear()`.
+
 ## v1.1.9
 
   - More write barriers...

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memory-profiler
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.1.10
 platform: ruby
 authors:
 - Samuel Williams