omq 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37d1cbdb4834bd8c3171e5317403066d6cc84f454ab4f3c076655019480634ad
-  data.tar.gz: 95e1712a3c993aad845d499c5b2462c42ab6720aa4c7f4134aab05fd4f972ea5
+  metadata.gz: 76cecd3650f9fb73d699a027570421f589452a40cf6bbf207af02afb2bc6df08
+  data.tar.gz: 0252e01bacd5278defe46ed9ab4750b3e33ca71e928beb13f1092c23a7c2ce62
 SHA512:
-  metadata.gz: 4e8412637f3eb2adce4451866217018e2947ab0e1ff1324664ff9946d658115ab042d3c429811d0d7c269704c54bb7c6ba2902570a8e882a2e5349b9504665c7
-  data.tar.gz: fc54cbabda462a9a50a9135f9c7f4da202229a768c74f60fff8cfe56fccd6ad7bdfd68a90e4e4525e091b8d0b71640692997596978b696596a33d572227bdbd3
+  metadata.gz: de2508cbe4e22c6dc93bdeab4626fed0c5280cf74eaaf4c4f886f566719a3c732f5db9b766c201f7e9d6eb7bb00ee4ed2d2392eec232abe88c7847148b889fc5
+  data.tar.gz: 65e96cef70697abe90588e5e35f4563e55ef183bb0be44276c6cb62ec007f6accb4e482a08c14d89b15ec3f542d75c78bacc87c6174ca6f4e69b588ddb540730

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.5.1 — 2026-03-28
+
+### Improved
+
+- **3–4x throughput under burst load** — send pumps now batch writes
+  before flushing. `Connection#write_message` buffers without flushing;
+  `Connection#flush` triggers the syscall. Pumps drain all queued messages
+  per cycle, reducing flush count from `N_msgs × N_conns` to `N_conns`
+  per batch. PUB/SUB TCP with 10 subscribers: 2.3k → 9.2k msg/s (**4x**).
+  PUSH/PULL TCP: 24k → 83k msg/s (**3.4x**). Zero overhead under light
+  load (batch of 1 = same path as before).
+
+- **Simplified Reactor IO thread** — replaced `Thread::Queue` + `IO.pipe`
+  wake signal with a single `Async::Queue`. `Thread::Queue#pop` is
+  fiber-scheduler-aware in Ruby 4.0, so the pipe pair was unnecessary.
+
+### Fixed
+
+- **`router_mandatory` SocketError raised in send pump** — the error
+  killed the pump fiber instead of reaching the caller. Now checked
+  synchronously in `enqueue` before queuing.
+
 ## 0.5.0 — 2026-03-28
 
 ### Added

data/lib/omq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/omq/zmtp/connection.rb

@@ -77,21 +77,36 @@ module OMQ
         end
       end
 
-      # Sends a multi-frame message.
+      # Sends a multi-frame message (write + flush).
       #
       # @param parts [Array<String>] message frames
       # @return [void]
       #
       def send_message(parts)
         @mutex.synchronize do
-          parts.each_with_index do |part, i|
-            more = i < parts.size - 1
-            if @mechanism.encrypted?
-              @io.write(@mechanism.encrypt(part.b, more: more))
-            else
-              @io.write(Codec::Frame.new(part, more: more).to_wire)
-            end
-          end
+          write_frames(parts)
+          @io.flush
+        end
+      end
+
+      # Writes a multi-frame message to the buffer without flushing.
+      # Call {#flush} after batching writes.
+      #
+      # @param parts [Array<String>] message frames
+      # @return [void]
+      #
+      def write_message(parts)
+        @mutex.synchronize do
+          write_frames(parts)
+        end
+      end
+
+      # Flushes the write buffer to the underlying IO.
+      #
+      # @return [void]
+      #
+      def flush
+        @mutex.synchronize do
           @io.flush
         end
       end
@@ -213,6 +228,17 @@ module OMQ
 
       private
 
+      def write_frames(parts)
+        parts.each_with_index do |part, i|
+          more = i < parts.size - 1
+          if @mechanism.encrypted?
+            @io.write(@mechanism.encrypt(part.b, more: more))
+          else
+            @io.write(Codec::Frame.new(part, more: more).to_wire)
+          end
+        end
+      end
+
       def touch_heartbeat
         @last_received_at = monotonic_now if @heartbeat_interval
       end

data/lib/omq/zmtp/reactor.rb

@@ -12,11 +12,9 @@ module OMQ
     # tasks — mirroring libzmq's IO thread architecture.
     #
     module Reactor
-      @work_queue = Thread::Queue.new
+      @work_queue = Async::Queue.new
       @thread     = nil
       @mutex      = Mutex.new
-      @wake_r     = nil
-      @wake_w     = nil
 
       class << self
         # Spawns a pump task (recv loop, send loop, accept loop).
@@ -33,7 +31,6 @@ module OMQ
             handle = PumpHandle.new
             ensure_started
             @work_queue.push([:spawn, block, handle])
-            @wake_w.write_nonblock(".") rescue nil
             handle
           end
         end
