digest-xxhash 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 557c034e51c5ed220c3ebba704e0b6d5dbd415c4178b2fecf4d6adb153cb9562
-  data.tar.gz: 209905cf00b851386b306a5a61a8a8a8de42cc7d30159fea4384ffb060cbc114
+  metadata.gz: 5aa94f079152f6f34485582fffd2dfa9a405d7e202fef418d9c569c28404b99a
+  data.tar.gz: aaaceebacfe3616bb16f974e1a4611d79d9662baf72e4e84622f6ea91232e7cc
 SHA512:
-  metadata.gz: 528a1c15bf7aa8c9aecc9e86c4e953b1fefb6b38b64c64852cffd2dbc254550ef8062f6ebbb5324e6026cc69b4d32f0db2c865a4088dbff1ee1c7c5bf440b511
-  data.tar.gz: dec45992be6ff41b92f26ff55e06be1832a115ac2885aa012342cb51643950b35e8a18aaedfb445bd2da7bbaa110d008b5be9b11fbe8fd5f5ed71a87533edda8
+  metadata.gz: 3800479093f35a377f17faf7f41a7624ba5fecff8ce12a13a3b88cdd75ec79e053f216203e02399ad0557e741d6051159866a0d75279897fe2a053cb06370fce
+  data.tar.gz: 79c51f9b3bc4ef219419441133276b3b6cb90a2db53e7f44c2d0c7e277a6ed7918a4759aaf0c629660024f870f84b36a01241b6214caf8e7e1682d41f597682c

data/README.md

@@ -1,10 +1,11 @@
 # digest-xxhash
 
-This gem 'digest-xxhash' provides XXH32 and XXH64 functions for Ruby.  It
-inherits Digest::Class and complies with Digest::Instance's functional design.
+This gem provides XXH32, XXH64, XXH3_64bits and XXH3_128bits
+functionalities for Ruby.  It inherits Digest::Class and complies
+with Digest::Instance's functional design.
 
-Its core implementation was taken from the official source, which is
-in https://github.com/Cyan4973/xxHash.
+Its core implementation comes from the official source, which is in
+https://github.com/Cyan4973/xxHash.
 
 ## Installation
 
@@ -62,6 +63,18 @@ The library can also be installed in Gentoo system-wide using 'layman':
     Digest::XXH64.new.reset("0123456789abcdef").update("12").update("34").hexdigest
     => "d7544504de216507"
 
+    Digest::XXH3_64bits.hexdigest("1234", "0123456789abcdef")
+    => "4156724c7605b1be"
+
+    Digest::XXH3_64bits.new.reset_with_secret("abcd" * 34).update("1234").hexdigest
+    => "f7bbdbf9ec8c6394"
+
+    Digest::XXH3_128bits.hexdigest("1234", "0123456789abcdef") # XXH3_128bits() only allows 64-bit seeds
+    => "ad6108fb0b9a6b51b7f80d053c76c0fd"
+
+    Digest::XXH3_128bits.new.reset_with_secret("abcd" * 34).update("1234").hexdigest
+    => "0d44dd7fde8ea2b4ba961e1a26f71f21"
+
 ## API Documentation
 
 RubyGems.org provides autogenerated API documentation of the library in

data/Rakefile

@@ -1,10 +1,21 @@
 require 'bundler/gem_tasks'
+require 'rake/extensiontask'
 require 'rake/testtask'
 
 # clean, clobber, compile, and compile:digest/xxhash
-require 'rake/extensiontask'
 Rake::ExtensionTask.new('digest/xxhash', Bundler::GemHelper.gemspec)
 
+# install
+Rake::Task[:install].clear
+task :install => :build do
+  name = Bundler::GemHelper.gemspec.name
+  pkg_dir = File.join(Bundler::GemHelper.instance.base, "pkg")
+  built_gem = Dir.chdir(pkg_dir){ Dir.glob("#{name}-*.gem").sort_by{ |f| File.mtime(f) }.last }
+  gem_command = (ENV["GEM_COMMAND"].shellsplit rescue nil) || ["gem"]
+  options = ARGV.select{ |e| e =~ /\A--?/ }
+  Process.wait spawn(*gem_command, "install", File.join(pkg_dir, built_gem), *options)
+end
+
 # test
 Rake::TestTask.new(:test => :compile) do |t|
   t.test_files = FileList['test/test.rb']
@@ -17,7 +28,7 @@ task :clean do
   rm_f list unless list.empty?
 end
 
-# Set 'test' as default task.
+# default
 task :default => :test
 
 # Run `rake --tasks` for a list of tasks.

data/digest-xxhash.gemspec

@@ -9,15 +9,19 @@ Gem::Specification.new do |spec|
   spec.version       = Digest::XXHash::VERSION
   spec.authors       = ["konsolebox"]
   spec.email         = ["konsolebox@gmail.com"]
