memory-profiler 1.1.4 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c70385bac57de768e1f6eb3ca9044942a357d77c97967b30636acd89b1f051f4
-  data.tar.gz: 8c7ae2a117684e61d34e09e9b2ebb4a99ab440b1b31fee364d2a92bc6caf5cac
+  metadata.gz: ea6e765ad50aed3c3cf538d5c1a44f102f1bbe5251d5fd9c0995dd9d6890282a
+  data.tar.gz: dac87b8b0bd69f57ce3a290ef84f6eae56192ab422e554f861a2cb89b3cfa290
 SHA512:
-  metadata.gz: 50d848d974700ab480c805c82decf0fa58806be6f087ab4a199fa6b88963c303e459ca7a3ea2dabfea9d05bc55972edc1912917f49b46dc2752f1ea8f6d23f4b
-  data.tar.gz: 248a8fded6707058ccea2f9e1ee8eef074af4f8afeb5abfa9e786ef0e8c05efbd12fc8139eb887a156a84eaa05aba35f4dec1907426153ba935d0339198a5532
+  metadata.gz: cc91cd05c5cf0a2680fefe8745d8be48f7d85c0e7f358326da2ee0b58a07b01363fd9238b3b00bc9f17d5df8f216da726ebbf6dfdd77242685753ebf285183e9
+  data.tar.gz: df0498c707e90556d7df5319aa22775c1912f5961c5ea4f8d60f5314a9bdc8920ac60f367ef1d29e912789974857a3275af3e680a2ad2447651366e53d5685df

data/ext/memory/profiler/capture.c

@@ -13,7 +13,7 @@
 
 enum {
 	DEBUG = 0,
-	DEBUG_FREED_QUEUE = 0,
+	DEBUG_EVENT_QUEUES = 0,
 	DEBUG_STATE = 0,
 };
 
@@ -23,8 +23,20 @@ static VALUE Memory_Profiler_Capture = Qnil;
 static VALUE sym_newobj;
 static VALUE sym_freeobj;
 
-// Queue item - freed object data to be processed after GC
-struct Memory_Profiler_Queue_Item {
+// Queue item - new object data to be processed via postponed job
+struct Memory_Profiler_Newobj_Queue_Item {
+	// The class of the new object:
+	VALUE klass;
+
+	// The Allocations wrapper:
+	VALUE allocations;
+
+	// The newly allocated object:
+	VALUE object;
+};
+
+// Queue item - freed object data to be processed via postponed job
+struct Memory_Profiler_Freeobj_Queue_Item {
 	// The class of the freed object:
 	VALUE klass;
 
@@ -40,13 +52,19 @@ 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 freed objects (processed after GC via postponed job)
-	struct Memory_Profiler_Queue freed_queue;
+	// Queue for new objects (processed via postponed job):
+	struct Memory_Profiler_Queue newobj_queue;
+	
+	// Queue for freed objects (processed via postponed job):
+	struct Memory_Profiler_Queue freeobj_queue;
 	
-	// Handle for the postponed job
+	// Handle for the postponed job (processes both queues)
 	rb_postponed_job_handle_t postponed_job_handle;
 };
 
@@ -75,9 +93,17 @@ static void Memory_Profiler_Capture_mark(void *ptr) {
 		st_foreach(capture->tracked_classes, Memory_Profiler_Capture_tracked_classes_mark, 0);
 	}
 	
+	// Mark new objects in the queue:
+	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
+		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
+		rb_gc_mark_movable(newobj->klass);
+		rb_gc_mark_movable(newobj->allocations);
+		rb_gc_mark_movable(newobj->object);
+	}
+	
 	// Mark freed objects in the queue:
-	for (size_t i = 0; i < capture->freed_queue.count; i++) {
-		struct Memory_Profiler_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freed_queue, i);
+	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
+		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
 		rb_gc_mark_movable(freed->klass);
 		rb_gc_mark_movable(freed->allocations);
 
@@ -95,8 +121,9 @@ static void Memory_Profiler_Capture_free(void *ptr) {
 		st_free_table(capture->tracked_classes);
 	}
 	
-	// Free the queue (elements are stored directly, just free the queue)
-	Memory_Profiler_Queue_free(&capture->freed_queue);
+	// Free both queues (elements are stored directly, just free the queues)
+	Memory_Profiler_Queue_free(&capture->newobj_queue);
+	Memory_Profiler_Queue_free(&capture->freeobj_queue);
 	
 	xfree(capture);
 }
@@ -110,8 +137,9 @@ static size_t Memory_Profiler_Capture_memsize(const void *ptr) {
 		size += capture->tracked_classes->num_entries * (sizeof(st_data_t) + sizeof(struct Memory_Profiler_Capture_Allocations));
 	}
 	
-	// Add size of freed queue (elements stored directly)
-	size += capture->freed_queue.capacity * capture->freed_queue.element_size;
+	// Add size of both queues (elements stored directly)
+	size += capture->newobj_queue.capacity * capture->newobj_queue.element_size;
+	size += capture->freeobj_queue.capacity * capture->freeobj_queue.element_size;
 	
 	return size;
 }
