memory-profiler 1.4.0 → 1.5.0

data/ext/memory/profiler/table.c

@@ -0,0 +1,343 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "table.h"
+#include <stdlib.h>
+#include <string.h>
+
+// Use the Entry struct from header
+// (No local definition needed)
+
+#define INITIAL_CAPACITY 1024
+#define LOAD_FACTOR 0.75
+
+// Create a new table
+struct Memory_Profiler_Object_Table* Memory_Profiler_Object_Table_new(size_t initial_capacity) {
+	struct Memory_Profiler_Object_Table *table = malloc(sizeof(struct Memory_Profiler_Object_Table));
+	
+	if (!table) {
+		return NULL;
+	}
+	
+	table->capacity = initial_capacity > 0 ? initial_capacity : INITIAL_CAPACITY;
+	table->count = 0;
+	table->strong = 0;  // Start as weak table (strong == 0 means weak)
+	
+	// Use calloc to zero out entries (Qnil = 0)
+	table->entries = calloc(table->capacity, sizeof(struct Memory_Profiler_Object_Table_Entry));
+	
+	if (!table->entries) {
+		free(table);
+		return NULL;
+	}
+	
+	return table;
+}
+
+// Free the table
+void Memory_Profiler_Object_Table_free(struct Memory_Profiler_Object_Table *table) {
+	if (table) {
+		free(table->entries);
+		free(table);
+	}
+}
+
+// Simple hash function for object addresses
+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;
+}
+
+// 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) {
+	size_t index = hash_object(object, capacity);
+	size_t start = index;
+	
+	*found = 0;
+	
+	do {
+		if (entries[index].object == 0) {
+			// Empty slot (calloc zeros memory)
+			return index;
+		}
+		
+		if (entries[index].object == object) {
+			// Found it
+			*found = 1;
+			return index;
+		}
+		
+		// Linear probe
+		index = (index + 1) % capacity;
+	} while (index != start);
+	
+	// Table is full (shouldn't happen with load factor)
+	return index;
+}
+
+// Resize the table (only called from insert, not during GC)
+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;
+	
+	// Double capacity
+	table->capacity = old_capacity * 2;
+	table->count = 0;
+	table->entries = calloc(table->capacity, sizeof(struct Memory_Profiler_Object_Table_Entry));
+	
+	if (!table->entries) {
+		// Resize failed - restore old state
+		table->capacity = old_capacity;
+		table->entries = old_entries;
+		return;
+	}
+	
+	// Rehash all entries
+	for (size_t i = 0; i < old_capacity; i++) {
+		if (old_entries[i].object != Qnil) {
+			int found;
+			size_t new_index = find_entry(table->entries, table->capacity, old_entries[i].object, &found);
+			table->entries[new_index] = old_entries[i];
+			table->count++;
+		}
+	}
+	
+	free(old_entries);
+}
+
+// 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_table(table);
+	}
+	
+	int found;
+	size_t index = find_entry(table->entries, table->capacity, object, &found);
+	
+	if (!found) {
+		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;
+	}
+	
+	// Set object (might be updating existing entry)
+	table->entries[index].object = object;
+	
+	// Return pointer for caller to fill fields
+	return &table->entries[index];
+}
+
+// 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);
+	
+	if (found) {
+		return &table->entries[index];
+	}
+	
+	return NULL;
+}
+
+// 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);
+	
+	if (!found) {
+		return;
+	}
+	
+	// Mark as deleted (set to 0/NULL)
+	table->entries[index].object = 0;
+	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;
+	}
+}
+
+// Mark all entries for GC
+void Memory_Profiler_Object_Table_mark(struct Memory_Profiler_Object_Table *table) {
+	if (!table) return;
+	
+	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
+			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);
+		}
+	}
+}
+
+// Update object pointers during compaction
+void Memory_Profiler_Object_Table_compact(struct Memory_Profiler_Object_Table *table) {
+	if (!table || table->count == 0) return;
+	
+	// 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) {
+			VALUE new_loc = rb_gc_location(table->entries[i].object);
+			if (new_loc != table->entries[i].object) {
+				any_moved = 1;
+				break;
+			}
+		}
+	}
+	
+	// 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) {
+				// 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;
+	}
+	
+	// Something moved - need to rehash entire table
+	// Collect all entries into temporary array (use system malloc, not Ruby's)
+	struct Memory_Profiler_Object_Table_Entry *temp_entries = malloc(table->count * sizeof(struct Memory_Profiler_Object_Table_Entry));
+	if (!temp_entries) {
+		// Allocation failed - this is bad, but can't do much during GC
+		return;
+	}
+	
+	size_t temp_count = 0;
+	for (size_t i = 0; i < table->capacity; i++) {
+		if (table->entries[i].object != 0) {
+			// 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)
+	memset(table->entries, 0, table->capacity * sizeof(struct Memory_Profiler_Object_Table_Entry));
+	table->count = 0;
+	
+	// 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);
+		
+		// Insert at new location
+		table->entries[index] = temp_entries[i];
+		table->count++;
+	}
+	
+	// Free temporary array
+	free(temp_entries);
+}
+
+// Delete by entry pointer (faster - avoids second lookup)
+void Memory_Profiler_Object_Table_delete_entry(struct Memory_Profiler_Object_Table *table, struct Memory_Profiler_Object_Table_Entry *entry) {
+	// Calculate index from pointer
+	size_t index = entry - table->entries;
+	
+	// Validate it's within our table
+	if (index >= table->capacity) {
+		return;  // Invalid pointer
+	}
+	
+	// Check if entry is actually occupied
+	if (entry->object == 0) {
+		return;  // Already deleted
+	}
+	
+	// Mark as deleted (set to 0/NULL)
+	entry->object = 0;
+	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;
+	}
+}
+
+// Get current size
+size_t Memory_Profiler_Object_Table_size(struct Memory_Profiler_Object_Table *table) {
+	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

@@ -0,0 +1,73 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+#include <stddef.h>
+
+// Entry in the object table
+struct Memory_Profiler_Object_Table_Entry {
+	// Object pointer (key):
+	VALUE object;
+	// The class of the allocated object:
+	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).
+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
+	struct Memory_Profiler_Object_Table_Entry *entries;  // System malloc'd array
+};
+
+// Create a new object table with initial capacity
+struct Memory_Profiler_Object_Table* Memory_Profiler_Object_Table_new(size_t initial_capacity);
+
+// Free the table and all its memory
+void Memory_Profiler_Object_Table_free(struct Memory_Profiler_Object_Table *table);
+
+// Insert an object, returns pointer to entry for caller to fill fields.
+// Safe to call from postponed job (not during GC).
+struct Memory_Profiler_Object_Table_Entry* Memory_Profiler_Object_Table_insert(struct Memory_Profiler_Object_Table *table, VALUE object);
+
+// Lookup entry for an object. Returns pointer to entry or NULL if not found.
+// Safe to call during FREEOBJ event handler (no allocation) - READ ONLY!
+struct Memory_Profiler_Object_Table_Entry* Memory_Profiler_Object_Table_lookup(struct Memory_Profiler_Object_Table *table, VALUE object);
+
+// Delete an object. Safe to call from postponed job (not during GC).
+void Memory_Profiler_Object_Table_delete(struct Memory_Profiler_Object_Table *table, VALUE object);
+
+// Delete by entry pointer (faster - no second lookup needed).
+// Safe to call from postponed job (not during GC).
+// entry must be a valid pointer from Object_Table_lookup.
+void Memory_Profiler_Object_Table_delete_entry(struct Memory_Profiler_Object_Table *table, struct Memory_Profiler_Object_Table_Entry *entry);
+
+// Mark all entries for GC.
+// Must be called from dmark callback.
+void Memory_Profiler_Object_Table_mark(struct Memory_Profiler_Object_Table *table);
+
+// Update object pointers after compaction.
+// Must be called from dcompact callback.
+void Memory_Profiler_Object_Table_compact(struct Memory_Profiler_Object_Table *table);
+
+// 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

