digest-murmurhash 1.0.0 → 1.1.0

data/ext/digest/murmurhash/init.h

@@ -0,0 +1,94 @@
+#ifndef MURMURHASH_INCLUDED
+#  define MURMURHASH_INCLUDED
+
+#include "ruby.h"
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER)
+  #define FORCE_INLINE    __forceinline
+  #include <stdlib.h>
+  #define ROTL32(x,y)     _rotl(x,y)
+  #define ROTL64(x,y)     _rotl64(x,y)
+  #define BIG_CONSTANT(x) (x)
+#else   // defined(_MSC_VER)
+  #define FORCE_INLINE inline __attribute__((always_inline))
+  #define ROTL32(x,y)     rotl32(x,y)
+  #define ROTL64(x,y)     rotl64(x,y)
+  #define BIG_CONSTANT(x) (x##LLU)
+#endif // !defined(_MSC_VER)
+
+#ifdef DYNAMIC_ENDIAN
+  /* for universal binary of NEXTSTEP and MacOS X */
+  /* useless since autoconf 2.63? */
+  static int
+  is_bigendian(void)
+  {
+    static int init = 0;
+    static int endian_value;
+    char *p;
+
+    if (init) return endian_value;
+    init = 1;
+    p = (char*)&init;
+    return endian_value = p[0] ? 0 : 1;
+  }
+#  define BIGENDIAN_P() (is_bigendian())
+#elif defined(WORDS_BIGENDIAN)
+#  define BIGENDIAN_P() 1
+#else
+#  define BIGENDIAN_P() 0
+#endif
+
+#define MURMURHASH_MAGIC 0x5bd1e995
+#define MURMURHASH_MAGIC64A BIG_CONSTANT(0xc6a4a7935bd1e995)
+
+void assign_by_endian_32(uint8_t *digest, uint32_t h);
+void assign_by_endian_64(uint8_t *digest, uint64_t h);
+void assign_by_endian_128(uint8_t*, void*);
+
+uint32_t rotl32(uint32_t, int8_t);
+uint64_t rotl64(uint64_t, int8_t);
+uint32_t getblock32(const uint32_t*, int);
+uint64_t getblock64(const uint64_t*, int);
+uint32_t fmix32(uint32_t);
+uint64_t fmix64(uint64_t);
+uint32_t _murmur_finish32(VALUE, uint32_t (*)(const char*, uint32_t, uint32_t));
+uint64_t _murmur_finish64(VALUE, uint64_t (*)(const char*, uint32_t, uint64_t));
+void _murmur_finish128(VALUE, void*, void (*)(const char*, uint32_t, uint32_t, void*));
+uint32_t _murmur_s_digest32(int, VALUE*, VALUE, uint32_t (*)(const char*, uint32_t, uint32_t));
+uint64_t _murmur_s_digest64(int, VALUE*, VALUE, uint64_t (*)(const char*, uint32_t, uint64_t));
+void _murmur_s_digest128(int, VALUE*, VALUE, void*, void (*)(const char*, uint32_t, uint32_t, void*));
+
+VALUE murmur1_finish(VALUE);
+VALUE murmur1_s_digest(int, VALUE*, VALUE);
+VALUE murmur1_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur2_finish(VALUE);
+VALUE murmur2_s_digest(int, VALUE*, VALUE);
+VALUE murmur2_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur2a_finish(VALUE);
+VALUE murmur2a_s_digest(int, VALUE*, VALUE);
+VALUE murmur2a_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur64a_finish(VALUE);
+VALUE murmur64a_s_digest(int, VALUE*, VALUE);
+VALUE murmur64a_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur64b_finish(VALUE);
+VALUE murmur64b_s_digest(int, VALUE*, VALUE);
+VALUE murmur64b_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur_neutral2_finish(VALUE);
+VALUE murmur_neutral2_s_digest(int, VALUE*, VALUE);
+VALUE murmur_neutral2_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur_aligned2_finish(VALUE);
+VALUE murmur_aligned2_s_digest(int, VALUE*, VALUE);
+VALUE murmur_aligned2_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur3_x86_32_finish(VALUE);
+VALUE murmur3_x86_32_s_digest(int, VALUE*, VALUE);
+VALUE murmur3_x86_32_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur3_x86_128_finish(VALUE);
+VALUE murmur3_x86_128_s_digest(int, VALUE*, VALUE);
+VALUE murmur3_x86_128_s_rawdigest(int, VALUE*, VALUE);
+VALUE murmur3_x64_128_finish(VALUE);
+VALUE murmur3_x64_128_s_digest(int, VALUE*, VALUE);
+VALUE murmur3_x64_128_s_rawdigest(int, VALUE*, VALUE);
+
+#endif /* ifndef MURMURHASH_INCLUDED */

