digest-murmurhash 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4bb19a065230c4cf479bbc3e5d30a3ecacaab7e
-  data.tar.gz: 8b6b55cb5d5d3c398e9ac006b5b84359272c034d
+  metadata.gz: cd9a5f608b1cac914b791b811bc75eba224ca841
+  data.tar.gz: ed6533e449b132c385c3457708c52d556d47114d
 SHA512:
-  metadata.gz: 09aa8502b047d0487b5727846236e91c33d06e7db3bfdc89f74ddc71f935d7f672232d3c6e27fc5c588fe6c90fb8d151e7611c356e2c168e216e20822862d07a
-  data.tar.gz: 1b6a03328a0428b3cc5455ca306fcc4d5bab0c5a8609300e9b7dbc774a499b8921d9f5b96b653ec3c72b8fa4d59cec5fcffe09447eac5d84f1c1b5ef4dc92771
+  metadata.gz: 54555dc73a82614b6fe9ba109662e96d4dad18b8e9ed30a073d9cde49d611b256158381d9c61280a9dbe7783e8db4967ccc8de2af9a2a507c71bdca87c99730b
+  data.tar.gz: 4b47b42486c884ddb3edee9b7c4f1ec11529657baf471492e45c113abc6e7dba622a5e7e7cc664480c9790b139fe49942e091c3257f0134635316075f8ce3791

data/README.md

@@ -4,57 +4,97 @@
 
 **MurmurHash** is a algorithm desiged by Austin Appleby.
 
-**Digest::MurmurHash1** use algorithm MurmurHash1(32-bit).
+This library have some classes for MurmurHash algorithm.
 
-**Digest::MurmurHash2** use algorithm MurmurHash2(32-bit).
+- **Digest::MurmurHash1** use algorithm MurmurHash1(32-bit).
 
-**Digest::MurmurHash2A** use algorithm MurmurHash2A(32-bit).
+- **Digest::MurmurHash2** use algorithm MurmurHash2(32-bit).
 
-**Digest::MurmurHash64A** use algorithm MurmurHash64A(64-bit).
+- **Digest::MurmurHash2A** use algorithm MurmurHash2A(32-bit).
 
-**Digest::MurmurHash64B** use algorithm MurmurHash64B(64-bit).
+- **Digest::MurmurHash64A** use algorithm MurmurHash64A(64-bit).
 
-**Digest::MurmurHashNeutral2** use algorithm MurmurHashNeutral2(32-bit).
+- **Digest::MurmurHash64B** use algorithm MurmurHash64B(64-bit).
 
-**Digest::MurmurHashAligned2** use algorithm MurmurHashAligned2(32-bit).
+- **Digest::MurmurHashNeutral2** use algorithm MurmurHashNeutral2(32-bit).
 
-(**Digest::MurmurHash** exist to write only version number)
+- **Digest::MurmurHashAligned2** use algorithm MurmurHashAligned2(32-bit).
+
+- **Digest::MurmurHash3\_x86\_32** use algorithm MurmurHash3 for 32-bit platform (32-bit).
+
+- **Digest::MurmurHash3\_x86\_128** use algorithm MurmurHash3 for 32-bit platform (128-bit).
+
+- **Digest::MurmurHash3\_x64\_128** use algorithm MurmurHash3 for 64-bit platform (128-bit).
+
+(**Digest::MurmurHash** class was nothing)
 
 All classes compliance Digest API of Ruby.
 
 ## Usage
 
-You can use same interface built-in Digest::XXX classes.
-
 ```ruby
 require 'digest/murmurhash'
 
 # MurmurHash1 can use like same than Digest::XXX.
 
-p Digest::MurmurHash1.hexdigest('murmurhash') #=> 'c709abd5'
-p Digest::MurmurHash1.file("./LICENSE.txt").hexdigest #=> '712e9641'
-
-# and MurmurHash2 too. but return another value because using another algorithm.
+p Digest::MurmurHash1.hexdigest('murmurhash') #=> d5ab09c7
+p Digest::MurmurHash1.digest('murmurhash') #=> \xD5\xAB\x09\xC7
+p Digest::MurmurHash1.rawdigest('murmurhash') #=> 3339299797
+p Digest::MurmurHash1.file("./LICENSE.txt").hexdigest #=> "41962e71"
 
-p Digest::MurmurHash2.hexdigest('murmurhash') #=> '33f67c7e'
-p Digest::MurmurHash2.file("./LICENSE.txt").hexdigest #=> '78678326'
 ```
 
-## Class tree
-
-**Digest::MurmurHash1** < Digest::StringBuffer
+## Feature
 
