digest-murmurhash 1.0.0 → 1.1.0

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

@@ -0,0 +1,88 @@
+/*
+ * MurmurHash3_x86_32 (C) Austin Appleby
+ */
+
+#include "init.h"
+
+uint32_t
+murmur_hash_process3_x86_32(const char * key, uint32_t len, uint32_t seed)
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 4;
+  int i;
+
+  uint32_t h1 = seed;
+
+  const uint32_t c1 = 0xcc9e2d51;
+  const uint32_t c2 = 0x1b873593;
+
+  //----------
+  // body
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
+
+  for(i = -nblocks; i; i++)
+  {
+    uint32_t k1 = getblock32(blocks,i);
+
+    k1 *= c1;
+    k1 = ROTL32(k1,15);
+    k1 *= c2;
+
+    h1 ^= k1;
+    h1 = ROTL32(h1,13);
+    h1 = h1*5+0xe6546b64;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
+
+  uint32_t k1 = 0;
+
+  switch(len & 3)
+  {
+  case 3: k1 ^= tail[2] << 16;
+  case 2: k1 ^= tail[1] << 8;
+  case 1: k1 ^= tail[0];
+          k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= len;
+
+  h1 = fmix32(h1);
+
+  return h1;
+}
+
+VALUE
+murmur3_x86_32_finish(VALUE self)
+{
+  uint8_t digest[4];
+  uint32_t h;
+
+  h = _murmur_finish32(self, murmur_hash_process3_x86_32);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur3_x86_32_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+  uint8_t digest[4];
+  uint32_t h;
+
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process3_x86_32);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur3_x86_32_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+  return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process3_x86_32));
+}

data/ext/digest/murmurhash/{murmurhash64a.c → 64a.c}

@@ -2,7 +2,7 @@
  * MurmurHash64A (C) Austin Appleby
  */
 
-#include "murmurhash64a.h"
+#include "init.h"
 
 static uint64_t
 murmur_hash_process64a(const char *key, uint32_t len, uint64_t seed)

data/ext/digest/murmurhash/{murmurhash64b.c → 64b.c}

@@ -2,7 +2,7 @@
  * MurmurHash64B (C) Austin Appleby
  */
 
-#include "murmurhash64b.h"
+#include "init.h"
 
 uint64_t
 murmur_hash_process64b(const char * key, uint32_t len, uint64_t seed)
@@ -46,7 +46,7 @@ murmur_hash_process64b(const char * key, uint32_t len, uint64_t seed)
   h1 ^= h2 >> 17; h1 *= m;
   h2 ^= h1 >> 19; h2 *= m;
 
-  uint64_t h = h1;
+  uint64_t h = (uint32_t)h1;
 
   h = (h << 32) | h2;
 

data/ext/digest/murmurhash/aligned2.c

@@ -0,0 +1,163 @@
+/*
+ * MurmurHashAligned2 (C) Austin Appleby
+ */
+
+#include "init.h"
+
+#define MIX(h,k,m) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
+
+uint32_t
+murmur_hash_process_aligned2(const char * key, uint32_t len, uint32_t seed)
+{
+  const uint32_t m = 0x5bd1e995;
+  const int r = 24;
+
+  const unsigned char * data = (const unsigned char *)key;
+
+  uint32_t h = seed ^ len;
+
+  int align = (uint64_t)data & 3;
+
+  if(align && (len >= 4))
+  {
+    // Pre-load the temp registers
+
+    uint32_t t = 0, d = 0;
+
+    switch(align)
+    {
+      case 1: t |= data[2] << 16;
+      case 2: t |= data[1] << 8;
+      case 3: t |= data[0];
+    }
+
+    t <<= (8 * align);
+
+    data += 4-align;
+    len -= 4-align;
+
+    int sl = 8 * (4-align);
+    int sr = 8 * align;
+
+    // Mix
+
+    while(len >= 4)
+    {
+      d = *(uint32_t *)data;
+      t = (t >> sr) | (d << sl);
+
+      uint32_t k = t;
+
+      MIX(h,k,m);
+
+      t = d;
+
+      data += 4;
+      len -= 4;
+    }
+
+    // Handle leftover data in temp registers
+
+    d = 0;
+
+    if(len >= align)
+    {
+      switch(align)
+      {
+      case 3: d |= data[2] << 16;
+      case 2: d |= data[1] << 8;
+      case 1: d |= data[0];
+      }
+
+      uint32_t k = (t >> sr) | (d << sl);
+      MIX(h,k,m);
+
+      data += align;
+      len -= align;
+
+      //----------
+      // Handle tail bytes
+
+      switch(len)
+      {
+      case 3: h ^= data[2] << 16;
+      case 2: h ^= data[1] << 8;
+      case 1: h ^= data[0];
+          h *= m;
+      };
+    }
+    else
+    {
+      switch(len)
+      {
+      case 3: d |= data[2] << 16;
+      case 2: d |= data[1] << 8;
+      case 1: d |= data[0];
+      case 0: h ^= (t >> sr) | (d << sl);
+          h *= m;
+      }
+    }
+
+    h ^= h >> 13;
+    h *= m;
+    h ^= h >> 15;
+
+    return h;
+  }
+  else
+  {
+    while(len >= 4)
+    {
+      uint32_t k = *(uint32_t *)data;
+
+      MIX(h,k,m);
+
+      data += 4;
+      len -= 4;
+    }
+
+    //----------
+    // Handle tail bytes
+
+    switch(len)
+    {
+    case 3: h ^= data[2] << 16;
+    case 2: h ^= data[1] << 8;
+    case 1: h ^= data[0];
+        h *= m;
+    };
+
+    h ^= h >> 13;
+    h *= m;
+    h ^= h >> 15;
+
+    return h;
+  }
+}
+
+VALUE
+murmur_aligned2_finish(VALUE self)
+{
+  uint8_t digest[4];
+  uint32_t h;
+
+  h = _murmur_finish32(self, murmur_hash_process_aligned2);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur_aligned2_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+  uint8_t digest[4];
+  uint64_t h;
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process_aligned2);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur_aligned2_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+  return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process_aligned2));
+}

