memory-profiler 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e818941dde11b9247c4451e48d59ded21116b7cbcd40d1885b200f9124a1adf4
-  data.tar.gz: 1ad6e8a133b29d3fa6011c5f21c5b15dca3a2b1f3c8839f5294bce46a578d82e
+  metadata.gz: 06ea6c4892f9d17ac8fa69ba374d2a6a94ab8b809be840b26cb544b18b529edc
+  data.tar.gz: a1c283a60721f988cac65878551eba4472a4dd889649d42b1409ba9a7b8b6756
 SHA512:
-  metadata.gz: f8d61cf642ed4fd9d0b0f6ceae5f3e09f53351df3f134245870edce7d1fbc7eea2ca82b87aa92abc9d7308444a4a0be5aaadadb4d7d613840e05ec34df022117
-  data.tar.gz: d67925a5753683b75eca7b49a861038cb28d52a537a04c459cb8808ddcb1c582f3512ecccbd922bd31f649101f3b726f3e60c5e6f5cf3072f25b5ee2a55e5a77
+  metadata.gz: 22a34ac3cd4ad0c0eead78deef38cd79f20f6c96338f0af5eff191a3d2f2d99ea7dc44a40993838ead2678cb52a257fbed2548e08248e5e389277801c5895cae
+  data.tar.gz: 49d267900c65e5481b6d784766e17721ba9919b984dcaf84737022622f4bbb9379773a0c98166a5d2b767192c787dd9fd13a8c43e98db3abd8d3dcb86aec74c5

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"]
+$srcs = ["memory/profiler/profiler.c", "memory/profiler/capture.c", "memory/profiler/allocations.c"]
 $VPATH << "$(srcdir)/memory/profiler"
 
 # Check for required headers

data/ext/memory/profiler/allocations.c

@@ -0,0 +1,179 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "allocations.h"
+
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "ruby/st.h"
+#include <stdio.h>
+
+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) {
+	VALUE object = (VALUE)key;
+	rb_gc_mark_movable(object);
+
+	VALUE state = (VALUE)value;
+	if (!NIL_P(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) {
+	// 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;
+	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;
+	}
+	
+	// Update value if it moved
+	if (old_state != new_state) {
+		*value = (st_data_t)new_state;
+	}
+	
+	return ST_CONTINUE;
+}
+
+// GC mark function for Allocations
+static void Memory_Profiler_Allocations_mark(void *ptr) {
+	struct Memory_Profiler_Capture_Allocations *record = ptr;
+	
+	if (!record) {
+		return;
+	}
+	
+	if (!NIL_P(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);
+	}
+}
+
+// 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);
+	}
+	
+	xfree(record);
+}
+
+// GC compact function for Allocations
+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);
+	}
+	
+	// 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");
+		}
+	}
+}
+
+static const rb_data_type_t Memory_Profiler_Allocations_type = {
+	"Memory::Profiler::Allocations",
+	{
+		.dmark = Memory_Profiler_Allocations_mark,
+		.dcompact = Memory_Profiler_Allocations_compact,
+		.dfree = Memory_Profiler_Allocations_free,
+	},
+	0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+// Wrap an allocations record
+VALUE Memory_Profiler_Allocations_wrap(struct Memory_Profiler_Capture_Allocations *record) {
+	return TypedData_Wrap_Struct(Memory_Profiler_Allocations, &Memory_Profiler_Allocations_type, record);
+}
+
+// Get allocations record from wrapper
+struct Memory_Profiler_Capture_Allocations* Memory_Profiler_Allocations_get(VALUE self) {
+	struct Memory_Profiler_Capture_Allocations *record;
+	TypedData_Get_Struct(self, struct Memory_Profiler_Capture_Allocations, &Memory_Profiler_Allocations_type, record);
+	return record;
+}
+
+// Allocations#new_count
+static VALUE Memory_Profiler_Allocations_new_count(VALUE self) {
+	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(self);
+	return SIZET2NUM(record->new_count);
+}
+
+// Allocations#free_count
+static VALUE Memory_Profiler_Allocations_free_count(VALUE self) {
+	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(self);
+	return SIZET2NUM(record->free_count);
+}
+
+// Allocations#retained_count
+static VALUE Memory_Profiler_Allocations_retained_count(VALUE self) {
+	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(self);
+	// Handle underflow when free_count > new_count
+	size_t retained = record->free_count > record->new_count ? 0 : record->new_count - record->free_count;
+	return SIZET2NUM(retained);
+}
+
+// Allocations#track { |klass| ... }
+static VALUE Memory_Profiler_Allocations_track(int argc, VALUE *argv, VALUE self) {
+	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(self);
+	
+	VALUE callback;
+	rb_scan_args(argc, argv, "&", &callback);
+	
+	// Use write barrier - self (Allocations wrapper) keeps Capture alive, which keeps callback alive
+	RB_OBJ_WRITE(self, &record->callback, callback);
+	
+	return self;
+}
+
+// Clear/reset allocation counts and state for a record
+void Memory_Profiler_Allocations_clear(VALUE allocations) {
+	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
+	record->new_count = 0;   // Reset allocation count
+	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;
+	}
+}
+
+void Init_Memory_Profiler_Allocations(VALUE Memory_Profiler)
+{
+	// Allocations class - wraps allocation data for a specific class
+	Memory_Profiler_Allocations = rb_define_class_under(Memory_Profiler, "Allocations", rb_cObject);
+	
+	// Allocations objects are only created internally via wrap, never from Ruby:
+	rb_undef_alloc_func(Memory_Profiler_Allocations);
+	
+	rb_define_method(Memory_Profiler_Allocations, "new_count", Memory_Profiler_Allocations_new_count, 0);
+	rb_define_method(Memory_Profiler_Allocations, "free_count", Memory_Profiler_Allocations_free_count, 0);
+	rb_define_method(Memory_Profiler_Allocations, "retained_count", Memory_Profiler_Allocations_retained_count, 0);
+	rb_define_method(Memory_Profiler_Allocations, "track", Memory_Profiler_Allocations_track, -1);  // -1 to accept block
+}

