d_heap 0.6.1 → 0.7.0

data/lib/d_heap/benchmarks/benchmarker.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require "d_heap/benchmarks"
-
-require "benchmark_driver"
-require "shellwords"
-require "English"
-
-module DHeap::Benchmarks
-  # Benchmarks different implementations with different sizes
-  class Benchmarker
-    include Randomness
-    include Scenarios
-
-    N_COUNTS = [
-      5,      # 1 + 4
-      21,     # 1 + 4 + 16
-      85,     # 1 + 4 + 16 + 64
-      341,    # 1 + 4 + 16 + 64 + 256
-      1365,   # 1 + 4 + 16 + 64 + 256 + 1024
-      5461,   # 1 + 4 + 16 + 64 + 256 + 1024 + 4096
-      21_845, # 1 + 4 + 16 + 64 + 256 + 1024 + 4096 + 16384
-      87_381, # 1 + 4 + 16 + 64 + 256 + 1024 + 4096 + 16384 + 65536
-    ].freeze
-
-    attr_reader :time
-    attr_reader :iterations_for_push_pop
-    attr_reader :io
-
-    def initialize(
-      time: Integer(ENV.fetch("BENCHMARK_TIME", 10)),
-      iterations_for_push_pop: 10_000,
-      io: $stdout
-    )
-      @time = time
-      @iterations_for_push_pop = Integer(iterations_for_push_pop)
-      @io = io
-    end
-
-    def call(queue_size: ENV.fetch("BENCHMARK_QUEUE_SIZE", :unset))
-      DHeap::Benchmarks.puts_version_info("Benchmarking")
-      sizes = (queue_size == :unset) ? N_COUNTS : [Integer(queue_size)]
-      sizes.each do |size|
-        benchmark_size(size)
-      end
-    end
-
-    def benchmark_size(size)
-      sep "#", "Benchmarks with N=#{size} (t=#{time}sec/benchmark)", big: true
-      io.puts
-      benchmark_push_n            size
-      benchmark_push_n_then_pop_n size
-      benchmark_repeated_push_pop size
-    end
-
-    def benchmark_push_n(queue_size)
-      benchmarking("push N", "push_n", queue_size)
-    end
-
-    def benchmark_push_n_then_pop_n(queue_size)
-      benchmarking("push N then pop N", "push_n_pop_n", queue_size)
-    end
-
-    def benchmark_repeated_push_pop(queue_size)
-      benchmarking(
-        "Push/pop with pre-filled queue (size=N)", "push_pop", queue_size
-      )
-    end
-
-    private
-
-    # TODO: move somewhere else...
-    def skip_profiling?(queue_size, impl)
-      impl.klass == DHeap::Benchmarks::PushAndResort && 10_000 < queue_size
-    end
-
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-
-    def benchmarking(name, file, size)
-      Bundler.with_unbundled_env do
-        sep "==", "#{name} (N=#{size})"
-        cmd = %W[
-          bin/benchmark-driver
-          --bundler
-          --run-duration 6
-          --timeout 15
-          --runner ips_zero_fail
-          benchmarks/#{file}.yml
-        ]
-        if file == "push_n"
-          cmd << "--filter" << /dheap|\bstl\b|\bbsearch\b|\brb_heap\b/.to_s
-        end
-        env = ENV.to_h.merge(
-          "BENCH_N" => size.to_s,
-          "RUBYLIB" => File.expand_path("../..", __dir__),
-        )
-        system(env, *cmd)
-      end
-    end
-
-    def sep(sep, msg = "", width: 80, big: false)
-      txt = String.new
-      txt += "#{sep * (width / sep.length)}\n" if big
-      txt += sep
-      txt += " #{msg}" if msg && !msg.empty?
-      txt += " " unless big
-      txt += sep * ((width - txt.length) / sep.length) unless big
-      txt += "\n"
-      txt += "#{sep * (width / sep.length)}\n" if big
-      io.print txt
-    end
-
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-
-  end
-end

