io-event 1.9.0 → 1.11.0

data/ext/io/event/worker_pool_test.c

@@ -0,0 +1,200 @@
+// worker_pool_test.c - Test functions for WorkerPool cancellation
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "worker_pool_test.h"
+
+#include <ruby/thread.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <unistd.h>
+#include <sys/select.h>
+#include <errno.h>
+#include <time.h>
+
+static ID id_duration;
+
+struct BusyOperationData {
+  int read_fd;
+  int write_fd;
+  volatile int cancelled;
+  double duration;  // How long to wait (for testing)
+  clock_t start_time;
+  clock_t end_time;
+  int operation_result;
+  VALUE exception;
+};
+
+// The actual blocking operation that can be cancelled
+static void* busy_blocking_operation(void *data) {
+	struct BusyOperationData *busy_data = (struct BusyOperationData*)data;
+	
+	// Use select() to wait for the pipe to become readable
+	fd_set read_fds;
+	struct timeval timeout;
+	
+	FD_ZERO(&read_fds);
+	FD_SET(busy_data->read_fd, &read_fds);
+	
+	// Set timeout based on duration
+	timeout.tv_sec = (long)busy_data->duration;
+	timeout.tv_usec = ((busy_data->duration - timeout.tv_sec) * 1000000);
+	
+	// This will block until:
+	// 1. The pipe becomes readable (cancellation)
+	// 2. The timeout expires
+	// 3. An error occurs
+	int result = select(busy_data->read_fd + 1, &read_fds, NULL, NULL, &timeout);
+
+	if (result > 0 && FD_ISSET(busy_data->read_fd, &read_fds)) {
+		// Pipe became readable - we were cancelled
+		char buffer;
+		read(busy_data->read_fd, &buffer, 1);  // Consume the byte
+		busy_data->cancelled = 1;
+		return (void*)-1;  // Indicate cancellation
+	} else if (result == 0) {
+		// Timeout - operation completed normally
+		return (void*)0;  // Indicate success
+	} else {
+		// Error occurred
+		return (void*)-2;  // Indicate error
+	}
+}
+
+// Unblock function that writes to the pipe to cancel the operation
+static void busy_unblock_function(void *data) {
+	struct BusyOperationData *busy_data = (struct BusyOperationData*)data;
+	
+	busy_data->cancelled = 1;
+
+	// Write a byte to the pipe to wake up the select()
+	char wake_byte = 1;
+	write(busy_data->write_fd, &wake_byte, 1);
+}
+
+// Function for the main operation execution (for rb_rescue)
+static VALUE busy_operation_execute(VALUE data_value) {
+	struct BusyOperationData *busy_data = (struct BusyOperationData*)data_value;
+	
+	// Record start time
+	busy_data->start_time = clock();
+	
+	// Execute the blocking operation
+	void *block_result = rb_nogvl(
+		busy_blocking_operation,
+		busy_data,
+		busy_unblock_function,
+		busy_data,
+		RB_NOGVL_UBF_ASYNC_SAFE | RB_NOGVL_OFFLOAD_SAFE
+	);
+	
+	// Record end time
+	busy_data->end_time = clock();
+	
+	// Store the operation result
+	busy_data->operation_result = (int)(intptr_t)block_result;
+	
+	return Qnil;
+}
+
+// Function for exception handling (for rb_rescue)
+static VALUE busy_operation_rescue(VALUE data_value, VALUE exception) {
+	struct BusyOperationData *busy_data = (struct BusyOperationData*)data_value;
+	
+	// Record end time even in case of exception
+	busy_data->end_time = clock();
+	
+	// Mark that an exception was caught
+	busy_data->exception = exception;
+	
+	return exception;
+}
+
+// Ruby method: IO::Event::WorkerPool.busy(duration: 1.0)
+// This creates a cancellable blocking operation for testing
+static VALUE worker_pool_test_busy(int argc, VALUE *argv, VALUE self) {
+	double duration = 1.0;  // Default 1 second
+	
+	// Extract keyword arguments
+	VALUE kwargs = Qnil;
+	VALUE rb_duration = Qnil;
+	
+	rb_scan_args(argc, argv, "0:", &kwargs);
+	
+	if (!NIL_P(kwargs)) {
+		VALUE kwvals[1];
+		ID kwkeys[1] = {id_duration};
+		rb_get_kwargs(kwargs, kwkeys, 0, 1, kwvals);
+		rb_duration = kwvals[0];
+	}
+	
+	if (!NIL_P(rb_duration)) {
+		duration = NUM2DBL(rb_duration);
+	}
+	
+	// Create pipe for cancellation
+	int pipe_fds[2];
+	if (pipe(pipe_fds) != 0) {
+		rb_sys_fail("pipe creation failed");
+	}
+	
+	// Stack allocate operation data
+	struct BusyOperationData busy_data = {
+		.read_fd = pipe_fds[0],
+		.write_fd = pipe_fds[1],
+		.cancelled = 0,
+		.duration = duration,
+		.start_time = 0,
+		.end_time = 0,
+		.operation_result = 0,
+		.exception = Qnil
+	};
+	
+	// Execute the blocking operation with exception handling using function pointers
+	rb_rescue(
+		busy_operation_execute,
+		(VALUE)&busy_data,
+		busy_operation_rescue,
+		(VALUE)&busy_data
+	);
+	
+	// Calculate elapsed time from the state stored in busy_data
+	double elapsed = ((double)(busy_data.end_time - busy_data.start_time)) / CLOCKS_PER_SEC;
+	
+	// Create result hash using the state from busy_data
+	VALUE result = rb_hash_new();
+	rb_hash_aset(result, ID2SYM(rb_intern("duration")), DBL2NUM(duration));
+	rb_hash_aset(result, ID2SYM(rb_intern("elapsed")), DBL2NUM(elapsed));
+	
+	// Determine result based on operation outcome
+	if (busy_data.exception != Qnil) {
+		rb_hash_aset(result, ID2SYM(rb_intern("result")), ID2SYM(rb_intern("exception")));
+		rb_hash_aset(result, ID2SYM(rb_intern("cancelled")), Qtrue);
+		rb_hash_aset(result, ID2SYM(rb_intern("exception")), busy_data.exception);
+	} else if (busy_data.operation_result == -1) {
+		rb_hash_aset(result, ID2SYM(rb_intern("result")), ID2SYM(rb_intern("cancelled")));
+		rb_hash_aset(result, ID2SYM(rb_intern("cancelled")), Qtrue);
+	} else if (busy_data.operation_result == 0) {
+		rb_hash_aset(result, ID2SYM(rb_intern("result")), ID2SYM(rb_intern("completed")));
+		rb_hash_aset(result, ID2SYM(rb_intern("cancelled")), Qfalse);
+	} else {
+		rb_hash_aset(result, ID2SYM(rb_intern("result")), ID2SYM(rb_intern("error")));
+		rb_hash_aset(result, ID2SYM(rb_intern("cancelled")), Qfalse);
+	}
+	
+	// Clean up pipe file descriptors
+	close(pipe_fds[0]);
+	close(pipe_fds[1]);
+	
+	return result;
+}
+
+// Initialize the test functions
+void Init_IO_Event_WorkerPool_Test(VALUE IO_Event_WorkerPool) {
+	// Initialize symbols
+	id_duration = rb_intern("duration");
+	
+	// Add test methods to IO::Event::WorkerPool class
+	rb_define_singleton_method(IO_Event_WorkerPool, "busy", worker_pool_test_busy, -1);
+} 

