dalli 5.0.1 → 5.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02d0fa949b7a065f86fb3ac7b511a3feacc50b700e82dcb385e0e79c56583a9d
-  data.tar.gz: d72b9e4b014ae1ae0b0d5a1ebe09ea48cdf9fbf0a2cda000efc19f17d5d34368
+  metadata.gz: ae3cbae2603955279bb78b75682ac1f56105d5ec2b2e0d464ab15255ed23369b
+  data.tar.gz: 2e5a3960e638293cfdf5663ef959d1ab9690620e09f0151a844cdeb9424cbf80
 SHA512:
-  metadata.gz: bf26484aa345df2d43a78da570027b68a7fd0dd70d7a62275ebe95a5e29ed36c11a8b1385ff0c71818f55184245e085cd75962510f9f8559aad10b0d284f8d71
-  data.tar.gz: 0b3913a33f61873d6e3da0d62ec643dbf49f679740d3469b7cb826083f02f3b32d37e2a20548634d09cecdc4389da7c5bdc43af530bb48956cb4084f91f10d9e
+  metadata.gz: 243382482bc345bf982f2cb96fae28b974f37b2eee653a71c7f3a85518ef5acdbfda6f2fddacfa31da6252774000e11a1c96d3707d29808c636951d85ace17be
+  data.tar.gz: 5938608c26cd307e397cad4fdf6e2fda4519fdbd8df2b7d75352b691996fec4dca59632cc0053b8bf410612c8e6cada73ccad7baf5c000a183bd04bb196d056e

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 Dalli Changelog
 =====================
 
