optimization around get for raw usage (#44)

* optimization around get for raw usage

* add tests ensuring the raw optimized code flow is used

* fix flaky test

Author: danmayer

lib/dalli/protocol/meta.rb

@@ -50,12 +50,18 @@ def write_multi_storage_req(_mode, pairs, ttl = nil, _cas = nil, options = {})
       end
 
       # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def read_multi_req(keys)
         # Pre-allocate the results hash with expected size
         results = SUPPORTS_CAPACITY ? Hash.new(nil, capacity: keys.size) : {}
+        optimized_for_raw = @value_marshaller.raw_by_default
+        key_index = optimized_for_raw ? 2 : 3
 
+        post_get_req = optimized_for_raw ? "v k q\r\n" : "v f k q\r\n"
         keys.each do |key|
-          @connection_manager.write("mg #{key} v f k q\r\n")
+          @connection_manager.write("mg #{key} #{post_get_req}")
         end
         @connection_manager.write("mn\r\n")
         @connection_manager.flush
@@ -68,25 +74,42 @@ def read_multi_req(keys)
           # VA value_length flags key
           tokens = line.split
           value = @connection_manager.read_exact(tokens[1].to_i)
+          bitflags = optimized_for_raw ? 0 : @response_processor.bitflags_from_tokens(tokens)
           @connection_manager.read_exact(terminator_length) # read the terminator
-          results[tokens[3].byteslice(1..-1)] =
-            @value_marshaller.retrieve(value, @response_processor.bitflags_from_tokens(tokens))
+          results[tokens[key_index].byteslice(1..-1)] =
+            @value_marshaller.retrieve(value, bitflags)
         end
         results
       end
       # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
 
       # Retrieval Commands
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def get(key, options = nil)
         encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_get(key: encoded_key, base64: base64, meta_flags: meta_flag_options(options))
-        write(req)
-        if meta_flag_options(options)
+        meta_options = meta_flag_options(options)
+
+        if !meta_options && !base64 && !quiet? && @value_marshaller.raw_by_default
+          write("mg #{encoded_key} v\r\n")
+        else
+          write(RequestFormatter.meta_get(key: encoded_key, base64: base64, meta_flags: meta_options))
+        end
+        if !meta_options && !base64 && !quiet? && @value_marshaller.raw_by_default
+          response_processor.meta_get_with_value(cache_nils: cache_nils?(options), skip_flags: true)
+        elsif meta_options
           response_processor.meta_get_with_value_and_meta_flags(cache_nils: cache_nils?(options))
         else
           response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
         end
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
 
       def quiet_get_request(key)
         encoded_key, base64 = KeyRegularizer.encode(key)

lib/dalli/protocol/meta/response_processor.rb

@@ -28,12 +28,16 @@ def initialize(io_source, value_marshaller)
           @value_marshaller = value_marshaller
         end
 
-        def meta_get_with_value(cache_nils: false)
+        def meta_get_with_value(cache_nils: false, skip_flags: false)
           tokens = error_on_unexpected!([VA, EN, HD])
           return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
           return true unless tokens.first == VA
 
-          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
+          if skip_flags
+            @value_marshaller.retrieve(read_data(tokens[1].to_i), 0)
+          else
+            @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
+          end
         end
 
         def meta_get_with_value_and_cas

lib/dalli/protocol/value_marshaller.rb

@@ -22,9 +22,12 @@ class ValueMarshaller
       def_delegators :@value_serializer, :serializer
       def_delegators :@value_compressor, :compressor, :compression_min_size, :compress_by_default?
 
+      attr_reader :raw_by_default
+
       def initialize(client_options)
         @value_serializer = ValueSerializer.new(client_options)
         @value_compressor = ValueCompressor.new(client_options)
+        @raw_by_default = client_options[:raw] || false
 
         @marshal_options =
           DEFAULTS.merge(client_options.slice(*OPTIONS))

test/integration/test_operations.rb

@@ -21,6 +21,20 @@
       end
     end
 
+    it 'returns the value on a hit when using raw single server optimized get' do
+      memcached_persistent do |_, port|
+        dc = Dalli::Client.new("localhost:#{port}", namespace: 'some:namspace', raw: true)
+        dc.close
+        dc.flush
+
+        val1 = '1234567890' * 50
+        dc.set('a', val1)
+        val2 = dc.get('a')
+
+        assert_equal val1, val2
+      end
+    end
+
     it 'return the value that include TERMINATOR on a hit' do
       memcached_persistent do |dc|
         dc.flush
@@ -46,14 +60,14 @@
 
         assert_equal val1, val2
         # not yet hit, and last accessed 0 from set
-        assert_equal({ c: 0, l: 0, h: false, t: -1, bitflag: nil }, meta_flags)
+        assert_equal({ c: 0, l: 0, h: false, t: -1, bitflag: nil }.sort, meta_flags.sort)
 
         sleep 1 # we can't simulate time in memcached so we need to sleep
         # ensure hit true and last accessed 1
         val2, meta_flags = dc.get('meta_key', meta_flags: %i[l h t])
 
         assert_equal val1, val2
-        assert_equal({ c: 0, l: 1, h: true, t: -1, bitflag: nil }, meta_flags)
+        assert_equal({ c: 0, l: 1, h: true, t: -1, bitflag: nil }.sort, meta_flags.sort)
 
         assert op_addset_succeeds(dc.set('meta_key', nil))
         assert_nil dc.get('meta_key')

test/integration/test_pipelined_get.rb

@@ -75,6 +75,28 @@
     end
   end
 
+  it 'meta read_multi_req supports optimized raw get' do
+    memcached_persistent do |_, port|
+      dc = Dalli::Client.new("localhost:#{port}", namespace: 'some:namspace', raw: true)
+      dc.close
+      dc.flush
+
+      keys_to_query = %w[a b]
+
+      resp = dc.get_multi(keys_to_query)
+
+      assert_empty(resp)
+
+      dc.set('a', 'foo')
+      dc.set('b', 'bar')
+
+      resp = dc.get_multi(keys_to_query)
+      expected_resp = { 'a' => 'foo', 'b' => 'bar' }
+
+      assert_equal(expected_resp, resp)
+    end
+  end
+
   it 'meta read_multi_req supports pipelined get doesnt default value on misses' do
     memcached_persistent do |_, port|
       dc = Dalli::Client.new("localhost:#{port}", namespace: 'some:namspace')