d_heap 0.3.0 → 0.4.0

data/ext/d_heap/d_heap.h

@@ -11,6 +11,12 @@
 // comparisons as d gets further from 4.
 #define DHEAP_MAX_D 32
 
+#define DHEAP_DEFAULT_SIZE 16
+#define DHEAP_MAX_SIZE (LONG_MAX / (int)sizeof(long double))
+
+// 10MB
+#define DHEAP_CAPA_INCR_MAX (10 * 1024 * 1024 / (int)sizeof(long double))
+
 VALUE rb_cDHeap;
 
 // copied from pg gem
@@ -26,9 +32,6 @@ VALUE rb_cDHeap;
 #define dheap_gc_location(x) UNUSED(x)
 #endif
 
-// from internal/compar.h
-#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
-
 #ifdef __D_HEAP_DEBUG
 #define debug(v) { \
     ID sym_puts = rb_intern("puts"); \

data/ext/d_heap/extconf.rb

@@ -2,10 +2,15 @@
 
 require "mkmf"
 
-# if /darwin/ =~ RUBY_PLATFORM
-#   $CFLAGS << " -D__D_HEAP_DEBUG"
-# end
+# For testing in CI (because I don't otherwise have easy access to Mac OS):
+# $CFLAGS << " -D__D_HEAP_DEBUG" if /darwin/ =~ RUBY_PLATFORM
 
 have_func "rb_gc_mark_movable" # since ruby-2.7
 
+check_sizeof("long")
+check_sizeof("unsigned long long")
+check_sizeof("long double")
+have_macro("LDBL_MANT_DIG", "float.h")
+
+CONFIG["warnflags"] << " -Werror"
 create_makefile("d_heap/d_heap")

