d_heap 0.1.0 → 0.4.0

data/ext/d_heap/d_heap.h

@@ -3,31 +3,42 @@
 
 #include "ruby.h"
 
-// This is somewhat a arbitary boundary, but it is highly unlikely that the
-// gains from fewer levels can outweight doing this many comparisons per level.
-// Since the comparisons will still be executed using <=> on ruby objects, it's
-// likely they will be too slow to make any d > 8 worthwhile.
-#define DHEAP_MAX_D 128
+// d=4 uses the fewest comparisons for insert + delete-min (in the worst case).
 #define DHEAP_DEFAULT_D 4
 
-#define CMP_LT(a, b) \
-    (rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b) < 0)
-#define CMP_LTE(a, b) \
-    (rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b) <= 0)
-#define CMP_GT(a, b) \
-    (rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b) > 0)
-#define CMP_GTE(a, b) \
-    (rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b) >= 0)
+// This is a somewhat arbitary maximum. But benefits from more leaf nodes
+// are very unlikely to outweigh the increasinly higher number of worst-case
+// 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;
-ID id_cmp;
 
-#define puts(v) { \
+// copied from pg gem
+
+#define UNUSED(x) ((void)(x))
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+#define dheap_compact_callback(x) ((void (*)(void*))(x))
+#define dheap_gc_location(x) x = rb_gc_location(x)
+#else
+#define rb_gc_mark_movable(x) rb_gc_mark(x)
+#define dheap_compact_callback(x) {(x)}
+#define dheap_gc_location(x) UNUSED(x)
+#endif
+
+#ifdef __D_HEAP_DEBUG
+#define debug(v) { \
     ID sym_puts = rb_intern("puts"); \
     rb_funcall(rb_mKernel, sym_puts, 1, v); \
 }
-
-VALUE dheap_ary_sift_up(VALUE heap_array, int d, long sift_idx);
-VALUE dheap_ary_sift_down(VALUE heap_array, int d, long sift_idx);
+#else
+#define debug(v)
+#endif
 
 #endif /* D_HEAP_H */

data/ext/d_heap/extconf.rb

@@ -1,3 +1,16 @@
+# frozen_string_literal: true
+
 require "mkmf"
 
+# 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

@@ -1,38 +1,24 @@
+# frozen_string_literal: true
+
 require "d_heap/d_heap"
 require "d_heap/version"
 
+# A fast _d_-ary heap implementation for ruby, useful in priority queues and graph
+# algorithms.
+#
+# The _d_-ary heap data structure is a generalization of the binary heap, in which
+# the nodes have _d_ children instead of 2.  This allows for "decrease priority"
+# operations to be performed more quickly with the tradeoff of slower delete
+# minimum.  Additionally, _d_-ary heaps can have better memory cache behavior than
+# binary heaps, allowing them to run more quickly in practice despite slower
+# worst-case time complexity.
+#
 class DHeap
-
-  def initialize_dup(other)
-    super
-    _ary_.replace(_ary_.dup)
-  end
-
-  def freeze
-    _ary_.freeze
-    super
-  end
-
-  def peek
-    _ary_[0]
-  end
-
-  def empty?
-    _ary_.empty?
-  end
-
-  def size
-    _ary_.size
-  end
-
-  def each_in_order
-    return to_enum(__method__) unless block_given?
-    heap = dup
-    yield val until heap.emptu?
-  end
-
-  def to_a
-    _ary_.dup
+  # 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