io-event 1.8.1 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b0f569ddbe799cd62297cbe404f9799a5354cdb8a29bf0e75c2ae566bedc1fa
-  data.tar.gz: dc7c358d32584e3f83bf13e4457e556606f38a8084408273b01e9cb5763284e5
+  metadata.gz: e8463c41263a6bb87c793fd0f45567ebc9cf8608f7d1c5453a5d22a6a0e47ae9
+  data.tar.gz: 8c603e1572174af54c78fd6bf0eaf5fe699fd744d4c46c5e8383e3bcea6b60c2
 SHA512:
-  metadata.gz: 358ccfbdcf25cd12731e6f98583db917207411db261d69c5ed2adf3c3c4f84fcb6e572d7029365bb82c501b00c68d9af3726cbb74d3983e44b189d7d362eb147
-  data.tar.gz: 63a5a659138caebfcd0fa8ebc08235127d556dc4c16d0e73f70613b360e702bc73f458156c40f79afdb2f93378e40859fd10c7be0df3e4cc7a355d29b8501325
+  metadata.gz: 92bcff52e0f13b360faf313cbeeb639ea7c76c70019cdb8af46b709c81d8e290dd716d6c729ade019ccb9d2a7917c09fb20518f52b01ad720be075b1a2b686e8
+  data.tar.gz: f32893a69e6d22c1c279dc11b0038c755be115f5894625afa61031accc4bc652e205c85e9eb296bb613aecb1f3b3d9b6cbe9d845e8c63b1f4a0c50e703f930c7

data/ext/io/event/event.c

@@ -2,6 +2,7 @@
 // Copyright, 2021-2025, by Samuel Williams.
 
 #include "event.h"
+#include "profile.h"
 #include "selector/selector.h"
 
 void Init_IO_Event(void)
@@ -11,8 +12,10 @@ void Init_IO_Event(void)
 #endif
 	
 	VALUE IO_Event = rb_define_module_under(rb_cIO, "Event");
-	VALUE IO_Event_Selector = rb_define_module_under(IO_Event, "Selector");
 	
+	Init_IO_Event_Profile(IO_Event);
+	
+	VALUE IO_Event_Selector = rb_define_module_under(IO_Event, "Selector");
 	Init_IO_Event_Selector(IO_Event_Selector);
 	
 	#ifdef IO_EVENT_SELECTOR_URING

data/ext/io/event/profile.c

@@ -8,27 +8,73 @@
 
 #include <stdio.h>
 
