memory-profiler 1.1.5 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45474399b764a755546268feed4710ae9c647a8265cd933be82e35b1f390e820
-  data.tar.gz: 47d263fc3fa31b8013d7eded37f22e74b8912b3029d6b5d9051f3a35e1b4aa6a
+  metadata.gz: 8bb750e881686089136fbcd20b073e857dc3a7dc7f4784f0a75cf8fbb17444ec
+  data.tar.gz: 75d398699455359a70dafbbd1c71ce8dd529faf492f8fd7f595cc9714101061f
 SHA512:
-  metadata.gz: d4afc54d3841e0517e966ca0e5015320cacdc747a0ed1b2004b3b5ed043345139e3d7125ee79a4ff8bc3781f04d88399f2373553fe870143adf92b7b745fe97c
-  data.tar.gz: e99bbeda7a53e23c30e90981711f88651fd7efd453d86ba9748b11485dd2fcad6562038b91390a1f692694508e71c0aa4221ec25f2ebe61663835f667973292e
+  metadata.gz: 83261c47a3365c107239cd626b61afe496e51d17e04ee36ac81235d7493997089fd97648965af42747ff1b3f8074f1fe72df31a1ecf6ce774fe9ac1ae2cf0565
+  data.tar.gz: 5bf3be79ccabbc16f1d753c94a3af7d89affabfc34d4feb9fd001f0573cf516614363f7430dfbe3553166076c349ffe38cee7e39309f9f6eecef867ba4978d78

data/ext/memory/profiler/capture.c

