fiber-profiler 0.1.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eff364d5f9fc0850ed71072242195873f790518f3f10b784329fe31dafcbf6f
-  data.tar.gz: ad7c9544f0d14fa2b2085d91d9211c7bcb42dc26e0840ca19bf7c064c5067cba
+  metadata.gz: 763fd680dafd595bcfdb69ffcac3161ab2c21ffe4ddeb54110d30b26af78c645
+  data.tar.gz: 7619a44d197a88b4ecb2f24e3e48a4d4e8a660f7fc9bd1d6cc0482bad45df92f
 SHA512:
-  metadata.gz: '069d76a3551bd65c3cf877e371f00c5dd57c3b0bb8c1d937f7187a291adca561b85628ed46b28b3ad2325e6e37e1da1ec4480cb7f4ef4e180b91c55ffd6fcea6'
-  data.tar.gz: d44f0981b66d6fc382005e13e2900b1c56cc879993d6dd0c141293b1b5ed6223e81e3201ce2e345cfa4e663b8e1b42ce3bacea53b7abff9db901470fc897d0df
+  metadata.gz: 968cc396e79c7030a7fa2d384b21dd0491f4d4ea03c2173cfe1c1081d982cc6976ba32c023a676deab5dfc748b1dbc320d9f1087f41532249484f647a62b1f94
+  data.tar.gz: 1b68a1bfccf03defd375fe90da755b33fd9da19155bfac3b7b03208a664075c3469518077c0270102f36f07b44b4016ce8fd96dd1969701370f14ccd526816b3

data/ext/fiber/profiler/capture.c

