memory-profiler 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b936617787e483bcf790aee25bb224bf10a199f431dbb8ac51eff005504a44d4
-  data.tar.gz: 587f38cef39c639c9d9e2efbffdd325cffdfbd3000dddbca46f5aba895a66a21
+  metadata.gz: 8a65991a6612d28ede2c4ab5652bcf410e7edf92a0f98e8bdeebd921b64232d6
+  data.tar.gz: 230a10b0d5ed42f74d19007534dbae1ee49df3c67d0507fcf42a0fc67b1cf5e3
 SHA512:
-  metadata.gz: c483112cf1dd1c82ea679afe3b86007bf20b2674558ac676fc2c66cd07f651787a09198b9f49fb3dd28f1f9b64865dfac9cc249d91b6b819e3849e0cc9c9ab0b
-  data.tar.gz: 0de0b5d28eb0f5af2b72ec0aa44ceaf8d0401822949ee4512f922b6caa730e1d69a6b2997fac633140168b3b8de93bdbf4c76223ae6ef789520ae5566ef23f08
+  metadata.gz: 7b64a8a6b0a500f84c52689aa5affad466d19e3ddc723db2014af3ef784fe35b7d6704aa2bf363f27c23d8fe75e27bdef5c7e969736a2bedcfc925467dd3e16a
+  data.tar.gz: da48ff77a1915aaa978ce162b6c44d310b6b4a77af59b6df18c3e6fc92b19aa40df99473bb461dafd0a160ded3c5721681cce3e22dece393d484c0b2c51e67b4

data/ext/memory/profiler/capture.c

@@ -20,7 +20,6 @@ static VALUE Memory_Profiler_Capture = Qnil;
 // Event symbols:
 static VALUE sym_newobj, sym_freeobj;
 
