dalli 5.0.4 → 5.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b211a810c4d54d2d4d92203b390e8b29260f725e6dae699ca04703ac42cef8e9
-  data.tar.gz: 4d765c4491412ad4b9c8ab6038232436cae5824db2abaffc20119f2dfb7fa1ee
+  metadata.gz: 5c110d569b03993cefe140fdc4b54fb5720ef407e15c0fe100e4a49f90b5ce36
+  data.tar.gz: 8a3967c3d9d82dd3a28172fdb06e7f235a8ebb6598fd742e04770b458d24d041
 SHA512:
-  metadata.gz: a09168f456e5ce4691d0e24b128997c3f87bee7e046592a600490bc8e9526d1ce681d156fc9997c7045e623017ee0df1273d46c16656820b0f4933b8acc42cbb
-  data.tar.gz: 14e72c85d60582e03b19f04b4fd822a2e789fc6f780ae3f55944271dc25f0eeb7d6de0acade39bedf4729710731d273f8501f2078dc690fa3093926041b8d178
+  metadata.gz: 486715371411ddcf9118f87296abaaf7a30597a340bba41f26d26a750268d85751fef62be52f332662d427fa79e0ed3ea9bf0e503747203f5039194875a878de
+  data.tar.gz: d1bdf88817ba281d7b88525b1e0579c6efefdd68cb1b437dbbc0cf4fa2f386a6d9612e579cbfc409b1c1458a05ee5b4c7af841599e1930433912a909550b84f1

data/CHANGELOG.md

@@ -4,6 +4,28 @@ Dalli Changelog
 Unreleased
 ==========
 
+5.0.5
+==========
+
+Performance:
+
+- Batch multi-key commands into a single write to reduce packet overhead (#1107)
+  - With `TCP_NODELAY` set on sockets, each `write` call emits a separate packet; the meta protocol was calling `write` up to 3 times per key in multi-key operations (`get_multi`, `set_multi`, `delete_multi`), significantly increasing network traffic compared to the old binary protocol
+  - Multi-key request paths now buffer all per-key commands into a single binary string and flush once; single-key paths combine the write and flush into one `flushed_write` call
+  - Thanks to Jean Boussier for this contribution
+
+- Avoid repeated `RUBY_ENGINE` checks on every socket read (#1103)
+  - Moved the JRuby branch from a runtime `if` inside `ConnectionManager#read` to a class-level conditional method definition, so the check happens once at load time rather than on every read call
+  - Thanks to Jean Boussier for this contribution
+
+- Eliminate per-call array allocations in `ResponseProcessor` (#1104)
+  - Token sets passed to `error_on_unexpected!` (e.g. `[VA, EN, HD]`) were allocated as new arrays on every invocation; replaced with frozen constants defined once at class load time
+  - Thanks to Jean Boussier for this contribution
+
+- Avoid string copies when building request commands in `RequestFormatter` (#1106)
+  - Changed `cmd + TERMINATOR` to `cmd << TERMINATOR`; since `cmd` is always a mutable string, the in-place append avoids copying the entire command string just to append two bytes
+  - Thanks to Jean Boussier for this contribution
+
 5.0.4
 ==========
 

data/lib/dalli/protocol/base.rb

@@ -18,7 +18,7 @@ module Dalli
 
       def_delegators :@value_marshaller, :serializer, :compressor, :compression_min_size, :compress_by_default?
       def_delegators :@connection_manager, :name, :sock, :hostname, :port, :close, :connected?, :socket_timeout,
-                     :socket_type, :up!, :down!, :write, :reconnect_down_server?, :raise_down_error
+                     :socket_type, :up!, :down!, :write, :reconnect_down_server?, :raise_down_error, :flushed_write
 
       def initialize(attribs, client_options = {})
         hostname, port, socket_type, @weight, user_creds = ServerConfigParser.parse(attribs)

data/lib/dalli/protocol/connection_manager.rb

@@ -155,16 +155,20 @@ module Dalli
         error_on_request!(e)
       end
 
-      def read(count)
-        # JRuby doesn't support IO#timeout=, so use custom readfull implementation
-        # CRuby 3.3+ has IO#timeout= which makes IO#read work with timeouts
-        if RUBY_ENGINE == 'jruby'
+      # JRuby doesn't support IO#timeout=, so use custom readfull implementation
+      # CRuby 3.3+ has IO#timeout= which makes IO#read work with timeouts
+      if RUBY_ENGINE == 'jruby'
+        def read(count)
           @sock.readfull(count)
-        else
+        rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
+          error_on_request!(e)
+        end
+      else
+        def read(count)
           @sock.read(count)
+        rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
+          error_on_request!(e)
         end
-      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
-        error_on_request!(e)
       end
 
       def write(bytes)
@@ -179,6 +183,14 @@ module Dalli
         error_on_request!(e)
       end
 
+      def flushed_write(bytes)
+        written = @sock.write(bytes)
+        @sock.flush
+        written
+      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, IOError => e
+        error_on_request!(e)
+      end
+
       # Non-blocking read.  Here to support the operation
       # of the get_multi operation
       def read_nonblock

data/lib/dalli/protocol/meta.rb

@@ -28,8 +28,7 @@ module Dalli
         # Skip bitflags in raw mode - saves 2 bytes per request and skips parsing
         skip_flags = raw_mode? || (options && options[:raw])
         req = RequestFormatter.meta_get(key: encoded_key, base64: base64, skip_flags: skip_flags)
-        write(req)
-        @connection_manager.flush
+        flushed_write(req)
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
@@ -45,8 +44,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         skip_flags = raw_mode? || (options && options[:raw])
         req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64, skip_flags: skip_flags)
-        write(req)
-        @connection_manager.flush
+        flushed_write(req)
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
@@ -54,8 +52,7 @@ module Dalli
         ttl = TtlSanitizer.sanitize(ttl)
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, value: false, base64: base64)
-        write(req)
-        @connection_manager.flush
+        flushed_write(req)
         response_processor.meta_get_without_value
       end
 
@@ -64,8 +61,7 @@ module Dalli
       def cas(key)
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, value: true, return_cas: true, base64: base64)
-        write(req)
-        @connection_manager.flush
+        flushed_write(req)
         response_processor.meta_get_with_value_and_cas
       end
 
@@ -101,8 +97,7 @@ module Dalli
           return_hit_status: options[:return_hit_status],
           return_last_access: options[:return_last_access], skip_lru_bump: options[:skip_lru_bump]
         )