-**Digest::MurmurHash2** < Digest::StringBuffer
+- Very fast because hash algorithm is written by C extention
+- You can try *all* Hurmurhash algorithms
+- You can use same interface built-in Digest::{MD5,SH1,...} classes.
 
-**Digest::MurmurHash2A** < Digest::StringBuffer
+## Simple benchmark
 
-**Digest::MurmurHash64A** < Digest::StringBuffer
-
-**Digest::MurmurHash64B** < Digest::StringBuffer
+```ruby
+#! /usr/bin/env ruby
 
-**Digest::MurmurHashNeutral2** < Digest::StringBuffer
+require 'benchmark'
+require 'digest/md5'
+require 'digest/sha1'
+require 'digest/murmurhash'
+require 'digest/siphash'
+
+include Digest
+
+n = 1000
+str = "teststrings" * 1024 * 10
+
+Benchmark.bm do |f|
+  [MurmurHash1, MurmurHash2, MurmurHash2A, MurmurHash64A, MurmurHash64B, MurmurHashNeutral2, MurmurHashAligned2, MurmurHash3_x86_32, MurmurHash3_x86_128, MurmurHash3_x64_128, SipHash, MD5, SHA1].each do |klass|
+    f.report(klass.to_s) {
+      i = 0
+      while i < n
+        klass.digest(str)
+        i += 1
+      end
+    }
+  end
+end
+```
 
-**Digest::MurmurHashAligned2** < Digest::StringBuffer
+```
+       user     system      total        real
+Digest::MurmurHash1  0.050000   0.010000   0.060000 (  0.047889)
+Digest::MurmurHash2  0.030000   0.000000   0.030000 (  0.034564)
+Digest::MurmurHash2A  0.030000   0.010000   0.040000 (  0.031808)
+Digest::MurmurHash64A  0.010000   0.000000   0.010000 (  0.018400)
+Digest::MurmurHash64B  0.030000   0.000000   0.030000 (  0.027818)
+Digest::MurmurHashNeutral2  0.040000   0.000000   0.040000 (  0.041021)
+Digest::MurmurHashAligned2  0.020000   0.010000   0.030000 (  0.030409)
+Digest::MurmurHash3_x86_32  0.130000   0.010000   0.140000 (  0.139622)
+Digest::MurmurHash3_x86_128  0.120000   0.020000   0.140000 (  0.143768)
+Digest::MurmurHash3_x64_128  0.070000   0.010000   0.080000 (  0.072687)
+Digest::SipHash  0.060000   0.010000   0.070000 (  0.068243)
+Digest::MD5  0.130000   0.010000   0.140000 (  0.153793)
+Digest::SHA1  0.130000   0.020000   0.150000 (  0.137686)
+```
 
 ## Installation
 

data/Rakefile

@@ -12,14 +12,14 @@ task :spec => :compile
 
 require 'rake/extensiontask'
 spec = Bundler::GemHelper.gemspec
-Rake::ExtensionTask.new('murmurhash', spec) do |ext|
+Rake::ExtensionTask.new('ext', spec) do |ext|
   ext.ext_dir = 'ext/digest/murmurhash'
   ext.lib_dir = 'lib/digest/murmurhash'
 end
 
 desc "gem reinstall"
 task :reinstall do |t|
-  system "gem uninstall murmurhash"
+  system "gem uninstall digest-murmurhash"
   system "rake clean"
   system "bundle exec rake"
   system "rake install"

data/digest-murmurhash.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "digest-murmurhash"
-  spec.version       = "1.0.0"
-  spec.author        = "ksss"
-  spec.email         = "co000ri@gmail.com"
-  spec.description   = %q{Digest::MurmurHash is class collections of use algorithm MurmurHash desiged by Austin Appleby.}
-  spec.summary       = %q{Digest::MurmurHash is class collections of use algorithm MurmurHash desiged by Austin Appleby.}
-  spec.homepage      = ""
+  spec.version       = "1.1.0"
+  spec.authors       = ["ksss"]
+  spec.email         = ["co000ri@gmail.com"]
+  spec.description   = %q{digest-murmurhash is class collections of use algorithm MurmurHash desiged by Austin Appleby.}
+  spec.summary       = %q{digest-murmurhash is class collections of use algorithm MurmurHash desiged by Austin Appleby.}
+  spec.homepage      = "https://github.com/ksss/digest-murmurhash"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -16,7 +16,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions    = ["ext/digest/murmurhash/extconf.rb"]
 
-  spec.add_runtime_dependency "digest-simple"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

