uringmachine 0.33.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6b62f0845e3bc8044bb1a21481d44c231d07a0fa191a92c7d4916ca6005a076
-  data.tar.gz: 7d2533a8c3c7c1fcc5d03c183a39a7fb789a2f05510cfbdce5bc08d9744969f3
+  metadata.gz: 6c4607791ec8b3aefe794167dc5a0ec500fe4ec4a58b56962d90d27fdd4c41a7
+  data.tar.gz: 151205d0887aef4cc0cf022baf295b9be8934f2bb895fd87bd98680a837349a0
 SHA512:
-  metadata.gz: a3d7b2d5ae670304d8540fd6684c3e2a8548c491866cbd3a2ddf1fb65034517f55b6faa41da4f7a8965d243cd86ae965c3ad3e6cb2d5026097ac36cdf4911d8b
-  data.tar.gz: 800d1c0fe51d8399aefd799efe3338e060c15a6a072b86b33078696f2920f84e59d138e97dd4518eb71d2a00f7ac7c5dc8860caef3d24a645486946291a09dba
+  metadata.gz: a4f580578fabf57dbc7c9c8d609a000b4b2ebc56ffb1273e3496137b7ba01f4ca71767e37d84d978dbf49b5012a211374cceb774b787f748c4b3351531a42c42
+  data.tar.gz: 0cc8a8d93345894b2f2b3570390ae829dea4bac1e975a0d777c7359e74161273df9658b0797bd2ecbe45a262efbd7588dd8f9ec673577d91e7e8030bd9ab15e4

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 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
+
 # 0.33.0 2026-04-12
 
 - Use buffer pool for `#read_each`, `#recv_each` methods

data/README.md

@@ -37,7 +37,7 @@ implementation that allows integration with the entire Ruby ecosystem.
 - Excellent performance characteristics for concurrent I/O-bound applications.
 - `Fiber::Scheduler` implementation to automatically integrate with the Ruby
   ecosystem in a transparent fashion.
-- [IO](#io-api) class with automatic buffer management for reading.
+- [UM::IO](#io-higher-level-api) class with automatic buffer management for reading.
 - Optimized I/O for encrypted SSL connections.
 
 ## Design
@@ -286,7 +286,7 @@ fiber = Fiber.schedule do
 end
 ```
 
-## IO API
+## IO Higher-level API
 
 `UringMachine::IO` is a class designed for efficiently read from and write to a
 socket or other file descriptor. The IO class is ideal for implementing

data/TODO.md

@@ -140,6 +140,4 @@ uint64_t alpha_numeric[] = [
 inline int test_char(char c, uint64 *bitmap) {
   return bitmap[c / 64] & (1UL << (c % 64));
 }
-
-
 ```

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/bm_redis_client.rb

@@ -4,7 +4,7 @@ require_relative './common'
 require 'securerandom'
 
 C = ENV['C']&.to_i || 50
-I = 10
+I = 100
 puts "C=#{C}"
 
 class UMBenchmark
@@ -12,6 +12,7 @@ class UMBenchmark
 
   def start_redis_server
     `docker run --name #{CONTAINER_NAME} -d -p 6379:6379 redis:latest`
+    create_redis_conn
   end
 
   def stop_redis_server
@@ -22,7 +23,7 @@ class UMBenchmark
     Redis.new
   rescue
     if retries < 3
-      sleep 0.5
+      sleep 0.2
       create_redis_conn(retries + 1)
     else
     raise
@@ -31,7 +32,7 @@ class UMBenchmark
 
   def query_redis(conn)
     conn.set('abc', 'def')
-    p conn.get('abc')
+    conn.get('abc')
   end
 
   def with_container
@@ -45,25 +46,33 @@ class UMBenchmark
   stop_redis_server
   end
 
+  def create_redis_conn(retries = 0)
+    Redis.new
+  rescue
+    raise if retries >= 3
+
+    sleep 0.5
+    create_redis_conn(retries + 1)
+  end
+
   def benchmark
     with_container {
       Benchmark.bm { run_benchmarks(it) }
     }
   end
 
-  # def do_threads(threads, ios)
-  #   C.times.map do
-  #     threads << Thread.new do
-  #       conn = create_redis_conn
-  #       I.times { query_redis(conn) }
-  #     ensure
-  #       conn.close
-  #     end
-  #   end
-  # end
+  def do_threads(threads, ios)
+    C.times.map do
+      threads << Thread.new do
+        conn = create_redis_conn
+        I.times { query_redis(conn) }
+      ensure
+        conn.close
+      end
+    end
+  end
 
   def do_scheduler(scheduler, ios)
-    return if !scheduler.is_a?(UM::FiberScheduler)
     C.times do
       Fiber.schedule do
         conn = create_redis_conn

data/benchmark/common.rb

@@ -62,18 +62,18 @@ class UMBenchmark
     # baseline_um:  [:baseline_um,  "UM no concurrency"],
     # thread_pool:  [:thread_pool,  "ThreadPool"],
 
-    # threads:        [:threads,      "Threads"],
+    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:          [:scheduler,    "UM FS"],
     # um_fs_x2:       [:scheduler_x,  "UM FS x2"],
 
-    # um:             [:um,           "UM"],
+    um:             [:um,           "UM"],
     # um_sidecar:     [:um,           "UM sidecar"],
     # um_sqpoll:      [:um,           "UM sqpoll"],
     um_x2:          [:um_x,         "UM x2"],

data/ext/um/extconf.rb

@@ -74,11 +74,4 @@ $defs << '-DHAVE_IO_URING_PREP_BIND'            if config[:prep_bind]
 $defs << '-DHAVE_IO_URING_PREP_LISTEN'          if config[:prep_listen]
 $defs << '-DHAVE_IO_URING_SEND_VECTORIZED'      if config[:send_vectoized]
 
-$CFLAGS << ' -Werror -Wall -Wextra'
-
-if ENV['SANITIZE']
-  $CFLAGS << ' -fsanitize=undefined,address -lasan'
-  $LDFLAGS << ' -fsanitize=undefined,address -lasan'
-end
-
 create_makefile 'um_ext'

data/ext/um/um.c

@@ -62,8 +62,7 @@ inline struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op) {
     machine->metrics.ops_unsubmitted, machine->metrics.ops_pending, machine->metrics.total_ops
   );
 
-  struct io_uring_sqe *sqe;
-  sqe = io_uring_get_sqe(&machine->ring);
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&machine->ring);
   if (likely(sqe)) goto done;
 
   um_raise_internal_error("Submission queue full. Consider raising the machine size.");
