memory-profiler 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b936617787e483bcf790aee25bb224bf10a199f431dbb8ac51eff005504a44d4
-  data.tar.gz: 587f38cef39c639c9d9e2efbffdd325cffdfbd3000dddbca46f5aba895a66a21
+  metadata.gz: c1f0d854f80d796037192a81dfe2912291e0653510755e06d0a7e85e8b84a4ea
+  data.tar.gz: 11e5bbe54085baa3cc2c085c947b2ef9c74f3e85a44a59249ea2c5e41bc4a2bd
 SHA512:
-  metadata.gz: c483112cf1dd1c82ea679afe3b86007bf20b2674558ac676fc2c66cd07f651787a09198b9f49fb3dd28f1f9b64865dfac9cc249d91b6b819e3849e0cc9c9ab0b
-  data.tar.gz: 0de0b5d28eb0f5af2b72ec0aa44ceaf8d0401822949ee4512f922b6caa730e1d69a6b2997fac633140168b3b8de93bdbf4c76223ae6ef789520ae5566ef23f08
+  metadata.gz: '05866071c2c1a20e868d8ca0c11f9951595bac35b86e051863ecde8c11e581d7c92780826c4816c087764f9cdc078859402e6d718e272f6a337dc59ab69d2b63'
+  data.tar.gz: e070faca1aa563faff377a56cb7287e1dbf369b65dc534c623425ad33c83e7d938925a25f470821e2134848ed2db7adce94408736e0fead52bba6cbc07ec5a9d

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).
@@ -199,7 +198,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 +225,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);
@@ -596,12 +602,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);
 		}
 	}
 	

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,10 @@ 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->tombstones = 0;
 	table->strong = 0;  // Start as weak table (strong == 0 means weak)
 	
-	// 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 +58,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 +212,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 +222,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 +238,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 +269,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 +281,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 +301,17 @@ 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) {
+		// Skip empty slots and tombstones
+		if (entry->object != 0 && entry->object != TOMBSTONE) {
 			// 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
+			// 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 +323,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 +336,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 +356,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 +395,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

data/ext/memory/profiler/table.h

@@ -14,8 +14,6 @@ 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.
@@ -25,8 +23,9 @@ 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
 };
 

data/lib/memory/profiler/sampler.rb

@@ -282,7 +282,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 +318,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.5.1"
 	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.5.1
 platform: ruby
 authors:
 - Samuel Williams