xxhash 0.2.0 → 0.3.0

data/ext/xxhash/libxxhash.h

@@ -1,7 +1,7 @@
 /*
-   xxHash - Fast Hash algorithm
+   xxHash - Extremely Fast Hash algorithm
    Header File
-   Copyright (C) 2012-2013, Yann Collet.
+   Copyright (C) 2012-2014, Yann Collet.
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
    Redistribution and use in source and binary forms, with or without
@@ -64,101 +64,93 @@ extern "C" {
 #endif
 
 
-//****************************
-// Type
-//****************************
+/*****************************
+   Includes
+*****************************/
+#include <stddef.h>   /* size_t */
+
+
+/*****************************
+   Type
+*****************************/
 typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
 
 
 
-//****************************
-// Simple Hash Functions
-//****************************
+/*****************************
+   Simple Hash Functions
+*****************************/
 
-unsigned int XXH32 (const void* input, int len, unsigned int seed);
+unsigned int       XXH32 (const void* input, size_t length, unsigned seed);
+unsigned long long XXH64 (const void* input, size_t length, unsigned long long seed);
 
 /*
 XXH32() :
-    Calculate the 32-bits hash of sequence of length "len" stored at memory address "input".
-    The memory between input & input+len must be valid (allocated and read-accessible).
+    Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input".
+    The memory between input & input+length must be valid (allocated and read-accessible).
     "seed" can be used to alter the result predictably.
     This function successfully passes all SMHasher tests.
     Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
-    Note that "len" is type "int", which means it is limited to 2^31-1.
-    If your data is larger, use the advanced functions below.
+XXH64() :
+    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
 */
 
 
 
-//****************************
-// Advanced Hash Functions
-//****************************
-
-void*         XXH32_init   (unsigned int seed);
-XXH_errorcode XXH32_update (void* state, const void* input, int len);
-unsigned int  XXH32_digest (void* state);
+/*****************************
+   Advanced Hash Functions
+*****************************/
+typedef struct { long long ll[ 6]; } XXH32_state_t;
+typedef struct { long long ll[11]; } XXH64_state_t;
 
 /*
-These functions calculate the xxhash of an input provided in several small packets,
-as opposed to an input provided as a single block.
+These structures allow static allocation of XXH states.
+States must then be initialized using XXHnn_reset() before first use.
 
-It must be started with :
-void* XXH32_init()
-The function returns a pointer which holds the state of calculation.
-
-This pointer must be provided as "void* state" parameter for XXH32_update().
-XXH32_update() can be called as many times as necessary.
-The user must provide a valid (allocated) input.
-The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
-Note that "len" is type "int", which means it is limited to 2^31-1.
-If your data is larger, it is recommended to chunk your data into blocks
-of size for example 2^30 (1GB) to avoid any "int" overflow issue.
-
-Finally, you can end the calculation anytime, by using XXH32_digest().
-This function returns the final 32-bits hash.
-You must provide the same "void* state" parameter created by XXH32_init().
-Memory will be freed by XXH32_digest().
+If you prefer dynamic allocation, please refer to functions below.
 */
 
+XXH32_state_t* XXH32_createState(void);
+XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
 
-int           XXH32_sizeofState();
-XXH_errorcode XXH32_resetState(void* state, unsigned int seed);
+XXH64_state_t* XXH64_createState(void);
+XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
 