@@ -9,7 +9,6 @@ require "objspace"
 require_relative "capture"
 require_relative "allocations"
 require_relative "call_tree"
-require_relative "graph"
 
 module Memory
 	module Profiler
@@ -142,7 +141,7 @@ module Memory
 			def stop
 				@capture.stop
 			end
-
+			
 			# Clear tracking data for a class.
 			def clear(klass)
 				tree = @call_trees[klass]
@@ -280,48 +279,42 @@ module Memory
 			#
 			# @parameter klass [Class] The class to get statistics for.
 			# @parameter allocation_roots [Boolean] Include call tree showing where allocations occurred (default: true if available).
-			# @parameter retained_roots [Boolean] Compute object graph showing what's retaining allocations (default: true, can be slow for large graphs).
-			# @parameter roots_from [Object] Starting point for retained roots analysis (default: Object).
-			# @returns [Hash] Statistics including allocations, allocation_roots (call tree), and retained_roots (object graph).
-			def analyze(klass, allocation_roots: true, retained_roots: false, retained_objects: true)
-				call_tree_data = @call_trees[klass] if allocation_roots
-				allocations = @capture[klass]
+			# @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)
+				unless allocations = @capture[klass]
+					return nil
+				end
 				
-				return nil unless call_tree_data or allocations
+				if retained_minimum && allocations.retained_count < retained_minimum
+					return nil
+				end
 				
 				result = {
 					allocations: allocations&.as_json,
 				}
 				
