d_heap 0.2.0 → 0.5.0

data/ext/d_heap/d_heap.h

@@ -11,64 +11,40 @@
 // comparisons as d gets further from 4.
 #define DHEAP_MAX_D 32
 
+typedef long double SCORE;
 
-#define CMP_LT(a, b, cmp_opt) \
-    (OPTIMIZED_CMP(a, b, cmp_opt) < 0)
-#define CMP_LTE(a, b, cmp_opt) \
-    (OPTIMIZED_CMP(a, b, cmp_opt) <= 0)
-#define CMP_GT(a, b, cmp_opt) \
-    (OPTIMIZED_CMP(a, b, cmp_opt) > 0)
-#define CMP_GTE(a, b, cmp_opt) \
-    (OPTIMIZED_CMP(a, b, cmp_opt) >= 0)
+typedef struct dheap_entry {
+    SCORE score;
+    VALUE value;
+} ENTRY;
 
-VALUE rb_cDHeap;
-ID id_cmp;
-
-// from internal/numeric.h
-#ifndef INTERNAL_NUMERIC_H
-int rb_float_cmp(VALUE x, VALUE y);
-#endif /* INTERNAL_NUMERIC_H */
+#define DHEAP_DEFAULT_SIZE 256
+#define DHEAP_MAX_SIZE (LONG_MAX / (int)sizeof(ENTRY))
 
-// from internal/compar.h
-#ifndef INTERNAL_COMPAR_H
-#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
+#define DHEAP_CAPA_INCR_MAX (10 * 1024 * 1024 / (int)sizeof(ENTRY))
 
-enum {
-    cmp_opt_Integer,
-    cmp_opt_String,
-    cmp_opt_Float,
-    cmp_optimizable_count
-};
+VALUE rb_cDHeap;
 
-struct cmp_opt_data {
-    unsigned int opt_methods;
-    unsigned int opt_inited;
-};
+// copied from pg gem
 
-#define NEW_CMP_OPT_MEMO(type, value) \
-    NEW_PARTIAL_MEMO_FOR(type, value, cmp_opt)
-#define CMP_OPTIMIZABLE_BIT(type) (1U << TOKEN_PASTE(cmp_opt_,type))
-#define CMP_OPTIMIZABLE(data, type) \
-    (((data).opt_inited & CMP_OPTIMIZABLE_BIT(type)) ? \
-     ((data).opt_methods & CMP_OPTIMIZABLE_BIT(type)) : \
-     (((data).opt_inited |= CMP_OPTIMIZABLE_BIT(type)), \
-      rb_method_basic_definition_p(TOKEN_PASTE(rb_c,type), id_cmp) && \
-      ((data).opt_methods |= CMP_OPTIMIZABLE_BIT(type))))
+#define UNUSED(x) ((void)(x))
 
-#define OPTIMIZED_CMP(a, b, data) \
-    ((FIXNUM_P(a) && FIXNUM_P(b) && CMP_OPTIMIZABLE(data, Integer)) ? \
-     (((long)a > (long)b) ? 1 : ((long)a < (long)b) ? -1 : 0) : \
-     (STRING_P(a) && STRING_P(b) && CMP_OPTIMIZABLE(data, String)) ? \
-     rb_str_cmp(a, b) : \
-     (RB_FLOAT_TYPE_P(a) && RB_FLOAT_TYPE_P(b) && CMP_OPTIMIZABLE(data, Float)) ? \
-     rb_float_cmp(a, b) : \
-     rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b))
+#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
 
-#define puts(v) { \
+#ifdef __D_HEAP_DEBUG
+#define debug(v) { \
     ID sym_puts = rb_intern("puts"); \
     rb_funcall(rb_mKernel, sym_puts, 1, v); \
 }
-
-#endif /* INTERNAL_COMPAR_H */
+#else
+#define debug(v)
+#endif
 
 #endif /* D_HEAP_H */

data/ext/d_heap/extconf.rb

@@ -1,3 +1,23 @@
+# 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
+# $CFLAGS << " -debug inline-debug-info "
+# $CFLAGS << " -g -ginline-points "
+# $CFLAGS << " -fno-omit-frame-pointer "
+
+# CONFIG["debugflags"] << " -ggdb3 -gstatement-frontiers -ginline-points "
+CONFIG["optflags"]  << " -O3 "
+CONFIG["optflags"]  << " -fno-omit-frame-pointer "
+CONFIG["warnflags"] << " -Werror"
+
+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")
+
 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,10 +1,48 @@
+# 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
+  alias deq       pop
+  alias enq       push
+  alias first     peek
+  alias pop_below pop_lt
+
+  alias length    size
+  alias count     size
+
+  # ruby 3.0+ (2.x can just use inherited initialize_clone)
+  if Object.instance_method(:initialize_clone).arity == -1
+    # @!visibility private
+    def initialize_clone(other, freeze: nil)
+      __init_clone__(other, freeze ? true : freeze)
+    end
+  end
 
-  def initialize_copy(other)
-    raise NotImplementedError, "initialize_copy should deep copy array"
+  # Consumes the heap by popping each minumum value until it is empty.
+  #
+  # If you want to iterate over the heap without consuming it, you will need to
+  # first call +#dup+
+  #
+  # @yieldparam value [Object] each value that would be popped
+  #
+  # @return [Enumerator] if no block is given
+  # @return [nil] if a block is given
+  def each_pop
+    return to_enum(__method__) unless block_given?
+    yield pop until empty?
+    nil
   end
 
 end

data/lib/d_heap/benchmarks.rb

@@ -0,0 +1,112 @@
+# 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, clear: false)
+    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.clear if clear
+    queue
+  end
+
+  # rubocop:enable Style/NumericPredicate
+
+  require "d_heap/benchmarks/implementations"
+
+end

data/lib/d_heap/benchmarks/benchmarker.rb

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