io-event 1.9.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7265f0fb5702ae05b5d928a8efb9e5a5e877f62afc5c93d23fec26f8a3dd1437
-  data.tar.gz: 8ba9b4b0d4e95be1401b8952cccac1a9bcc93c7a0a40e843aea60f0015c791ad
+  metadata.gz: e5601614e57f23e24edb8f34dfdaf5b87ca33e902312c27fa51dc9af375ab76c
+  data.tar.gz: c791965fb7be4525b4894de46f1a14787a19ea68920d4009e89713e3aebc1001
 SHA512:
-  metadata.gz: b4346972aa2dbe00b560e2a1e2cce32a50e9acafaa0c9253f12791c183f35bea8e3cffba93eb93147b4d975ef05edeffef84e0ed8bf29934fb39c70ea1320c6f
-  data.tar.gz: 41b6b53ca30bd0934c702c1ff0899e0e8a6bd3bc97a95f455b0d6cf0be28ff690b69575c44d92a784226edea27958cd43c486e9d907989859e298d602536078b
+  metadata.gz: 6f662e6208b30d95aeb68d68ea9e3459bd51b6dc920d7bfcaa4794ffa455316443d2da3c6e954805bd8daadd0339341aab09c225054d9e81903866d63b39d9f0
+  data.tar.gz: 0016b73d68044784ec52d270725d7f4a8bde5064bfd54c5fd3d685f36771d235ae16719fa1ca0a3f9d4dd246894e84d74e8e5025605ebcfc86fb9b5d6be39696

data/ext/extconf.rb

@@ -4,6 +4,7 @@
 # Released under the MIT License.
 # Copyright, 2021-2025, by Samuel Williams.
 # Copyright, 2023, by Math Ieu.
+# Copyright, 2025, by Stanislav (Stas) Katkov.
 
 return if RUBY_DESCRIPTION =~ /jruby/
 
@@ -14,15 +15,15 @@ extension_name = "IO_Event"
 
 # dir_config(extension_name)
 
-$CFLAGS << " -Wall -Wno-unknown-pragmas -std=c99"
+append_cflags(["-Wall", "-Wno-unknown-pragmas", "-std=c99"])
 
 if ENV.key?("RUBY_DEBUG")
 	$stderr.puts "Enabling debug mode..."
-	
-	$CFLAGS << " -DRUBY_DEBUG -O0"
+
+	append_cflags(["-DRUBY_DEBUG", "-O0"])
 end
 
-$srcs = ["io/event/event.c", "io/event/time.c", "io/event/fiber.c", "io/event/profiler.c", "io/event/selector/selector.c"]
+$srcs = ["io/event/event.c", "io/event/time.c", "io/event/fiber.c", "io/event/selector/selector.c"]
 $VPATH << "$(srcdir)/io/event"
 $VPATH << "$(srcdir)/io/event/selector"
 
@@ -32,7 +33,7 @@ have_func("&rb_fiber_transfer")
 if have_library("uring") and have_header("liburing.h")
 	# We might want to consider using this in the future:
 	# have_func("io_uring_submit_and_wait_timeout", "liburing.h")
-	
+
 	$srcs << "io/event/selector/uring.c"
 end
 
@@ -57,11 +58,21 @@ have_func("epoll_pwait2")
 
 have_header("ruby/io/buffer.h")
 
+# Feature detection for blocking operation support
+if have_func("rb_fiber_scheduler_blocking_operation_extract")
+	# Feature detection for pthread support (needed for WorkerPool)
+	if have_header("pthread.h")
+		append_cflags(["-DHAVE_IO_EVENT_WORKER_POOL"])
+		$srcs << "io/event/worker_pool.c"
+		$srcs << "io/event/worker_pool_test.c"
+	end
+end
+
 if ENV.key?("RUBY_SANITIZE")
 	$stderr.puts "Enabling sanitizers..."
-	
+
 	# Add address and undefined behaviour sanitizers:
-	$CFLAGS << " -fsanitize=address -fsanitize=undefined -fno-omit-frame-pointer"
+	append_cflags(["-fsanitize=address", "-fsanitize=undefined", "-fno-omit-frame-pointer"])
 	$LDFLAGS << " -fsanitize=address -fsanitize=undefined"
 end
 

data/ext/io/event/event.c

@@ -3,9 +3,7 @@
 
 #include "event.h"
 #include "fiber.h"
-#include "profiler.h"
 #include "selector/selector.h"
-#include <complex.h>
 
 void Init_IO_Event(void)
 {
@@ -16,8 +14,11 @@ void Init_IO_Event(void)
 	VALUE IO_Event = rb_define_module_under(rb_cIO, "Event");
 	
 	Init_IO_Event_Fiber(IO_Event);
-	Init_IO_Event_Profiler(IO_Event);
-	
+
+	#ifdef HAVE_IO_EVENT_WORKER_POOL
+	Init_IO_Event_WorkerPool(IO_Event);
+	#endif
+
 	VALUE IO_Event_Selector = rb_define_module_under(IO_Event, "Selector");
 	Init_IO_Event_Selector(IO_Event_Selector);
 	

data/ext/io/event/event.h

@@ -18,3 +18,7 @@ void Init_IO_Event(void);
 #ifdef HAVE_SYS_EVENT_H
 #include "selector/kqueue.h"
 #endif
+
+#ifdef HAVE_IO_EVENT_WORKER_POOL
+#include "worker_pool.h"
+#endif

data/ext/io/event/fiber.c

@@ -35,7 +35,7 @@ VALUE IO_Event_Fiber_raise(VALUE fiber, int argc, VALUE *argv) {
 #ifndef HAVE_RB_FIBER_CURRENT
 static ID id_current;
 
-static VALUE IO_Event_Fiber_current(void) {
+VALUE IO_Event_Fiber_current(void) {
 	return rb_funcall(rb_cFiber, id_current, 0);
 }
 #endif

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

@@ -1035,7 +1035,25 @@ VALUE IO_Event_Selector_EPoll_wakeup(VALUE self) {
 	return Qfalse;
 }
 
+static int IO_Event_Selector_EPoll_supported_p(void) {
+	int fd = epoll_create1(EPOLL_CLOEXEC);
+	
+	if (fd < 0) {
+		rb_warn("epoll_create1() was available at compile time but failed at run time: %s\n", strerror(errno));
+		
+		return 0;
+	}
+	
+	close(fd);
+	
+	return 1;
+}
+
 void Init_IO_Event_Selector_EPoll(VALUE IO_Event_Selector) {
+	if (!IO_Event_Selector_EPoll_supported_p()) {
+		return;
+	}
+	
 	VALUE IO_Event_Selector_EPoll = rb_define_class_under(IO_Event_Selector, "EPoll", rb_cObject);
 	
 	rb_define_alloc_func(IO_Event_Selector_EPoll, IO_Event_Selector_EPoll_allocate);

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

@@ -1045,7 +1045,26 @@ VALUE IO_Event_Selector_KQueue_wakeup(VALUE self) {
 	return Qfalse;
 }
 
+
+static int IO_Event_Selector_KQueue_supported_p(void) {
+	int fd = kqueue();
+	
+	if (fd < 0) {
+		rb_warn("kqueue() was available at compile time but failed at run time: %s\n", strerror(errno));
+		
+		return 0;
+	}
+	
+	close(fd);
+	
+	return 1;
+}
+
 void Init_IO_Event_Selector_KQueue(VALUE IO_Event_Selector) {
+	if (!IO_Event_Selector_KQueue_supported_p()) {
+		return;
+	}
+	
 	VALUE IO_Event_Selector_KQueue = rb_define_class_under(IO_Event_Selector, "KQueue", rb_cObject);
 	
 	rb_define_alloc_func(IO_Event_Selector_KQueue, IO_Event_Selector_KQueue_allocate);

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

@@ -18,7 +18,7 @@
 enum {
 	DEBUG = 0,
 	DEBUG_COMPLETION = 0,
-	DEBUG_IO_READ = 1,
+	DEBUG_CQE = 0,
 };
 
 enum {URING_ENTRIES = 64};
@@ -552,7 +552,10 @@ VALUE io_wait_transfer(VALUE _arguments) {
 	
 	if (DEBUG) fprintf(stderr, "io_wait_transfer:waiting=%p, result=%d\n", (void*)arguments->waiting, arguments->waiting->result);
 	
-	if (arguments->waiting->result) {
+	int32_t result = arguments->waiting->result;
+	if (result < 0) {
+		rb_syserr_fail(-result, "io_wait_transfer:io_uring_poll_add");
+	} else if (result > 0) {
 		// We explicitly filter the resulting events based on the requested events.
 		// In some cases, poll will report events we didn't ask for.
 		return RB_INT2NUM(events_from_poll_flags(arguments->waiting->result & arguments->flags));
@@ -1059,7 +1062,7 @@ unsigned select_process_completions(struct IO_Event_Selector_URing *selector) {
 	}
 	
 	io_uring_for_each_cqe(ring, head, cqe) {
-		if (DEBUG) fprintf(stderr, "select_process_completions: cqe res=%d user_data=%p\n", cqe->res, (void*)cqe->user_data);
+		if (DEBUG_CQE) fprintf(stderr, "select_process_completions: cqe res=%d user_data=%p\n", cqe->res, (void*)cqe->user_data);
 		
 		++completed;
 		
@@ -1175,7 +1178,26 @@ VALUE IO_Event_Selector_URing_wakeup(VALUE self) {
 
 #pragma mark - Native Methods
 
+static int IO_Event_Selector_URing_supported_p(void) {
+	struct io_uring ring;
+	int result = io_uring_queue_init(32, &ring, 0);
+	
+	if (result < 0) {
+		rb_warn("io_uring_queue_init() was available at compile time but failed at run time: %s\n", strerror(-result));
+		
+		return 0;
+	}
+	
+	io_uring_queue_exit(&ring);
+	
+	return 1;
+}
+
 void Init_IO_Event_Selector_URing(VALUE IO_Event_Selector) {
+	if (!IO_Event_Selector_URing_supported_p()) {
+		return;
+	}
+	
 	VALUE IO_Event_Selector_URing = rb_define_class_under(IO_Event_Selector, "URing", rb_cObject);
 	
 	rb_define_alloc_func(IO_Event_Selector_URing, IO_Event_Selector_URing_allocate);

data/ext/io/event/worker_pool.c

@@ -0,0 +1,464 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "worker_pool.h"
+#include "worker_pool_test.h"
+#include "fiber.h"
+
+#include <ruby/thread.h>
+#include <ruby/fiber/scheduler.h>
+
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+
+enum {
+	DEBUG = 0,
+};
+
+static VALUE IO_Event_WorkerPool;
+static ID id_maximum_worker_count;
+
+// Thread pool structure
+struct IO_Event_WorkerPool_Worker {
+	VALUE thread;
+	
+	// Flag to indicate this specific worker should exit:
+	bool interrupted;
+
+	// Currently executing operation:
+	rb_fiber_scheduler_blocking_operation_t *current_blocking_operation;
+
+	struct IO_Event_WorkerPool *pool;
+	struct IO_Event_WorkerPool_Worker *next;
+};
+
+// Work item structure
+struct IO_Event_WorkerPool_Work {
+	rb_fiber_scheduler_blocking_operation_t *blocking_operation;
+	
+	bool completed;
+	
+	VALUE scheduler;
+	VALUE blocker;
+	VALUE fiber;
+	
+	struct IO_Event_WorkerPool_Work *next;
+};
+
+// Worker pool structure
+struct IO_Event_WorkerPool {
+	pthread_mutex_t mutex;
+	pthread_cond_t work_available;
+	
+	struct IO_Event_WorkerPool_Work *work_queue;
+	struct IO_Event_WorkerPool_Work *work_queue_tail;
+	
+	struct IO_Event_WorkerPool_Worker *workers;
+	size_t current_worker_count;
+	size_t maximum_worker_count;
+	
+	size_t call_count;
+	size_t completed_count;
+	size_t cancelled_count;
+	
+	bool shutdown;
+};
+
+// Free functions for Ruby GC
+static void worker_pool_free(void *ptr) {
+	struct IO_Event_WorkerPool *pool = (struct IO_Event_WorkerPool *)ptr;
+	
+	if (pool) {
+		// Signal shutdown to all workers
+		if (!pool->shutdown) {
+			pthread_mutex_lock(&pool->mutex);
+			pool->shutdown = true;
+			pthread_cond_broadcast(&pool->work_available);
+			pthread_mutex_unlock(&pool->mutex);
+		}
+		
+		// Note: We don't free worker structures or wait for threads during GC
+		// as this can cause deadlocks. The Ruby GC will handle the thread objects.
+		// Workers will see the shutdown flag and exit cleanly.
+	}
+}
+
+// Size functions for Ruby GC
+static size_t worker_pool_size(const void *ptr) {
+	return sizeof(struct IO_Event_WorkerPool);
+}
+
+// Ruby TypedData structures
+static const rb_data_type_t IO_Event_WorkerPool_type = {
+	"IO::Event::WorkerPool",
+	{0, worker_pool_free, worker_pool_size,},
+	0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+// Helper function to enqueue work (must be called with mutex held)
+static void enqueue_work(struct IO_Event_WorkerPool *pool, struct IO_Event_WorkerPool_Work *work) {
+	if (pool->work_queue_tail) {
+		pool->work_queue_tail->next = work;
+	} else {
+		pool->work_queue = work;
+	}
+	pool->work_queue_tail = work;
+}
+
+// Helper function to dequeue work (must be called with mutex held)
+static struct IO_Event_WorkerPool_Work *dequeue_work(struct IO_Event_WorkerPool *pool) {
+	struct IO_Event_WorkerPool_Work *work = pool->work_queue;
+	if (work) {
+		pool->work_queue = work->next;
+		if (!pool->work_queue) {
+			pool->work_queue_tail = NULL;
+		}
+		work->next = NULL; // Clear the next pointer for safety
+	}
+	return work;
+}
+
+// Unblock function to interrupt a specific worker.
+static void worker_unblock_func(void *_worker) {
+	struct IO_Event_WorkerPool_Worker *worker = (struct IO_Event_WorkerPool_Worker *)_worker;
+	struct IO_Event_WorkerPool *pool = worker->pool;
+	
+	// Mark this specific worker as interrupted
+	pthread_mutex_lock(&pool->mutex);
+	worker->interrupted = true;
+	pthread_cond_broadcast(&pool->work_available);
+	pthread_mutex_unlock(&pool->mutex);
+	
+	// If there's a currently executing blocking operation, cancel it
+	if (worker->current_blocking_operation) {
+		rb_fiber_scheduler_blocking_operation_cancel(worker->current_blocking_operation);
+	}
+}
+
+// Function to wait for work and execute it without GVL.
+static void *worker_wait_and_execute(void *_worker) {
+	struct IO_Event_WorkerPool_Worker *worker = (struct IO_Event_WorkerPool_Worker *)_worker;
+	struct IO_Event_WorkerPool *pool = worker->pool;
+	
+	while (true) {
+		struct IO_Event_WorkerPool_Work *work = NULL;
+		
+		pthread_mutex_lock(&pool->mutex);
+		
+		// Wait for work, shutdown, or interruption
+		while (!pool->work_queue && !pool->shutdown && !worker->interrupted) {
+			pthread_cond_wait(&pool->work_available, &pool->mutex);
+		}
+		
+		if (pool->shutdown || worker->interrupted) {
+			pthread_mutex_unlock(&pool->mutex);
+			break;
+		}
+		
+		work = dequeue_work(pool);
+		
+		pthread_mutex_unlock(&pool->mutex);
+		
+		// Execute work WITHOUT GVL (this is the whole point!)
+		if (work) {
+			worker->current_blocking_operation = work->blocking_operation;
+			rb_fiber_scheduler_blocking_operation_execute(work->blocking_operation);
+			worker->current_blocking_operation = NULL;
+		}
+
+		return work;
+	}
+	
+	return NULL; // Shutdown signal
+}
+
+static VALUE worker_thread_func(void *_worker) {
+	struct IO_Event_WorkerPool_Worker *worker = (struct IO_Event_WorkerPool_Worker *)_worker;
+	
+	while (true) {
+		// Wait for work and execute it without holding GVL
+		struct IO_Event_WorkerPool_Work *work = (struct IO_Event_WorkerPool_Work *)rb_thread_call_without_gvl(worker_wait_and_execute, worker, worker_unblock_func, worker);
+		
+		if (!work) {
+			// Shutdown signal received
+			break;
+		}
+
+		// Protected by GVL:
+		work->completed = true;
+		worker->pool->completed_count++;
+		
+		// Work was executed without GVL, now unblock the waiting fiber (we have GVL here)
+		rb_fiber_scheduler_unblock(work->scheduler, work->blocker, work->fiber);
+	}
+	
+	return Qnil;
+}
+
+// Create a new worker thread
+static int create_worker_thread(struct IO_Event_WorkerPool *pool) {
+	if (pool->current_worker_count >= pool->maximum_worker_count) {
+		return -1;
+	}
+	
+		struct IO_Event_WorkerPool_Worker *worker = malloc(sizeof(struct IO_Event_WorkerPool_Worker));
+	if (!worker) {
+		return -1;
+	}
+	
+	worker->pool = pool;
+	worker->interrupted = false;
+	worker->current_blocking_operation = NULL;
+	worker->next = pool->workers;
+	
+	worker->thread = rb_thread_create(worker_thread_func, worker);
+	if (NIL_P(worker->thread)) {
+		free(worker);
+		return -1;
+	}
+	
+	pool->workers = worker;
+	pool->current_worker_count++;
+	
+	return 0;
+}
+
+// Ruby constructor for WorkerPool
+static VALUE worker_pool_initialize(int argc, VALUE *argv, VALUE self) {
+	size_t maximum_worker_count = 1; // Default
+	
+	// Extract keyword arguments
+	VALUE kwargs = Qnil;
+	VALUE rb_maximum_worker_count = Qnil;
+	
+	rb_scan_args(argc, argv, "0:", &kwargs);
+	
+	if (!NIL_P(kwargs)) {
+		VALUE kwvals[1];
+		ID kwkeys[1] = {id_maximum_worker_count};
+		rb_get_kwargs(kwargs, kwkeys, 0, 1, kwvals);
+		rb_maximum_worker_count = kwvals[0];
+	}
+	
+	if (!NIL_P(rb_maximum_worker_count)) {
+		maximum_worker_count = NUM2SIZET(rb_maximum_worker_count);
+		if (maximum_worker_count == 0) {
+			rb_raise(rb_eArgError, "maximum_worker_count must be greater than 0!");
+		}
+	}
+	
+	// Get the pool that was allocated by worker_pool_allocate
+	struct IO_Event_WorkerPool *pool;
+	TypedData_Get_Struct(self, struct IO_Event_WorkerPool, &IO_Event_WorkerPool_type, pool);
+	
+	if (!pool) {
+		rb_raise(rb_eRuntimeError, "WorkerPool allocation failed!");
+	}
+	
+	pthread_mutex_init(&pool->mutex, NULL);
+	pthread_cond_init(&pool->work_available, NULL);
+	
+	pool->work_queue = NULL;
+	pool->work_queue_tail = NULL;
+	pool->workers = NULL;
+	pool->current_worker_count = 0;
+	pool->maximum_worker_count = maximum_worker_count;
+	pool->call_count = 0;
+	pool->completed_count = 0;
+	pool->cancelled_count = 0;
+	pool->shutdown = false;
+	
+	// Create initial workers
+	for (size_t i = 0; i < maximum_worker_count; i++) {
+		if (create_worker_thread(pool) != 0) {
+			// Just set the maximum_worker_count for debugging, don't fail completely
+			// worker_pool_free(pool);
+			// rb_raise(rb_eRuntimeError, "Failed to create workers");
+			break;
+		}
+	}
+	
+	return self;
+}
+
+static VALUE worker_pool_work_begin(VALUE _work) {
+	struct IO_Event_WorkerPool_Work *work = (void*)_work;
+
+	if (DEBUG) fprintf(stderr, "worker_pool_work_begin:rb_fiber_scheduler_block work=%p\n", work);
+	rb_fiber_scheduler_block(work->scheduler, work->blocker, Qnil);
+
+	return Qnil;
+}
+
+// Ruby method to submit work and wait for completion
+static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
+	struct IO_Event_WorkerPool *pool;
+	TypedData_Get_Struct(self, struct IO_Event_WorkerPool, &IO_Event_WorkerPool_type, pool);
+	
+	if (pool->shutdown) {
+		rb_raise(rb_eRuntimeError, "Worker pool is shut down!");
+	}
+	
+	// Increment call count (protected by GVL)
+	pool->call_count++;
+	
+	// Get current fiber and scheduler
+	VALUE fiber = rb_fiber_current();
+	VALUE scheduler = rb_fiber_scheduler_current();
+	if (NIL_P(scheduler)) {
+		rb_raise(rb_eRuntimeError, "WorkerPool requires a fiber scheduler!");
+	}
+	
+	// Extract blocking operation handle
+	rb_fiber_scheduler_blocking_operation_t *blocking_operation = rb_fiber_scheduler_blocking_operation_extract(_blocking_operation);
+	
+	if (!blocking_operation) {
+		rb_raise(rb_eArgError, "Invalid blocking operation!");
+	}
+	
+	// Create work item
+	struct IO_Event_WorkerPool_Work work = {
+		.blocking_operation = blocking_operation,
+		.completed = false,
+		.scheduler = scheduler,
+		.blocker = self,
+		.fiber = fiber,
+		.next = NULL
+	};
+		
+	// Enqueue work:
+	pthread_mutex_lock(&pool->mutex);
+	enqueue_work(pool, &work);
+	pthread_cond_signal(&pool->work_available);
+	pthread_mutex_unlock(&pool->mutex);
+	
+	// Block the current fiber until work is completed:
+	int state;
+	while (true) {
+		rb_protect(worker_pool_work_begin, (VALUE)&work, &state);
+
+		if (work.completed) {
+			break;
+		} else {
+			if (DEBUG) fprintf(stderr, "worker_pool_call:rb_fiber_scheduler_blocking_operation_cancel\n");
+			rb_fiber_scheduler_blocking_operation_cancel(blocking_operation);
+			// The work was not completed, we need to wait for it to be completed.
+		}
+	}
+	
+	if (state) {
+		rb_jump_tag(state);
+	} else {
+		return Qtrue;
+	}
+}
+
+static VALUE worker_pool_allocate(VALUE klass) {
+	struct IO_Event_WorkerPool *pool;
+	VALUE self = TypedData_Make_Struct(klass, struct IO_Event_WorkerPool, &IO_Event_WorkerPool_type, pool);
+	
+	// Initialize to NULL/zero so we can detect uninitialized pools
+	memset(pool, 0, sizeof(struct IO_Event_WorkerPool));
+	
+	return self;
+}
+
+// Ruby method to close the worker pool
+static VALUE worker_pool_close(VALUE self) {
+	struct IO_Event_WorkerPool *pool;
+	TypedData_Get_Struct(self, struct IO_Event_WorkerPool, &IO_Event_WorkerPool_type, pool);
+	
+	if (!pool) {
+		rb_raise(rb_eRuntimeError, "WorkerPool not initialized!");
+	}
+	
+	if (pool->shutdown) {
+		return Qnil; // Already closed
+	}
+	
+	// Signal shutdown to all workers
+	pthread_mutex_lock(&pool->mutex);
+	pool->shutdown = true;
+	pthread_cond_broadcast(&pool->work_available);
+	pthread_mutex_unlock(&pool->mutex);
+	
+	// Wait for all worker threads to finish
+	struct IO_Event_WorkerPool_Worker *worker = pool->workers;
+	while (worker) {
+		if (!NIL_P(worker->thread)) {
+			rb_funcall(worker->thread, rb_intern("join"), 0);
+		}
+		worker = worker->next;
+	}
+	
+	// Clean up worker structures
+	worker = pool->workers;
+	while (worker) {
+		struct IO_Event_WorkerPool_Worker *next = worker->next;
+		free(worker);
+		worker = next;
+	}
+	pool->workers = NULL;
+	pool->current_worker_count = 0;
+	
+	// Clean up mutex and condition variable
+	pthread_mutex_destroy(&pool->mutex);
+	pthread_cond_destroy(&pool->work_available);
+	
+	return Qnil;
+}
+
+// Test helper: get pool statistics for debugging/testing
+static VALUE worker_pool_statistics(VALUE self) {
+	struct IO_Event_WorkerPool *pool;
+	TypedData_Get_Struct(self, struct IO_Event_WorkerPool, &IO_Event_WorkerPool_type, pool);
+	
+	if (!pool) {
+		rb_raise(rb_eRuntimeError, "WorkerPool not initialized!");
+	}
+	
+	VALUE stats = rb_hash_new();
+	rb_hash_aset(stats, ID2SYM(rb_intern("current_worker_count")), SIZET2NUM(pool->current_worker_count));
+	rb_hash_aset(stats, ID2SYM(rb_intern("maximum_worker_count")), SIZET2NUM(pool->maximum_worker_count));
+	rb_hash_aset(stats, ID2SYM(rb_intern("call_count")), SIZET2NUM(pool->call_count));
+	rb_hash_aset(stats, ID2SYM(rb_intern("completed_count")), SIZET2NUM(pool->completed_count));
+	rb_hash_aset(stats, ID2SYM(rb_intern("cancelled_count")), SIZET2NUM(pool->cancelled_count));
+	rb_hash_aset(stats, ID2SYM(rb_intern("shutdown")), pool->shutdown ? Qtrue : Qfalse);
+	
+	// Count work items in queue (only if properly initialized)
+	if (pool->maximum_worker_count > 0) {
+		pthread_mutex_lock(&pool->mutex);
+		size_t current_queue_size = 0;
+		struct IO_Event_WorkerPool_Work *work = pool->work_queue;
+		while (work) {
+			current_queue_size++;
+			work = work->next;
+		}
+		pthread_mutex_unlock(&pool->mutex);
+		rb_hash_aset(stats, ID2SYM(rb_intern("current_queue_size")), SIZET2NUM(current_queue_size));
+	} else {
+		rb_hash_aset(stats, ID2SYM(rb_intern("current_queue_size")), SIZET2NUM(0));
+	}
+	
+	return stats;
+}
+
+void Init_IO_Event_WorkerPool(VALUE IO_Event) {
+	// Initialize symbols
+	id_maximum_worker_count = rb_intern("maximum_worker_count");
+	
+	IO_Event_WorkerPool = rb_define_class_under(IO_Event, "WorkerPool", rb_cObject);
+	rb_define_alloc_func(IO_Event_WorkerPool, worker_pool_allocate);
+
+	rb_define_method(IO_Event_WorkerPool, "initialize", worker_pool_initialize, -1);
+	rb_define_method(IO_Event_WorkerPool, "call", worker_pool_call, 1);
+	rb_define_method(IO_Event_WorkerPool, "close", worker_pool_close, 0);
+	
+	rb_define_method(IO_Event_WorkerPool, "statistics", worker_pool_statistics, 0);
+	
+	// Initialize test functions
+	Init_IO_Event_WorkerPool_Test(IO_Event_WorkerPool);
+}

data/ext/io/event/{profiler.h → worker_pool.h}

@@ -5,4 +5,4 @@
 
 #include <ruby.h>
 
-void Init_IO_Event_Profiler(VALUE IO_Event);
+void Init_IO_Event_WorkerPool(VALUE IO_Event);