-        write(req)
-        @connection_manager.flush
+        flushed_write(req)
         response_processor.meta_get_with_metadata(
           cache_nils: cache_nils?(options), return_hit_status: options[:return_hit_status],
           return_last_access: options[:return_last_access]
@@ -119,8 +114,7 @@ module Dalli
       def delete_stale(key, cas = nil)
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_delete(key: encoded_key, cas: cas, base64: base64, stale: true)
-        write(req)
-        @connection_manager.flush
+        flushed_write(req)
         response_processor.meta_delete
       end
 
@@ -154,9 +148,7 @@ module Dalli
         req = RequestFormatter.meta_set(key: encoded_key, value: value,
                                         bitflags: bitflags, cas: cas,
                                         ttl: ttl, mode: mode, quiet: quiet, base64: base64)
-        write(req)
-        write(value)
-        write(TERMINATOR)
+        write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet
       end
       # rubocop:enable Metrics/ParameterLists
@@ -177,9 +169,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_set(key: encoded_key, value: value, base64: base64,
                                         cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
-        write(req)
-        write(value)
-        write(TERMINATOR)
+        write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet?
       end
       # rubocop:enable Metrics/ParameterLists
@@ -235,26 +225,22 @@ module Dalli
       end
 
       def stats(info = nil)
-        write(RequestFormatter.stats(info))
-        @connection_manager.flush
+        flushed_write(RequestFormatter.stats(info))
         response_processor.stats
       end
 
       def reset_stats
-        write(RequestFormatter.stats('reset'))
-        @connection_manager.flush
+        flushed_write(RequestFormatter.stats('reset'))
         response_processor.reset
       end
 
       def version
-        write(RequestFormatter.version)
-        @connection_manager.flush
+        flushed_write(RequestFormatter.version)
         response_processor.version
       end
 
       def write_noop
-        write(RequestFormatter.meta_noop)
-        @connection_manager.flush
+        flushed_write(RequestFormatter.meta_noop)
       end
 
       # Single-server fast path for get_multi. Inlines request formatting and
@@ -266,12 +252,18 @@ module Dalli
         # 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"
+        buffer = ''.b
         keys.each do |key|
           encoded_key, base64 = KeyRegularizer.encode(key)
-          write(base64 ? "mg #{encoded_key} b#{post_get}" : "mg #{encoded_key}#{post_get}")
+          if base64
+            buffer << 'mg ' << encoded_key << ' b' << post_get
+          else
+            buffer << 'mg ' << encoded_key << post_get
+          end
         end
-        write("mn\r\n")
-        @connection_manager.flush
+        buffer << 'mn' << TERMINATOR
+        flushed_write(buffer)
+        buffer.clear
 
         read_multi_get_responses(is_raw)
       end
@@ -300,36 +292,46 @@ module Dalli
         [key, @value_marshaller.retrieve(value, bitflags)]
       end
 
+      # rubocop:disable Metrics/AbcSize
+
       # 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
+        buffer = ''.b
         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)
+          buffer << "ms #{encoded_key} #{value.bytesize} c"
+          buffer << ' b' if base64
+          buffer << " F#{bitflags}" if bitflags
+          buffer << " T#{ttl}" if ttl
+          buffer << ' MS q' << TERMINATOR << value << TERMINATOR
         end
-        write_noop
+        buffer << RequestFormatter.meta_noop
+        flushed_write(buffer)
+        buffer.clear
         response_processor.consume_all_responses_until_mn
       end
+      # rubocop:enable Metrics/AbcSize
 
       # 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)
+        buffer = ''.b
         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")
+          if base64
+            buffer << 'md ' << encoded_key << ' b q' << TERMINATOR
+          else
+            buffer << 'md ' << encoded_key << ' q' << TERMINATOR
+          end
         end
-        write_noop
+        buffer << RequestFormatter.meta_noop
+        flushed_write(buffer)
+        buffer.clear
         response_processor.consume_all_responses_until_mn
       end
 

data/lib/dalli/protocol/request_formatter.rb

@@ -52,7 +52,7 @@ module Dalli
           cmd << ' h' if return_hit_status # Return hit status (0 or 1)
           cmd << ' l' if return_last_access # Return seconds since last access
           cmd << ' u' if skip_lru_bump # Don't bump LRU or update access stats
-          cmd + TERMINATOR
+          cmd << TERMINATOR
         end
 
         def self.meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, base64: false, quiet: false)