data/lib/d_heap/benchmarks/implementations.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-require "fc"
-
-module DHeap::Benchmarks
-
-  # base class for example priority queues
-  class ExamplePriorityQueue
-    attr_reader :a
-
-    # quick initialization by simply sorting the array once.
-    def initialize(count = nil, &block)
-      @a = []
-      return unless count
-      count.times {|i| @a << block.call(i) }
-      @a.sort!
-    end
-
-    def clear
-      @a.clear
-    end
-
-    def empty?
-      @a.empty?
-    end
-
-    if ENV["LOG_LEVEL"] == "debug"
-      def dbg(msg)
-        puts "%20s: %p, %p" % [msg, @a.first, (@a[1..-1] || []).each_slice(2).to_a]
-      end
-    else
-      def dbg(msg) nil end
-    end
-
-  end
-
-  # The most naive approach--completely unsorted!--is ironically not the worst.
-  class FindMin < ExamplePriorityQueue
-
-    # O(1)
-    def <<(score)
-      raise ArgumentError unless score
-      @a.push score
-    end
-
-    # O(n)
-    def pop
-      return unless (score = @a.min)
-      index = @a.rindex(score)
-      @a.delete_at(index)
-      score
-    end
-
-  end
-
-  # Re-sorting after each insert: this both naive and performs the worst.
-  class Sorting < ExamplePriorityQueue
-
-    # O(n log n)
-    def <<(score)
-      raise ArgumentError unless score
-      @a.push score
-      @a.sort!
-    end
-
-    # O(1)
-    def pop
-      @a.shift
-    end
-
-  end
-
-  # A very simple example priority queue that is implemented with a sorted array.
-  #
-  # It uses Array#bsearch + Array#insert to push new values, and Array#pop to pop
-  # the min value.
-  class BSearch < ExamplePriorityQueue
-
-    # Array#bsearch_index is O(log n)
-    # Array#insert        is O(n)
-    #
-    # So this should be O(n).
-    #
-    # In practice though, memcpy has a *very* small constant factor.
-    # And bsearch_index uses *exactly* (log n / log 2) comparisons.
-    def <<(score)
-      raise ArgumentError unless score
-      index = @a.bsearch_index {|other| score > other } || @a.length
-      @a.insert(index, score)
-    end
-
-    # Array#pop is O(1). It updates length without changing capacity or contents.
-    #
-    # No comparisons are necessary.
-    #
-    # shift is usually also O(1) and could be used if it were sorted normally.
-    def pop
-      @a.pop
-    end
-
-  end
-
-  # a very simple pure ruby binary heap
-  class RbHeap < ExamplePriorityQueue
-
-    def <<(value)
-      raise ArgumentError unless value
-      @a.push(value)
-      sift_up(@a.size - 1, value)
-    end
-
-    def pop
-      return if @a.empty?
-      popped = @a.first
-      value = @a.pop
-      last_index = @a.size - 1
-      return popped unless 0 <= last_index
-
-      sift_down(0, last_index, value)
-      popped
-    end
-
-    private
-
-    def sift_up(index, value = @a[index])
-      while 0 < index # rubocop:disable Style/NumericPredicate
-        parent_index = (index - 1) / 2
-        parent_value = @a[parent_index]
-        break if parent_value <= value
-        @a[index] = parent_value
-        index = parent_index
-      end
-      @a[index] = value
-      # check_heap!(index)
-    end
-
-    def sift_down(index, last_index = @a.size - 1, value = @a[index])
-      last_parent = (last_index - 1) / 2
-      while index <= last_parent
-        child_index, child_value = select_min_child(index, last_index)
-        break if value <= child_value
-        @a[index] = child_value
-        index = child_index
-        child_index = index * 2 + 1
-      end
-      @a[index] = value
-    end
-
-    def select_min_child(index, last_index = @a.size - 1)
-      child_index = index * 2 + 1
-      if child_index < last_index && a[child_index + 1] < @a[child_index]
-        child_index += 1
-      end
-      [child_index, @a[child_index]]
-    end
-
-    def check_heap!(idx)
-      check_heap_up!(idx)
-      check_heap_dn!(idx)
-    end
-
-    # compares index to its parent
-    def check_heap_at!(idx)
-      value = @a[idx]
-      unless idx <= 0
-        pidx = (idx - 1) / 2
-        pval = @a[pidx]
-        raise "@a[#{idx}] == #{value}, #{pval} > #{value}" if pval > value
-      end
-      value
-    end
-
-    def check_heap_up!(idx)
-      return if idx <= 0
-      pidx = (idx - 1) / 2
-      check_heap_at!(pidx)
-      check_heap_up!(pidx)
-    end
-
-    def check_heap_dn!(idx)
-      return unless @a.size <= idx
-      check_heap_at!(idx)
-      check_heap_down!(idx * 2 + 1)
-      check_heap_down!(idx * 2 + 2)
-    end
-
-  end
-
-  # minor adjustments to the "priority_queue_cxx" gem, to match the API
-  class CppSTL
-
-    def initialize
-      clear
-    end
-
-    def <<(value); @q.push(value, value) end
-
-    def clear
-      @q = FastContainers::PriorityQueue.new(:min)
-    end
-
-    def empty?
-      @q.empty?
-    end
-
-    def pop
-      @q.pop
-    rescue RuntimeError
-      nil
-    end
-
-  end
-
-  # Different duck-typed priority queue implemenations
-  IMPLEMENTATIONS = [
-    OpenStruct.new(name: " push and resort", klass: Sorting).freeze,
-    OpenStruct.new(name: "  find min + del", klass: FindMin).freeze,
-    OpenStruct.new(name: "bsearch + insert", klass: BSearch).freeze,
-    OpenStruct.new(name: "ruby binary heap", klass: RbHeap).freeze,
-    OpenStruct.new(name: "C++STL PriorityQ", klass: CppSTL).freeze,
-    OpenStruct.new(name: "quaternary DHeap", klass: DHeap).freeze,
-  ].freeze
-
-end