data/ext/memory/profiler/allocations.h

@@ -0,0 +1,31 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include "ruby.h"
+#include "ruby/st.h"
+
+// 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
+	
+	// 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
+VALUE Memory_Profiler_Allocations_wrap(struct Memory_Profiler_Capture_Allocations *record);
+
+// 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
+void Memory_Profiler_Allocations_clear(VALUE allocations);
+
+// Initialize the Allocations class
+void Init_Memory_Profiler_Allocations(VALUE Memory_Profiler);

data/ext/memory/profiler/capture.c

@@ -2,6 +2,7 @@
 // Copyright, 2025, by Samuel Williams.
 
 #include "capture.h"
+#include "allocations.h"
 
 #include "ruby.h"
 #include "ruby/debug.h"
@@ -14,57 +15,29 @@ enum {
 };
 
 static VALUE Memory_Profiler_Capture = Qnil;
-static VALUE Memory_Profiler_Allocations = Qnil;
 
 // Event symbols
 static VALUE sym_newobj;
 static VALUE sym_freeobj;
 
-// 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
-	
-	// For detailed tracking: map object (VALUE) => state (VALUE)
-	// State is returned from callback on :newobj and passed back on :freeobj
-	st_table *object_states;
-};
-
 // Main capture state
 struct Memory_Profiler_Capture {
-	// class => Memory_Profiler_Capture_Allocations.
+	// class => VALUE (wrapped Memory_Profiler_Capture_Allocations).
 	st_table *tracked_classes;
 
 	// Is tracking enabled (via start/stop):
 	int enabled;
 };
 
-// Helper to mark object_states table values
-static int Memory_Profiler_Capture_mark_state(st_data_t key, st_data_t value, st_data_t arg) {
-	// key is VALUE (object) - don't mark it, we're just using it as a key
-	// value is VALUE (state) - mark it as movable
-	rb_gc_mark_movable((VALUE)value);
-	return ST_CONTINUE;
-}
-
 // GC mark callback for tracked_classes table
-static int Memory_Profiler_Capture_mark_class(st_data_t key, st_data_t value, st_data_t arg) {
-	VALUE klass = (VALUE)key;
-	
+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.
+	VALUE klass = (VALUE)key;
 	rb_gc_mark(klass);
 	
-	struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)value;
-	if (!NIL_P(record->callback)) {
-		rb_gc_mark_movable(record->callback);  // Mark callback as movable
-	}
-	
-	// Mark object_states table if it exists
-	if (record->object_states) {
-		st_foreach(record->object_states, Memory_Profiler_Capture_mark_state, 0);
-	}
+	// Mark the wrapped Allocations VALUE (its own mark function will handle internal refs)
+	VALUE allocations = (VALUE)value;
+	rb_gc_mark_movable(allocations);
 	
 	return ST_CONTINUE;
 }
