memory-profiler 1.1.7 → 1.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bb750e881686089136fbcd20b073e857dc3a7dc7f4784f0a75cf8fbb17444ec
-  data.tar.gz: 75d398699455359a70dafbbd1c71ce8dd529faf492f8fd7f595cc9714101061f
+  metadata.gz: 1c43ffe32db5ad0039b47cc3aa32162d58cd320e82864d78112dd5bef43f1a53
+  data.tar.gz: '01095d67b202e81846c70b915b7077708c5b395faa1f3165d4877764f18c547b'
 SHA512:
-  metadata.gz: 83261c47a3365c107239cd626b61afe496e51d17e04ee36ac81235d7493997089fd97648965af42747ff1b3f8074f1fe72df31a1ecf6ce774fe9ac1ae2cf0565
-  data.tar.gz: 5bf3be79ccabbc16f1d753c94a3af7d89affabfc34d4feb9fd001f0573cf516614363f7430dfbe3553166076c349ffe38cee7e39309f9f6eecef867ba4978d78
+  metadata.gz: 37ddeacd7c676da0ca4d0656c9d971dc209b5340f122adb9201a16b740523d208dfb5845ba79ef21192cb4165496f1c4baedfda3368309eb113458aa6b9fd27e
+  data.tar.gz: d2c7fb78cdf96d799cfc531d9219defe941a50723b72f6e386c90b23507c78d3ed1bc6edb3f0b060b71e2fcb2109532239e78dcaff0f85f2743fc3d6cb014cf7

data/ext/extconf.rb

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

data/ext/memory/profiler/allocations.h

@@ -6,26 +6,30 @@
 #include "ruby.h"
 #include "ruby/st.h"
 
-// Per-class allocation tracking record
+// Per-class allocation tracking record:
 struct Memory_Profiler_Capture_Allocations {
-	VALUE callback;   // Optional Ruby proc/lambda to call on allocation
-	size_t new_count;  // Total allocations seen since tracking started
-	size_t free_count; // Total frees seen since tracking started
-	// Live count = new_count - free_count
+	// Optional Ruby proc/lambda to call on allocation.
+	VALUE callback;
+
+	// Total allocations seen since tracking started.
+	size_t new_count;
+	// // Total frees seen since tracking started.
+	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
+	// For detailed tracking: map object (VALUE) => state (VALUE).
+	// State is returned from callback on `newobj` and passed back on `freeobj`.
 	st_table *object_states;
 };
 
-// Wrap an allocations record in a VALUE
+// Wrap an allocations record in a VALUE.
 VALUE Memory_Profiler_Allocations_wrap(struct Memory_Profiler_Capture_Allocations *record);
 
-// Get allocations record from wrapper VALUE
+// Get allocations record from wrapper VALUE.
 struct Memory_Profiler_Capture_Allocations* Memory_Profiler_Allocations_get(VALUE self);
 
-// Clear/reset allocation counts and state for a record
+// Clear/reset allocation counts and state for a record.
 void Memory_Profiler_Allocations_clear(VALUE allocations);
 
-// Initialize the Allocations class
+// Initialize the Allocations class.
 void Init_Memory_Profiler_Allocations(VALUE Memory_Profiler);

data/ext/memory/profiler/capture.c

@@ -3,7 +3,7 @@
 
 #include "capture.h"
 #include "allocations.h"
-#include "queue.h"
+#include "events.h"
 
 #include "ruby.h"
 #include "ruby/debug.h"
@@ -13,107 +13,47 @@
 
 enum {
 	DEBUG = 0,
-	DEBUG_EVENT_QUEUES = 0,
 	DEBUG_STATE = 0,
 };
 
 static VALUE Memory_Profiler_Capture = Qnil;
 
-// Event symbols
-static VALUE sym_newobj;
-static VALUE sym_freeobj;
+// Event symbols:
+static VALUE sym_newobj, sym_freeobj;
 
