digest-murmurhash 0.2.3 → 0.3.0

data/ext/digest/murmurhash/murmurhash2.c

@@ -4,31 +4,24 @@
 
 #include "murmurhash2.h"
 
-static inline size_t
-murmur2(uint32_t h, uint32_t k, const uint8_t r)
-{
-	const uint32_t m = MURMURHASH_MAGIC;
-	k *= m;
-	k ^= k >> r;
-	k *= m;
-
-	h *= m;
-	h ^= k;
-	return h;
-}
-
 static uint32_t
-murmur_hash_process2(const char *data, uint32_t length)
+murmur_hash_process2(const char *data, uint32_t length, uint32_t seed)
 {
 	const uint32_t m = MURMURHASH_MAGIC;
 	const uint8_t r = 24;
 	uint32_t h, k;
 
-	h = length * m;
+	h = seed ^ length;
 
 	while (4 <= length) {
 		k = *(uint32_t*)data;
-		h = murmur2(h, k, r);
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+
+		h *= m;
+		h ^= k;
+
 		data += 4;
 		length -= 4;
 	}
@@ -50,49 +43,27 @@ murmur_hash_process2(const char *data, uint32_t length)
 VALUE
 murmur2_finish(VALUE self)
 {
-	uint32_t h;
 	uint8_t digest[4];
-	MURMURHASH(self, ptr);
-
-	h = murmur_hash_process2(ptr->buffer, ptr->p - ptr->buffer);
-
-	digest[0] = h >> 24;
-	digest[1] = h >> 16;
-	digest[2] = h >> 8;
-	digest[3] = h;
+	uint64_t h;
 
+	h = _murmur_finish32(self, murmur_hash_process2);
+	ASSINE_BY_ENDIAN_32(digest, h);
 	return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur2_to_i(VALUE self)
 {
-	MURMURHASH(self, ptr);
-	return UINT2NUM(murmur_hash_process2(ptr->buffer, ptr->p - ptr->buffer));
+	return ULONG2NUM(_murmur_finish32(self, murmur_hash_process2));
 }
 
 VALUE
 murmur2_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE str;
-	uint32_t h;
 	uint8_t digest[4];
-
-	if (argc < 1)
-		rb_raise(rb_eArgError, "no data given");
-
-	str = *argv++;
-	argc--;
-
-	StringValue(str);
-
-	h = murmur_hash_process2(RSTRING_PTR(str), RSTRING_LEN(str));
-
-	digest[0] = h >> 24;
-	digest[1] = h >> 16;
-	digest[2] = h >> 8;
-	digest[3] = h;
-
+	uint32_t h;
+	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process2);
+	ASSINE_BY_ENDIAN_32(digest, h);
 	return rb_str_new((const char*) digest, 4);
 }
 
@@ -105,16 +76,6 @@ murmur2_s_hexdigest(int argc, VALUE *argv, VALUE klass)
 VALUE
 murmur2_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE str;
-
-	if (argc < 1)
-		rb_raise(rb_eArgError, "no data given");
-
-	str = *argv++;
-	argc--;
-
-	StringValue(str);
-
-	return UINT2NUM(murmur_hash_process2(RSTRING_PTR(str), RSTRING_LEN(str)));
+	return ULONG2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process2));
 }
 

data/ext/digest/murmurhash/murmurhash2a.c

@@ -7,7 +7,7 @@
 #define mmix(h,k) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
 
 static uint32_t
-murmur_hash_process2a(const void *key, uint32_t length)
+murmur_hash_process2a(const char *key, uint32_t length, uint32_t seed)
 {
 	const uint32_t m = MURMURHASH_MAGIC;
 	const uint8_t r = 24;
@@ -15,7 +15,7 @@ murmur_hash_process2a(const void *key, uint32_t length)
 	const unsigned char *data = (const unsigned char *) key;
 
 	l = length;
-	h = 0 ^ length;
+	h = seed;
 
 	while (4 <= length) {
 		k = *(uint32_t*)data;
@@ -41,52 +41,38 @@ murmur_hash_process2a(const void *key, uint32_t length)
 	return h;
 }
 
+static uint32_t
+_murmur2a_finish(VALUE self)
+{
+	const char *seed = RSTRING_PTR(murmur_seed_get32(self));
+	MURMURHASH(self, ptr);
+	return murmur_hash_process2a(ptr->buffer, ptr->p - ptr->buffer, *(uint32_t*)seed);
+}
+
 VALUE
 murmur2a_finish(VALUE self)
 {
-	uint32_t h;
 	uint8_t digest[4];
-	MURMURHASH(self, ptr);
-
-	h = murmur_hash_process2a(ptr->buffer, ptr->p - ptr->buffer);
-
-	digest[0] = h >> 24;
-	digest[1] = h >> 16;
-	digest[2] = h >> 8;
-	digest[3] = h;
+	uint64_t h;
 
+	h = _murmur2a_finish(self);
+	ASSINE_BY_ENDIAN_32(digest, h);
 	return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur2a_to_i(VALUE self)
 {
-	MURMURHASH(self, ptr);
-	return UINT2NUM(murmur_hash_process2a(ptr->buffer, ptr->p - ptr->buffer));
+	return ULONG2NUM(_murmur2a_finish(self));
 }
 
 VALUE
 murmur2a_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE str;
-	uint32_t h;
 	uint8_t digest[4];
-
-	if (argc < 1)
-		rb_raise(rb_eArgError, "no data given");
-
-	str = *argv++;
-	argc--;
-
-	StringValue(str);
-
-	h = murmur_hash_process2a(RSTRING_PTR(str), RSTRING_LEN(str));
-
-	digest[0] = h >> 24;
-	digest[1] = h >> 16;
-	digest[2] = h >> 8;
-	digest[3] = h;
-
+	uint32_t h;
+	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process2a);
+	ASSINE_BY_ENDIAN_32(digest, h);
 	return rb_str_new((const char*) digest, 4);
 }
 