@@ -152,9 +180,19 @@ static void Memory_Profiler_Capture_compact(void *ptr) {
 		}
 	}
 	
+	// Update new objects in the queue
+	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
+		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
+		
+		// Update all VALUEs if they moved during compaction
+		newobj->klass = rb_gc_location(newobj->klass);
+		newobj->allocations = rb_gc_location(newobj->allocations);
+		newobj->object = rb_gc_location(newobj->object);
+	}
+	
 	// Update freed objects in the queue
-	for (size_t i = 0; i < capture->freed_queue.count; i++) {
-		struct Memory_Profiler_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freed_queue, i);
+	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
+		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
 		
 		// Update all VALUEs if they moved during compaction
 		freed->klass = rb_gc_location(freed->klass);
@@ -192,18 +230,52 @@ const char *event_flag_name(rb_event_flag_t event_flag) {
 	}
 }
 
-// Postponed job callback - processes queued freed objects
-// This runs after GC completes, when it's safe to call Ruby code
-static void Memory_Profiler_Capture_process_freed_queue(void *arg) {
+// Postponed job callback - processes queued new and freed objects
+// This runs when it's safe to call Ruby code (not during allocation or GC)
+// IMPORTANT: Process newobj queue first, then freeobj queue to maintain order
+static void Memory_Profiler_Capture_process_queues(void *arg) {
 	VALUE self = (VALUE)arg;
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	if (DEBUG_FREED_QUEUE) fprintf(stderr, "Processing freed queue with %zu entries\n", capture->freed_queue.count);
+	if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Processing queues: %zu newobj, %zu freeobj\n", 
+		capture->newobj_queue.count, capture->freeobj_queue.count);
+	
+	// Disable tracking during queue processing to prevent infinite loop
+	// (rb_funcall can allocate, which would trigger more NEWOBJ events)
+	int was_enabled = capture->enabled;
+	capture->enabled = 0;
+	
+	// First, process all new objects in the queue
+	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
+		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
+		VALUE klass = newobj->klass;
+		VALUE allocations = newobj->allocations;
+		VALUE object = newobj->object;
+		
+		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
+		
+		// Call the Ruby callback with (klass, :newobj, nil) - callback returns state to store
+		if (!NIL_P(record->callback)) {
+			VALUE state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
+			
+			// Store the state if callback returned something
+			if (!NIL_P(state)) {
+				if (!record->object_states) {
+					record->object_states = st_init_numtable();
+				}
+				
+				if (DEBUG_STATE) fprintf(stderr, "Memory_Profiler_Capture_process_queues: Storing state for object: %p (%s)\n", 
+					(void *)object, rb_class2name(klass));
+
+				st_insert(record->object_states, (st_data_t)object, (st_data_t)state);
+			}
+		}
+	}
 	
-	// Process all freed objects in the queue
-	for (size_t i = 0; i < capture->freed_queue.count; i++) {
-		struct Memory_Profiler_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freed_queue, i);
+	// Then, process all freed objects in the queue
+	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
+		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
 		VALUE klass = freed->klass;
 		VALUE allocations = freed->allocations;
 		VALUE state = freed->state;
@@ -216,41 +288,46 @@ static void Memory_Profiler_Capture_process_freed_queue(void *arg) {
 		}
 	}
 	
-	// Clear the queue (elements are reused on next cycle)
-	Memory_Profiler_Queue_clear(&capture->freed_queue);
+	// Clear both queues (elements are reused on next cycle)
+	Memory_Profiler_Queue_clear(&capture->newobj_queue);
+	Memory_Profiler_Queue_clear(&capture->freeobj_queue);
+	
+	// Restore tracking state
+	capture->enabled = was_enabled;
 }
 
 // Handler for NEWOBJ event