-// Queue item - new object data to be processed via postponed job
-struct Memory_Profiler_Newobj_Queue_Item {
-	// The class of the new object:
-	VALUE klass;
-
-	// The Allocations wrapper:
-	VALUE allocations;
-
-	// The newly allocated object:
-	VALUE object;
-};
-
-// Queue item - freed object data to be processed via postponed job
-struct Memory_Profiler_Freeobj_Queue_Item {
-	// The class of the freed object:
-	VALUE klass;
-
-	// The Allocations wrapper:
-	VALUE allocations;
-
-	// The state returned from callback on newobj:
-	VALUE state;
-};
-
-// Main capture state
+// Main capture state (per-instance).
 struct Memory_Profiler_Capture {
-	// class => VALUE (wrapped Memory_Profiler_Capture_Allocations).
+	// Tracked classes: class => VALUE (wrapped Memory_Profiler_Capture_Allocations).
 	st_table *tracked_classes;
 
-	// Master switch - is tracking active? (set by start/stop)
+	// Master switch - is tracking active? (set by start/stop).
 	int running;
 	
-	// Internal - should we queue callbacks? (temporarily disabled during queue processing)
+	// Should we queue callbacks? (temporarily disabled during queue processing).
 	int enabled;
-	
-	// Queue for new objects (processed via postponed job):
-	struct Memory_Profiler_Queue newobj_queue;
-	
-	// Queue for freed objects (processed via postponed job):
-	struct Memory_Profiler_Queue freeobj_queue;
-	
-	// Handle for the postponed job (processes both queues)
-	rb_postponed_job_handle_t postponed_job_handle;
 };
 
-// GC mark callback for tracked_classes table
+// 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 as we don't want it moving in freeobj.
+	// Mark class as un-movable:
 	VALUE klass = (VALUE)key;
 	rb_gc_mark(klass);
 	
-	// Mark the wrapped Allocations VALUE (its own mark function will handle internal refs)
+	// Mark the wrapped Allocations VALUE:
 	VALUE allocations = (VALUE)value;
 	rb_gc_mark_movable(allocations);
 	
 	return ST_CONTINUE;
 }
 
-// GC mark function
 static void Memory_Profiler_Capture_mark(void *ptr) {
 	struct Memory_Profiler_Capture *capture = ptr;
 	
-	if (!capture) {
-		return;
-	}
-	
 	if (capture->tracked_classes) {
 		st_foreach(capture->tracked_classes, Memory_Profiler_Capture_tracked_classes_mark, 0);
 	}
-	
-	// Mark new objects in the queue:
-	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
-		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
-		rb_gc_mark_movable(newobj->klass);
-		rb_gc_mark_movable(newobj->allocations);
-		rb_gc_mark_movable(newobj->object);
-	}
-	
-	// Mark freed objects in the queue:
-	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
-		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
-		rb_gc_mark_movable(freed->klass);
-		rb_gc_mark_movable(freed->allocations);
-
-		if (freed->state) {
-			rb_gc_mark_movable(freed->state);
-		}
-	}
 }
 
-// GC free function
 static void Memory_Profiler_Capture_free(void *ptr) {
 	struct Memory_Profiler_Capture *capture = ptr;
 		
@@ -121,14 +61,9 @@ static void Memory_Profiler_Capture_free(void *ptr) {
 		st_free_table(capture->tracked_classes);
 	}
 	
-	// Free both queues (elements are stored directly, just free the queues)
-	Memory_Profiler_Queue_free(&capture->newobj_queue);
-	Memory_Profiler_Queue_free(&capture->freeobj_queue);
-	
 	xfree(capture);
 }
 
-// GC memsize function
 static size_t Memory_Profiler_Capture_memsize(const void *ptr) {
 	const struct Memory_Profiler_Capture *capture = ptr;
 	size_t size = sizeof(struct Memory_Profiler_Capture);
@@ -137,29 +72,24 @@ static size_t Memory_Profiler_Capture_memsize(const void *ptr) {
 		size += capture->tracked_classes->num_entries * (sizeof(st_data_t) + sizeof(struct Memory_Profiler_Capture_Allocations));
 	}
 	
-	// Add size of both queues (elements stored directly)
-	size += capture->newobj_queue.capacity * capture->newobj_queue.element_size;
-	size += capture->freeobj_queue.capacity * capture->freeobj_queue.element_size;
-	
 	return size;
 }
 
-// Foreach callback for st_foreach_with_replace (iteration logic)
+// Foreach callback for st_foreach_with_replace (iteration logic).
 static int Memory_Profiler_Capture_tracked_classes_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 (update logic)