data/ext/digest/murmurhash/{murmurhash_neutral2.c → neutral2.c}

@@ -2,7 +2,7 @@
  * MurmurHashNeutral2 (C) Austin Appleby
  */
 
-#include "murmurhash_neutral2.h"
+#include "init.h"
 
 uint32_t
 murmur_hash_process_neutral2(const char * key, uint32_t len, uint32_t seed)
@@ -22,8 +22,8 @@ murmur_hash_process_neutral2(const char * key, uint32_t len, uint32_t seed)
     k |= data[2] << 16;
     k |= data[3] << 24;
 
-    k *= m; 
-    k ^= k >> r; 
+    k *= m;
+    k ^= k >> r;
     k *= m;
 
     h *= m;

data/lib/digest/murmurhash.rb

@@ -1,73 +1,3 @@
-require "digest/simple"
-
-module Digest
-  class MurmurHash < Simple
-    def initialize
-      @seed = self.class::DEFAULT_SEED
-      super
-    end
-
-    def seed
-      @seed
-    end
-
-    def seed=(s)
-      fail ArgumentError, "seed string should #{digest_length * 16} bit chars" if s.bytesize != digest_length
-      @seed = s
-    end
-
-    module Size32
-      DEFAULT_SEED = "\x00\x00\x00\x00".encode('ASCII-8BIT')
-
-      def digest_length
-        4
-      end
-
-      def to_i
-        finish.unpack("I")[0]
-      end
-    end
-
-    module Size64
-      DEFAULT_SEED = "\x00\x00\x00\x00\x00\x00\x00\x00".encode('ASCII-8BIT')
-
-      def digest_length
-        8
-      end
-
-      def to_i
-        finish.unpack("L")[0]
-      end
-    end
-  end
-
-  class MurmurHash1 < MurmurHash
-    include Size32
-  end
-
-  class MurmurHash2 < MurmurHash
-    include Size32
-  end
-
-  class MurmurHash2A < MurmurHash
-    include Size32
-  end
-
-  class MurmurHash64A < MurmurHash
-    include Size64
-  end
-
-  class MurmurHash64B < MurmurHash
-    include Size64
-  end
-
-  class MurmurHashAligned2 < MurmurHash
-    include Size32
-  end
-
-  class MurmurHashNeutral2 < MurmurHash
-    include Size32
-  end
-end
-
-require "digest/murmurhash/murmurhash"
+require "digest"
+require "digest/murmurhash/base"
+require "digest/murmurhash/ext"

data/lib/digest/murmurhash/base.rb

@@ -0,0 +1,58 @@
+module Digest
+  ds = Struct.new(:digest_length, :seed_length)
+  s1 = ds.new(4, 4)
+  s2 = ds.new(8, 8)
+  s3 = ds.new(16, 4)
+  {
+    '1' => s1,
+    '2' => s1,
+    '2A' => s1,
+    '64A' => s2,
+    '64B' => s2,
+    'Aligned2' => s1,
+    'Neutral2' => s1,
+    '3_x86_32' => s1,
+    '3_x86_128' => s3,
+    '3_x64_128' => s3,
+  }.each do |name, s|
+    class_eval %Q{
+      class MurmurHash#{name} < Digest::Class
+        DEFAULT_SEED = "#{"\x00" * s.seed_length}".encode('ASCII-8BIT')
+
+        def initialize
+          @buffer = ""
+          @seed = DEFAULT_SEED
+        end
+
+        def update(str)
+          @buffer += str
+          self
+        end
+        alias << update
+
+        def reset
+          @buffer.clear
+          @seed = DEFAULT_SEED
+          self
+        end
+
+        def seed
+          @seed
+        end
+
+        def seed=(s)
+          fail ArgumentError, "seed string should be #{s.seed_length} length" if #{s.seed_length} != s.length
+          @seed = s
+        end
+
+        def digest_length
+          #{s.digest_length}
+        end
+
+        def block_length
+          0
+        end
+      end
+    }
+  end
+end

data/spec/bench.rb

@@ -3,7 +3,6 @@
 lib = File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require 'digest/stringbuffer'
 require 'digest/murmurhash'
 require 'benchmark'
 
@@ -58,7 +57,6 @@ def murmur_hash str, seed
 end
 
 n = 100000
-times_enum = n.times
 
 a = Array.new(n, 0)
 n.times do |i|
