chore: add some benchmarks for iteration per seconds (#266)

Author: supercaracal

.github/workflows/test.yaml

@@ -53,7 +53,7 @@ jobs:
       REDIS_CLIENT_MAX_STARTUP_SAMPLE: ${{ matrix.startup || '3' }}
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -80,7 +80,7 @@ jobs:
       DOCKER_COMPOSE_FILE: 'compose.nat.yaml'
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -135,7 +135,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -155,7 +155,7 @@ jobs:
       DELAY_TIME: '1ms'
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -195,6 +195,8 @@ jobs:
         run: df -h
       - name: Run minitest
         run: bundle exec rake bench | grep BenchCommand | grep -v 'Envoy#bench_pipeline_echo\|Envoy#bench_single_echo' | sort
+      - name: Run iteration per second
+        run: bundle exec rake ips
       - name: Reset qdisc
         run: |
           for i in {5..9..2}
@@ -219,7 +221,7 @@ jobs:
       DOCKER_COMPOSE_FILE: 'compose.yaml'
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -251,7 +253,7 @@ jobs:
       REDIS_CLIENT_MAX_STARTUP_SAMPLE: '5'
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

lib/redis_client/cluster/concurrent_worker.rb

@@ -20,7 +20,13 @@ def exec
           rescue StandardError => e
             self[:result] = e
           ensure
+            done
+          end
+
+          def done
             queue&.push(self)
+          rescue ClosedQueueError
+            # something was wrong
           end
         end
 
@@ -69,6 +75,10 @@ def create(model: :on_demand)
         else raise ArgumentError, "Unknown model: #{model}"
         end
       end
+
+      def size
+        MAX_WORKERS.positive? ? MAX_WORKERS : 5
+      end
     end
   end
 end

lib/redis_client/cluster/concurrent_worker/on_demand.rb

@@ -5,14 +5,10 @@ class Cluster
     module ConcurrentWorker
       class OnDemand
         def initialize
-          size = ::RedisClient::Cluster::ConcurrentWorker::MAX_WORKERS
-          size = size.positive? ? size : 5
-          @q = SizedQueue.new(size)
+          @q = SizedQueue.new(::RedisClient::Cluster::ConcurrentWorker.size)
         end
 
         def new_group(size:)
-          raise ArgumentError, "size must be positive: #{size} given" unless size.positive?
-
           ::RedisClient::Cluster::ConcurrentWorker::Group.new(worker: self, size: size)
         end
 

lib/redis_client/cluster/concurrent_worker/pooled.rb

@@ -15,8 +15,6 @@ def initialize
         end
 
         def new_group(size:)
-          raise ArgumentError, "size must be positive: #{size} given" unless size.positive?
-
           reset if @pid != ::RedisClient::PIDCache.pid
           ensure_workers if @workers.first.nil?
           ::RedisClient::Cluster::ConcurrentWorker::Group.new(worker: self, size: size)
@@ -37,30 +35,26 @@ def close
 
         private
 
-        def ensure_workers
-          @workers.size.times do |i|
-            @workers[i] = spawn_worker unless @workers[i]&.alive?
-          end
-        end
-
-        def spawn_worker
-          Thread.new(@q) do |q|
-            loop { q.pop.exec }
-          end
-        end
-
         def setup
           @q = Queue.new
-          size = ::RedisClient::Cluster::ConcurrentWorker::MAX_WORKERS
-          size = size.positive? ? size : 5
-          @workers = Array.new(size)
+          @workers = Array.new(::RedisClient::Cluster::ConcurrentWorker.size)
           @pid = ::RedisClient::PIDCache.pid
         end
 
         def reset
           close
           setup
         end
+
+        def ensure_workers
+          @workers.size.times do |i|
+            @workers[i] = spawn_worker unless @workers[i]&.alive?
+          end
+        end
+
+        def spawn_worker
+          Thread.new(@q) { |q| loop { q.pop.exec } }
+        end
       end
     end
   end

test/ips_pipeline.rb

@@ -4,16 +4,24 @@
 require 'redis_cluster_client'
 require 'testing_constants'
 
-module BenchPipeline
+module IpsPipeline
   module_function
 
   ATTEMPTS = 100
 
   def run
     on_demand = make_client(:on_demand)
     pooled = make_client(:pooled)
-    prepare(on_demand, pooled)
-    bench(on_demand, pooled)
+    envoy = make_client_for_envoy
+    cluster_proxy = make_client_for_cluster_proxy
+    prepare(on_demand, pooled, envoy, cluster_proxy)
+    print_letter('pipelined')
+    bench(
+      ondemand: on_demand,
+      pooled: pooled,
+      envoy: envoy,
+      cproxy: cluster_proxy
+    )
   end
 
   def make_client(model)
@@ -25,32 +33,53 @@ def make_client(model)
     ).new_client
   end
 