-  spec.summary       = "XXHash for Ruby"
-  spec.description   = "An XXHash library that complies with Digest::Instance's functional design."
+  spec.summary       = "A Digest framework based XXHash library for Ruby"
+  spec.description   = <<-EOF
+    This gem provides XXH32, XXH64, XXH3_64bits and XXH3_128bits
+    functionalities for Ruby.  It inherits Digest::Class and complies
+    with Digest::Instance's functional design.
+  EOF
   spec.homepage      = "https://github.com/konsolebox/digest-xxhash-ruby"
   spec.license       = "MIT"
 
   spec.required_ruby_version = '>= 2.2'
 
   spec.files         = `git ls-files -z`.split("\x0").reject{ |f| f =~ /\.yml$/ }
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{^bin/}){ |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 

data/ext/digest/xxhash/ext.c

@@ -25,9 +25,8 @@
 
 #include <ruby.h>
 #include <ruby/digest.h>
-#include <stdint.h>
 
-#define XXH_STATIC_LINKING_ONLY
+#define XXH_INLINE_ALL
 #include "xxhash.h"
 #include "utils.h"
 
@@ -38,14 +37,21 @@
 #endif
 
 #define _XXH32_DIGEST_SIZE 4
-#define _XXH64_DIGEST_SIZE 8
-
 #define _XXH32_BLOCK_SIZE 4
-#define _XXH64_BLOCK_SIZE 8
-
 #define _XXH32_DEFAULT_SEED 0
+
+#define _XXH64_DIGEST_SIZE 8
+#define _XXH64_BLOCK_SIZE 8
 #define _XXH64_DEFAULT_SEED 0
 
+#define _XXH3_64BITS_DIGEST_SIZE 8
+#define _XXH3_64BITS_BLOCK_SIZE 8
+#define _XXH3_64BITS_DEFAULT_SEED 0
+
+#define _XXH3_128BITS_DIGEST_SIZE 16
+#define _XXH3_128BITS_BLOCK_SIZE 16
+#define _XXH3_128BITS_DEFAULT_SEED 0
+
 #if 0
 #	define _DEBUG(...) fprintf(stderr, __VA_ARGS__)
 #else
@@ -66,8 +72,15 @@ static VALUE _Digest_Class;
 static VALUE _Digest_XXHash;
 static VALUE _Digest_XXH32;
 static VALUE _Digest_XXH64;
+static VALUE _Digest_XXH3_64bits;
+static VALUE _Digest_XXH3_128bits;
+
+#define _RSTRING_PTR_U(x) ((unsigned char *)RSTRING_PTR(x))
+#define _TWICE(x) (x * 2)
 
-#define _RSTRING_PTR_UCHAR(x) ((const unsigned char *)RSTRING_PTR(x))
+static void _xxh32_free_state(void *);
+static void _xxh64_free_state(void *);
+static void _xxh3_free_state(void *);
 
 /*
  * Data types
@@ -75,13 +88,25 @@ static VALUE _Digest_XXH64;
 
 static const rb_data_type_t _xxh32_state_data_type = {
 	"xxh32_state_data",
-	{ 0, RUBY_TYPED_DEFAULT_FREE, 0, }, 0, 0,
+	{ 0, _xxh32_free_state, 0, }, 0, 0,
 	RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
 };
 
 static const rb_data_type_t _xxh64_state_data_type = {
 	"xxh64_state_data",
-	{ 0, RUBY_TYPED_DEFAULT_FREE, 0, }, 0, 0,
+	{ 0, _xxh64_free_state, 0, }, 0, 0,
+	RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
+};
+
+static const rb_data_type_t _xxh3_64bits_state_data_type = {
+	"xxh3_64bits_state_data",
+	{ 0, _xxh3_free_state, 0, }, 0, 0,
+	RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
+};
+
+static const rb_data_type_t _xxh3_128bits_state_data_type = {
+	"xxh3_128bits_state_data",
+	{ 0, _xxh3_free_state, 0, }, 0, 0,
 	RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
 };
 
@@ -89,108 +114,93 @@ static const rb_data_type_t _xxh64_state_data_type = {
  * Common functions
  */
 
-static XXH32_state_t *_get_state_32(VALUE self)
+static XXH32_state_t *_get_state_xxh32(VALUE self)
 {
 	XXH32_state_t *state_p;
 	TypedData_Get_Struct(self, XXH32_state_t, &_xxh32_state_data_type, state_p);
 	return state_p;
 }
 
-static XXH64_state_t *_get_state_64(VALUE self)
+static XXH64_state_t *_get_state_xxh64(VALUE self)
 {
 	XXH64_state_t *state_p;
 	TypedData_Get_Struct(self, XXH64_state_t, &_xxh64_state_data_type, state_p);
 	return state_p;
 }
 
-static void _xxh32_reset(XXH32_state_t *state_p, uint32_t seed)
+static XXH3_state_t *_get_state_xxh3_64bits(VALUE self)
 {
-	if (XXH32_reset(state_p, seed) != XXH_OK)
-		rb_raise(rb_eRuntimeError, "Failed to reset state.");
+	XXH3_state_t *state_p;
+	TypedData_Get_Struct(self, XXH3_state_t, &_xxh3_64bits_state_data_type, state_p);
+	return state_p;
 }
 
-static void _xxh64_reset(XXH64_state_t *state_p, uint64_t seed)
+static XXH3_state_t *_get_state_xxh3_128bits(VALUE self)
 {
-	if (XXH64_reset(state_p, seed) != XXH_OK)
-		rb_raise(rb_eRuntimeError, "Failed to reset state.");
+	XXH3_state_t *state_p;
+	TypedData_Get_Struct(self, XXH3_state_t, &_xxh3_128bits_state_data_type, state_p);
+	return state_p;
 }
 
-static VALUE _encode_big_endian_32(uint32_t num)
+static void _xxh32_reset(XXH32_state_t *state_p, XXH32_hash_t seed)
 {
-	uint32_t temp;
-
-	if (is_little_endian()) {
-		temp = swap_uint32(num);
-	} else {
-		temp = num;
-	}
-
-	return rb_usascii_str_new((char *) &temp, sizeof(uint32_t));
+	if (XXH32_reset(state_p, seed) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state.");
 }
 
-static uint32_t _decode_big_endian_32_cstr(const char *str)
+static void _xxh64_reset(XXH64_state_t *state_p, XXH64_hash_t seed)
 {
-	uint32_t temp = read32(str);
-
-	if (is_little_endian()) {
-		return swap_uint32(temp);
-	} else {
-		return temp;
-	}
+	if (XXH64_reset(state_p, seed) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state.");
 }
 
-static uint32_t _decode_big_endian_32(VALUE str)
+static void _xxh3_64bits_reset(XXH3_state_t *state_p, XXH64_hash_t seed)
 {
-	return _decode_big_endian_32_cstr(RSTRING_PTR(str));
+	if (XXH3_64bits_reset_withSeed(state_p, seed) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state.");
 }
 
-static VALUE _encode_big_endian_64(uint64_t num)
+static void _xxh3_128bits_reset(XXH3_state_t *state_p, XXH64_hash_t seed)
 {
-	uint64_t temp;
-
-	if (is_little_endian()) {
-		temp = swap_uint64(num);
-	} else {
-		temp = num;
-	}
-
-	return rb_usascii_str_new((char *) &temp, sizeof(uint64_t));
+	if (XXH3_128bits_reset_withSeed(state_p, seed) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state.");
 }
 
-static uint64_t _decode_big_endian_64_cstr(const char *str)
+static void _xxh32_free_state(void* state)
 {
-	uint64_t temp = read64(str);
+	XXH32_freeState((XXH32_state_t *)state);
+}
 
-	if (is_little_endian()) {
-		return swap_uint64(temp);
-	} else {
-		return temp;
-	}
+static void _xxh64_free_state(void* state)
+{
+	XXH64_freeState((XXH64_state_t *)state);
 }
 
-static uint64_t _decode_big_endian_64(VALUE str)
+static void _xxh3_free_state(void* state)
 {
-	return _decode_big_endian_64_cstr(RSTRING_PTR(str));
+	XXH3_freeState((XXH3_state_t *)state);
 }
 
 static VALUE _hex_encode_str(VALUE str)
 {
 	int len = RSTRING_LEN(str);
-	VALUE hex = rb_str_new(0, len * 2);
-	hex_encode_str_implied(_RSTRING_PTR_UCHAR(str), len, (unsigned char *)RSTRING_PTR(hex));
+	VALUE hex = rb_usascii_str_new(0, _TWICE(len));
+	hex_encode_str_implied(_RSTRING_PTR_U(str), len, _RSTRING_PTR_U(hex));
 	return hex;
 }
 
 /*
  * Document-class: Digest::XXHash
  *
- * This is the base class of Digest::XXH32 and Digest::XXH64.
+ * This is the base class of Digest::XXH32, Digest::XXH64,
+ * Digest::XXH3_64bits, and Digest::XXH3_128bits.
  */
 
 static VALUE _Digest_XXHash_internal_allocate(VALUE klass)
 {
 	if (klass == _Digest_XXHash)
-		rb_raise(rb_eRuntimeError, "Digest::XXHash is an incomplete class and cannot be instantiated.");
+		rb_raise(rb_eRuntimeError, "Digest::XXHash is an incomplete class and cannot be "
+				"instantiated.");
 
 	rb_raise(rb_eNotImpError, "Allocator function not implemented.");
 }
@@ -260,8 +270,9 @@ static VALUE _do_digest(int argc, VALUE* argv, VALUE self, ID finish_method_id)
  * with +seed+, and is used as the return value.  The instance's state is reset
  * to default afterwards.
  *
- * Providing an argument means that previous calculations done with #update
- * would be discarded, so be careful with its use.
+ * Providing an argument means that previous initializations done with custom
+ * seeds or secrets, and previous calculations done with #update would be
+ * discarded, so be careful with its use.
  *
  * +seed+ can be in the form of a string, a hex string, or a number.
  */
@@ -280,9 +291,7 @@ static VALUE _Digest_XXHash_digest(int argc, VALUE* argv, VALUE self)
  */
 static VALUE _Digest_XXHash_hexdigest(int argc, VALUE* argv, VALUE self)
 {
-	VALUE result;
-	result = _do_digest(argc, argv, self, _id_finish);
-	return _hex_encode_str(result);
+	return _hex_encode_str(_do_digest(argc, argv, self, _id_finish));
 }
 
 /*
@@ -403,10 +412,9 @@ static VALUE _Digest_XXHash_singleton_idigest(int argc, VALUE* argv, VALUE self)
 
 static VALUE _Digest_XXH32_internal_allocate(VALUE klass)
 {
-	XXH32_state_t *state_p;
-	VALUE obj = TypedData_Make_Struct(klass, XXH32_state_t, &_xxh32_state_data_type, state_p);
+	XXH32_state_t *state_p = XXH32_createState();
 	_xxh32_reset(state_p, 0);
-	return obj;
+	return TypedData_Wrap_Struct(klass, &_xxh32_state_data_type, state_p);
 }
 
 /*
@@ -416,7 +424,7 @@ static VALUE _Digest_XXH32_internal_allocate(VALUE klass)
  */
 static VALUE _Digest_XXH32_update(VALUE self, VALUE str)
 {
-	if (XXH32_update(_get_state_32(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
+	if (XXH32_update(_get_state_xxh32(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
 		rb_raise(rb_eRuntimeError, "Failed to update state.");
 
 	return self;
@@ -425,15 +433,17 @@ static VALUE _Digest_XXH32_update(VALUE self, VALUE str)
 /* :nodoc: */
 static VALUE _Digest_XXH32_finish(VALUE self)
 {
-	uint32_t result = XXH32_digest(_get_state_32(self));
-	return _encode_big_endian_32(result);
+	XXH64_hash_t hash = XXH32_digest(_get_state_xxh32(self));
+	VALUE str = rb_usascii_str_new(0, sizeof(XXH32_canonical_t));
+	XXH32_canonicalFromHash((XXH32_canonical_t *)RSTRING_PTR(str), hash);
+	return str;
 }
 
 /* :nodoc: */
 static VALUE _Digest_XXH32_ifinish(VALUE self)
 {
-	uint32_t result = XXH32_digest(_get_state_32(self));
-	return ULONG2NUM(result);
+	XXH32_hash_t hash = XXH32_digest(_get_state_xxh32(self));
+	return ULONG2NUM(hash);
 }
 
 /*
@@ -441,9 +451,10 @@ static VALUE _Digest_XXH32_ifinish(VALUE self)
  *
  * Resets state to initial form with seed.
  *
- * This would discard previous calculations with #update.
+ * This discards previous calculations with #update.
  *
  * +seed+ can be in the form of a string, a hex string, or a number.
+ * Its virtual length should be 32-bits.
  *
  * If +seed+ is not provided, the default value would be 0.
  */
@@ -456,36 +467,39 @@ static VALUE _Digest_XXH32_reset(int argc, VALUE* argv, VALUE self)
 		case T_STRING:
 			{
 				int len = RSTRING_LEN(seed);
-				uint32_t decoded_seed;
+				XXH32_hash_t decoded_seed;
 
-				if (len == (sizeof(uint32_t) * 2)) {
-					unsigned char hex_decoded_seed[sizeof(uint32_t)];
+				if (len == _TWICE(sizeof(XXH32_hash_t))) {
+					unsigned char hex_decoded_seed[sizeof(XXH32_hash_t)];
 
-					if (! hex_decode_str_implied(_RSTRING_PTR_UCHAR(seed), sizeof(uint32_t) * 2, hex_decoded_seed))
-						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n", StringValueCStr(seed));
+					if (! hex_decode_str_implied(_RSTRING_PTR_U(seed), len, hex_decoded_seed))
+						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n",
+								StringValueCStr(seed));
 
-					decoded_seed = _decode_big_endian_32_cstr((const char *)hex_decoded_seed);
-				} else if (len == sizeof(uint32_t)) {
-					decoded_seed = _decode_big_endian_32(seed);
+					decoded_seed = XXH_readBE32(hex_decoded_seed);
+				} else if (len == sizeof(XXH32_hash_t)) {
+					decoded_seed = XXH_readBE32(RSTRING_PTR(seed));
 				} else {
-					rb_raise(rb_eArgError, "Invalid seed length.  Expecting an 8-character hex string or a 4-byte string.");
+					rb_raise(rb_eArgError, "Invalid seed length.  "
+							"Expecting an 8-character hex string or a 4-byte string.");
 				}
 
-				_xxh32_reset(_get_state_32(self), decoded_seed);
+				_xxh32_reset(_get_state_xxh32(self), decoded_seed);
 			}
 
 			break;
 		case T_FIXNUM:
-			_xxh32_reset(_get_state_32(self), FIX2UINT(seed));
+			_xxh32_reset(_get_state_xxh32(self), FIX2UINT(seed));
 			break;
 		case T_BIGNUM:
-			_xxh32_reset(_get_state_32(self), NUM2UINT(seed));
+			_xxh32_reset(_get_state_xxh32(self), NUM2UINT(seed));
 			break;
 		default:
-			rb_raise(rb_eArgError, "Invalid argument type for seed.  Expecting a string or number.");
+			rb_raise(rb_eArgError, "Invalid argument type for 'seed'.  "
+					"Expecting a string or a number.");
 		}
 	} else {
-		_xxh32_reset(_get_state_32(self), _XXH32_DEFAULT_SEED);
+		_xxh32_reset(_get_state_xxh32(self), _XXH32_DEFAULT_SEED);
 	}
 
 	return self;
@@ -499,14 +513,14 @@ static VALUE _Digest_XXH32_reset(int argc, VALUE* argv, VALUE self)
  */
 static VALUE _Digest_XXH32_initialize_copy(VALUE self, VALUE orig)
 {
-	XXH32_copyState(_get_state_32(self), _get_state_32(orig));
+	XXH32_copyState(_get_state_xxh32(self), _get_state_xxh32(orig));
 	return self;
 }
 
 /*
  * call-seq: digest_length -> int
  *
- * Returns 4.
+ * Returns 4
  */
 static VALUE _Digest_XXH32_digest_length(VALUE self)
 {
@@ -516,7 +530,7 @@ static VALUE _Digest_XXH32_digest_length(VALUE self)
 /*
  * call-seq: block_length  -> int
  *
- * Returns 4.
+ * Returns 4
  */
 static VALUE _Digest_XXH32_block_length(VALUE self)
 {
@@ -526,7 +540,7 @@ static VALUE _Digest_XXH32_block_length(VALUE self)
 /*
  * call-seq: digest_length -> int
  *
- * Returns 4.
+ * Returns 4
  */
 static VALUE _Digest_XXH32_singleton_digest_length(VALUE self)
 {
@@ -536,7 +550,7 @@ static VALUE _Digest_XXH32_singleton_digest_length(VALUE self)
 /*
  * call-seq: block_length -> int
  *
- * Returns 4.
+ * Returns 4
  */
 static VALUE _Digest_XXH32_singleton_block_length(VALUE self)
 {
@@ -551,10 +565,9 @@ static VALUE _Digest_XXH32_singleton_block_length(VALUE self)
 
 static VALUE _Digest_XXH64_internal_allocate(VALUE klass)
 {
-	XXH64_state_t *state_p;
-	VALUE obj = TypedData_Make_Struct(klass, XXH64_state_t, &_xxh64_state_data_type, state_p);
+	XXH64_state_t *state_p = XXH64_createState();
 	_xxh64_reset(state_p, 0);
-	return obj;
+	return TypedData_Wrap_Struct(klass, &_xxh64_state_data_type, state_p);
 }
 
 /*
@@ -564,7 +577,7 @@ static VALUE _Digest_XXH64_internal_allocate(VALUE klass)
  */
 static VALUE _Digest_XXH64_update(VALUE self, VALUE str)
 {
-	if (XXH64_update(_get_state_64(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
+	if (XXH64_update(_get_state_xxh64(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
 		rb_raise(rb_eRuntimeError, "Failed to update state.");
 
 	return self;
@@ -573,15 +586,17 @@ static VALUE _Digest_XXH64_update(VALUE self, VALUE str)
 /* :nodoc: */
 static VALUE _Digest_XXH64_finish(VALUE self)
 {
-	uint64_t result = XXH64_digest(_get_state_64(self));
-	return _encode_big_endian_64(result);
+	XXH64_hash_t hash = XXH64_digest(_get_state_xxh64(self));
+	VALUE str = rb_usascii_str_new(0, sizeof(XXH64_canonical_t));
+	XXH64_canonicalFromHash((XXH64_canonical_t *)RSTRING_PTR(str), hash);
+	return str;
 }
 
 /* :nodoc: */
 static VALUE _Digest_XXH64_ifinish(VALUE self)
 {
-	uint64_t result = XXH64_digest(_get_state_64(self));
-	return ULL2NUM(result);
+	XXH64_hash_t hash = XXH64_digest(_get_state_xxh64(self));
+	return ULL2NUM(hash);
 }
 
 /*
@@ -589,9 +604,10 @@ static VALUE _Digest_XXH64_ifinish(VALUE self)
  *
  * Resets state to initial form with seed.
  *
- * This would discard previous calculations with #update.
+ * This discards previous calculations with #update.
  *
  * +seed+ can be in the form of a string, a hex string, or a number.
+ * Its virtual length should be 64-bits.
  *
  * If +seed+ is not provided, the default value would be 0.
  */
@@ -604,36 +620,39 @@ static VALUE _Digest_XXH64_reset(int argc, VALUE* argv, VALUE self)
 		case T_STRING:
 			{
 				int len = RSTRING_LEN(seed);
-				uint64_t decoded_seed;
+				XXH64_hash_t decoded_seed;
 
-				if (len == (sizeof(uint64_t) * 2)) {
-					unsigned char hex_decoded_seed[sizeof(uint64_t)];
+				if (len == _TWICE(sizeof(XXH64_hash_t))) {
+					unsigned char hex_decoded_seed[sizeof(XXH64_hash_t)];
 
-					if (! hex_decode_str_implied(_RSTRING_PTR_UCHAR(seed), sizeof(uint64_t) * 2, hex_decoded_seed))
-						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n", StringValueCStr(seed));
+					if (! hex_decode_str_implied(_RSTRING_PTR_U(seed), len, hex_decoded_seed))
+						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n",
+								StringValueCStr(seed));
 
-					decoded_seed = _decode_big_endian_64_cstr((const char *)hex_decoded_seed);
-				} else if (len == sizeof(uint64_t)) {
-					decoded_seed = _decode_big_endian_64(seed);
+					decoded_seed = XXH_readBE64(hex_decoded_seed);
+				} else if (len == sizeof(XXH64_hash_t)) {
+					decoded_seed = XXH_readBE64(RSTRING_PTR(seed));
 				} else {
-					rb_raise(rb_eArgError, "Invalid seed length.  Expecting a 16-character hex string or an 8-byte string.");
+					rb_raise(rb_eArgError, "Invalid seed length.  "
+							"Expecting a 16-character hex string or an 8-byte string.");
 				}
 
-				_xxh64_reset(_get_state_64(self), decoded_seed);
+				_xxh64_reset(_get_state_xxh64(self), decoded_seed);
 			}
 
 			break;
 		case T_FIXNUM:
-			_xxh64_reset(_get_state_64(self), FIX2UINT(seed));
+			_xxh64_reset(_get_state_xxh64(self), FIX2UINT(seed));
 			break;
 		case T_BIGNUM:
-			_xxh64_reset(_get_state_64(self), NUM2ULL(seed));
+			_xxh64_reset(_get_state_xxh64(self), NUM2ULL(seed));
 			break;
 		default:
-			rb_raise(rb_eArgError, "Invalid argument type for seed.  Expecting a string or number.");
+			rb_raise(rb_eArgError, "Invalid argument type for 'seed'.  "
+					"Expecting a string or a number.");
 		}
 	} else {
-		_xxh64_reset(_get_state_64(self), _XXH64_DEFAULT_SEED);
+		_xxh64_reset(_get_state_xxh64(self), _XXH64_DEFAULT_SEED);
 	}
 
 	return self;
@@ -647,14 +666,14 @@ static VALUE _Digest_XXH64_reset(int argc, VALUE* argv, VALUE self)
  */
 static VALUE _Digest_XXH64_initialize_copy(VALUE self, VALUE orig)
 {
-	XXH64_copyState(_get_state_64(self), _get_state_64(orig));
+	XXH64_copyState(_get_state_xxh64(self), _get_state_xxh64(orig));
 	return self;
 }
 
 /*
  * call-seq: digest_length -> int
  *
- * Returns 8.
+ * Returns 8
  */
 static VALUE _Digest_XXH64_digest_length(VALUE self)
 {
@@ -664,7 +683,7 @@ static VALUE _Digest_XXH64_digest_length(VALUE self)
 /*
  * call-seq: block_length -> int
  *
- * Returns 8.
+ * Returns 8
  */
 static VALUE _Digest_XXH64_block_length(VALUE self)
 {
@@ -674,7 +693,7 @@ static VALUE _Digest_XXH64_block_length(VALUE self)
 /*
  * call-seq: digest_length -> int
  *
- * Returns 8.
+ * Returns 8
  */
 static VALUE _Digest_XXH64_singleton_digest_length(VALUE self)
 {
@@ -684,13 +703,378 @@ static VALUE _Digest_XXH64_singleton_digest_length(VALUE self)
 /*
  * call-seq: block_length -> int
  *
- * Returns 8.
+ * Returns 8
  */
 static VALUE _Digest_XXH64_singleton_block_length(VALUE self)
 {
 	return INT2FIX(_XXH64_BLOCK_SIZE);
 }
 
+/*
+ * Document-class: Digest::XXH3_64bits
+ *
+ * This class implements XXH3_64bits.
+ */
+
+static VALUE _Digest_XXH3_64bits_internal_allocate(VALUE klass)
+{
+	XXH3_state_t *state_p = XXH3_createState();
+	XXH3_64bits_reset(state_p);
+	return TypedData_Wrap_Struct(klass, &_xxh3_64bits_state_data_type, state_p);
+}
+
+/*
+ * call-seq: update(str) -> self
+ *
+ * Updates current digest value with string.
+ */
+static VALUE _Digest_XXH3_64bits_update(VALUE self, VALUE str)
+{
+	if (XXH3_64bits_update(_get_state_xxh3_64bits(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to update state.");
+
+	return self;
+}
+
+/* :nodoc: */
+static VALUE _Digest_XXH3_64bits_finish(VALUE self)
+{
+	XXH64_hash_t hash = XXH3_64bits_digest(_get_state_xxh3_64bits(self));
+	VALUE str = rb_usascii_str_new(0, sizeof(XXH64_canonical_t));
+	XXH64_canonicalFromHash((XXH64_canonical_t *)RSTRING_PTR(str), hash);
+	return str;
+}
+
+/* :nodoc: */
+static VALUE _Digest_XXH3_64bits_ifinish(VALUE self)
+{
+	XXH64_hash_t hash = XXH3_64bits_digest(_get_state_xxh3_64bits(self));
+	return ULL2NUM(hash);
+}
+
+/*
+ * call-seq: reset(seed = 0) -> self
+ *
+ * Resets state to initial form with seed.
+ *
+ * This discards previous calculations with #update.
+ *
+ * +seed+ can be in the form of a string, a hex string, or a number.
+ * Its virtual length should be 64-bits.
+ *
+ * If +seed+ is not provided, the default value would be 0.
+ */
+static VALUE _Digest_XXH3_64bits_reset(int argc, VALUE* argv, VALUE self)
+{
+	VALUE seed;
+
+	if (rb_scan_args(argc, argv, "01", &seed) > 0) {
+		switch (TYPE(seed)) {
+		case T_STRING:
+			{
+				int len = RSTRING_LEN(seed);
+				XXH64_hash_t decoded_seed;
+
+				if (len == _TWICE(sizeof(XXH64_hash_t))) {
+					unsigned char hex_decoded_seed[sizeof(XXH64_hash_t)];
+
+					if (! hex_decode_str_implied(_RSTRING_PTR_U(seed), len, hex_decoded_seed))
+						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n",
+								StringValueCStr(seed));
+
+					decoded_seed = XXH_readBE64(hex_decoded_seed);
+				} else if (len == sizeof(XXH64_hash_t)) {
+					decoded_seed = XXH_readBE64(RSTRING_PTR(seed));
+				} else {
+					rb_raise(rb_eArgError, "Invalid seed length.  "
+							"Expecting a 16-character hex string or an 8-byte string.");
+				}
+
+				_xxh3_64bits_reset(_get_state_xxh3_64bits(self), decoded_seed);
+			}
+
+			break;
+		case T_FIXNUM:
+			_xxh3_64bits_reset(_get_state_xxh3_64bits(self), FIX2UINT(seed));
+			break;
+		case T_BIGNUM:
+			_xxh3_64bits_reset(_get_state_xxh3_64bits(self), NUM2ULL(seed));
+			break;
+		default:
+			rb_raise(rb_eArgError, "Invalid argument type for 'seed'.  "
+					"Expecting a string or a number.");
+		}
+	} else {
+		_xxh3_64bits_reset(_get_state_xxh3_64bits(self), _XXH3_64BITS_DEFAULT_SEED);
+	}
+
+	return self;
+}
+
+/*
+ * call-seq: reset_with_secret(secret) -> self
+ *
+ * Resets state to initial form using a secret.
+ *
+ * This discards previous calculations with #update.
+ *
+ * Secret should be a string and have a minimum length of XXH3_SECRET_SIZE_MIN.
+ */
+static VALUE _Digest_XXH3_64bits_reset_with_secret(VALUE self, VALUE secret)
+{
+	if (TYPE(secret) != T_STRING)
+		rb_raise(rb_eArgError, "Argument 'secret' needs to be a string.");
+
+	if (RSTRING_LEN(secret) < XXH3_SECRET_SIZE_MIN)
+		rb_raise(rb_eRuntimeError, "Secret needs to be at least %d bytes in length.",
+				XXH3_SECRET_SIZE_MIN);
+
+	if (XXH3_64bits_reset_withSecret(_get_state_xxh3_64bits(self), RSTRING_PTR(secret),
+			RSTRING_LEN(secret)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state with secret.");
+
+	return self;
+}
+
+/*
+ * call-seq: initialize_copy(orig) -> self
+ *
+ * This method is called when instances are cloned.  It is responsible for
+ * replicating internal data.
+ */
+static VALUE _Digest_XXH3_64bits_initialize_copy(VALUE self, VALUE orig)
+{
+	XXH3_copyState(_get_state_xxh3_64bits(self), _get_state_xxh3_64bits(orig));
+	return self;
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns 8
+ */
+static VALUE _Digest_XXH3_64bits_digest_length(VALUE self)
+{
+	return INT2FIX(_XXH3_64BITS_DIGEST_SIZE);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns 8
+ */
+static VALUE _Digest_XXH3_64bits_block_length(VALUE self)
+{
+	return INT2FIX(_XXH3_64BITS_BLOCK_SIZE);
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns 8
+ */
+static VALUE _Digest_XXH3_64bits_singleton_digest_length(VALUE self)
+{
+	return INT2FIX(_XXH3_64BITS_DIGEST_SIZE);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns 8
+ */
+static VALUE _Digest_XXH3_64bits_singleton_block_length(VALUE self)
+{
+	return INT2FIX(_XXH3_64BITS_BLOCK_SIZE);
+}
+
+/*
+ * Document-class: Digest::XXH3_128bits
+ *
+ * This class implements XXH3_128bits.
+ */
+
+static VALUE _Digest_XXH3_128bits_internal_allocate(VALUE klass)
+{
+	XXH3_state_t *state_p = XXH3_createState();
+	XXH3_128bits_reset(state_p);
+	return TypedData_Wrap_Struct(klass, &_xxh3_128bits_state_data_type, state_p);
+}
+
+/*
+ * call-seq: update(str) -> self
+ *
+ * Updates current digest value with string.
+ */
+static VALUE _Digest_XXH3_128bits_update(VALUE self, VALUE str)
+{
+	if (XXH3_128bits_update(_get_state_xxh3_128bits(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to update state.");
+
+	return self;
+}
+
+/* :nodoc: */
+static VALUE _Digest_XXH3_128bits_finish(VALUE self)
+{
+	XXH128_hash_t hash = XXH3_128bits_digest(_get_state_xxh3_128bits(self));
+	VALUE str = rb_usascii_str_new(0, sizeof(XXH128_canonical_t));
+	XXH128_canonicalFromHash((XXH128_canonical_t *)RSTRING_PTR(str), hash);
+	return str;
+}
+
+/* :nodoc: */
+static VALUE _Digest_XXH3_128bits_ifinish(VALUE self)
+{
+	XXH128_hash_t hash = XXH3_128bits_digest(_get_state_xxh3_128bits(self));
+
+	if (! XXH_CPU_LITTLE_ENDIAN) {
+		#define _SWAP_WORDS(x) ((x << 32) & 0xffffffff00000000ULL) | \
+			((x >> 32) & 0x000000000ffffffffULL)
+		hash.low64 = _SWAP_WORDS(hash.low64);
+		hash.high64 = _SWAP_WORDS(hash.high64);
+	}
+
+	return rb_integer_unpack(&hash, 4, sizeof(XXH32_hash_t), 0, INTEGER_PACK_LSWORD_FIRST|
+			INTEGER_PACK_NATIVE_BYTE_ORDER);
+}
+
+/*
+ * call-seq: reset(seed = 0) -> self
+ *
+ * Resets state to initial form with seed.
+ *
+ * This discards previous calculations with #update.
+ *
+ * +seed+ can be in the form of a string, a hex string, or a number.
+ * Its virtual length should be 64-bits and not 128-bits.
+ *
+ * If +seed+ is not provided, the default value would be 0.
+ */
+static VALUE _Digest_XXH3_128bits_reset(int argc, VALUE* argv, VALUE self)
+{
+	VALUE seed;
+
+	if (rb_scan_args(argc, argv, "01", &seed) > 0) {
+		switch (TYPE(seed)) {
+		case T_STRING:
+			{
+				int len = RSTRING_LEN(seed);
+				XXH64_hash_t decoded_seed;
+
+				if (len == _TWICE(sizeof(XXH64_hash_t))) {
+					unsigned char hex_decoded_seed[sizeof(XXH64_hash_t)];
+
+					if (! hex_decode_str_implied(_RSTRING_PTR_U(seed), len, hex_decoded_seed))
+						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n",
+								StringValueCStr(seed));
+
+					decoded_seed = XXH_readBE64(hex_decoded_seed);
+				} else if (len == sizeof(XXH64_hash_t)) {
+					decoded_seed = XXH_readBE64(RSTRING_PTR(seed));
+				} else {
+					rb_raise(rb_eArgError, "Invalid seed length.  Expecting a 16-character hex "
+							"string or an 8-byte string.");
+				}
+
+				_xxh3_128bits_reset(_get_state_xxh3_128bits(self), decoded_seed);
+			}
+
+			break;
+		case T_FIXNUM:
+			_xxh3_128bits_reset(_get_state_xxh3_128bits(self), FIX2UINT(seed));
+			break;
+		case T_BIGNUM:
+			_xxh3_128bits_reset(_get_state_xxh3_128bits(self), NUM2ULL(seed));
+			break;
+		default:
+			rb_raise(rb_eArgError, "Invalid argument type for 'seed'.  "
+					"Expecting a string or a number.");
+		}
+	} else {
+		_xxh3_128bits_reset(_get_state_xxh3_128bits(self), _XXH3_128BITS_DEFAULT_SEED);
+	}
+
+	return self;
+}
+
+/*
+ * call-seq: reset_with_secret(secret) -> self
+ *
+ * Resets state to initial form using a secret.
+ *
+ * This discards previous calculations with #update.
+ *
+ * Secret should be a string having a minimum length of XXH3_SECRET_SIZE_MIN.
+ */
+static VALUE _Digest_XXH3_128bits_reset_with_secret(VALUE self, VALUE secret)
+{
+	if (TYPE(secret) != T_STRING)
+		rb_raise(rb_eArgError, "Argument 'secret' needs to be a string.");
+
+	if (RSTRING_LEN(secret) < XXH3_SECRET_SIZE_MIN)
+		rb_raise(rb_eRuntimeError, "Secret needs to be at least %d bytes in length.",
+				XXH3_SECRET_SIZE_MIN);
+
+	if (XXH3_128bits_reset_withSecret(_get_state_xxh3_128bits(self), RSTRING_PTR(secret),
+			RSTRING_LEN(secret)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state with secret.");
+
+	return self;
+}
+
+/*
+ * call-seq: initialize_copy(orig) -> self
+ *
+ * This method is called when instances are cloned.  It is responsible for
+ * replicating internal data.
+ */
+static VALUE _Digest_XXH3_128bits_initialize_copy(VALUE self, VALUE orig)
+{
+	XXH3_copyState(_get_state_xxh3_128bits(self), _get_state_xxh3_128bits(orig));
+	return self;
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns 16
+ */
+static VALUE _Digest_XXH3_128bits_digest_length(VALUE self)
+{
+	return INT2FIX(_XXH3_128BITS_DIGEST_SIZE);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns 16
+ */
+static VALUE _Digest_XXH3_128bits_block_length(VALUE self)
+{
+	return INT2FIX(_XXH3_128BITS_BLOCK_SIZE);
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns 16
+ */
+static VALUE _Digest_XXH3_128bits_singleton_digest_length(VALUE self)
+{
+	return INT2FIX(_XXH3_128BITS_DIGEST_SIZE);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns 16
+ */
+static VALUE _Digest_XXH3_128bits_singleton_block_length(VALUE self)
+{
+	return INT2FIX(_XXH3_128BITS_BLOCK_SIZE);
+}
+
 /*
  * Initialization
  */
@@ -723,7 +1107,7 @@ void Init_xxhash()
 	 */
 
 	_Digest_XXHash = rb_define_class_under(_Digest, "XXHash", _Digest_Class);
-
+	rb_define_alloc_func(_Digest_XXHash, _Digest_XXHash_internal_allocate);
 	rb_define_method(_Digest_XXHash, "digest", _Digest_XXHash_digest, -1);
 	rb_define_method(_Digest_XXHash, "hexdigest", _Digest_XXHash_hexdigest, -1);
 	rb_define_method(_Digest_XXHash, "idigest", _Digest_XXHash_idigest, -1);
@@ -731,32 +1115,24 @@ void Init_xxhash()
 	rb_define_method(_Digest_XXHash, "initialize", _Digest_XXHash_initialize, -1);
 	rb_define_method(_Digest_XXHash, "inspect", _Digest_XXHash_inspect, 0);
 	rb_define_method(_Digest_XXHash, "initialize_copy", _Digest_XXHash_initialize_copy, 1);
-
 	rb_define_protected_method(_Digest_XXHash, "ifinish", _Digest_XXHash_ifinish, 0);
-
 	rb_define_singleton_method(_Digest_XXHash, "digest", _Digest_XXHash_singleton_digest, -1);
 	rb_define_singleton_method(_Digest_XXHash, "hexdigest", _Digest_XXHash_singleton_hexdigest, -1);
 	rb_define_singleton_method(_Digest_XXHash, "idigest", _Digest_XXHash_singleton_idigest, -1);
 
-	rb_define_alloc_func(_Digest_XXHash, _Digest_XXHash_internal_allocate);
-
 	/*
 	 * Document-class: Digest::XXH32
 	 */
 
 	_Digest_XXH32 = rb_define_class_under(_Digest, "XXH32", _Digest_XXHash);
-
 	rb_define_alloc_func(_Digest_XXH32, _Digest_XXH32_internal_allocate);
-
 	rb_define_private_method(_Digest_XXH32, "finish", _Digest_XXH32_finish, 0);
 	rb_define_private_method(_Digest_XXH32, "ifinish", _Digest_XXH32_ifinish, 0);
-
 	rb_define_method(_Digest_XXH32, "update", _Digest_XXH32_update, 1);
 	rb_define_method(_Digest_XXH32, "reset", _Digest_XXH32_reset, -1);
 	rb_define_method(_Digest_XXH32, "digest_length", _Digest_XXH32_digest_length, 0);
 	rb_define_method(_Digest_XXH32, "block_length", _Digest_XXH32_block_length, 0);
 	rb_define_method(_Digest_XXH32, "initialize_copy", _Digest_XXH32_initialize_copy, 1);
-
 	rb_define_singleton_method(_Digest_XXH32, "digest_length", _Digest_XXH32_singleton_digest_length, 0);
 	rb_define_singleton_method(_Digest_XXH32, "block_length", _Digest_XXH32_singleton_block_length, 0);
 
@@ -765,18 +1141,60 @@ void Init_xxhash()
 	 */
 
 	_Digest_XXH64 = rb_define_class_under(_Digest, "XXH64", _Digest_XXHash);
-
 	rb_define_alloc_func(_Digest_XXH64, _Digest_XXH64_internal_allocate);
-
 	rb_define_private_method(_Digest_XXH64, "finish", _Digest_XXH64_finish, 0);
 	rb_define_private_method(_Digest_XXH64, "ifinish", _Digest_XXH64_ifinish, 0);
-
 	rb_define_method(_Digest_XXH64, "update", _Digest_XXH64_update, 1);
 	rb_define_method(_Digest_XXH64, "reset", _Digest_XXH64_reset, -1);
 	rb_define_method(_Digest_XXH64, "digest_length", _Digest_XXH64_digest_length, 0);
 	rb_define_method(_Digest_XXH64, "block_length", _Digest_XXH64_block_length, 0);
 	rb_define_method(_Digest_XXH64, "initialize_copy", _Digest_XXH64_initialize_copy, 1);
-
 	rb_define_singleton_method(_Digest_XXH64, "digest_length", _Digest_XXH64_singleton_digest_length, 0);
 	rb_define_singleton_method(_Digest_XXH64, "block_length", _Digest_XXH64_singleton_block_length, 0);
+
+	/*
+	 * Document-class: Digest::XXH3_64bits
+	 */
+
+	_Digest_XXH3_64bits = rb_define_class_under(_Digest, "XXH3_64bits", _Digest_XXHash);
+	rb_define_alloc_func(_Digest_XXH3_64bits, _Digest_XXH3_64bits_internal_allocate);
+	rb_define_private_method(_Digest_XXH3_64bits, "finish", _Digest_XXH3_64bits_finish, 0);
+	rb_define_private_method(_Digest_XXH3_64bits, "ifinish", _Digest_XXH3_64bits_ifinish, 0);
+	rb_define_method(_Digest_XXH3_64bits, "update", _Digest_XXH3_64bits_update, 1);
+	rb_define_method(_Digest_XXH3_64bits, "reset", _Digest_XXH3_64bits_reset, -1);
+	rb_define_method(_Digest_XXH3_64bits, "reset_with_secret", _Digest_XXH3_64bits_reset_with_secret, 1);
+	rb_define_method(_Digest_XXH3_64bits, "digest_length", _Digest_XXH3_64bits_digest_length, 0);
+	rb_define_method(_Digest_XXH3_64bits, "block_length", _Digest_XXH3_64bits_block_length, 0);
+	rb_define_method(_Digest_XXH3_64bits, "initialize_copy", _Digest_XXH3_64bits_initialize_copy, 1);
+	rb_define_singleton_method(_Digest_XXH3_64bits, "digest_length", _Digest_XXH3_64bits_singleton_digest_length, 0);
+	rb_define_singleton_method(_Digest_XXH3_64bits, "block_length", _Digest_XXH3_64bits_singleton_block_length, 0);
+
+	/*
+	 * Document-class: Digest::XXH3_128bits
+	 */
+
+	_Digest_XXH3_128bits = rb_define_class_under(_Digest, "XXH3_128bits", _Digest_XXHash);
+	rb_define_alloc_func(_Digest_XXH3_128bits, _Digest_XXH3_128bits_internal_allocate);
+	rb_define_private_method(_Digest_XXH3_128bits, "finish", _Digest_XXH3_128bits_finish, 0);
+	rb_define_private_method(_Digest_XXH3_128bits, "ifinish", _Digest_XXH3_128bits_ifinish, 0);
+	rb_define_method(_Digest_XXH3_128bits, "update", _Digest_XXH3_128bits_update, 1);
+	rb_define_method(_Digest_XXH3_128bits, "reset", _Digest_XXH3_128bits_reset, -1);
+	rb_define_method(_Digest_XXH3_128bits, "reset_with_secret", _Digest_XXH3_128bits_reset_with_secret, 1);
+	rb_define_method(_Digest_XXH3_128bits, "digest_length", _Digest_XXH3_128bits_digest_length, 0);
+	rb_define_method(_Digest_XXH3_128bits, "block_length", _Digest_XXH3_128bits_block_length, 0);
+	rb_define_method(_Digest_XXH3_128bits, "initialize_copy", _Digest_XXH3_128bits_initialize_copy, 1);
+	rb_define_singleton_method(_Digest_XXH3_128bits, "digest_length", _Digest_XXH3_128bits_singleton_digest_length, 0);
+	rb_define_singleton_method(_Digest_XXH3_128bits, "block_length", _Digest_XXH3_128bits_singleton_block_length, 0);
+
+	/*
+	 * Document-const: Digest::XXHash::XXH3_SECRET_SIZE_MIN
+	 *
+	 * Minimum allowed custom secret size defined in the core XXHash
+	 * code.  The current value is 136.
+	 *
+	 * The author of Digest::XXHash doesn't know if this value would
+	 * change in the future.
+	 */
+
+	rb_define_const(_Digest_XXHash, "XXH3_SECRET_SIZE_MIN", INT2FIX(XXH3_SECRET_SIZE_MIN));
 }