data/ext/digest/murmurhash/{murmurhash1.c → 1.c}

@@ -2,7 +2,7 @@
  * MurmurHash1 (C) Austin Appleby
  */
 
-#include "murmurhash1.h"
+#include "init.h"
 
 #define murmur1(r) do { \
   h *= m; \

data/ext/digest/murmurhash/{murmurhash2.c → 2.c}

@@ -2,7 +2,7 @@
  * MurmurHash2 (C) Austin Appleby
  */
 
-#include "murmurhash2.h"
+#include "init.h"
 
 static uint32_t
 murmur_hash_process2(const char *data, uint32_t length, uint32_t seed)

data/ext/digest/murmurhash/{murmurhash2a.c → 2a.c}

@@ -2,7 +2,7 @@
  * MurmurHash2A (C) Austin Appleby
  */
 
-#include "murmurhash2a.h"
+#include "init.h"
 
 #define mmix(h,k) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
 

data/ext/digest/murmurhash/3_x64_128.c

@@ -0,0 +1,117 @@
+/*
+ * MurmurHash3_x64_128 (C) Austin Appleby
+ */
+
+#include "init.h"
+
+void
+murmur_hash_process3_x64_128(const char * key, uint32_t len, uint32_t seed, void *out)
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 16;
+
+  uint64_t h1 = seed;
+  uint64_t h2 = seed;
+
+  const uint64_t c1 = (uint64_t)BIG_CONSTANT(0x87c37b91114253d5);
+  const uint64_t c2 = (uint64_t)BIG_CONSTANT(0x4cf5ad432745937f);
+
+  //----------
+  // body
+
+  const uint64_t * blocks = (const uint64_t *)(data);
+
+  int i;
+
+  for(i = 0; i < nblocks; i++)
+  {
+    uint64_t k1 = getblock64(blocks,i*2+0);
+    uint64_t k2 = getblock64(blocks,i*2+1);
+
+    k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+
+    h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
+
+    k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+
+    h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+
+  uint64_t k1 = 0;
+  uint64_t k2 = 0;
+
+  switch(len & 15)
+  {
+  case 15: k2 ^= ((uint64_t)tail[14]) << 48;
+  case 14: k2 ^= ((uint64_t)tail[13]) << 40;
+  case 13: k2 ^= ((uint64_t)tail[12]) << 32;
+  case 12: k2 ^= ((uint64_t)tail[11]) << 24;
+  case 11: k2 ^= ((uint64_t)tail[10]) << 16;
+  case 10: k2 ^= ((uint64_t)tail[ 9]) << 8;
+  case  9: k2 ^= ((uint64_t)tail[ 8]) << 0;
+           k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+
+  case  8: k1 ^= ((uint64_t)tail[ 7]) << 56;
+  case  7: k1 ^= ((uint64_t)tail[ 6]) << 48;
+  case  6: k1 ^= ((uint64_t)tail[ 5]) << 40;
+  case  5: k1 ^= ((uint64_t)tail[ 4]) << 32;
+  case  4: k1 ^= ((uint64_t)tail[ 3]) << 24;
+  case  3: k1 ^= ((uint64_t)tail[ 2]) << 16;
+  case  2: k1 ^= ((uint64_t)tail[ 1]) << 8;
+  case  1: k1 ^= ((uint64_t)tail[ 0]) << 0;
+           k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= len; h2 ^= len;
+
+  h1 += h2;
+  h2 += h1;
+
+  h1 = fmix64(h1);
+  h2 = fmix64(h2);
+
+  h1 += h2;
+  h2 += h1;
+
+  ((uint64_t*)out)[0] = h1;
+  ((uint64_t*)out)[1] = h2;
+}
+
+VALUE
+murmur3_x64_128_finish(VALUE self)
+{
+  uint8_t digest[16];
+  uint64_t out[2];
+
+  _murmur_finish128(self, out, murmur_hash_process3_x64_128);
+  assign_by_endian_128(digest, out);
+  return rb_str_new((const char*) digest, 16);
+}
+
+VALUE
+murmur3_x64_128_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+  uint8_t digest[16];
+  uint64_t out[2];
+
+  _murmur_s_digest128(argc, argv, klass, (void*)out, murmur_hash_process3_x64_128);
+  assign_by_endian_128(digest, out);
+  return rb_str_new((const char*) digest, 16);
+}
+
+VALUE
+murmur3_x64_128_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+  uint64_t out[2];
+
+  _murmur_s_digest128(argc, argv, klass, (void*)out, murmur_hash_process3_x64_128);
+  return rb_assoc_new(ULL2NUM(out[0]), ULL2NUM(out[1]));
+}

