memory-profiler 1.1.9 → 1.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85589b15e3229992f9afefb5333efebaa07d7e25da717a46b3db5846e14af63d
-  data.tar.gz: 82986a841e9964aed258e1d7d94f2af7719f350f517423ca49ffb496237e497c
+  metadata.gz: 1237585b03f1c87b2c4cafb01668200bc33d518c35f832539315a7f6f37dc4f2
+  data.tar.gz: 13a79c36183a794df061076e3e09dd2a8a1e14eadfcdb0dc5e3317a6902f622c
 SHA512:
-  metadata.gz: ed056829d3a27ca9b2cc681107a7254e798338c77bbe539f91332d915be126665a19550c5533db8fe751531f12c66963cdfe692232d3f5d3a5f409dd66e31cab
-  data.tar.gz: cd44bca86e0db7a75413492a694dad3d202359f6cbe2d386ff71dd08d74adcc13557181565694679d3da1978c58664beff442b54e3a4b2512ef83d16cf96fce8
+  metadata.gz: 98c104bac6001ec5cde21d984a80a69ac992a113677ea672a81d1d1e468e754331f1170ea58c3a6ba8f1fe4a453ec669d143f7af71ab797e0d206a50bd8bbe8a
+  data.tar.gz: 2bf799367a7cd59a760f52c89f8da0ab3ee252867bdcca431ca9340349172bcf0962f626f4cada76fcfd721084fb8de8dbe0d8692eb9593a5b4a56f625587436

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;
+	int paused;
+
+	// 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,129 +137,116 @@ 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);
+	// Pause the capture to prevent infinite loop:
+	capture->paused += 1;
 	
-	// Ensure object_states table exists:
-	if (!record->object_states) {
-		record->object_states = st_init_numtable();
-	}
+	// Increment global new count:
+	capture->new_count++;
 	
-	VALUE state;
+	// Look up or create allocations record for this class:
+	st_data_t allocations_data;
+	VALUE allocations;
+	struct Memory_Profiler_Capture_Allocations *record;
 	
-	if (!NIL_P(record->callback)) {
-		// 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);
-		
-		capture->enabled = was_enabled;
-		
-		if (DEBUG_STATE) fprintf(stderr, "Storing callback state for object: %p\n", (void *)object);
+	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 {
-		// No callback, store sentinel (Qnil):
-		state = Qnil;
+		// 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();
 		
-		if (DEBUG_STATE) fprintf(stderr, "Storing sentinel (Qnil) for object: %p\n", (void *)object);
+		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);
 	}
 	
-	// Always store something to maintain NEWOBJ/FREEOBJ symmetry:
-	st_insert(record->object_states, (st_data_t)object, (st_data_t)state);
+	// Only store state if there's a callback
+	if (!NIL_P(record->callback)) {
+		VALUE state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
+		
+		// Store state using object as key (works because object is alive):
+		st_insert(record->states, (st_data_t)object, (st_data_t)state);
+	} else {
+		// Store state as nil:
+		st_insert(record->states, (st_data_t)object, (st_data_t)Qnil);
+	}
+
+	// Resume the capture:
+	capture->paused -= 1;
 }
 
-// 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);
 	
+	// Pause the capture to prevent infinite loop:
+	capture->paused += 1;
+	
+	// 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.
+		goto done;
+	}
+	
+	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.
+		goto done;
+	}
+	
+	st_data_t state_data;
+	if (st_delete(record->states, (st_data_t *)&object, &state_data)) {
+		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)) {
+			rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_freeobj, state);
 		}
 	}
+
+done:
+	// Resume the capture:
+	capture->paused -= 1;
 }
 
 // Process a single event (NEWOBJ or FREEOBJ). Called from events.c via rb_protect to catch exceptions.
 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;
+		default:
+			// Ignore.
 			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 +290,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->paused) 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,9 +324,13 @@ 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;
+	capture->paused = 0;
 	
 	// Global event queue system will auto-initialize on first use (lazy initialization)
 	
@@ -382,7 +363,7 @@ static VALUE Memory_Profiler_Capture_start(VALUE self) {
 	
 	// Set both flags - we're now running and callbacks are enabled
 	capture->running = 1;
-	capture->enabled = 1;
+	capture->paused = 0;
 	
 	return Qtrue;
 }
@@ -403,7 +384,7 @@ static VALUE Memory_Profiler_Capture_stop(VALUE self) {
 	
 	// Clear both flags - we're no longer running and callbacks are disabled
 	capture->running = 0;
-	capture->enabled = 0;
+	capture->paused = 0;
 	
 	return Qtrue;
 }
@@ -431,7 +412,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 +462,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 +484,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 +544,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 +568,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 +583,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 +631,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