+// 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
+	// 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 (its own compact function handles internal refs)
+	// Update wrapped Allocations VALUE if it moved:
 	VALUE old_allocations = (VALUE)*value;
 	VALUE new_allocations = rb_gc_location(old_allocations);
 	if (old_allocations != new_allocations) {
@@ -169,36 +99,15 @@ static int Memory_Profiler_Capture_tracked_classes_update(st_data_t *key, st_dat
 	return ST_CONTINUE;
 }
 
-// GC compact function - update VALUEs when GC compaction moves objects
 static void Memory_Profiler_Capture_compact(void *ptr) {
 	struct Memory_Profiler_Capture *capture = ptr;
 	
-	// Update tracked_classes keys and callback values in-place
+	// Update tracked_classes keys and allocations values in-place:
 	if (capture->tracked_classes && capture->tracked_classes->num_entries > 0) {
 		if (st_foreach_with_replace(capture->tracked_classes, Memory_Profiler_Capture_tracked_classes_foreach, Memory_Profiler_Capture_tracked_classes_update, 0)) {
 			rb_raise(rb_eRuntimeError, "tracked_classes modified during GC compaction");
 		}
 	}
-	
-	// Update new objects in the queue
-	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
-		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
-		
-		// Update all VALUEs if they moved during compaction
-		newobj->klass = rb_gc_location(newobj->klass);
-		newobj->allocations = rb_gc_location(newobj->allocations);
-		newobj->object = rb_gc_location(newobj->object);
-	}
-	
-	// Update freed objects in the queue
-	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
-		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
-		
-		// Update all VALUEs if they moved during compaction
-		freed->klass = rb_gc_location(freed->klass);
-		freed->allocations = rb_gc_location(freed->allocations);
-		freed->state = rb_gc_location(freed->state);
-	}
 }
 
 static const rb_data_type_t Memory_Profiler_Capture_type = {
@@ -230,174 +139,130 @@ const char *event_flag_name(rb_event_flag_t event_flag) {
 	}
 }
 
-// Postponed job callback - processes queued new and freed objects
-// This runs when it's safe to call Ruby code (not during allocation or GC)
-// IMPORTANT: Process newobj queue first, then freeobj queue to maintain order
-static void Memory_Profiler_Capture_process_queues(void *arg) {
-	VALUE self = (VALUE)arg;
+// 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) {
 	struct Memory_Profiler_Capture *capture;
-	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, 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);
 	
-	if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Processing queues: %zu newobj, %zu freeobj\n", 
-		capture->newobj_queue.count, capture->freeobj_queue.count);
+	// Ensure object_states table exists:
+	if (!record->object_states) {
+		record->object_states = st_init_numtable();
+	}
 	
-	// Disable tracking during queue processing to prevent infinite loop
-	// (rb_funcall can allocate, which would trigger more NEWOBJ events)
-	int was_enabled = capture->enabled;
-	capture->enabled = 0;
+	VALUE state;
 	
-	// First, process all new objects in the queue
-	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
-		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
-		VALUE klass = newobj->klass;
-		VALUE allocations = newobj->allocations;
-		VALUE object = newobj->object;
+	if (!NIL_P(record->callback)) {
+		// Temporarily disable queueing to prevent infinite loop:
+		int was_enabled = capture->enabled;
+		capture->enabled = 0;
 		
-		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
+		state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
+		
+		capture->enabled = was_enabled;
 		
-		// Call the Ruby callback with (klass, :newobj, nil) - callback returns state to store
-		if (!NIL_P(record->callback)) {
-			VALUE state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
+		if (DEBUG_STATE) fprintf(stderr, "Storing callback state for object: %p\n", (void *)object);
+	} else {
+		// No callback, store sentinel (Qnil):
+		state = Qnil;
+		
+		if (DEBUG_STATE) fprintf(stderr, "Storing sentinel (Qnil) for object: %p\n", (void *)object);
+	}
+	
+	// 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) {
+	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);
+	
+	// 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");
 			
-			// Store the state if callback returned something
-			if (!NIL_P(state)) {
-				if (!record->object_states) {
-					record->object_states = st_init_numtable();
-				}
+			// 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;
 				
-				if (DEBUG_STATE) fprintf(stderr, "Memory_Profiler_Capture_process_queues: Storing state for object: %p (%s)\n", 
-					(void *)object, rb_class2name(klass));
-
-				st_insert(record->object_states, (st_data_t)object, (st_data_t)state);
+				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);
 		}
 	}