@@ -52,7 +49,6 @@ module OMQ
             result_queue = Thread::Queue.new
             ensure_started
             @work_queue.push([:run, block, result_queue])
-            @wake_w.write_nonblock(".") rescue nil
             status, value = result_queue.pop
             raise value if status == :error
             value
@@ -66,9 +62,8 @@ module OMQ
         def ensure_started
           @mutex.synchronize do
             return if @thread&.alive?
-            @wake_r, @wake_w = IO.pipe
             ready = Thread::Queue.new
-            @thread = Thread.new { run_reactor(ready, @wake_r) }
+            @thread = Thread.new { run_reactor(ready) }
             @thread.name = "omq-io"
             ready.pop
           end
@@ -80,42 +75,31 @@ module OMQ
         #
         def stop!
           @work_queue.push([:stop])
-          @wake_w&.write_nonblock(".") rescue nil
           @thread&.join(2)
           @thread = nil
-          @wake_r&.close rescue nil
-          @wake_w&.close rescue nil
-          @wake_r = nil
-          @wake_w = nil
         end
 
         private
 
-        def run_reactor(ready, wake_r)
+        def run_reactor(ready)
           Async do |task|
             ready.push(true)
             loop do
-              # Wait for wakeup signal (non-blocking for Async scheduler)
-              wake_r.wait_readable
-              wake_r.read_nonblock(256) rescue nil
-
-              # Drain all pending work items
-              while (item = @work_queue.pop(true) rescue nil)
-                case item[0]
-                when :spawn
-                  _, block, handle = item
-                  async_task = task.async(transient: true, &block)
-                  handle.task = async_task
-                when :run
-                  _, block, result_queue = item
-                  task.async do
-                    result_queue.push([:ok, block.call])
-                  rescue => e
-                    result_queue.push([:error, e])
-                  end
-                when :stop
-                  return
+              item = @work_queue.dequeue
+              case item[0]
+              when :spawn
+                _, block, handle = item
+                async_task = task.async(transient: true, &block)
+                handle.task = async_task
+              when :run
+                _, block, result_queue = item
+                task.async do
+                  result_queue.push([:ok, block.call])
+                rescue => e
+                  result_queue.push([:error, e])
                 end
+              when :stop
+                return
               end
             end
           end

data/lib/omq/zmtp/routing/channel.rb

@@ -58,7 +58,12 @@ module OMQ
 
         def start_send_pump(conn)
           @send_pump = Reactor.spawn_pump do
-            loop { conn.send_message(@send_queue.dequeue) }
+            loop do
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+              batch.each { |parts| conn.write_message(parts) }
+              conn.flush
+            end
           rescue *ZMTP::CONNECTION_LOST
             @engine.connection_lost(conn)
           end

data/lib/omq/zmtp/routing/fan_out.rb

@@ -54,16 +54,28 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              topic = parts.first || "".b
-              @connections.each do |conn|
-                next unless subscribed?(conn, topic)
-                begin
-                  conn.send_message(parts)
-                rescue *ZMTP::CONNECTION_LOST
-                  # connection dead — will be cleaned up
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                topic = parts.first || "".b
+                @connections.each do |conn|
+                  next unless subscribed?(conn, topic)
+                  begin
+                    conn.write_message(parts)
+                    written << conn
+                  rescue *ZMTP::CONNECTION_LOST
+                    # connection dead — will be cleaned up
+                  end
                 end
               end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # connection dead — will be cleaned up
+              end
             end
           end
         end

data/lib/omq/zmtp/routing/pair.rb

@@ -61,7 +61,12 @@ module OMQ
 
         def start_send_pump(conn)
           @send_pump = Reactor.spawn_pump do
-            loop { conn.send_message(@send_queue.dequeue) }
+            loop do
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+              batch.each { |parts| conn.write_message(parts) }
+              conn.flush
+            end
           rescue *ZMTP::CONNECTION_LOST
             @engine.connection_lost(conn)
           end

data/lib/omq/zmtp/routing/peer.rb

@@ -63,11 +63,27 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts      = @send_queue.dequeue
-              routing_id = parts.first
-              conn       = @connections_by_routing_id[routing_id]
-              next unless conn # silently drop if peer gone
-              conn.send_message(parts[1..])
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                routing_id = parts.first
+                conn       = @connections_by_routing_id[routing_id]
+                next unless conn # silently drop if peer gone
+                begin
+                  conn.write_message(parts[1..])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # will be cleaned up
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              end
             end
           end
         end

data/lib/omq/zmtp/routing/radio.rb

@@ -69,18 +69,30 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              group = parts[0]
-              body  = parts[1] || "".b
-              @connections.each do |conn|
-                next unless @groups[conn]&.include?(group)
-                begin
-                  # Wire format: group frame (MORE) + body frame
-                  conn.send_message([group, body])
-                rescue *ZMTP::CONNECTION_LOST
-                  # connection dead — will be cleaned up
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                group = parts[0]
+                body  = parts[1] || "".b
+                @connections.each do |conn|
+                  next unless @groups[conn]&.include?(group)
+                  begin
+                    # Wire format: group frame (MORE) + body frame
+                    conn.write_message([group, body])
+                    written << conn
+                  rescue *ZMTP::CONNECTION_LOST
+                    # connection dead — will be cleaned up
+                  end
                 end
               end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # connection dead — will be cleaned up
