lazy_record 0.2.1 → 0.2.2

data/vendor/bundle/gems/thread_safe-0.3.6/lib/thread_safe/util/volatile.rb

@@ -1,64 +0,0 @@
-module ThreadSafe
-  module Util
-    module Volatile
-      # Provides +volatile+ (in the JVM's sense) attribute accessors implemented
-      # atop of the +AtomicReference+s.
-      #
-      # Usage:
-      #   class Foo
-      #     extend ThreadSafe::Util::Volatile
-      #     attr_volatile :foo, :bar
-      #
-      #     def initialize(bar)
-      #       super() # must super() into parent initializers before using the volatile attribute accessors
-      #       self.bar = bar
-      #     end
-      #
-      #     def hello
-      #       my_foo = foo # volatile read
-      #       self.foo = 1 # volatile write
-      #       cas_foo(1, 2) # => true | a strong CAS
-      #     end
-      #   end
-      def attr_volatile(*attr_names)
-        return if attr_names.empty?
-        include(Module.new do
-          atomic_ref_setup = attr_names.map {|attr_name| "@__#{attr_name} = ThreadSafe::Util::AtomicReference.new"}
-          initialize_copy_setup = attr_names.zip(atomic_ref_setup).map do |attr_name, ref_setup|
-            "#{ref_setup}(other.instance_variable_get(:@__#{attr_name}).get)"
-          end
-          class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-            def initialize(*)
-              super
-              #{atomic_ref_setup.join('; ')}
-            end
-
-            def initialize_copy(other)
-              super
-              #{initialize_copy_setup.join('; ')}
-            end
-          RUBY_EVAL
-
-          attr_names.each do |attr_name|
-            class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-              def #{attr_name}
-                @__#{attr_name}.get
-              end
-
-              def #{attr_name}=(value)
-                @__#{attr_name}.set(value)
-              end
-
-              def compare_and_set_#{attr_name}(old_value, new_value)
-                @__#{attr_name}.compare_and_set(old_value, new_value)
-              end
-            RUBY_EVAL
-
-            alias_method :"cas_#{attr_name}", :"compare_and_set_#{attr_name}"
-            alias_method :"lazy_set_#{attr_name}", :"#{attr_name}="
-          end
-        end)
-      end
-    end
-  end
-end

data/vendor/bundle/gems/thread_safe-0.3.6/lib/thread_safe/util/volatile_tuple.rb

@@ -1,46 +0,0 @@
-module ThreadSafe
-  module Util
-    # A fixed size array with volatile volatile getters/setters.
-    # Usage:
-    #   arr = VolatileTuple.new(16)
-    #   arr.volatile_set(0, :foo)
-    #   arr.volatile_get(0)    # => :foo
-    #   arr.cas(0, :foo, :bar) # => true
-    #   arr.volatile_get(0)    # => :bar
-    class VolatileTuple
-      include Enumerable
-
-      Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : Array
-
-      def initialize(size)
-        @tuple = tuple = Tuple.new(size)
-        i = 0
-        while i < size
-          tuple[i] = AtomicReference.new
-          i += 1
-        end
-      end
-
-      def volatile_get(i)
-        @tuple[i].get
-      end
-
-      def volatile_set(i, value)
-        @tuple[i].set(value)
-      end
-
-      def compare_and_set(i, old_value, new_value)
-        @tuple[i].compare_and_set(old_value, new_value)
-      end
-      alias_method :cas, :compare_and_set
-
-      def size
-        @tuple.size
-      end
-
-      def each
-        @tuple.each {|ref| yield ref.get}
-      end
-    end
-  end
-end

data/vendor/bundle/gems/thread_safe-0.3.6/lib/thread_safe/util/xor_shift_random.rb