-
 // Main capture state (per-instance).
 struct Memory_Profiler_Capture {
 	// Master switch - is tracking active? (set by start/stop).
@@ -29,6 +28,9 @@ struct Memory_Profiler_Capture {
 	// Should we queue callbacks? (temporarily disabled during queue processing).
 	int paused;
 
+	// Should we automatically track all classes? (if false, only explicitly tracked classes are tracked).
+	int track_all;
+
 	// Tracked classes: class => VALUE (wrapped Memory_Profiler_Capture_Allocations).
 	st_table *tracked;
 	
@@ -164,21 +166,18 @@ static void Memory_Profiler_Capture_process_newobj(VALUE self, VALUE klass, VALU
 	// Pause the capture to prevent infinite loop:
 	capture->paused += 1;
 	
-	// Increment global new count:
-	capture->new_count++;
-	
-	// Look up or create allocations record for this class:
+	// Look up allocations record for this class:
 	st_data_t allocations_data;
 	VALUE allocations;
 	struct Memory_Profiler_Capture_Allocations *record;
 	
 	if (st_lookup(capture->tracked, (st_data_t)klass, &allocations_data)) {
-		// Existing record
+		// Existing record - class is explicitly tracked
 		allocations = (VALUE)allocations_data;
 		record = Memory_Profiler_Allocations_get(allocations);
 		record->new_count++;
-	} else {
-		// First time seeing this class, create record automatically
+	} else if (capture->track_all) {
+		// First time seeing this class, create record automatically (if track_all is enabled)
 		record = ALLOC(struct Memory_Profiler_Capture_Allocations);
 		record->callback = Qnil;
 		record->new_count = 1;
@@ -188,8 +187,15 @@ static void Memory_Profiler_Capture_process_newobj(VALUE self, VALUE klass, VALU
 		st_insert(capture->tracked, (st_data_t)klass, (st_data_t)allocations);
 		RB_OBJ_WRITTEN(self, Qnil, klass);
 		RB_OBJ_WRITTEN(self, Qnil, allocations);
+	} else {
+		// track_all disabled and class not explicitly tracked - skip this allocation entirely
+		capture->paused -= 1;
+		return;
 	}
 	
+	// Increment global new count (only if we're tracking this class):
+	capture->new_count++;
+	
 	VALUE data = Qnil;
 	if (!NIL_P(record->callback)) {
 		data = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
@@ -199,7 +205,6 @@ static void Memory_Profiler_Capture_process_newobj(VALUE self, VALUE klass, VALU
 	RB_OBJ_WRITTEN(self, Qnil, object);
 	RB_OBJ_WRITE(self, &entry->klass, klass);
 	RB_OBJ_WRITE(self, &entry->data, data);
-	RB_OBJ_WRITE(self, &entry->allocations, allocations);
 	
 	if (DEBUG) fprintf(stderr, "[NEWOBJ] Object inserted into table: %p\n", (void*)object);
 	
@@ -227,7 +232,15 @@ static void Memory_Profiler_Capture_process_freeobj(VALUE capture_value, VALUE u
 	
 	VALUE klass = entry->klass;
 	VALUE data = entry->data;
-	VALUE allocations = entry->allocations;
+	
+	// Look up allocations from tracked table:
+	st_data_t allocations_data;
+	if (!st_lookup(capture->tracked, (st_data_t)klass, &allocations_data)) {
+		// Class not tracked - shouldn't happen, but be defensive:
+		if (DEBUG) fprintf(stderr, "[FREEOBJ] Class not found in tracked: %p\n", (void*)klass);
+		goto done;
+	}
+	VALUE allocations = (VALUE)allocations_data;
 	
 	// Delete by entry pointer (faster - no second lookup!)
 	Memory_Profiler_Object_Table_delete_entry(capture->states, entry);
@@ -361,9 +374,10 @@ static VALUE Memory_Profiler_Capture_alloc(VALUE klass) {
 	capture->new_count = 0;
 	capture->free_count = 0;
 	
-	// Initialize state flags - not running, callbacks disabled
+	// Initialize state flags - not running, callbacks disabled, track_all disabled by default
 	capture->running = 0;
 	capture->paused = 0;
+	capture->track_all = 0;
 	
 	// Global event queue system will auto-initialize on first use (lazy initialization)
 	
@@ -375,6 +389,24 @@ static VALUE Memory_Profiler_Capture_initialize(VALUE self) {
 	return self;
 }
 
+// Get track_all setting
+static VALUE Memory_Profiler_Capture_track_all_get(VALUE self) {
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
+	
+	return capture->track_all ? Qtrue : Qfalse;
+}
+
+// Set track_all setting
+static VALUE Memory_Profiler_Capture_track_all_set(VALUE self, VALUE value) {
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
+	
+	capture->track_all = RTEST(value) ? 1 : 0;
+	
+	return value;
+}
+
 // Start capturing allocations
 static VALUE Memory_Profiler_Capture_start(VALUE self) {
 	struct Memory_Profiler_Capture *capture;
@@ -566,14 +598,10 @@ struct Memory_Profiler_Each_Object_Arguments {
 	VALUE allocations;
 };
 
-// Cleanup function to ensure table is made weak again
+// Cleanup function to re-enable GC
 static VALUE Memory_Profiler_Capture_each_object_ensure(VALUE arg) {
-	struct Memory_Profiler_Each_Object_Arguments *arguments = (struct Memory_Profiler_Each_Object_Arguments *)arg;
-	struct Memory_Profiler_Capture *capture;
-	TypedData_Get_Struct(arguments->self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
-	
-	// Make table weak again
-	Memory_Profiler_Object_Table_decrement_strong(capture->states);
+	// Re-enable GC (rb_gc_enable returns previous state, but we don't need it)
+	rb_gc_enable();
 	
 	return Qnil;
 }
@@ -596,12 +624,19 @@ static VALUE Memory_Profiler_Capture_each_object_body(VALUE arg) {
 				continue;
 			}
 			
+			// Look up allocations from klass
+			st_data_t allocations_data;
+			VALUE allocations = Qnil;
+			if (st_lookup(capture->tracked, (st_data_t)entry->klass, &allocations_data)) {
+				allocations = (VALUE)allocations_data;
+			}
+			
 			// Filter by allocations if specified
 			if (!NIL_P(arguments->allocations)) {
-				if (entry->allocations != arguments->allocations) continue;
+				if (allocations != arguments->allocations) continue;
 			}
 			
-			rb_yield_values(2, entry->object, entry->allocations);
+			rb_yield_values(2, entry->object, allocations);
 		}
 	}
 	
@@ -626,10 +661,11 @@ static VALUE Memory_Profiler_Capture_each_object(int argc, VALUE *argv, VALUE se
 	
 	RETURN_ENUMERATOR(self, argc, argv);
 	
-	// Make table strong so objects won't be collected during iteration
-	Memory_Profiler_Object_Table_increment_strong(capture->states);
+	// Disable GC to prevent objects from being collected during iteration
+	rb_gc_disable();
 	
-	// Process all pending events and run GC to clean up stale objects:
+	// Process all pending events to clean up stale entries
+	// At this point, all remaining objects in the table should be valid
 	Memory_Profiler_Events_process_all();
 	
 	// If class provided, look up its allocations wrapper
@@ -640,7 +676,8 @@ static VALUE Memory_Profiler_Capture_each_object(int argc, VALUE *argv, VALUE se
 			allocations = (VALUE)allocations_data;
 		} else {
 			// Class not tracked - nothing to iterate
-			Memory_Profiler_Object_Table_decrement_strong(capture->states);
+			// Re-enable GC before returning
+			rb_gc_enable();
 			return self;
 		}
 	}
@@ -733,6 +770,8 @@ void Init_Memory_Profiler_Capture(VALUE Memory_Profiler)
 	rb_define_alloc_func(Memory_Profiler_Capture, Memory_Profiler_Capture_alloc);
 	
 	rb_define_method(Memory_Profiler_Capture, "initialize", Memory_Profiler_Capture_initialize, 0);
+	rb_define_method(Memory_Profiler_Capture, "track_all", Memory_Profiler_Capture_track_all_get, 0);
+	rb_define_method(Memory_Profiler_Capture, "track_all=", Memory_Profiler_Capture_track_all_set, 1);
 	rb_define_method(Memory_Profiler_Capture, "start", Memory_Profiler_Capture_start, 0);
 	rb_define_method(Memory_Profiler_Capture, "stop", Memory_Profiler_Capture_stop, 0);
 	rb_define_method(Memory_Profiler_Capture, "track", Memory_Profiler_Capture_track, -1);  // -1 to accept block

data/ext/memory/profiler/table.c

@@ -4,12 +4,27 @@
 #include "table.h"
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
+
+enum {
+	DEBUG = 1,
+	
+	// Performance monitoring thresholds
+
+	// Log warning if probe chain exceeds this
+	WARN_PROBE_LENGTH = 100,
+
+	// Safety limit - abort search if exceeded
+	MAX_PROBE_LENGTH = 10000,
+};
 
 // Use the Entry struct from header
 // (No local definition needed)
+const size_t INITIAL_CAPACITY = 1024;
+const float LOAD_FACTOR = 0.50;  // Reduced from 0.75 to avoid clustering
 
-#define INITIAL_CAPACITY 1024
-#define LOAD_FACTOR 0.75
+
+VALUE TOMBSTONE = Qnil;
 
 // Create a new table
 struct Memory_Profiler_Object_Table* Memory_Profiler_Object_Table_new(size_t initial_capacity) {
@@ -21,9 +36,9 @@ struct Memory_Profiler_Object_Table* Memory_Profiler_Object_Table_new(size_t ini
 	
 	table->capacity = initial_capacity > 0 ? initial_capacity : INITIAL_CAPACITY;
 	table->count = 0;
-	table->strong = 0;  // Start as weak table (strong == 0 means weak)
+	table->tombstones = 0;
 	
-	// Use calloc to zero out entries (Qnil = 0)
+	// Use calloc to zero out entries (0 = empty slot)
 	table->entries = calloc(table->capacity, sizeof(struct Memory_Profiler_Object_Table_Entry));
 	
 	if (!table->entries) {
@@ -42,41 +57,153 @@ void Memory_Profiler_Object_Table_free(struct Memory_Profiler_Object_Table *tabl
 	}
 }
 
-// Simple hash function for object addresses
+// Hash function for object addresses
+// Uses multiplicative hashing with bit mixing to reduce clustering
 static inline size_t hash_object(VALUE object, size_t capacity) {
-	// Use address bits, shift right to ignore alignment
-	return ((size_t)object >> 3) % capacity;
+	size_t hash = (size_t)object;
+	
+	// Remove alignment bits (objects are typically 8-byte aligned)
+	hash >>= 3;
+	
+	// Multiplicative hashing (Knuth's golden ratio method)
+	// This helps distribute consecutive addresses across the table
+	hash *= 2654435761UL;  // 2^32 / phi (golden ratio)
+	
+	// Mix high bits into low bits for better distribution
+	hash ^= (hash >> 16);
+	hash *= 0x85ebca6b;
+	hash ^= (hash >> 13);
+	hash *= 0xc2b2ae35;
+	hash ^= (hash >> 16);
+	
+	return hash % capacity;
 }
 
 // Find entry index for an object (linear probing)
 // Returns index if found, or index of empty slot if not found
-static size_t find_entry(struct Memory_Profiler_Object_Table_Entry *entries, size_t capacity, VALUE object, int *found) {
+// If table is provided (not NULL), logs statistics when probe length is excessive
+static size_t find_entry(struct Memory_Profiler_Object_Table_Entry *entries, size_t capacity, VALUE object, int *found, struct Memory_Profiler_Object_Table *table, const char *operation) {
 	size_t index = hash_object(object, capacity);
 	size_t start = index;
+	size_t probe_count = 0;
 	
 	*found = 0;
 	
 	do {
+		probe_count++;
+		
+		// Safety check - prevent infinite loops
+		if (probe_count > MAX_PROBE_LENGTH) {
+			if (DEBUG && table) {
+				double load = (double)table->count / capacity;
+				double tomb_ratio = (double)table->tombstones / capacity;
+				fprintf(stderr, "{\"subject\":\"Memory::Profiler::ObjectTable\",\"level\":\"critical\",\"operation\":\"%s\",\"event\":\"max_probes_exceeded\",\"probe_count\":%zu,\"capacity\":%zu,\"count\":%zu,\"tombstones\":%zu,\"load_factor\":%.3f,\"tombstone_ratio\":%.3f}\n", 
+					operation, probe_count, capacity, table->count, table->tombstones, load, tomb_ratio);
+			} else if (DEBUG) {
+				fprintf(stderr, "{\"subject\":\"Memory::Profiler::ObjectTable\",\"level\":\"critical\",\"operation\":\"%s\",\"event\":\"max_probes_exceeded\",\"probe_count\":%zu,\"capacity\":%zu}\n", 
+					operation, probe_count, capacity);
+			}
+			return index;
+		}
+		
+		// Log warning for excessive probing
+		if (DEBUG && probe_count == WARN_PROBE_LENGTH && table) {
+			double load = (double)table->count / capacity;
+			double tomb_ratio = (double)table->tombstones / capacity;
+			fprintf(stderr, "{\"subject\":\"Memory::Profiler::ObjectTable\",\"level\":\"warning\",\"operation\":\"%s\",\"event\":\"long_probe_chain\",\"probe_count\":%zu,\"capacity\":%zu,\"count\":%zu,\"tombstones\":%zu,\"load_factor\":%.3f,\"tombstone_ratio\":%.3f}\n", 
+				operation, probe_count, capacity, table->count, table->tombstones, load, tomb_ratio);
+		}
+		
 		if (entries[index].object == 0) {
-			// Empty slot (calloc zeros memory)
 			return index;
 		}
 		
-		if (entries[index].object == object) {
-			// Found it
+		if (entries[index].object != TOMBSTONE && entries[index].object == object) {
 			*found = 1;
 			return index;
 		}
 		
-		// Linear probe
 		index = (index + 1) % capacity;
 	} while (index != start);
 	
-	// Table is full (shouldn't happen with load factor)
+	// Table is full
+	if (DEBUG && table) {
+		double load = (double)table->count / capacity;
+		double tomb_ratio = (double)table->tombstones / capacity;
+		fprintf(stderr, "{\"subject\":\"Memory::Profiler::ObjectTable\",\"level\":\"error\",\"operation\":\"%s\",\"event\":\"table_full\",\"probe_count\":%zu,\"capacity\":%zu,\"count\":%zu,\"tombstones\":%zu,\"load_factor\":%.3f,\"tombstone_ratio\":%.3f}\n", 
+			operation, probe_count, capacity, table->count, table->tombstones, load, tomb_ratio);
+	}
 	return index;
 }
 
+// Find slot for inserting an object (linear probing)
+// Returns index to insert at - reuses tombstone slots if found
+// If object exists, returns its index with found=1
+static size_t find_insert_slot(struct Memory_Profiler_Object_Table *table, VALUE object, int *found) {
+	struct Memory_Profiler_Object_Table_Entry *entries = table->entries;
+	size_t capacity = table->capacity;
+	size_t index = hash_object(object, capacity);
+	size_t start = index;
+	size_t first_tombstone = SIZE_MAX;  // Track first tombstone we encounter
+	size_t probe_count = 0;
+	
+	*found = 0;
+	
+	do {
+		probe_count++;
+		
+		// Safety check - prevent infinite loops
+		if (probe_count > MAX_PROBE_LENGTH) {
+			if (DEBUG) {
+				double load = (double)table->count / capacity;
+				double tomb_ratio = (double)table->tombstones / capacity;
+				fprintf(stderr, "{\"subject\":\"Memory::Profiler::ObjectTable\",\"level\":\"critical\",\"operation\":\"insert\",\"event\":\"max_probes_exceeded\",\"probe_count\":%zu,\"capacity\":%zu,\"count\":%zu,\"tombstones\":%zu,\"load_factor\":%.3f,\"tombstone_ratio\":%.3f}\n", 
+					probe_count, capacity, table->count, table->tombstones, load, tomb_ratio);
+			}
+			// Return tombstone if we found one, otherwise current position
+			return (first_tombstone != SIZE_MAX) ? first_tombstone : index;
+		}
+		
+		// Log warning for excessive probing
+		if (DEBUG && probe_count == WARN_PROBE_LENGTH) {
+			double load = (double)table->count / capacity;
+			double tomb_ratio = (double)table->tombstones / capacity;
+			fprintf(stderr, "{\"subject\":\"Memory::Profiler::ObjectTable\",\"level\":\"warning\",\"operation\":\"insert\",\"event\":\"long_probe_chain\",\"probe_count\":%zu,\"capacity\":%zu,\"count\":%zu,\"tombstones\":%zu,\"load_factor\":%.3f,\"tombstone_ratio\":%.3f}\n", 
+				probe_count, capacity, table->count, table->tombstones, load, tomb_ratio);
+		}
+		
+		if (entries[index].object == 0) {
+			// Empty slot - use tombstone if we found one, otherwise this slot
+			return (first_tombstone != SIZE_MAX) ? first_tombstone : index;
+		}
+		
+		if (entries[index].object == TOMBSTONE) {
+			// Remember first tombstone (but keep searching for existing object)
+			if (first_tombstone == SIZE_MAX) {
+				first_tombstone = index;
+			}
+		} else if (entries[index].object == object) {
+			// Found existing entry
+			*found = 1;
+			return index;
+		}
+		
+		index = (index + 1) % capacity;
+	} while (index != start);
+	
+	// Table is full
+	if (DEBUG) {
+		double load = (double)table->count / capacity;
+		double tomb_ratio = (double)table->tombstones / capacity;
+		fprintf(stderr, "{\"subject\":\"Memory::Profiler::ObjectTable\",\"level\":\"error\",\"operation\":\"insert\",\"event\":\"table_full\",\"probe_count\":%zu,\"capacity\":%zu,\"count\":%zu,\"tombstones\":%zu,\"load_factor\":%.3f,\"tombstone_ratio\":%.3f}\n", 
+			probe_count, capacity, table->count, table->tombstones, load, tomb_ratio);
+	}
+	// Use tombstone slot if we found one
+	return (first_tombstone != SIZE_MAX) ? first_tombstone : index;
+}
+
 // Resize the table (only called from insert, not during GC)
+// This clears all tombstones
 static void resize_table(struct Memory_Profiler_Object_Table *table) {
 	size_t old_capacity = table->capacity;
 	struct Memory_Profiler_Object_Table_Entry *old_entries = table->entries;
@@ -84,6 +211,7 @@ static void resize_table(struct Memory_Profiler_Object_Table *table) {
 	// Double capacity
 	table->capacity = old_capacity * 2;
 	table->count = 0;
+	table->tombstones = 0;  // Reset tombstones
 	table->entries = calloc(table->capacity, sizeof(struct Memory_Profiler_Object_Table_Entry));
 	
 	if (!table->entries) {
@@ -93,11 +221,12 @@ static void resize_table(struct Memory_Profiler_Object_Table *table) {
 		return;
 	}
 	
-	// Rehash all entries
+	// Rehash all non-tombstone entries
 	for (size_t i = 0; i < old_capacity; i++) {
-		if (old_entries[i].object != Qnil) {
+		// Skip empty slots and tombstones
+		if (old_entries[i].object != 0 && old_entries[i].object != TOMBSTONE) {
 			int found;
-			size_t new_index = find_entry(table->entries, table->capacity, old_entries[i].object, &found);
+			size_t new_index = find_entry(table->entries, table->capacity, old_entries[i].object, &found, NULL, "resize");
 			table->entries[new_index] = old_entries[i];
 			table->count++;
 		}
@@ -108,26 +237,30 @@ static void resize_table(struct Memory_Profiler_Object_Table *table) {
 
 // Insert object, returns pointer to entry for caller to fill
 struct Memory_Profiler_Object_Table_Entry* Memory_Profiler_Object_Table_insert(struct Memory_Profiler_Object_Table *table, VALUE object) {
-	// Resize if load factor exceeded
-	if ((double)table->count / table->capacity > LOAD_FACTOR) {
+	// Resize if load factor exceeded (count + tombstones)
+	// This clears tombstones and gives us fresh space
+	if ((double)(table->count + table->tombstones) / table->capacity > LOAD_FACTOR) {
 		resize_table(table);
 	}
 	
 	int found;
-	size_t index = find_entry(table->entries, table->capacity, object, &found);
+	size_t index = find_insert_slot(table, object, &found);
 	
 	if (!found) {
+		// New entry - check if we're reusing a tombstone slot
+		if (table->entries[index].object == TOMBSTONE) {
+			table->tombstones--;  // Reusing tombstone
+		}
 		table->count++;
 		// Zero out the entry
 		table->entries[index].object = object;
 		table->entries[index].klass = 0;
 		table->entries[index].data = 0;
-		table->entries[index].allocations = 0;
+	} else {
+		// Updating existing entry
+		table->entries[index].object = object;
 	}
 	
-	// Set object (might be updating existing entry)
-	table->entries[index].object = object;
-	
 	// Return pointer for caller to fill fields
 	return &table->entries[index];
 }
@@ -135,7 +268,7 @@ struct Memory_Profiler_Object_Table_Entry* Memory_Profiler_Object_Table_insert(s
 // Lookup entry for object - returns pointer or NULL
 struct Memory_Profiler_Object_Table_Entry* Memory_Profiler_Object_Table_lookup(struct Memory_Profiler_Object_Table *table, VALUE object) {
 	int found;
-	size_t index = find_entry(table->entries, table->capacity, object, &found);
+	size_t index = find_entry(table->entries, table->capacity, object, &found, table, "lookup");
 	
 	if (found) {
 		return &table->entries[index];
@@ -147,43 +280,18 @@ struct Memory_Profiler_Object_Table_Entry* Memory_Profiler_Object_Table_lookup(s
 // Delete object from table
 void Memory_Profiler_Object_Table_delete(struct Memory_Profiler_Object_Table *table, VALUE object) {
 	int found;
-	size_t index = find_entry(table->entries, table->capacity, object, &found);
+	size_t index = find_entry(table->entries, table->capacity, object, &found, table, "delete");
 	
 	if (!found) {
 		return;
 	}
 	
-	// Mark as deleted (set to 0/NULL)
-	table->entries[index].object = 0;
+	// Mark as tombstone - no rehashing needed!
+	table->entries[index].object = TOMBSTONE;
 	table->entries[index].klass = 0;
 	table->entries[index].data = 0;
-	table->entries[index].allocations = 0;
 	table->count--;
-	
-	// Rehash following entries to fix probe chains
-	size_t next = (index + 1) % table->capacity;
-	while (table->entries[next].object != 0) {
-		// Save entry values
-		VALUE obj = table->entries[next].object;
-		VALUE k = table->entries[next].klass;
-		VALUE d = table->entries[next].data;
-		VALUE a = table->entries[next].allocations;
-		
-		// Remove this entry (set to 0/NULL)
-		table->entries[next].object = 0;
-		table->entries[next].klass = 0;
-		table->entries[next].data = 0;
-		table->entries[next].allocations = 0;
-		table->count--;
-		
-		// Reinsert (will find correct spot and fill fields)
-		struct Memory_Profiler_Object_Table_Entry *new_entry = Memory_Profiler_Object_Table_insert(table, obj);
-		new_entry->klass = k;
-		new_entry->data = d;
-		new_entry->allocations = a;
-		
-		next = (next + 1) % table->capacity;
-	}
+	table->tombstones++;
 }
 
 // Mark all entries for GC
@@ -192,17 +300,12 @@ void Memory_Profiler_Object_Table_mark(struct Memory_Profiler_Object_Table *tabl
 	
 	for (size_t i = 0; i < table->capacity; i++) {
 		struct Memory_Profiler_Object_Table_Entry *entry = &table->entries[i];
-		if (entry->object != 0) {
-			// Mark object key if table is strong (strong > 0)
-			// When weak (strong == 0), object keys can be GC'd (that's how we detect frees)
-			if (table->strong > 0) {
-				rb_gc_mark_movable(entry->object);
-			}
-			
-			// Always mark the other fields (klass, data, allocations) - we own these
+		// Skip empty slots and tombstones
+		if (entry->object != 0 && entry->object != TOMBSTONE) {
+			// Don't mark object keys - table is weak (object keys can be GC'd, that's how we detect frees)
+			// Always mark the other fields (klass, data) - we own these
 			if (entry->klass) rb_gc_mark_movable(entry->klass);
 			if (entry->data) rb_gc_mark_movable(entry->data);
-			if (entry->allocations) rb_gc_mark_movable(entry->allocations);
 		}
 	}
 }
@@ -214,7 +317,8 @@ void Memory_Profiler_Object_Table_compact(struct Memory_Profiler_Object_Table *t
 	// First pass: check if any objects moved
 	int any_moved = 0;
 	for (size_t i = 0; i < table->capacity; i++) {
-		if (table->entries[i].object != 0) {
+		// Skip empty slots and tombstones
+		if (table->entries[i].object != 0 && table->entries[i].object != TOMBSTONE) {
 			VALUE new_loc = rb_gc_location(table->entries[i].object);
 			if (new_loc != table->entries[i].object) {
 				any_moved = 1;
@@ -226,11 +330,11 @@ void Memory_Profiler_Object_Table_compact(struct Memory_Profiler_Object_Table *t
 	// If nothing moved, just update VALUE fields and we're done
 	if (!any_moved) {
 		for (size_t i = 0; i < table->capacity; i++) {
-			if (table->entries[i].object != 0) {
+			// Skip empty slots and tombstones
+			if (table->entries[i].object != 0 && table->entries[i].object != TOMBSTONE) {
 				// Update VALUE fields if they moved
 				table->entries[i].klass = rb_gc_location(table->entries[i].klass);
 				table->entries[i].data = rb_gc_location(table->entries[i].data);
-				table->entries[i].allocations = rb_gc_location(table->entries[i].allocations);
 			}
 		}
 		return;
@@ -246,24 +350,25 @@ void Memory_Profiler_Object_Table_compact(struct Memory_Profiler_Object_Table *t
 	
 	size_t temp_count = 0;
 	for (size_t i = 0; i < table->capacity; i++) {
-		if (table->entries[i].object != 0) {
+		// Skip empty slots and tombstones
+		if (table->entries[i].object != 0 && table->entries[i].object != TOMBSTONE) {
 			// Update all pointers first
 			temp_entries[temp_count].object = rb_gc_location(table->entries[i].object);
 			temp_entries[temp_count].klass = rb_gc_location(table->entries[i].klass);
 			temp_entries[temp_count].data = rb_gc_location(table->entries[i].data);
-			temp_entries[temp_count].allocations = rb_gc_location(table->entries[i].allocations);
 			temp_count++;
 		}
 	}
 	
-	// Clear the table (zero out all entries)
+	// Clear the table (zero out all entries, clears tombstones too)
 	memset(table->entries, 0, table->capacity * sizeof(struct Memory_Profiler_Object_Table_Entry));
 	table->count = 0;
+	table->tombstones = 0;  // Compaction clears tombstones
 	
 	// Reinsert all entries with new hash values
 	for (size_t i = 0; i < temp_count; i++) {
 		int found;
-		size_t index = find_entry(table->entries, table->capacity, temp_entries[i].object, &found);
+		size_t index = find_entry(table->entries, table->capacity, temp_entries[i].object, &found, NULL, "compact");
 		
 		// Insert at new location
 		table->entries[index] = temp_entries[i];
@@ -284,42 +389,17 @@ void Memory_Profiler_Object_Table_delete_entry(struct Memory_Profiler_Object_Tab
 		return;  // Invalid pointer
 	}
 	
-	// Check if entry is actually occupied
-	if (entry->object == 0) {
-		return;  // Already deleted
+	// Check if entry is actually occupied (not empty or tombstone)
+	if (entry->object == 0 || entry->object == TOMBSTONE) {
+		return;  // Already deleted or empty
 	}
 	
-	// Mark as deleted (set to 0/NULL)
-	entry->object = 0;
+	// Mark as tombstone - no rehashing needed!
+	entry->object = TOMBSTONE;
 	entry->klass = 0;
 	entry->data = 0;
-	entry->allocations = 0;
 	table->count--;
-	
-	// Rehash following entries to fix probe chains
-	size_t next = (index + 1) % table->capacity;
-	while (table->entries[next].object != 0) {
-		// Save entry values
-		VALUE obj = table->entries[next].object;
-		VALUE k = table->entries[next].klass;
-		VALUE d = table->entries[next].data;
-		VALUE a = table->entries[next].allocations;
-		
-		// Remove this entry (set to 0/NULL)
-		table->entries[next].object = 0;
-		table->entries[next].klass = 0;
-		table->entries[next].data = 0;
-		table->entries[next].allocations = 0;
-		table->count--;
-		
-		// Reinsert (will find correct spot and fill fields)
-		struct Memory_Profiler_Object_Table_Entry *new_entry = Memory_Profiler_Object_Table_insert(table, obj);
-		new_entry->klass = k;
-		new_entry->data = d;
-		new_entry->allocations = a;
-		
-		next = (next + 1) % table->capacity;
-	}
+	table->tombstones++;
 }
 
 // Get current size
@@ -327,17 +407,3 @@ size_t Memory_Profiler_Object_Table_size(struct Memory_Profiler_Object_Table *ta
 	return table->count;
 }
 
-// Increment strong reference count (makes table strong when > 0)
-void Memory_Profiler_Object_Table_increment_strong(struct Memory_Profiler_Object_Table *table) {
-	if (table) {
-		table->strong++;
-	}
-}
-
-// Decrement strong reference count (makes table weak when == 0)
-void Memory_Profiler_Object_Table_decrement_strong(struct Memory_Profiler_Object_Table *table) {
-	if (table && table->strong > 0) {
-		table->strong--;
-	}
-}
-

data/ext/memory/profiler/table.h

@@ -14,19 +14,16 @@ struct Memory_Profiler_Object_Table_Entry {
 	VALUE klass;
 	// User-defined state from callback:
 	VALUE data;
-	// The Allocations wrapper for this class:
-	VALUE allocations;
 };
 
 // Custom object table for tracking allocations during GC.
 // Uses system malloc/free (not ruby_xmalloc) to be safe during GC compaction.
 // Keys are object addresses (updated during compaction).
+// Table is always weak - object keys are not marked, allowing GC to collect them.
 struct Memory_Profiler_Object_Table {
-	// Strong reference count: 0 = weak (don't mark keys), >0 = strong (mark keys)
-	int strong;
-
-	size_t capacity;  // Total slots
-	size_t count;     // Used slots
+	size_t capacity;    // Total slots
+	size_t count;       // Used slots (occupied entries)
+	size_t tombstones;  // Deleted slots (tombstone markers)
 	struct Memory_Profiler_Object_Table_Entry *entries;  // System malloc'd array
 };
 
@@ -63,11 +60,3 @@ void Memory_Profiler_Object_Table_compact(struct Memory_Profiler_Object_Table *t
 // Get current size
 size_t Memory_Profiler_Object_Table_size(struct Memory_Profiler_Object_Table *table);
 
-// Increment strong reference count
-// When strong > 0, table is strong and will mark object keys during GC
-void Memory_Profiler_Object_Table_increment_strong(struct Memory_Profiler_Object_Table *table);
-
-// Decrement strong reference count
-// When strong == 0, table is weak and will not mark object keys during GC
-void Memory_Profiler_Object_Table_decrement_strong(struct Memory_Profiler_Object_Table *table);
-

data/lib/memory/profiler/sampler.rb

@@ -104,6 +104,7 @@ module Memory
 				@gc = gc
 				
 				@capture = Capture.new
+				@capture.track_all = true
 				@call_trees = {}
 				@samples = {}
 			end
@@ -282,7 +283,7 @@ module Memory
 			# @parameter retained_roots [Boolean] Compute object graph showing what's retaining allocations (default: false, can be slow for large graphs).
 			# @parameter retained_addresses [Boolean | Integer] Include memory addresses of retained objects for correlation with heap dumps (default: 1000).
 			# @returns [Hash] Statistics including allocations, allocation_roots (call tree), retained_roots (object graph), and retained_addresses (array of memory addresses)	.
-			def analyze(klass, allocation_roots: true, retained_addresses: 1000, retained_minimum: 100)
+			def analyze(klass, allocation_roots: true, retained_addresses: 100, retained_minimum: 100)
 				unless allocations = @capture[klass]
 					return nil
 				end
@@ -318,7 +319,7 @@ module Memory
 			
 			# Default filter to include all locations.
 			def default_filter
-				->(location) {true}
+				->(location){true}
 			end
 			
 			def prune_call_trees!

data/lib/memory/profiler/version.rb

@@ -7,7 +7,7 @@
 module Memory
 	# @namespace
 	module Profiler
-		VERSION = "1.5.0"
+		VERSION = "1.6.0"
 	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.5.1
+
+  - Improve performance of object table.
+
 ### v1.5.0
 
   - Add `Capture#each_object` for getting all retained objects.
@@ -75,15 +79,6 @@ Please see the [project releases](https://socketry.github.io/memory-profiler/rel
 
   - Double buffer shared events queues to fix queue corruption.
 
-### v1.1.10
-
-  - Added `Capture#new_count` - returns total number of allocations tracked across all classes.
-  - Added `Capture#free_count` - returns total number of objects freed across all classes.
-  - Added `Capture#retained_count` - returns retained object count (new\_count - free\_count).
-  - **Critical:** Fixed GC crash during compaction caused by missing write barriers in event queue.
-  - Fixed allocation/deallocation counts being inaccurate when objects are allocated during callbacks or freed after compaction.
-  - `Capture#clear` now raises `RuntimeError` if called while capture is running. Call `stop()` before `clear()`.
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## v1.5.1
+
+  - Improve performance of object table.
+
 ## v1.5.0
 
   - Add `Capture#each_object` for getting all retained objects.

metadata

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