ever 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ba6404ba736a8c3c519cba46a8bf8a9df85ecc4a9532790c15821bff12f348e
-  data.tar.gz: 162398e3f59e7a638cf7de58b47e0a05c746f4be49e46f62bbd23b60305a1f77
+  metadata.gz: f926fe6eb2d131d56a1efdc1ba290ce20d76da83f1647253b3b685ccbf49a446
+  data.tar.gz: 699c3ffcaf8c24bdfaac6d8e5e774f75473de4f3293a1e938621dd3cc4c1a2f2
 SHA512:
-  metadata.gz: a3e8236c119bdb97b0c5aa0b26f60cbc40f740201218de11494b2368e0c60e7ab3dc4b0235751b903483dc441fcc55f07bc9da61e6c06e5a26135656e909cfc8
-  data.tar.gz: aeef774232228911357f7c472a937695f319615d31f0bf11d93554177c3b184a32003b4489a5193ca803d90dbb67cfda5a64417e6c6045be11f73bc98d341b21
+  metadata.gz: 7faa3b7153799409100ca9a9427e20b26c38962e97f5fd480013880cef105387c4b4c10441b80676c4f31336f2235c15617335d7536e9b2db710ff72156ee1c4
+  data.tar.gz: af0b88f3a990fcf4e8f3a1d1f4e564b6746860162d786c84bb46d6673590f385f3bd4ad9d6ff3318d1fbcb26ca412e9a9becbca30c80e249408769592a835122