@@ -1,41 +0,0 @@
-module ThreadSafe
-  module Util
-    # A xorshift random number (positive +Fixnum+s) generator, provides
-    # reasonably cheap way to generate thread local random numbers without
-    # contending for the global +Kernel.rand+.
-    #
-    # Usage:
-    #   x = XorShiftRandom.get # uses Kernel.rand to generate an initial seed
-    #   while true
-    #     if (x = XorShiftRandom.xorshift).odd? # thread-localy generate a next random number
-    #       do_something_at_random
-    #     end
-    #   end
-    module XorShiftRandom
-      extend self
-      MAX_XOR_SHIFTABLE_INT = MAX_INT - 1
-
-      # Generates an initial non-zero positive +Fixnum+ via +Kernel.rand+.
-      def get
-        Kernel.rand(MAX_XOR_SHIFTABLE_INT) + 1 # 0 can't be xorshifted
-      end
-
-      # xorshift based on: http://www.jstatsoft.org/v08/i14/paper
-      if 0.size == 4
-        # using the "yˆ=y>>a; yˆ=y<<b; yˆ=y>>c;" transform with the (a,b,c) tuple with values (3,1,14) to minimise Bignum overflows
-        def xorshift(x)
-          x ^= x >> 3
-          x ^= (x << 1) & MAX_INT # cut-off Bignum overflow
-          x ^= x >> 14
-        end
-      else
-        # using the "yˆ=y>>a; yˆ=y<<b; yˆ=y>>c;" transform with the (a,b,c) tuple with values (1,1,54) to minimise Bignum overflows
-        def xorshift(x)
-          x ^= x >> 1
-          x ^= (x << 1) & MAX_INT # cut-off Bignum overflow
-          x ^= x >> 54
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/thread_safe-0.3.6/lib/thread_safe/version.rb

@@ -1,21 +0,0 @@
-module ThreadSafe
-  VERSION = "0.3.6"
-end
-
-# NOTE: <= 0.2.0 used Threadsafe::VERSION
-# @private
-module Threadsafe
-
-  # @private
-  def self.const_missing(name)
-    name = name.to_sym
-    if ThreadSafe.const_defined?(name)
-      warn "[DEPRECATION] `Threadsafe::#{name}' is deprecated, use `ThreadSafe::#{name}' instead."
-      ThreadSafe.const_get(name)
-    else
-      warn "[DEPRECATION] the `Threadsafe' module is deprecated, please use `ThreadSafe` instead."
-      super
-    end
-  end
-
-end

data/vendor/bundle/gems/thread_safe-0.3.6/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-require 'logger'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-]
-
-SimpleCov.start do
-  project_name 'thread_safe'
-  add_filter '/coverage/'
-  add_filter '/pkg/'
-  add_filter '/spec/'
-  add_filter '/tasks/'
-  add_filter '/yard-template/'
-end
-
-$VERBOSE = nil # suppress our deprecation warnings
-require 'thread_safe'
-
-logger                          = Logger.new($stderr)
-logger.level                    = Logger::WARN
-
-# import all the support files
-Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }
-
-RSpec.configure do |config|
-  #config.raise_errors_for_deprecations!
-  config.order = 'random'
-end

data/vendor/bundle/gems/thread_safe-0.3.6/spec/src/thread_safe/SecurityManager.java

@@ -1,21 +0,0 @@
-package thread_safe;
-
-import java.security.Permission;
-import java.util.ArrayList;
-import java.util.List;
-
-public class SecurityManager extends java.lang.SecurityManager {
-  private final List<Permission> deniedPermissions =
-      new ArrayList<Permission>();
-
-  @Override
-  public void checkPermission(Permission p) {
-    if (deniedPermissions.contains(p)) {
-      throw new SecurityException("Denied!");
-    }
-  }
-
-  public void deny(Permission p) {
-    deniedPermissions.add(p);
-  }
-}

data/vendor/bundle/gems/thread_safe-0.3.6/spec/support/threads.rb

@@ -1 +0,0 @@
-THREADS = (RUBY_ENGINE == 'ruby' ? 100 : 10)

data/vendor/bundle/gems/thread_safe-0.3.6/spec/support/threadsafe_test.rb