@@ -72,13 +70,16 @@ c = Struct.new "Cases",
                :func
 cases = [
   c.new("pureRuby", proc{|x| murmur_hash x, seed }),
-  c.new("MurmurHash1", proc{|x| Digest::MurmurHash1.rawdigest x, seed_str32 }),
-  c.new("MurmurHash2", proc{|x| Digest::MurmurHash2.rawdigest x, seed_str32 }),
-  c.new("MurmurHash2A", proc{|x| Digest::MurmurHash2A.rawdigest x, seed_str32 }),
-  c.new("MurmurHash64A", proc{|x| Digest::MurmurHash64A.rawdigest x, seed_str64 }),
-  c.new("MurmurHash64B", proc{|x| Digest::MurmurHash64B.rawdigest x, seed_str64 }),
-  c.new("MurmurHashNeutral2", proc{|x| Digest::MurmurHashNeutral2.rawdigest x, seed_str32 }),
-  c.new("MurmurHashAligned2", proc{|x| Digest::MurmurHashAligned2.rawdigest x, seed_str32 }),
+  c.new("MurmurHash1", proc{|x| Digest::MurmurHash1.digest x, seed_str32 }),
+  c.new("MurmurHash2", proc{|x| Digest::MurmurHash2.digest x, seed_str32 }),
+  c.new("MurmurHash2A", proc{|x| Digest::MurmurHash2A.digest x, seed_str32 }),
+  c.new("MurmurHash64A", proc{|x| Digest::MurmurHash64A.digest x, seed_str64 }),
+  c.new("MurmurHash64B", proc{|x| Digest::MurmurHash64B.digest x, seed_str64 }),
+  c.new("MurmurHashNeutral2", proc{|x| Digest::MurmurHashNeutral2.digest x, seed_str32 }),
+  c.new("MurmurHashAligned2", proc{|x| Digest::MurmurHashAligned2.digest x, seed_str32 }),
+  c.new("MurmurHash3_x86_32", proc{|x| Digest::MurmurHash3_x86_32.digest x, seed_str32 }),
+  c.new("MurmurHash3_x86_128", proc{|x| Digest::MurmurHash3_x86_128.digest x, seed_str32 }),
+  c.new("MurmurHash3_x64_128", proc{|x| Digest::MurmurHash3_x64_128.digest x, seed_str32 }),
 ]
 reals = {}
 confrict = {}
@@ -94,20 +95,25 @@ puts
 puts "```"
 Benchmark.bm do |x|
   cases.each do |c|
+    i = 0
     z = x.report c.name do
-      times_enum.each do |i|
+      while i < n
         c.func.call(a[i])
+        i += 1
       end
     end
 
     confrict.clear
-    times_enum.each do |i|
+
+    i = 0
+    while i < n
       rethash = c.func.call(a[i])
       if confrict[rethash].nil?
         confrict[rethash] = 0
-      else 
+      else
         confrict[rethash] += 1
       end
+      i += 1
     end
     reals[c.name] = z.real
     confricts[c.name] = confrict.count{|hash, count| 0 < count}

data/spec/digest_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Digest::MurmurHash do
+describe "Digest::MurmurHash" do
   it "seed" do
     all_classes.each do |c|
       m = c.new
@@ -13,7 +13,7 @@ describe Digest::MurmurHash do
       m = c.new
       m.update "murmurhash"
       before_digest = m.hexdigest
-      m.seed = (c::DEFAULT_SEED.length == 4) ? seed32 : seed64
+      m.seed = seed_str(c)
       expect(c::DEFAULT_SEED).not_to eq(m.seed)
       expect(before_digest).not_to eq(m.hexdigest)
     end
@@ -25,45 +25,59 @@ describe Digest::MurmurHash do
     end
   end
 
-  it "digest and hexdigest" do
-    expect(Digest::MurmurHash1.hexdigest("abc")).to eq("dc5f5755")
+  context "static hexdigest" do
+    it { expect(Digest::MurmurHash1.hexdigest("abc")).to eq("dc5f5755") }
+    it { expect(Digest::MurmurHash2.hexdigest("abc")).to eq("9b7c5713") }
+    it { expect(Digest::MurmurHash2A.hexdigest("abc")).to eq("679f5811") }
+    it { expect(Digest::MurmurHash64A.hexdigest("abc")).to eq("fb5ea99834c3c99c") }
+    it { expect(Digest::MurmurHash64B.hexdigest("abc")).to eq("9d595cce51420da6") }
+    it { expect(Digest::MurmurHashAligned2.hexdigest("abc")).to eq("9b7c5713") }
+    it { expect(Digest::MurmurHashNeutral2.hexdigest("abc")).to eq("9b7c5713") }
+    it { expect(Digest::MurmurHash3_x86_32.hexdigest("abc")).to eq("fa93ddb3") }
+    it { expect(Digest::MurmurHash3_x86_128.hexdigest("abc")).to eq("a506b0a2a506b0a2a506b0a2d1c6cd75") }
+    it { expect(Digest::MurmurHash3_x64_128.hexdigest("abc")).to eq("4174a23b522dca263f3f96b46778ad3f") }
+  end
+
+  context "digest and hexdigest" do
     all_classes.each do |c|
       [:digest, :hexdigest].each do |method|
         str = "a" * 1024
         d = c.send(method, str)
