KellyMahan-memcachedb-client 1.1.1 → 1.1.2

data/History.txt

@@ -1,3 +1,31 @@
+
+= 1.1.2
+
+merged changes from memcache-client VERSION = '1.6.5'
+
+* Change memcache-client to multithreaded by default.  The mutex does not add significant
+  overhead and it is far too easy, now that Sinatra, Rails and Merb are all thread-safe, to
+  use memcache-client in a thread-unsafe manner.  Remove some unnecessary mutexing and add
+  a test to verify heavily multithreaded usage does not act unexpectedly.
+
+
+* Add optional support for the SystemTimer gem when running on Ruby 1.8.x.  This gem is
+  highly recommended - it ensures timeouts actually work and halves the overhead of using
+  timeouts.  Using this gem, Ruby 1.8.x is actually faster in my performance tests
+  than Ruby 1.9.x.  Just "gem install SystemTimer" and it should be picked up automatically.
+
+= 1.6.4 (2009-02-19)
+
+* Remove native code altogether.  The speedup was only 10% on Ruby 1.8.6 and did not work
+  on Ruby 1.9.1.
+
+* Removed memcache_util.rb from the distribution.  If you are using it, please copy the code
+  into your own project.  The file will live in the github repository for a few more months
+  for this purposes. http://github.com/mperham/memcache-client/raw/7a276089aa3c914e47e3960f9740ac7377204970/lib/memcache_util.rb
+
+* Roll continuum.rb into memcache.rb.  The project is again a single Ruby file, with no dependencies.
+
+
 = 1.1.1
 
   merged changes from memcache-client 1.6.4

data/lib/memcache_db.rb

@@ -2,11 +2,27 @@ $TESTING = defined?($TESTING) && $TESTING
 
 require 'socket'
 require 'thread'
-require 'timeout'
 require 'zlib'
 require 'digest/sha1'
 
-require 'continuum_db'
+begin
+  # Try to use the SystemTimer gem instead of Ruby's timeout library
+  # when running on something that looks like Ruby 1.8.x.  See:
+  #   http://ph7spot.com/articles/system_timer
+  # We don't want to bother trying to load SystemTimer on jruby and
+  # ruby 1.9+.
+  if !defined?(RUBY_ENGINE)
+    require 'system_timer'
+    MemCacheTimerDb = SystemTimer
+  else
+    require 'timeout'
+    MemCacheTimerDb = Timeout
+  end
+rescue LoadError => e
+  puts "[memcache-client] Could not load SystemTimer gem, falling back to Ruby's slower/unsafe timeout library: #{e.message}"
+  require 'timeout'
+  MemCacheTimerDb = Timeout
+end
 
 ##
 # A Ruby client library for memcachedb.
@@ -14,17 +30,17 @@ require 'continuum_db'
 
 class MemCacheDb
 
-  ##
+
   # The version of MemCacheDb you are using.
 
