perf: reduce memory allocations for string and array (#125)

Author: supercaracal

docs/class_diagrams_redis_client.md

@@ -19,8 +19,11 @@ classDiagram
     +write_timeout=()
     +pubsub()
     +call()
+    +call_v()
     +call_once()
+    +call_once_v()
     +blocking_call()
+    +blocking_call_v()
     +scan()
     +sscan()
     +hscan()
@@ -46,19 +49,23 @@ classDiagram
   class RedisClient_PubSub {
     +initialize()
     +call()
+    +call_v()
     +close()
     +next_event()
   }
 
   class RedisClient_Multi {
     +initialize()
     +call()
+    +call_v()
     +call_once()
+    +call_once_v()
   }
 
   class RedisClient_Pipeline {
     +initialize()
     +blocking_call()
+    +blocking_call_v()
   }
 
   class RedisClient_RubyConnection_BufferedIO {

docs/class_diagrams_redis_cluster_client.md

@@ -99,14 +99,18 @@ classDiagram
 
   class RedisClient_Cluster_Pipeline {
     +call()
+    +call_v()
     +call_once()
+    +call_once_v()
     +blocking_call()
+    +blocking_call_v()
     +empty?()
     +execute()
   }
 
   class RedisClient_Cluster_PubSub {
     +call()
+    +call_v()
     +close()
     +next_event()
   }

lib/redis_client/cluster/command.rb

@@ -6,6 +6,8 @@
 class RedisClient
   class Cluster
     class Command
+      EMPTY_STRING = ''
+
       class << self
         def load(nodes) # rubocop:disable Metrics/MethodLength
           errors = []
@@ -36,11 +38,12 @@ def parse_command_details(rows)
 
       def initialize(details)
         @details = pick_details(details)
+        @normalized_cmd_name_cache = {}
       end
 
       def extract_first_key(command)
         i = determine_first_key_position(command)
-        return '' if i == 0
+        return EMPTY_STRING if i == 0
 
         key = (command[i].is_a?(Array) ? command[i].flatten.first : command[i]).to_s
         hash_tag = extract_hash_tag(key)
@@ -72,14 +75,14 @@ def pick_details(details)
       end
 
       def dig_details(command, key)
-        name = command&.flatten&.first.to_s.downcase # OPTIMIZE: prevent allocation for string
+        name = normalize_cmd_name(command)
         return if name.empty? || !@details.key?(name)
 
         @details.fetch(name).fetch(key)
       end
 
       def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
-        case command&.flatten&.first.to_s.downcase # OPTIMIZE: prevent allocation for string
+        case normalize_cmd_name(command)
         when 'eval', 'evalsha', 'zinterstore', 'zunionstore' then 3
         when 'object' then 2
         when 'memory'
@@ -104,10 +107,23 @@ def extract_hash_tag(key)
         s = key.index('{')
         e = key.index('}', s.to_i + 1)
 
-        return '' if s.nil? || e.nil?
+        return EMPTY_STRING if s.nil? || e.nil?
 
         key[s + 1..e - 1]
       end
+
+      def normalize_cmd_name(command)
+        return EMPTY_STRING unless command.is_a?(Array)
+
+        name = case e = command.first
+               when String then e
+               when Array then e.first
+               end
+        return EMPTY_STRING if name.nil? || name.empty?
+
+        @normalized_cmd_name_cache[name] = name.downcase unless @normalized_cmd_name_cache.key?(name)
+        @normalized_cmd_name_cache[name]
+      end
     end
   end
 end

lib/redis_client/cluster/pipeline.rb

@@ -66,8 +66,11 @@ def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Met
             Thread.new(@router, k, v) do |router, node_key, rows|
               Thread.pass
               replies = router.find_node(node_key).pipelined do |pipeline|
-                rows.each do |(_size, *row, block)|
-                  pipeline.send(*row, &block)
+                rows.each do |row|
+                  case row.size
+                  when 4 then pipeline.send(row[1], row[2], &row[3])
+                  when 5 then pipeline.send(row[1], row[2], row[3], &row[4])
+                  end
                 end
               end
 

test/prof_mem.rb

@@ -18,8 +18,8 @@ def run
 
       profile do
         send("new_#{cli_type}_client".to_sym).pipelined do |pi|
-          ATTEMPT_COUNT.times { |i| pi.call('SET', "key#{i}", i) }
-          ATTEMPT_COUNT.times { |i| pi.call('GET', "key#{i}") }
+          ATTEMPT_COUNT.times { |i| pi.call('SET', i, i) }
+          ATTEMPT_COUNT.times { |i| pi.call('GET', i) }
         end
       end
     end