data/lib/d_heap/benchmarks/profiler.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "d_heap/benchmarks"
-
-require "ruby-prof"
-
-module DHeap::Benchmarks
-  # Profiles different implementations with different sizes
-  class Profiler
-    include Randomness
-    include Scenarios
-
-    N_COUNTS = [
-      5,      # 1 + 4
-      1365,   # 1 + 4 + 16 + 64 + 256 + 1024
-      87_381, # 1 + 4 + 16 + 64 + 256 + 1024 + 4096 + 16384 + 65536
-    ].freeze
-
-    def call(
-      queue_size: ENV.fetch("PROFILE_QUEUE_SIZE", :unset),
-      iterations: ENV.fetch("PROFILE_ITERATIONS", 1_000_000)
-    )
-      DHeap::Benchmarks.puts_version_info("Profiling")
-      fill_random_vals
-      sizes = queue_size == :unset ? N_COUNTS : [Integer(queue_size)]
-      sizes.each do |size|
-        profile_all(size, iterations)
-      end
-    end
-
-    def profile_all(queue_size, iterations, io: $stdout)
-      io.puts <<~TEXT
-        ########################################################################
-        # Profile w/ N=#{queue_size} (i=#{iterations})
-        # (n.b. RubyProf & tracepoint can change relative performance.
-        #       A sampling profiler can provide more accurate relative metrics.
-        ########################################################################
-
-      TEXT
-      DHeap::Benchmarks::IMPLEMENTATIONS.each do |impl|
-        profile_one(impl, queue_size, iterations, io: io)
-      end
-    end
-
-    # TODO: move somewhere else...
-    def skip_profiling?(queue_size, impl)
-      impl.klass == DHeap::Benchmarks::Sorting && 10_000 < queue_size
-    end
-
-    def profile_one(impl, queue_size, iterations, io: $stdout)
-      return if skip_profiling?(queue_size, impl)
-      io.puts "Filling   #{impl.name} ---------------------------"
-      queue = impl.klass.new
-      push_n(queue, queue_size)
-      io.puts "Profiling #{impl.name} ---------------------------"
-      profiling do
-        repeated_push_pop(queue, iterations)
-      end
-    end
-
-    def profiling(io: $stdout, &block)
-      # do the thing
-      result = RubyProf.profile(&block)
-      # report_the_thing
-      printer = RubyProf::FlatPrinter.new(result)
-      printer.print($stdout, min_percent: 1.0)
-      io.puts
-    end
-
-  end
-end

data/lib/d_heap/benchmarks/rspec_matchers.rb