-void IO_Event_Profile_Call_initialize(struct IO_Event_Profile_Call *event) {
-	event->enter_time.tv_sec = 0;
-	event->enter_time.tv_nsec = 0;
-	event->exit_time.tv_sec = 0;
-	event->exit_time.tv_nsec = 0;
+VALUE IO_Event_Profile = Qnil;
+
+void IO_Event_Profile_Call_initialize(struct IO_Event_Profile_Call *call) {
+	call->enter_time.tv_sec = 0;
+	call->enter_time.tv_nsec = 0;
+	call->exit_time.tv_sec = 0;
+	call->exit_time.tv_nsec = 0;
 	
-	event->nesting = 0;
+	call->nesting = 0;
 	
-	event->event_flag = 0;
-	event->id = 0;
+	call->event_flag = 0;
+	call->id = 0;
 	
-	event->path = NULL;
-	event->line = 0;
+	call->path = NULL;
+	call->line = 0;
+}
+
+void IO_Event_Profile_Call_free(struct IO_Event_Profile_Call *call) {
+	if (call->path) {
+		free((void*)call->path);
+	}
 }
 
-void IO_Event_Profile_Call_free(struct IO_Event_Profile_Call *event) {
-	if (event->path) {
-		free((void*)event->path);
+static void IO_Event_Profile_mark(void *ptr) {
+	struct IO_Event_Profile *profile = (struct IO_Event_Profile*)ptr;
+	
+	// If `klass` is stored as a VALUE in calls, we need to mark them here:
+	for (size_t i = 0; i < profile->calls.limit; i += 1) {
+		struct IO_Event_Profile_Call *call = profile->calls.base[i];
+		rb_gc_mark(call->klass);
 	}
 }
 
+static void IO_Event_Profile_free(void *ptr) {
+	struct IO_Event_Profile *profile = (struct IO_Event_Profile*)ptr;
+	
+	IO_Event_Array_free(&profile->calls);
+	
+	free(profile);
+}
+
+const rb_data_type_t IO_Event_Profile_Type = {
+	.wrap_struct_name = "IO_Event_Profile",
+	.function = {
+		.dmark = IO_Event_Profile_mark,
+		.dfree = IO_Event_Profile_free,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE IO_Event_Profile_allocate(VALUE klass) {
+	struct IO_Event_Profile *profile = ALLOC(struct IO_Event_Profile);
+	
+	profile->calls.element_initialize = (void (*)(void*))IO_Event_Profile_Call_initialize;
+	profile->calls.element_free = (void (*)(void*))IO_Event_Profile_Call_free;
+	
+	IO_Event_Array_initialize(&profile->calls, 0, sizeof(struct IO_Event_Profile_Call));
+	
+	return TypedData_Wrap_Struct(klass, &IO_Event_Profile_Type, profile);
+}
+
+struct IO_Event_Profile *IO_Event_Profile_get(VALUE self) {
+	struct IO_Event_Profile *profile;
+	TypedData_Get_Struct(self, struct IO_Event_Profile, &IO_Event_Profile_Type, profile);
+	return profile;
+}
+
 int event_flag_call_p(rb_event_flag_t event_flags) {
 	return event_flags & (RUBY_EVENT_CALL | RUBY_EVENT_C_CALL);
 }
@@ -38,105 +84,111 @@ int event_flag_return_p(rb_event_flag_t event_flags) {
 }
 
 static void profile_event_callback(rb_event_flag_t event_flag, VALUE data, VALUE self, ID id, VALUE klass) {
-	struct IO_Event_Profile *profile = (struct IO_Event_Profile*)data;
+	struct IO_Event_Profile *profile = IO_Event_Profile_get(data);
 	
 	if (event_flag_call_p(event_flag)) {
-		struct IO_Event_Profile_Call *event = IO_Event_Array_push(&profile->events);
-		IO_Event_Time_current(&event->enter_time);
+		struct IO_Event_Profile_Call *call = IO_Event_Array_push(&profile->calls);
+		IO_Event_Time_current(&call->enter_time);
 	
-		event->event_flag = event_flag;
+		call->event_flag = event_flag;
 		
-		event->parent = profile->current;
-		profile->current = event;
+		call->parent = profile->current;
+		profile->current = call;
 		
-		event->nesting = profile->nesting;
+		call->nesting = profile->nesting;
 		profile->nesting += 1;
 		
 		if (id) {
-			event->id = id;
-			event->klass = klass;
+			call->id = id;
+			call->klass = klass;
 		} else {
-			rb_frame_method_id_and_class(&event->id, &event->klass);
+			rb_frame_method_id_and_class(&call->id, &call->klass);
 		}
 		
 		const char *path = rb_sourcefile();
 		if (path) {
-			event->path = strdup(path);
+			call->path = strdup(path);
 		}
-		event->line = rb_sourceline();
+		call->line = rb_sourceline();
 	} else if (event_flag_return_p(event_flag)) {
-		struct IO_Event_Profile_Call *event = profile->current;
+		struct IO_Event_Profile_Call *call = profile->current;
 		
-		// Bad event sequence?
-		if (event == NULL) return;
+		// Bad call sequence?
+		if (call == NULL) return;
 		
-		IO_Event_Time_current(&event->exit_time);
+		IO_Event_Time_current(&call->exit_time);
 		
-		profile->current = event->parent;
+		profile->current = call->parent;
 		profile->nesting -= 1;
 	}
 }
 
-void IO_Event_Profile_initialize(struct IO_Event_Profile *profile, VALUE fiber) {
-	profile->fiber = fiber;
+void IO_Event_Profile_start(VALUE self, int track_calls) {
+	struct IO_Event_Profile *profile = IO_Event_Profile_get(self);
 	
-	profile->events.element_initialize = (void (*)(void*))IO_Event_Profile_Call_initialize;
-	profile->events.element_free = (void (*)(void*))IO_Event_Profile_Call_free;
-	
-	IO_Event_Array_initialize(&profile->events, 0, sizeof(struct IO_Event_Profile_Call));
-}
-
-void IO_Event_Profile_start(struct IO_Event_Profile *profile) {
 	IO_Event_Time_current(&profile->start_time);
 	profile->nesting = 0;
 	profile->current = NULL;
 	
+	profile->track_calls = track_calls;
+	
 	// Since fibers are currently limited to a single thread, we use this in the hope that it's a little more efficient:
-	VALUE thread = rb_thread_current();
-	rb_thread_add_event_hook(thread, profile_event_callback, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL | RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN, (VALUE)profile);
+	if (profile->track_calls) {
+		VALUE thread = rb_thread_current();
+		rb_thread_add_event_hook(thread, profile_event_callback, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL | RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN, self);
+	}
 }
 
-void IO_Event_Profile_stop(struct IO_Event_Profile *profile) {
+void IO_Event_Profile_stop(VALUE self) {
+	struct IO_Event_Profile *profile = IO_Event_Profile_get(self);
+	
 	IO_Event_Time_current(&profile->stop_time);
 	
-	VALUE thread = rb_thread_current();
-	rb_thread_remove_event_hook_with_data(thread, profile_event_callback, (VALUE)profile);
-}
-
-void IO_Event_Profile_free(struct IO_Event_Profile *profile) {
-	IO_Event_Array_free(&profile->events);
+	if (profile->track_calls) {
+		VALUE thread = rb_thread_current();
+		rb_thread_remove_event_hook_with_data(thread, profile_event_callback, self);
+	}
 }
 
 static const float IO_EVENT_PROFILE_PRINT_MINIMUM_PROPORTION = 0.01;
 
-void IO_Event_Profile_print(FILE *restrict stream, struct IO_Event_Profile *profile) {
+void IO_Event_Profile_print(VALUE self, FILE *restrict stream) {
+	struct IO_Event_Profile *profile = IO_Event_Profile_get(self);
+	
 	struct timespec total_duration = {};
 	IO_Event_Time_elapsed(&profile->start_time, &profile->stop_time, &total_duration);
 	
 	size_t skipped = 0;
 	
-	for (size_t i = 0; i < profile->events.limit; i += 1) {
-		struct IO_Event_Profile_Call *event = profile->events.base[i];
+	for (size_t i = 0; i < profile->calls.limit; i += 1) {
+		struct IO_Event_Profile_Call *call = profile->calls.base[i];
 		
 		struct timespec duration = {};
 		
-		IO_Event_Time_elapsed(&event->enter_time, &event->exit_time, &duration);
+		IO_Event_Time_elapsed(&call->enter_time, &call->exit_time, &duration);
 		
-		// Skip events that are too short to be meaningful:
+		// Skip calls that are too short to be meaningful:
 		if (IO_Event_Time_proportion(&duration, &total_duration) < IO_EVENT_PROFILE_PRINT_MINIMUM_PROPORTION) {
 			skipped += 1;
 			continue;
 		}
 		
-		for (size_t i = 0; i < event->nesting; i += 1) {
+		for (size_t i = 0; i < call->nesting; i += 1) {
 			fputc('\t', stream);
 		}
 		
-		const char *name = rb_id2name(event->id);
-		fprintf(stream, "\t%s:%d in '%s#%s' (" IO_EVENT_TIME_PRINTF_TIMESPEC "s)\n", event->path, event->line, RSTRING_PTR(rb_inspect(event->klass)), name, IO_EVENT_TIME_PRINTF_TIMESPEC_ARGUMENTS(duration));
+		VALUE class_inspect = rb_inspect(call->klass);
+		const char *name = rb_id2name(call->id);
+		
+		fprintf(stream, "\t%s:%d in '%s#%s' (" IO_EVENT_TIME_PRINTF_TIMESPEC "s)\n", call->path, call->line, RSTRING_PTR(class_inspect), name, IO_EVENT_TIME_PRINTF_TIMESPEC_ARGUMENTS(duration));
 	}
 	
 	if (skipped > 0) {
-		fprintf(stream, "Skipped %zu events that were too short to be meaningful.\n", skipped);
+		fprintf(stream, "Skipped %zu calls that were too short to be meaningful.\n", skipped);
 	}
 }
+
+void Init_IO_Event_Profile(VALUE IO_Event) {
+	IO_Event_Profile = rb_define_class_under(IO_Event, "Profile", rb_cObject);
+	rb_define_alloc_func(IO_Event_Profile, IO_Event_Profile_allocate);
+}

data/ext/io/event/profile.h

@@ -7,6 +7,8 @@
 #include "array.h"
 #include "time.h"
 
+extern VALUE IO_Event_Profile;
+
 struct IO_Event_Profile_Call {
 	struct timespec enter_time;
 	struct timespec exit_time;
@@ -24,7 +26,7 @@ struct IO_Event_Profile_Call {
 };
 
 struct IO_Event_Profile {
-	VALUE fiber;
+	int track_calls;
 	
 	struct timespec start_time;
 	struct timespec stop_time;
@@ -35,21 +37,27 @@ struct IO_Event_Profile {
 	// The current call frame:
 	struct IO_Event_Profile_Call *current;
 	
-	struct IO_Event_Array events;
+	struct IO_Event_Array calls;
 };
 
-void IO_Event_Profile_initialize(struct IO_Event_Profile *profile, VALUE fiber);
+extern const rb_data_type_t IO_Event_Profile_Type;
+VALUE IO_Event_Profile_allocate(VALUE klass);
+struct IO_Event_Profile *IO_Event_Profile_get(VALUE self);
 
-void IO_Event_Profile_start(struct IO_Event_Profile *profile);
-void IO_Event_Profile_stop(struct IO_Event_Profile *profile);
+void IO_Event_Profile_initialize(struct IO_Event_Profile *profile, VALUE fiber);
+void IO_Event_Profile_start(VALUE self, int track_calls);
+void IO_Event_Profile_stop(VALUE self);
 
-void IO_Event_Profile_free(struct IO_Event_Profile *profile);
-void IO_Event_Profile_print(FILE *restrict stream, struct IO_Event_Profile *profile);
+void IO_Event_Profile_print(VALUE profile, FILE *restrict stream);
 
-static inline float IO_Event_Profile_duration(struct IO_Event_Profile *profile) {
+static inline float IO_Event_Profile_duration(VALUE self) {
+	struct IO_Event_Profile *profile = IO_Event_Profile_get(self);
+	
 	struct timespec duration;
 	
 	IO_Event_Time_elapsed(&profile->start_time, &profile->stop_time, &duration);
 	
 	return IO_Event_Time_duration(&duration);
 }
+
+void Init_IO_Event_Profile(VALUE IO_Event);

data/ext/io/event/selector/selector.c

@@ -12,6 +12,7 @@ static const int DEBUG = 0;
 static ID id_transfer, id_alive_p;
 
 static float IO_Event_Selector_stall_log_threshold = 0;
+static int IO_Event_Selector_stall_log_profile = 0;
 
 VALUE IO_Event_Selector_fiber_transfer(VALUE fiber, int argc, VALUE *argv) {
 	// TODO Consider introducing something like `rb_fiber_scheduler_transfer(...)`.
@@ -37,20 +38,21 @@ VALUE IO_Event_Selector_fiber_transfer_user(VALUE fiber, int argc, VALUE *argv)
 		return IO_Event_Selector_fiber_transfer(fiber, argc, argv);
 	}
 	
-	struct IO_Event_Profile profile;
-	IO_Event_Profile_initialize(&profile, fiber);
-	IO_Event_Profile_start(&profile);
+	VALUE profile = IO_Event_Profile_allocate(IO_Event_Profile);
+	
+	IO_Event_Profile_start(profile, IO_Event_Selector_stall_log_profile);
 	
 	// Transfer control to the fiber:
 	VALUE result = IO_Event_Selector_fiber_transfer(fiber, argc, argv);
 	
-	IO_Event_Profile_stop(&profile);
+	IO_Event_Profile_stop(profile);
 	
-	float duration = IO_Event_Profile_duration(&profile);
+	float duration = IO_Event_Profile_duration(profile);
 	
 	if (duration > IO_Event_Selector_stall_log_threshold) {
 		fprintf(stderr, "Fiber stalled for %.3f seconds\n", duration);
-		IO_Event_Profile_print(stderr, &profile);
+		
+		IO_Event_Profile_print(profile, stderr);
 	}
 	
 	return result;
@@ -179,7 +181,7 @@ void Init_IO_Event_Selector(VALUE IO_Event_Selector) {
 	
 	if (stall_log_threshold) {
 		if (strcmp(stall_log_threshold, "true") == 0) {
-			IO_Event_Selector_stall_log_threshold = 0.001;
+			IO_Event_Selector_stall_log_threshold = 0.01;
 		} else if (strcmp(stall_log_threshold, "false") == 0) {
 			IO_Event_Selector_stall_log_threshold = 0;
 		} else {
@@ -188,6 +190,14 @@ void Init_IO_Event_Selector(VALUE IO_Event_Selector) {
 		
 		if (DEBUG) fprintf(stderr, "IO_EVENT_SELECTOR_STALL_LOG_THRESHOLD = %.3f\n", IO_Event_Selector_stall_log_threshold);
 	}
+	
+	char *stall_log_profile = getenv("IO_EVENT_SELECTOR_STALL_LOG_PROFILE");
+	
+	if (stall_log_profile) {
+		if (strcmp(stall_log_profile, "true") == 0) {
+			IO_Event_Selector_stall_log_profile = 1;
+		}
+	}
 }
 
 struct wait_and_transfer_arguments {

data/lib/io/event/version.rb

@@ -7,6 +7,6 @@
 class IO
 	# @namespace
 	module Event
-		VERSION = "1.8.1"
+		VERSION = "1.8.2"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.8.2
 platform: ruby
 authors:
 - Samuel Williams