@@ -78,29 +51,15 @@ static void Memory_Profiler_Capture_mark(void *ptr) {
 	}
 	
 	if (capture->tracked_classes) {
-		st_foreach(capture->tracked_classes, Memory_Profiler_Capture_mark_class, 0);
+		st_foreach(capture->tracked_classes, Memory_Profiler_Capture_tracked_classes_mark, 0);
 	}
 }
 
-// Iterator to free each class record
-static int Memory_Profiler_Capture_free_class_record(st_data_t key, st_data_t value, st_data_t arg) {
-	struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)value;
-	if (record->object_states) {
-		st_free_table(record->object_states);
-	}
-	xfree(record);
-	return ST_CONTINUE;
-}
-
 // GC free function
 static void Memory_Profiler_Capture_free(void *ptr) {
 	struct Memory_Profiler_Capture *capture = ptr;
-	
-	// Event hooks must be removed via stop() before object is freed
-	// Ruby will automatically remove hooks when the VALUE is GC'd
-	
+		
 	if (capture->tracked_classes) {
-		st_foreach(capture->tracked_classes, Memory_Profiler_Capture_free_class_record, 0);
 		st_free_table(capture->tracked_classes);
 	}
 	
@@ -119,9 +78,14 @@ static size_t Memory_Profiler_Capture_memsize(const void *ptr) {
 	return size;
 }
 
+// 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;
+}
 
-// Callback for st_foreach_with_replace to update class keys and callback values
-static int Memory_Profiler_Capture_update_refs(st_data_t *key, st_data_t *value, st_data_t argp, int existing) {
+// 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);
@@ -129,14 +93,11 @@ static int Memory_Profiler_Capture_update_refs(st_data_t *key, st_data_t *value,
 		*key = (st_data_t)new_klass;
 	}
 	
-	// Update callback if it moved
-	struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)*value;
-	if (!NIL_P(record->callback)) {
-		VALUE old_callback = record->callback;
-		VALUE new_callback = rb_gc_location(old_callback);
-		if (old_callback != new_callback) {
-			record->callback = new_callback;
-		}
+	// Update wrapped Allocations VALUE if it moved (its own compact function handles internal refs)
+	VALUE old_allocations = (VALUE)*value;
+	VALUE new_allocations = rb_gc_location(old_allocations);
+	if (old_allocations != new_allocations) {
+		*value = (st_data_t)new_allocations;
 	}
 	
 	return ST_CONTINUE;
@@ -148,7 +109,7 @@ static void Memory_Profiler_Capture_compact(void *ptr) {
 	
 	// Update tracked_classes keys and callback values in-place
 	if (capture->tracked_classes && capture->tracked_classes->num_entries > 0) {
-		if (st_foreach_with_replace(capture->tracked_classes, NULL, Memory_Profiler_Capture_update_refs, 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");
 		}
 	}
@@ -184,10 +145,11 @@ const char *event_flag_name(rb_event_flag_t event_flag) {
 }
 
 // Handler for NEWOBJ event
-static void Memory_Profiler_Capture_newobj_handler(struct Memory_Profiler_Capture *capture, VALUE klass, VALUE object) {
-	st_data_t record_data;
-	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &record_data)) {
-		struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)record_data;
+static void Memory_Profiler_Capture_newobj_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->new_count++;
 		if (!NIL_P(record->callback)) {
 			// Invoke callback - runs during NEWOBJ with GC disabled
@@ -207,6 +169,8 @@ static void Memory_Profiler_Capture_newobj_handler(struct Memory_Profiler_Captur
 					record->object_states = st_init_numtable();
 				}
 				st_insert(record->object_states, (st_data_t)object, (st_data_t)state);
+				// Notify GC about the state VALUE stored in the table
+				RB_OBJ_WRITTEN(self, Qnil, state);
 			}
 		}
 	} else {
@@ -216,15 +180,24 @@ static void Memory_Profiler_Capture_newobj_handler(struct Memory_Profiler_Captur
 		record->new_count = 1;  // This is the first allocation
 		record->free_count = 0;
 		record->object_states = NULL;
-		st_insert(capture->tracked_classes, (st_data_t)klass, (st_data_t)record);
+		
+		// Wrap the record in a VALUE
+		VALUE 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);
 	}
 }
 
 // Handler for FREEOBJ event