data/ext/io/event/worker_pool_test.h

@@ -0,0 +1,9 @@
+// worker_pool_test.h - Header for WorkerPool test functions
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+
+void Init_IO_Event_WorkerPool_Test(VALUE IO_Event_WorkerPool);

data/lib/io/event/selector/select.rb

@@ -421,19 +421,25 @@ module IO::Event
 				writable = Array.new
 				priority = Array.new
 				
-				@waiting.each do |io, waiter|
-					waiter.each do |fiber, events|
-						if (events & IO::READABLE) > 0
-							readable << io
-						end
-						
-						if (events & IO::WRITABLE) > 0
-							writable << io
-						end
-						
-						if (events & IO::PRIORITY) > 0
-							priority << io
+				@waiting.delete_if do |io, waiter|
+					if io.closed?
+						true
+					else
+						waiter.each do |fiber, events|
+							if (events & IO::READABLE) > 0
+								readable << io
+							end
+							
+							if (events & IO::WRITABLE) > 0
+								writable << io
+							end
+							
+							if (events & IO::PRIORITY) > 0
+								priority << io
+							end
 						end
+
+						false
 					end
 				end
 				

data/lib/io/event/timers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2024, by Samuel Williams.
+# Copyright, 2024-2025, by Samuel Williams.
 
 require_relative "priority_heap"
 
