dalli 4.3.2 → 4.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eda4c85eb715e06ef3d8b34ea8e33a3cde89f19379a758f105363457451a034
-  data.tar.gz: 36ae8b603f8f778edbbf3bed9b7504ff1a440382bf5520423f49c39961f04a55
+  metadata.gz: 57b78e30ee409a2d742fc47ee57ccdd482fe9c75f369366ae315b7ef8b649934
+  data.tar.gz: b8cad66f3cba53bbcb84b18f406eed60f22209c10dd4a312063a1e13189185ca
 SHA512:
-  metadata.gz: b9a37ecfc73734a141979a34f2e155baa40cea5b22b016c192514c9d5847335d949ee642620c4508cc2ec8a2ceeb4dcec381715e633893623c42454975999d1a
-  data.tar.gz: 2a5f38c78c371e0710354a2b915a074512a87225f33fca95c9088ded76cad0dfc22e454fc9f64bddd40d8b0c0a6ab65bb108f467cd5b2b2c39d651285665f845
+  metadata.gz: 18b26e3c4aa30e5f8b4195d95307afca6c9240dd1154a36966d40d52047e638758850ec06e2a40fd1bd8e69fe150dee7409b1f4a565f0a80e397aaf115315463
+  data.tar.gz: b6db69ecbc1e6d34587d8ec29b861f6a71c863b36229d3c642e3d0e646ba6234e3bac04225d64ff174d12f35b728663e82e1d2b5f7e93dc9ac3e1ff33fd58db3

data/CHANGELOG.md

@@ -1,6 +1,22 @@
 Dalli Changelog
 =====================
 