@@ -19,6 +19,7 @@ enum {
 
 int Fiber_Profiler_capture_p = 0;
 double Fiber_Profiler_Capture_stall_threshold = 0.01;
+double Fiber_Profiler_Capture_filter_threshold = 0.001;
 int Fiber_Profiler_Capture_track_calls = 1;
 double Fiber_Profiler_Capture_sample_rate = 1;
 
@@ -65,7 +66,7 @@ void Fiber_Profiler_Stream_free(struct Fiber_Profiler_Stream *stream) {
 }
 
 struct Fiber_Profiler_Capture;
-typedef void(*Fiber_Profiler_Stream_Print)(struct Fiber_Profiler_Capture*, FILE* restrict);
+typedef void(*Fiber_Profiler_Stream_Print)(struct Fiber_Profiler_Capture*, FILE* restrict, double duration);
 
 struct Fiber_Profiler_Capture {
 	// The threshold in seconds, which determines when a fiber is considered to have stalled the event loop.
@@ -74,7 +75,7 @@ struct Fiber_Profiler_Capture {
 	// Whether or not to track calls.
 	int track_calls;
 	
-	// The sample rate of the profiler, as a fraction of 1.0, which controls how often the profiler will sample between fiber context switches.
+	// The sample rate of the capture, as a fraction of 1.0, which controls how often the profiler will sample between fiber context switches.
 	double sample_rate;
 	
 	// Calls that are shorter than this filter threshold will be ignored.
@@ -89,6 +90,15 @@ struct Fiber_Profiler_Capture {
 	// The stream buffer used for printing.
 	struct Fiber_Profiler_Stream stream;
 	
+	// How many fiber context switches have been encountered. Not all of them will be sampled, based on the sample rate.
+	size_t switches;
+
+	// How many samples have been taken, not all of them will be stalls, based on the stall threshold.
+	size_t samples;
+	
+	// The number of stalls encountered and printed.
+	size_t stalls;
+	
 	// Whether or not the profiler is currently running.
 	int running;
 	
@@ -98,14 +108,11 @@ struct Fiber_Profiler_Capture {
 	// Whether or not to capture call data.
 	int capture;
 	
-	// The number of stalls encountered.
-	size_t stalls;
-	
 	// The start time of the profile.
 	struct timespec start_time;
 	
-	// The stop time of the profile.
-	struct timespec stop_time;
+	// The time of the last fiber switch that was sampled.
+	struct timespec switch_time;
 	
 	// The depth of the call stack (can be negative).
 	int nesting;
@@ -120,13 +127,6 @@ struct Fiber_Profiler_Capture {
 	struct Fiber_Profiler_Deque calls;
 };
 
-void Fiber_Profiler_Capture_reset(struct Fiber_Profiler_Capture *profiler) {
-	profiler->nesting = 0;
-	profiler->nesting_minimum = 0;
-	profiler->current = NULL;
-	Fiber_Profiler_Deque_truncate(&profiler->calls);
-}
-
 void Fiber_Profiler_Capture_Call_initialize(void *element) {
 	struct Fiber_Profiler_Capture_Call *call = element;
 	
@@ -155,43 +155,43 @@ void Fiber_Profiler_Capture_Call_free(void *element) {
 }
 
 static void Fiber_Profiler_Capture_mark(void *ptr) {
-	struct Fiber_Profiler_Capture *profiler = (struct Fiber_Profiler_Capture*)ptr;
+	struct Fiber_Profiler_Capture *capture = (struct Fiber_Profiler_Capture*)ptr;
 	
-	rb_gc_mark_movable(profiler->thread);
-	rb_gc_mark_movable(profiler->output);
+	rb_gc_mark_movable(capture->thread);
+	rb_gc_mark_movable(capture->output);
 	
 	// If `klass` is stored as a VALUE in calls, we need to mark them here:
-	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
+	Fiber_Profiler_Deque_each(&capture->calls, struct Fiber_Profiler_Capture_Call, call) {
 		rb_gc_mark_movable(call->klass);
 	}
 }
 
 static void Fiber_Profiler_Capture_compact(void *ptr) {
-	struct Fiber_Profiler_Capture *profiler = (struct Fiber_Profiler_Capture*)ptr;
+	struct Fiber_Profiler_Capture *capture = (struct Fiber_Profiler_Capture*)ptr;
 	
-	profiler->thread = rb_gc_location(profiler->thread);
-	profiler->output = rb_gc_location(profiler->output);
+	capture->thread = rb_gc_location(capture->thread);
+	capture->output = rb_gc_location(capture->output);
 	
 	// If `klass` is stored as a VALUE in calls, we need to update their locations here:
-	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
+	Fiber_Profiler_Deque_each(&capture->calls, struct Fiber_Profiler_Capture_Call, call) {
 		call->klass = rb_gc_location(call->klass);
 	}
 }
 
 static void Fiber_Profiler_Capture_free(void *ptr) {
-	struct Fiber_Profiler_Capture *profiler = (struct Fiber_Profiler_Capture*)ptr;
+	struct Fiber_Profiler_Capture *capture = (struct Fiber_Profiler_Capture*)ptr;
 	
-	RUBY_ASSERT(profiler->running == 0);
+	RUBY_ASSERT(capture->running == 0);
 	
-	Fiber_Profiler_Stream_free(&profiler->stream);
-	Fiber_Profiler_Deque_free(&profiler->calls);
+	Fiber_Profiler_Stream_free(&capture->stream);
+	Fiber_Profiler_Deque_free(&capture->calls);
 	
-	free(profiler);
+	free(capture);
 }
 
 static size_t Fiber_Profiler_Capture_memsize(const void *ptr) {
-	const struct Fiber_Profiler_Capture *profiler = (const struct Fiber_Profiler_Capture*)ptr;
-	return sizeof(*profiler) + Fiber_Profiler_Deque_memory_size(&profiler->calls);
+	const struct Fiber_Profiler_Capture *capture = (const struct Fiber_Profiler_Capture*)ptr;
+	return sizeof(*capture) + Fiber_Profiler_Deque_memory_size(&capture->calls);
 }
 
 const rb_data_type_t Fiber_Profiler_Capture_Type = {
@@ -206,9 +206,9 @@ const rb_data_type_t Fiber_Profiler_Capture_Type = {
 };
 
 struct Fiber_Profiler_Capture *Fiber_Profiler_Capture_get(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler;
-	TypedData_Get_Struct(self, struct Fiber_Profiler_Capture, &Fiber_Profiler_Capture_Type, profiler);
-	return profiler;
+	struct Fiber_Profiler_Capture *capture;
+	TypedData_Get_Struct(self, struct Fiber_Profiler_Capture, &Fiber_Profiler_Capture_Type, capture);
+	return capture;
 }
 
 int IO_istty(VALUE io) {
@@ -220,78 +220,83 @@ int IO_istty(VALUE io) {
 	return 0;
 }
 
-void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream);
-void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream);
+void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *capture, FILE *restrict stream, double duration);
+void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *capture, FILE *restrict stream, double duration);
 
-static void Fiber_Profiler_Capture_output_set(struct Fiber_Profiler_Capture *profiler, VALUE output) {
-	profiler->output = output;
+static void Fiber_Profiler_Capture_output_set(struct Fiber_Profiler_Capture *capture, VALUE output) {
+	capture->output = output;
 	
-	if (IO_istty(profiler->output)) {
-		profiler->print = &Fiber_Profiler_Capture_print_tty;
+	if (IO_istty(capture->output)) {
+		capture->print = &Fiber_Profiler_Capture_print_tty;
 	} else {
-		profiler->print = &Fiber_Profiler_Capture_print_json;
+		capture->print = &Fiber_Profiler_Capture_print_json;
 	}
 }
 
 VALUE Fiber_Profiler_Capture_allocate(VALUE klass) {
-	struct Fiber_Profiler_Capture *profiler = ALLOC(struct Fiber_Profiler_Capture);
+	struct Fiber_Profiler_Capture *capture = ALLOC(struct Fiber_Profiler_Capture);
 	
 	// Initialize the profiler state:
-	Fiber_Profiler_Stream_initialize(&profiler->stream);
-	profiler->output = Qnil;
+	Fiber_Profiler_Stream_initialize(&capture->stream);
+	capture->output = Qnil;
 	
-	profiler->running = 0;
-	profiler->thread = Qnil;
+	capture->switches = 0;
+	capture->samples = 0;
+	capture->stalls = 0;
 	
-	profiler->capture = 0;
-	profiler->stalls = 0;
-	profiler->nesting = 0;
-	profiler->nesting_minimum = 0;
-	profiler->current = NULL;
+	capture->running = 0;
+	capture->thread = Qnil;
 	
-	profiler->stall_threshold = Fiber_Profiler_Capture_stall_threshold;
-	profiler->track_calls = Fiber_Profiler_Capture_track_calls;
-	profiler->sample_rate = Fiber_Profiler_Capture_sample_rate;
+	capture->capture = 0;
+	capture->nesting = 0;
+	capture->nesting_minimum = 0;
+	capture->current = NULL;
 	
-	// Filter calls that are less than 10% of the stall threshold:
-	profiler->filter_threshold = profiler->stall_threshold * 0.1;
+	capture->stall_threshold = Fiber_Profiler_Capture_stall_threshold;
+	capture->filter_threshold = Fiber_Profiler_Capture_filter_threshold;
+	capture->track_calls = Fiber_Profiler_Capture_track_calls;
+	capture->sample_rate = Fiber_Profiler_Capture_sample_rate;
 	
-	profiler->calls.element_initialize = (void (*)(void*))Fiber_Profiler_Capture_Call_initialize;
-	profiler->calls.element_free = (void (*)(void*))Fiber_Profiler_Capture_Call_free;
+	capture->calls.element_initialize = (void (*)(void*))Fiber_Profiler_Capture_Call_initialize;
+	capture->calls.element_free = (void (*)(void*))Fiber_Profiler_Capture_Call_free;
 	
-	Fiber_Profiler_Deque_initialize(&profiler->calls, sizeof(struct Fiber_Profiler_Capture_Call));
-	Fiber_Profiler_Deque_reserve_default(&profiler->calls);
+	Fiber_Profiler_Deque_initialize(&capture->calls, sizeof(struct Fiber_Profiler_Capture_Call));
+	Fiber_Profiler_Deque_reserve_default(&capture->calls);
 	
-	return TypedData_Wrap_Struct(klass, &Fiber_Profiler_Capture_Type, profiler);
+	return TypedData_Wrap_Struct(klass, &Fiber_Profiler_Capture_Type, capture);
 }
 
-ID Fiber_Profiler_Capture_initialize_options[4];
+ID Fiber_Profiler_Capture_initialize_options[5];
 
 VALUE Fiber_Profiler_Capture_initialize(int argc, VALUE *argv, VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	VALUE arguments[4] = {0};
+	VALUE arguments[5] = {0};
 	VALUE options = Qnil;
 	rb_scan_args(argc, argv, ":", &options);
-	rb_get_kwargs(options, Fiber_Profiler_Capture_initialize_options, 0, 4, arguments);
+	rb_get_kwargs(options, Fiber_Profiler_Capture_initialize_options, 0, 5, arguments);
 	
 	if (arguments[0] != Qundef) {
-		profiler->stall_threshold = NUM2DBL(arguments[0]);
+		capture->stall_threshold = NUM2DBL(arguments[0]);
 	}
 	
 	if (arguments[1] != Qundef) {
-		profiler->track_calls = RB_TEST(arguments[1]);
+		capture->filter_threshold = NUM2DBL(arguments[1]);
 	}
 	
 	if (arguments[2] != Qundef) {
-		profiler->sample_rate = NUM2DBL(arguments[2]);
+		capture->track_calls = RB_TEST(arguments[2]);
 	}
 	
 	if (arguments[3] != Qundef) {
-		Fiber_Profiler_Capture_output_set(profiler, arguments[3]);
+		capture->sample_rate = NUM2DBL(arguments[3]);
+	}
+	
+	if (arguments[4] != Qundef) {
+		Fiber_Profiler_Capture_output_set(capture, arguments[4]);
 	} else {
 		// Initialize the profiler output - we dup `rb_stderr` because the profiler may otherwise run into synchronization issues with other uses of `rb_stderr`:
-		Fiber_Profiler_Capture_output_set(profiler, rb_obj_dup(rb_stderr));
+		Fiber_Profiler_Capture_output_set(capture, rb_obj_dup(rb_stderr));
 	}
 	
 	return self;
@@ -302,10 +307,10 @@ VALUE Fiber_Profiler_Capture_default(VALUE klass) {
 		return Qnil;
 	}
 	
-	VALUE profiler = Fiber_Profiler_Capture_allocate(klass);
-	Fiber_Profiler_Capture_initialize(0, NULL, profiler);
+	VALUE capture = Fiber_Profiler_Capture_allocate(klass);
+	Fiber_Profiler_Capture_initialize(0, NULL, capture);
 	
-	return profiler;
+	return capture;
 }
 
 int event_flag_call_p(rb_event_flag_t event_flags) {
@@ -332,19 +337,19 @@ const char *event_flag_name(rb_event_flag_t event_flag) {
 	}
 }
 
-static struct Fiber_Profiler_Capture_Call* Fiber_Profiler_Capture_Call_new(struct Fiber_Profiler_Capture *profiler, rb_event_flag_t event_flag, ID id, VALUE klass) {
-	struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Deque_push(&profiler->calls);
+static struct Fiber_Profiler_Capture_Call* Fiber_Profiler_Capture_Call_new(struct Fiber_Profiler_Capture *capture, rb_event_flag_t event_flag, ID id, VALUE klass) {
+	struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Deque_push(&capture->calls);
 	
 	call->event_flag = event_flag;
 
-	call->parent = profiler->current;
+	call->parent = capture->current;
 	if (call->parent) {
 		call->parent->children += 1;
 	}
 	
-	profiler->current = call;
+	capture->current = call;
 	
-	call->nesting = profiler->nesting;
+	call->nesting = capture->nesting;
 
 	if (id) {
 		call->id = id;
@@ -363,15 +368,20 @@ static struct Fiber_Profiler_Capture_Call* Fiber_Profiler_Capture_Call_new(struc
 }
 
 // Finish the call by calculating the duration and filtering it if necessary.
-int Fiber_Profiler_Capture_Call_finish(struct Fiber_Profiler_Capture *profiler, struct Fiber_Profiler_Capture_Call *call) {
+int Fiber_Profiler_Capture_Call_finish(struct Fiber_Profiler_Capture *capture, struct Fiber_Profiler_Capture_Call *call) {
 	// Don't filter calls if we're not running:
 	if (DEBUG_FILTERED) return 0;
 	
-	if (call->duration < profiler->filter_threshold) {
+	if (event_flag_return_p(call->event_flag)) {
+		// We don't filter return statements, as they are always part of the call stack:
+		return 0;
+	}
+	
+	if (call->duration < capture->filter_threshold) {
 		// We can only remove calls from the end of the deque, otherwise they might be referenced by other calls:
-		if (call == Fiber_Profiler_Deque_last(&profiler->calls)) {
-			if (profiler->current == call) {
-				profiler->current = call->parent;
+		if (call == Fiber_Profiler_Deque_last(&capture->calls)) {
+			if (capture->current == call) {
+				capture->current = call->parent;
 			}
 			
 			if (call->parent) {
@@ -380,7 +390,7 @@ int Fiber_Profiler_Capture_Call_finish(struct Fiber_Profiler_Capture *profiler,
 				call->parent = NULL;
 			}
 			
-			Fiber_Profiler_Deque_pop(&profiler->calls);
+			Fiber_Profiler_Deque_pop(&capture->calls);
 			
 			return 1;
 		}
@@ -389,10 +399,11 @@ int Fiber_Profiler_Capture_Call_finish(struct Fiber_Profiler_Capture *profiler,
 	return 0;
 }
 
+// Whether to highlight a call as expensive. This is purely cosmetic.
 static const double Fiber_Profiler_Capture_Call_EXPENSIVE_THRESHOLD = 0.2;
 
-int Fiber_Profiler_Capture_Call_expensive_p(struct Fiber_Profiler_Capture_Call *call, double total_duration) {
-	if (call->duration > total_duration * Fiber_Profiler_Capture_Call_EXPENSIVE_THRESHOLD) {
+int Fiber_Profiler_Capture_Call_expensive_p(struct Fiber_Profiler_Capture *capture, struct Fiber_Profiler_Capture_Call *call, double duration) {
+	if (call->duration > duration * Fiber_Profiler_Capture_Call_EXPENSIVE_THRESHOLD) {
 		return 1;
 	}
 	
@@ -400,57 +411,63 @@ int Fiber_Profiler_Capture_Call_expensive_p(struct Fiber_Profiler_Capture_Call *
 }
 
 static void Fiber_Profiler_Capture_callback(rb_event_flag_t event_flag, VALUE data, VALUE self, ID id, VALUE klass) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(data);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(data);
 	
 	// We don't want to capture data if we're not running:
-	if (!profiler->capture) return;
+	if (!capture->capture) return;
 	
 	if (event_flag_call_p(event_flag)) {
-		struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Capture_Call_new(profiler, event_flag, id, klass);
+		struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Capture_Call_new(capture, event_flag, id, klass);
 		
-		profiler->nesting += 1;
+		capture->nesting += 1;
 		
 		Fiber_Profiler_Time_current(&call->enter_time);
 	}
 	
 	else if (event_flag_return_p(event_flag)) {
-		struct Fiber_Profiler_Capture_Call *call = profiler->current;
+		struct Fiber_Profiler_Capture_Call *call = capture->current;
 		
 		// We may encounter returns without a preceeding call. This isn't an error, but we should pretend like the call started at the beginning of the profiling session:
 		if (call == NULL) {
-			struct Fiber_Profiler_Capture_Call *last_call = Fiber_Profiler_Deque_last(&profiler->calls);
-			call = Fiber_Profiler_Capture_Call_new(profiler, event_flag, id, klass);
+			struct Fiber_Profiler_Capture_Call *last_call = Fiber_Profiler_Deque_last(&capture->calls);
+			call = Fiber_Profiler_Capture_Call_new(capture, event_flag, id, klass);
+			
+			struct timespec call_time;
 			
 			if (last_call) {
-				call->enter_time = last_call->enter_time;
+				call_time = last_call->enter_time;
 			} else {
-				call->enter_time = profiler->start_time;
+				call_time = capture->switch_time;
 			}
+			
+			// For return statements, we record the current time as the enter time:
+			Fiber_Profiler_Time_current(&call->enter_time);
+			call->duration = Fiber_Profiler_Time_delta(&call_time, &call->enter_time);
+		} else {
+			call->duration = Fiber_Profiler_Time_delta_current(&call->enter_time);
 		}
 		
-		call->duration = Fiber_Profiler_Time_delta_current(&call->enter_time);
-		
-		profiler->current = call->parent;
+		capture->current = call->parent;
 		
 		// We may encounter returns without a preceeding call.
-		profiler->nesting -= 1;
+		capture->nesting -= 1;
 		
 		// We need to keep track of how deep the call stack goes:
-		if (profiler->nesting < profiler->nesting_minimum) {
-			profiler->nesting_minimum = profiler->nesting;
+		if (capture->nesting < capture->nesting_minimum) {
+			capture->nesting_minimum = capture->nesting;
 		}
 		
-		Fiber_Profiler_Capture_Call_finish(profiler, call);
+		Fiber_Profiler_Capture_Call_finish(capture, call);
 	}
 	
 	else {
-		struct Fiber_Profiler_Capture_Call *last_call = Fiber_Profiler_Deque_last(&profiler->calls);
-		struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Capture_Call_new(profiler, event_flag, id, klass);
+		struct Fiber_Profiler_Capture_Call *last_call = Fiber_Profiler_Deque_last(&capture->calls);
+		struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Capture_Call_new(capture, event_flag, id, klass);
 		
 		if (last_call) {
 			call->enter_time = last_call->enter_time;
 		} else {
-			call->enter_time = profiler->start_time;
+			call->enter_time = capture->switch_time;
 		}
 		
 		call->duration = Fiber_Profiler_Time_delta_current(&call->enter_time);
@@ -458,35 +475,35 @@ static void Fiber_Profiler_Capture_callback(rb_event_flag_t event_flag, VALUE da
 }
 
 void Fiber_Profiler_Capture_pause(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	if (!profiler->capture) return;
+	if (!capture->capture) return;
+	capture->capture = 0;
 	
-	profiler->capture = 0;
-	
-	rb_thread_remove_event_hook_with_data(profiler->thread, Fiber_Profiler_Capture_callback, self);
+	if (capture->track_calls) {
+		rb_thread_remove_event_hook_with_data(capture->thread, Fiber_Profiler_Capture_callback, self);
+	}
 }
 
 void Fiber_Profiler_Capture_resume(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
-	
-	if (profiler->capture) return;
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	profiler->capture = 1;
+	if (capture->capture) return;
+	capture->capture = 1;
+	capture->samples += 1;
 	
-	rb_event_flag_t event_flags = 0;
-	
-	if (profiler->track_calls) {
-		// event_flags |= RUBY_EVENT_LINE;
+	if (capture->track_calls) {
+		rb_event_flag_t event_flags = 0;
 		
+		// event_flags |= RUBY_EVENT_LINE;
 		event_flags |= RUBY_EVENT_CALL | RUBY_EVENT_RETURN;
 		event_flags |= RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN;
 		event_flags |= RUBY_EVENT_B_CALL | RUBY_EVENT_B_RETURN;
+		
+		// CRuby will raise an exception if you try to add "INTERNAL_EVENT" hooks at the same time as other hooks, so we do it in two calls:
+		rb_thread_add_event_hook(capture->thread, Fiber_Profiler_Capture_callback, event_flags, self);
+		rb_thread_add_event_hook(capture->thread, Fiber_Profiler_Capture_callback, RUBY_INTERNAL_EVENT_GC_START | RUBY_INTERNAL_EVENT_GC_END_SWEEP, self);
 	}
-	
-	// CRuby will raise an exception if you try to add "INTERNAL_EVENT" hooks at the same time as other hooks, so we do it in two calls:
-	rb_thread_add_event_hook(profiler->thread, Fiber_Profiler_Capture_callback, event_flags, self);
-	rb_thread_add_event_hook(profiler->thread, Fiber_Profiler_Capture_callback, RUBY_INTERNAL_EVENT_GC_START | RUBY_INTERNAL_EVENT_GC_END_SWEEP, self);
 }
 
 void Fiber_Profiler_Capture_fiber_switch(VALUE self);
@@ -495,68 +512,70 @@ void Fiber_Profiler_Capture_fiber_switch_callback(rb_event_flag_t event_flag, VA
 	Fiber_Profiler_Capture_fiber_switch(data);
 }
 
+// Reset the sample state, and truncate the call log.
+void Fiber_Profiler_Capture_reset(struct Fiber_Profiler_Capture *capture) {
+	capture->nesting = 0;
+	capture->nesting_minimum = 0;
+	capture->current = NULL;
+	Fiber_Profiler_Deque_truncate(&capture->calls);
+}
+
 VALUE Fiber_Profiler_Capture_start(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	if (profiler->running) return Qfalse;
+	if (capture->running) return Qfalse;
 	
-	profiler->running = 1;
-	profiler->thread = rb_thread_current();
+	capture->running = 1;
+	capture->thread = rb_thread_current();
 	
-	Fiber_Profiler_Capture_reset(profiler);
-	Fiber_Profiler_Time_current(&profiler->start_time);
+	Fiber_Profiler_Capture_reset(capture);
+	Fiber_Profiler_Time_current(&capture->start_time);
 	
-	rb_thread_add_event_hook(profiler->thread, Fiber_Profiler_Capture_fiber_switch_callback, RUBY_EVENT_FIBER_SWITCH, self);
+	rb_thread_add_event_hook(capture->thread, Fiber_Profiler_Capture_fiber_switch_callback, RUBY_EVENT_FIBER_SWITCH, self);
 	
 	return self;
 }
 
 VALUE Fiber_Profiler_Capture_stop(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	if (!profiler->running) return Qfalse;
+	if (!capture->running) return Qfalse;
 	
 	Fiber_Profiler_Capture_pause(self);
 	
-	rb_thread_remove_event_hook_with_data(profiler->thread, Fiber_Profiler_Capture_fiber_switch_callback, self);
+	rb_thread_remove_event_hook_with_data(capture->thread, Fiber_Profiler_Capture_fiber_switch_callback, self);
 	
-	profiler->running = 0;
-	profiler->thread = Qnil;
-		
-	Fiber_Profiler_Time_current(&profiler->stop_time);
-	Fiber_Profiler_Capture_reset(profiler);
+	capture->running = 0;
+	capture->thread = Qnil;
+	
+	Fiber_Profiler_Capture_reset(capture);
 	
 	return self;
 }
 
-void Fiber_Profiler_Capture_finish(struct Fiber_Profiler_Capture *profiler) {
-	profiler->capture = 0;
-	
-	struct timespec stop_time;
-	Fiber_Profiler_Time_current(&stop_time);
-	
-	struct Fiber_Profiler_Capture_Call *current = profiler->current;
+void Fiber_Profiler_Capture_finish(struct Fiber_Profiler_Capture *capture, struct timespec switch_time) {
+	struct Fiber_Profiler_Capture_Call *current = capture->current;
 	while (current) {
 		struct Fiber_Profiler_Capture_Call *parent = current->parent;
 		
-		current->duration = Fiber_Profiler_Time_delta(&current->enter_time, &stop_time);
+		current->duration = Fiber_Profiler_Time_delta(&current->enter_time, &switch_time);
 		
-		Fiber_Profiler_Capture_Call_finish(profiler, current);
+		Fiber_Profiler_Capture_Call_finish(capture, current);
 		
 		current = parent;
 	}
 }
 
-void Fiber_Profiler_Capture_print(struct Fiber_Profiler_Capture *profiler);
+void Fiber_Profiler_Capture_print(struct Fiber_Profiler_Capture *capture, double duration);
 
-int Fiber_Profiler_Capture_sample(struct Fiber_Profiler_Capture *profiler) {
+int Fiber_Profiler_Capture_sample(struct Fiber_Profiler_Capture *capture) {
 	VALUE fiber = Fiber_Profiler_Fiber_current();
 	
 	// We don't want to capture data from blocking fibers:
 	if (Fiber_Profiler_Fiber_blocking(fiber)) return 0;
 	
-	if (profiler->sample_rate < 1) {
-		return rand() < (RAND_MAX * profiler->sample_rate);
+	if (capture->sample_rate < 1) {
+		return rand() < (RAND_MAX * capture->sample_rate);
 	} else {
 		return 1;
 	}
@@ -564,47 +583,58 @@ int Fiber_Profiler_Capture_sample(struct Fiber_Profiler_Capture *profiler) {
 
 void Fiber_Profiler_Capture_fiber_switch(VALUE self)
 {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
-	Fiber_Profiler_Time_current(&profiler->stop_time);
-	double duration = Fiber_Profiler_Time_delta(&profiler->start_time, &profiler->stop_time);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
+	capture->switches += 1;
 	
-	if (profiler->capture) {
-		Fiber_Profiler_Capture_pause(self);
+	// The time of the switch:
+	struct timespec switch_time;
+	Fiber_Profiler_Time_current(&switch_time);
+	
+	if (capture->capture) {
+		// The duration of the sample:
+		double duration = Fiber_Profiler_Time_delta(&capture->switch_time, &switch_time);
 		
-		Fiber_Profiler_Capture_finish(profiler);
+		// Finish the current sample:
+		Fiber_Profiler_Capture_pause(self);
+		Fiber_Profiler_Capture_finish(capture, switch_time);
 		
-		if (duration > profiler->stall_threshold) {
-			profiler->stalls += 1;
-			Fiber_Profiler_Capture_print(profiler);
+		// If the duration of the sample is greater than the stall threshold, we consider it a stall:
+		if (duration > capture->stall_threshold) {
+			capture->stalls += 1;
+			
+			// Print the sample:
+			Fiber_Profiler_Capture_print(capture, duration);
 		}
 		
-		Fiber_Profiler_Capture_reset(profiler);
+		// Reset the capture state:
+		Fiber_Profiler_Capture_reset(capture);
 	}
 	
-	if (Fiber_Profiler_Capture_sample(profiler)) {
-		// Reset the start time:
-		Fiber_Profiler_Time_current(&profiler->start_time);
+	if (Fiber_Profiler_Capture_sample(capture)) {
+		// Save the time of the switch for the next sample:
+		capture->switch_time = switch_time;
 		
+		// Start capturing data again:
 		Fiber_Profiler_Capture_resume(self);
 	}
 }
 
 // When sampling a fiber, we may encounter returns without a preceeding call. This isn't an error, and we should correctly visualize the call stack. We track both the relative nesting (which can be negative) and the minimum nesting level encountered during the profiling session, and use that to determine the absolute nesting level of each call when printing the call stack.
-static size_t Fiber_Profiler_Capture_absolute_nesting(struct Fiber_Profiler_Capture *profiler, struct Fiber_Profiler_Capture_Call *call) {
-	return call->nesting - profiler->nesting_minimum;
+static size_t Fiber_Profiler_Capture_absolute_nesting(struct Fiber_Profiler_Capture *capture, struct Fiber_Profiler_Capture_Call *call) {
+	return call->nesting - capture->nesting_minimum;
 }
 
 // If a call is within this threshold of the parent call, it will be skipped when printing the call stack - it's considered inconsequential to the performance of the parent call.
 static const double Fiber_Profiler_Capture_SKIP_THRESHOLD = 0.98;
 
-void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream) {
-	double total_duration = Fiber_Profiler_Time_delta(&profiler->start_time, &profiler->stop_time);
+void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *capture, FILE *restrict stream, double duration) {
+	double start_time = Fiber_Profiler_Time_delta(&capture->start_time, &capture->switch_time);
 	
-	fprintf(stderr, "## Fiber stalled for %.3f seconds ##\n", total_duration);
+	fprintf(stderr, "## Fiber stalled for %.3f seconds (switches=%zu, samples=%zu, stalls=%zu, T+%0.3fs)\n", duration, capture->switches, capture->samples, capture->stalls, start_time);
 	
 	size_t skipped = 0;
 	
-	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
+	Fiber_Profiler_Deque_each(&capture->calls, struct Fiber_Profiler_Capture_Call, call) {
 		if (call->children) {
 			if (call->parent && call->parent->children == 1) {
 				if (call->duration > call->parent->duration * Fiber_Profiler_Capture_SKIP_THRESHOLD) {
@@ -627,7 +657,7 @@ void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, F
 		if (skipped) {
 			fprintf(stream, "\e[2m");
 			
-			size_t nesting = Fiber_Profiler_Capture_absolute_nesting(profiler, call);
+			size_t nesting = Fiber_Profiler_Capture_absolute_nesting(capture, call);
 			for (size_t i = 0; i < nesting; i += 1) {
 				fputc('\t', stream);
 			}
@@ -638,12 +668,12 @@ void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, F
 			call->nesting += 1;
 		}
 		
-		size_t nesting = Fiber_Profiler_Capture_absolute_nesting(profiler, call);
+		size_t nesting = Fiber_Profiler_Capture_absolute_nesting(capture, call);
 		for (size_t i = 0; i < nesting; i += 1) {
 			fputc('\t', stream);
 		}
 		
-		if (Fiber_Profiler_Capture_Call_expensive_p(call, total_duration)) {
+		if (Fiber_Profiler_Capture_Call_expensive_p(capture, call, duration)) {
 			fprintf(stream, "\e[31m");
 		}
 		
@@ -651,7 +681,7 @@ void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, F
 		const char *name = rb_id2name(call->id);
 		
 		struct timespec offset;
-		Fiber_Profiler_Time_elapsed(&profiler->start_time, &call->enter_time, &offset);
+		Fiber_Profiler_Time_elapsed(&capture->switch_time, &call->enter_time, &offset);
 		
 		fprintf(stream, "%s:%d in %s '%s#%s' (%0.4fs, T+" Fiber_Profiler_TIME_PRINTF_TIMESPEC ")\n", call->path, call->line, event_flag_name(call->event_flag), RSTRING_PTR(class_inspect), name, call->duration, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(offset));
 		
@@ -667,21 +697,25 @@ void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, F
 			fprintf(stream, "... filtered %zu direct calls ...\e[0m\n", call->filtered);
 		}
 	}
+	
+	if (skipped) {
+		fprintf(stream, "\e[2m... skipped %zu calls ...\e[0m\n", skipped);
+	}
 }
 
-void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream) {
-	double total_duration = Fiber_Profiler_Time_delta(&profiler->start_time, &profiler->stop_time);
+void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *capture, FILE *restrict stream, double duration) {
+	double start_time = Fiber_Profiler_Time_delta(&capture->start_time, &capture->switch_time);
 	
 	fputc('{', stream);
 	
-	fprintf(stream, "\"duration\":%0.6f", total_duration);
+	fprintf(stream, "\"start_time\":%0.3f,\"duration\":%0.6f", start_time, duration);
 	
 	size_t skipped = 0;
 	
 	fprintf(stream, ",\"calls\":[");
 	int first = 1;
 	
-	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
+	Fiber_Profiler_Deque_each(&capture->calls, struct Fiber_Profiler_Capture_Call, call) {
 		if (call->children) {
 			if (call->parent && call->parent->children == 1) {
 				if (call->duration > call->parent->duration * Fiber_Profiler_Capture_SKIP_THRESHOLD) {
@@ -700,10 +734,10 @@ void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *profiler,
 		VALUE class_inspect = rb_inspect(call->klass);
 		const char *name = rb_id2name(call->id);
 		
-		size_t nesting = Fiber_Profiler_Capture_absolute_nesting(profiler, call);
+		size_t nesting = Fiber_Profiler_Capture_absolute_nesting(capture, call);
 		
 		struct timespec offset;
-		Fiber_Profiler_Time_elapsed(&profiler->start_time, &call->enter_time, &offset);
+		Fiber_Profiler_Time_elapsed(&capture->switch_time, &call->enter_time, &offset);
 		
 		fprintf(stream, "%s{\"path\":\"%s\",\"line\":%d,\"class\":\"%s\",\"method\":\"%s\",\"duration\":%0.6f,\"offset\":" Fiber_Profiler_TIME_PRINTF_TIMESPEC ",\"nesting\":%zu,\"skipped\":%zu,\"filtered\":%zu}", first ? "" : ",", call->path, call->line, RSTRING_PTR(class_inspect), name, call->duration, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(offset), nesting, skipped, call->filtered);
 		
@@ -717,17 +751,17 @@ void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *profiler,
 		fprintf(stream, ",\"skipped\":%zu", skipped);
 	}
 	
-	fprintf(stream, "}\n");
+	fprintf(stream, ",\"switches\":%zu,\"samples\":%zu,\"stalls\":%zu}\n", capture->switches, capture->samples, capture->stalls);
 }
 
-void Fiber_Profiler_Capture_print(struct Fiber_Profiler_Capture *profiler) {
-	if (profiler->output == Qnil) return;
+void Fiber_Profiler_Capture_print(struct Fiber_Profiler_Capture *capture, double duration) {
+	if (capture->output == Qnil) return;
 	
-	FILE *stream = profiler->stream.file;
-	profiler->print(profiler, stream);
+	FILE *stream = capture->stream.file;
+	capture->print(capture, stream, duration);
 	fflush(stream);
 	
-	rb_io_write(profiler->output, rb_str_new_static(profiler->stream.buffer, profiler->stream.size));
+	rb_io_write(capture->output, rb_str_new_static(capture->stream.buffer, capture->stream.size));
 	
 	fseek(stream, 0, SEEK_SET);
 }
@@ -735,27 +769,33 @@ void Fiber_Profiler_Capture_print(struct Fiber_Profiler_Capture *profiler) {
 #pragma mark - Accessors
 
 static VALUE Fiber_Profiler_Capture_stall_threshold_get(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
+	
+	return DBL2NUM(capture->stall_threshold);
+}
+
+static VALUE Fiber_Profiler_Capture_filter_threshold_get(VALUE self) {
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	return DBL2NUM(profiler->stall_threshold);
+	return DBL2NUM(capture->filter_threshold);
 }
 
 static VALUE Fiber_Profiler_Capture_track_calls_get(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	return profiler->track_calls ? Qtrue : Qfalse;
+	return capture->track_calls ? Qtrue : Qfalse;
 }
 
 static VALUE Fiber_Profiler_Capture_stalls_get(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	return SIZET2NUM(profiler->stalls);
+	return SIZET2NUM(capture->stalls);
 }
 
 static VALUE Fiber_Profiler_Capture_sample_rate_get(VALUE self) {
-	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	struct Fiber_Profiler_Capture *capture = Fiber_Profiler_Capture_get(self);
 	
-	return DBL2NUM(profiler->sample_rate);
+	return DBL2NUM(capture->sample_rate);
 }
 
 #pragma mark - Environment Variables
@@ -800,18 +840,31 @@ static double FIBER_PROFILER_CAPTURE_SAMPLE_RATE(void) {
 	}
 }
 
+static double FIBER_PROFILER_CAPTURE_FILTER_THRESHOLD(void) {
+	const char *value = getenv("FIBER_PROFILER_CAPTURE_FILTER_THRESHOLD");
+	
+	if (value) {
+		return atof(value);
+	} else {
+		// We use 10% of the stall threshold as the default filter threshold:
+		return Fiber_Profiler_Capture_stall_threshold * 0.1;
+	}
+}
+
 #pragma mark - Initialization
 
 void Init_Fiber_Profiler_Capture(VALUE Fiber_Profiler) {
 	Fiber_Profiler_capture_p = FIBER_PROFILER_CAPTURE();
 	Fiber_Profiler_Capture_stall_threshold = FIBER_PROFILER_CAPTURE_STALL_THRESHOLD();
+	Fiber_Profiler_Capture_filter_threshold = FIBER_PROFILER_CAPTURE_FILTER_THRESHOLD();
 	Fiber_Profiler_Capture_track_calls = FIBER_PROFILER_CAPTURE_TRACK_CALLS();
 	Fiber_Profiler_Capture_sample_rate = FIBER_PROFILER_CAPTURE_SAMPLE_RATE();
 	
 	Fiber_Profiler_Capture_initialize_options[0] = rb_intern("stall_threshold");
-	Fiber_Profiler_Capture_initialize_options[1] = rb_intern("track_calls");
-	Fiber_Profiler_Capture_initialize_options[2] = rb_intern("sample_rate");
-	Fiber_Profiler_Capture_initialize_options[3] = rb_intern("output");
+	Fiber_Profiler_Capture_initialize_options[1] = rb_intern("filter_threshold");
+	Fiber_Profiler_Capture_initialize_options[2] = rb_intern("track_calls");
+	Fiber_Profiler_Capture_initialize_options[3] = rb_intern("sample_rate");
+	Fiber_Profiler_Capture_initialize_options[4] = rb_intern("output");
 	
 	Fiber_Profiler_Capture = rb_define_class_under(Fiber_Profiler, "Capture", rb_cObject);
 	rb_define_alloc_func(Fiber_Profiler_Capture, Fiber_Profiler_Capture_allocate);
@@ -824,6 +877,7 @@ void Init_Fiber_Profiler_Capture(VALUE Fiber_Profiler) {
 	rb_define_method(Fiber_Profiler_Capture, "stop", Fiber_Profiler_Capture_stop, 0);
 	
 	rb_define_method(Fiber_Profiler_Capture, "stall_threshold", Fiber_Profiler_Capture_stall_threshold_get, 0);
+	rb_define_method(Fiber_Profiler_Capture, "filter_threshold", Fiber_Profiler_Capture_filter_threshold_get, 0);
 	rb_define_method(Fiber_Profiler_Capture, "track_calls", Fiber_Profiler_Capture_track_calls_get, 0);
 	rb_define_method(Fiber_Profiler_Capture, "sample_rate", Fiber_Profiler_Capture_sample_rate_get, 0);
 	

data/ext/fiber/profiler/capture.h

@@ -5,8 +5,4 @@
 
 #include <ruby.h>
 
-extern int Fiber_Profiler_capture;
-extern float Fiber_Profiler_Capture_stall_threshold;
-extern int Fiber_Profiler_Capture_track_calls;
-
 void Init_Fiber_Profiler_Capture(VALUE Fiber_Profiler);

data/lib/fiber/profiler/version.rb

@@ -7,6 +7,6 @@
 class Fiber
 	# @namespace
 	module Profiler
-		VERSION = "0.1.5"
+		VERSION = "0.3.0"
 	end
 end

metadata

@@ -1,10 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: fiber-profiler
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Williams
+autorequire:
 bindir: bin
 cert_chain:
 - |
@@ -36,8 +37,10 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2025-02-14 00:00:00.000000000 Z
+date: 2025-02-15 00:00:00.000000000 Z
 dependencies: []
+description:
+email:
 executables: []
 extensions:
 - ext/extconf.rb
@@ -66,6 +69,7 @@ licenses:
 metadata:
   documentation_uri: https://socketry.github.io/fiber-profiler/
   source_code_uri: https://github.com/socketry/fiber-profiler.git
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -80,7 +84,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: A fiber stall profiler.
 test_files: []