@@ -1,75 +0,0 @@
-module ThreadSafe
-  module Test
-    class Latch
-      def initialize(count = 1)
-        @count = count
-        @mutex = Mutex.new
-        @cond  = ConditionVariable.new
-      end
-
-      def release
-        @mutex.synchronize do
-          @count -= 1 if @count > 0
-          @cond.broadcast if @count.zero?
-        end
-      end
-
-      def await
-        @mutex.synchronize do
-          @cond.wait @mutex if @count > 0
-        end
-      end
-    end
-
-    class Barrier < Latch
-      def await
-        @mutex.synchronize do
-          if @count.zero? # fall through
-          elsif @count > 0
-            @count -= 1
-            @count.zero? ? @cond.broadcast : @cond.wait(@mutex)
-          end
-        end
-      end
-    end
-
-    class HashCollisionKey
-      attr_reader :hash, :key
-      def initialize(key, hash = key.hash % 3)
-        @key  = key
-        @hash = hash
-      end
-
-      def eql?(other)
-        other.kind_of?(self.class) && @key.eql?(other.key)
-      end
-
-      def even?
-        @key.even?
-      end
-
-      def <=>(other)
-        @key <=> other.key
-      end
-    end
-
-    # having 4 separate HCK classes helps for a more thorough CHMV8 testing
-    class HashCollisionKey2 < HashCollisionKey; end
-    class HashCollisionKeyNoCompare < HashCollisionKey
-      def <=>(other)
-        0
-      end
-    end
-    class HashCollisionKey4 < HashCollisionKeyNoCompare; end
-
-    HASH_COLLISION_CLASSES = [HashCollisionKey, HashCollisionKey2, HashCollisionKeyNoCompare, HashCollisionKey4]
-
-    def self.HashCollisionKey(key, hash = key.hash % 3)
-      HASH_COLLISION_CLASSES[rand(4)].new(key, hash)
-    end
-
-    class HashCollisionKeyNonComparable < HashCollisionKey
-      undef <=>
-    end
-  end
-end

data/vendor/bundle/gems/thread_safe-0.3.6/spec/thread_safe/array_spec.rb

@@ -1,18 +0,0 @@
-module ThreadSafe
-  describe Array do
-    let!(:ary) { described_class.new }
-
-    it 'concurrency' do
-      (1..THREADS).map do |i|
-        Thread.new do
-          1000.times do
-            ary << i
-            ary.each { |x| x * 2 }
-            ary.shift
-            ary.last
-          end
-        end
-      end.map(&:join)
-    end
-  end
-end

data/vendor/bundle/gems/thread_safe-0.3.6/spec/thread_safe/cache_loops_spec.rb