+              end
             end
           end
         end

data/lib/omq/zmtp/routing/rep.rb

@@ -68,13 +68,28 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              reply_info = @pending_replies.shift
-              next unless reply_info
-              reply_info[:conn].send_message([*reply_info[:envelope], "".b, *parts])
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                reply_info = @pending_replies.shift
+                next unless reply_info
+                conn = reply_info[:conn]
+                begin
+                  conn.write_message([*reply_info[:envelope], "".b, *parts])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # connection lost mid-write
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # connection lost mid-flush
+              end
             end
-          rescue *ZMTP::CONNECTION_LOST
-            # connection lost mid-write
           end
         end
       end

data/lib/omq/zmtp/routing/round_robin.rb

@@ -55,8 +55,14 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              send_with_retry(parts)
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              if batch.size == 1
+                send_with_retry(batch[0])
+              else
+                send_batch(batch)
+              end
             end
           end
         end
@@ -68,6 +74,35 @@ module OMQ
           @engine.connection_lost(conn)
           retry
         end
+
+        def send_batch(batch)
+          written = Set.new
+          batch.each_with_index do |parts, i|
+            conn = next_connection
+            begin
+              conn.write_message(transform_send(parts))
+              written << conn
+            rescue *ZMTP::CONNECTION_LOST
+              @engine.connection_lost(conn)
+              # Flush what we've written so far
+              written.each do |c|
+                c.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              end
+              written.clear
+              # Fall back to send_with_retry for this and remaining
+              send_with_retry(parts)
+              batch[(i + 1)..].each { |p| send_with_retry(p) }
+              return
+            end
+          end
+          written.each do |conn|
+            conn.flush
+          rescue *ZMTP::CONNECTION_LOST
+            # will be cleaned up
+          end
+        end
       end
     end
   end

data/lib/omq/zmtp/routing/router.rb

@@ -52,6 +52,12 @@ module OMQ
         # @param parts [Array<String>]
         #
         def enqueue(parts)
+          if @engine.options.router_mandatory?
+            identity = parts.first
+            unless @connections_by_identity[identity]
+              raise SocketError, "no route to identity #{identity.inspect}"
+            end
+          end
           @send_queue.enqueue(parts)
         end
 
@@ -66,19 +72,27 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              identity = parts.first
-              conn = @connections_by_identity[identity]
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
 
-              unless conn
-                if @engine.options.router_mandatory?
-                  raise SocketError, "no route to identity #{identity.inspect}"
+              written = Set.new
+              batch.each do |parts|
+                identity = parts.first
+                conn     = @connections_by_identity[identity]
+                next unless conn # silently drop (peer may have disconnected)
+                begin
+                  conn.write_message(parts[1..])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # will be cleaned up
                 end
-                next # silently drop
               end
 
-              # Send everything after the identity frame
-              conn.send_message(parts[1..])
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              end
             end
           end
         end

data/lib/omq/zmtp/routing/server.rb

@@ -63,11 +63,27 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts      = @send_queue.dequeue
-              routing_id = parts.first
-              conn       = @connections_by_routing_id[routing_id]
-              next unless conn # silently drop if peer gone
-              conn.send_message(parts[1..])
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                routing_id = parts.first
+                conn       = @connections_by_routing_id[routing_id]
+                next unless conn # silently drop if peer gone
+                begin
+                  conn.write_message(parts[1..])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # will be cleaned up
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              end
             end
           end
         end

data/lib/omq/zmtp/routing.rb

@@ -12,6 +12,25 @@ module OMQ
     # the socket's send/recv queues.
     #
     module Routing
+      # Maximum messages to drain from the send queue per flush cycle.
+      MAX_SEND_BATCH = 64
+
+      # Drains up to +max+ additional messages from +queue+ into +batch+
+      # without blocking. Call after the initial blocking dequeue.
+      #
+      # @param queue [Async::LimitedQueue]
+      # @param batch [Array]
+      # @param max [Integer]
+      # @return [void]
+      #
+      def self.drain_send_queue(queue, batch, max = MAX_SEND_BATCH)
+        while batch.size < max
+          msg = queue.dequeue(timeout: 0)
+          break unless msg
+          batch << msg
+        end
+      end
+
       # Returns the routing strategy class for a socket type.
       #
       # @param socket_type [Symbol] e.g. :PAIR, :REQ

data/lib/omq/zmtp/transport/inproc.rb

@@ -262,6 +262,14 @@ module OMQ
             end
           end
 
+          alias write_message send_message
+
+          # No-op — inproc has no IO buffer to flush.
+          #
+          # @return [void]
+          #
+          def flush = nil
+
           # Receives a multi-frame message.
           #
           # @return [Array<String>]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Patrik Wenger