memory-profiler 1.1.10 → 1.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05249db4d71f31bfdaa1e8eb0814d7c44688aa9b576a6df40e48bb2b0505c802'
-  data.tar.gz: 3c39173cf151e64ca8ae17790dc4453f337091f973ba25e5db54f2917e0b3bf1
+  metadata.gz: 4fb4dabaaccdf849f1226fc675a2ffed0893ee3b1298263c40b42667c544f0b4
+  data.tar.gz: de34c582331bcd65fa65bda39e41ea5c9fd07ab44fa9c325729011c47f0a5353
 SHA512:
-  metadata.gz: a6aa1342bd86d5dd8dfcdb80497bb50c07937182a60dfb9d296d84e88fbd72f0ebdc4dd6c82fb396a4067b2adc129572f556d8545328a4dd04516bd0ffedf613
-  data.tar.gz: 819cb8882b506f4341faa8095469279ec0d053c67392fa1d7d0e6a689b80bf037f196743280e91e4fb70987ea89cfcd492f3f0f39a8a9fcb6bafa7de3c4e4cb1
+  metadata.gz: c8b7a4c1c3d3eff6c2ff9531847544bf7b9c8be7008615162b9442726066df94d48ab77ce34d0af106ac1376e14a8ede49ed90be8b2e29818b781c6ac34ae8f3
+  data.tar.gz: bdf055ac783a19b8662a271de7b5493c4c7cbac6b01c0c1a515809a04058262ec6d2c42c96a8f2cbef558edf0c28e35fdbcc3f818c4e5e9d2fc7fb6a11d57d1c

data/ext/memory/profiler/allocations.c

@@ -12,8 +12,9 @@ static VALUE Memory_Profiler_Allocations = Qnil;
 
 // 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
+	// We don't want the key to move - we can't rehash the table if it does.
+	rb_gc_mark((VALUE)key);
+	
 	VALUE state = (VALUE)value;
 	rb_gc_mark_movable(state);
 	return ST_CONTINUE;
@@ -27,19 +28,7 @@ static int Memory_Profiler_Allocations_states_foreach(st_data_t key, st_data_t v
 
 // 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_state = rb_gc_location(old_state);
-	
-	// 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 state value if it moved (this is safe, doesn't rehash)
-	if (old_state != new_state) {
-		*value = (st_data_t)new_state;
-	}
+	*value = (st_data_t)rb_gc_location((VALUE)*value);
 	
 	return ST_CONTINUE;
 }

data/ext/memory/profiler/capture.c

@@ -26,7 +26,7 @@ struct Memory_Profiler_Capture {
 	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;
@@ -142,6 +142,9 @@ static void Memory_Profiler_Capture_process_newobj(VALUE capture_value, VALUE kl
 	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;
+	
 	// Increment global new count:
 	capture->new_count++;
 	
@@ -171,20 +174,17 @@ static void Memory_Profiler_Capture_process_newobj(VALUE capture_value, VALUE kl
 	
 	// Only store state if there's a callback
 	if (!NIL_P(record->callback)) {
-		// Temporarily disable queueing to prevent infinite loop
-		int was_enabled = capture->enabled;
-		capture->enabled = 0;
-		
 		VALUE state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
 		
-		capture->enabled = was_enabled;
-		
 		// 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. All deallocation tracking logic is here.
@@ -192,11 +192,14 @@ static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE k
 	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.
-		return;
+		goto done;
 	}
 	
 	VALUE allocations = (VALUE)allocations_data;
@@ -204,32 +207,27 @@ static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE k
 	
 	if (!record->states) {
 		// There is no state table for this class, so we are not tracking it.
-		return;
+		goto done;
 	}
 	
 	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;
+	if (st_delete(record->states, (st_data_t *)&object, &state_data)) {
+		VALUE state = (VALUE)state_data;
+		
+		// Increment global free count
+		capture->free_count++;
 		
-		rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_freeobj, state);
+		// Increment per-class free count
+		record->free_count++;
 		
-		capture->enabled = was_enabled;
+		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.
@@ -241,6 +239,9 @@ void Memory_Profiler_Capture_process_event(struct Memory_Profiler_Event *event)
 		case MEMORY_PROFILER_EVENT_TYPE_FREEOBJ:
 			Memory_Profiler_Capture_process_freeobj(event->capture, event->klass, event->object);
 			break;
+		default:
+			// Ignore.
+			break;
 	}
 }
 
@@ -299,12 +300,20 @@ static void Memory_Profiler_Capture_event_callback(VALUE data, void *ptr) {
 	
 	if (event_flag == RUBY_INTERNAL_EVENT_NEWOBJ) {
 		// Skip NEWOBJ if disabled (during callback) to prevent infinite recursion
-		if (!capture->enabled) return;
+		if (capture->paused) return;
 		
+		// It's safe to unconditionally call here:
+		object = rb_obj_id(object);
+
 		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_NEWOBJ, data, klass, object);
 	} else if (event_flag == RUBY_INTERNAL_EVENT_FREEOBJ) {
-		// Always process FREEOBJ to ensure state cleanup
-		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_FREEOBJ, data, klass, object);
+		// 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)) {
+			// It's only safe to call here if the object already has an object ID.
+			object = rb_obj_id(object);
+			
+			Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_FREEOBJ, data, klass, object);
+		}
 	}
 }
 
@@ -329,7 +338,7 @@ static VALUE Memory_Profiler_Capture_alloc(VALUE klass) {
 	
 	// 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)
 	
@@ -362,7 +371,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;
 }
@@ -383,7 +392,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;
 }

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,13 +94,13 @@ 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 and class:
 		rb_gc_mark_movable(event->capture);
@@ -108,39 +114,70 @@ static void Memory_Profiler_Events_mark(void *ptr) {
 	}
 }
 
-// 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);
-		
-		// 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);
-		}
+		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,
@@ -148,8 +185,9 @@ int Memory_Profiler_Events_enqueue(
 	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;
 		
@@ -158,8 +196,8 @@ int Memory_Profiler_Events_enqueue(
 		RB_OBJ_WRITE(events->self, &event->klass, klass);
 		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:
@@ -191,11 +229,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;
@@ -206,8 +249,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,
 };

data/lib/memory/profiler/version.rb

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

data/readme.md

@@ -22,6 +22,14 @@ 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.12
+
+  - Use `rb_obj_id` for tracking object states to avoid compaction issues.
+
+### 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.

data/releases.md

@@ -1,5 +1,13 @@
 # Releases
 
+## v1.1.12
+
+  - Use `rb_obj_id` for tracking object states to avoid compaction issues.
+
+## 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.

metadata

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