memory-profiler 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45474399b764a755546268feed4710ae9c647a8265cd933be82e35b1f390e820
-  data.tar.gz: 47d263fc3fa31b8013d7eded37f22e74b8912b3029d6b5d9051f3a35e1b4aa6a
+  metadata.gz: ea6e765ad50aed3c3cf538d5c1a44f102f1bbe5251d5fd9c0995dd9d6890282a
+  data.tar.gz: dac87b8b0bd69f57ce3a290ef84f6eae56192ab422e554f861a2cb89b3cfa290
 SHA512:
-  metadata.gz: d4afc54d3841e0517e966ca0e5015320cacdc747a0ed1b2004b3b5ed043345139e3d7125ee79a4ff8bc3781f04d88399f2373553fe870143adf92b7b745fe97c
-  data.tar.gz: e99bbeda7a53e23c30e90981711f88651fd7efd453d86ba9748b11485dd2fcad6562038b91390a1f692694508e71c0aa4221ec25f2ebe61663835f667973292e
+  metadata.gz: cc91cd05c5cf0a2680fefe8745d8be48f7d85c0e7f358326da2ee0b58a07b01363fd9238b3b00bc9f17d5df8f216da726ebbf6dfdd77242685753ebf285183e9
+  data.tar.gz: df0498c707e90556d7df5319aa22775c1912f5961c5ea4f8d60f5314a9bdc8920ac60f367ef1d29e912789974857a3275af3e680a2ad2447651366e53d5685df

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;

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"
 
@@ -90,10 +92,14 @@ module Memory
 			# @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 = {}
@@ -148,6 +154,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 +265,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.6"
 	end
 end
 

data/readme.md

@@ -22,6 +22,12 @@ 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.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,11 @@
 # Releases
 
+## 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.6
 platform: ruby
 authors:
 - Samuel Williams