data/ext/digest/murmurhash/extconf.rb

@@ -1,3 +1,3 @@
 require 'mkmf'
 
-create_makefile('digest/murmurhash/murmurhash')
+create_makefile('digest/murmurhash/ext')

data/ext/digest/murmurhash/{murmurhash.c → init.c}

@@ -1,25 +1,53 @@
-#include "murmurhash.h"
-#include "murmurhash1.h"
-#include "murmurhash2.h"
-#include "murmurhash2a.h"
-#include "murmurhash64a.h"
-#include "murmurhash64b.h"
-#include "murmurhash_neutral2.h"
-#include "murmurhash_aligned2.h"
-
-VALUE cDigest_MurmurHash1,
-      cDigest_MurmurHash2,
-      cDigest_MurmurHash2A,
-      cDigest_MurmurHash64A,
-      cDigest_MurmurHash64B,
-      cDigest_MurmurHashNeutral2,
-      cDigest_MurmurHashAligned2;
+#include "init.h"
+
 ID id_DEFAULT_SEED;
 ID iv_seed;
 ID iv_buffer;
 
+
+inline uint32_t rotl32 ( uint32_t x, int8_t r )
+{
+  return (x << r) | (x >> (32 - r));
+}
+inline uint64_t rotl64 ( uint64_t x, int8_t r )
+{
+  return (x << r) | (x >> (64 - r));
+}
+
+FORCE_INLINE uint32_t getblock32 ( const uint32_t * p, int i )
+{
+  return p[i];
+}
+
+FORCE_INLINE uint64_t getblock64 ( const uint64_t * p, int i )
+{
+  return p[i];
+}
+
+FORCE_INLINE uint32_t fmix32 ( uint32_t h )
+{
+  h ^= h >> 16;
+  h *= 0x85ebca6b;
+  h ^= h >> 13;
+  h *= 0xc2b2ae35;
+  h ^= h >> 16;
+
+  return h;
+}
+
+FORCE_INLINE uint64_t fmix64 ( uint64_t k )
+{
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+  k ^= k >> 33;
+
+  return k;
+}
+
 void
-assign_by_endian_32(uint8_t *digest, uint64_t h)
+assign_by_endian_32(uint8_t *digest, uint32_t h)
 {
   if (BIGENDIAN_P()) {
     digest[0] = h >> 24;
@@ -60,8 +88,32 @@ assign_by_endian_64(uint8_t *digest, uint64_t h)
   }
 }
 
+void
+assign_by_endian_128(uint8_t *digest, void *out)
+{
+  int i;
+
+  if (BIGENDIAN_P()) {
+    for (i = 0; i < 4; i++) {
+      digest[(i*4)  ] = ((uint32_t*)out)[i] >> 24;
+      digest[(i*4)+1] = ((uint32_t*)out)[i] >> 16;
+      digest[(i*4)+2] = ((uint32_t*)out)[i] >> 8;
+      digest[(i*4)+3] = ((uint32_t*)out)[i];
+    }
+  }
+  else {
+    for (i = 0; i < 4; i++) {
+      digest[16-(i*4)-1] = ((uint32_t*)out)[i] >> 24;
+      digest[16-(i*4)-2] = ((uint32_t*)out)[i] >> 16;
+      digest[16-(i*4)-3] = ((uint32_t*)out)[i] >> 8;
+      digest[16-(i*4)-4] = ((uint32_t*)out)[i];
+    }
+  }
+}
+
+
 uint32_t