-	
-	// Then, process all freed objects in the queue
-	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
-		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
-		VALUE klass = freed->klass;
-		VALUE allocations = freed->allocations;
-		VALUE state = freed->state;
-		
-		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
-		
-		// Call the Ruby callback with (klass, :freeobj, state)
-		if (!NIL_P(record->callback)) {
-			rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_freeobj, state);
-		}
+}
+
+// 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);
+			break;
+		case MEMORY_PROFILER_EVENT_TYPE_FREEOBJ:
+			Memory_Profiler_Capture_process_freeobj(event->capture, event->klass, event->allocations, event->object);
+			break;
 	}
-	
-	// Clear both queues (elements are reused on next cycle)
-	Memory_Profiler_Queue_clear(&capture->newobj_queue);
-	Memory_Profiler_Queue_clear(&capture->freeobj_queue);
-	
-	// Restore tracking state
-	capture->enabled = was_enabled;
 }
 
-// Handler for NEWOBJ event
-// SAFE: No longer calls Ruby code directly - queues for deferred processing
+#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)) {
-		VALUE allocations = (VALUE)allocations_data;
+		// Existing record, increment count:
+		allocations = (VALUE)allocations_data;
 		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
-		
-		// Always track counts (even during queue processing)
 		record->new_count++;
-		
-		// Only queue for callback if tracking is enabled (prevents infinite recursion)
-		if (capture->enabled && !NIL_P(record->callback)) {
-			// Push a new item onto the queue (returns pointer to write to)
-			// NOTE: realloc is safe during allocation (doesn't trigger Ruby allocation)
-			struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_push(&capture->newobj_queue);
-			if (newobj) {
-				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Queued newobj, queue size now: %zu/%zu\n", 
-					capture->newobj_queue.count, capture->newobj_queue.capacity);
-				
-				// Write VALUEs with write barriers (combines write + GC notification)
-				RB_OBJ_WRITE(self, &newobj->klass, klass);
-				RB_OBJ_WRITE(self, &newobj->allocations, allocations);
-				RB_OBJ_WRITE(self, &newobj->object, object);
-				
-				// Trigger postponed job to process the queue
-				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Triggering postponed job to process queues\n");
-				rb_postponed_job_trigger(capture->postponed_job_handle);
-			} else {
-				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Failed to queue newobj, out of memory\n");
-			}
-			// If push failed (out of memory), silently drop this newobj event
-		}
 	} else {
-		// Create record for this class (first time seeing it)
+		// 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;  // This is the first allocation
+		record->new_count = 1;
 		record->free_count = 0;
 		record->object_states = NULL;
 		
-		// Wrap the record in a VALUE
-		VALUE allocations = Memory_Profiler_Allocations_wrap(record);
-		
+		allocations = Memory_Profiler_Allocations_wrap(record);
 		st_insert(capture->tracked_classes, (st_data_t)klass, (st_data_t)allocations);
-		// Notify GC about the class VALUE stored as key in the table
 		RB_OBJ_WRITTEN(self, Qnil, klass);
-		// Notify GC about the allocations VALUE stored as value in the table
 		RB_OBJ_WRITTEN(self, Qnil, allocations);
 	}
+	
+	// Enqueue to global event queue:
+	Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_NEWOBJ, self, klass, allocations, object);
 }
 
-// Handler for FREEOBJ event
-// CRITICAL: This runs during GC when no Ruby code can be executed!
-// We MUST NOT call rb_funcall or any Ruby code here - just queue the work.
+// 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);
 		
-		// Always track counts (even during queue processing)
 		record->free_count++;
 		
-		// Only queue for callback if tracking is enabled and we have state
-		// Note: If NEWOBJ didn't queue (enabled=0), there's no state, so this naturally skips
-		if (capture->enabled && !NIL_P(record->callback) && record->object_states) {
-			if (DEBUG_STATE) fprintf(stderr, "Memory_Profiler_Capture_freeobj_handler: Looking up state for object: %p\n", (void *)object);
-
-			// Look up state stored during NEWOBJ
-			st_data_t state_data;
-			if (st_delete(record->object_states, (st_data_t *)&object, &state_data)) {
-				if (DEBUG_STATE) fprintf(stderr, "Found state for object: %p\n", (void *)object);
-				VALUE state = (VALUE)state_data;
-				
-				// Push a new item onto the queue (returns pointer to write to)
-				// NOTE: realloc is safe during GC (doesn't trigger Ruby allocation)
-				struct Memory_Profiler_Freeobj_Queue_Item *freeobj = Memory_Profiler_Queue_push(&capture->freeobj_queue);
-				if (freeobj) {
-					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Queued freed object, queue size now: %zu/%zu\n", 
-						capture->freeobj_queue.count, capture->freeobj_queue.capacity);
-					
-					// Write VALUEs with write barriers (combines write + GC notification)
-					// Note: We're during GC/FREEOBJ, but write barriers should be safe
-					RB_OBJ_WRITE(self, &freeobj->klass, klass);
-					RB_OBJ_WRITE(self, &freeobj->allocations, allocations);
-					RB_OBJ_WRITE(self, &freeobj->state, state);
-					
-					// Trigger postponed job to process both queues after GC
-					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Triggering postponed job to process queues after GC\n");
-					rb_postponed_job_trigger(capture->postponed_job_handle);
-				} else {
-					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Failed to queue freed object, out of memory\n");
-				}
-				// If push failed (out of memory), silently drop this freeobj event
-			}
-		}
+		// Enqueue to global event queue:
+		Memory_Profiler_Events_enqueue(MEMORY_PROFILER_EVENT_TYPE_FREEOBJ, self, klass, allocations, object);
 	}
 }
 