-static void Memory_Profiler_Capture_freeobj_handler(struct Memory_Profiler_Capture *capture, VALUE klass, VALUE object) {
-	st_data_t record_data;
-	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &record_data)) {
-		struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)record_data;
+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++;
 		if (!NIL_P(record->callback) && record->object_states) {
 			// Look up state stored during NEWOBJ
@@ -299,10 +272,10 @@ static void Memory_Profiler_Capture_event_callback(VALUE data, void *ptr) {
 	
 	if (event_flag == RUBY_INTERNAL_EVENT_NEWOBJ) {
 		// self is the newly allocated object
-		Memory_Profiler_Capture_newobj_handler(capture, klass, object);
+		Memory_Profiler_Capture_newobj_handler(data, capture, klass, object);
 	} else if (event_flag == RUBY_INTERNAL_EVENT_FREEOBJ) {
 		// self is the object being freed
-		Memory_Profiler_Capture_freeobj_handler(capture, klass, object);
+		Memory_Profiler_Capture_freeobj_handler(data, capture, klass, object);
 	}
 }
 
@@ -376,9 +349,10 @@ static VALUE Memory_Profiler_Capture_track(int argc, VALUE *argv, VALUE self) {
 	VALUE klass, callback;
 	rb_scan_args(argc, argv, "1&", &klass, &callback);
 		
-	st_data_t record_data;
-	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &record_data)) {
-		struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)record_data;
+	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);
 		RB_OBJ_WRITE(self, &record->callback, callback);
 	} else {
 		struct Memory_Profiler_Capture_Allocations *record = ALLOC(struct Memory_Profiler_Capture_Allocations);
@@ -386,7 +360,15 @@ static VALUE Memory_Profiler_Capture_track(int argc, VALUE *argv, VALUE self) {
 		record->new_count = 0;
 		record->free_count = 0;
 		record->object_states = NULL;
-		st_insert(capture->tracked_classes, (st_data_t)klass, (st_data_t)record);
+		
+		// Wrap the record in a VALUE
+		VALUE 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);
 		// Now inform GC about the callback reference
 		if (!NIL_P(callback)) {
 			RB_OBJ_WRITTEN(self, Qnil, callback);
@@ -401,10 +383,10 @@ static VALUE Memory_Profiler_Capture_untrack(VALUE self, VALUE klass) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	st_data_t record_data;
-	if (st_delete(capture->tracked_classes, (st_data_t *)&klass, &record_data)) {
-		struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)record_data;
-		xfree(record);
+	st_data_t allocations_data;
+	if (st_delete(capture->tracked_classes, (st_data_t *)&klass, &allocations_data)) {
+		// The wrapped Allocations VALUE will be GC'd naturally
+		// No manual cleanup needed
 	}
 	
 	return self;
@@ -424,9 +406,10 @@ static VALUE Memory_Profiler_Capture_count_for(VALUE self, VALUE klass) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	st_data_t record_data;
-	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &record_data)) {
-		struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)record_data;
+	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);
 		// 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) {
@@ -439,18 +422,11 @@ static VALUE Memory_Profiler_Capture_count_for(VALUE self, VALUE klass) {
 	return INT2FIX(0);
 }
 
-// Iterator to free and reset each class record
-static int Memory_Profiler_Capture_reset_class(st_data_t key, st_data_t value, st_data_t arg) {
-	struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)value;
-	record->new_count = 0;   // Reset allocation count
-	record->free_count = 0;  // Reset free count
-	record->callback = Qnil; // Clear callback
+// Iterator to reset each class record
+static int Memory_Profiler_Capture_tracked_classes_clear(st_data_t key, st_data_t value, st_data_t arg) {
+	VALUE allocations = (VALUE)value;
 	
-	// Clear object states
-	if (record->object_states) {
-		st_free_table(record->object_states);
-		record->object_states = NULL;
-	}
+	Memory_Profiler_Allocations_clear(allocations);
 	
 	return ST_CONTINUE;
 }