-				if allocation_roots && call_tree_data
-					result[:allocation_roots] = call_tree_data.as_json
+				if allocation_roots
+					if call_tree_data = @call_trees[klass]
+						result[:allocation_roots] = call_tree_data.as_json
+					end
 				end
 				
-				if retained_roots
-					result[:retained_roots] = compute_roots(klass)
+				if retained_addresses
+					addresses = []
+					@capture.each_object(klass) do |object, state|
+						addresses << Memory::Profiler.address_of(object)
+						break if retained_addresses.is_a?(Integer) && addresses.size >= retained_addresses
+					end
+					
+					result[:retained_addresses] = addresses
 				end
 				
 				result
 			end
 			
 		private
-
-			# Compute retaining roots for a class's allocations
-			def compute_roots(klass)
-				graph = Graph.new
-				
-				# Add all tracked objects to the graph
-				# NOTE: States table is now at Capture level, so we use capture.each_object
-				@capture.each_object(klass) do |object, state|
-					graph.add(object)
-				end
-				
-				# Build parent relationships
-				graph.update!
-				
-				# Return roots analysis
-				graph.roots
-			end
 			
 			# Default filter to include all locations.
 			def default_filter

data/lib/memory/profiler/version.rb

@@ -7,7 +7,7 @@
 module Memory
 	# @namespace
 	module Profiler
-		VERSION = "1.4.0"
+		VERSION = "1.5.0"
 	end
 end
 

data/lib/memory/profiler.rb

@@ -8,4 +8,3 @@ require_relative "profiler/call_tree"
 require_relative "profiler/capture"
 require_relative "profiler/allocations"
 require_relative "profiler/sampler"
-require_relative "profiler/graph"

data/readme.md

@@ -22,6 +22,14 @@ 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.0
+
+  - Add `Capture#each_object` for getting all retained objects.
+  - Add `retained_addresses:` option to `Sampler#analyze` to capture addresses.
+  - Add `Sampler#analyze(retained_minimum: 100)` - if the retained\_size is less than this, the analyse won't proceed.
+  - Remove `Memory::Profiler::Graph` - it's too slow for practical use.
+  - Add `Memory::Profiler.address_of(object)` to get the memory address of an object.
+
 ### v1.4.0
 
   - Implement [Cooper-Harvey-Kennedy](https://www.cs.tufts.edu/~nr/cs257/archive/keith-cooper/dom14.pdf) algorithm for finding root objects in memory leaks.
@@ -76,10 +84,6 @@ Please see the [project releases](https://socketry.github.io/memory-profiler/rel
   - 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()`.
 
-### v1.1.9
-
-  - More write barriers...
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,13 @@
 # Releases
 
+## v1.5.0
+
+  - Add `Capture#each_object` for getting all retained objects.
+  - Add `retained_addresses:` option to `Sampler#analyze` to capture addresses.
+  - Add `Sampler#analyze(retained_minimum: 100)` - if the retained\_size is less than this, the analyse won't proceed.
+  - Remove `Memory::Profiler::Graph` - it's too slow for practical use.
+  - Add `Memory::Profiler.address_of(object)` to get the memory address of an object.
+
 ## v1.4.0
 
   - Implement [Cooper-Harvey-Kennedy](https://www.cs.tufts.edu/~nr/cs257/archive/keith-cooper/dom14.pdf) algorithm for finding root objects in memory leaks.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memory-profiler
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -55,11 +55,12 @@ files:
 - ext/memory/profiler/events.h
 - ext/memory/profiler/profiler.c
 - ext/memory/profiler/queue.h
+- ext/memory/profiler/table.c
+- ext/memory/profiler/table.h
 - lib/memory/profiler.rb
 - lib/memory/profiler/allocations.rb
 - lib/memory/profiler/call_tree.rb
 - lib/memory/profiler/capture.rb
-- lib/memory/profiler/graph.rb
 - lib/memory/profiler/native.rb
 - lib/memory/profiler/sampler.rb
 - lib/memory/profiler/version.rb