@@ -17,9 +17,10 @@ struct Memory_Profiler_Events {
 	// The VALUE wrapper for this struct (needed for write barriers).
 	VALUE self;
 	
-	// Global event queue (contains events from all Capture instances).
-	struct Memory_Profiler_Queue queue;
-	
+	// Double-buffered event queues (contains events from all Capture instances).
+	struct Memory_Profiler_Queue queues[2];
+	struct Memory_Profiler_Queue *available, *processing;
+
 	// Postponed job handle for processing the queue.
 	// Postponed job handles are an extremely limited resource, so we only register one global event queue.
 	rb_postponed_job_handle_t postponed_job_handle;
@@ -51,8 +52,13 @@ static VALUE Memory_Profiler_Events_new(void) {
 	// Store the VALUE wrapper for write barriers:
 	events->self = self;
 	
-	// Initialize the global event queue:
-	Memory_Profiler_Queue_initialize(&events->queue, sizeof(struct Memory_Profiler_Event));
+	// Initialize both queues for double buffering:
+	Memory_Profiler_Queue_initialize(&events->queues[0], sizeof(struct Memory_Profiler_Event));
+	Memory_Profiler_Queue_initialize(&events->queues[1], sizeof(struct Memory_Profiler_Event));
+
+	// Start with queues[0] available for incoming events, queues[1] for processing (initially empty):
+	events->available = &events->queues[0];
+	events->processing = &events->queues[1];
 	
 	// Pre-register the single postponed job for processing the queue:
 	events->postponed_job_handle = rb_postponed_job_preregister(0,
@@ -88,82 +94,115 @@ struct Memory_Profiler_Events* Memory_Profiler_Events_instance(void) {
 	return events;
 }
 
-// GC mark callback - mark all VALUEs in the event queue.
-static void Memory_Profiler_Events_mark(void *ptr) {
-	struct Memory_Profiler_Events *events = ptr;
-	
-	// Mark all events in the global queue:
-	for (size_t i = 0; i < events->queue.count; i++) {
-		struct Memory_Profiler_Event *event = Memory_Profiler_Queue_at(&events->queue, i);
+// Helper to mark events in a queue.
+static void Memory_Profiler_Events_mark_queue(struct Memory_Profiler_Queue *queue, int skip_none) {
+	for (size_t i = 0; i < queue->count; i++) {
+		struct Memory_Profiler_Event *event = Memory_Profiler_Queue_at(queue, i);
+		
+		// Skip already-processed events if requested:
+		if (skip_none && event->type == MEMORY_PROFILER_EVENT_TYPE_NONE) continue;
 		
-		// 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);
 		}
 	}
 }
 
-// GC compact callback - update all VALUEs in the event queue.
-static void Memory_Profiler_Events_compact(void *ptr) {
+// GC mark callback - mark all VALUEs in both event queues.
+static void Memory_Profiler_Events_mark(void *ptr) {
 	struct Memory_Profiler_Events *events = ptr;
 	
-	// Update objects in the global event queue:
-	for (size_t i = 0; i < events->queue.count; i++) {
-		struct Memory_Profiler_Event *event = Memory_Profiler_Queue_at(&events->queue, i);
+	// Mark all events in the available queue (receiving new events):
+	Memory_Profiler_Events_mark_queue(events->available, 0);
+	
+	// Mark all events in the processing queue (currently being processed):
+	Memory_Profiler_Events_mark_queue(events->processing, 1);
+}
+
+// Helper to compact events in a queue.
+static void Memory_Profiler_Events_compact_queue(struct Memory_Profiler_Queue *queue, int skip_none) {
+	for (size_t i = 0; i < queue->count; i++) {
+		struct Memory_Profiler_Event *event = Memory_Profiler_Queue_at(queue, i);
+		
+		// Skip already-processed events if requested:
+		if (skip_none && event->type == MEMORY_PROFILER_EVENT_TYPE_NONE) continue;
 		
 		// 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);
 		}
 	}
 }
 
+// GC compact callback - update all VALUEs in both event queues.
+static void Memory_Profiler_Events_compact(void *ptr) {
+	struct Memory_Profiler_Events *events = ptr;
+	
+	// Update objects in the available queue:
+	Memory_Profiler_Events_compact_queue(events->available, 0);
+	
+	// Update objects in the processing queue:
+	Memory_Profiler_Events_compact_queue(events->processing, 1);
+}
+
 // GC free callback.
 static void Memory_Profiler_Events_free(void *ptr) {
 	struct Memory_Profiler_Events *events = ptr;
-	Memory_Profiler_Queue_free(&events->queue);
+	Memory_Profiler_Queue_free(&events->queues[0]);
+	Memory_Profiler_Queue_free(&events->queues[1]);
 }
 
 // GC memsize callback.
 static size_t Memory_Profiler_Events_memsize(const void *ptr) {
 	const struct Memory_Profiler_Events *events = ptr;
-	return sizeof(struct Memory_Profiler_Events) + (events->queue.capacity * events->queue.element_size);
+	return sizeof(struct Memory_Profiler_Events) 
+		+ (events->queues[0].capacity * events->queues[0].element_size)
+		+ (events->queues[1].capacity * events->queues[1].element_size);
 }
 
-// Enqueue an event to the global queue.
+const char *Memory_Profiler_Event_Type_name(enum Memory_Profiler_Event_Type type) {
+	switch (type) {
+		case MEMORY_PROFILER_EVENT_TYPE_NEWOBJ:
+			return "NEWOBJ";
+		case MEMORY_PROFILER_EVENT_TYPE_FREEOBJ:
+			return "FREEOBJ";
+		default:
+			return "NONE";
+	}
+}
+
+// Enqueue an event to the available queue (can be called anytime, even during processing).
 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();
-	
-	struct Memory_Profiler_Event *event = Memory_Profiler_Queue_push(&events->queue);
+
+	// Always enqueue to the available queue - it won't be touched during processing:
+	struct Memory_Profiler_Event *event = Memory_Profiler_Queue_push(events->available);
 	if (event) {
 		event->type = type;
 		
 		// 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";
-		if (DEBUG) fprintf(stderr, "Queued %s to global queue, size: %zu\n", type_name, events->queue.count);
+		if (DEBUG) fprintf(stderr, "Queued %s to available queue, size: %zu\n", 
+			Memory_Profiler_Event_Type_name(type), events->available->count);
 		
 		rb_postponed_job_trigger(events->postponed_job_handle);
 		// Success:
@@ -195,11 +234,16 @@ static VALUE Memory_Profiler_Events_process_event_protected(VALUE arg) {
 static void Memory_Profiler_Events_process_queue(void *arg) {
 	struct Memory_Profiler_Events *events = (struct Memory_Profiler_Events *)arg;
 	
-	if (DEBUG) fprintf(stderr, "Processing global event queue: %zu events\n", events->queue.count);
+	// Swap the queues: available becomes processing, and the old processing queue (now empty) becomes available. This allows new events to continue enqueueing to the new available queue while we process.
+	struct Memory_Profiler_Queue *queue_to_process = events->available;
+	events->available = events->processing;
+	events->processing = queue_to_process;
 	
+	if (DEBUG) fprintf(stderr, "Processing event queue: %zu events\n", events->processing->count);
+
 	// Process all events in order (maintains NEWOBJ before FREEOBJ for same object):
-	for (size_t i = 0; i < events->queue.count; i++) {
-		struct Memory_Profiler_Event *event = Memory_Profiler_Queue_at(&events->queue, i);
+	for (size_t i = 0; i < events->processing->count; i++) {
+		struct Memory_Profiler_Event *event = Memory_Profiler_Queue_at(events->processing, i);
 		
 		// Process event with rb_protect to catch any exceptions:
 		int state = 0;
@@ -210,8 +254,14 @@ static void Memory_Profiler_Events_process_queue(void *arg) {
 			rb_warning("Exception in event processing callback (caught and suppressed): %"PRIsVALUE, rb_errinfo());
 			rb_set_errinfo(Qnil);
 		}
+		
+		// Clear this event after processing to prevent marking stale data if GC runs:
+		event->type = MEMORY_PROFILER_EVENT_TYPE_NONE;
+		RB_OBJ_WRITE(events->self, &event->capture, Qnil);
+		RB_OBJ_WRITE(events->self, &event->klass, Qnil);
+		RB_OBJ_WRITE(events->self, &event->object, Qnil);
 	}
 	
-	// Always clear the global queue, even if exceptions occurred:
-	Memory_Profiler_Queue_clear(&events->queue);
+	// Clear the processing queue (which is now empty logically):
+	Memory_Profiler_Queue_clear(events->processing);
 }

data/ext/memory/profiler/events.h

@@ -8,6 +8,7 @@
 
 // Event types
 enum Memory_Profiler_Event_Type {
+	MEMORY_PROFILER_EVENT_TYPE_NONE = 0,
 	MEMORY_PROFILER_EVENT_TYPE_NEWOBJ,
 	MEMORY_PROFILER_EVENT_TYPE_FREEOBJ,
 };
@@ -22,10 +23,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 +37,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.11"
 	end
 end
 

data/readme.md

@@ -22,6 +22,19 @@ 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.11
+
+  - Double buffer shared events queues to fix queue corruption.
+
+### 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,18 @@
 # Releases
 
+## v1.1.11
+
+  - Double buffer shared events queues to fix queue corruption.
+
+## 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.11
 platform: ruby
 authors:
 - Samuel Williams