@@ -460,60 +436,8 @@ 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)
-	st_foreach(capture->tracked_classes, Memory_Profiler_Capture_reset_class, 0);
-	
-	return self;
-}
-
-// TypedData for Allocations wrapper - just wraps the record pointer
-static const rb_data_type_t Memory_Profiler_Allocations_type = {
-	"Memory::Profiler::Allocations",
-	{NULL, NULL, NULL},  // No mark/free needed - record is owned by Capture
-	0, 0, 0
-};
-
-// Wrap an allocations record
-static VALUE Memory_Profiler_Allocations_wrap(struct Memory_Profiler_Capture_Allocations *record) {
-	return TypedData_Wrap_Struct(Memory_Profiler_Allocations, &Memory_Profiler_Allocations_type, record);
-}
-
-// Get allocations record from wrapper
-static struct Memory_Profiler_Capture_Allocations* Memory_Profiler_Allocations_get(VALUE self) {
-	struct Memory_Profiler_Capture_Allocations *record;
-	TypedData_Get_Struct(self, struct Memory_Profiler_Capture_Allocations, &Memory_Profiler_Allocations_type, record);
-	return record;
-}
-
-// Allocations#new_count
-static VALUE Memory_Profiler_Allocations_new_count(VALUE self) {
-	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(self);
-	return SIZET2NUM(record->new_count);
-}
-
-// Allocations#free_count
-static VALUE Memory_Profiler_Allocations_free_count(VALUE self) {
-	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(self);
-	return SIZET2NUM(record->free_count);
-}
-
-// Allocations#retained_count
-static VALUE Memory_Profiler_Allocations_retained_count(VALUE self) {
-	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(self);
-	// Handle underflow when free_count > new_count
-	size_t retained = record->free_count > record->new_count ? 0 : record->new_count - record->free_count;
-	return SIZET2NUM(retained);
-}
-
-// Allocations#track { |klass| ... }
-static VALUE Memory_Profiler_Allocations_track(int argc, VALUE *argv, VALUE self) {
-	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(self);
-	
-	VALUE callback;
-	rb_scan_args(argc, argv, "&", &callback);
-	
-	// Use write barrier - self (Allocations wrapper) keeps Capture alive, which keeps callback alive
-	RB_OBJ_WRITE(self, &record->callback, callback);
+	// 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);
 	
 	return self;
 }
@@ -521,10 +445,7 @@ static VALUE Memory_Profiler_Allocations_track(int argc, VALUE *argv, VALUE self
 // Iterator callback for each
 static int Memory_Profiler_Capture_each_allocation(st_data_t key, st_data_t value, st_data_t arg) {
 	VALUE klass = (VALUE)key;
-	struct Memory_Profiler_Capture_Allocations *record = (struct Memory_Profiler_Capture_Allocations *)value;
-	
-	// Wrap the allocations record
-	VALUE allocations = Memory_Profiler_Allocations_wrap(record);
+	VALUE allocations = (VALUE)value;  // Already a wrapped VALUE
 	
 	// Yield class and allocations wrapper
 	rb_yield_values(2, klass, allocations);
@@ -565,12 +486,6 @@ void Init_Memory_Profiler_Capture(VALUE Memory_Profiler)
 	rb_define_method(Memory_Profiler_Capture, "each", Memory_Profiler_Capture_each, 0);
 	rb_define_method(Memory_Profiler_Capture, "clear", Memory_Profiler_Capture_clear, 0);
 	
-	// Allocations class - wraps allocation data for a specific class
-	Memory_Profiler_Allocations = rb_define_class_under(Memory_Profiler, "Allocations", rb_cObject);
-	
-	rb_define_method(Memory_Profiler_Allocations, "new_count", Memory_Profiler_Allocations_new_count, 0);
-	rb_define_method(Memory_Profiler_Allocations, "free_count", Memory_Profiler_Allocations_free_count, 0);
-	rb_define_method(Memory_Profiler_Allocations, "retained_count", Memory_Profiler_Allocations_retained_count, 0);
-	rb_define_method(Memory_Profiler_Allocations, "track", Memory_Profiler_Allocations_track, -1);  // -1 to accept block
+	// Initialize Allocations class
+	Init_Memory_Profiler_Allocations(Memory_Profiler);
 }
-

data/lib/memory/profiler/version.rb

@@ -7,7 +7,7 @@
 module Memory
 	# @namespace
 	module Profiler
-		VERSION = "1.1.1"
+		VERSION = "1.1.2"
 	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.2
+
+    - Fix handling of GC compaction (I hope).
+
 ### v0.1.0
 
   - Initial implementation.

data/releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## v1.1.2
+
+    - Fix handling of GC compaction (I hope).
+
 ## v0.1.0
 
   - Initial implementation.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memory-profiler
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Samuel Williams
@@ -46,6 +46,8 @@ files:
 - context/getting-started.md
 - context/index.yaml
 - ext/extconf.rb
+- ext/memory/profiler/allocations.c
+- ext/memory/profiler/allocations.h
 - ext/memory/profiler/capture.c
 - ext/memory/profiler/capture.h
 - ext/memory/profiler/profiler.c