min_max 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48b9b64396908ffd54a712e8a8e9b4eb6546e0538a6c168a69d67304dc6fcf1d
-  data.tar.gz: 487b79da6a3a3f99ab408af1feb17ebe33c21c08b7c64b9e20e5b259bcf764bf
+  metadata.gz: 012d1e5c570db138f41f8ac8556dde89598878d15fc9176a7006bdd33e5deaf5
+  data.tar.gz: 70a8c3a7bb6afdaf23260ccd56c87acd1bd85e49d40d9231fbb316bf6beb4917
 SHA512:
-  metadata.gz: '086026e3dfe0851390e4090e700aed60a27eaaf70ae53beb9a50164fd78a024797513994b2bd3c67995b29a655c6c8ca755b19ff42797e12190fae9bac10f4c6'
-  data.tar.gz: b7cebaf1da79607d638628c1ef2d54ff11126902e9c1072d4c2bfd1db883db662d323c9e760134c76941747f447494141122e2a4dad6dd0ddc9a65682bfcfd9f
+  metadata.gz: bc3d399e2eae53e244c0bb3a5d502cf725e3b4d4b0d941e1c96d9f0ceeee367a4688ec191116c75d94bed5bbc4470c59626e53da13c85afb24fd44df1f6668bc
+  data.tar.gz: d98bef37722feef1534e85f709f95dcaf314dc5f9013b32e10d667c653b97c3274e8f210fa42d2fdeb6f1fdb63c9f4a62da2d1cfd44ae2178b1439d79c56e8a8

data/Cargo.lock

@@ -270,9 +270,9 @@ checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
 
 [[package]]
 name = "shlex"
-version = "1.1.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "syn"

data/Cargo.toml

@@ -8,5 +8,6 @@ resolver = "2"
 
 [profile.release]
 opt-level = 3
-lto = "fat"
+lto = "thin"
 codegen-units = 1
+strip = "debuginfo"

data/README.md

@@ -24,10 +24,6 @@ Add this line to your application's Gemfile:
 
 ```ruby
 gem 'min_max'
-
-# or manually specify target . E.g.
-
-CARGO_BUILD_TARGET=x86_64-apple-darwin gem install min_max
 ```
 
 
@@ -40,6 +36,10 @@ bundle install
 Or install it yourself as:
 ```bash
 gem install min_max
+
+# or manually specify target . E.g.
+
+CARGO_BUILD_TARGET=x86_64-apple-darwin gem install min_max
 ```
 
 ## Usage