@@ -99,16 +85,6 @@ murmur2a_s_hexdigest(int argc, VALUE *argv, VALUE klass)
 VALUE
 murmur2a_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE str;
-
-	if (argc < 1)
-		rb_raise(rb_eArgError, "no data given");
-
-	str = *argv++;
-	argc--;
-
-	StringValue(str);
-
-	return UINT2NUM(murmur_hash_process2a(RSTRING_PTR(str), RSTRING_LEN(str)));
+	return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process2a));
 }
 

data/ext/digest/murmurhash/murmurhash64a.c

@@ -0,0 +1,87 @@
+/*
+ * MurmurHash64A (C) Austin Appleby
+ */
+
+#include "murmurhash64a.h"
+
+static uint64_t
+murmur_hash_process64a(const char *key, uint32_t len, uint64_t seed)
+{
+	const uint64_t m = MURMURHASH_MAGIC64A;
+	const int r = 47;
+
+	uint64_t h = seed ^ (len * m);
+
+	const uint64_t * data = (const uint64_t *)key;
+	const uint64_t * end = data + (len/8);
+
+	while(data != end)
+	{
+		uint64_t k = *data++;
+
+		k *= m; 
+		k ^= k >> r; 
+		k *= m; 
+
+		h ^= k;
+		h *= m; 
+	}
+
+	const unsigned char * data2 = (const unsigned char*)data;
+
+	switch(len & 7) {
+	case 7: h ^= (uint64_t)((uint64_t)data2[6] << (uint64_t)48);
+	case 6: h ^= (uint64_t)((uint64_t)data2[5] << (uint64_t)40);
+	case 5: h ^= (uint64_t)((uint64_t)data2[4] << (uint64_t)32);
+	case 4: h ^= (uint64_t)((uint64_t)data2[3] << (uint64_t)24);
+	case 3: h ^= (uint64_t)((uint64_t)data2[2] << (uint64_t)16);
+	case 2: h ^= (uint64_t)((uint64_t)data2[1] << (uint64_t)8 );
+	case 1: h ^= (uint64_t)((uint64_t)data2[0]                );
+			h *= m;
+	};
+
+	h ^= h >> r;
+	h *= m;
+	h ^= h >> r;
+
+	return h;
+}
+
+VALUE
+murmur64a_finish(VALUE self)
+{
+	uint8_t digest[8];
+	uint64_t h;
+
+	h = _murmur_finish64(self, murmur_hash_process64a);
+	ASSINE_BY_ENDIAN_64(digest, h);
+	return rb_str_new((const char*) digest, 8);
+}
+
+VALUE
+murmur64a_to_i(VALUE self)
+{
+	return ULL2NUM(_murmur_finish64(self, murmur_hash_process64a));
+}
+
+VALUE
+murmur64a_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+	uint8_t digest[8];
+	uint64_t h;
+	h = _murmur_s_digest64(argc, argv, klass, murmur_hash_process64a);
+	ASSINE_BY_ENDIAN_64(digest, h);
+	return rb_str_new((const char*) digest, 8);
+}
+
+VALUE
+murmur64a_s_hexdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return hexencode_str_new(murmur64a_s_digest(argc, argv, klass));
+}
+
+VALUE
+murmur64a_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return ULL2NUM(_murmur_s_digest64(argc, argv, klass, murmur_hash_process64a));
+}

data/ext/digest/murmurhash/murmurhash64a.h

@@ -0,0 +1,13 @@
+#ifndef MURMURHASH64A_INCLUDED
+#  define MURMURHASH64A_INCLUDED
+
+#include "murmurhash.h"
+
+VALUE murmur64a_finish(VALUE self);
+VALUE murmur64a_to_i(VALUE self);
+VALUE murmur64a_s_digest(int argc, VALUE *argv, VALUE klass);
+VALUE murmur64a_s_hexdigest(int argc, VALUE *argv, VALUE klass);
+VALUE murmur64a_s_rawdigest(int argc, VALUE *argv, VALUE klass);
+
+#endif /* ifndef MURMURHASH64A_INCLUDED */
+

data/ext/digest/murmurhash/murmurhash64b.c

@@ -0,0 +1,93 @@
+/*
+ * MurmurHash64B (C) Austin Appleby
+ */
+
+#include "murmurhash64b.h"
+
+uint64_t
+murmur_hash_process64b(const char * key, uint32_t len, uint64_t seed)
+{
+	const uint32_t m = MURMURHASH_MAGIC;
+	const int r = 24;
+
+	uint32_t h1 = (uint32_t)(seed) ^ len;
+	uint32_t h2 = (uint32_t)(seed >> 32);
+
+	const uint32_t * data = (const uint32_t *)key;
+
+	while(len >= 8) {
+		uint32_t k1 = *data++;
+		k1 *= m; k1 ^= k1 >> r; k1 *= m;
+		h1 *= m; h1 ^= k1;
+		len -= 4;
+
+		uint32_t k2 = *data++;
+		k2 *= m; k2 ^= k2 >> r; k2 *= m;
+		h2 *= m; h2 ^= k2;
+		len -= 4;
+	}
+
+	if(len >= 4) {
+		uint32_t k1 = *data++;
+		k1 *= m; k1 ^= k1 >> r; k1 *= m;
+		h1 *= m; h1 ^= k1;
+		len -= 4;
+	}
+
+	switch(len) {
+	case 3: h2 ^= ((unsigned char*)data)[2] << 16;
+	case 2: h2 ^= ((unsigned char*)data)[1] << 8;
+	case 1: h2 ^= ((unsigned char*)data)[0];
+			h2 *= m;
+	};
+
+	h1 ^= h2 >> 18; h1 *= m;
+	h2 ^= h1 >> 22; h2 *= m;
+	h1 ^= h2 >> 17; h1 *= m;
+	h2 ^= h1 >> 19; h2 *= m;
+
+	uint64_t h = h1;
+
+	h = (h << 32) | h2;
+
+	return h;
+} 
+
+VALUE
+murmur64b_finish(VALUE self)
+{
+	uint8_t digest[8];
+	uint64_t h;
+
+	h = _murmur_finish64(self, murmur_hash_process64b);
+	ASSINE_BY_ENDIAN_64(digest, h);
+	return rb_str_new((const char*) digest, 8);
+}
+
+VALUE
+murmur64b_to_i(VALUE self)
+{
+	return ULL2NUM(_murmur_finish64(self, murmur_hash_process64b));
+}
+
+VALUE
+murmur64b_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+	uint8_t digest[8];
+	uint64_t h;
+	h = _murmur_s_digest64(argc, argv, klass, murmur_hash_process64b);
+	ASSINE_BY_ENDIAN_64(digest, h);
+	return rb_str_new((const char*) digest, 8);
+}
+
+VALUE
+murmur64b_s_hexdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return hexencode_str_new(murmur64b_s_digest(argc, argv, klass));
+}
+
+VALUE
+murmur64b_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return ULL2NUM(_murmur_s_digest64(argc, argv, klass, murmur_hash_process64b));
+}

data/ext/digest/murmurhash/murmurhash64b.h

@@ -0,0 +1,13 @@
+#ifndef MURMURHASH64B_INCLUDED
+#  define MURMURHASH64B_INCLUDED
+
+#include "murmurhash.h"
+
+VALUE murmur64b_finish(VALUE self);
+VALUE murmur64b_to_i(VALUE self);
+VALUE murmur64b_s_digest(int argc, VALUE *argv, VALUE klass);
+VALUE murmur64b_s_hexdigest(int argc, VALUE *argv, VALUE klass);
+VALUE murmur64b_s_rawdigest(int argc, VALUE *argv, VALUE klass);
+
+#endif /* ifndef MURMURHASH64B_INCLUDED */
+

data/ext/digest/murmurhash/murmurhash_aligned2.c

@@ -0,0 +1,87 @@
+/*
+ * MurmurHashAligned2 (C) Austin Appleby
+ */
+
+#include "murmurhash_aligned2.h"
+
+uint32_t
+murmur_hash_process_aligned2(const char * key, uint32_t len, uint32_t seed)
+{
+	const uint32_t m = 0x5bd1e995;
+	const int r = 24;
+
+	uint32_t h = seed ^ len;
+
+	const unsigned char * data = (const unsigned char *)key;
+
+	while(len >= 4) {
+		uint32_t k;
+
+		k  = data[0];
+		k |= data[1] << 8;
+		k |= data[2] << 16;
+		k |= data[3] << 24;
+
+		k *= m; 
+		k ^= k >> r; 
+		k *= m;
+
+		h *= m;
+		h ^= k;
+
+		data += 4;
+		len -= 4;
+	}
+
+	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);
+	ASSINE_BY_ENDIAN_32(digest, h);
+	return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur_aligned2_to_i(VALUE self)
+{
+	return ULL2NUM(_murmur_finish32(self, murmur_hash_process_aligned2));
+}
+
+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);
+	ASSINE_BY_ENDIAN_32(digest, h);
+	return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur_aligned2_s_hexdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return hexencode_str_new(murmur_aligned2_s_digest(argc, argv, klass));
+}
+
+VALUE
+murmur_aligned2_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process_aligned2));
+}