data/lib/benchmark_driver/runner/ips_zero_fail.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "English" # $CHILD_STATUS
+require "timeout" # Timeout::Error
+
+require "benchmark_driver"
+
+# monkey-patch to convert miniscule values to 0.0
+class BenchmarkDriver::Output::Compare
+
+  # monkey-patch to convert miniscule values to 0.0
+  module MinisculeToZero
+
+    def humanize(value, width = 10)
+      value <= 0.0.next_float.next_float ? 0.0 : super(value, width)
+    end
+
+  end
+
+  prepend MinisculeToZero
+
+end
+
+# A simple patch to let slow specs error out without
+class BenchmarkDriver::Runner::IpsZeroFail < BenchmarkDriver::Runner::Ips
+  METRIC = BenchmarkDriver::Runner::Ips::METRIC
+
+  # always run at least once
+  class Job < BenchmarkDriver::DefaultJob
+    attr_accessor :warmup_value, :warmup_duration, :warmup_loop_count
+
+  end
+
+  # BenchmarkDriver::Runner looks for this class
+  JobParser = BenchmarkDriver::DefaultJobParser.for(klass: Job, metrics: [METRIC])
+
+  # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/BlockLength, Layout/LineLength, Layout/SpaceInsideBlockBraces, Style/BlockDelimiters
+
+  # This method is dynamically called by `BenchmarkDriver::JobRunner.run`
+  # @param [Array<BenchmarkDriver::Default::Job>] jobs
+  def run(jobs)
+    if jobs.any? { |job| job.loop_count.nil? }
+      @output.with_warmup do
+        jobs = jobs.map do |job|
+          next job if job.loop_count # skip warmup if loop_count is set
+
+          @output.with_job(name: job.name) do
+            context = job.runnable_contexts(@contexts).first
+            duration, loop_count = run_warmup(job, context: context)
+            value, duration = value_duration(duration: duration, loop_count: loop_count)
+
+            @output.with_context(name: context.name, executable: context.executable, gems: context.gems, prelude: context.prelude) do
+              @output.report(values: { metric => value }, duration: duration, loop_count: loop_count)
+            end
+
+            warmup_loop_count = loop_count
+
+            loop_count = (loop_count.to_f * @config.run_duration / duration).floor
+            Job.new(**job.to_h.merge(loop_count: loop_count))
+              .tap {|j| j.warmup_value      = value }
+              .tap {|j| j.warmup_duration   = duration }
+              .tap {|j| j.warmup_loop_count = warmup_loop_count }
+          end
+        end
+          .compact
+      end
+    end
+
+    @output.with_benchmark do
+      jobs.each do |job|
+        @output.with_job(name: job.name) do
+          job.runnable_contexts(@contexts).each do |context|
+            repeat_params = { config: @config, larger_better: true, rest_on_average: :average }
+            result =
+              if job.loop_count&.positive?
+                loop_count = job.loop_count
+                BenchmarkDriver::Repeater.with_repeat(**repeat_params) do
+                  run_benchmark(job, context: context)
+                end
+              else
+                loop_count = job.warmup_loop_count
+                repeater_value = [job.warmup_value, job.warmup_duration]
+                BenchmarkDriver::Repeater::RepeatResult.new(
+                  value: repeater_value, all_values: [repeater_value]
+                )
+              end
+            value, duration = result.value
+            @output.with_context(name: context.name, executable: context.executable, gems: context.gems, prelude: context.prelude) do
+              @output.report(
+                values: { metric => value },
+                all_values: { metric => result.all_values },
+                duration: duration,
+                loop_count: loop_count,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/BlockLength, Layout/LineLength, Layout/SpaceInsideBlockBraces, Style/BlockDelimiters
+
+  def run_warmup(job, context:)
+    start = Time.now
+    super(job, context: context)
+  rescue Timeout::Error
+    [Time.now - start, 0.0.next_float]
+  end
+
+  def execute(*args, exception: true)
+    super
+  rescue RuntimeError => ex
+    if args.include?("timeout") && $CHILD_STATUS&.exitstatus == 124
+      raise Timeout::Error, ex.message
+    end
+    raise ex
+  end
+
+end

data/lib/d_heap.rb

@@ -14,9 +14,11 @@ require "d_heap/version"
 # worst-case time complexity.
 #
 class DHeap
-
-  def initialize_copy(other)
-    raise NotImplementedError, "initialize_copy should deep copy array"
+  # ruby 3.0+ (2.x can just use inherited initialize_clone)
+  if Object.instance_method(:initialize_clone).arity == -1
+    def initialize_clone(other, freeze: nil)
+      __init_clone__(other, freeze ? true : freeze)
+    end
   end
 
 end

data/lib/d_heap/benchmarks.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "d_heap"
+require "ostruct"
+
+# Different benchmark scenarios and implementations to benchmark
+module DHeap::Benchmarks
+
+  def self.puts_version_info(type = "Benchmark", io = $stdout)
+    io.puts "#{type} run at %s" % [Time.now]
+    io.puts "ruby v%s, DHeap v%s" % [RUBY_VERSION, DHeap::VERSION]
+    io.puts
+  end
+
+  # rubocop:disable Style/NumericPredicate
+
+  # moves "rand" outside the benchmarked code, to avoid measuring that too.
+  module Randomness
+
+    def default_randomness_size; 1_000_000 end
+
+    def fill_random_vals(target_size = default_randomness_size, io: $stdout)
+      @dheap_bm_random_vals ||= []
+      count = target_size - @dheap_bm_random_vals.length
+      return 0 if count <= 0
+      millions = (count / 1_000_000.0).round(3)
+      io&.puts "~~~~~~ filling @dheap_bm_random_vals with #{millions}M ~~~~~~"
+      io&.flush
+      count.times do @dheap_bm_random_vals << rand(0..10_000) end
+      @dheap_bm_random_len = @dheap_bm_random_vals.length
+      @dheap_bm_random_idx = (((@dheap_bm_random_idx || -1) + 1) % @dheap_bm_random_len)
+      nil
+    end
+
+    def random_val
+      @dheap_bm_random_vals.fetch(
+        @dheap_bm_random_idx = ((@dheap_bm_random_idx + 1) % @dheap_bm_random_len)
+      )
+    end
+
+  end
+
+  # different scenarios to be benchmarked or profiled
+  module Scenarios
+
+    def push_n_multiple_queues(count, *queues)
+      while 0 < count
+        value = @dheap_bm_random_vals.fetch(
+          @dheap_bm_random_idx = ((@dheap_bm_random_idx + 1) % @dheap_bm_random_len)
+        )
+        queues.each do |queue|
+          queue << value
+        end
+        count -= 1
+      end
+    end
+
+    def push_n(queue, count)
+      while 0 < count
+        queue << @dheap_bm_random_vals.fetch(
+          @dheap_bm_random_idx = ((@dheap_bm_random_idx + 1) % @dheap_bm_random_len)
+        )
+        count -= 1
+      end
+    end
+
+    def push_n_then_pop_n(queue, count) # rubocop:disable Metrics/MethodLength
+      i = 0
+      while i < count
+        queue << @dheap_bm_random_vals.fetch(
+          @dheap_bm_random_idx = ((@dheap_bm_random_idx + 1) % @dheap_bm_random_len)
+        )
+        i += 1
+      end
+      while 0 < i
+        queue.pop
+        i -= 1
+      end
+    end
+
+    def repeated_push_pop(queue, count)
+      while 0 < count
+        queue << @dheap_bm_random_vals.fetch(
+          @dheap_bm_random_idx = ((@dheap_bm_random_idx + 1) % @dheap_bm_random_len)
+        )
+        queue.pop
+        count -= 1
+      end
+    end
+
+  end
+
+  include Randomness
+  include Scenarios
+
+  def initq(klass, count = 0)
+    queue = klass.new
+    while 0 < count
+      queue << @dheap_bm_random_vals.fetch(
+        @dheap_bm_random_idx = ((@dheap_bm_random_idx + 1) % @dheap_bm_random_len)
+      )
+      count -= 1
+    end
+    queue
+  end
+
+  # rubocop:enable Style/NumericPredicate
+
+  require "d_heap/benchmarks/implementations"
+
+end

data/lib/d_heap/benchmarks/benchmarker.rb

@@ -0,0 +1,113 @@
+# 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
+        ]
+        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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module DHeap::Benchmarks
+
+  # base class for example priority queues
+  class ExamplePriorityQueue
+    attr_reader :a
+
+    def initialize
+      @a = []
+    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
+  # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+  class RbHeap < ExamplePriorityQueue
+
+    def <<(score)
+      raise ArgumentError unless score
+      @a.push(score)
+      # shift up
+      index = @a.size - 1
+      while 0 < index # rubocop:disable Style/NumericPredicate
+        parent_index = (index - 1) / 2
+        break if @a[parent_index] <= @a[index]
+        @a[index] = @a[parent_index]
+        index = parent_index
+        @a[index] = score
+        # check_heap!(index)
+      end
+      self
+    end
+
+    def pop
+      return if @a.empty?
+      popped = @a.first
+      @a[0] = shifting = @a.last
+      @a.pop
+      # shift down
+      index = 0
+      last_index = @a.size - 1
+      while (child_index = index * 2 + 1) <= last_index
+        # select min child
+        if child_index < last_index && @a[child_index + 1] < @a[child_index]
+          child_index += 1
+        end
+        break if @a[index] <= @a[child_index]
+        @a[index] = @a[child_index]
+        index = child_index
+        @a[index] = shifting
+      end
+      popped
+    end
+
+    private
+
+    def check_heap!(idx, last = @a.size - 1)
+      pscore = @a[idx]
+      child = idx * 2 + 1
+      if child <= last
+        cscore = check_heap!(child)
+        raise "#{pscore} > #{cscore}" if pscore > cscore
+      end
+      child += 1
+      if child <= last
+        check_heap!(child)
+        cscore = check_heap!(child)
+        raise "#{pscore} > #{cscore}" if pscore > cscore
+      end
+      pscore
+    end
+
+  end
+  # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+  # 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: "quaternary DHeap", klass: DHeap).freeze,
+  ].freeze
+
+end