@@ -77,7 +77,7 @@ module Dalli
           cmd << " T#{ttl}" if ttl
           cmd << ' I' if stale # Mark stale instead of deleting
           cmd << ' q' if quiet
-          cmd + TERMINATOR
+          cmd << TERMINATOR
         end
 
         def self.meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, base64: false, quiet: false)
@@ -90,14 +90,15 @@ module Dalli
           cmd << cas_string(cas)
           cmd << ' q' if quiet
           cmd << " M#{incr ? 'I' : 'D'}"
-          cmd + TERMINATOR
+          cmd << TERMINATOR
         end
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/ParameterLists
         # rubocop:enable Metrics/PerceivedComplexity
 
+        META_NOOP = "mn#{TERMINATOR}".freeze
         def self.meta_noop
-          "mn#{TERMINATOR}"
+          META_NOOP
         end
 
         def self.version
@@ -108,7 +109,7 @@ module Dalli
           cmd = +'flush_all'
           cmd << " #{parse_to_64_bit_int(delay, 0)}" if delay
           cmd << ' noreply' if quiet
-          cmd + TERMINATOR
+          cmd << TERMINATOR
         end
 
         ALLOWED_STATS_ARGS = [nil, '', 'items', 'slabs', 'settings', 'reset'].freeze
@@ -118,7 +119,7 @@ module Dalli
 
           cmd = +'stats'
           cmd << " #{arg}" if arg && !arg.empty?
-          cmd + TERMINATOR
+          cmd << TERMINATOR
         end
 
         def self.mode_to_token(mode)

data/lib/dalli/protocol/response_processor.rb

@@ -23,13 +23,23 @@ module Dalli
         VERSION = 'VERSION'
         SERVER_ERROR = 'SERVER_ERROR'
 