@@ -1,507 +0,0 @@
-Thread.abort_on_exception = true
-
-module ThreadSafe
-  describe 'CacheTorture' 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         = ThreadSafe::Cache.new
-      initial_value = options[:initial_value] || 0
-      keys.each { |key| cache[key] = initial_value }
-      cache
-    end
-    ZERO_VALUE_CACHE_SETUP = lambda do |options, keys|
-      INITIAL_VALUE_CACHE_SETUP.call(options.merge(:initial_value => 0), keys)
-    end
-
-    DEFAULTS = {
-      key_count:    KEY_COUNT,
-      thread_count: THREAD_COUNT,
-      loop_count:   1,
-      prelude:      '',
-      cache_setup:  lambda { |options, keys| ThreadSafe::Cache.new }
-    }
-
-    LOW_KEY_COUNT_OPTIONS    = {loop_count: 150,     key_count: LOW_KEY_COUNT}
-    SINGLE_KEY_COUNT_OPTIONS = {loop_count: 100_000, key_count: 1}
-
-    it 'concurrency' do
-      code = <<-RUBY_EVAL
-        cache[key]
-        cache[key] = key
-        cache[key]
-        cache.delete(key)
-      RUBY_EVAL
-      do_thread_loop(:concurrency, code)
-    end
-
-    it '#put_if_absent' do
-      do_thread_loop(
-        :put_if_absent, 
-        'acc += 1 unless cache.put_if_absent(key, key)', 
-        key_count: 100_000
-      ) do |result, cache, options, keys|
-        expect_standard_accumulator_test_result(result, cache, options, keys)
-      end
-    end
-
-    it '#compute_put_if_absent' do
-      code = <<-RUBY_EVAL
-        if key.even?
-          cache.compute_if_absent(key) { acc += 1; key }
-        else
-          acc += 1 unless cache.put_if_absent(key, key)
-        end
-      RUBY_EVAL
-      do_thread_loop(:compute_if_absent, code) do |result, cache, options, keys|
-        expect_standard_accumulator_test_result(result, cache, options, keys)
-      end
-    end
-
-    it '#compute_if_absent_and_present' do
-      compute_if_absent_and_present
-      compute_if_absent_and_present(LOW_KEY_COUNT_OPTIONS)
-      compute_if_absent_and_present(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'add_remove_to_zero' do
-      add_remove_to_zero
-      add_remove_to_zero(LOW_KEY_COUNT_OPTIONS)
-      add_remove_to_zero(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'add_remove_to_zero_via_merge_pair' do
-      add_remove_to_zero_via_merge_pair
-      add_remove_to_zero_via_merge_pair(LOW_KEY_COUNT_OPTIONS)
-      add_remove_to_zero_via_merge_pair(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'add_remove' do
-      add_remove
-      add_remove(LOW_KEY_COUNT_OPTIONS)
-      add_remove(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'add_remove_via_compute' do
-      add_remove_via_compute
-      add_remove_via_compute(LOW_KEY_COUNT_OPTIONS)
-      add_remove_via_compute(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'emove_via_compute_if_absent_present' do
-      add_remove_via_compute_if_absent_present
-      add_remove_via_compute_if_absent_present(LOW_KEY_COUNT_OPTIONS)
-      add_remove_via_compute_if_absent_present(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'add_remove_indiscriminate' do
-      add_remove_indiscriminate
-      add_remove_indiscriminate(LOW_KEY_COUNT_OPTIONS)
-      add_remove_indiscriminate(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'count_up' do
-      count_up
-      count_up(LOW_KEY_COUNT_OPTIONS)
-      count_up(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'count_up_via_compute' do
-      count_up_via_compute
-      count_up_via_compute(LOW_KEY_COUNT_OPTIONS)
-      count_up_via_compute(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'count_up_via_merge_pair' do
-      count_up_via_merge_pair
-      count_up_via_merge_pair(LOW_KEY_COUNT_OPTIONS)
-      count_up_via_merge_pair(SINGLE_KEY_COUNT_OPTIONS)
-    end
-
-    it 'count_race' do
-      prelude = 'change = (rand(2) == 1) ? 1 : -1'
-      code = <<-RUBY_EVAL
-        v = cache[key]
-        acc += change if cache.replace_pair(key, v, v + change)
-      RUBY_EVAL
-      do_thread_loop(
-        :count_race, 
-        code, 
-        loop_count: 5, 
-        prelude: prelude, 
-        cache_setup: ZERO_VALUE_CACHE_SETUP
-      ) do |result, cache, options, keys|
-        result_sum = sum(result)
-        expect(sum(keys.map { |key| cache[key] })).to eq result_sum
-        expect(sum(cache.values)).to eq result_sum
-        expect(options[:key_count]).to eq cache.size
-      end
-    end
-
-    it 'get_and_set_new' do
-      code = 'acc += 1 unless cache.get_and_set(key, key)'
-      do_thread_loop(:get_and_set_new, code) do |result, cache, options, keys|
-        expect_standard_accumulator_test_result(result, cache, options, keys)
-      end
-    end
-
-    it 'get_and_set_existing' do
-      code = 'acc += 1 if cache.get_and_set(key, key) == -1'
-      do_thread_loop(
-        :get_and_set_existing, 
-        code, 
-        cache_setup: INITIAL_VALUE_CACHE_SETUP, 
-        initial_value: -1
-      ) do |result, cache, options, keys|
-        expect_standard_accumulator_test_result(result, cache, options, keys)
-      end
-    end
-
-    private
-
-    def compute_if_absent_and_present(opts = {})
-      prelude = 'on_present = rand(2) == 1'
-      code = <<-RUBY_EVAL
-        if on_present
-          cache.compute_if_present(key) { |old_value| acc += 1; old_value + 1 }
-        else
-          cache.compute_if_absent(key)  { acc += 1; 1 }
-        end
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5, prelude: prelude}.merge(opts)
-      ) do |result, cache, options, keys|
-        stored_sum       = 0
-        stored_key_count = 0
-        keys.each do |k|
-          if value = cache[k]
-            stored_sum += value
-            stored_key_count += 1
-          end
-        end
-        expect(stored_sum).to eq sum(result)
-        expect(stored_key_count).to eq cache.size
-      end
-    end
-
-    def add_remove(opts = {})
-      prelude = 'do_add = rand(2) == 1'
-      code = <<-RUBY_EVAL
-        if do_add
-          acc += 1 unless cache.put_if_absent(key, key)
-        else
-          acc -= 1 if cache.delete_pair(key, key)
-        end
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5, prelude: prelude}.merge(opts)
-      ) do |result, cache, options, keys|
-        expect_all_key_mappings_exist(cache, keys, false)
-        expect(cache.size).to eq sum(result)
-      end
-    end
-
-    def add_remove_via_compute(opts = {})
-      prelude = 'do_add = rand(2) == 1'
-      code = <<-RUBY_EVAL
-        cache.compute(key) do |old_value|
-          if do_add
-            acc += 1 unless old_value
-            key
-          else
-            acc -= 1 if old_value
-            nil
-          end
-        end
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5, prelude: prelude}.merge(opts)
-      ) do |result, cache, options, keys|
-        expect_all_key_mappings_exist(cache, keys, false)
-        expect(cache.size).to eq sum(result)
-      end
-    end
-
-    def add_remove_via_compute_if_absent_present(opts = {})
-      prelude = 'do_add = rand(2) == 1'
-      code = <<-RUBY_EVAL
-        if do_add
-          cache.compute_if_absent(key)  { acc += 1; key }
-        else
-          cache.compute_if_present(key) { acc -= 1; nil }
-        end
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5, prelude: prelude}.merge(opts)
-      ) do |result, cache, options, keys|
-        expect_all_key_mappings_exist(cache, keys, false)
-        expect(cache.size).to eq sum(result)
-      end
-    end
-
-    def add_remove_indiscriminate(opts = {})
-      prelude = 'do_add = rand(2) == 1'
-      code = <<-RUBY_EVAL
-        if do_add
-          acc += 1 unless cache.put_if_absent(key, key)
-        else
-          acc -= 1 if cache.delete(key)
-        end
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5, prelude: prelude}.merge(opts)
-      ) do |result, cache, options, keys|
-        expect_all_key_mappings_exist(cache, keys, false)
-        expect(cache.size).to eq sum(result)
-      end
-    end
-
-    def count_up(opts = {})
-      code = <<-RUBY_EVAL
-        v = cache[key]
-        acc += 1 if cache.replace_pair(key, v, v + 1)
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5, cache_setup: ZERO_VALUE_CACHE_SETUP}.merge(opts)
-      ) do |result, cache, options, keys|
-        expect_count_up(result, cache, options, keys)
-      end
-    end
-
-    def count_up_via_compute(opts = {})
-      code = <<-RUBY_EVAL
-        cache.compute(key) do |old_value|
-          acc += 1
-          old_value ? old_value + 1 : 1
-        end
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, {loop_count: 5}.merge(opts)
-      ) do |result, cache, options, keys|
-        expect_count_up(result, cache, options, keys)
-        result.inject(nil) do |previous_value, next_value| # since compute guarantees atomicity all count ups should be equal
-          expect(previous_value).to eq next_value if previous_value
-          next_value
-        end
-      end
-    end
-
-    def count_up_via_merge_pair(opts = {})
-      code = <<-RUBY_EVAL
-        cache.merge_pair(key, 1) { |old_value| old_value + 1 }
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5}.merge(opts)
-      ) do |result, cache, options, keys|
-        all_match      = true
-        expected_value = options[:loop_count] * options[:thread_count]
-        keys.each do |key|
-          value = cache[key]
-          if expected_value != value
-            all_match = false
-            break
-          end
-        end
-        expect(all_match).to be_truthy
-      end
-    end
-
-    def add_remove_to_zero(opts = {})
-      code = <<-RUBY_EVAL
-        acc += 1 unless cache.put_if_absent(key, key)
-        acc -= 1 if cache.delete_pair(key, key)
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5}.merge(opts)
-      ) do |result, cache, options, keys|
-        expect_all_key_mappings_exist(cache, keys, false)
-        expect(cache.size).to eq sum(result)
-      end
-    end
-
-    def add_remove_to_zero_via_merge_pair(opts = {})
-      code = <<-RUBY_EVAL
-        acc += (cache.merge_pair(key, key) {}) ? 1 : -1
-      RUBY_EVAL
-      do_thread_loop(
-        __method__, 
-        code, 
-        {loop_count: 5}.merge(opts)
-      ) do |result, cache, options, keys|
-        expect_all_key_mappings_exist(cache, keys, false)
-        expect(cache.size).to eq sum(result)
-      end
-    end
-
-    def do_thread_loop(name, code, options = {}, &block)
-      options = DEFAULTS.merge(options)
-      meth    = define_loop(name, code, options[:prelude])
-      keys    = to_keys_array(options[:key_count])
-      run_thread_loop(meth, keys, options, &block)
-
-      if options[:key_count] > 1
-        options[:key_count] = (options[:key_count] / 40).to_i
-        keys = to_hash_collision_keys_array(options[:key_count])
-        run_thread_loop(
-          meth, 
-          keys, 
-          options.merge(loop_count: options[:loop_count] * 5), 
-          &block
-        )
-      end
-    end
-
-    def run_thread_loop(meth, keys, options, &block)
-      cache   = options[:cache_setup].call(options, keys)
-      barrier = ThreadSafe::Test::Barrier.new(options[:thread_count])
-      result = (1..options[:thread_count]).map do
-        Thread.new do
-          setup_sync_and_start_loop(
-            meth, 
-            cache, 
-            keys, 
-            barrier, 
-            options[:loop_count]
-          )
-        end
-      end.map(&:value)
-      block.call(result, cache, options, keys) if block_given?
-    end
-
-    def setup_sync_and_start_loop(meth, cache, keys, barrier, loop_count)
-      my_keys = keys.shuffle
-      barrier.await
-      if my_keys.size == 1
-        key = my_keys.first
-        send("#{meth}_single_key", cache, key, loop_count)
-      else
-        send("#{meth}_multiple_keys", cache, my_keys, loop_count)
-      end
-    end
-
-    def define_loop(name, body, prelude)
-      inner_meth_name = :"_#{name}_loop_inner"
-      outer_meth_name = :"_#{name}_loop_outer"
-      # looping is splitted into the "loop methods" to trigger the JIT
-      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-        def #{inner_meth_name}_multiple_keys(cache, keys, i, length, acc)
-          #{prelude}
-          target = i + length
-          while i < target
-            key = keys[i]
-            #{body}
-            i += 1
-          end
-          acc
-        end unless method_defined?(:#{inner_meth_name}_multiple_keys)
-      RUBY_EVAL
-
-      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-        def #{inner_meth_name}_single_key(cache, key, i, length, acc)
-          #{prelude}
-          target = i + length
-          while i < target
-            #{body}
-            i += 1
-          end
-          acc
-        end unless method_defined?(:#{inner_meth_name}_single_key)
-      RUBY_EVAL
-
-      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-        def #{outer_meth_name}_multiple_keys(cache, keys, loop_count)
-          total_length = keys.size
-          acc = 0
-          inc = 100
-          loop_count.times do
-            i = 0
-            pre_loop_inc = total_length % inc
-            acc = #{inner_meth_name}_multiple_keys(cache, keys, i, pre_loop_inc, acc)
-            i += pre_loop_inc
-            while i < total_length
-              acc = #{inner_meth_name}_multiple_keys(cache, keys, i, inc, acc)
-              i += inc
-            end
-          end
-          acc
-        end unless method_defined?(:#{outer_meth_name}_multiple_keys)
-      RUBY_EVAL
-
-      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-        def #{outer_meth_name}_single_key(cache, key, loop_count)
-          acc = 0
-          i   = 0
-          inc = 100
-
-          pre_loop_inc = loop_count % inc
-          acc          = #{inner_meth_name}_single_key(cache, key, i, pre_loop_inc, acc)
-          i += pre_loop_inc
-
-          while i < loop_count
-            acc = #{inner_meth_name}_single_key(cache, key, i, inc, acc)
-            i += inc
-          end
-          acc
-        end unless method_defined?(:#{outer_meth_name}_single_key)
-      RUBY_EVAL
-      outer_meth_name
-    end
-
-    def to_keys_array(key_count)
-      arr = []
-      key_count.times {|i| arr << i}
-      arr
-    end
-
-    def to_hash_collision_keys_array(key_count)
-      to_keys_array(key_count).map { |key| ThreadSafe::Test::HashCollisionKey(key) }
-    end
-
-    def sum(result)
-      result.inject(0) { |acc, i| acc + i }
-    end
-
-    def expect_standard_accumulator_test_result(result, cache, options, keys)
-      expect_all_key_mappings_exist(cache, keys)
-      expect(options[:key_count]).to eq sum(result)
-      expect(options[:key_count]).to eq cache.size
-    end
-
-    def expect_all_key_mappings_exist(cache, keys, all_must_exist = true)
-      keys.each do |key|
-        value = cache[key]
-        if value || all_must_exist
-          expect(key).to eq value unless key == value # don't do a bazzilion assertions unless necessary
-        end
-      end
-    end
-
-    def expect_count_up(result, cache, options, keys)
-      keys.each do |key|
-        value = cache[key]
-        expect(value).to be_truthy unless value
-      end
-      expect(sum(cache.values)).to   eq sum(result)
-      expect(options[:key_count]).to eq cache.size
-    end
-  end unless RUBY_ENGINE == 'rbx' || ENV['TRAVIS']
-end