@@ -52,7 +52,10 @@ struct Memory_Profiler_Capture {
 	// class => VALUE (wrapped Memory_Profiler_Capture_Allocations).
 	st_table *tracked_classes;
 
-	// Is tracking enabled (via start/stop):
+	// Master switch - is tracking active? (set by start/stop)
+	int running;
+	
+	// Internal - should we queue callbacks? (temporarily disabled during queue processing)
 	int enabled;
 	
 	// Queue for new objects (processed via postponed job):
@@ -300,20 +303,23 @@ static void Memory_Profiler_Capture_newobj_handler(VALUE self, struct Memory_Pro
 	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
 		VALUE allocations = (VALUE)allocations_data;
 		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
+		
+		// Always track counts (even during queue processing)
 		record->new_count++;
 		
-		// If we have a callback, queue the newobj for later processing
-		if (!NIL_P(record->callback)) {
+		// Only queue for callback if tracking is enabled (prevents infinite recursion)
+		if (capture->enabled && !NIL_P(record->callback)) {
 			// Push a new item onto the queue (returns pointer to write to)
 			// NOTE: realloc is safe during allocation (doesn't trigger Ruby allocation)
 			struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_push(&capture->newobj_queue);
 			if (newobj) {
 				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Queued newobj, queue size now: %zu/%zu\n", 
 					capture->newobj_queue.count, capture->newobj_queue.capacity);
-				// Write directly to the allocated space
-				newobj->klass = klass;
-				newobj->allocations = allocations;
-				newobj->object = object;
+				
+				// Write VALUEs with write barriers (combines write + GC notification)
+				RB_OBJ_WRITE(self, &newobj->klass, klass);
+				RB_OBJ_WRITE(self, &newobj->allocations, allocations);
+				RB_OBJ_WRITE(self, &newobj->object, object);
 				
 				// Trigger postponed job to process the queue
 				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Triggering postponed job to process queues\n");
@@ -350,10 +356,13 @@ static void Memory_Profiler_Capture_freeobj_handler(VALUE self, struct Memory_Pr
 	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
 		VALUE allocations = (VALUE)allocations_data;
 		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
+		
+		// Always track counts (even during queue processing)
 		record->free_count++;
 		
-		// If we have a callback and detailed tracking, queue the freeobj for later processing
-		if (!NIL_P(record->callback) && record->object_states) {
+		// Only queue for callback if tracking is enabled and we have state
+		// Note: If NEWOBJ didn't queue (enabled=0), there's no state, so this naturally skips
+		if (capture->enabled && !NIL_P(record->callback) && record->object_states) {
 			if (DEBUG_STATE) fprintf(stderr, "Memory_Profiler_Capture_freeobj_handler: Looking up state for object: %p\n", (void *)object);
 
 			// Look up state stored during NEWOBJ
@@ -364,14 +373,16 @@ static void Memory_Profiler_Capture_freeobj_handler(VALUE self, struct Memory_Pr
 				
 				// Push a new item onto the queue (returns pointer to write to)
 				// NOTE: realloc is safe during GC (doesn't trigger Ruby allocation)
-				struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_push(&capture->freeobj_queue);
-				if (freed) {
+				struct Memory_Profiler_Freeobj_Queue_Item *freeobj = Memory_Profiler_Queue_push(&capture->freeobj_queue);
+				if (freeobj) {
 					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Queued freed object, queue size now: %zu/%zu\n", 
 						capture->freeobj_queue.count, capture->freeobj_queue.capacity);
-					// Write directly to the allocated space
-					freed->klass = klass;
-					freed->allocations = allocations;
-					freed->state = state;
+					
+					// Write VALUEs with write barriers (combines write + GC notification)
+					// Note: We're during GC/FREEOBJ, but write barriers should be safe
+					RB_OBJ_WRITE(self, &freeobj->klass, klass);
+					RB_OBJ_WRITE(self, &freeobj->allocations, allocations);
+					RB_OBJ_WRITE(self, &freeobj->state, state);
 					
 					// Trigger postponed job to process both queues after GC
 					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Triggering postponed job to process queues after GC\n");
@@ -428,8 +439,6 @@ static void Memory_Profiler_Capture_event_callback(VALUE data, void *ptr) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(data, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	if (!capture->enabled) return;
-	
 	VALUE object = rb_tracearg_object(trace_arg);
 
 	// We don't want to track internal non-Object allocations:
@@ -473,6 +482,8 @@ static VALUE Memory_Profiler_Capture_alloc(VALUE klass) {
 		rb_raise(rb_eRuntimeError, "Failed to initialize hash table");
 	}
 	
+	// Initialize state flags - not running, callbacks disabled
+	capture->running = 0;
 	capture->enabled = 0;
 	
 	// Initialize both queues
@@ -504,7 +515,7 @@ static VALUE Memory_Profiler_Capture_start(VALUE self) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	if (capture->enabled) return Qfalse;
+	if (capture->running) return Qfalse;
 	
 	// Add event hook for NEWOBJ and FREEOBJ with RAW_ARG to get trace_arg
 	rb_add_event_hook2(
@@ -514,6 +525,8 @@ static VALUE Memory_Profiler_Capture_start(VALUE self) {
 		RUBY_EVENT_HOOK_FLAG_SAFE | RUBY_EVENT_HOOK_FLAG_RAW_ARG
 	);
 	
+	// Set both flags - we're now running and callbacks are enabled
+	capture->running = 1;
 	capture->enabled = 1;
 	
 	return Qtrue;
@@ -524,11 +537,16 @@ static VALUE Memory_Profiler_Capture_stop(VALUE self) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	if (!capture->enabled) return Qfalse;
+	if (!capture->running) return Qfalse;
 	
-	// Remove event hook using same data (self) we registered with
+	// Remove event hook using same data (self) we registered with. No more events will be queued after this point:
 	rb_remove_event_hook_with_data((rb_event_hook_func_t)Memory_Profiler_Capture_event_callback, self);
 	
+	// Flush any pending queued events before stopping. This ensures all callbacks are invoked and object_states is properly maintained.
+	Memory_Profiler_Capture_process_queues((void *)self);
+	
+	// Clear both flags - we're no longer running and callbacks are disabled
+	capture->running = 0;
 	capture->enabled = 0;
 	
 	return Qtrue;
@@ -676,6 +694,57 @@ static VALUE Memory_Profiler_Capture_aref(VALUE self, VALUE klass) {
 	return Qnil;
 }
 
+// Struct to accumulate statistics during iteration
+struct Memory_Profiler_Allocations_Statistics {
+	size_t total_tracked_objects;
+	VALUE per_class_counts;
+};
+
+// Iterator callback to count object_states per class
+static int Memory_Profiler_Capture_count_object_states(st_data_t key, st_data_t value, st_data_t argument) {
+	struct Memory_Profiler_Allocations_Statistics *statistics = (struct Memory_Profiler_Allocations_Statistics *)argument;
+	VALUE klass = (VALUE)key;
+	VALUE allocations = (VALUE)value;
+	struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
+	
+	size_t object_states_count = record->object_states ? record->object_states->num_entries : 0;
+	statistics->total_tracked_objects += object_states_count;
+	
+	rb_hash_aset(statistics->per_class_counts, klass, SIZET2NUM(object_states_count));
+	return ST_CONTINUE;
+}
+
+// Get internal statistics for debugging
+// Returns hash with internal state sizes
+static VALUE Memory_Profiler_Capture_statistics(VALUE self) {
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
+	
+	VALUE statistics = rb_hash_new();
+	
+	// Tracked classes count
+	rb_hash_aset(statistics, ID2SYM(rb_intern("tracked_classes_count")), SIZET2NUM(capture->tracked_classes->num_entries));
+	
+	// Queue sizes
+	rb_hash_aset(statistics, ID2SYM(rb_intern("newobj_queue_size")), SIZET2NUM(capture->newobj_queue.count));
+	rb_hash_aset(statistics, ID2SYM(rb_intern("newobj_queue_capacity")), SIZET2NUM(capture->newobj_queue.capacity));
+	rb_hash_aset(statistics, ID2SYM(rb_intern("freeobj_queue_size")), SIZET2NUM(capture->freeobj_queue.count));
+	rb_hash_aset(statistics, ID2SYM(rb_intern("freeobj_queue_capacity")), SIZET2NUM(capture->freeobj_queue.capacity));
+	
+	// Count object_states entries for each tracked class
+	struct Memory_Profiler_Allocations_Statistics allocations_statistics = {
+		.total_tracked_objects = 0,
+		.per_class_counts = rb_hash_new()
+	};
+	
+	st_foreach(capture->tracked_classes, Memory_Profiler_Capture_count_object_states, (st_data_t)&allocations_statistics);
+	
+	rb_hash_aset(statistics, ID2SYM(rb_intern("total_tracked_objects")), SIZET2NUM(allocations_statistics.total_tracked_objects));
+	rb_hash_aset(statistics, ID2SYM(rb_intern("tracked_objects_per_class")), allocations_statistics.per_class_counts);
+	
+	return statistics;
+}
+
 void Init_Memory_Profiler_Capture(VALUE Memory_Profiler)
 {
 	// Initialize event symbols
@@ -697,6 +766,7 @@ 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, "[]", Memory_Profiler_Capture_aref, 1);
 	rb_define_method(Memory_Profiler_Capture, "clear", Memory_Profiler_Capture_clear, 0);
+	rb_define_method(Memory_Profiler_Capture, "statistics", Memory_Profiler_Capture_statistics, 0);
 	
 	// Initialize Allocations class
 	Init_Memory_Profiler_Allocations(Memory_Profiler);

data/lib/memory/profiler/call_tree.rb

@@ -52,6 +52,63 @@ module Memory
 					end
 				end
 				
+				# Prune this node's children, keeping only the top N by retained count.
+				# Prunes current level first, then recursively prunes retained children (top-down).
+				#
+				# @parameter limit [Integer] Number of children to keep.
+				# @returns [Integer] Total number of nodes pruned (discarded).
+				def prune!(limit)
+					return 0 if @children.nil?
+					
+					pruned_count = 0
+					
+					# Prune at this level first - keep only top N children by retained count
+					if @children.size > limit
+						sorted = @children.sort_by do |_location, child|
+							-child.retained_count  # Sort descending
+						end
+						
+						# Detach and count discarded subtrees before we discard them:
+						discarded = sorted.drop(limit)
+						discarded.each do |_location, child|
+							# detach! breaks references to aid GC and returns node count
+							pruned_count += child.detach!
+						end
+						
+						@children = sorted.first(limit).to_h
+					end
+					
+					# Now recursively prune the retained children (avoid pruning nodes we just discarded)
+					@children.each_value {|child| pruned_count += child.prune!(limit)}
+					
+					# Clean up if we ended up with no children
+					@children = nil if @children.empty?
+					
+					pruned_count
+				end
+				
+				# Detach this node from the tree, breaking parent/child relationships.
+				# This helps GC collect pruned nodes that might be retained in object_states.
+				#
+				# Recursively detaches all descendants and returns total nodes detached.
+				#
+				# @returns [Integer] Number of nodes detached (including self).
+				def detach!
+					count = 1  # Self
+					
+					# Recursively detach all children first and sum their counts
+					if @children
+						@children.each_value {|child| count += child.detach!}
+					end
+					
+					# Break all references
+					@parent = nil
+					@children = nil
+					@location = nil
+					
+					return count
+				end
+				
 				# Check if this node is a leaf (end of a call path).
 				#
 				# @returns [Boolean] True if this node has no children.
@@ -95,8 +152,12 @@ module Memory
 			# Create a new call tree for tracking allocation paths.
 			def initialize
 				@root = Node.new
+				@insertion_count = 0
 			end
 			
+			# @attribute [Integer] Number of insertions (allocations) recorded in this tree.
+			attr_accessor :insertion_count
+			
 			# Record an allocation with the given caller locations.
 			#
 			# @parameter caller_locations [Array<Thread::Backtrace::Location>] The call stack.
@@ -114,6 +175,9 @@ module Memory
 				# Increment counts for entire path (from leaf back to root):
 				current.increment_path!
 				
+				# Track total insertions
+				@insertion_count += 1
+				
 				# Return leaf node for object tracking:
 				current
 			end
@@ -122,7 +186,7 @@ module Memory
 			#
 			# @parameter limit [Integer] Maximum number of paths to return.
 			# @parameter by [Symbol] Sort by :total or :retained count.
-			# @returns [Array<Array>] Array of [locations, total_count, retained_count].
+			# @returns [Array(Array)] Array of [locations, total_count, retained_count].
 			def top_paths(limit = 10, by: :retained)
 				paths = []
 				
@@ -169,6 +233,16 @@ module Memory
 			# Clear all tracking data
 			def clear!
 				@root = Node.new
+				@insertion_count = 0
+			end
+			
+			# Prune the tree to keep only the top N children at each level.
+			# This controls memory usage by removing low-retained branches.
+			#
+			# @parameter limit [Integer] Number of children to keep per node (default: 5).
+			# @returns [Integer] Total number of nodes pruned (discarded).
+			def prune!(limit = 5)
+				@root.prune!(limit)
 			end
 			
 		private

data/lib/memory/profiler/sampler.rb

@@ -3,6 +3,8 @@
 # Released under the MIT License.
 # Copyright, 2025, by Samuel Williams.
 
+require "console"
+
 require_relative "capture"
 require_relative "call_tree"
 
@@ -83,21 +85,47 @@ module Memory
 				end
 			end
 			
-			attr_reader :depth
-			
 			# Create a new memory sampler.
 			#
 			# @parameter depth [Integer] Number of stack frames to capture for call path analysis.
 			# @parameter filter [Proc] Optional filter to exclude frames from call paths.
 			# @parameter increases_threshold [Integer] Number of increases before enabling detailed tracking.
-			def initialize(depth: 10, filter: nil, increases_threshold: 10)
+			# @parameter prune_limit [Integer] Keep only top N children per node during pruning (default: 5).
+			# @parameter prune_threshold [Integer] Number of insertions before auto-pruning (nil = no auto-pruning).
+			def initialize(depth: 4, filter: nil, increases_threshold: 10, prune_limit: 5, prune_threshold: nil)
 				@depth = depth
 				@filter = filter || default_filter
 				@increases_threshold = increases_threshold
+				@prune_limit = prune_limit
+				@prune_threshold = prune_threshold
 				@capture = Capture.new
 				@call_trees = {}
 				@samples = {}
 			end
+
+			# @attribute [Integer] The depth of the call tree.
+			attr :depth
+			
+			# @attribute [Proc] The filter to exclude frames from call paths.
+			attr :filter
+
+			# @attribute [Integer] The number of increases before enabling detailed tracking.
+			attr :increases_threshold
+
+			# @attribute [Integer] The number of insertions before auto-pruning (nil = no auto-pruning).
+			attr :prune_limit
+
+			# @attribute [Integer | Nil] The number of insertions before auto-pruning (nil = no auto-pruning).
+			attr :prune_threshold
+
+			# @attribute [Capture] The capture object.
+			attr :capture
+
+			# @attribute [Hash] The call trees.
+			attr :call_trees
+
+			# @attribute [Hash] The samples for each class being tracked.
+			attr :samples
 			
 			# Start capturing allocations.
 			def start
@@ -148,6 +176,9 @@ module Memory
 						yield sample if block_given?
 					end
 				end
+				
+				# Prune call trees to control memory usage
+				prune_call_trees!
 			end
 			
 			# Start tracking with call path analysis.
@@ -256,11 +287,37 @@ module Memory
 				@call_trees.clear
 			end
 			
-			private
+		private
 			
 			def default_filter
 				->(location) {!location.path.match?(%r{/(gems|ruby)/|\A\(eval\)})}
 			end
+			
+			def prune_call_trees!
+				return if @prune_threshold.nil?
+				
+				@call_trees.each do |klass, tree|
+					# Only prune if insertions exceed threshold:
+					insertions = tree.insertion_count
+					next if insertions < @prune_threshold
+					
+					# Prune the tree
+					pruned_count = tree.prune!(@prune_limit)
+					
+					# Reset insertion counter after pruning
+					tree.insertion_count = 0
+					
+					# Log pruning activity for visibility
+					if pruned_count > 0 && defined?(Console)
+						Console.debug(klass, "Pruned call tree:",
+							pruned_nodes: pruned_count,
+							insertions_since_last_prune: insertions,
+							total: tree.total_allocations,
+							retained: tree.retained_allocations
+						)
+					end
+				end
+			end
 		end
 	end
 end

data/lib/memory/profiler/version.rb

@@ -7,7 +7,7 @@
 module Memory
 	# @namespace
 	module Profiler
-		VERSION = "1.1.5"
+		VERSION = "1.1.7"
 	end
 end
 

data/readme.md

@@ -22,6 +22,16 @@ 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.7
+
+  - Expose `Capture#statistics` for debugging internal memory tracking state.
+
+### v1.1.6
+
+  - Write barriers all the things.
+  - Better state handling and object increment/decrement counting.
+  - Better call tree handling - including support for `prune!`.
+
 ### v1.1.5
 
   - Use queue for `newobj` too to avoid invoking user code during object allocation.

data/releases.md

@@ -1,5 +1,15 @@
 # Releases
 
+## v1.1.7
+
+  - Expose `Capture#statistics` for debugging internal memory tracking state.
+
+## v1.1.6
+
+  - Write barriers all the things.
+  - Better state handling and object increment/decrement counting.
+  - Better call tree handling - including support for `prune!`.
+
 ## v1.1.5
 
   - Use queue for `newobj` too to avoid invoking user code during object allocation.

metadata

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