+        T_OK = [OK].freeze
+        T_RESET = [RESET].freeze
+        T_EN_HD = [EN, HD].freeze
+        T_VERSION = [VERSION].freeze
+        T_VA_EN_HD = [VA, EN, HD].freeze
+        T_HD_NF_EX = [HD, NF, EX].freeze
+        T_HD_NS_NF_EX = [HD, NS, NF, EX].freeze
+        T_VA_NF_NS_EX = [VA, NF, NS, EX].freeze
+        T_END_TOKEN_STAT = [END_TOKEN, STAT].freeze
+
         def initialize(io_source, value_marshaller)
           @io_source = io_source
           @value_marshaller = value_marshaller
         end
 
         def meta_get_with_value(cache_nils: false)
-          tokens = error_on_unexpected!([VA, EN, HD])
+          tokens = error_on_unexpected!(T_VA_EN_HD)
           return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
           return true unless tokens.first == VA
 
@@ -37,7 +47,7 @@ module Dalli
         end
 
         def meta_get_with_value_and_cas
-          tokens = error_on_unexpected!([VA, EN, HD])
+          tokens = error_on_unexpected!(T_VA_EN_HD)
           return [nil, 0] if tokens.first == EN
 
           cas = cas_from_tokens(tokens)
@@ -47,7 +57,7 @@ module Dalli
         end
 
         def meta_get_without_value
-          tokens = error_on_unexpected!([EN, HD])
+          tokens = error_on_unexpected!(T_EN_HD)
           tokens.first == EN ? nil : true
         end
 
@@ -63,7 +73,7 @@ module Dalli
         # Used by meta_get for comprehensive metadata retrieval.
         # Supports thundering herd protection (N/R flags) and metadata flags (h/l/u).
         def meta_get_with_metadata(cache_nils: false, return_hit_status: false, return_last_access: false)
-          tokens = error_on_unexpected!([VA, EN, HD])
+          tokens = error_on_unexpected!(T_VA_EN_HD)
           result = build_metadata_result(tokens)
           result[:hit_before] = hit_status_from_tokens(tokens) if return_hit_status
           result[:last_access] = last_access_from_tokens(tokens) if return_last_access
@@ -87,26 +97,26 @@ module Dalli
         end
 
         def meta_set_with_cas
-          tokens = error_on_unexpected!([HD, NS, NF, EX])
+          tokens = error_on_unexpected!(T_HD_NS_NF_EX)
           return false unless tokens.first == HD
 
           cas_from_tokens(tokens)
         end
 
         def meta_set_append_prepend
-          tokens = error_on_unexpected!([HD, NS, NF, EX])
+          tokens = error_on_unexpected!(T_HD_NS_NF_EX)
           return false unless tokens.first == HD
 
           true
         end
 
         def meta_delete
-          tokens = error_on_unexpected!([HD, NF, EX])
+          tokens = error_on_unexpected!(T_HD_NF_EX)
           tokens.first == HD
         end
 
         def decr_incr
-          tokens = error_on_unexpected!([VA, NF, NS, EX])
+          tokens = error_on_unexpected!(T_VA_NF_NS_EX)
           return false if [NS, EX].include?(tokens.first)
           return nil if tokens.first == NF
 
@@ -114,7 +124,7 @@ module Dalli
         end
 
         def stats
-          tokens = error_on_unexpected!([END_TOKEN, STAT])
+          tokens = error_on_unexpected!(T_END_TOKEN_STAT)
           values = {}
           while tokens.first != END_TOKEN
             values[tokens[1]] = tokens[2]
@@ -124,19 +134,19 @@ module Dalli
         end
 
         def flush
-          error_on_unexpected!([OK])
+          error_on_unexpected!(T_OK)
 
           true
         end
 
         def reset
-          error_on_unexpected!([RESET])
+          error_on_unexpected!(T_RESET)
 
           true
         end
 
         def version
-          tokens = error_on_unexpected!([VERSION])
+          tokens = error_on_unexpected!(T_VERSION)
           tokens.last
         end
 

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.0.4'
+  VERSION = '5.0.5'
 
   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.4
+  version: 5.0.5
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -88,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.12
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []