uringmachine 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8704dd734601efec57a8bb095c43dc44f752cd01b0cbe04c550fbc321fb2fbfa
-  data.tar.gz: 86d5a99e31296951b2fb565bd12a60b64f6ef43ba331c16bb1307d5a27b27971
+  metadata.gz: 6c4607791ec8b3aefe794167dc5a0ec500fe4ec4a58b56962d90d27fdd4c41a7
+  data.tar.gz: 151205d0887aef4cc0cf022baf295b9be8934f2bb895fd87bd98680a837349a0
 SHA512:
-  metadata.gz: e83aece1507a0be85ccbcc7bd229dbe2976fab489a59bb07814e147f51de5a9e526a4a4fbc08ddc5b3b01d96bfd132ad79de40acb58bcfca31eaab2b1516df01
-  data.tar.gz: 0d5572ccc1822cf50d9c0d3e1ad0fccb39f80640b753a9962a737a58ca6ea0024cb3342fe3c91d097f4f785186ded75f3cde587463409a2148ddb81bfef8de8f
+  metadata.gz: a4f580578fabf57dbc7c9c8d609a000b4b2ebc56ffb1273e3496137b7ba01f4ca71767e37d84d978dbf49b5012a211374cceb774b787f748c4b3351531a42c42
+  data.tar.gz: 0cc8a8d93345894b2f2b3570390ae829dea4bac1e975a0d777c7359e74161273df9658b0797bd2ecbe45a262efbd7588dd8f9ec673577d91e7e8030bd9ab15e4

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.0.1 2026-05-12
+
+- Fix Net::HTTP performance regression when running on fiber scheduler
+
 # 1.0.0 2026-04-27
 
 - Remove custom -Wxxx CFLAGS

data/benchmark/bm_net_http.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative './common'
+require_relative './bm_net_http_support'
+
+require 'net/http'
+
+CONCURRENCY = ENV['C']&.to_i || 50
+ITERATIONS = ENV['I']&.to_i || 200
+
+# Adapted from benchmark code in https://github.com/yaroslav/carbon_fiber
+
+RESPONSE_BODY = %({"ok":true,"value":12345})
+REQUEST_PATH = "/api"
+
+SERVER = LoopbackServer.new(
+  response_body: RESPONSE_BODY,
+  content_type: "application/json"
+)
+PORT = SERVER.port
+sleep(0.1)
+
+class UMBenchmark
+  def run_http_client
+    Net::HTTP.start("127.0.0.1", PORT, nil, nil) do |http|
+      ITERATIONS.times do
+        request = Net::HTTP::Get.new(REQUEST_PATH)
+        response = http.request(request)
+        raise "unexpected status #{response.code}" unless response.code == "200"
+        raise "unexpected body size" unless response.body&.bytesize == RESPONSE_BODY.bytesize
+      end
+    end
+  rescue => e
+    p e
+    p e.backtrace
+    exit!
+  end
+
+  def do_threads(threads, ios)
+    CONCURRENCY.times do
+      threads << Thread.new { run_http_client }
+    end
+  end
+
+  def do_scheduler(scheduler, ios)
+    CONCURRENCY.times do
+      Fiber.schedule { run_http_client }
+    end
+  end
+
+  def do_scheduler_x(div, scheduler, ios)
+    (CONCURRENCY/div).times { run_http_client }
+  end
+end

data/benchmark/bm_net_http_support.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Adapted from benchmark code in https://github.com/yaroslav/carbon_fiber
+
+require "socket"
+
+class LoopbackServer
+  attr_reader :port
+
+  def initialize(response_body:, content_type:)
+    @response_body = response_body.b
+    @content_type = content_type
+    @response = build_response(@response_body, @content_type)
+    @server = TCPServer.new("127.0.0.1", 0)
+    @port = @server.local_address.ip_port
+    @closed = false
+    @lock = Thread::Mutex.new
+    @client_threads = []
+    @client_sockets = []
+    @accept_thread = Thread.new { accept_loop }
+    @accept_thread.report_on_exception = false
+  end
+
+  def close
+    return if @closed
+
+    if Fiber.scheduler
+      closer = Thread.new { close_without_scheduler }
+      closer.report_on_exception = false
+      closer.join(2.0)
+    else
+      close_without_scheduler
+    end
+  rescue
+  end
+
+  private
+
+  def close_without_scheduler
+    return if @closed
+
+    @closed = true
+    @server.close unless @server.closed?
+    @lock.synchronize do
+      @client_sockets.each do |socket|
+        socket.close unless socket.closed?
+      rescue
+      end
+    end
+    @accept_thread.join(0.5)
+    @lock.synchronize { @client_threads.dup }.each { |thread| thread.join(0.5) }
+  end
+
+  def accept_loop
+    loop do
+      conn = @server.accept
+      conn.sync = true
+
+      worker = Thread.new(conn) do |socket|
+        Thread.current.report_on_exception = false
+        handle_client(socket)
+      end
+
+      @lock.synchronize do
+        @client_sockets << conn
+        @client_threads << worker
+      end
+    end
+  rescue IOError, Errno::EBADF
+    nil
+  end
+
+  def handle_client(socket)
+    loop do
+      request = read_request(socket)
+      break unless request
+
+      socket.write(@response)
+    end
+  rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+    nil
+  ensure
+    begin
+      @lock.synchronize { @client_sockets.delete(socket) }
+      socket.close unless socket.closed?
+    rescue # rubocop:disable Lint/SuppressedException
+    end
+  end
+
+  def read_request(socket)
+    buffer = +""
+    loop do
+      buffer << socket.readpartial(4096)
+      break if buffer.include?("\r\n\r\n")
+    end
+    buffer
+  rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+    nil
+  end
+
+  def build_response(body, content_type)
+    "HTTP/1.1 200 OK\r\n" \
+      "Content-Length: #{body.bytesize}\r\n" \
+      "Content-Type: #{content_type}\r\n" \
+      "Connection: keep-alive\r\n" \
+      "\r\n" \
+      "#{body}"
+  end
+end

data/benchmark/common.rb

@@ -64,14 +64,14 @@ class UMBenchmark
 
     threads:        [:threads,      "Threads"],
 
-    # async_uring:    [:scheduler,    "Async uring"],
+    async_uring:    [:scheduler,    "Async uring"],
     # async_uring_x2: [:scheduler_x,  "Async uring x2"],
 
     # async_epoll:    [:scheduler,    "Async epoll"],
     # async_epoll_x2: [:scheduler_x,  "Async epoll x2"],
 
     um_fs:          [:scheduler,    "UM FS"],
-    um_fs_x2:       [:scheduler_x,  "UM FS x2"],
+    # um_fs_x2:       [:scheduler_x,  "UM FS x2"],
 
     um:             [:um,           "UM"],
     # um_sidecar:     [:um,           "UM sidecar"],

data/lib/uringmachine/fiber_scheduler.rb

@@ -210,13 +210,21 @@ class UringMachine
     # Waits for the given io to become ready.
     #
     # @param io [IO] IO object
-    # @param events [Number] readiness bitmask
+    # @param events [Integer] readiness bitmask
     # @param timeout [Number, nil] optional timeout
-    # @return [void]
+    # @return [Integer] ready events bitmask
     def io_wait(io, events, timeout = nil)
-      # p io_wait: [io, events, timeout]
+      # Useful note from the Carbon Fiber Fiber::Scheduler implementation:
+      # Net::HTTP#begin_transport calls `wait_readable(0)` before every
+      # keep-alive request to probe for a closed connection.  On a healthy
+      # connection this is always "not readable", so returning false
+      # directly saves one MSG_PEEK recvfrom per request.  On a genuinely
+      # closed connection Net::HTTP will detect EOF on the next real read
+      # and reconnect — one extra request's worth of latency, at most.
+      return 0 if timeout == 0 && events == ::IO::READABLE && io.is_a?(BasicSocket)
+
       timeout ||= io.timeout
-      if timeout
+      if timeout && timeout > 0
         @machine.timeout(timeout, Timeout::Error) {
           @machine.poll(io.fileno, events)
         }

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Sharon Rosner
@@ -61,6 +61,8 @@ files:
 - benchmark/bm_io_ssl.rb
 - benchmark/bm_mutex_cpu.rb
 - benchmark/bm_mutex_io.rb
+- benchmark/bm_net_http.rb
+- benchmark/bm_net_http_support.rb
 - benchmark/bm_pg_client.rb
 - benchmark/bm_queue.rb
 - benchmark/bm_redis_client.rb