mperham-memcache-client 1.6.4 → 1.6.5

data/History.txt

@@ -1,3 +1,15 @@
+= 1.6.5 (2009-02-27)
+
+* 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

data/README.rdoc

@@ -16,22 +16,24 @@ Just install the gem:
 
 With one server:
 
-  CACHE = MemCache.new 'localhost:11211', :namespace => 'my_namespace'
+  CACHE = MemCache.new 'localhost:11211'
 
 Or with multiple servers:
 
-  CACHE = MemCache.new %w[one.example.com:11211 two.example.com:11211],
-                       :namespace => 'my_namespace'
+  CACHE = MemCache.new %w[one.example.com:11211 two.example.com:11211]
+
+
+== Tuning memcache-client
+
+The MemCache.new method takes a number of options which can be useful at times.  Please
+read the source comments there for an overview.
 
-See MemCache.new for details.  Please note memcache-client is not thread-safe
-by default.  You should create a separate instance for each thread in your
-process.
 
 == Using memcache-client with Rails
 
-There's no need to use memcache-client in a Rails application.  Rails 2.1+ includes
-a basic caching library which can be used with memcached.  See ActiveSupport::Cache::Store
-for more details.
+Rails 2.1+ includes memcache-client out of the box.  See ActiveSupport::Cache::MemCacheStore
+and the Rails.cache method for more details.
+
 
 == Questions?
 

data/lib/memcache.rb

@@ -2,10 +2,28 @@ $TESTING = defined?($TESTING) && $TESTING
 
 require 'socket'
 require 'thread'
-require 'timeout'
 require 'zlib'
 require 'digest/sha1'
 
+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'
+    MemCacheTimer = SystemTimer
+  else
+    require 'timeout'
+    MemCacheTimer = 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'
+  MemCacheTimer = Timeout
+end
+
 ##
 # A Ruby client library for memcached.
 #
@@ -15,7 +33,7 @@ class MemCache
   ##
   # The version of MemCache you are using.
 
-  VERSION = '1.6.4'
+  VERSION = '1.6.5'
 
   ##
   # Default options for the cache object.
@@ -23,7 +41,7 @@ class MemCache
   DEFAULT_OPTIONS = {
     :namespace   => nil,
     :readonly    => false,
-    :multithread => false,
+    :multithread => true,
     :failover    => true,
     :timeout     => 0.5,
     :logger      => nil,
@@ -55,7 +73,7 @@ class MemCache
   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
@@ -79,12 +97,14 @@ class MemCache
   #
   #   [: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)
@@ -160,9 +180,6 @@ class MemCache
         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
@@ -220,6 +237,8 @@ class MemCache
   #   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_multi(*keys)
     raise MemCacheError, 'No active servers' unless active?
@@ -353,7 +372,6 @@ class MemCache
     raise MemCacheError, "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"
@@ -364,8 +382,6 @@ class MemCache
       end
     rescue IndexError => err
       handle_error nil, err
-    ensure
-      @mutex.unlock if @multithread
     end
   end
 
@@ -621,7 +637,7 @@ class MemCache
 
       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)
@@ -754,7 +770,6 @@ class MemCache
 
     attr_reader :status
 
-    attr_reader :multithread
     attr_reader :logger
 
     ##
@@ -769,9 +784,6 @@ class MemCache
       @port   = port.to_i
       @weight = weight.to_i
 
-      @multithread = memcache.multithread
-      @mutex = Mutex.new
-
       @sock   = nil
       @retry  = nil
       @status = 'NOT CONNECTED'
@@ -801,7 +813,6 @@ class MemCache
     # 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
@@ -824,8 +835,6 @@ class MemCache
       end
 
       return @sock
-    ensure
-      @mutex.unlock if @multithread
     end
 
     ##
@@ -833,13 +842,10 @@ class MemCache
     # 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
 
     ##
@@ -868,26 +874,26 @@ end
 class TCPTimeoutSocket
   
   def initialize(host, port, timeout)
-    Timeout::timeout(MemCache::Server::CONNECT_TIMEOUT, SocketError) do
+    MemCacheTimer.timeout(MemCache::Server::CONNECT_TIMEOUT) do
       @sock = TCPSocket.new(host, port)
       @len = timeout
     end
   end
   
   def write(*args)
-    Timeout::timeout(@len, SocketError) do
+    MemCacheTimer.timeout(@len) do
       @sock.write(*args)
     end
   end
   
   def gets(*args)
-    Timeout::timeout(@len, SocketError) do
+    MemCacheTimer.timeout(@len) do
       @sock.gets(*args)
     end
   end
   
   def read(*args)
-    Timeout::timeout(@len, SocketError) do
+    MemCacheTimer.timeout(@len) do
       @sock.read(*args)
     end
   end

data/test/test_mem_cache.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?(MemCache)
 
 class MemCache
 
@@ -79,7 +80,7 @@ end
 
 class FakeServer
 
-  attr_reader :host, :port, :socket, :weight, :multithread, :status
+  attr_accessor :host, :port, :socket, :weight, :multithread, :status
 
   def initialize(socket = nil)
     @closed = false
@@ -87,7 +88,7 @@ class FakeServer
     @port = 11211
     @socket = socket || FakeSocket.new
     @weight = 1
-    @multithread = false
+    @multithread = true
     @status = "CONNECTED"
   end
 
@@ -117,9 +118,9 @@ class TestMemCache < Test::Unit::TestCase
 
   def test_performance
     requirement(memcached_running?, 'A real memcached server must be running for performance testing') do
-      host = Socket.gethostname
 
-      cache = MemCache.new(['localhost:11211',"#{host}:11211"])
+      cache = MemCache.new(['localhost:11211',"127.0.0.1:11211"])
+      cache.flush_all
       cache.add('a', 1, 120)
       with = xprofile 'get' do
         1000.times do
@@ -129,7 +130,7 @@ class TestMemCache < Test::Unit::TestCase
       puts ''
       puts "1000 gets with socket timeout: #{with} sec"
 
-      cache = MemCache.new(['localhost:11211',"#{host}:11211"], :timeout => nil)
+      cache = MemCache.new(['localhost:11211',"127.0.0.1:11211"], :timeout => nil)
       cache.add('a', 1, 120)
       without = xprofile 'get' do
         1000.times do
@@ -335,8 +336,10 @@ class TestMemCache < Test::Unit::TestCase
 
   def test_multithread_error
     server = FakeServer.new
+    server.multithread = false
+    
+    @cache = MemCache.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
 
@@ -972,5 +975,37 @@ class TestMemCache < 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 = MemCache.new(['localhost:11211', '127.0.0.1:11211'])
+      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: mperham-memcache-client
 version: !ruby/object:Gem::Version 
-  version: 1.6.4
+  version: 1.6.5
 platform: ruby
 authors: 
 - Eric Hodel
@@ -11,7 +11,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: []