-        d2 = c.send(method, str, (c::DEFAULT_SEED.length == 4) ? seed32 : seed64)
-        expect(d).to be_a_kind_of(String)
-        expect(d2).to be_a_kind_of(String)
-        expect(d.length).to be > 0
-        expect(d2.length).to be > 0
-        expect(d != d2).to be_truthy
+        d2 = c.send(method, str, seed_str(c))
+        it ("#{c}##{method}") do
+          expect(d).to be_a_kind_of(String)
+          expect(d2).to be_a_kind_of(String)
+          expect(d.length).to be > 0
+          expect(d2.length).to be > 0
+          expect(d != d2).to be_truthy
+        end
       end
     end
   end
 
-  it "rawdigest" do
+  describe "rawdigest" do
     all_classes.each do |c|
       str = "a" * 1024
+      seed = seed_str(c)
       d = c.rawdigest str
-      d2 = c.rawdigest str, (c::DEFAULT_SEED.length == 4) ? seed32 : seed64
-      expect(d).to be_a_kind_of(Integer)
-      expect(d2).to be_a_kind_of(Integer)
-      expect(d).to be > 0
-      expect(d2).to be > 0
-      expect(d != d2).to be_truthy
+      d2 = c.rawdigest str, seed
+      it(c) do
+        expect(d != d2).to be_truthy
+      end
     end
   end
 
-  it "update and reset and hexdigest(32bit)" do
+  describe "update and reset and hexdigest" do
     all_classes.each do |c|
       murmur = c.new
       murmur.update("m").update("u").update("r")
       murmur << "m" << "u" << "r"
       murmur << "hash"
       hex = murmur.hexdigest
-      expect(murmur.hexdigest! == hex).to be true
-      reset_str = "0" * ((c::DEFAULT_SEED.length == 4) ? 8 : 16)
-      expect(murmur.hexdigest).to eq(reset_str)
+      it(c) do
+        expect(murmur.hexdigest! == hex).to be true
+        expect(murmur.hexdigest).to eq("0" * (murmur.digest_length*2))
+      end
     end
   end
 
@@ -89,15 +103,13 @@ describe Digest::MurmurHash do
     end
   end
 
-  it "length" do
-    all_classes.each do |c|
-      expect(c.new.length == c::DEFAULT_SEED.length).to be_truthy
-    end
-  end
-
-  it "to_i" do
+  it "reset" do
     all_classes.each do |c|
-      expect(c.new.update("murmurhash").to_i).to be_a_kind_of(Integer)
+      m1 = c.new
+      m2 = c.new
+      m1.update("murmurhash")
+      m1.seed = seed_str(c)
+      expect(m1.reset).to eq(m2)
     end
   end
 end

data/spec/exception_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MurmurHash do
+describe "Digest::MurmurHash" do
   it "update nil" do
     all_classes.each do |c|
       murmur = c.new
@@ -14,22 +14,27 @@ describe MurmurHash do
     end
   end
 
-  it "seed digest" do
+  describe "seed digest" do
     all_classes.each do |c|
-      expect{ c.digest "", ""}.to raise_error(ArgumentError)
-      expect{ c.digest "", "\x00" }.to raise_error(ArgumentError)
-      seed = (c::DEFAULT_SEED.bytesize == 4) ? seed32 : seed64
-      expect{ c.digest "", seed }.to_not raise_error
+      it (c) do
+        expect{ c.digest "", ""}.to raise_error(ArgumentError)
+        expect{ c.digest "", "\x00" * (c::DEFAULT_SEED.length  )}.to_not raise_error
+        expect{ c.digest "", "\x00" * (c::DEFAULT_SEED.length+1)}.to raise_error(ArgumentError)
+        expect{ c.digest "", seed_str(c) }.to_not raise_error
+      end
     end
   end
 
-  it "seed instance" do
+  describe "seed instance" do
     all_classes.each do |c|
-      murmur = c.new
-      expect{ murmur.seed = "" }.to raise_error(ArgumentError)
-      expect{ murmur.seed = "\x00" }.to raise_error(ArgumentError)
-      seed = (c::DEFAULT_SEED.bytesize == 4) ? seed32 : seed64
-      expect{ murmur.seed = seed }.to_not raise_error
+      it (c) do
+        murmur = c.new
+        expect{ murmur.seed = "" }.to raise_error(ArgumentError)
+        expect{ murmur.seed = "\x00" * (c::DEFAULT_SEED.length  ) }.to_not raise_error
+        expect{ murmur.seed = "\x00" * (c::DEFAULT_SEED.length+1) }.to raise_error(ArgumentError)
+        seed = seed_str(c)
+        expect{ murmur.seed = seed }.to_not raise_error
+      end
     end
   end
 end