-  def prepare(on_demand, pooled)
-    on_demand.pipelined do |pi|
-      ATTEMPTS.times { |i| pi.call('SET', "key#{i}", "val#{i}") }
-    end
+  def make_client_for_envoy
+    ::RedisClient.config(
+      **TEST_GENERIC_OPTIONS.merge(BENCH_ENVOY_OPTIONS)
+    ).new_client
+  end
+
+  def make_client_for_cluster_proxy
+    ::RedisClient.config(
+      **TEST_GENERIC_OPTIONS.merge(BENCH_REDIS_CLUSTER_PROXY_OPTIONS)
+    ).new_client
+  end
 
-    pooled.pipelined do |pi|
-      ATTEMPTS.times { |i| pi.call('SET', "key#{i}", "val#{i}") }
+  def print_letter(title)
+    print "################################################################################\n"
+    print "# #{title}\n"
+    print "################################################################################\n"
+    print "\n"
+  end
+
+  def prepare(*clients)
+    clients.each do |client|
+      client.pipelined do |pi|
+        ATTEMPTS.times do |i|
+          pi.call('SET', "key#{i}", "val#{i}")
+        end
+      end
     end
   end
 
-  def bench(on_demand, pooled)
+  def bench(**kwargs)
     Benchmark.ips do |x|
       x.time = 5
       x.warmup = 1
 
-      x.report('on_demand') do
-        on_demand.pipelined { |pi| ATTEMPTS.times { |i| pi.call('GET', "key#{i}") } }
-      end
-
-      x.report('pooled') do
-        pooled.pipelined { |pi| ATTEMPTS.times { |i| pi.call('GET', "key#{i}") } }
+      kwargs.each do |key, client|
+        x.report("pipelined: #{key}") do
+          client.pipelined do |pi|
+            ATTEMPTS.times do |i|
+              pi.call('GET', "key#{i}")
+            end
+          end
+        end
       end
 
       x.compare!
     end
   end
 end
 
-BenchPipeline.run
+IpsPipeline.run

test/ips_single.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'redis_cluster_client'
+require 'testing_constants'
+
+module IpsSingle
+  module_function
+
+  ATTEMPTS = 10
+
+  def run
+    cli = make_client
+    envoy = make_client_for_envoy
+    cluster_proxy = make_client_for_cluster_proxy
+    prepare(cli, envoy, cluster_proxy)
+    print_letter('single')
+    bench(
+      cli: cli,
+      envoy: envoy,
+      cproxy: cluster_proxy
+    )
+  end
+
+  def make_client
+    ::RedisClient.cluster(
+      nodes: TEST_NODE_URIS,
+      fixed_hostname: TEST_FIXED_HOSTNAME,
+      **TEST_GENERIC_OPTIONS
+    ).new_client
+  end
+
+  def make_client_for_envoy
+    ::RedisClient.config(
+      **TEST_GENERIC_OPTIONS.merge(BENCH_ENVOY_OPTIONS)
+    ).new_client
+  end
+
+  def make_client_for_cluster_proxy
+    ::RedisClient.config(
+      **TEST_GENERIC_OPTIONS.merge(BENCH_REDIS_CLUSTER_PROXY_OPTIONS)
+    ).new_client
+  end
+
+  def print_letter(title)
+    print "################################################################################\n"
+    print "# #{title}\n"
+    print "################################################################################\n"
+    print "\n"
+  end
+
+  def prepare(*clients)
+    clients.each do |client|
+      ATTEMPTS.times do |i|
+        client.call('SET', "key#{i}", "val#{i}")
+      end
+    end
+  end
+
+  def bench(**kwargs)
+    Benchmark.ips do |x|
+      x.time = 5
+      x.warmup = 1
+
+      kwargs.each do |key, client|
+        x.report("single: #{key}") do
+          ATTEMPTS.times do |i|
+            client.call('GET', "key#{i}")
+          end
+        end
+      end
+
+      x.compare!
+    end
+  end
+end
+
+IpsSingle.run

test/redis_client/cluster/test_node.rb

@@ -60,7 +60,7 @@ def test_load_info
         [
           {
             params: { options: TEST_NODE_OPTIONS, kwargs: TEST_GENERIC_OPTIONS },
-            want: { size: TEST_NODE_OPTIONS.size }
+            want: { size: TEST_NUMBER_OF_NODES }
           },
           {
             params: { options: { '127.0.0.1:11211' => { host: '127.0.0.1', port: 11_211 } }, kwargs: TEST_GENERIC_OPTIONS },