-_murmur_finish32(VALUE self, uint32_t (*process)(const char *, uint32_t, uint32_t))
+_murmur_finish32(VALUE self, uint32_t (*process)(const char*, uint32_t, uint32_t))
 {
   const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
   VALUE buffer = rb_ivar_get(self, iv_buffer);
@@ -69,13 +121,21 @@ _murmur_finish32(VALUE self, uint32_t (*process)(const char *, uint32_t, uint32_
 }
 
 uint64_t
-_murmur_finish64(VALUE self, uint64_t (*process)(const char *, uint32_t, uint64_t))
+_murmur_finish64(VALUE self, uint64_t (*process)(const char*, uint32_t, uint64_t))
 {
   const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
   VALUE buffer = rb_ivar_get(self, iv_buffer);
   return process(RSTRING_PTR(buffer), RSTRING_LEN(buffer), *(uint64_t*)seed);
 }
 
+void
+_murmur_finish128(VALUE self, void *out, void (*process)(const char*, uint32_t, uint32_t, void*))
+{
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  process(RSTRING_PTR(buffer), RSTRING_LEN(buffer), *(uint32_t*)seed, out);
+}
+
 uint32_t
 _murmur_s_digest32(int argc, VALUE *argv, VALUE klass, uint32_t (*process)(const char *, uint32_t, uint32_t))
 {
@@ -92,7 +152,7 @@ _murmur_s_digest32(int argc, VALUE *argv, VALUE klass, uint32_t (*process)(const
   if (1 < argc) {
     StringValue(argv[1]);
     if (RSTRING_LEN(argv[1]) != 4) {
-      rb_raise(rb_eArgError, "seed string should 32 bit chars");
+      rb_raise(rb_eArgError, "seed string should be 4 length");
     }
     seed = RSTRING_PTR(argv[1]);
   } else {
@@ -118,7 +178,7 @@ _murmur_s_digest64(int argc, VALUE *argv, VALUE klass, uint64_t (*process)(const
   if (1 < argc) {
     StringValue(argv[1]);
     if (RSTRING_LEN(argv[1]) != 8) {
-      rb_raise(rb_eArgError, "seed string should 64 bit chars");
+      rb_raise(rb_eArgError, "seed string should be 8 length");
     }
     seed = RSTRING_PTR(argv[1]);
   } else {
@@ -129,8 +189,47 @@ _murmur_s_digest64(int argc, VALUE *argv, VALUE klass, uint64_t (*process)(const
 }
 
 void
-Init_murmurhash(void)
+_murmur_s_digest128(int argc, VALUE *argv, VALUE klass, void *out, void (*process)(const char *, uint32_t, uint32_t, void *))
 {
+  VALUE str;
+  const char *seed;
+  int seed_length = 4;
+
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
+
+  str = *argv;
+
+  StringValue(str);
+
+  if (1 < argc) {
+    StringValue(argv[1]);
+    if (RSTRING_LEN(argv[1]) != seed_length) {
+      rb_raise(rb_eArgError, "seed string should be %d length", seed_length);
+    }
+    seed = RSTRING_PTR(argv[1]);
+  } else {
+    seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+  }
+
+  process(RSTRING_PTR(str), RSTRING_LEN(str), *(uint32_t*)seed, out);
+}
+
+
+void
+Init_ext(void)
+{
+  VALUE cDigest_MurmurHash1,
+        cDigest_MurmurHash2,
+        cDigest_MurmurHash2A,
+        cDigest_MurmurHash64A,
+        cDigest_MurmurHash64B,
+        cDigest_MurmurHashNeutral2,
+        cDigest_MurmurHashAligned2,
+        cDigest_MurmurHash3_x86_32,
+        cDigest_MurmurHash3_x86_128,
+        cDigest_MurmurHash3_x64_128;
+
   id_DEFAULT_SEED = rb_intern("DEFAULT_SEED");
   iv_seed = rb_intern("@seed");
   iv_buffer = rb_intern("@buffer");
@@ -169,4 +268,19 @@ Init_murmurhash(void)
   rb_define_singleton_method(cDigest_MurmurHashAligned2, "digest", murmur_aligned2_s_digest, -1);
   rb_define_singleton_method(cDigest_MurmurHashAligned2, "rawdigest", murmur_aligned2_s_rawdigest, -1);
   rb_define_private_method(cDigest_MurmurHashAligned2, "finish", murmur_aligned2_finish, 0);
+
+  cDigest_MurmurHash3_x86_32 = rb_path2class("Digest::MurmurHash3_x86_32");
+  rb_define_singleton_method(cDigest_MurmurHash3_x86_32, "digest", murmur3_x86_32_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash3_x86_32, "rawdigest", murmur3_x86_32_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash3_x86_32, "finish", murmur3_x86_32_finish, 0);
+
+  cDigest_MurmurHash3_x86_128 = rb_path2class("Digest::MurmurHash3_x86_128");
+  rb_define_singleton_method(cDigest_MurmurHash3_x86_128, "digest", murmur3_x86_128_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash3_x86_128, "rawdigest", murmur3_x86_128_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash3_x86_128, "finish", murmur3_x86_128_finish, 0);
+
+  cDigest_MurmurHash3_x64_128 = rb_path2class("Digest::MurmurHash3_x64_128");
+  rb_define_singleton_method(cDigest_MurmurHash3_x64_128, "digest", murmur3_x64_128_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash3_x64_128, "rawdigest", murmur3_x64_128_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash3_x64_128, "finish", murmur3_x64_128_finish, 0);
 }