@@ -91,7 +91,6 @@ class IO
 				schedule(self.now + offset.to_f, block)
 			end
 			
-			
 			# Compute the time interval until the next timer fires.
 			#
 			# @parameter now [Float] The current time.

data/lib/io/event/version.rb

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

data/license.md

@@ -11,6 +11,7 @@ Copyright, 2024, by Pavel Rosický.
 Copyright, 2024, by Anthony Ross.  
 Copyright, 2024, by Shizuo Fujita.  
 Copyright, 2024, by Jean Boussier.  
+Copyright, 2025, by Stanislav (Stas) Katkov.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/readme.md

@@ -1,4 +1,4 @@
-# ![Event](logo.svg)
+# ![IO::Event](logo.svg)
 
 Provides low level cross-platform primitives for constructing event loops, with support for `select`, `kqueue`, `epoll` and `io_uring`.
 
@@ -18,13 +18,26 @@ Please see the [project documentation](https://socketry.github.io/io-event/) for
 
 Please see the [project releases](https://socketry.github.io/io-event/releases/index) for all releases.
 
+### v1.11.0
+
+  - [Introduce `IO::Event::WorkerPool` for off-loading blocking operations.](https://socketry.github.io/io-event/releases/index#introduce-io::event::workerpool-for-off-loading-blocking-operations.)
+
+### v1.10.2
+
+  - Improved consistency of handling closed IO when invoking `#select`.
+
+### v1.10.0
+
+  - `IO::Event::Profiler` is moved to dedicated gem: [fiber-profiler](https://github.com/socketry/fiber-profiler).
+  - Perform runtime checks for native selectors to ensure they are supported in the current environment. While compile-time checks determine availability, restrictions like seccomp and SELinux may still prevent them from working.
+
 ### v1.9.0
 
-  - [Improved `IO::Event::Profiler` for detecting stalls.](https://socketry.github.io/io-event/releases/index#improved-io::event::profiler-for-detecting-stalls.)
+  - Improved `IO::Event::Profiler` for detecting stalls.
 
 ### v1.8.0
 
-  - [Detecting fibers that are stalling the event loop.](https://socketry.github.io/io-event/releases/index#detecting-fibers-that-are-stalling-the-event-loop.)
+  - Detecting fibers that are stalling the event loop.
 
 ### v1.7.5
 

data/releases.md

@@ -1,56 +1,47 @@
 # Releases
 
-## v1.9.0
+## v1.11.0
 
-### Improved `IO::Event::Profiler` for detecting stalls.
+### Introduce `IO::Event::WorkerPool` for off-loading blocking operations.
 
-A new `IO::Event::Profiler` class has been added to help detect stalls in the event loop. The previous approach was insufficient to detect all possible stalls. This new approach uses the `RUBY_EVENT_FIBER_SWITCH` event to track context switching by the scheduler, and can detect stalls no matter how they occur.
+The {ruby IO::Event::WorkerPool} provides a mechanism for executing blocking operations on separate OS threads while properly integrating with Ruby's fiber scheduler and GVL (Global VM Lock) management. This enables true parallelism for CPU-intensive or blocking operations that would otherwise block the event loop.
 
 ``` ruby
-profiler = IO::Event::Profiler.new
+# Fiber scheduler integration via blocking_operation_wait hook
+class MyScheduler
+	def initialize
+		@worker_pool = IO::Event::WorkerPool.new
+	end
+
+  def blocking_operation_wait(operation)
+    @worker_pool.call(operation)
+  end
+end
+
+# Usage with automatic offloading
+Fiber.set_scheduler(MyScheduler.new)
+# Automatically offload `rb_nogvl(..., RB_NOGVL_OFFLOAD_SAFE)` to a background thread:
+result = some_blocking_operation()
+```
 
-profiler.start
-		
-Fiber.new do
-	sleep 1.0
-end.transfer
+The implementation uses one or more background threads and a list of pending blocking operations. Those operations either execute through to completion or may be cancelled, which executes the "unblock function" provided to `rb_nogvl`.
 
-profiler.stop
-```
+## v1.10.2
 
-A default profiler is exposed using `IO::Event::Profiler.default` which is controlled by the following environment variables:
+  - Improved consistency of handling closed IO when invoking `#select`.
 
-  - `IO_EVENT_PROFILER=true` - Enable the profiler, otherwise `IO::Event::Profiler.default` will return `nil`.
-  - `IO_EVENT_PROFILER_LOG_THRESHOLD` - Specify the threshold in seconds for logging a stall. Defaults to `0.01`.
-  - `IO_EVENT_PROFILER_TRACK_CALLS` - Track the method call for each event, in order to log specifically which method is causing the stall. Defaults to `true`.
+## v1.10.0
+
+  - `IO::Event::Profiler` is moved to dedicated gem: [fiber-profiler](https://github.com/socketry/fiber-profiler).
+  - Perform runtime checks for native selectors to ensure they are supported in the current environment. While compile-time checks determine availability, restrictions like seccomp and SELinux may still prevent them from working.
+
+## v1.9.0
 
-The previous environment variables `IO_EVENT_SELECTOR_STALL_LOG_THRESHOLD` and `IO_EVENT_SELECTOR_STALL_LOG` no longer have any effect.
+  - Improved `IO::Event::Profiler` for detecting stalls.
 
 ## v1.8.0
 
-### Detecting fibers that are stalling the event loop.
-
-A new (experimental) feature for detecting fiber stalls has been added. This feature is disabled by default and can be enabled by setting the `IO_EVENT_SELECTOR_STALL_LOG_THRESHOLD` to `true` or a floating point number representing the threshold in seconds.
-
-When enabled, the event loop will measure and profile user code when resuming a fiber. If the fiber takes too long to return back to the event loop, the event loop will log a warning message with a profile of the fiber's execution.
-
-    > cat test.rb 
-    #!/usr/bin/env ruby
-    
-    require_relative "lib/async"
-    
-    Async do
-    	Fiber.blocking do
-    		sleep 1
-    	end
-    end
-    
-    > IO_EVENT_SELECTOR_STALL_LOG_THRESHOLD=true bundle exec ./test.rb
-    Fiber stalled for 1.003 seconds
-    	/home/samuel/Developer/socketry/async/test.rb:6 in '#<Class:Fiber>#blocking' (1s)
-    		/home/samuel/Developer/socketry/async/test.rb:7 in 'Kernel#sleep' (1s)
-
-There is a performance overhead to this feature, so it is recommended to only enable it when debugging performance issues.
+  - Detecting fibers that are stalling the event loop.
 
 ## v1.7.5
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.11.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -15,6 +15,7 @@ authors:
 - Delton Ding
 - Pavel Rosický
 - Shizuo Fujita
+- Stanislav (Stas) Katkov
 bindir: bin
 cert_chain:
 - |
@@ -46,7 +47,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2025-02-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 executables: []
 extensions:
@@ -63,8 +64,6 @@ files:
 - ext/io/event/interrupt.c
 - ext/io/event/interrupt.h
 - ext/io/event/list.h
-- ext/io/event/profiler.c
-- ext/io/event/profiler.h
 - ext/io/event/selector/epoll.c
 - ext/io/event/selector/epoll.h
 - ext/io/event/selector/kqueue.c
@@ -76,12 +75,15 @@ files:
 - ext/io/event/selector/uring.h
 - ext/io/event/time.c
 - ext/io/event/time.h
+- ext/io/event/worker_pool.c
+- ext/io/event/worker_pool.h
+- ext/io/event/worker_pool_test.c
+- ext/io/event/worker_pool_test.h
 - lib/io/event.rb
 - lib/io/event/debug/selector.rb
 - lib/io/event/interrupt.rb
 - lib/io/event/native.rb
 - lib/io/event/priority_heap.rb
-- lib/io/event/profiler.rb
 - lib/io/event/selector.rb
 - lib/io/event/selector/nonblock.rb
 - lib/io/event/selector/select.rb
@@ -111,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: An event loop.
 test_files: []