Renamed Concurrent::Cache to Concurrent::Map.

jdantonio · jdantonio · commit 52e5f373a93a · 2015-08-10T10:50:04.000-04:00
diff --git a/README.md b/README.md
@@ -75,7 +75,7 @@ These classes were originally part of the (deprecated) `thread_safe` gem.
 
 * [Array](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Array.html) A thread-safe subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
 * [Hash](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Hash.html) A thread-safe subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
-* [Cache](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Cache.html) A hash-like object that should have much better performance characteristics, especially under high concurrency, than `Concurrent::Hash`.
+* [Map](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Map.html) A hash-like object that should have much better performance characteristics, especially under high concurrency, than `Concurrent::Hash`.
 
 #### Thread-safe Value Objects
 
diff --git a/examples/bench_cache.rb b/examples/bench_cache.rb
diff --git a/examples/bench_map.rb b/examples/bench_map.rb
@@ -1,16 +1,16 @@
-#!/usr/bin/env ruby -wU
+#!/usr/bin/env ruby
 
-require 'benchmark'
-require 'concurrent'
+require "benchmark"
+require "concurrent"
 
 hash  = {}
-cache = Concurrent::Map.new
+map = Concurrent::Map.new
 
 ENTRIES = 10_000
 
 ENTRIES.times do |i|
   hash[i]  = i
-  cache[i] = i
+  map[i] = i
 end
 
 TESTS = 40_000_000
@@ -22,14 +22,14 @@
   end
 
   results.report('Map#[]') do
-    TESTS.times { cache[key] }
+    TESTS.times { map[key] }
   end
 
   results.report('Hash#each_pair') do
     (TESTS / ENTRIES).times { hash.each_pair {|k,v| v} }
   end
 
   results.report('Map#each_pair') do
-    (TESTS / ENTRIES).times { cache.each_pair {|k,v| v} }
+    (TESTS / ENTRIES).times { map.each_pair {|k,v| v} }
   end
 end
diff --git a/ext/ConcurrentRubyExtService.java b/ext/ConcurrentRubyExtService.java
@@ -2,7 +2,7 @@
 
 import org.jruby.Ruby;
 import org.jruby.runtime.load.BasicLibraryService;