-// Check if object type is trackable (has valid class pointer and is a normal Ruby object)
-// Excludes internal types (T_IMEMO, T_NODE, T_ICLASS, etc.) that don't have normal classes
+// 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)) {
 		// Normal Ruby objects with valid class pointers
@@ -486,21 +351,7 @@ static VALUE Memory_Profiler_Capture_alloc(VALUE klass) {
 	capture->running = 0;
 	capture->enabled = 0;
 	
-	// Initialize both queues
-	Memory_Profiler_Queue_initialize(&capture->newobj_queue, sizeof(struct Memory_Profiler_Newobj_Queue_Item));
-	Memory_Profiler_Queue_initialize(&capture->freeobj_queue, sizeof(struct Memory_Profiler_Freeobj_Queue_Item));
-	
-	// Pre-register the postponed job for processing both queues
-	// The job will be triggered whenever we queue newobj or freeobj events
-	capture->postponed_job_handle = rb_postponed_job_preregister(
-		0, // flags
-		Memory_Profiler_Capture_process_queues,
-		(void *)obj
-	);
-	
-	if (capture->postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID) {
-		rb_raise(rb_eRuntimeError, "Failed to register postponed job!");
-	}
+	// Global event queue system will auto-initialize on first use (lazy initialization)
 	
 	return obj;
 }
