From: "ko1 (Koichi Sasada) via ruby-core" <ruby-core@...>
Date: 2026-09-09T20:08:44+00:00
Subject: [ruby-core:126618] [Ruby Feature#21869] Add receive_all Method to Ractor API for Message Batching

Issue #21869 has been updated by ko1 (Koichi Sasada).


Sorry for late response.

Could you rebase it to the current master, and could you show some benchmark example we can understand it should be merged?
Now we are not sure it is valuable to introduce or not.

Or I can take over this proposal (and ask Claude code).

BTW

> Reduced context���switching overhead.

doesn't make sense nowadays because `a << o while o = Ractor.receive(timeout:0))` can emulate it and no context switch now.


----------------------------------------
Feature #21869: Add receive_all Method to Ractor API for Message Batching
https://bugs.ruby-lang.org/issues/21869#change-118857

* Author: synacker (Mikhail Milovidov)
* Status: Open
* Assignee: ractor
----------------------------------------
**Summary**
The Ractor API provides an excellent mechanism for inter���thread communication, but it currently lacks a built���in message batching technique. I propose adding a receive_all method to enable batch processing of messages, which can significantly improve performance in high���load scenarios.

**Motivation**
In distributed queued systems, processing messages one���by���one (as with the current receive method) can introduce unnecessary overhead. Batch processing allows:

Reduced context���switching overhead.

More efficient I/O operations (e.g., fewer file writes).

Better throughput in high���concurrency environments.

**Proposed Solution** 
Add a receive_all method to the Ractor API that:

Returns all available messages in the Ractor���s mailbox at once (as an array).

**Demonstration Code** 
Below is a benchmark comparing individual receive vs. batch receive_all:

``` ruby
require 'benchmark'
class RactorsTest

  def initialize(count)
    @count = count
    @ractor1 = Ractor.new(count, 'output1.txt') do |count, filename|
      File.open(filename, 'w') do |file|
        while count.positive?
          message = receive
          file.write("Ractor 1 received message: #{message}\n")
          file.flush
          count -= 1
        end
      end
    end
    
    @ractor2 = Ractor.new(count, 'output2.txt') do |count, filename|
      File.open(filename, 'w') do |file|
        while count.positive?
          messages = receive_all
          messages.each do |message|
            file.write("Ractor 2 received message: #{message}\n")
          end
          count -= messages.length
          file.flush
        end
      end
    end
  end

  def run1
    @count.times do |i|
      @ractor1.send("Message #{i + 1}")
    end
    @ractor1.join
  end

  def run2
    @count.times do |i|
      @ractor2.send("Message #{i + 1}")
    end
    @ractor2.join
  end
end

records = 1_000_000

test = RactorsTest.new(records)

p [:once, Benchmark.realtime { test.run1 }.round(2)]
p [:all, Benchmark.realtime { test.run2 }.round(2)]
```

**Benchmark Results** 
On my system, receive_all shows ~4x improvement over individual receive:

**Key Observations:**
Ractor1 (using receive): Processes each message individually, resulting in frequent I/O calls.

Ractor2 (using receive_all): Processes all queued messages at once, minimizing I/O overhead



-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/