@@ -100,3 +100,14 @@ heap.count(item)
 heap.contains?(item)
 ```
 
+## Performance
+You can run the `benchmarks/benchmarks.rb` file inside this repository for comparison to other popular heap libraries:
+* [rb_heap](https://github.com/florian/rb_heap)
+* [algorithms](https://github.com/kanwei/algorithms)
+* [ruby-heap](https://github.com/general-CbIC/ruby-heap)
+* [pqueue](https://github.com/rubyworks/pqueue)
+
+min-max should be the fastest to pop from a large heap, often by a significant margin, while also offering both min and max operations from a single heap.
+Some options are faster at pushing individual items, but the difference is within the same order of magnitude.
+Batch pushing to min-max also significantly increases insert speed.
+

data/benchmarks/benchmarks.rb

@@ -0,0 +1,85 @@
+require "bundler/setup"
+require "min_max"
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'rb_heap'
+  gem 'algorithms'
+  gem 'ruby-heap'
+  gem 'pqueue'
+end
+
+require 'benchmark'
+require 'rb_heap'
+require 'min_max'
+
+
+data = 100_000.times.map{ Random.rand(0...1000_000_000) }
+rb_hp = Heap.new(:<)
+mm_hp = MinMax[]
+
+Benchmark.bm do |x|
+  x.report("push_rb_heap"){ data.each{|d| rb_hp.add(d) } }
+  x.report("push_mm_heap"){ data.each{|d| mm_hp.push(d) } }
+  x.report("push_mm_heap_batches"){ mm_hp = MinMax[]; data.each_slice(1000){|d| mm_hp.push(*d) } }
+end
+
+Benchmark.bm do |x|
+  x.report("pop_rb_heap"){ 100_000.times{|d| rb_hp.pop } }
+  x.report("pop_mm_heap"){ 100_000.times{|d| mm_hp.pop_min } }
+  x.report("pop_mm_heap_batches"){ 1000.times{|d| mm_hp.pop_min(100) } }
+end
+
+Object.send(:remove_const, :Heap)
+
+require 'Heap'
+puts "# ruby-heap vs min_max"
+ruby_hp = Heap::BinaryHeap::MinHeap.new
+mm_hp = MinMax[]
+
+Benchmark.bm do |x|
+  x.report("push_ruby_heap"){ data.each{|d| ruby_hp.add(d) } }
+  x.report("push_mm_heap"){ data.each{|d| mm_hp.push(d) } }
+  x.report("push_mm_heap_batches"){ mm_hp = MinMax[]; data.each_slice(1000){|d| mm_hp.push(*d) } }
+end
+
+Benchmark.bm do |x|
+  x.report("pop_ruby_heap"){ 100_000.times{|d| ruby_hp.extract_min! } }
+  x.report("pop_mm_heap"){ 100_000.times{|d| mm_hp.pop_min } }
+  x.report("pop_mm_heap_batches"){ 1000.times{|d| mm_hp.pop_min(100) } }
+end
+
+
+require 'algorithms'
+minheap = Containers::MinHeap.new()
+mm_hp = MinMax[]
+
+Benchmark.bm do |x|
+  x.report("push_algos_heap"){ data.each{|d| minheap.push(d) } }
+  x.report("push_mm_heap"){ data.each{|d| mm_hp.push(d) } }
+  x.report("push_mm_heap_batches"){ mm_hp = MinMax[]; data.each_slice(1000){|d| mm_hp.push(*d) } }
+end
+
+Benchmark.bm do |x|
+  x.report("pop_algos_heap"){ 100_000.times{|d| minheap.pop } }
+  x.report("pop_mm_heap"){ 100_000.times{|d| mm_hp.pop_min } }
+  x.report("pop_mm_heap_batches"){ 1000.times{|d| mm_hp.pop_min(100) } }
+end
+
+require 'pqueue'
+pqueue = PQueue.new()
+mm_hp = MinMax[]
+
+Benchmark.bm do |x|
+  x.report("push_pqueue_heap"){ data.each{|d| pqueue.push(d) } }
+  x.report("push_mm_heap"){ data.each{|d| mm_hp.push(d) } }
+  x.report("push_mm_heap_batches"){ mm_hp = MinMax[]; data.each_slice(1000){|d| mm_hp.push(*d) } }
+end
+
+Benchmark.bm do |x|
+  x.report("pop_pqueue_heap"){ 100_000.times{|d| pqueue.pop } }
+  x.report("pop_mm_heap"){ 100_000.times{|d| mm_hp.pop_min } }
+  x.report("pop_mm_heap_batches"){ 1000.times{|d| mm_hp.pop_min(100) } }
+end

data/ext/min_max/src/lib.rs

@@ -52,9 +52,9 @@ impl RubyMinMaxHeap {
 
     fn push(&self, values: RArray) -> Result<(), Error> {
         let mut hp = self.heap.borrow_mut();
-        let values_vec = values.to_vec::<(i64, i64)>().unwrap();
-        values_vec.into_iter().for_each(|(priority, key)| {
-            hp.push(PriorityOrderableValue(priority, key));
+        let values_vec = values.to_vec::<(i64, i64)>()?;
+        values_vec.iter().for_each(|(priority, key)| {
+            hp.push(PriorityOrderableValue(*priority, *key));
         });
         Ok(())
     }

data/lib/min_max/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class MinMax
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

data/lib/min_max.rb

@@ -6,7 +6,7 @@ require_relative "min_max/min_max"
 class MinMax
   class Error < StandardError; end
 
-  attr_reader :priority_blk, :storage, :counts, :mtx
+  attr_reader :priority_blk, :storage
 
   def self.[](*args, &blk)
     new(*args, &blk)
@@ -15,28 +15,25 @@ class MinMax
   def self.new(*args, &blk)
     self._new.tap{|s|
       s.instance_eval{
-        @priority_blk = (blk || proc{|x| (x.respond_to?(:priority) ? x.priority : x.to_i ) rescue 0})
-        @storage = Hash.new
-        @counts = Hash.new(0)
-        @mtx  ||= Mutex.new
+        @priority_blk = (blk || proc{|x| x.respond_to?(:priority) ? x.priority : x.to_i })
+        @storage = Hash.new{|h,k| h[k] = [0, nil] }
       }
       s.push(*args)
     }
   end
 
   def push(*args)
-    mtx.synchronize do
-      mapped = args.map do |a|
-          self.counts[a.hash] += 1
-          self.storage[a.hash] = a
-          [
-            self.priority_blk.call(a),
-            a.hash
-          ]
-      end
-       _push(mapped)
+    mapped = args.map do |a|
+      hash = a.hash
+      entry = self.storage[hash]
+      entry[0] += 1
+      entry[1] ||= a
+      [
+        (self.priority_blk.call(a) rescue 0),
+        hash
+      ]
     end
-    self
+     _push(mapped)
   end
 
   def add(*args)
@@ -44,32 +41,36 @@ class MinMax
   end
 
   def pop_max(*args)
-    mtx.synchronize {
-      popped = _pop_max(*args)
-      popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
-    }
+    popped = _pop_max(*args)
+    popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
   end
 
   def pop_min(*args)
-    mtx.synchronize {
-      popped = _pop_min(*args)
-      popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
-    }
+    popped = _pop_min(*args)
+    popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
   end
 
-  def peek_min(*args)
-    peeked = _peek_min(*args)
-    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  def peek_min
+    retrieve(_peek_min, false)
   end
 
-  def peek_max(*args)
-    peeked = _peek_max(*args)
-    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  def peek_max
+    retrieve(_peek_max, false)
+  end
+
+  def first
+    peek_min
+  end
+
+  def last
+    peek_max
   end
 
   def each(*args, &blk)
     if block_given?
-      mtx.synchronize { _each(*args).map{|p| blk[retrieve(p, false)] } }
+      _each(*args) do |p|
+        blk[retrieve(p, false)]
+      end
     else
       to_enum(:each, *args)
     end
@@ -88,28 +89,22 @@ class MinMax
   end
 
   def to_a_asc
-    mtx.synchronize { _to_a_asc.map{|p| retrieve(p, false) } }
+    _to_a_asc.map{|p| retrieve(p, false) }
   end
 
   def to_a_desc
-    mtx.synchronize { _to_a_desc.map{|p| retrieve(p, false) } }
+    _to_a_desc.map{|p| retrieve(p, false) }
   end
 
   def inspect
-    "MinMax[#{_each.first(10).map{|v| retrieve(v, false).to_s }.join(", ")}#{size > 10 ? ", ..." : ""}]"
+    "MinMax[#{each.first(10).map(&:to_s).join(", ")}#{size > 10 ? ", ..." : ""}]"
   end
 
   private
   def retrieve(hash, remove=true)
-    if remove
-      if (self.counts[hash] -= 1) == 0
-        self.storage.delete(hash)
-      else
-        self.storage[hash]
-      end
-    else
-      self.storage[hash]
-    end
+    entry = self.storage[hash]
+    self.storage.delete(hash) if remove && (entry[0] -= 1) == 0
+    entry[1]
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: min_max
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Wouter Coppieters
@@ -66,6 +66,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/benchmarks.rb
 - ext/min_max/Cargo.toml
 - ext/min_max/extconf.rb
 - ext/min_max/src/lib.rs
@@ -93,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: A min max heap extension for Ruby