@@ -517,6 +368,10 @@ static VALUE Memory_Profiler_Capture_start(VALUE self) {
 	
 	if (capture->running) return Qfalse;
 	
+	// Ensure global event queue system is initialized:
+	// It could fail and we want to raise an error if it does, here specifically.
+	Memory_Profiler_Events_instance();
+	
 	// Add event hook for NEWOBJ and FREEOBJ with RAW_ARG to get trace_arg
 	rb_add_event_hook2(
 		(rb_event_hook_func_t)Memory_Profiler_Capture_event_callback,
@@ -542,8 +397,9 @@ static VALUE Memory_Profiler_Capture_stop(VALUE self) {
 	// Remove event hook using same data (self) we registered with. No more events will be queued after this point:
 	rb_remove_event_hook_with_data((rb_event_hook_func_t)Memory_Profiler_Capture_event_callback, self);
 	
-	// Flush any pending queued events before stopping. This ensures all callbacks are invoked and object_states is properly maintained.
-	Memory_Profiler_Capture_process_queues((void *)self);
+	// Flush any pending queued events in the global queue before stopping.
+	// This ensures all callbacks are invoked and object_states is properly maintained.
+	Memory_Profiler_Events_process_all();
 	
 	// Clear both flags - we're no longer running and callbacks are disabled
 	capture->running = 0;
@@ -575,7 +431,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 = NULL;
+		record->object_states = st_init_numtable();
 		
 		// Wrap the record in a VALUE
 		allocations = Memory_Profiler_Allocations_wrap(record);
@@ -616,7 +472,6 @@ static VALUE Memory_Profiler_Capture_tracking_p(VALUE self, VALUE klass) {
 	return st_lookup(capture->tracked_classes, (st_data_t)klass, NULL) ? Qtrue : Qfalse;
 }
 
-
 // Get count of live objects for a specific class (O(1) lookup!)
 static VALUE Memory_Profiler_Capture_count_for(VALUE self, VALUE klass) {
 	struct Memory_Profiler_Capture *capture;
@@ -725,11 +580,7 @@ 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));
 	
-	// Queue sizes
-	rb_hash_aset(statistics, ID2SYM(rb_intern("newobj_queue_size")), SIZET2NUM(capture->newobj_queue.count));
-	rb_hash_aset(statistics, ID2SYM(rb_intern("newobj_queue_capacity")), SIZET2NUM(capture->newobj_queue.capacity));
-	rb_hash_aset(statistics, ID2SYM(rb_intern("freeobj_queue_size")), SIZET2NUM(capture->freeobj_queue.count));
-	rb_hash_aset(statistics, ID2SYM(rb_intern("freeobj_queue_capacity")), SIZET2NUM(capture->freeobj_queue.capacity));
+	// Note: Global event queue stats are internal to the events module
 	
 	// Count object_states entries for each tracked class
 	struct Memory_Profiler_Allocations_Statistics allocations_statistics = {

data/ext/memory/profiler/capture.h

@@ -5,5 +5,12 @@
 
 #include <ruby.h>
 
+// Initialize the Capture module.
 void Init_Memory_Profiler_Capture(VALUE Memory_Profiler);
 
+// Forward declaration.
+struct Memory_Profiler_Event;
+
+// Process a single event. Called from the global event queue processor.
+// This is wrapped with rb_protect to catch exceptions.
+void Memory_Profiler_Capture_process_event(struct Memory_Profiler_Event *event);

data/ext/memory/profiler/events.c

@@ -0,0 +1,209 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "ruby.h"
+#include "ruby/debug.h"
+
+#include "events.h"
+#include "capture.h"
+#include <stdio.h>
+
+enum {
+	DEBUG = 0,
+};
+
+// Internal structure for the global event queue system.
+struct Memory_Profiler_Events {
+	// Global event queue (contains events from all Capture instances).
+	struct Memory_Profiler_Queue queue;
+	
+	// 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;
+};
+
+static void Memory_Profiler_Events_process_queue(void *arg);
+static void Memory_Profiler_Events_mark(void *ptr);
+static void Memory_Profiler_Events_compact(void *ptr);
+static void Memory_Profiler_Events_free(void *ptr);
+static size_t Memory_Profiler_Events_memsize(const void *ptr);
+
+// TypedData definition for Events.
+static const rb_data_type_t Memory_Profiler_Events_type = {
+	"Memory::Profiler::Events",
+	{
+		.dmark = Memory_Profiler_Events_mark,
+		.dcompact = Memory_Profiler_Events_compact,
+		.dfree = Memory_Profiler_Events_free,
+		.dsize = Memory_Profiler_Events_memsize,
+	},
+	0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+// Create and initialize the global event queue system.
+static VALUE Memory_Profiler_Events_new(void) {
+	struct Memory_Profiler_Events *events;
+	VALUE obj = TypedData_Make_Struct(rb_cObject, struct Memory_Profiler_Events, &Memory_Profiler_Events_type, events);
+	
+	// Initialize the global event queue:
+	Memory_Profiler_Queue_initialize(&events->queue, sizeof(struct Memory_Profiler_Event));
+	
+	// Pre-register the single postponed job for processing the queue:
+	events->postponed_job_handle = rb_postponed_job_preregister(0,
+		// Callback function to process the queue:
+		Memory_Profiler_Events_process_queue,
+		// Pass the events struct as argument:
+		(void *)events
+	);
+	
+	if (events->postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID) {
+		rb_raise(rb_eRuntimeError, "Failed to register postponed job!");
+	}
+	
+	return obj;
+}
+
+// Get the global events instance (internal helper).
+struct Memory_Profiler_Events* Memory_Profiler_Events_instance(void) {
+	static VALUE instance = Qnil;
+	static struct Memory_Profiler_Events *events = NULL;
+
+	if (instance == Qnil) {
+		instance = Memory_Profiler_Events_new();
+		
+		// Pin the global events object so it's never GC'd:
+		rb_gc_register_mark_object(instance);
+		
+		if (DEBUG) fprintf(stderr, "Global event queue system initialized and pinned\n");
+		
+		TypedData_Get_Struct(instance, struct Memory_Profiler_Events, &Memory_Profiler_Events_type, events);
+	}
+	
+	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);
+		
+		// Mark the Capture instance this event belongs to:
+		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).
+		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) {
+	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);
+		
+		// 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).
+		if (event->type == MEMORY_PROFILER_EVENT_TYPE_NEWOBJ) {
+			event->object = rb_gc_location(event->object);
+		}
+	}
+}
+
+// GC free callback.
+static void Memory_Profiler_Events_free(void *ptr) {
+	struct Memory_Profiler_Events *events = ptr;
+	Memory_Profiler_Queue_free(&events->queue);
+}
+
+// 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);
+}
+
+// Enqueue an event to the global queue.
+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);
+	if (event) {
+		event->type = type;
+		event->capture = capture;
+		event->klass = klass;
+		event->allocations = allocations;
+		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);
+		
+		rb_postponed_job_trigger(events->postponed_job_handle);
+		// Success:
+		return 1;
+	}
+
+	// Queue full:
+	return 0;
+}
+
+// Process all queued events immediately (flush the queue).
+// Public API function - called from Capture stop() to ensure all events are processed.
+void Memory_Profiler_Events_process_all(void) {
+	struct Memory_Profiler_Events *events = Memory_Profiler_Events_instance();
+	Memory_Profiler_Events_process_queue((void *)events);
+}
+
+// Wrapper for rb_protect - processes a single event.
+// rb_protect requires signature: VALUE func(VALUE arg).
+static VALUE Memory_Profiler_Events_process_event_protected(VALUE arg) {
+	struct Memory_Profiler_Event *event = (struct Memory_Profiler_Event *)arg;
+	Memory_Profiler_Capture_process_event(event);
+	return Qnil;
+}
+
+// Postponed job callback - processes global event queue.
+// This runs when it's safe to call Ruby code (not during allocation or GC).
+// Processes events from ALL Capture instances.
+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);
+	
+	// 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);
+		
+		// Process event with rb_protect to catch any exceptions:
+		int state = 0;
+		rb_protect(Memory_Profiler_Events_process_event_protected, (VALUE)event, &state);
+		
+		if (state) {
+			// Exception occurred, warn and suppress:
+			rb_warning("Exception in event processing callback (caught and suppressed): %"PRIsVALUE, rb_errinfo());
+			rb_set_errinfo(Qnil);
+		}
+	}
+	
+	// Always clear the global queue, even if exceptions occurred:
+	Memory_Profiler_Queue_clear(&events->queue);
+}

