meowhash 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c656d4783358e5a42260dd2485ec44f981d55f20ca3a844e0e93c5d9c0baf70a
+  data.tar.gz: e964dac5d53526c7db83cb832f12ff07e71269ab41fe76cbd10c4e8a13602311
+SHA512:
+  metadata.gz: 53a5317408a40723ec248dc760641c8cc7679ded23ab634eb735f5c1c364941d6e8d994d2a00c6f4fc4cfd9074d45734c80c4e5295d8ce7388982babc6f11451
+  data.tar.gz: 38de55bc2e688a22fd4200c7edca5364810d8258a4592c315e4ceaa754b4aa87d31461974b33cfac5e866e44c91fe38a8c0e707587fe17d40bbf7187c0fc6528

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+gemspec
+
+group :deployment do 
+  gem 'package_cloud'
+  gem 'rake'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+zlib License
+
+(C) Copyright 2018 Molly Rocket, Inc. (Meow Hash)
+(C) Copyright 2018 Alex Snaps (wrapper)
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

data/Rakefile

@@ -0,0 +1,34 @@
+task :default => :test
+
+# ==========================================================
+# Packaging
+# ==========================================================
+
+GEMSPEC = eval(File.read('meowhash.gemspec'))
+
+require 'rubygems/package_task'
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+end
+
+# ==========================================================
+# Ruby Extension
+# ==========================================================
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('meowhash', GEMSPEC) do |ext|
+  ext.ext_dir = 'ext/meowhash'
+  ext.lib_dir = 'lib/meowhash'
+end
+task :build => :compile
+
+# ==========================================================
+# Testing
+# ==========================================================
+
+require 'rake/testtask'
+Rake::TestTask.new 'test' do |t|
+  t.test_files = FileList['test/test_*.rb']
+end
+task :test => :build
+
+require "bundler/gem_tasks"

data/ext/meowhash/extconf.rb

@@ -0,0 +1,7 @@
+require "mkmf"
+
+$CFLAGS = "-O3 -Wall -mavx -maes"
+
+abort "Requires CLANG!" if CONFIG['CC'] != "clang"
+
+create_makefile "meowhash/meowhash"

data/ext/meowhash/meow_hash.h

@@ -0,0 +1,255 @@
+/* ========================================================================
+
+   Meow - A Fast Non-cryptographic Hash
+   (C) Copyright 2018 by Molly Rocket, Inc. (https://mollyrocket.com)
+   
+   See https://mollyrocket.com/meowhash for details.
+   
+   ========================================================================
+   
+   zlib License
+   
+   (C) Copyright 2018 Molly Rocket, Inc.
+   
+   This software is provided 'as-is', without any express or implied
+   warranty.  In no event will the authors be held liable for any damages
+   arising from the use of this software.
+   
+   Permission is granted to anyone to use this software for any purpose,
+   including commercial applications, and to alter it and redistribute it
+   freely, subject to the following restrictions:
+   
+   1. The origin of this software must not be misrepresented; you must not
+      claim that you wrote the original software. If you use this software
+      in a product, an acknowledgment in the product documentation would be
+      appreciated but is not required.
+   2. Altered source versions must be plainly marked as such, and must not be
+      misrepresented as being the original software.
+   3. This notice may not be removed or altered from any source distribution.
+   
+   ========================================================================
+   
+   FAQ
+   
+   Q: What is it?
+   
+   A: Meow is a 128-bit non-cryptographic hash that operates at high speeds
+      on x64 and ARM processors that provide AES instructions.  It is
+      designed to be truncatable to 64 and 32-bit hash values and still
+      retain good collision resistance.
+      
+   Q: What is it GOOD for?
+   
+   A: Quickly hashing any amount of data for comparison purposes such as
+      block deduplication or change detection.  It is extremely fast on
+      all buffer sizes, from one byte to one gigabyte and up.
+      
+   Q: What is it BAD for?
+   
+   A: Anything security-related.  It should be assumed that it provides
+      no protection from adversaries whatsoever.  It is also not particularly
+      fast on processors that don't support AES instructions (eg., non-x64/ARM
+      processors).
+      
+   Q: Why is it called the "Meow hash"?
+   
+   A: It is named after a character in Meow the Infinite
+      (https://meowtheinfinite.com)
+      
+   Q: Who wrote it?
+   
+   A: CASEY MURATORI (https://caseymuratori.com) wrote the original
+      implementation for use in processing large-footprint assets for
+      the game 1935 (https://molly1935.com).
+      
+      After the initial version, the hash was refined via collaboration
+      with several great programmers who contributed suggestions and
+      modifications:
+      
+      JEFF ROBERTS (https://radgametools.com) provided a super slick
+      way to handle the residual end-of-buffer bytes that dramatically
+      improved Meow's small hash performance.
+      
+      MARTINS MOZEIKO (https://matrins.ninja) ported Meow to ARM and
+      ANSI-C, and added the proper preprocessor dressing for clean
+      compilation on a variety of compiler configurations.
+      
+      FABIAN GIESEN (https://fgiesen.wordpress.com) provided support
+      for getting the benchmarking working properly across a number
+      of platforms.
+      
+      ARAS PRANCKEVICIUS (https://aras-p.info) provided the allocation
+      shim for compilation on Mac OS X.
+      
+   ========================================================================
+   
+   USAGE
+   
+   For a complete working example, see meow_example.cpp.  Briefly:
+   
+       // Include meow_intrinsics if you want it to detect platforms
+       // and define types and intrinsics for you.  Omit it if you
+       // want to define them yourself.
+       #include "meow_intrinsics.h"
+       
+       // Include meow_hash for the Meow hash function
+       #include "meow_hash.h"
+       
+       // Hash a block of data using CPU-specific acceleration
+       meow_u128 MeowHash_Accelerated(u64 Seed, u64 Len, void *Source);
+       
+       // Check if two Meow hashes are the same
+       // (returns zero if they aren't, non-zero if they are)
+       int MeowHashesAreEqual(meow_u128 A, meow_u128 B)
+       
+       // Truncate a Meow hash to 64 bits
+       meow_u64 MeowU64From(meow_u128 Hash);
+       
+       // Truncate a Meow hash to 32 bits
+       meow_u32 MeowU32From(meow_u128 Hash);
+       
+   **** VERY IMPORTANT X64 COMPILATION NOTES ****
+   
+   On x64, Meow uses the AESDEC instruction, which comes in two flavors:
+   SSE (aesdec) and AVX (vaesdec).  If you are compiling _with_ AVX support,
+   your compiler will probably emit the AVX variant, which means your code
+   WILL NOT RUN on computers that do not have AVX.  If you need to deploy
+   this hash on computers that do not have AVX, you must take care to
+   TURN OFF support for AVX in your compiler for the file that includes
+   the Meow hash!
+   
+   ======================================================================== */
+
+//
+// NOTE(casey): This version is EXPERIMENTAL.  The Meow hash is still
+// undergoing testing and finalization.
+//
+// **** EXPECT HASHES/APIs TO CHANGE UNTIL THE VERSION NUMBER HITS 1.0. ****
+//
+// You have been warned.
+//
+
+static const unsigned char MeowShiftAdjust[31] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128};
+static const unsigned char MeowMaskLen[32] = {255,255,255,255, 255,255,255,255, 255,255,255,255, 255,255,255,255, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
+
+// TODO(casey): These constants are loaded to initialize the lanes.  Jacob should
+// give us some feedback on what they should _actually_ be set to.
+#define MEOW_S0_INIT { 0, 1, 2, 3,  4, 5, 6, 7,  8, 9,10,11, 12,13,14,15}
+#define MEOW_S1_INIT {16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31}
+#define MEOW_S2_INIT {32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47}
+#define MEOW_S3_INIT {48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63}
+static const unsigned char MeowS0Init[] = MEOW_S0_INIT;
+static const unsigned char MeowS1Init[] = MEOW_S1_INIT;
+static const unsigned char MeowS2Init[] = MEOW_S2_INIT;
+static const unsigned char MeowS3Init[] = MEOW_S3_INIT;
+
+//
+// NOTE(casey): 128-wide AES-NI Meow (maximum of 16 bytes/clock single threaded)
+//
+
+static meow_hash
+MeowHash_Accelerated(meow_u64 Seed, meow_u64 TotalLengthInBytes, void *SourceInit)
+{
+    //
+    // NOTE(casey): Initialize the four AES streams and the mixer
+    //
+    
+    meow_aes_128 S0 = Meow128_GetAESConstant(MeowS0Init);
+    meow_aes_128 S1 = Meow128_GetAESConstant(MeowS1Init);
+    meow_aes_128 S2 = Meow128_GetAESConstant(MeowS2Init);
+    meow_aes_128 S3 = Meow128_GetAESConstant(MeowS3Init);
+    
+    meow_u128 Mixer = Meow128_Set64x2(Seed - TotalLengthInBytes,
+                                      Seed + TotalLengthInBytes + 1);
+    
+    //
+    // NOTE(casey): Handle as many full 256-byte blocks as possible
+    //
+    
+    meow_u8 *Source = (meow_u8 *)SourceInit;
+    meow_u64 Len = TotalLengthInBytes;
+    int unsigned Len8 = Len & 15;
+    int unsigned Len128 = Len & 48;
+    
+    while(Len >= 64)
+    {
+        S0 = Meow128_AESDEC_Mem(S0, Source);
+        S1 = Meow128_AESDEC_Mem(S1, Source + 16);
+        S2 = Meow128_AESDEC_Mem(S2, Source + 32);
+        S3 = Meow128_AESDEC_Mem(S3, Source + 48);
+        
+        Len -= 64;
+        Source += 64;
+    }
+    
+    //
+    // NOTE(casey): Overhanging individual bytes
+    //
+    
+    if(Len8)
+    {
+        meow_u8 *Overhang = Source + Len128;
+        int Align = ((int)(meow_umm)Overhang) & 15;
+        if(Align)
+        {
+            int End = ((int)(meow_umm)Overhang) & (MEOW_PAGESIZE - 1);
+        
+            // NOTE(jeffr): If we are nowhere near the page end, use full unaligned load (cmov to set)
+            if (End <= (MEOW_PAGESIZE - 16))
+            {
+                Align = 0;
+            }
+            
+            // NOTE(jeffr): If we will read over the page end, use a full unaligned load (cmov to set)
+            if ((End + Len8) > MEOW_PAGESIZE)
+            {
+                Align = 0;
+            }
+            
+            meow_u128 Partial = Meow128_Shuffle_Mem(Overhang - Align, &MeowShiftAdjust[Align]);
+            
+            Partial = Meow128_And_Mem( Partial, &MeowMaskLen[16 - Len8] );
+            S3 = Meow128_AESDEC(S3, Partial);
+        }
+        else
+        {
+            // NOTE(casey): We don't have to do Jeff's heroics when we know the
+            // buffer is aligned, since we cannot span a memory page (by definition).
+            meow_u128 Partial = Meow128_And_Mem(*(meow_u128 *)Overhang, &MeowMaskLen[16 - Len8]);
+            S3 = Meow128_AESDEC(S3, Partial);
+        }
+    }
+    
+    //
+    // NOTE(casey): Overhanging full 128-bit lanes
+    //
+    
+    switch(Len128)
+    {
+        case 48: S2 = Meow128_AESDEC_Mem(S2, Source + 32);
+        case 32: S1 = Meow128_AESDEC_Mem(S1, Source + 16);
+        case 16: S0 = Meow128_AESDEC_Mem(S0, Source);
+    }
+    
+    //
+    // NOTE(casey): Mix the four lanes down to one 128-bit hash
+    //
+    
+    S3 = Meow128_AESDEC(S3, Mixer);
+    S2 = Meow128_AESDEC(S2, Mixer);
+    S1 = Meow128_AESDEC(S1, Mixer);
+    S0 = Meow128_AESDEC(S0, Mixer);
+    
+    S2 = Meow128_AESDEC(S2, Meow128_AESDEC_Finalize(S3));
+    S0 = Meow128_AESDEC(S0, Meow128_AESDEC_Finalize(S1));
+    
+    S2 = Meow128_AESDEC(S2, Mixer);
+    
+    S0 = Meow128_AESDEC(S0, Meow128_AESDEC_Finalize(S2));
+    S0 = Meow128_AESDEC(S0, Mixer);
+    
+    meow_hash Result;
+    Meow128_CopyToHash(Meow128_AESDEC_Finalize(S0), Result);
+    
+    return(Result);
+}

data/ext/meowhash/meow_intrinsics.h

@@ -0,0 +1,261 @@
+/* ========================================================================
+
+   meow_intrinsics.h
+   (C) Copyright 2018 by Molly Rocket, Inc. (https://mollyrocket.com)
+   
+   See https://mollyrocket.com/meowhash for details.
+   
+   This is the default way to define all of the types and operations that
+   meow_hash.h needs.  However, if you've got your _own_ equivalent type
+   definitions and intrinsics, you can _omit_ this header file and just
+   #define/typedef all the Meow ops to map to your own ops, keeping things
+   nice and uniform in your codebase.
+   
+   ======================================================================== */
+
+#if !defined(MEOW_HASH_INTRINSICS_H)
+
+//
+// NOTE(casey): Try to guess the source file for compiler intrinsics
+//
+#if _MSC_VER
+
+#if _M_AMD64 || _M_IX86
+#include <intrin.h>
+#elif _M_ARM64
+#include <arm64_neon.h>
+#endif
+
+#else
+
+#if __x86_64__ || __i386__
+#include <x86intrin.h>
+#elif __aarch64__
+#include <arm_neon.h>
+#endif
+
+#endif
+
+//
+// NOTE(casey): Set #define's to their defaults
+//
+
+#if !defined(MEOW_HASH_INTEL) || !defined(MEOW_HASH_ARMV8)
+#if __x86_64__ || _M_AMD64
+#define MEOW_HASH_INTEL 1
+#define MEOW_64BIT 1
+#define MEOW_PAGESIZE 4096
+#elif __i386__  || _M_IX86
+#define MEOW_HASH_INTEL 1
+#define MEOW_64BIT 0
+#define MEOW_PAGESIZE 4096
+#elif __aarch64__ || _M_ARM64
+#define MEOW_HASH_ARMV8 1
+#define MEOW_64BIT 1
+#define MEOW_PAGESIZE 4096
+#else
+#error Cannot determine architecture to use!
+#endif
+#endif
+
+//
+// NOTE(casey): Define basic types
+//
+
+#define meow_u8 char unsigned
+#define meow_u16 short unsigned
+#define meow_u32 int unsigned
+#define meow_u64 long long unsigned
+
+#if MEOW_64BIT
+#define meow_umm long long unsigned
+#else
+#define meow_umm int unsigned
+#endif
+
+//
+// NOTE(casey): Operations for x64 processors
+//
+
+#if MEOW_HASH_INTEL
+
+#define meow_u128 __m128i
+#define meow_aes_128 __m128i
+#define meow_u256 __m256i
+#define meow_aes_256 __m256i
+#define meow_u512 __m512i
+#define meow_aes_512 __m512i
+
+#define MeowU32From(A, I) (_mm_extract_epi32((A), (I)))
+#define MeowU64From(A, I) (_mm_extract_epi64((A), (I)))
+#define MeowHashesAreEqual(A, B) (_mm_movemask_epi8(_mm_cmpeq_epi8((A), (B))) == 0xFFFF)
+
+#define Meow128_AESDEC(Prior, Xor) _mm_aesdec_si128((Prior), (Xor))
+#define Meow128_AESDEC_Mem(Prior, Xor) _mm_aesdec_si128((Prior), _mm_loadu_si128((meow_u128 *)(Xor)))
+#define Meow128_AESDEC_Finalize(A) (A)
+#define Meow128_Set64x2(Low64, High64) _mm_set_epi64x((High64), (Low64))
+#define Meow128_Set64x2_State(Low64, High64) Meow128_Set64x2(Low64, High64)
+#define Meow128_GetAESConstant(Ptr) (*(meow_u128 *)(Ptr))
+
+#define Meow128_And_Mem(A,B) _mm_and_si128((A),_mm_loadu_si128((meow_u128 *)(B)))
+#define Meow128_Shuffle_Mem(Mem,Control) _mm_shuffle_epi8(_mm_loadu_si128((meow_u128 *)(Mem)),_mm_loadu_si128((meow_u128 *)(Control)))
+
+// TODO(casey): Not sure if this should actually be Meow128_Zero(A) ((A) = _mm_setzero_si128()), maybe
+#define Meow128_Zero() _mm_setzero_si128()
+
+#define Meow256_AESDEC(Prior, XOr) _mm256_aesdec_epi128((Prior), (XOr))
+#define Meow256_AESDEC_Mem(Prior, XOr) _mm256_aesdec_epi128((Prior), *(meow_u256 *)(XOr))
+#define Meow256_Zero() _mm256_setzero_si256()
+#define Meow256_PartialLoad(A, B) _mm256_mask_loadu_epi8(_mm256_setzero_si256(), _cvtu32_mask32((1UL<<(B)) - 1), (A))
+#define Meow128_FromLow(A) _mm256_extracti128_si256((A), 0)
+#define Meow128_FromHigh(A) _mm256_extracti128_si256((A), 1)
+
+#define Meow512_AESDEC(Prior, XOr) _mm512_aesdec_epi128((Prior), (XOr))
+#define Meow512_AESDEC_Mem(Prior, XOr) _mm512_aesdec_epi128((Prior), *(meow_u512 *)(XOr))
+#define Meow512_Zero() _mm512_setzero_si512()
+#define Meow512_PartialLoad(A, B) _mm512_mask_loadu_epi8(_mm512_setzero_si512(), _cvtu64_mask64((1ULL<<(B)) - 1), (A))
+#define Meow256_FromLow(A) _mm512_extracti64x4_epi64((A), 0)
+#define Meow256_FromHigh(A) _mm512_extracti64x4_epi64((A), 1)
+
+//
+// NOTE(casey): Operations for ARM processors
+//
+
+#elif MEOW_HASH_ARMV8
+
+#define meow_u128 uint8x16_t
+
+// NOTE(mmozeiko): AES opcodes on ARMv8 work a bit differently than on Intel
+// On Intel the "x = AESDEC(x, m)" does following:
+//   x = InvMixColumns(SubBytes(ShiftRows(x))) ^ m
+// But on ARMv8 the "x = AESDEC(x, m)" does following:
+//   x = SubBytes(ShiftRows(x ^ m))
+// Thus on ARMv8 it requires extra InvMixColumns call and delay on Xor operation.
+// On iteration N it needs to use m[N-1] as input, and remeber m[N] for next iteration.
+// This structure will store memory operand in member B which will be used in
+// next AESDEC opcode. Remember to do one more XOR(A,B) when finishing AES
+// operations in a loop.
+typedef struct {
+    meow_u128 A;
+    meow_u128 B;
+} meow_aes_128;
+
+#define MeowU32From(A, I) (vgetq_lane_u32(vreinterpretq_u32_u8((A)), (I)))
+#define MeowU64From(A, I) (vgetq_lane_u64(vreinterpretq_u64_u8((A)), (I)))
+
+static int
+MeowHashesAreEqualImpl(meow_u128 A, meow_u128 B)
+{
+    uint8x16_t Powers = {
+        1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128,
+    };
+
+    uint8x16_t Input = vceqq_u8(A, B);
+    uint64x2_t Mask = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(vandq_u8(Input, Powers))));
+
+    meow_u16 Output;
+    vst1q_lane_u8((meow_u8*)&Output + 0, vreinterpretq_u8_u64(Mask), 0);
+    vst1q_lane_u8((meow_u8*)&Output + 1, vreinterpretq_u8_u64(Mask), 8);
+    return Output == 0xFFFF;
+}
+
+#define MeowHashesAreEqual(A, B) MeowHashesAreEqualImpl((A), (B))
+
+static meow_aes_128
+Meow128_AESDEC(meow_aes_128 Prior, meow_u128 Xor)
+{
+    meow_aes_128 R;
+    R.A = vaesimcq_u8(vaesdq_u8(Prior.A, Prior.B));
+    R.B = Xor;
+    return(R);
+}
+
+static meow_aes_128
+Meow128_AESDEC_Mem(meow_aes_128 Prior, void *Xor)
+{
+    meow_aes_128 R;
+    R.A = vaesimcq_u8(vaesdq_u8(Prior.A, Prior.B));
+    R.B = vld1q_u8((meow_u8*)Xor);
+    return(R);
+}
+
+static meow_u128
+Meow128_AESDEC_Finalize(meow_aes_128 Value)
+{
+    meow_u128 R = veorq_u8(Value.A, Value.B);
+    return(R);
+}
+
+static meow_u128
+Meow128_Zero()
+{
+    meow_u128 R = vdupq_n_u8(0);
+    return(R);
+}
+
+static meow_aes_128
+Meow128_GetAESConstant(const meow_u8 *Ptr)
+{
+    meow_aes_128 R;
+    R.A = vld1q_u8(Ptr);
+    R.B = vdupq_n_u8(0);
+    return(R);
+}
+
+static meow_u128
+Meow128_Set64x2(meow_u64 Low64, meow_u64 High64)
+{
+   meow_u128 R = vreinterpretq_u8_u64(vcombine_u64(vcreate_u64(Low64), vcreate_u64(High64)));
+   return(R);
+}
+
+static meow_aes_128
+Meow128_Set64x2_State(meow_u64 Low64, meow_u64 High64)
+{
+   meow_aes_128 R;
+   R.A = Meow128_Set64x2(Low64, High64);
+   R.B = Meow128_Zero();
+   return(R);
+}
+
+#define Meow128_And_Mem(A,B) vandq_u8((A), vld1q_u8((meow_u8 *)B))
+#define Meow128_Shuffle_Mem(Mem,Control) vqtbl1q_u8(vld1q_u8((meow_u8 *)(Mem)),vld1q_u8((meow_u8 *)(Control)))
+
+#endif
+
+#define MEOW_HASH_VERSION 4
+#define MEOW_HASH_VERSION_NAME "0.4/himalayan"
+
+#if MEOW_INCLUDE_C
+
+// NOTE(casey): Unfortunately, if you want an ANSI-C version, we have to slow everyone
+// else down because you can't return 128-bit values by register anymore (in case the
+// CPU doesn't support that)
+union meow_hash
+{
+    meow_u128 u128;
+    meow_u64 u64[2];
+    meow_u32 u32[4];
+};
+#define Meow128_CopyToHash(A, B) ((B).u128 = (A))
+
+#undef MeowU64From
+#undef MeowU32From
+#undef MeowHashesAreEqual
+#define MeowU32From(A, I) ((A).u32[I])
+#define MeowU64From(A, I) ((A).u64[I])
+#define MeowHashesAreEqual(A, B) (((A).u32[0] == (B).u32[0]) && ((A).u32[1] == (B).u32[1]) && ((A).u32[2] == (B).u32[2]) && ((A).u32[3] == (B).u32[3]))
+
+#else
+
+typedef meow_u128 meow_hash;
+#define Meow128_CopyToHash(A, B) ((B) = (A))
+
+#endif
+
+typedef struct meow_hash_state meow_hash_state;
+typedef meow_hash meow_hash_implementation(meow_u64 Seed, meow_u64 Len, void *Source);
+typedef void meow_absorb_implementation(struct meow_hash_state *State, meow_u64 Len, void *Source);
+
+#define MEOW_HASH_INTRINSICS_H
+#endif

data/ext/meowhash/meowhash.c

@@ -0,0 +1,48 @@
+#include <ruby.h>
+
+#include "meow_intrinsics.h"
+#include "meow_hash.h"
+
+#define VERSION "0.4"
+
+/*
+ */
+static VALUE 
+rb_meow_version(int argc, VALUE *argv, VALUE klass)
+{
+  return rb_sprintf("v%s", VERSION);
+}
+
+static void 
+to_chars(unsigned long n, unsigned char *bytes)
+{
+  bytes[0] = (n >> 24) & 0xFF;
+  bytes[1] = (n >> 16) & 0xFF;
+  bytes[2] = (n >> 8) & 0xFF;
+  bytes[3] = n & 0xFF;
+}
+
+static VALUE
+rb_meow_hash(VALUE self, VALUE toHash)
+{
+  Check_Type(toHash, T_STRING);
+  
+  meow_hash Hash = MeowHash_Accelerated(0, RSTRING_LEN(toHash), StringValuePtr(toHash));
+  unsigned char buffer[16];
+  to_chars(MeowU32From(Hash, 3), &buffer[0]);
+  to_chars(MeowU32From(Hash, 2), &buffer[4]);
+  to_chars(MeowU32From(Hash, 1), &buffer[8]);
+  to_chars(MeowU32From(Hash, 0), &buffer[12]);
+  VALUE rb_binary = rb_str_new(buffer, 16);
+  return rb_binary;
+}
+
+void
+Init_meowhash()
+{
+  VALUE mMH = rb_define_module("MeowHash");
+  VALUE cHasher = rb_define_module_under(mMH, "Hasher");
+
+  rb_define_module_function(cHasher, "version", rb_meow_version, 0);
+  rb_define_module_function(cHasher, "digest", rb_meow_hash, 1);
+}

data/lib/meowhash.rb

@@ -0,0 +1 @@
+require 'meowhash/meowhash'

data/meowhash.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+    s.name = 'meowhash'
+    s.version = '0.4.0'
+    s.summary = 'Meow Hash for Ruby'
+    s.description = <<-DOC
+      Meow Hash C extension for Ruby
+    DOC
+    s.homepage = 'https://github.com/alexsnaps/meowhash'
+    s.authors = ['Alex Snaps']
+    s.email   = ['alex.snaps@gmail.com']
+    s.license = 'zlib'
+  
+    s.files = `git ls-files`.split("\n")
+    s.extensions = ['ext/meowhash/extconf.rb']
+    s.add_development_dependency 'rake-compiler', '~> 1.0'
+    s.add_development_dependency 'test-unit'
+  end

data/test/test_meowhash.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'meowhash'
+
+class TestMeowHash < Test::Unit::TestCase
+  def test_version
+    assert MeowHash::Hasher.version() == "v0.4"
+  end
+
+  def test_hasher
+    assert_equal("0591045C3C3F33B515D7D2E366FBF082".downcase, MeowHash::Hasher.digest("toto").each_byte.map { |b| b.to_s(16).rjust(2,'0') }.join)
+  end
+
+  def test_raises_on_non_string
+    assert_raise TypeError do
+      MeowHash::Hasher.digest(42)
+    end
+  end
+
+  def test_meow_hash_version
+    file = File.open("ext/meowhash/meow_hash.h", "rb")
+    assert_equal("9F177F35D31536CDE904FF01EE0E9A72".downcase, MeowHash::Hasher.digest(file.read).each_byte.map { |b| b.to_s(16).rjust(2,'0') }.join)
+  end
+
+  def test_meow_intrinsics_version
+    file = File.open("ext/meowhash/meow_intrinsics.h", "rb")
+    assert_equal("B6F0D59805A037BFFC13AF959E08CC92".downcase, MeowHash::Hasher.digest(file.read).each_byte.map { |b| b.to_s(16).rjust(2,'0') }.join)
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: meowhash
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Alex Snaps
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "      Meow Hash C extension for Ruby\n"
+email:
+- alex.snaps@gmail.com
+executables: []
+extensions:
+- ext/meowhash/extconf.rb
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- Rakefile
+- ext/meowhash/extconf.rb
+- ext/meowhash/meow_hash.h
+- ext/meowhash/meow_intrinsics.h
+- ext/meowhash/meowhash.c
+- lib/meowhash.rb
+- meowhash.gemspec
+- test/test_meowhash.rb
+homepage: https://github.com/alexsnaps/meowhash
+licenses:
+- zlib
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Meow Hash for Ruby
+test_files: []