@@ -282,22 +281,22 @@ void *um_wait_for_cqe_without_gvl(void *ptr) {
   return NULL;
 }
 
-inline void um_profile_wait_cqe_pre(struct um *machine, double *time_monotonic0, VALUE *fiber) {
-  // *fiber = rb_fiber_current();
-  *time_monotonic0 = um_get_time_monotonic();
-  // double time_cpu = um_get_time_cpu();
-  // double elapsed = time_cpu - machine->metrics.time_last_cpu;
-  // um_update_fiber_time_run(fiber, time_monotonic0, elapsed);
-  // machine->metrics.time_last_cpu = time_cpu;
-}
+// inline void um_profile_wait_cqe_pre(struct um *machine, double *time_monotonic0, VALUE *fiber) {
+//   VALUE fiber = rb_fiber_current();
+//   *time_monotonic0 = um_get_time_monotonic();
+//   double time_cpu = um_get_time_cpu();
+//   double elapsed = time_cpu - machine->metrics.time_last_cpu;
+//   um_update_fiber_time_run(fiber, time_monotonic0, elapsed);
+//   machine->metrics.time_last_cpu = time_cpu;
+// }
 
-inline void um_profile_wait_cqe_post(struct um *machine, double time_monotonic0, VALUE fiber) {
-  // double time_cpu = um_get_time_cpu();
-  double elapsed = um_get_time_monotonic() - time_monotonic0;
-  // um_update_fiber_last_time(fiber, cpu_time1);
-  machine->metrics.time_total_wait += elapsed;
-  // machine->metrics.time_last_cpu = time_cpu;
-}
+// inline void um_profile_wait_cqe_post(struct um *machine, double time_monotonic0, VALUE fiber) {
+//   // double time_cpu = um_get_time_cpu();
+//   double elapsed = um_get_time_monotonic() - time_monotonic0;
+//   // um_update_fiber_last_time(fiber, cpu_time1);
+//   machine->metrics.time_total_wait += elapsed;
+//   // machine->metrics.time_last_cpu = time_cpu;
+// }
 
 inline void *um_wait_for_sidecar_signal(void *ptr) {
   struct um *machine = ptr;
@@ -329,11 +328,11 @@ static inline void um_wait_for_and_process_ready_cqes(struct um *machine, int wa
     // fprintf(stderr, "<< sidecar wait cqes\n");
   }
   else {
-    double time_monotonic0 = 0.0;
-    VALUE fiber;
-    if (machine->profile_mode) um_profile_wait_cqe_pre(machine, &time_monotonic0, &fiber);
+    // double time_monotonic0 = 0.0;
+    // VALUE fiber;
+    // if (machine->profile_mode) um_profile_wait_cqe_pre(machine, &time_monotonic0, &fiber);
     rb_thread_call_without_gvl(um_wait_for_cqe_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
-    if (machine->profile_mode) um_profile_wait_cqe_post(machine, time_monotonic0, fiber);
+    // if (machine->profile_mode) um_profile_wait_cqe_post(machine, time_monotonic0, fiber);
 
     if (unlikely(ctx.result < 0)) {
       // the internal calls to (maybe submit) and wait for cqes may fail with:
@@ -357,14 +356,14 @@ static inline void um_wait_for_and_process_ready_cqes(struct um *machine, int wa
   }
 }
 
-inline void um_profile_switch(struct um *machine, VALUE next_fiber) {
-  // *current_fiber = rb_fiber_current();
-  // double time_cpu = um_get_time_cpu();
-  // double elapsed = time_cpu - machine->metrics.time_last_cpu;
-  // um_update_fiber_time_run(cur_fiber, time_cpu, elapsed);
-  // um_update_fiber_time_wait(next_fiber, time_cpu);
-  // machine->metrics.time_last_cpu = time_cpu;
-}
+// inline void um_profile_switch(struct um *machine, VALUE next_fiber) {
+//   VALUE current_fiber = rb_fiber_current();
+//   double time_cpu = um_get_time_cpu();
+//   double elapsed = time_cpu - machine->metrics.time_last_cpu;
+//   um_update_fiber_time_run(cur_fiber, time_cpu, elapsed);
+//   um_update_fiber_time_wait(next_fiber, time_cpu);
+//   machine->metrics.time_last_cpu = time_cpu;
+// }
 
 inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
   DEBUG_PRINTF("* process_runqueue_op: op=%p kind=%s ref_count=%d flags=%x\n",
@@ -378,7 +377,7 @@ inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
   op->flags &= ~OP_F_SCHEDULED;
   um_op_release(machine, op);
 
-  if (machine->profile_mode) um_profile_switch(machine, fiber);
+  // if (machine->profile_mode) um_profile_switch(machine, fiber);
   VALUE ret = rb_fiber_transfer(fiber, 1, &value);
   RB_GC_GUARD(value);
   RB_GC_GUARD(ret);

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 = '0.33.0'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 0.33.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