data/ext/memory/profiler/events.h

@@ -0,0 +1,48 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+#include "queue.h"
+
+// Event types
+enum Memory_Profiler_Event_Type {
+	MEMORY_PROFILER_EVENT_TYPE_NEWOBJ,
+	MEMORY_PROFILER_EVENT_TYPE_FREEOBJ,
+};
+
+// Event queue item - stores all info needed to process an event
+struct Memory_Profiler_Event {
+	enum Memory_Profiler_Event_Type type;
+	
+	// Which Capture instance this event belongs to:
+	VALUE capture;
+	
+	// The class of the object:
+	VALUE klass;
+
+	// The Allocations wrapper:
+	VALUE allocations;
+
+	// The object itself:
+	VALUE object;
+};
+
+struct Memory_Profiler_Events;
+
+struct Memory_Profiler_Events* Memory_Profiler_Events_instance(void);
+
+// Enqueue an event to the global queue.
+// Returns non-zero on success, zero on failure.
+int Memory_Profiler_Events_enqueue(
+	enum Memory_Profiler_Event_Type type,
+	VALUE capture,
+	VALUE klass,
+	VALUE allocations,
+	VALUE object
+);
+
+// Process all queued events immediately (flush the queue)
+// Called from Capture stop() to ensure all events are processed before stopping
+void Memory_Profiler_Events_process_all(void);

data/lib/memory/profiler/call_tree.rb

@@ -79,7 +79,7 @@ module Memory
 					end
 					
 					# Now recursively prune the retained children (avoid pruning nodes we just discarded)
-					@children.each_value {|child| pruned_count += child.prune!(limit)}
+					@children.each_value{|child| pruned_count += child.prune!(limit)}
 					
 					# Clean up if we ended up with no children
 					@children = nil if @children.empty?
@@ -98,7 +98,7 @@ module Memory
 					
 					# Recursively detach all children first and sum their counts
 					if @children
-						@children.each_value {|child| count += child.detach!}
+						@children.each_value{|child| count += child.detach!}
 					end
 					
 					# Break all references
@@ -192,13 +192,13 @@ module Memory
 				
 				@root.each_path do |path, total_count, retained_count|
 					# Filter out root node (has nil location) and map to location strings