+// SAFE: No longer calls Ruby code directly - queues for deferred processing
 static void Memory_Profiler_Capture_newobj_handler(VALUE self, struct Memory_Profiler_Capture *capture, VALUE klass, VALUE object) {
 	st_data_t allocations_data;
 	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 (!NIL_P(record->callback)) {
-			// Invoke callback - runs during NEWOBJ with GC disabled
-			// CRITICAL CALLBACK REQUIREMENTS:
-			// - Must be FAST (runs on EVERY allocation)
-			// - Must NOT call GC.start (will deadlock)
-			// - Must NOT block/sleep (stalls all allocations system-wide)
-			// - Should NOT raise exceptions (will propagate to allocating code)
-			// - Avoid allocating objects (causes re-entry)
-			
-			// Call with (klass, :newobj, nil) - callback returns state to store
-			VALUE state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
-			
-			// Store the state if callback returned something
-			if (!NIL_P(state)) {
-				if (!record->object_states) {
-					record->object_states = st_init_numtable();
-				}
+		
+		// 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);
 				
-				if (DEBUG_STATE) fprintf(stderr, "Memory_Profiler_Capture_newobj_handler: Inserting state for object: %p (%s)\n", (void *)object, rb_class2name(klass));
-
-				st_insert(record->object_states, (st_data_t)object, (st_data_t)state);
-				// Notify GC about the state VALUE stored in the table
-				RB_OBJ_WRITTEN(self, Qnil, state);
+				// 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");
+				rb_postponed_job_trigger(capture->postponed_job_handle);
+			} else {
+				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Failed to queue newobj, out of memory\n");
 			}
+			// If push failed (out of memory), silently drop this newobj event
 		}
 	} else {
 		// Create record for this class (first time seeing it)
@@ -279,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
@@ -293,19 +373,22 @@ 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_Queue_Item *freed = Memory_Profiler_Queue_push(&capture->freed_queue);
-				if (freed) {
-					if (DEBUG_FREED_QUEUE) fprintf(stderr, "Queued freed object, queue size now: %zu/%zu\n", capture->freed_queue.count, capture->freed_queue.capacity);
-					// Write directly to the allocated space
-					freed->klass = klass;
-					freed->allocations = allocations;
-					freed->state = state;
+				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);
 					
-					// Trigger postponed job to process the queue after GC
-					if (DEBUG_FREED_QUEUE) fprintf(stderr, "Triggering postponed job to process the queue after GC\n");
+					// 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");
 					rb_postponed_job_trigger(capture->postponed_job_handle);
 				} else {
-					if (DEBUG_FREED_QUEUE) fprintf(stderr, "Failed to queue freed object, out of memory\n");
+					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Failed to queue freed object, out of memory\n");
 				}
 				// If push failed (out of memory), silently drop this freeobj event
 			}
@@ -356,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:
@@ -401,16 +482,19 @@ 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 the freed object queue
-	Memory_Profiler_Queue_initialize(&capture->freed_queue, sizeof(struct Memory_Profiler_Queue_Item));
+	// Initialize both queues
+	Memory_Profiler_Queue_initialize(&capture->newobj_queue, sizeof(struct Memory_Profiler_Newobj_Queue_Item));
+	Memory_Profiler_Queue_initialize(&capture->freeobj_queue, sizeof(struct Memory_Profiler_Freeobj_Queue_Item));
 	
-	// Pre-register the postponed job for processing freed objects
-	// The job will be triggered whenever we queue freed objects during GC
+	// Pre-register the postponed job for processing both queues
+	// The job will be triggered whenever we queue newobj or freeobj events
 	capture->postponed_job_handle = rb_postponed_job_preregister(
 		0, // flags
-		Memory_Profiler_Capture_process_freed_queue,
+		Memory_Profiler_Capture_process_queues,
 		(void *)obj
 	);
 	
@@ -431,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(
@@ -441,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;
@@ -451,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.4"
+		VERSION = "1.1.6"
 	end
 end
 

data/readme.md

@@ -22,9 +22,19 @@ 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.
+
 ### v1.1.2
 
-    - Fix handling of GC compaction (I hope).
+  - Fix handling of GC compaction (I hope).
 
 ### v0.1.0
 

data/releases.md

@@ -1,8 +1,18 @@
 # 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.
+
 ## v1.1.2
 
-    - Fix handling of GC compaction (I hope).
+  - Fix handling of GC compaction (I hope).
 
 ## v0.1.0
 

data.tar.gz.sig

@@ -1,7 +1,3 @@
-�(�Q�"��	D���#	>�t&ކN
-��ӧ�6ʲW����~hELJ�dܺ}�����Z�Jг�dӇ�{Dy�)-�\&��'ԩ�}R��7`E�5n�s
-�t�~
-�|L�y�8��I�/D�gƎ@pm��1ɪL�٦����bm!�ח��uu��PYx�ǚ]�k/9�A=�Ɋ
-�5u�
-�9!�2G�����*����u\d�!.�O_.�ˆ�� %�̠����
-�1ܧ��~��S?�ywX,Z�\>e�J�nM���퉦ja�Յ/�Qk���L���B��Ne6���سa��TE�����'�J$ke�`e��p7���n������Et	�͝�2	l����M;�d��D>$,�����%Yd��9]L���{
+5�Ԝ��(�8�׾�x��^i;��^hC��o���V�����9���WBK�Lu�s�ҕ��g3��Ι���'@�P�
+�
+Sb'ɻ�mao�E�^D���ѫ�-�g����W� ��W����'�����>��E��AK������a��I�+�0٢<+�|�IЂ�%��'x|��!?�if)e*�vf���+���f����Py,#��z����6}��!0\*+*v���&����yL�����x^�})kt)�-+̠����YZ�enM��`葉�������.�j�Ǫ��Fiϕ�=���q.�f���G_��$w8��벡q9��O�N�P��:��>���ɯYO�\�N��㯴

metadata

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