-  VERSION = '1.1.1'
+  VERSION = '1.1.2'
   ##
   # Default options for the cache object.
 
   DEFAULT_OPTIONS = {
     :namespace   => nil,
     :readonly    => false,
-    :multithread => false,
+    :multithread => true,
     :failover    => true,
     :timeout     => 0.5,
     :logger      => nil,
@@ -56,7 +72,7 @@ class MemCacheDb
   attr_reader :servers
 
   ##
-  # Socket timeout limit with this client, defaults to 0.25 sec.
+  # Socket timeout limit with this client, defaults to 0.5 sec.
   # Set to nil to disable timeouts.
 
   attr_reader :timeout
@@ -80,12 +96,14 @@ class MemCacheDb
   #
   #   [:namespace]   Prepends this value to all keys added or retrieved.
   #   [:readonly]    Raises an exception on cache writes when true.
-  #   [:multithread] Wraps cache access in a Mutex for thread safety.
+  #   [:multithread] Wraps cache access in a Mutex for thread safety. Defaults to true.
   #   [:failover]    Should the client try to failover to another server if the
   #                  first server is down?  Defaults to true.
-  #   [:timeout]     Time to use as the socket read timeout.  Defaults to 0.25 sec,
-  #                  set to nil to disable timeouts (this is a major performance penalty in Ruby 1.8).
+  #   [:timeout]     Time to use as the socket read timeout.  Defaults to 0.5 sec,
+  #                  set to nil to disable timeouts (this is a major performance penalty in Ruby 1.8,
+  #                  "gem install SystemTimer' to remove most of the penalty).
   #   [:logger]      Logger to use for info/debug output, defaults to nil
+  #
   # Other options are ignored.
 
   def initialize(*args)
@@ -161,9 +179,6 @@ class MemCacheDb
         weight ||= DEFAULT_WEIGHT
         Server.new self, host, port, weight
       else
-        if server.multithread != @multithread then
-          raise ArgumentError, "can't mix threaded and non-threaded servers"
-        end
         server
       end
     end
@@ -221,6 +236,8 @@ class MemCacheDb
   #   cache["a"] = 1
   #   cache["b"] = 2
   #   cache.get_multi "a", "b" # => { "a" => 1, "b" => 2 }
+  #
+  # Note that get_multi assumes the values are marshalled.
 
 
   def get_range(key1, key2, limit=100)
@@ -377,7 +394,6 @@ class MemCacheDb
     raise MemCacheDbError, "Update of readonly cache" if @readonly
 
     begin
-      @mutex.lock if @multithread
       @servers.each do |server|
         with_socket_management(server) do |socket|
           socket.write "flush_all\r\n"
@@ -388,8 +404,6 @@ class MemCacheDb
       end
     rescue IndexError => err
       handle_error nil, err
-    ensure
-      @mutex.unlock if @multithread
     end
   end
 
@@ -522,7 +536,7 @@ class MemCacheDb
     hkey = hash_for(key)
 
     20.times do |try|
-      entryidx = Continuum.binary_search(@continuum, hkey)
+      entryidx = ContinuumDb.binary_search(@continuum, hkey)
       server = @continuum[entryidx].server
       return server if server.alive?
       break unless failover
@@ -708,7 +722,7 @@ class MemCacheDb
 
       block.call(socket)
 
-    rescue SocketError => err
+    rescue SocketError, Timeout::Error => err
       logger.warn { "Socket failure: #{err.message}" } if logger
       server.mark_dead(err)
       handle_error(server, err)
@@ -775,7 +789,7 @@ class MemCacheDb
       entry_count_for(server, servers.size, total_weight).times do |idx|
         hash = Digest::SHA1.hexdigest("#{server.host}:#{server.port}:#{idx}")
         value = Integer("0x#{hash[0..7]}")
-        continuum << Continuum::Entry.new(value, server)
+        continuum << ContinuumDb::Entry.new(value, server)
       end
     end
 
@@ -783,7 +797,7 @@ class MemCacheDb
   end
 
   def entry_count_for(server, total_servers, total_weight)
-    ((total_servers * Continuum::POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
+    ((total_servers * ContinuumDb::POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
   end
 
   def check_multithread_status!
@@ -841,7 +855,6 @@ class MemCacheDb
 
     attr_reader :status
 
-    attr_reader :multithread
     attr_reader :logger
 
     ##
@@ -856,9 +869,6 @@ class MemCacheDb
       @port   = port.to_i
       @weight = weight.to_i
 
-      @multithread = memcache.multithread
-      @mutex = Mutex.new
-
       @sock   = nil
       @retry  = nil
       @status = 'NOT CONNECTED'
@@ -888,7 +898,6 @@ class MemCacheDb
     # Returns the connected socket object on success or nil on failure.
 
     def socket
-      @mutex.lock if @multithread
       return @sock if @sock and not @sock.closed?
 
       @sock = nil
@@ -911,8 +920,6 @@ class MemCacheDb
       end
 
       return @sock
-    ensure
-      @mutex.unlock if @multithread
     end
 
     ##
@@ -920,13 +927,10 @@ class MemCacheDb
     # object.  The server is not considered dead.
 
     def close
-      @mutex.lock if @multithread
       @sock.close if @sock && !@sock.closed?
       @sock   = nil
       @retry  = nil
       @status = "NOT CONNECTED"
-    ensure
-      @mutex.unlock if @multithread
     end
 
     ##
@@ -955,26 +959,26 @@ end
 class TCPTimeoutSocket
   
   def initialize(host, port, timeout)
-    Timeout::timeout(MemCacheDb::Server::CONNECT_TIMEOUT, SocketError) do
+    MemCacheTimerDb.timeout(MemCacheDb::Server::CONNECT_TIMEOUT) do
       @sock = TCPSocket.new(host, port)
       @len = timeout
     end
   end
   
   def write(*args)
-    Timeout::timeout(@len, SocketError) do
+    MemCacheTimerDb.timeout(@len) do
       @sock.write(*args)
     end
   end
   
   def gets(*args)
-    Timeout::timeout(@len, SocketError) do
+    MemCacheTimerDb.timeout(@len) do
       @sock.gets(*args)
     end
   end
   
   def read(*args)
-    Timeout::timeout(@len, SocketError) do
+    MemCacheTimerDb.timeout(@len) do
       @sock.read(*args)
     end
   end
@@ -995,3 +999,42 @@ class TCPTimeoutSocket
     @sock.close
   end
 end
+
+module ContinuumDb
+  POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+  # Find the closest index in ContinuumDb with value <= the given value
+  def self.binary_search(ary, value, &block)
+    upper = ary.size - 1
+    lower = 0
+    idx = 0
+
+    while(lower <= upper) do
+      idx = (lower + upper) / 2
+      comp = ary[idx].value <=> value
+
+      if comp == 0
+        return idx
+      elsif comp > 0
+        upper = idx - 1
+      else
+        lower = idx + 1
+      end
+    end
+    return upper
+  end
+
+  class Entry
+    attr_reader :value
+    attr_reader :server
+
+    def initialize(val, srv)
+      @value = val
+      @server = srv
+    end
+
+    def inspect
+      "<#{value}, #{server.host}:#{server.port}>"
+    end
+  end
+end

data/test/test_mem_cache_db.rb

@@ -10,9 +10,10 @@ rescue LoadError => e
   puts "Some tests require flexmock, please run `gem install flexmock`"
 end
 
+Thread.abort_on_exception = true
 $TESTING = true
 
-require File.dirname(__FILE__) + '/../lib/memcache'
+require File.dirname(__FILE__) + '/../lib/memcache' if not defined?(MemCacheDb)
 
 class MemCacheDb
 
@@ -54,7 +55,7 @@ class Test::Unit::TestCase
   end
   
   def memcached_running?
-    TCPSocket.new('localhost', 11211) rescue false
+    TCPSocket.new('localhost', 21201) rescue false
   end
   
   def xprofile(name, &block)
@@ -79,15 +80,15 @@ end
 
 class FakeServerDb
 
-  attr_reader :host, :port, :socket, :weight, :multithread, :status
+  attr_accessor :host, :port, :socket, :weight, :multithread, :status
 
   def initialize(socket = nil)
     @closed = false
     @host = 'example.com'
-    @port = 11211
+    @port = 21201
     @socket = socket || FakeSocketDb.new
     @weight = 1
-    @multithread = false
+    @multithread = true
     @status = "CONNECTED"
   end
 
@@ -117,9 +118,9 @@ class TestMemCacheDb < Test::Unit::TestCase
 
   def test_performance
     requirement(memcached_running?, 'A real memcached server must be running for performance testing') do
-      host = Socket.gethostname
 
       cache = MemCacheDb.new(['localhost:21201',"#{host}:21201"])
+      cache.flush_all
       cache.add('a', 1, 120)
       with = xprofile 'get' do
         1000.times do
@@ -129,7 +130,7 @@ class TestMemCacheDb < Test::Unit::TestCase
       puts ''
       puts "1000 gets with socket timeout: #{with} sec"
 
-      cache = MemCacheDb.new(['localhost:21201',"#{host}:21201"], :timeout => nil)
+      cache = MemCacheDb.new(['localhost:21201',"127.0.0.1:21201"], :timeout => nil)
       cache.add('a', 1, 120)
       without = xprofile 'get' do
         1000.times do
@@ -335,8 +336,10 @@ class TestMemCacheDb < Test::Unit::TestCase
 
   def test_multithread_error
     server = FakeServer.new
+    server.multithread = false
+    
+    @cache = MemCacheDb.new(['localhost:1'], :multithread => false)
 
-    # Write two messages to the socket to test failover
     server.socket.data.write "bogus response\r\nbogus response\r\n"
     server.socket.data.rewind
 
@@ -887,7 +890,7 @@ class TestMemCacheDb < Test::Unit::TestCase
     socket.data.rewind
     server = FakeServerDb.new socket
     def server.host() 'localhost'; end
-    def server.port() 11211; end
+    def server.port() 21201; end
 
     @cache.servers = []
     @cache.servers << server
@@ -972,5 +975,37 @@ class TestMemCacheDb < Test::Unit::TestCase
     return server
   end
 
+  def test_crazy_multithreaded_access
+    requirement(memcached_running?, 'A real memcached server must be running for performance testing') do
+
+      cache = MemCacheDb.new(['localhost:21201', '127.0.0.1:21201'])
+      cache.flush_all
+      workers = []
+
+      # Have a bunch of threads perform a bunch of operations at the same time.
+      # Verify the result of each operation to ensure the request and response
+      # are not intermingled between threads.
+      10.times do
+        workers << Thread.new do
+          100.times do
+            cache.set('a', 9)
+            cache.set('b', 11)
+            cache.add('c', 10, 0, true)
+            assert_equal "NOT_STORED\r\n", cache.add('a', 11)
+            assert_equal({ 'a' => 9, 'b' => 11 }, cache.get_multi(['a', 'b']))
+            inc = cache.incr('c', 10)
+            assert_equal 0, inc % 5
+            assert inc > 14
+            assert cache.decr('c', 5) > 14
+            assert_equal 11, cache.get('b')
+          end
+        end
+      end
+
+      workers.each { |w| w.join }
+      cache.flush_all
+    end
+  end
+
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: KellyMahan-memcachedb-client
 version: !ruby/object:Gem::Version 
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors: 
 - Kelly Mahan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-13 00:00:00 -08:00
+date: 2009-02-25 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 

data/lib/continuum_db.rb

@@ -1,77 +0,0 @@
-module ContinuumDb
-  POINTS_PER_SERVER = 160 # this is the default in libmemcached
-
-  class << self
-
-    begin
-      require 'inline'
-      inline do |builder|
-        builder.c <<-EOM
-        int binary_search(VALUE ary, unsigned int r) {
-            int upper = RARRAY_LEN(ary) - 1;
-            int lower = 0;
-            int idx = 0;
-            ID value = rb_intern("value");
-
-            while (lower <= upper) {
-                idx = (lower + upper) / 2;
-
-                VALUE continuumValue = rb_funcall(RARRAY_PTR(ary)[idx], value, 0);
-                unsigned int l = NUM2UINT(continuumValue);
-                if (l == r) {
-                    return idx;
-                }
-                else if (l > r) {
-                    upper = idx - 1;
-                }
-                else {
-                    lower = idx + 1;
-                }
-            }
-            return upper;
-        }
-        EOM
-      end
-    rescue Exception => e
-      puts "Unable to generate native code, falling back to Ruby: #{e.message}"
-
-      # slow but pure ruby version
-      # Find the closest index in Continuum with value <= the given value
-      def binary_search(ary, value, &block)
-        upper = ary.size - 1
-        lower = 0
-        idx = 0
-
-        while(lower <= upper) do
-          idx = (lower + upper) / 2
-          comp = ary[idx].value <=> value
-
-          if comp == 0
-            return idx
-          elsif comp > 0
-            upper = idx - 1
-          else
-            lower = idx + 1
-          end
-        end
-        return upper
-      end
-
-    end
-  end
-
-
-  class Entry
-    attr_reader :value
-    attr_reader :server
-
-    def initialize(val, srv)
-      @value = val
-      @server = srv
-    end
-
-    def inspect
-      "<#{value}, #{server.host}:#{server.port}>"
-    end
-  end
-end

data/lib/memcache_util_db.rb

@@ -1,102 +0,0 @@
-##
-# A utility wrapper around the MemCacheDb client to simplify cache access.  All
-# methods silently ignore MemCacheDb errors.
-
-module CacheDb
-  
-  ##
-  # Try to return a logger object that does not rely
-  # on ActiveRecord for logging.
-  def self.logger
-    @logger ||= if defined? Rails.logger # Rails 2.1 +
-      Rails.logger
-    elsif defined? RAILS_DEFAULT_LOGGER # Rails 1.2.2 +
-      RAILS_DEFAULT_LOGGER
-    else
-      ActiveRecord::Base.logger # ... very old Rails.
-    end
-  end
-  ##
-  # Returns the object at +key+ from the cache if successful, or nil if either
-  # the object is not in the cache or if there was an error attermpting to
-  # access the cache.
-  #
-  # If there is a cache miss and a block is given the result of the block will
-  # be stored in the cache with optional +expiry+, using the +add+ method rather
-  # than +set+.
-
-  def self.get(key, expiry = 0)
-    start_time = Time.now
-    value = CACHE.get key
-    elapsed = Time.now - start_time
-    logger.debug('MemCacheDb Get (%0.6f)  %s' % [elapsed, key])
-    if value.nil? and block_given? then
-      value = yield
-      add key, value, expiry
-    end
-    value
-  rescue MemCacheDb::MemCacheDbError => err
-    logger.debug "MemCacheDb Error: #{err.message}"
-    if block_given? then
-      value = yield
-      put key, value, expiry
-    end
-    value
-  end
-
-  ##
-  # Sets +value+ in the cache at +key+, with an optional +expiry+ time in
-  # seconds.
-
-  def self.put(key, value, expiry = 0)
-    start_time = Time.now
-    CACHE.set key, value, expiry
-    elapsed = Time.now - start_time
-    logger.debug('MemCacheDb Set (%0.6f)  %s' % [elapsed, key])
-    value
-  rescue MemCacheDb::MemCacheDbError => err
-    ActiveRecord::Base.logger.debug "MemCacheDb Error: #{err.message}"
-    nil
-  end
-
-  ##
-  # Sets +value+ in the cache at +key+, with an optional +expiry+ time in
-  # seconds.  If +key+ already exists in cache, returns nil.
-
-  def self.add(key, value, expiry = 0)
-    start_time = Time.now
-    response = CACHE.add key, value, expiry
-    elapsed = Time.now - start_time
-    logger.debug('MemCacheDb Add (%0.6f)  %s' % [elapsed, key])
-    (response == "STORED\r\n") ? value : nil
-  rescue MemCacheDb::MemCacheDbError => err
-    ActiveRecord::Base.logger.debug "MemCacheDb Error: #{err.message}"
-    nil
-  end
-
-  ##
-  # Deletes +key+ from the cache in +delay+ seconds.
-
-  def self.delete(key, delay = nil)
-    start_time = Time.now
-    CACHE.delete key, delay
-    elapsed = Time.now - start_time
-    logger.debug('MemCacheDb Delete (%0.6f)  %s' %
-                                    [elapsed, key])
-    nil
-  rescue MemCacheDb::MemCacheDbError => err
-    logger.debug "MemCacheDb Error: #{err.message}"
-    nil
-  end
-
-  ##
-  # Resets all connections to MemCacheDb servers.
-
-  def self.reset
-    CACHE.reset
-    logger.debug 'MemCacheDb Connections Reset'
-    nil
-  end
-
-end
-