-					locations = path.select(&:location).map {|node| node.location.to_s}
+					locations = path.select(&:location).map{|node| node.location.to_s}
 					paths << [locations, total_count, retained_count] unless locations.empty?
 				end
 				
 				# Sort by the requested metric (default: retained, since that's what matters for leaks)
 				sort_index = (by == :total) ? 1 : 2
-				paths.sort_by {|path_data| -path_data[sort_index]}.first(limit)
+				paths.sort_by{|path_data| -path_data[sort_index]}.first(limit)
 			end
 			
 			# Get hotspot locations (individual frames with highest counts).
@@ -207,13 +207,13 @@ module Memory
 			# @parameter by [Symbol] Sort by :total or :retained count.
 			# @returns [Hash] Map of location => [total_count, retained_count].
 			def hotspots(limit = 20, by: :retained)
-				frames = Hash.new {|h, k| h[k] = [0, 0]}
+				frames = Hash.new{|h, k| h[k] = [0, 0]}
 				
 				collect_frames(@root, frames)
 				
 				# Sort by the requested metric
 				sort_index = (by == :total) ? 0 : 1
-				frames.sort_by {|_, counts| -counts[sort_index]}.first(limit).to_h
+				frames.sort_by{|_, counts| -counts[sort_index]}.first(limit).to_h
 			end
 			
 			# Total number of allocations tracked.
@@ -255,7 +255,7 @@ module Memory
 					frames[location_str][1] += node.retained_count
 				end
 				
-				node.each_child {|child| collect_frames(child, frames)}
+				node.each_child{|child| collect_frames(child, frames)}
 			end
 		end
 	end

data/lib/memory/profiler/sampler.rb

@@ -102,28 +102,28 @@ module Memory
 				@call_trees = {}
 				@samples = {}
 			end
-
+			
 			# @attribute [Integer] The depth of the call tree.
 			attr :depth
 			
 			# @attribute [Proc] The filter to exclude frames from call paths.
 			attr :filter
-
+			
 			# @attribute [Integer] The number of increases before enabling detailed tracking.
 			attr :increases_threshold
-
+			
 			# @attribute [Integer] The number of insertions before auto-pruning (nil = no auto-pruning).
 			attr :prune_limit
-
+			
 			# @attribute [Integer | Nil] The number of insertions before auto-pruning (nil = no auto-pruning).
 			attr :prune_threshold
-
+			
 			# @attribute [Capture] The capture object.
 			attr :capture
-
+			
 			# @attribute [Hash] The call trees.
 			attr :call_trees
-
+			
 			# @attribute [Hash] The samples for each class being tracked.
 			attr :samples
 			
@@ -249,11 +249,11 @@ module Memory
 					live_count: @capture.count_for(klass),
 					total_allocations: tree.total_allocations,
 					retained_allocations: tree.retained_allocations,
-					top_paths: tree.top_paths(10).map {|path, total, retained| 
-						{ path: path, total_count: total, retained_count: retained }
+					top_paths: tree.top_paths(10).map{|path, total, retained| 
+						{path: path, total_count: total, retained_count: retained}
 					},
-					hotspots: tree.hotspots(20).transform_values {|total, retained|
-						{ total_count: total, retained_count: retained }
+					hotspots: tree.hotspots(20).transform_values{|total, retained|
+						{total_count: total, retained_count: retained}
 					}
 				}
 			end

data/lib/memory/profiler/version.rb

@@ -7,7 +7,7 @@
 module Memory
 	# @namespace
 	module Profiler
-		VERSION = "1.1.7"
+		VERSION = "1.1.8"
 	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.8
+
+  - Use single global queue for event handling to avoid incorrect ordering.
+
 ### v1.1.7
 
   - Expose `Capture#statistics` for debugging internal memory tracking state.

data/releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## v1.1.8
+
+  - Use single global queue for event handling to avoid incorrect ordering.
+
 ## v1.1.7
 
   - Expose `Capture#statistics` for debugging internal memory tracking state.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memory-profiler
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 1.1.8
 platform: ruby
 authors:
 - Samuel Williams
@@ -51,6 +51,8 @@ files:
 - ext/memory/profiler/allocations.h
 - ext/memory/profiler/capture.c
 - ext/memory/profiler/capture.h
+- ext/memory/profiler/events.c
+- ext/memory/profiler/events.h
 - ext/memory/profiler/profiler.c
 - ext/memory/profiler/queue.h
 - lib/memory/profiler.rb