-import com.concurrent_ruby.ext.JRubyCacheBackendLibrary;
+import com.concurrent_ruby.ext.JRubyMapBackendLibrary;
 
 public class ConcurrentRubyExtService implements BasicLibraryService {
     public boolean basicLoad(final Ruby runtime) throws IOException {
@@ -11,7 +11,7 @@ public boolean basicLoad(final Ruby runtime) throws IOException {
         new com.concurrent_ruby.ext.JavaAtomicFixnumLibrary().load(runtime, false);
         new com.concurrent_ruby.ext.JavaSemaphoreLibrary().load(runtime, false);
         new com.concurrent_ruby.ext.SynchronizationLibrary().load(runtime, false);
-        new com.concurrent_ruby.ext.JRubyCacheBackendLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JRubyMapBackendLibrary().load(runtime, false);
         return true;
     }
 }
diff --git a/ext/com/concurrent_ruby/ext/JRubyMapBackendLibrary.java b/ext/com/concurrent_ruby/ext/JRubyMapBackendLibrary.java
@@ -23,24 +23,24 @@
  *
  * @author thedarkone
  */
-public class JRubyCacheBackendLibrary implements Library {
+public class JRubyMapBackendLibrary implements Library {
   public void load(Ruby runtime, boolean wrap) throws IOException {
 
     RubyModule concurrentMod = runtime.defineModule("Concurrent");
     RubyModule thread_safeMod = concurrentMod.defineModuleUnder("ThreadSafe");
-    RubyClass jrubyRefClass = thread_safeMod.defineClassUnder("JRubyCacheBackend", runtime.getObject(), BACKEND_ALLOCATOR);
+    RubyClass jrubyRefClass = thread_safeMod.defineClassUnder("JRubyMapBackend", runtime.getObject(), BACKEND_ALLOCATOR);
     jrubyRefClass.setAllocator(BACKEND_ALLOCATOR);
-    jrubyRefClass.defineAnnotatedMethods(JRubyCacheBackend.class);
+    jrubyRefClass.defineAnnotatedMethods(JRubyMapBackend.class);
   }
 
   private static final ObjectAllocator BACKEND_ALLOCATOR = new ObjectAllocator() {
     public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-      return new JRubyCacheBackend(runtime, klazz);
+      return new JRubyMapBackend(runtime, klazz);
     }
   };
 
-  @JRubyClass(name="JRubyCacheBackend", parent="Object")
-    public static class JRubyCacheBackend extends RubyObject {
+  @JRubyClass(name="JRubyMapBackend", parent="Object")
+    public static class JRubyMapBackend extends RubyObject {
       // Defaults used by the CHM
       static final int DEFAULT_INITIAL_CAPACITY = 16;
       static final float DEFAULT_LOAD_FACTOR = 0.75f;
@@ -65,7 +65,7 @@ private static boolean isCausedBySecurityException(Throwable t) {
         return false;
       }
 
-      public JRubyCacheBackend(Ruby runtime, RubyClass klass) {
+      public JRubyMapBackend(Ruby runtime, RubyClass klass) {
         super(runtime, klass);
       }
 
@@ -228,7 +228,7 @@ public IRubyObject get_or_default(IRubyObject key, IRubyObject defaultValue) {
       }
 
       @JRubyMethod(visibility = PRIVATE)
-        public JRubyCacheBackend initialize_copy(ThreadContext context, IRubyObject other) {
+        public JRubyMapBackend initialize_copy(ThreadContext context, IRubyObject other) {
           map = newCHM();
           return this;
         }
diff --git a/lib/concurrent.rb b/lib/concurrent.rb
@@ -12,13 +12,13 @@
 require 'concurrent/atom'
 require 'concurrent/array'
 require 'concurrent/async'
-require 'concurrent/cache'
 require 'concurrent/dataflow'
 require 'concurrent/delay'
 require 'concurrent/future'
 require 'concurrent/hash'
 require 'concurrent/immutable_struct'
 require 'concurrent/ivar'
+require 'concurrent/map'
 require 'concurrent/maybe'
 require 'concurrent/mutable_struct'
 require 'concurrent/mvar'
diff --git a/lib/concurrent/map.rb b/lib/concurrent/map.rb
@@ -1,42 +1,42 @@
 require 'thread'
 
 module Concurrent
-  autoload :JRubyCacheBackend,           'concurrent/thread_safe/jruby_cache_backend'
-  autoload :MriCacheBackend,             'concurrent/thread_safe/mri_cache_backend'
-  autoload :NonConcurrentCacheBackend,   'concurrent/thread_safe/non_concurrent_cache_backend'
-  autoload :AtomicReferenceCacheBackend, 'concurrent/thread_safe/atomic_reference_cache_backend'
-  autoload :SynchronizedCacheBackend,    'concurrent/thread_safe/synchronized_cache_backend'
+  autoload :JRubyMapBackend,           'concurrent/thread_safe/jruby_map_backend'
+  autoload :MriMapBackend,             'concurrent/thread_safe/mri_map_backend'
+  autoload :NonConcurrentMapBackend,   'concurrent/thread_safe/non_concurrent_map_backend'
+  autoload :AtomicReferenceMapBackend, 'concurrent/thread_safe/atomic_reference_map_backend'
+  autoload :SynchronizedMapBackend,    'concurrent/thread_safe/synchronized_map_backend'
 
   # @!visibility private
   module ThreadSafe
 
     # @!visibility private
-    CacheBackend = if defined?(RUBY_ENGINE)
-                     case RUBY_ENGINE
-                     when 'jruby'; JRubyCacheBackend
-                     when 'ruby';  MriCacheBackend
-                     when 'rbx';   AtomicReferenceCacheBackend
-                     else
-                       warn 'Concurrent::Cache: unsupported Ruby engine, using a fully synchronized Concurrent::Cache implementation' if $VERBOSE
-                       SynchronizedCacheBackend
-                     end
+    MapBackend = if defined?(RUBY_ENGINE)
+                   case RUBY_ENGINE
+                   when 'jruby'; JRubyMapBackend
+                   when 'ruby';  MriMapBackend
+                   when 'rbx';   AtomicReferenceMapBackend
                    else
-                     MriCacheBackend
+                     warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation' if $VERBOSE
+                     SynchronizedMapBackend
                    end
+                 else
+                   MriMapBackend
+                 end
   end
 
-  # `Concurrent::Cache` is a hash-like object and should have much better performance
+  # `Concurrent::Map` is a hash-like object and should have much better performance
   # characteristics, especially under high concurrency, than `Concurrent::Hash`.
-  # However, `Concurrent::Cache `is not strictly semantically equivalent to a ruby `Hash`
+  # However, `Concurrent::Map `is not strictly semantically equivalent to a ruby `Hash`
   # -- for instance, it does not necessarily retain ordering by insertion time as `Hash`
   # does. For most uses it should do fine though, and we recommend you consider
-  # `Concurrent::Cache` instead of `Concurrent::Hash` for your concurrency-safe hash needs.
+  # `Concurrent::Map` instead of `Concurrent::Hash` for your concurrency-safe hash needs.
   # 
   # > require 'concurrent'
   # >
-  # > cache = Concurrent::Cache.new
+  # > map = Concurrent::Map.new
 
-  class Cache < ThreadSafe::CacheBackend
+  class Map < ThreadSafe::MapBackend
     def initialize(options = nil, &block)
       if options.kind_of?(::Hash)
         validate_options_hash!(options)
diff --git a/lib/concurrent/thread_safe.rb b/lib/concurrent/thread_safe.rb
@@ -2,8 +2,8 @@
 require 'concurrent/thread_safe/synchronized_delegator'
 
 module Concurrent
-  autoload :Cache, 'concurrent/cache'
-  autoload :Util,  'concurrent/thread_safe/util'
+  autoload :Map,  'concurrent/map'
+  autoload :Util, 'concurrent/thread_safe/util'
 
   # Various classes within allows for +nil+ values to be stored,
   # so a special +NULL+ token is required to indicate the "nil-ness".
diff --git a/lib/concurrent/thread_safe/atomic_reference_map_backend.rb b/lib/concurrent/thread_safe/atomic_reference_map_backend.rb
@@ -183,7 +183,7 @@ module ThreadSafe
     # checks.
     #
     # @!visibility private
-    class AtomicReferenceCacheBackend
+    class AtomicReferenceMapBackend
       
       # @!visibility private
       class Table < Util::PowerOfTwoTuple
diff --git a/lib/concurrent/thread_safe/mri_map_backend.rb b/lib/concurrent/thread_safe/mri_map_backend.rb
@@ -4,7 +4,7 @@ module Concurrent
   module ThreadSafe
         
     # @!visibility private
-    class MriCacheBackend < NonConcurrentCacheBackend
+    class MriMapBackend < NonConcurrentMapBackend
 
       # We can get away with a single global write lock (instead of a per-instance
       # one) because of the GVL/green threads.
diff --git a/lib/concurrent/thread_safe/non_concurrent_map_backend.rb b/lib/concurrent/thread_safe/non_concurrent_map_backend.rb
@@ -4,11 +4,11 @@ module Concurrent
   module ThreadSafe
 
     # @!visibility private
-    class NonConcurrentCacheBackend
+    class NonConcurrentMapBackend
 
       # WARNING: all public methods of the class must operate on the @backend
       # directly without calling each other. This is important because of the
-      # SynchronizedCacheBackend which uses a non-reentrant mutex for perfomance
+      # SynchronizedMapBackend which uses a non-reentrant mutex for perfomance
       # reasons.
       def initialize(options = nil)
         @backend = {}
diff --git a/lib/concurrent/thread_safe/synchronized_map_backend.rb b/lib/concurrent/thread_safe/synchronized_map_backend.rb
@@ -4,7 +4,7 @@ module Concurrent
   module ThreadSafe
 
     # @!visibility private
-    class SynchronizedCacheBackend < NonConcurrentCacheBackend
+    class SynchronizedMapBackend < NonConcurrentMapBackend
 
       require 'mutex_m'
       include Mutex_m
diff --git a/spec/concurrent/map_spec.rb b/spec/concurrent/map_spec.rb
@@ -1,7 +1,7 @@
 Thread.abort_on_exception = true
 
 module Concurrent
-  describe Cache do
+  describe Map do
     before(:each) do
       @cache = described_class.new
     end
@@ -814,7 +814,7 @@ def key # assert_collision_resistance expects to be able to call .key to get the
 
     it 'marshal dump load' do
       new_cache = Marshal.load(Marshal.dump(@cache))
-      expect(new_cache).to be_an_instance_of Concurrent::Cache
+      expect(new_cache).to be_an_instance_of Concurrent::Map
       expect(0).to eq new_cache.size
       @cache[:a] = 1
       new_cache = Marshal.load(Marshal.dump(@cache))
@@ -823,19 +823,19 @@ def key # assert_collision_resistance expects to be able to call .key to get the
     end
 
     it 'marshal dump doesnt work with default proc' do
-      expect { Marshal.dump(Concurrent::Cache.new {}) }.to raise_error(TypeError)
+      expect { Marshal.dump(Concurrent::Map.new {}) }.to raise_error(TypeError)
     end
 
     private
 
     def with_or_without_default_proc(&block)
       block.call(false)
-      @cache = Concurrent::Cache.new { |h, k| h[k] = :default_value }
+      @cache = Concurrent::Map.new { |h, k| h[k] = :default_value }
       block.call(true)
     end
 
     def cache_with_default_proc(default_value = 1)
-      Concurrent::Cache.new { |cache, k| cache[k] = default_value }
+      Concurrent::Map.new { |cache, k| cache[k] = default_value }
     end
 
     def expect_size_change(change, cache = @cache, &block)
@@ -849,16 +849,16 @@ def expect_valid_option(option_name, value)
     end
 
     def expect_valid_options(options)
-      c = Concurrent::Cache.new(options)
-      expect(c).to be_an_instance_of Concurrent::Cache
+      c = Concurrent::Map.new(options)
+      expect(c).to be_an_instance_of Concurrent::Map
     end
 
     def expect_invalid_option(option_name, value)
       expect_invalid_options(option_name => value)
     end
 
     def expect_invalid_options(options)
-      expect { Concurrent::Cache.new(options) }.to raise_error(ArgumentError)
+      expect { Concurrent::Map.new(options) }.to raise_error(ArgumentError)
     end
 
     def expect_no_size_change(cache = @cache, &block) 
diff --git a/spec/concurrent/thread_safe/map_loops_spec.rb b/spec/concurrent/thread_safe/map_loops_spec.rb
@@ -2,13 +2,13 @@
 
 module Concurrent
 
-  describe 'CacheTorture', stress: true, notravis: true do
+  describe 'MapTorture', stress: true, notravis: true do
     THREAD_COUNT  = 40
     KEY_COUNT     = (((2**13) - 2) * 0.75).to_i # get close to the doubling cliff
     LOW_KEY_COUNT = (((2**8 ) - 2) * 0.75).to_i # get close to the doubling cliff
 
     INITIAL_VALUE_CACHE_SETUP = lambda do |options, keys|
-      cache         = Concurrent::Cache.new
+      cache         = Concurrent::Map.new
       initial_value = options[:initial_value] || 0
       keys.each { |key| cache[key] = initial_value }
       cache
@@ -22,7 +22,7 @@ module Concurrent
       thread_count: THREAD_COUNT,
       loop_count:   1,
       prelude:      '',
-      cache_setup:  lambda { |options, keys| Concurrent::Cache.new }
+      cache_setup:  lambda { |options, keys| Concurrent::Map.new }
     }
 
     LOW_KEY_COUNT_OPTIONS    = {loop_count: 150,     key_count: LOW_KEY_COUNT}
diff --git a/spec/concurrent/thread_safe/no_unsafe_spec.rb b/spec/concurrent/thread_safe/no_unsafe_spec.rb
@@ -20,7 +20,7 @@ module Concurrent
 
       it 'no_unsafe_version_of_chmv8_is_used' do
         require 'concurrent/thread_safe/jruby_cache_backend' # make sure the jar has been loaded
-        expect(!Java::OrgJrubyExtThread_safe::JRubyCacheBackendLibrary::JRubyCacheBackend::CAN_USE_UNSAFE_CHM).to be_truthy
+        expect(!Java::OrgJrubyExtThread_safe::JRubyMapBackendLibrary::JRubyMapBackend::CAN_USE_UNSAFE_CHM).to be_truthy
       end
     end
   end

Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,7 @@ module ThreadSafe`
`183`	`183`	`# checks.`
`184`	`184`	`#`
`185`	`185`	`# @!visibility private`
`186`		`- class AtomicReferenceCacheBackend`
	`186`	`+ class AtomicReferenceMapBackend`
`187`	`187`
`188`	`188`	`# @!visibility private`
`189`	`189`	`class Table < Util::PowerOfTwoTuple`