data/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: ciconia

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    ever (0.1)
+    ever (0.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
     http_parser.rb (0.7.0)
     minitest (5.14.4)
+    nio4r (2.5.8)
     rake (13.0.6)
     rake-compiler (1.1.1)
       rake
@@ -19,7 +20,8 @@ DEPENDENCIES
   ever!
   http_parser.rb (= 0.7.0)
   minitest (= 5.14.4)
+  nio4r (= 2.5.8)
   rake-compiler (= 1.1.1)
 
 BUNDLED WITH
-   2.2.26
+   2.3.7

data/README.md

@@ -13,6 +13,8 @@ Ever is a [libev](http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod)-based ev
 - Callback-less API for getting events
 - Events for I/O readiness
 - Events for one-shot or recurring timers
+- Application-defined event semantic (an event can be identifed by any object)
+- Easy API for breaking a blocking poll, no need for setting a timeout or writing to a pipe
 - Cross-thread signalling and emitting of events
 
 ## Rationale
@@ -29,10 +31,12 @@ After coming up with a bunch of different ideas for how to achieve this, I settl
 - When the request is complete, the worker threads continues to run the Rack app, gets the response, and tries to write the response. If the response cannot be written, the connection is watched for write readiness.
 - When the response has been written, the connection is watched again for read readiness in preparation for the next request.
 
-(A working sketch for this design is included [here as an example](https://github.com/digital-fabric/ever/blob/main/examples/http_server.rb).)
+(A working sketch for this design is included [here as an example](https://github.com/digital-fabric/ever/blob/main/examples/http_server_worker_threads.rb).)
 
 What's interesting about this design is that any number of worker threads can (theoretically) handle any number of concurrent requests, since each worker thread is not tied to a specific connection, but rather work on each connection in the queue as it becomes ready (for reading or writing).
 
+**Update**: actually I have seen performance degrade when adding more worker threads (also see the section below on [performance](#performance)). Switching to a [single-threaded design](https://github.com/digital-fabric/ever/blob/main/examples/http_server_single_thread.rb) improves throughput by ~25%!
+
 ## Installing
 
 If you're using bundler just add it to your `Gemfile`:
@@ -159,7 +163,24 @@ evloop.each { |key| handle_event(key) }
 
 ## Performance
 
-I did not yet explore all the performance implications of this new design, but [a sketch I made for an HTTP server](https://github.com/digital-fabric/ever/blob/main/examples/http_server.rb) shows it performing consistently at >60000 reqs/seconds on my development machine.
+I did not yet explore all the performance implications of this new design, but [a sketch I made for an HTTP server](https://github.com/digital-fabric/ever/blob/main/examples/http_server_worker_threads.rb) shows it performing consistently at >60,000 reqs/seconds on my development machine, with a single worker thread.
+
+However, adding more worker threads actually degrades the performance. This is both due to the cost associated with the [GVL](https://www.speedshop.co/2020/05/11/the-ruby-gvl-and-scaling.html), and contention for the job queue.
+
+A [slightly modified HTTP server script](https://github.com/digital-fabric/ever/blob/main/examples/http_server_worker_threads_separate_queues.rb), with a separate job queue for each thread, does not fare much better. A [separate design with no worker thread](https://github.com/digital-fabric/ever/blob/main/examples/http_server_single_thread.rb) (everything happens on the main thread), yields a throughput of ~75,000 reqs/seconds on the same machine, about ~25% better than the version with worker threads. Of course, when running a Rack app, having everything happen on the main thread means there's no concurrent handling of requests within a single process. Here are some indicative results, along with an equivalent implementation using [nio4r](https://github.com/socketry/nio4r/):
+
+|Script|`-t2 -c10`|`-t4 -c64`|`-t8 -c256`|`-t8 -c1024`|
+|------|---------:|---------:|----------:|-----------:|
+|[nio4r single thread](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r_single_thread.rb)|63775 (4.27ms)|58420 (28.80ms)|51302 (584.78ms)|47294 (1.21s)|
+|[nio4r 1 worker threads](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r.rb)|25276 (89.69ms)|13458 (394.90ms)|6559 (1.83s)|2660 (1.99s)|
+|[nio4r 4 worker threads](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r.rb)|23785 (104.84ms)|12826 (439.89ms)|6471 (1.08s)|2660 (2.00s)|
+|[nio4r 8 worker threads](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r.rb)|24028 (106.38ms)|12825 (429.98ms)|6409 (956.85ms)|2600 (2.00s)|
+|[ever single thread](https://github.com/digital-fabric/ever/blob/main/examples/http_server_single_thread.rb)|77994 (3.91ms)|75271 (32.32ms)|65799 (443.88ms)|56425 (1.99s)|
+|[ever 1 worker thread](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r.rb)|64475 (4.05ms)|69883 (31.68ms)|61917 (327.95ms)|52975 (4.56s)|
+|[ever 4 worker threads](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r.rb)|48763 (4.15ms)|60829 (26.15ms)|56906 (482.95ms)|54713 (6.03s)|
+|[ever 8 worker threads](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r.rb)|41378 (4.18ms)|55959 (36.51ms)|
+|[ever 4 worker threads, separate queues](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r.rb)|
+|[ever 8 worker threads, separate queues](https://github.com/digital-fabric/ever/blob/main/examples/http_server_nio4r.rb)|
 
 ## Contributing
 

data/ever.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency  'rake-compiler',        '1.1.1'
   s.add_development_dependency  'minitest',             '5.14.4'
   s.add_development_dependency  'http_parser.rb',       '0.7.0'
+  s.add_development_dependency  'nio4r',                '2.5.8'
 end

data/examples/http_server_nio4r_single_thread.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'nio'
+require 'http/parser'
+require 'socket'
+
+class Connection
+  attr_reader :io, :parser, :request_complete,
+              :request_headers, :request_body
+  attr_accessor :response, :monitor
+
+  def initialize(io)
+    @io = io
+    @parser = Http::Parser.new(self)
+    setup_read_request
+  end
+
+  def setup_read_request
+    @request_complete = nil
+    @request_headers = nil
+    @request_body = +''
+  end
+
+  def on_headers_complete(headers)
+    @request_headers = headers
+  end
+
+  def on_body(chunk)
+    @request_body << chunk
+  end
+
+  def on_message_complete
+    @request_complete = true
+  end
+
+  def monitor(event)
+    @monitor&.close
+    @monitor = $selector.register(@io, event)
+    @monitor.value = self
+  end
+
+  def close
+    @monitor&.close
+    @io.close
+  end
+end
+
+def handle_connection(conn)
+  if !conn.request_complete
+    handle_read_request(conn)
+  else
+    handle_write_response(conn)
+  end
+end
+
+def handle_read_request(conn)
+  result = conn.io.read_nonblock(16384, exception: false)
+  case result
+  when :wait_readable
+    conn.monitor(:r)
+  when :wait_writable
+    conn.monitor(:w)
+  when nil
+    conn.close
+  else
+    conn.parser << result
+    if conn.request_complete
+      conn.response = handle_request(conn.request_headers, conn.request_body)
+      handle_write_response(conn)
+    else
+      conn.monitor(:r)
+    end
+  end
+rescue HTTP::Parser::Error, SystemCallError, IOError
+  conn.close
+end
+
+def handle_request(headers, body)
+  response_body = "Hello, world!"
+  "HTTP/1.1 200 OK\nContent-Length: #{response_body.bytesize}\n\n#{response_body}"
+end
+
+def handle_write_response(conn)
+  result = conn.io.write_nonblock(conn.response, exception: false)
+  case result
+  when :wait_readable
+    conn.monitor(:r)
+  when :wait_writable
+    conn.monitor(:w)
+  when nil
+    conn.close
+  else
+    conn.setup_read_request
+    conn.monitor(:r)
+  end
+end
+
+def setup_connection(io)
+  conn = Connection.new(io)
+  conn.monitor(:r)
+end
+
+server = TCPServer.new('0.0.0.0', 1234)
+puts "Listening on port 1234..."
+trap('SIGINT') { exit! }
+
+$selector = NIO::Selector.new
+
+$selector.register(server, :r)
+
+loop do
+  $selector.select do |monitor|
+    case monitor.io
+    when server
+      socket = server.accept
+      setup_connection(socket)
+    else
+      handle_connection(monitor.value)
+    end
+  end
+end

data/examples/http_server_nio4r_worker_threads.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'nio'
+require 'http/parser'
+require 'socket'
+
+class Connection
+  attr_reader :io, :parser, :request_complete,
+              :request_headers, :request_body
+  attr_accessor :response, :monitor
+
+  def initialize(io)
+    @io = io
+    @parser = Http::Parser.new(self)
+    setup_read_request
+  end
+
+  def setup_read_request
+    @request_complete = nil
+    @request_headers = nil
+    @request_body = +''
+  end
+
+  def on_headers_complete(headers)
+    @request_headers = headers
+  end
+
+  def on_body(chunk)
+    @request_body << chunk
+  end
+
+  def on_message_complete
+    @request_complete = true
+  end
+
+  def emit_monitor(event)
+    $directive_queue << [:monitor, self, event]
+    $o << '.'
+  end
+
+  def emit_close
+    $directive_queue << [:close, self]
+    $o << '.'
+  end
+
+  def monitor(event)
+    @monitor&.close
+    @monitor = $selector.register(@io, event)
+    @monitor.value = self
+  rescue IOError
+    @monitor = nil
+  end
+
+  def close
+    @monitor&.close
+    @io.close
+  end
+end
+
+def handle_connection(conn)
+  if !conn.request_complete
+    handle_read_request(conn)
+  else
+    handle_write_response(conn)
+  end
+end
+
+def handle_read_request(conn)
+  result = conn.io.read_nonblock(16384, exception: false)
+  case result
+  when :wait_readable
+    conn.emit_monitor(:r)
+  when :wait_writable
+    conn.emit_monitor(:w)
+  when nil
+    conn.emit_close
+  else
+    conn.parser << result
+    if conn.request_complete
+      conn.response = handle_request(conn.request_headers, conn.request_body)
+      handle_write_response(conn)
+    else
+      conn.emit_monitor(:r)
+    end
+  end
+rescue HTTP::Parser::Error, SystemCallError, IOError
+  conn.emit_close
+end
+
+def handle_request(headers, body)
+  response_body = "Hello, world!"
+  "HTTP/1.1 200 OK\nContent-Length: #{response_body.bytesize}\n\n#{response_body}"
+end
+
+def handle_write_response(conn)
+  result = conn.io.write_nonblock(conn.response, exception: false)
+  case result
+  when :wait_readable
+    conn.emit_monitor(:r)
+  when :wait_writable
+    conn.emit_monitor(:w)
+  when nil
+    conn.emit_close
+  else
+    conn.setup_read_request
+    conn.emit_monitor(:r)
+  end
+end
+
+def setup_connection(io)
+  # happens in the main thread
+  conn = Connection.new(io)
+  conn.monitor(:r)
+end
+
+num_workers = ARGV[0] ? ARGV[0].to_i : 1
+if num_workers < 1
+  puts "Invalid number of worker threads: #{ARGV[0].inspect}"
+  exit!
+end
+
+server = TCPServer.new('0.0.0.0', 1234)
+puts "Listening on port 1234..."
+trap('SIGINT') { exit! }
+
+$selector = NIO::Selector.new
+$i, $o = IO.pipe
+$selector.register(server, :r)
+$selector.register($i, :r)
+
+$job_queue = Queue.new
+$directive_queue = Queue.new
+
+puts "Starting #{num_workers} worker threads..."
+num_workers.times do
+  Thread.new do
+    while (job = $job_queue.shift)
+      handle_connection(job)
+    end
+  end
+end
+
+loop do
+  $selector.select do |monitor|
+    case monitor.io
+    when server
+      socket = server.accept
+      setup_connection(socket)
+    when $i
+      $i.read(1) # flush pipe
+      while !$directive_queue.empty?
+        k, c, e = $directive_queue.shift
+        case k
+        when :monitor
+          c.monitor(e)
+        when :close
+          c.close
+        end
+      end
+    else
+      $job_queue << monitor.value
+    end
+  end
+end

data/examples/{http_server.rb → http_server_single_thread.rb}

@@ -35,15 +35,8 @@ class Connection
   end
 end
 
-$job_queue = Queue.new
 $evloop = Ever::Loop.new
 
-worker = Thread.new do
-  while (job = $job_queue.shift)
-    handle_connection(job)
-  end
-end
-
 def handle_connection(conn)
   if !conn.request_complete
     handle_read_request(conn)
@@ -110,7 +103,7 @@ $evloop.each do |event|
     socket = server.accept
     setup_connection(socket)
   when Connection
-    $job_queue << event
+    handle_connection(event)
   when Array
     cmd = event[0]
     case cmd

data/examples/http_server_worker_threads.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ever'
+require 'http/parser'
+require 'socket'
+
+class Connection
+  attr_reader :io, :parser, :request_complete,
+              :request_headers, :request_body
+  attr_accessor :response
+
+  def initialize(io)
+    @io = io
+    @parser = Http::Parser.new(self)
+    setup_read_request
+  end
+
+  def setup_read_request
+    @request_complete = nil
+    @request_headers = nil
+    @request_body = +''
+  end
+
+  def on_headers_complete(headers)
+    @request_headers = headers
+  end
+
+  def on_body(chunk)
+    @request_body << chunk
+  end
+
+  def on_message_complete
+    @request_complete = true
+  end
+end
+
+$job_queue = Queue.new
+$evloop = Ever::Loop.new
+
+def handle_connection(conn)
+  if !conn.request_complete
+    handle_read_request(conn)
+  else
+    handle_write_response(conn)
+  end
+end
+
+def handle_read_request(conn)
+  result = conn.io.read_nonblock(16384, exception: false)
+  case result
+  when :wait_readable
+    $evloop.emit([:watch_io, conn, false, true])
+  when :wait_writable
+    $evloop.emit([:watch_io, conn, true, true])
+  when nil
+    $evloop.emit([:close, conn])
+  else
+    conn.parser << result
+    if conn.request_complete
+      conn.response = handle_request(conn.request_headers, conn.request_body)
+      handle_write_response(conn)
+    else
+      $evloop.emit([:watch_io, conn, false, true])
+    end
+  end
+rescue HTTP::Parser::Error, SystemCallError, IOError
+  $evloop.emit([:close, conn])
+end
+
+def handle_request(headers, body)
+  response_body = "Hello, world!"
+  "HTTP/1.1 200 OK\nContent-Length: #{response_body.bytesize}\n\n#{response_body}"
+end
+
+def handle_write_response(conn)
+  result = conn.io.write_nonblock(conn.response, exception: false)
+  case result
+  when :wait_readable
+    $evloop.emit([:watch_io, conn, false, true])
+  when :wait_writable
+    $evloop.emit([:watch_io, conn, true, true])
+  when nil
+    $evloop.emit([:close, conn])
+  else
+    conn.setup_read_request
+    $evloop.emit([:watch_io, conn, false, true])
+  end
+end
+
+def setup_connection(io)
+  conn = Connection.new(io)
+  $evloop.emit([:watch_io, conn, false, true])
+end
+
+num_workers = ARGV[0] ? ARGV[0].to_i : 1
+if num_workers < 1
+  puts "Invalid number of worker threads: #{ARGV[0].inspect}"
+  exit!
+end
+
+server = TCPServer.new('0.0.0.0', 1234)
+puts "Listening on port 1234..."
+trap('SIGINT') { $evloop.stop }
+$evloop.watch_io(:accept, server, false, false)
+
+puts "Starting #{num_workers} worker threads..."
+num_workers.times do
+  Thread.new do
+    while (job = $job_queue.shift)
+      handle_connection(job)
+    end
+  end
+end
+
+$evloop.each do |event|
+  case event
+  when :accept
+    socket = server.accept
+    setup_connection(socket)
+  when Connection
+    $job_queue << event
+  when Array
+    cmd = event[0]
+    case cmd
+    when :watch_io
+      $evloop.watch_io(event[1], event[1].io, event[2], event[3])
+    when :close
+      conn = event[1]
+      conn.io.close
+    end
+  end
+end

data/examples/http_server_worker_threads_separate_queues.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ever'
+require 'http/parser'
+require 'socket'
+
+class Connection
+  attr_reader :io, :parser, :request_complete,
+              :request_headers, :request_body
+  attr_accessor :response
+
+  def initialize(io)
+    @io = io
+    @parser = Http::Parser.new(self)
+    setup_read_request
+  end
+
+  def setup_read_request
+    @request_complete = nil
+    @request_headers = nil
+    @request_body = +''
+  end
+
+  def on_headers_complete(headers)
+    @request_headers = headers
+  end
+
+  def on_body(chunk)
+    @request_body << chunk
+  end
+
+  def on_message_complete
+    @request_complete = true
+  end
+end
+
+$evloop = Ever::Loop.new
+
+def handle_connection(conn)
+  if !conn.request_complete
+    handle_read_request(conn)
+  else
+    handle_write_response(conn)
+  end
+end
+
+def handle_read_request(conn)
+  result = conn.io.read_nonblock(16384, exception: false)
+  case result
+  when :wait_readable
+    $evloop.emit([:watch_io, conn, false, true])
+  when :wait_writable
+    $evloop.emit([:watch_io, conn, true, true])
+  when nil
+    $evloop.emit([:close, conn])
+  else
+    conn.parser << result
+    if conn.request_complete
+      conn.response = handle_request(conn.request_headers, conn.request_body)
+      handle_write_response(conn)
+    else
+      $evloop.emit([:watch_io, conn, false, true])
+    end
+  end
+rescue HTTP::Parser::Error, SystemCallError, IOError
+  $evloop.emit([:close, conn])
+end
+
+def handle_request(headers, body)
+  response_body = "Hello, world!"
+  "HTTP/1.1 200 OK\nContent-Length: #{response_body.bytesize}\n\n#{response_body}"
+end
+
+def handle_write_response(conn)
+  result = conn.io.write_nonblock(conn.response, exception: false)
+  case result
+  when :wait_readable
+    $evloop.emit([:watch_io, conn, false, true])
+  when :wait_writable
+    $evloop.emit([:watch_io, conn, true, true])
+  when nil
+    $evloop.emit([:close, conn])
+  else
+    conn.setup_read_request
+    $evloop.emit([:watch_io, conn, false, true])
+  end
+end
+
+def setup_connection(io)
+  conn = Connection.new(io)
+  $evloop.emit([:watch_io, conn, false, true])
+end
+
+num_workers = ARGV[0] ? ARGV[0].to_i : 1
+if num_workers < 1
+  puts "Invalid number of worker threads: #{ARGV[0].inspect}"
+  exit!
+end
+
+server = TCPServer.new('0.0.0.0', 1234)
+puts "Listening on port 1234..."
+trap('SIGINT') { $evloop.stop }
+$evloop.watch_io(:accept, server, false, false)
+
+puts "Starting #{num_workers} worker threads..."
+
+$queues = []
+def start_worker_thread
+  queue = Queue.new
+  $queues << queue
+  Thread.new do
+    while (job = queue.shift)
+      handle_connection(job)
+    end
+  end
+end
+
+num_workers.times { start_worker_thread }
+
+$evloop.each do |event|
+  case event
+  when :accept
+    socket = server.accept
+    setup_connection(socket)
+  when Connection
+    queue = $queues.sample
+    queue << event
+  when Array
+    cmd = event[0]
+    case cmd
+    when :watch_io
+      $evloop.watch_io(event[1], event[1].io, event[2], event[3])
+    when :close
+      conn = event[1]
+      conn.io.close
+    end
+  end
+end

data/ext/ever/ever.h

@@ -1,7 +1,6 @@
 #ifndef EVER_H
 #define EVER_H
 
-#include <execinfo.h>
 #include "ruby.h"
 #include "../libev/ev.h"
 
@@ -9,13 +8,6 @@
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
 #define INSPECT(str, obj) { printf(str); VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf(": %s\n", StringValueCStr(s)); }
 #define TRACE_CALLER() { VALUE c = rb_funcall(rb_mKernel, rb_intern("caller"), 0); INSPECT("caller: ", c); }
-#define TRACE_C_STACK() { \
-  void *entries[10]; \
-  size_t size = backtrace(entries, 10); \
-  char **strings = backtrace_symbols(entries, size); \
-  for (unsigned long i = 0; i < size; i++) printf("%s\n", strings[i]); \
-  free(strings); \
-}
 
 // exceptions
 #define TEST_EXCEPTION(ret) (rb_obj_is_kind_of(ret, rb_eException) == Qtrue)
@@ -34,7 +26,7 @@ typedef struct Loop_t {
   VALUE active_watchers;
   VALUE free_watchers;
   VALUE queued_events;
-  
+
   int stop;
   int in_ev_loop;
 } Loop_t;

data/ext/ever/extconf.rb

@@ -9,7 +9,7 @@ $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')
 $defs << '-DEV_USE_EPOLL'        if have_header('sys/epoll.h')
 $defs << '-DEV_USE_KQUEUE'       if have_header('sys/event.h') && have_header('sys/queue.h')
 $defs << '-DEV_USE_PORT'         if have_type('port_event_t', 'port.h')
-$defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')  
+$defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')
 
 $CFLAGS << " -Wno-comment"
 $CFLAGS << " -Wno-unused-result"

data/ext/ever/loop.c

@@ -65,9 +65,7 @@ static inline int sym_to_events(VALUE rw) {
 
 static inline int fd_from_io(VALUE io) {
   rb_io_t *fptr;
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
-  if (underlying_io != Qnil) io = underlying_io;
-  GetOpenFile(io, fptr);
+  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
   return fptr->fd;
 }
 
@@ -195,7 +193,7 @@ VALUE Loop_watch_fd(VALUE self, VALUE key, VALUE fd, VALUE rw, VALUE oneshot) {
   if (rb_hash_aref(loop->active_watchers, key) != Qnil)
     rb_raise(rb_eRuntimeError, "Duplicate event key detected, event key must be unique");
 
-  loop_watch_fd(loop, key, NUM2INT(fd), sym_to_events(rw), RTEST(oneshot));
+  loop_watch_fd(loop, key, FIX2INT(fd), sym_to_events(rw), RTEST(oneshot));
   return self;
 }
 
@@ -218,7 +216,7 @@ VALUE Loop_watch_timer(VALUE self, VALUE key, VALUE timeout, VALUE interval) {
     rb_raise(rb_eRuntimeError, "Duplicate event key detected, event key must be unique");
 
   loop_watch_timer(loop, key, NUM2DBL(timeout), NUM2DBL(interval));
-  return self;  
+  return self;
 }
 
 VALUE Loop_unwatch(VALUE self, VALUE key) {
@@ -241,7 +239,7 @@ void Init_Loop() {
   rb_define_alloc_func(cLoop, Loop_allocate);
 
   rb_define_method(cLoop, "initialize", Loop_initialize, 0);
-  
+
   rb_define_method(cLoop, "each", Loop_each, 0);
   rb_define_method(cLoop, "next_event", Loop_next_event, 0);
   rb_define_method(cLoop, "emit", Loop_emit, 1);

data/ext/ever/watcher.c

@@ -51,6 +51,10 @@ static VALUE Watcher_allocate(VALUE klass) {
   TypedData_Get_Struct((obj), Watcher_t, &Watcher_type, (watcher))
 
 VALUE Watcher_initialize(VALUE self) {
+  Watcher_t *watcher;
+  GetWatcher(self, watcher);
+
+  watcher->key = Qnil;
   return self;
 }
 
@@ -60,11 +64,11 @@ inline void watcher_stop(Watcher_t *watcher) {
   switch (watcher->type) {
     case WATCHER_IO:
       ev_io_stop(watcher->loop->ev_loop, &watcher->io);
-      return;
+      break;
     case WATCHER_TIMER:
       ev_timer_stop(watcher->loop->ev_loop, &watcher->timer);
-      return;
   }
+  watcher->key = Qnil;
 }
 
 void watcher_io_callback(EV_P_ ev_io *w, int revents)
@@ -72,8 +76,8 @@ void watcher_io_callback(EV_P_ ev_io *w, int revents)
   Watcher_t *watcher = (Watcher_t *)w;
   loop_emit(watcher->loop, watcher->key);
   if (watcher->oneshot) {
-    watcher_stop(watcher);
     loop_release_watcher(watcher->loop, watcher->key);
+    watcher_stop(watcher);
   }
 }
 
@@ -82,8 +86,8 @@ void watcher_timer_callback(EV_P_ ev_timer *w, int revents)
   Watcher_t *watcher = (Watcher_t *)w;
   loop_emit(watcher->loop, watcher->key);
   if (watcher->oneshot) {
-    watcher_stop(watcher);
     loop_release_watcher(watcher->loop, watcher->key);
+    watcher_stop(watcher);
   }
 }
 

data/lib/ever/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ever
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/test/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{__dir__}/test_*.rb").each do |path|
+  require(path)
+end

data/test/test_loop.rb

@@ -23,7 +23,7 @@ class LoopTest < MiniTest::Test
 
   def test_io
     i, o = IO.pipe
-    
+
     @loop.watch_io('foo', i, false, true)
 
     o << 'foo'
@@ -50,7 +50,7 @@ class LoopTest < MiniTest::Test
     i, o = IO.pipe
     @loop.watch_io('foo', i, false, true)
 
-    Thread.new { o << 'bar'; @loop.emit('baz') }
+    Thread.new { @loop.emit('baz'); o << 'bar' }
 
     event = @loop.next_event
     assert_equal 'baz', event

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ever
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-30 00:00:00.000000000 Z
+date: 2022-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -52,6 +52,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: nio4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.5.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.5.8
 description: 
 email: sharon@noteflakes.com
 executables: []
@@ -60,6 +74,7 @@ extensions:
 extra_rdoc_files:
 - README.md
 files:
+- ".github/FUNDING.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - CHANGELOG.md
@@ -69,7 +84,11 @@ files:
 - README.md
 - Rakefile
 - ever.gemspec
-- examples/http_server.rb
+- examples/http_server_nio4r_single_thread.rb
+- examples/http_server_nio4r_worker_threads.rb
+- examples/http_server_single_thread.rb
+- examples/http_server_worker_threads.rb
+- examples/http_server_worker_threads_separate_queues.rb
 - ext/ever/ever.h
 - ext/ever/ever_ext.c
 - ext/ever/extconf.rb
@@ -124,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Callback-less event reactor for Ruby