@@ -1,352 +0,0 @@
-# frozen_string_literal: true
-
-require "d_heap/benchmarks"
-
-module DHeap::Benchmarks
-
-  # Profiles different implementations with different sizes
-  module RSpecMatchers # rubocop:disable Metrics/ModuleLength
-    extend RSpec::Matchers::DSL
-
-    # Assert ips (iterations per second):
-    #
-    #     expect { ... }.to perform_at_least(1_000_000).ips
-    #        .running_at_least(10).times             # optional, defaults to  1
-    #        .running_at_least(10).seconds           # optional, defaults to  1s
-    #        .running_at_most(10_000_000).times      # optional, defaults to nil
-    #        .running_at_most(2).seconds             # optional, defaults to  2s
-    #        .warmup_at_most(1000).times             # optional, defaults to  1k
-    #        .warmup_at_most(0.100).seconds          # optional, defaults to  0.1s
-    #        .iterations_per_round                   # optional, defaults to  1
-    #        .and_at_least(1.1).times.faster_than { ... } # can also compare
-    #
-    # Assert comparison (and optionally runtime or ips):
-    #
-    #     expect { ... }.to perform_at_least(2.5).times_faster_than { ... }
-    #        .running_at_least(10).times             # optional, defaults to  1
-    #        .running_at_least(10).seconds           # optional, defaults to  1s
-    #        .running_at_most(10_000_000).times      # optional, defaults to nil
-    #        .running_at_most(2).seconds             # optional, defaults to  2s
-    #        .warmup_at_most(1000).times             # optional, defaults to  1k
-    #        .warmup_at_most(0.100).seconds          # optional, defaults to  0.1s
-    #        .iterations_per_call                    # optional, defaults to  1
-    #        .and_at_least(100).ips { ... } # can also assert ips
-    #
-    # n.b: Given a known constant number of iterations, run time and ips are both
-    # measuring the same underlying metric.
-    #
-    # rubocop:disable Metrics/BlockLength, Layout/SpaceAroundOperators
-    matcher :perform_at_least do |expected|
-      supports_block_expectations
-
-      %i[
-        is_at_least
-        running_at_most
-        running_at_least
-        warmup_at_most
-      ].each do |type|
-        chain type do |number|
-          reason, value = ___number_reason_and_value___
-          if reason || value
-            raise "Need to handle unit-less number first: %s(%p)" % [reason, value]
-          end
-          @number_for = type
-          @number_val = number
-        end
-      end
-
-      alias_method :and_at_least, :is_at_least
-
-      %i[
-        times
-        seconds
-        milliseconds
-      ].each do |unit|
-        chain unit do
-          reason, value = ___number_reason_and_value___
-          raise "No number was specified" unless reason && value
-          apply_number_to_reason(reason, value, unit)
-          @number_for = @number_val = nil
-        end
-      end
-
-      # TODO: let IPS set time to run instead of iterations to run
-      chain :ips do
-        reason, value = ___number_reason_and_value___
-        raise "'ips' unit is only for assertions" unless reason == :is_at_least
-        raise "Already asserting %s ips" % [@expect_ips] if @expect_ips
-        raise "'ips' assertion has already been made" if @expect_ips
-        raise "Unknown assertion count" unless value
-        @expect_ips = Integer(value)
-        @number_for = @number_val = nil
-      end
-
-      # need to use method because "chain" can't take a block
-      def times_faster_than(&other)
-        reason, value = ___number_reason_and_value___
-        raise "'times_faster_than' is only for assertions" unless reason == :is_at_least
-        raise "Already asserting %sx comparison" % [@expect_cmp] if @expect_cmp
-        raise ArgumentError, "must provide a proc" unless other
-        @expect_cmp = Float(value)
-        @cmp_proc = other
-        @number_for = @number_val = nil
-        self
-      end
-
-      chain :loudly  do @volume = :loud  end
-      chain :quietly do @volume = :quiet end
-      chain :volume do |volume|
-        raise "Invalid volume" unless %i[loud quiet].include?(volume)
-        @volume = volume
-      end
-
-      chain :iterations_per_round do |iterations|
-        if @iterations_per_round
-          raise "Already set iterations per round (%p)" [@iterations_per_round]
-        end
-        @iterations_per_round = Integer(iterations)
-      end
-
-      match do |actual|
-        require "benchmark"
-        raise "Need to expect a proc or block" unless actual.respond_to?(:to_proc)
-        raise "Need a performance assertion" unless assertion?
-        @actual_proc = actual
-        prepare_for_measurement
-        if @max_iter && (@max_iter % @iterations_per_round) != 0
-          raise "Iterations per round (%p) must divide evenly by max iterations (%p)" % [
-            @iterations_per_round, @max_iter,
-          ]
-        end
-        run_measurements
-        cmp_okay? && ips_okay?
-      end
-
-      description do
-        [
-          @expect_cmp && cmp_okay_msg,
-          @expect_ips && ips_okay_msg,
-        ].join(", and ")
-      end
-
-      failure_message do
-        [
-          cmp_okay? ? nil : "expected to #{cmp_okay_msg} but #{cmp_fail_msg}",  # =>
-          ips_okay? ? nil : "expected to #{ips_okay_msg} but #{ips_fail_msg}",
-        ].compact.join(", and ")
-      end
-
-      private
-
-      chain :__convert_expected_to_ivars__ do
-        @number_val ||= expected
-        @number_for ||= :is_at_least if @number_val
-        expected = nil
-      end
-      private :__convert_expected_to_ivars__
-
-      def ___number_reason_and_value___
-        __convert_expected_to_ivars__
-        [@number_for, @number_val]
-      end
-
-      def apply_number_to_reason(reason, value, unit)
-        normalized_value, normalized_unit = normalize_unit(unit)
-        case reason
-        when :running_at_most;  apply_max_run normalized_value, normalized_unit
-        when :running_at_least; apply_min_run normalized_value, normalized_unit
-        when :warmup_at_most;   apply_warmup  normalized_value, normalized_unit
-        else raise "%s is incompatible with %s(%p)" % [unit, reason, value]
-        end
-      end
-
-      def normalize_unit(unit)
-        case unit
-        when :seconds;      [Float(@number_val),          :seconds]
-        when :milliseconds; [Float(@number_val) / 1000.0, :seconds]
-        when :times;        [Integer(@number_val),        :times]
-        else raise "Invalid unit %s for %s(%p)" % [unit, reason, value]
-        end
-      end
-
-      def apply_min_run(value, unit)
-        case unit
-        when :seconds; @min_time = value
-        when :times;   @min_iter = value
-        end
-      end
-
-      def apply_max_run(value, unit)
-        case unit
-        when :seconds; @max_time = value
-        when :times;   @max_iter = value
-        end
-      end
-
-      def apply_warmup(value, unit)
-        case unit
-        when :seconds; @warmup_time = value
-        when :times;   @warmup_iter = value
-        end
-      end
-
-      def prepare_for_measurement
-        @volume               ||= ENV.fetch("RSPEC_BENCHMARK_VOLUME", :quiet).to_sym
-        @max_time             ||= 2
-        @min_time             ||= 1
-        @min_iter             ||= 1
-        @warmup_time          ||= 0.100
-        @warmup_iter          ||= 1000
-        @iterations_per_round ||= 1
-        nil
-      end
-
-      def run_measurements
-        puts header if loud?
-        warmup
-        take_measurements
-      end
-
-      def header
-        max_rounds = @max_iter && @max_iter / @iterations_per_round
-        [
-          "Warmup time %s, or iterations: %s" % [@min_iter, @max_iter],
-          "Benchmark time (%s..%s) or iterations (%s..%s), max rounds: %p" % [
-            @min_time, @max_time, @min_iter, @max_iter, max_rounds,
-          ],
-          "%-10s %s" % ["", Benchmark::CAPTION],
-        ].join("\n")
-      end
-
-      def warmup
-        return unless 0 < @warmup_time && 0 < @warmup_iter # rubocop:disable Style/NumericPredicate
-        args = [@warmup_iter, 0, @warmup_time, 1, @warmup_iter]
-        measure("warmup",     *args, &@actual_proc)
-        measure("warmup cmp", *args, &@cmp_proc) if @cmp_proc
-      end
-
-      def take_measurements
-        args = [@iterations_per_round, @min_time, @max_time, @min_iter, @max_iter]
-        @actual_tms = measure("actual", *args, &@actual_proc)
-        @cmp_tms    = measure("cmp",    *args, &@cmp_proc) if @cmp_proc
-        return unless @cmp_proc
-        # how many times faster?
-        @actual_cmp = @actual_tms.ips_real / @cmp_tms.ips_real
-        puts "Ran %0.3fx as fast as comparison" % [@actual_cmp] if loud?
-      end
-
-      def loud?; @volume == :loud end
-
-      def assertion?; !!(@expect_cmp || @expect_ips) end
-
-      def cmp_okay?; !@expect_cmp || @expect_cmp < @actual_cmp end
-      def ips_okay?; !@expect_tms || @expect_tms.ips < @actual_tms.ips end
-
-      def measure(name, ipr, *args)
-        measurements = TmsMeasurements.new(name, ipr, *args)
-        measurements.max_rounds.times do
-          # GC.start(full_mark: true, immediate_sweep: true)
-          # GC.compact
-          measurements << Benchmark.measure do
-            yield ipr
-          end
-          # p measurements.real
-          break if measurements.max_time < measurements.real
-        end
-        log_measurement(name, measurements)
-        measurements
-      end
-
-      # rubocop:disable Metrics/AbcSize
-      def units_str(num)
-        if    num >= 10**12; "%7.3fT" % [num.to_f / 10**12]
-        elsif num >= 10** 9; "%7.3fB" % [num.to_f / 10** 9]
-        elsif num >= 10** 6; "%7.3fM" % [num.to_f / 10** 6]
-        elsif num >= 10** 3; "%7.3fk" % [num.to_f / 10** 3]
-        else                 "%7.3f" % [num.to_f]
-        end
-      end
-      # rubocop:enable Metrics/AbcSize
-
-      def log_measurement(name, measurements)
-        return unless loud?
-        puts "%-10s %s => %s ips (%d rounds)" % [
-          name,
-          measurements.tms.to_s.rstrip,
-          units_str(measurements.ips_real),
-          measurements.size,
-        ]
-      end
-
-      def cmp_okay_msg; "run %0.2fx faster"          % [@expect_cmp] end
-      def cmp_fail_msg; "was only %0.2fx as fast"    % [@actual_cmp] end
-      def ips_okay_msg; "run with %s ips"            % [units_str(@expect_ips)] end
-      def ips_fail_msg; "was only %s ips"            % [units_str(@actual_ips)] end
-
-    end
-    # rubocop:enable Metrics/BlockLength, Layout/SpaceAroundOperators
-
-    alias_matcher :perform_with, :perform
-
-  end
-
-  # Replicates a subset of the functionality in benchmark-ips
-  #
-  # TODO: merge this with benchmark-ips
-  # TODO: implement (or remove) min_time, min_iter
-  class TmsMeasurements
-    attr_reader :iterations_per_entry
-    attr_reader :iterations
-
-    attr_reader :min_time
-    attr_reader :max_time
-
-    attr_reader :min_iter
-    attr_reader :max_iter
-
-    def initialize(name, ipe, min_time, max_time, min_iter, max_iter) # rubocop:disable Metrics/ParameterLists
-      @name = name
-      @iterations_per_entry = Integer(ipe)
-      @min_time = Float(min_time)
-      @max_time = Float(max_time)
-      @min_iter = Integer(min_iter)
-      @max_iter = Integer(max_iter)
-      @entries = []
-      @sum = Benchmark::Tms.new
-      @iterations = 0
-    end
-
-    def size; entries.size end
-
-    def <<(tms)
-      raise TypeError, "not a #{Benchmark::Tms}" unless tms.is_a?(Benchmark::Tms)
-      raise IndexError, "full" if @max_iter <= size
-      @sum += tms
-      @iterations += @iterations_per_entry
-      @entries << tms
-      self
-    end
-
-    def sum; @sum.dup end
-    alias tms sum
-
-    def entries; @entries.dup end
-
-    def cstime; @sum.cstime end
-    def cutime; @sum.cutime end
-    def real;   @sum.real   end
-    def stime;  @sum.stime  end
-    def total;  @sum.total  end
-    def utime;  @sum.utime  end
-
-    def ips_real;  @iterations / real  end
-    def ips_total; @iterations / total end
-    def ips_utime; @iterations / utime end
-
-    def max_rounds
-      @max_iter && @max_iter / @iterations_per_entry
-    end
-
-  end
-
-end