+5.0.2
+==========
+
+Performance:
+
+- Add single-server fast path for `get_multi`, `set_multi`, and `delete_multi` (#1077)
+  - When only one memcached server is configured, bypass the `Pipelined*` machinery (IO.select, response buffering, server grouping) and issue all quiet meta requests inline followed by a noop terminator
+  - `get_multi` shows ~1.5x improvement at 10 keys and ~1.75x at 100–500 keys compared to the `PipelinedGetter` path
+  - Thanks to Dan Mayer (Shopify) for this contribution
+
+Development:
+
+- Add `bin/benchmark_branch` script for benchmarking against the current branch
+
 5.0.1
 ==========
 

data/lib/dalli/client.rb

@@ -311,7 +311,11 @@ module Dalli
       return if hash.empty?
 
       Instrumentation.trace('set_multi', multi_trace_attrs('set_multi', hash.size, hash.keys)) do
-        pipelined_setter.process(hash, ttl_or_default(ttl), req_options)
+        if ring.servers.size == 1
+          single_server_set_multi(hash, ttl_or_default(ttl), req_options)
+        else
+          pipelined_setter.process(hash, ttl_or_default(ttl), req_options)
+        end
       end
     end
 
@@ -368,7 +372,11 @@ module Dalli
       return if keys.empty?
 
       Instrumentation.trace('delete_multi', multi_trace_attrs('delete_multi', keys.size, keys)) do
-        pipelined_deleter.process(keys)
+        if ring.servers.size == 1
+          single_server_delete_multi(keys)
+        else
+          pipelined_deleter.process(keys)
+        end
       end
     end
 
@@ -522,13 +530,52 @@ module Dalli
 
     def get_multi_hash(keys)
       Instrumentation.trace_with_result('get_multi', get_multi_attributes(keys)) do |span|
-        {}.tap do |hash|
-          pipelined_getter.process(keys) { |k, data| hash[k] = data.first }
-          record_hit_miss_metrics(span, keys.size, hash.size)
-        end
+        hash = if ring.servers.size == 1
+                 single_server_get_multi(keys)
+               else
+                 {}.tap do |h|
+                   pipelined_getter.process(keys) { |k, data| h[k] = data.first }
+                 end
+               end
+        record_hit_miss_metrics(span, keys.size, hash.size)
+        hash
       end
     end
 
+    def single_server
+      server = ring.servers.first
+      server if server&.alive?
+    end
+
+    def single_server_get_multi(keys)
+      keys.map! { |k| @key_manager.validate_key(k.to_s) }
+      return {} unless (server = single_server)
+
+      result = server.request(:read_multi_req, keys)
+      result.transform_keys! { |k| @key_manager.key_without_namespace(k) }
+      result
+    rescue Dalli::NetworkError
+      {}
+    end
+
+    def single_server_set_multi(hash, ttl, req_options)
+      pairs = hash.transform_keys { |k| @key_manager.validate_key(k.to_s) }
+      return unless (server = single_server)
+
+      server.request(:write_multi_req, pairs, ttl, req_options)
+    rescue Dalli::NetworkError
+      nil
+    end
+
+    def single_server_delete_multi(keys)
+      validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
+      return unless (server = single_server)
+
+      server.request(:delete_multi_req, validated_keys)
+    rescue Dalli::NetworkError
+      nil
+    end
+
     def get_multi_attributes(keys)
       multi_trace_attrs('get_multi', keys.size, keys)
     end

data/lib/dalli/protocol/meta.rb

@@ -257,6 +257,82 @@ module Dalli
         @connection_manager.flush
       end
 
+      # Single-server fast path for get_multi. Inlines request formatting and
+      # response parsing to minimize per-key overhead. Avoids the PipelinedGetter
+      # machinery (IO.select, response buffering, server grouping).
+      def read_multi_req(keys)
+        is_raw = raw_mode?
+        # Inline request formatting — avoids RequestFormatter.meta_get overhead per key.
+        # In raw mode: "mg <key> v k q s\r\n" (no f flag, key at index 2)
+        # Normal mode: "mg <key> v f k q s\r\n" (key at index 3)
+        post_get = is_raw ? " v k q s\r\n" : " v f k q s\r\n"
+        keys.each do |key|
+          encoded_key, base64 = KeyRegularizer.encode(key)
+          write(base64 ? "mg #{encoded_key} b#{post_get}" : "mg #{encoded_key}#{post_get}")
+        end
+        write("mn\r\n")
+        @connection_manager.flush
+
+        read_multi_get_responses(is_raw)
+      end
+
+      def read_multi_get_responses(is_raw)
+        hash = {}
+        key_index = is_raw ? 2 : 3
+        while (line = @connection_manager.read_line)
+          break if line.start_with?('MN')
+          next unless line.start_with?('VA ')
+
+          key, value = parse_multi_get_value(line, key_index, is_raw)
+          hash[key] = value if key
+        end
+        hash
+      end
+
+      def parse_multi_get_value(line, key_index, is_raw)
+        tokens = line.chomp!(TERMINATOR).split
+        value = @connection_manager.read(tokens[1].to_i + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
+        raw_key = tokens[key_index]
+        return unless raw_key
+
+        key = KeyRegularizer.decode(raw_key[1..], tokens.include?('b'))
+        bitflags = is_raw ? 0 : response_processor.bitflags_from_tokens(tokens)
+        [key, @value_marshaller.retrieve(value, bitflags)]
+      end
+
+      # Single-server fast path for set_multi. Inlines request formatting to
+      # minimize per-key overhead. Avoids PipelinedSetter server grouping.
+      def write_multi_req(pairs, ttl, req_options)
+        ttl = TtlSanitizer.sanitize(ttl) if ttl
+        pairs.each do |key, raw_value|
+          (value, bitflags) = @value_marshaller.store(key, raw_value, req_options)
+          encoded_key, base64 = KeyRegularizer.encode(key)
+          # Inline format: "ms <key> <size> c [b] F<flags> T<ttl> MS q\r\n"
+          cmd = "ms #{encoded_key} #{value.bytesize} c"
+          cmd << ' b' if base64
+          cmd << " F#{bitflags}" if bitflags
+          cmd << " T#{ttl}" if ttl
+          cmd << " MS q\r\n"
+          write(cmd)
+          write(value)
+          write(TERMINATOR)
+        end
+        write_noop
+        response_processor.consume_all_responses_until_mn
+      end
+
+      # Single-server fast path for delete_multi. Writes all quiet delete requests
+      # terminated by a noop, then consumes all responses.
+      def delete_multi_req(keys)
+        keys.each do |key|
+          encoded_key, base64 = KeyRegularizer.encode(key)
+          # Inline format: "md <key> [b] q\r\n"
+          write(base64 ? "md #{encoded_key} b q\r\n" : "md #{encoded_key} q\r\n")
+        end
+        write_noop
+        response_processor.consume_all_responses_until_mn
+      end
+
       require_relative 'key_regularizer'
       require_relative 'request_formatter'
       require_relative 'response_processor'

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.0.1'
+  VERSION = '5.0.2'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.0.2
 platform: ruby
 authors:
 - Peter M. Goldstein