data/ext/digest/murmurhash/3_x86_128.c

@@ -0,0 +1,141 @@
+/*
+ * MurmurHash3_x86_128 (C) Austin Appleby
+ */
+
+#include "init.h"
+
+void
+murmur_hash_process3_x86_128(const char * key, uint32_t len, uint32_t seed, void *out)
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 16;
+
+  uint32_t h1 = seed;
+  uint32_t h2 = seed;
+  uint32_t h3 = seed;
+  uint32_t h4 = seed;
+
+  const uint32_t c1 = 0x239b961b;
+  const uint32_t c2 = 0xab0e9789;
+  const uint32_t c3 = 0x38b34ae5;
+  const uint32_t c4 = 0xa1e38b93;
+
+  int i;
+
+  //----------
+  // body
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*16);
+
+  for(i = -nblocks; i; i++)
+  {
+    uint32_t k1 = getblock32(blocks,i*4+0);
+    uint32_t k2 = getblock32(blocks,i*4+1);
+    uint32_t k3 = getblock32(blocks,i*4+2);
+    uint32_t k4 = getblock32(blocks,i*4+3);
+
+    k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+
+    h1 = ROTL32(h1,19); h1 += h2; h1 = h1*5+0x561ccd1b;
+
+    k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
+
+    h2 = ROTL32(h2,17); h2 += h3; h2 = h2*5+0x0bcaa747;
+
+    k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
+
+    h3 = ROTL32(h3,15); h3 += h4; h3 = h3*5+0x96cd1c35;
+
+    k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
+
+    h4 = ROTL32(h4,13); h4 += h1; h4 = h4*5+0x32ac3b17;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+
+  uint32_t k1 = 0;
+  uint32_t k2 = 0;
+  uint32_t k3 = 0;
+  uint32_t k4 = 0;
+
+  switch(len & 15)
+  {
+  case 15: k4 ^= tail[14] << 16;
+  case 14: k4 ^= tail[13] << 8;
+  case 13: k4 ^= tail[12] << 0;
+           k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
+
+  case 12: k3 ^= tail[11] << 24;
+  case 11: k3 ^= tail[10] << 16;
+  case 10: k3 ^= tail[ 9] << 8;
+  case  9: k3 ^= tail[ 8] << 0;
+           k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
+
+  case  8: k2 ^= tail[ 7] << 24;
+  case  7: k2 ^= tail[ 6] << 16;
+  case  6: k2 ^= tail[ 5] << 8;
+  case  5: k2 ^= tail[ 4] << 0;
+           k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
+
+  case  4: k1 ^= tail[ 3] << 24;
+  case  3: k1 ^= tail[ 2] << 16;
+  case  2: k1 ^= tail[ 1] << 8;
+  case  1: k1 ^= tail[ 0] << 0;
+           k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  }
+
+  //----------
+  // finalization
+
+  h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len;
+
+  h1 += h2; h1 += h3; h1 += h4;
+  h2 += h1; h3 += h1; h4 += h1;
+
+  h1 = fmix32(h1);
+  h2 = fmix32(h2);
+  h3 = fmix32(h3);
+  h4 = fmix32(h4);
+
+  h1 += h2; h1 += h3; h1 += h4;
+  h2 += h1; h3 += h1; h4 += h1;
+
+  ((uint32_t*)out)[0] = h1;
+  ((uint32_t*)out)[1] = h2;
+  ((uint32_t*)out)[2] = h3;
+  ((uint32_t*)out)[3] = h4;
+}
+
+VALUE
+murmur3_x86_128_finish(VALUE self)
+{
+  uint8_t digest[16];
+  uint32_t out[4];
+
+  _murmur_finish128(self, out, murmur_hash_process3_x86_128);
+  assign_by_endian_128(digest, out);
+  return rb_str_new((const char*) digest, 16);
+}
+
+VALUE
+murmur3_x86_128_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+  uint8_t digest[16];
+  uint32_t out[4];
+
+  _murmur_s_digest128(argc, argv, klass, out, murmur_hash_process3_x86_128);
+  assign_by_endian_128(digest, out);
+  return rb_str_new((const char*) digest, 16);
+}
+
+VALUE
+murmur3_x86_128_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+  uint64_t out[2];
+
+  _murmur_s_digest128(argc, argv, klass, (void*)out, murmur_hash_process3_x86_128);
+  return rb_assoc_new(ULL2NUM(out[0]), ULL2NUM(out[1]));
+}