+4.3.3
+==========
+
+Performance:
+
+- Reduce object allocations in pipelined get response processing (#1072)
+  - Offset-based `ResponseBuffer`: track a read offset instead of slicing a new string after every parsed response; compact only when the consumed portion exceeds 4KB and more than half the buffer
+  - Inline response processor parsing: avoid intermediate array allocations from `split`-based header parsing in both binary and meta protocols
+  - Block-based `pipeline_next_responses`: yield `(key, value, cas)` directly when a block is given, avoiding per-call Hash allocation
+  - `PipelinedGetter`: replace Hash-based socket-to-server mapping with linear scan (faster for typical 1-5 server counts); use `Process.clock_gettime(CLOCK_MONOTONIC)` instead of `Time.now`
+- Add cross-version benchmark script (`bin/compare_versions`) for reproducible performance comparisons across Dalli versions
+
+Bug Fixes:
+
+- Skip OTel integration tests when meta protocol is unavailable (#1072)
+
 4.3.2
 ==========
 

data/lib/dalli/pipelined_getter.rb

@@ -29,7 +29,7 @@ module Dalli
         # Stores partial results collected during interleaved send phase
         @partial_results = {}
         servers = setup_requests(keys)
-        start_time = Time.now
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
         # First yield any partial results collected during interleaved send
         yield_partial_results(&block)
@@ -149,7 +149,7 @@ module Dalli
     end
 
     def remaining_time(start, timeout)
-      elapsed = Time.now - start
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
       return 0 if elapsed > timeout
 
       timeout - elapsed
@@ -168,8 +168,8 @@ module Dalli
     # Processes responses from a server.  Returns true if there are no
     # additional responses from this server.
     def process_server(server)
-      server.pipeline_next_responses.each_pair do |key, value_list|
-        yield @key_manager.key_without_namespace(key), value_list
+      server.pipeline_next_responses do |key, value, cas|
+        yield @key_manager.key_without_namespace(key), [value, cas]
       end
 
       server.pipeline_complete?
@@ -178,18 +178,13 @@ module Dalli
     def servers_with_response(servers, timeout)
       return [] if servers.empty?
 
-      # TODO: - This is a bit challenging.  Essentially the PipelinedGetter
-      # is a reactor, but without the benefit of a Fiber or separate thread.
-      # My suspicion is that we may want to try and push this down into the
-      # individual servers, but I'm not sure.  For now, we keep the
-      # mapping between the alerted object (the socket) and the
-      # corrresponding server here.
-      server_map = servers.each_with_object({}) { |s, h| h[s.sock] = s }
-
-      readable, = IO.select(server_map.keys, nil, nil, timeout)
+      sockets = servers.map(&:sock)
+      readable, = IO.select(sockets, nil, nil, timeout)
       return [] if readable.nil?
 
-      readable.map { |sock| server_map[sock] }
+      # For typical server counts (1-5), linear scan is faster than
+      # building and looking up a hash map
+      readable.filter_map { |sock| servers.find { |s| s.sock == sock } }
     end
 
     def groups_for_keys(*keys)

data/lib/dalli/protocol/base.rb

@@ -91,10 +91,13 @@ module Dalli
       # repeatedly whenever this server's socket is readable until
       # #pipeline_complete?.
       #
-      # Returns a Hash of kv pairs received.
-      def pipeline_next_responses
+      # When a block is given, yields (key, value, cas) for each response,
+      # avoiding intermediate Hash allocation. Returns nil.
+      # Without a block, returns a Hash of { key => [value, cas] }.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def pipeline_next_responses(&block)
         reconnect_on_pipeline_complete!
-        values = {}
+        values = nil
 
         response_buffer.read
 
@@ -108,16 +111,24 @@ module Dalli
 
           # If the status is ok and the key is not nil, then this is a
           # getkq response with a value that we want to set in the response hash
-          values[key] = [value, cas] unless key.nil?
+          unless key.nil?
+            if block
+              yield key, value, cas
+            else
+              values ||= {}
+              values[key] = [value, cas]
+            end
+          end
 
           # Get the next response from the buffer
           status, cas, key, value = response_buffer.process_single_getk_response
         end
 
-        values
+        values || {}
       rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
         @connection_manager.error_on_request!(e)
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       # Abort current pipelined get. Generally used to signal an external
       # timeout during pipelined get.  The underlying socket is

data/lib/dalli/protocol/binary/response_processor.rb

@@ -189,16 +189,6 @@ module Dalli
           [resp_header.status, content]
         end
 
-        def contains_header?(buf)
-          return false unless buf
-
-          buf.bytesize >= ResponseHeader::SIZE
-        end
-
-        def response_header_from_buffer(buf)
-          ResponseHeader.new(buf)
-        end
-
         ##
         # This method returns an array of values used in a pipelined
         # getk process.  The first value is the number of bytes by
@@ -209,11 +199,11 @@ module Dalli
         # The remaining three values in the array are the ResponseHeader,
         # key, and value.
         ##
-        def getk_response_from_buffer(buf)
+        def getk_response_from_buffer(buf, offset = 0)
           # There's no header in the buffer, so don't advance
-          return [0, nil, nil, nil, nil] unless contains_header?(buf)
+          return [0, nil, nil, nil, nil] unless buf && buf.bytesize >= offset + ResponseHeader::SIZE
 
-          resp_header = response_header_from_buffer(buf)
+          resp_header = ResponseHeader.new(buf.byteslice(offset, ResponseHeader::SIZE))
           body_len = resp_header.body_len
 
           # We have a complete response that has no body.
@@ -225,11 +215,11 @@ module Dalli
           resp_size = ResponseHeader::SIZE + body_len
           # The header is in the buffer, but the body is not.  As we don't have
           # a complete response, don't advance the buffer
-          return [0, nil, nil, nil, nil] unless buf.bytesize >= resp_size
+          return [0, nil, nil, nil, nil] unless buf.bytesize >= offset + resp_size
 
           # The full response is in our buffer, so parse it and return
           # the values
-          body = buf.byteslice(ResponseHeader::SIZE, body_len)
+          body = buf.byteslice(offset + ResponseHeader::SIZE, body_len)
           key, value = unpack_response_body(resp_header, body, true)
           [resp_size, resp_header.ok?, resp_header.cas, key, value]
         end

data/lib/dalli/protocol/meta/response_processor.rb

@@ -147,14 +147,6 @@ module Dalli
           true
         end
 
-        def tokens_from_header_buffer(buf)
-          header = header_from_buffer(buf)
-          tokens = header.split
-          header_len = header.bytesize + TERMINATOR.length
-          body_len = body_len_from_tokens(tokens)
-          [tokens, header_len, body_len]
-        end
-
         def full_response_from_buffer(tokens, body, resp_size)
           value = @value_marshaller.retrieve(body, bitflags_from_tokens(tokens))
           [resp_size, tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value]
@@ -170,11 +162,15 @@ module Dalli
         # The remaining three values in the array are the ResponseHeader,
         # key, and value.
         ##
-        def getk_response_from_buffer(buf)
-          # There's no header in the buffer, so don't advance
-          return [0, nil, nil, nil, nil] unless contains_header?(buf)
+        def getk_response_from_buffer(buf, offset = 0)
+          # Find the header terminator starting from offset
+          term_idx = buf.index(TERMINATOR, offset)
+          return [0, nil, nil, nil, nil] unless term_idx
 
-          tokens, header_len, body_len = tokens_from_header_buffer(buf)
+          header = buf.byteslice(offset, term_idx - offset)
+          tokens = header.split
+          header_len = header.bytesize + TERMINATOR.length
+          body_len = body_len_from_tokens(tokens)
 
           # We have a complete response that has no body.
           # This is either the response to the terminating
@@ -185,22 +181,14 @@ module Dalli
           resp_size = header_len + body_len + TERMINATOR.length
           # The header is in the buffer, but the body is not.  As we don't have
           # a complete response, don't advance the buffer
-          return [0, nil, nil, nil, nil] unless buf.bytesize >= resp_size
+          return [0, nil, nil, nil, nil] unless buf.bytesize >= offset + resp_size
 
           # The full response is in our buffer, so parse it and return
           # the values
-          body = buf.slice(header_len, body_len)
+          body = buf.byteslice(offset + header_len, body_len)
           full_response_from_buffer(tokens, body, resp_size)
         end
 
-        def contains_header?(buf)
-          buf.include?(TERMINATOR)
-        end
-
-        def header_from_buffer(buf)
-          buf.split(TERMINATOR, 2).first
-        end
-
         def error_on_unexpected!(expected_codes)
           tokens = next_line_to_tokens
 

data/lib/dalli/protocol/response_buffer.rb

@@ -7,38 +7,39 @@ module Dalli
   module Protocol
     ##
     # Manages the buffer for responses from memcached.
+    # Uses an offset-based approach to avoid string allocations
+    # when advancing through parsed responses.
     ##
     class ResponseBuffer
+      # Compact the buffer when the consumed portion exceeds this
+      # threshold and represents more than half the buffer
+      COMPACT_THRESHOLD = 4096
+
       def initialize(io_source, response_processor)
         @io_source = io_source
         @response_processor = response_processor
         @buffer = nil
+        @offset = 0
       end
 
       def read
         @buffer << @io_source.read_nonblock
       end
 
-      # Attempts to process a single response from the buffer.  Starts
-      # by advancing the buffer to the specified start position
+      # Attempts to process a single response from the buffer,
+      # advancing the offset past the consumed bytes.
       def process_single_getk_response
-        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer)
-        advance(bytes)
+        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer, @offset)
+        @offset += bytes
+        compact_if_needed
         [status, cas, key, value]
       end
 