-#define       XXH32_SIZEOFSTATE 48
-typedef struct { long long ll[(XXH32_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH32_stateSpace_t;
 /*
-These functions allow user application to make its own allocation for state.
+These functions create and release memory for XXH state.
+States must then be initialized using XXHnn_reset() before first use.
+*/
 
-XXH32_sizeofState() is used to know how much space must be allocated for the xxHash 32-bits state.
-Note that the state must be aligned to access 'long long' fields. Memory must be allocated and referenced by a pointer.
-This pointer must then be provided as 'state' into XXH32_resetState(), which initializes the state.
 
-For static allocation purposes (such as allocation on stack, or freestanding systems without malloc()),
-use the structure XXH32_stateSpace_t, which will ensure that memory space is large enough and correctly aligned to access 'long long' fields.
-*/
+XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned seed);
+XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+unsigned int  XXH32_digest (const XXH32_state_t* statePtr);
 
+XXH_errorcode      XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
+XXH_errorcode      XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
+unsigned long long XXH64_digest (const XXH64_state_t* statePtr);
 
-unsigned int XXH32_intermediateDigest (void* state);
 /*
-This function does the same as XXH32_digest(), generating a 32-bit hash,
-but preserve memory context.
-This way, it becomes possible to generate intermediate hashes, and then continue feeding data with XXH32_update().
-To free memory context, use XXH32_digest(), or free().
-*/
+These functions calculate the xxHash of an input provided in multiple smaller packets,
+as opposed to an input provided as a single block.
 
+XXH state space must first be allocated, using either static or dynamic method provided above.
 
+Start a new hash by initializing state with a seed, using XXHnn_reset().
 
-//****************************
-// Deprecated function names
-//****************************
-// The following translations are provided to ease code transition
-// You are encouraged to no longer this function names
-#define XXH32_feed   XXH32_update
-#define XXH32_result XXH32_digest
-#define XXH32_getIntermediateResult XXH32_intermediateDigest
+Then, feed the hash state by calling XXHnn_update() as many times as necessary.
+Obviously, input must be valid, meaning allocated and read accessible.
+The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
 
+Finally, you can produce a hash anytime, by using XXHnn_digest().
+This function returns the final nn-bits hash.
+You can nonetheless continue feeding the hash state with more input,
+and therefore get some new hashes, by calling again XXHnn_digest().
+
+When you are done, don't forget to free XXH state space, using typically XXHnn_freeState().
+*/
 
 
 #if defined (__cplusplus)
 }
-#endif
+#endif

data/ext/xxhash/xxhash.c

@@ -0,0 +1,109 @@
+#include "xxhash.h"
+
+VALUE xxhash_xxh32(VALUE mod, VALUE input, VALUE seed)
+{
+  return ULL2NUM(XXH32(StringValuePtr(input), (size_t)RSTRING_LEN(input), (unsigned int)NUM2ULL(seed)));
+}
+
+void xxhash32_streaming_hash_free(XXH32_state_t* state)
+{
+  // Digest frees the memory.
+  XXH32_freeState(state);
+}
+
+VALUE xxhash32_streaming_hash_new(VALUE klass, VALUE seed)
+{
+  XXH32_state_t* state = XXH32_createState();
+  XXH_errorcode code = XXH32_reset(state, (unsigned int)NUM2ULL(seed));
+  if(code != XXH_OK) {
+    rb_raise(rb_eRuntimeError, "Error during reset.");
+    return Qnil;
+  }
+  return Data_Wrap_Struct(klass, 0, xxhash32_streaming_hash_free, state);
+}
+
+VALUE xxhash32_streaming_hash_update(VALUE self, VALUE data)
+{
+  XXH32_state_t* state;
+  Data_Get_Struct(self, XXH32_state_t, state);
+
+  XXH_errorcode code = XXH32_update(state, StringValuePtr(data), (size_t)RSTRING_LEN(data));
+  if(code != XXH_OK) {
+    rb_raise(rb_eRuntimeError, "Error during update.");
+  }
+  return Qnil;
+}
+
+VALUE xxhash32_streaming_hash_digest(VALUE self)
+{
+  XXH32_state_t* state;
+  Data_Get_Struct(self, XXH32_state_t, state);
+
+  // Do not free memory now.
+  return ULL2NUM(XXH32_digest(state));
+}
+
+VALUE xxhash_xxh64(VALUE mod, VALUE input, VALUE seed)
+{
+  return ULL2NUM(XXH64(StringValuePtr(input), (size_t)RSTRING_LEN(input), (unsigned int)NUM2ULL(seed)));
+}
+
+void xxhash64_streaming_hash_free(XXH64_state_t* state)
+{
+  // Digest frees the memory.
+  XXH64_freeState(state);
+}
+
+VALUE xxhash64_streaming_hash_new(VALUE klass, VALUE seed)
+{
+  XXH64_state_t* state = XXH64_createState();
+  XXH_errorcode code = XXH64_reset(state, NUM2ULL(seed));
+  if(code != XXH_OK) {
+    rb_raise(rb_eRuntimeError, "Error during reset.");
+    return Qnil;
+  }
+  return Data_Wrap_Struct(klass, 0, xxhash64_streaming_hash_free, state);
+}
+
+VALUE xxhash64_streaming_hash_update(VALUE self, VALUE data)
+{
+  XXH64_state_t* state;
+  Data_Get_Struct(self, XXH64_state_t, state);
+
+  XXH_errorcode code = XXH64_update(state, StringValuePtr(data), (size_t)RSTRING_LEN(data));
+  if(code != XXH_OK) {
+    rb_raise(rb_eRuntimeError, "Error during update.");
+  }
+  return Qnil;
+}
+
+VALUE xxhash64_streaming_hash_digest(VALUE self)
+{
+  XXH64_state_t* state;
+  Data_Get_Struct(self, XXH64_state_t, state);
+
+  // Do not free memory now.
+  return ULL2NUM(XXH64_digest(state));
+}
+
+
+void Init_xxhash(void)
+{
+  VALUE mXXhash = rb_define_module("XXhash");
+  VALUE mInternal = rb_define_module_under(mXXhash, "XXhashInternal");
+
+  rb_define_singleton_method(mInternal, "xxh32", (ruby_method*) &xxhash_xxh32, 2);
+  rb_define_singleton_method(mInternal, "xxh64", (ruby_method*) &xxhash_xxh64, 2);
+
+  VALUE cStreamingHash = rb_define_class_under(mInternal, "StreamingHash32", rb_cObject);
+
+  rb_define_singleton_method(cStreamingHash, "new", (ruby_method*) &xxhash32_streaming_hash_new, 1);
+  rb_define_method(cStreamingHash, "update", (ruby_method*) &xxhash32_streaming_hash_update, 1);
+  rb_define_method(cStreamingHash, "digest", (ruby_method*) &xxhash32_streaming_hash_digest, 0);
+
+  VALUE cStreamingHash64 = rb_define_class_under(mInternal, "StreamingHash64", rb_cObject);
+
+  rb_define_singleton_method(cStreamingHash64, "new", (ruby_method*) &xxhash64_streaming_hash_new, 1);
+  rb_define_method(cStreamingHash64, "update", (ruby_method*) &xxhash64_streaming_hash_update, 1);
+  rb_define_method(cStreamingHash64, "digest", (ruby_method*) &xxhash64_streaming_hash_digest, 0);
+}

data/ext/xxhash/xxhash.h

@@ -0,0 +1,18 @@
+#include <ruby.h>
+#include "libxxhash.h"
+
+// Use this typedef to make the compiler happy when
+// calling rb_define_method()
+typedef VALUE (ruby_method)();
+
+VALUE xxhash_xxh32(VALUE mod, VALUE input, VALUE seed);
+void xxhash32_streaming_hash_free(XXH32_state_t* state);
+VALUE xxhash32_streaming_hash_new(VALUE klass, VALUE seed);
+VALUE xxhash32_streaming_hash_update(VALUE self, VALUE data);
+VALUE xxhash32_streaming_hash_digest(VALUE self);
+VALUE xxhash_xxh64(VALUE mod, VALUE input, VALUE seed);
+void xxhash64_streaming_hash_free(XXH64_state_t* state);
+VALUE xxhash64_streaming_hash_new(VALUE klass, VALUE seed);
+VALUE xxhash64_streaming_hash_update(VALUE self, VALUE data);
+VALUE xxhash64_streaming_hash_digest(VALUE self);
+void Init_xxhash(void);

data/lib/xxhash.rb

@@ -2,14 +2,30 @@ require 'xxhash/version'
 require 'xxhash/xxhash'
 
 module XXhash
-  def self.xxh32(input, seed)
-    Internal.xxh32(input, seed)
+  def self.xxh32(input, seed = 0)
+    XXhashInternal.xxh32(input, seed)
   end
 
-  def self.xxh32_stream(io, seed, chunk_size = 32)
+  def self.xxh64(input, seed = 0)
+    XXhashInternal.xxh64(input, seed)
+  end
+
+  def self.xxh32_stream(io, seed = 0, chunk_size = 32)
+    raise ArgumentError, 'first argument should be IO' if !io.is_a?(IO) && !io.is_a?(StringIO)
+
+    hash = XXhashInternal::StreamingHash32.new(seed)
+
+    while chunk = io.read(chunk_size)
+      hash.update(chunk)
+    end
+
+    hash.digest
+  end
+
+  def self.xxh64_stream(io, seed = 0, chunk_size = 32)
     raise ArgumentError, 'first argument should be IO' if !io.is_a?(IO) && !io.is_a?(StringIO)
 
-    hash = Internal::StreamingHash.new(seed)
+    hash = XXhashInternal::StreamingHash64.new(seed)
 
     while chunk = io.read(chunk_size)
       hash.update(chunk)

data/lib/xxhash/version.rb

@@ -1,3 +1,3 @@
 module XXhash
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/test/xxhash_test.rb

@@ -1,13 +1,23 @@
-require 'test_helper'
+require_relative 'test_helper'
 require 'stringio'
 
 describe XXhash do
-  it 'returns hash' do
+  it 'returns 32-bit hash' do
     assert_equal 2758658570, XXhash.xxh32('test', 123)
   end
 
-  describe 'StreamingHash' do
-    it 'rises ArgumentError if forst argument is not IO object' do
+  it 'returns 64-bit hash' do
+    assert_equal 3134990500624303823, XXhash.xxh64('test', 123)
+  end
+
+  it 'uses 0 (default value) if seed is not specified' do
+    assert_equal 1042293711, XXhash.xxh32('test')
+    assert_equal 5754696928334414137, XXhash.xxh64('test')
+  end
+
+  describe 'StreamingHash32' do
+
+    it 'rises ArgumentError if first argument is not IO object' do
       assert_raises(ArgumentError) do
         XXhash.xxh32_stream('test', 123)
       end
@@ -23,4 +33,22 @@ describe XXhash do
       assert_equal h1, h2
     end
   end
+
+  describe 'StreamingHash64' do
+    it 'rises ArgumentError if first argument is not IO object' do
+      assert_raises(ArgumentError) do
+        XXhash.xxh64_stream('test', 123)
+      end
+    end
+
+    it 'returns the hash for streamed strings' do
+      assert_equal 3134990500624303823, XXhash.xxh64_stream(StringIO.new('test'), 123)
+    end
+
+    it 'returns the hash for streamed files' do
+      h1 = XXhash.xxh64(File.read(__FILE__), 123)
+      h2 = XXhash.xxh64_stream(File.open(__FILE__), 123)
+      assert_equal h1, h2
+    end
+  end
 end

data/xxhash.gemspec

@@ -11,7 +11,8 @@ Gem::Specification.new do |gem|
   gem.description   = %q{Ruby wrapper for xxHash lib}
   gem.summary       = %q{Ruby wrapper for xxHash lib}
   gem.homepage      = "http://github.com/nashby/xxhash"
-
+  gem.license       = 'MIT'
+  
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xxhash
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Vasiliy Ermolovich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-04 00:00:00.000000000 Z
+date: 2015-01-18 00:00:00.000000000 Z
 dependencies: []
 description: Ruby wrapper for xxHash lib
 email:
@@ -19,8 +18,8 @@ extensions:
 - ext/xxhash/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -29,41 +28,36 @@ files:
 - ext/xxhash/extconf.rb
 - ext/xxhash/libxxhash.c
 - ext/xxhash/libxxhash.h
-- ext/xxhash/xxhash.cc
+- ext/xxhash/xxhash.c
+- ext/xxhash/xxhash.h
 - lib/xxhash.rb
 - lib/xxhash/version.rb
 - test/test_helper.rb
 - test/xxhash_test.rb
 - xxhash.gemspec
 homepage: http://github.com/nashby/xxhash
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3728750430932162062
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3728750430932162062
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby wrapper for xxHash lib
 test_files:
 - test/test_helper.rb