memory-profiler 1.1.10 → 1.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05249db4d71f31bfdaa1e8eb0814d7c44688aa9b576a6df40e48bb2b0505c802'
-  data.tar.gz: 3c39173cf151e64ca8ae17790dc4453f337091f973ba25e5db54f2917e0b3bf1
+  metadata.gz: 1237585b03f1c87b2c4cafb01668200bc33d518c35f832539315a7f6f37dc4f2
+  data.tar.gz: 13a79c36183a794df061076e3e09dd2a8a1e14eadfcdb0dc5e3317a6902f622c
 SHA512:
-  metadata.gz: a6aa1342bd86d5dd8dfcdb80497bb50c07937182a60dfb9d296d84e88fbd72f0ebdc4dd6c82fb396a4067b2adc129572f556d8545328a4dd04516bd0ffedf613
-  data.tar.gz: 819cb8882b506f4341faa8095469279ec0d053c67392fa1d7d0e6a689b80bf037f196743280e91e4fb70987ea89cfcd492f3f0f39a8a9fcb6bafa7de3c4e4cb1
+  metadata.gz: 98c104bac6001ec5cde21d984a80a69ac992a113677ea672a81d1d1e468e754331f1170ea58c3a6ba8f1fe4a453ec669d143f7af71ab797e0d206a50bd8bbe8a
+  data.tar.gz: 2bf799367a7cd59a760f52c89f8da0ab3ee252867bdcca431ca9340349172bcf0962f626f4cada76fcfd721084fb8de8dbe0d8692eb9593a5b4a56f625587436

checksums.yaml.gz.sig

@@ -1,2 +1 @@
-@Z�Bկ�5a�1����F�Zh�i��:�?N���yB�O�3�<��GΝ*�����Q��I�A� �F�ȥjF*�m�äs"��Dj"h�Q��@���|X���/�j��?8�w�����,ޤz!ؗ�
72^
t�$�{�6B��K��������6�>ؾ4��/�6�*��&&�w�ð@�+u��T��J�|����%Aw�Xw���Z�|vIJ:V-��\<�m��+˯漕W�Ec��s����ZB���X`���\g��c�R4�rcrZFN�OT
-�|YP��	�TH@xDm�֞�V� �TQ4Vu�̖f�	�L���b!���&b�+���!�9_��)%?1(?��7��mO��Rbf�8v��s�1fL
+?#�nV����h����;4�Mq%��M��`+�*e!-��6;S�qX� 6+�̀,D5�A�_�3?|�

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;
 		
-		rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_freeobj, state);
+		// Increment global free count
+		capture->free_count++;
 		
-		capture->enabled = was_enabled;
+		// 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.
@@ -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,7 +300,7 @@ 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;
 		
 		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_NEWOBJ, data, klass, object);
 	} else if (event_flag == RUBY_INTERNAL_EVENT_FREEOBJ) {
@@ -329,7 +330,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 +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;
 }
@@ -383,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;
 }

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,13 +114,24 @@ 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);
@@ -128,19 +145,44 @@ static void Memory_Profiler_Events_compact(void *ptr) {
 	}
 }
 
+// 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 +190,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 +201,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 +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;
@@ -206,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,
 };

data/lib/memory/profiler/version.rb

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

data/readme.md

@@ -22,6 +22,10 @@ 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.

data/releases.md

@@ -1,5 +1,9 @@
 # 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.

metadata

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