-      # Advances the internal response buffer by bytes_to_advance
-      # bytes.  The
-      def advance(bytes_to_advance)
-        return unless bytes_to_advance.positive?
-
-        @buffer = @buffer.byteslice(bytes_to_advance..-1)
-      end
-
       # Resets the internal buffer to an empty state,
       # so that we're ready to read pipelined responses
       def reset
         @buffer = ''.b
+        @offset = 0
       end
 
       # Ensures the buffer is initialized for reading without discarding
@@ -48,16 +49,30 @@ module Dalli
         return if in_progress?
 
         @buffer = ''.b
+        @offset = 0
       end
 
       # Clear the internal response buffer
       def clear
         @buffer = nil
+        @offset = 0
       end
 
       def in_progress?
         !@buffer.nil?
       end
+
+      private
+
+      # Only compact when we've consumed a significant portion of the buffer.
+      # This avoids per-response string allocation while preventing unbounded
+      # memory growth for large pipelines.
+      def compact_if_needed
+        return unless @offset > COMPACT_THRESHOLD && @offset > @buffer.bytesize / 2
+
+        @buffer = @buffer.byteslice(@offset..)
+        @offset = 0
+      end
     end
   end
 end

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '4.3.2'
+  VERSION = '4.3.3'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 4.3.2
+  version: 4.3.3
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -77,7 +77,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/petergoldstein/dalli/issues
-  changelog_uri: https://github.com/petergoldstein/dalli/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/petergoldstein/dalli/blob/v4.3/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: