Misc hashing updates / upgrades (#5909)

Summary:
- Updated our included xxhash implementation to version 0.7.2 (== the latest dev version as of 2019-10-09).
- Using XXH_NAMESPACE (like other fb projects) to avoid potential name collisions.
- Added fastrange64, and unit tests for it and fastrange32. These are faster alternatives to hash % range.
- Use preview version of XXH3 instead of MurmurHash64A for NPHash64
-- Had to update cache_test to increase probability of passing for any given hash function.
- Use fastrange64 instead of % with uses of NPHash64
-- Had to fix WritePreparedTransactionTest.CommitOfDelayedPrepared to avoid deadlock apparently caused by new hash collision.
- Set default seed for NPHash64 because specifying a seed rarely makes sense for it.
- Removed unnecessary include xxhash.h in a popular .h file
- Rename preview version of XXH3 to XXH3p for clarity and to ease backward compatibility in case final version of XXH3 is integrated.

Relying on existing unit tests for NPHash64-related changes. Each new implementation of fastrange64 passed unit tests when manipulating my local build to select it. I haven't done any integration performance tests, but I consider the improved performance of the pieces being swapped in to be well established.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5909

Differential Revision: D18125196

Pulled By: pdillinger

fbshipit-source-id: f6bf83d49d20cbb2549926adf454fd035f0ecc0d

build_tools/build_detect_platform

@@ -605,6 +605,19 @@ elif test "$USE_SSE"; then
   echo "warning: USE_SSE specified but compiler could not use PCLMUL intrinsics, disabling" >&2
 fi
 
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF
+  #include <cstdint>
+  int main() {
+    uint64_t a = 0xffffFFFFffffFFFF;
+    __uint128_t b = __uint128_t(a) * a;
+    a = static_cast<uint64_t>(b >> 64);
+    (void)a;
+  }
+EOF
+if [ "$?" = 0 ]; then
+  COMMON_FLAGS="$COMMON_FLAGS -DHAVE_UINT128_EXTENSION"
+fi
+
 # iOS doesn't support thread-local storage, but this check would erroneously
 # succeed because the cross-compiler flags are added by the Makefile, not this
 # script.

cache/cache_test.cc

@@ -365,7 +365,7 @@ TEST_P(CacheTest, EvictionPolicy) {
   Insert(200, 201);
 
   // Frequently used entry must be kept around
-  for (int i = 0; i < kCacheSize + 200; i++) {
+  for (int i = 0; i < kCacheSize * 2; i++) {
     Insert(1000+i, 2000+i);
     ASSERT_EQ(101, Lookup(100));
   }
@@ -418,7 +418,7 @@ TEST_P(CacheTest, EvictionPolicyRef) {
   Insert(303, 104);
 
   // Insert entries much more than Cache capacity
-  for (int i = 0; i < kCacheSize + 200; i++) {
+  for (int i = 0; i < kCacheSize * 2; i++) {
     Insert(1000 + i, 2000 + i);
   }
 

db/db_basic_test.cc

@@ -871,11 +871,12 @@ TEST_F(DBBasicTest, ChecksumTest) {
     ASSERT_OK(Flush());
   }
 
-  // verify data with each type of checksum
+  // with each valid checksum type setting...
-  for (int i = 0; i <= kxxHash64; ++i) {
+  for (int i = 0; i <= max_checksum; ++i) {
     table_options.checksum = static_cast<ChecksumType>(i);
     options.table_factory.reset(NewBlockBasedTableFactory(table_options));
     Reopen(options);
+    // verify every type of checksum (should be regardless of that setting)
     for (int j = 0; j < (max_checksum + 1) * kNumPerFile; ++j) {
       ASSERT_EQ(Key(j), Get(Key(j)));
     }

db/memtable.cc

@@ -442,7 +442,7 @@ FragmentedRangeTombstoneIterator* MemTable::NewRangeTombstoneIterator(
 }
 
 port::RWMutex* MemTable::GetLock(const Slice& key) {
-  return &locks_[static_cast<size_t>(GetSliceNPHash64(key)) % locks_.size()];
+  return &locks_[fastrange64(GetSliceNPHash64(key), locks_.size())];
 }
 
 MemTable::MemTableStats MemTable::ApproximateStats(const Slice& start_ikey,

memtable/hash_linklist_rep.cc

@@ -218,8 +218,7 @@ class HashLinkListRep : public MemTableRep {
   }
 
   size_t GetHash(const Slice& slice) const {
-    return NPHash64(slice.data(), static_cast<int>(slice.size()), 0) %
+    return fastrange64(GetSliceNPHash64(slice), bucket_size_);
-           bucket_size_;
   }
 
   Pointer* GetBucket(size_t i) const {

table/block_based/block_based_table_builder.cc

@@ -733,11 +733,13 @@ void BlockBasedTableBuilder::WriteRawBlock(const Slice& block_contents,
         break;
       }
       case kxxHash: {
-        void* xxh = XXH32_init(0);
+        XXH32_state_t* const state = XXH32_createState();
-        XXH32_update(xxh, block_contents.data(),
+        XXH32_reset(state, 0);
+        XXH32_update(state, block_contents.data(),
                      static_cast<uint32_t>(block_contents.size()));
-        XXH32_update(xxh, trailer, 1);  // Extend  to cover block type
+        XXH32_update(state, trailer, 1);  // Extend  to cover block type
-        EncodeFixed32(trailer_without_type, XXH32_digest(xxh));
+        EncodeFixed32(trailer_without_type, XXH32_digest(state));
+        XXH32_freeState(state);
         break;
       }
       case kxxHash64: {

table/format.h

@@ -23,8 +23,6 @@
 #include "port/malloc.h"
 #include "port/port.h"  // noexcept
 #include "table/persistent_cache_options.h"
-#include "util/crc32c.h"
-#include "util/xxhash.h"
 
 namespace rocksdb {
 

trace_replay/block_cache_tracer.cc

@@ -28,8 +28,8 @@ bool ShouldTrace(const Slice& block_key, const TraceOptions& trace_options) {
   }
   // We use spatial downsampling so that we have a complete access history for a
   // block.
-  const uint64_t hash = GetSliceNPHash64(block_key);
+  return 0 == fastrange64(GetSliceNPHash64(block_key),
-  return hash % trace_options.sampling_frequency == 0;
+                          trace_options.sampling_frequency);
 }
 }  // namespace
 

util/hash.h

@@ -7,20 +7,25 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 //
-// Simple hash function used for internal data structures
+// Common hash functions with convenient interfaces.
 
 #pragma once
 #include <stddef.h>
 #include <stdint.h>
 
 #include "rocksdb/slice.h"
-#include "util/murmurhash.h"
+#include "util/xxhash.h"
 
 namespace rocksdb {
 
-// Non-persistent hash. Only used for in-memory data structure
+// Non-persistent hash. Must only used for in-memory data structure.
-// The hash results are applicable to change.
+// The hash results are thus applicable to change. (Thus, it rarely makes
-extern uint64_t NPHash64(const char* data, size_t n, uint32_t seed);
+// sense to specify a seed for this function.)
+inline uint64_t NPHash64(const char* data, size_t n, uint32_t seed = 0) {
+  // XXH3 currently experimental, but generally faster than other quality
+  // 64-bit hash functions.
+  return XXH3p_64bits_withSeed(data, n, seed);
+}
 
 extern uint32_t Hash(const char* data, size_t n, uint32_t seed);
 
@@ -29,32 +34,52 @@ inline uint32_t BloomHash(const Slice& key) {
 }
 
 inline uint64_t GetSliceNPHash64(const Slice& s) {
-  return NPHash64(s.data(), s.size(), 0);
+  return NPHash64(s.data(), s.size());
 }
 
 inline uint32_t GetSliceHash(const Slice& s) {
   return Hash(s.data(), s.size(), 397);
 }
 
-inline uint64_t NPHash64(const char* data, size_t n, uint32_t seed) {
-  // Right now murmurhash2B is used. It should able to be freely
-  // changed to a better hash, without worrying about backward
-  // compatibility issue.
-  return MURMUR_HASH(data, static_cast<int>(n),
-                     static_cast<unsigned int>(seed));
-}
-
 // std::hash compatible interface.
 struct SliceHasher {
   uint32_t operator()(const Slice& s) const { return GetSliceHash(s); }
 };
 
 // An alternative to % for mapping a hash value to an arbitrary range. See
-// https://github.com/lemire/fastrange and
+// https://github.com/lemire/fastrange
-// https://github.com/pdillinger/wormhashing/blob/2c4035a4462194bf15f3e9fc180c27c513335225/bloom_simulation_tests/foo.cc#L57
+inline uint32_t fastrange32(uint32_t hash, uint32_t range) {
-inline uint32_t fastrange32(uint32_t a, uint32_t h) {
+  uint64_t product = uint64_t{range} * hash;
-  uint64_t product = static_cast<uint64_t>(a) * h;
   return static_cast<uint32_t>(product >> 32);
 }
 
+// An alternative to % for mapping a 64-bit hash value to an arbitrary range
+// that fits in size_t. See https://github.com/lemire/fastrange
+// We find size_t more convenient than uint64_t for the range, with side
+// benefit of better optimization on 32-bit platforms.
+inline size_t fastrange64(uint64_t hash, size_t range) {
+#if defined(HAVE_UINT128_EXTENSION)
+  // Can use compiler's 128-bit type. Trust it to do the right thing.
+  __uint128_t wide = __uint128_t{range} * hash;
+  return static_cast<size_t>(wide >> 64);
+#else
+  // Fall back: full decomposition.
+  // NOTE: GCC seems to fully understand this code as 64-bit x {32 or 64}-bit
+  // -> {96 or 128}-bit multiplication and optimize it down to a single
+  // wide-result multiplication (64-bit platform) or two wide-result
+  // multiplications (32-bit platforms, where range64 >> 32 is zero).
+  uint64_t range64 = range;  // ok to shift by 32, even if size_t is 32-bit
+  uint64_t tmp = uint64_t{range64 & 0xffffFFFF} * uint64_t{hash & 0xffffFFFF};
+  tmp >>= 32;
+  tmp += uint64_t{range64 & 0xffffFFFF} * uint64_t{hash >> 32};
+  // Avoid overflow: first add lower 32 of tmp2, and later upper 32
+  uint64_t tmp2 = uint64_t{range64 >> 32} * uint64_t{hash & 0xffffFFFF};
+  tmp += static_cast<uint32_t>(tmp2);
+  tmp >>= 32;
+  tmp += (tmp2 >> 32);
+  tmp += uint64_t{range64 >> 32} * uint64_t{hash >> 32};
+  return static_cast<size_t>(tmp);
+#endif
+}
+
 }  // namespace rocksdb

util/hash_test.cc

@@ -70,6 +70,116 @@ TEST(HashTest, Values) {
             3382479516u);
 }
 
+TEST(Fastrange32Test, Values) {
+  using rocksdb::fastrange32;
+  // Zero range
+  EXPECT_EQ(fastrange32(0, 0), 0U);
+  EXPECT_EQ(fastrange32(123, 0), 0U);
+  EXPECT_EQ(fastrange32(0xffffffff, 0), 0U);
+
+  // One range
+  EXPECT_EQ(fastrange32(0, 1), 0U);
+  EXPECT_EQ(fastrange32(123, 1), 0U);
+  EXPECT_EQ(fastrange32(0xffffffff, 1), 0U);
+
+  // Two range
+  EXPECT_EQ(fastrange32(0, 2), 0U);
+  EXPECT_EQ(fastrange32(123, 2), 0U);
+  EXPECT_EQ(fastrange32(0x7fffffff, 2), 0U);
+  EXPECT_EQ(fastrange32(0x80000000, 2), 1U);
+  EXPECT_EQ(fastrange32(0xffffffff, 2), 1U);
+
+  // Seven range
+  EXPECT_EQ(fastrange32(0, 7), 0U);
+  EXPECT_EQ(fastrange32(123, 7), 0U);
+  EXPECT_EQ(fastrange32(613566756, 7), 0U);
+  EXPECT_EQ(fastrange32(613566757, 7), 1U);
+  EXPECT_EQ(fastrange32(1227133513, 7), 1U);
+  EXPECT_EQ(fastrange32(1227133514, 7), 2U);
+  // etc.
+  EXPECT_EQ(fastrange32(0xffffffff, 7), 6U);
+
+  // Big
+  EXPECT_EQ(fastrange32(1, 0x80000000), 0U);
+  EXPECT_EQ(fastrange32(2, 0x80000000), 1U);
+  EXPECT_EQ(fastrange32(4, 0x7fffffff), 1U);
+  EXPECT_EQ(fastrange32(4, 0x80000000), 2U);
+  EXPECT_EQ(fastrange32(0xffffffff, 0x7fffffff), 0x7ffffffeU);
+  EXPECT_EQ(fastrange32(0xffffffff, 0x80000000), 0x7fffffffU);
+}
+
+TEST(Fastrange64Test, Values) {
+  using rocksdb::fastrange64;
+  // Zero range
+  EXPECT_EQ(fastrange64(0, 0), 0U);
+  EXPECT_EQ(fastrange64(123, 0), 0U);
+  EXPECT_EQ(fastrange64(0xffffFFFF, 0), 0U);
+  EXPECT_EQ(fastrange64(0xffffFFFFffffFFFF, 0), 0U);
+
+  // One range
+  EXPECT_EQ(fastrange64(0, 1), 0U);
+  EXPECT_EQ(fastrange64(123, 1), 0U);
+  EXPECT_EQ(fastrange64(0xffffFFFF, 1), 0U);
+  EXPECT_EQ(fastrange64(0xffffFFFFffffFFFF, 1), 0U);
+
+  // Two range
+  EXPECT_EQ(fastrange64(0, 2), 0U);
+  EXPECT_EQ(fastrange64(123, 2), 0U);
+  EXPECT_EQ(fastrange64(0xffffFFFF, 2), 0U);
+  EXPECT_EQ(fastrange64(0x7fffFFFFffffFFFF, 2), 0U);
+  EXPECT_EQ(fastrange64(0x8000000000000000, 2), 1U);
+  EXPECT_EQ(fastrange64(0xffffFFFFffffFFFF, 2), 1U);
+
+  // Seven range
+  EXPECT_EQ(fastrange64(0, 7), 0U);
+  EXPECT_EQ(fastrange64(123, 7), 0U);
+  EXPECT_EQ(fastrange64(0xffffFFFF, 7), 0U);
+  EXPECT_EQ(fastrange64(2635249153387078802, 7), 0U);
+  EXPECT_EQ(fastrange64(2635249153387078803, 7), 1U);
+  EXPECT_EQ(fastrange64(5270498306774157604, 7), 1U);
+  EXPECT_EQ(fastrange64(5270498306774157605, 7), 2U);
+  EXPECT_EQ(fastrange64(0x7fffFFFFffffFFFF, 7), 3U);
+  EXPECT_EQ(fastrange64(0x8000000000000000, 7), 3U);
+  EXPECT_EQ(fastrange64(0xffffFFFFffffFFFF, 7), 6U);
+
+  // Big but 32-bit range
+  EXPECT_EQ(fastrange64(0x100000000, 0x80000000), 0U);
+  EXPECT_EQ(fastrange64(0x200000000, 0x80000000), 1U);
+  EXPECT_EQ(fastrange64(0x400000000, 0x7fffFFFF), 1U);
+  EXPECT_EQ(fastrange64(0x400000000, 0x80000000), 2U);
+  EXPECT_EQ(fastrange64(0xffffFFFFffffFFFF, 0x7fffFFFF), 0x7fffFFFEU);
+  EXPECT_EQ(fastrange64(0xffffFFFFffffFFFF, 0x80000000), 0x7fffFFFFU);
+
+  // Big, > 32-bit range
+#if SIZE_MAX == UINT64_MAX
+  EXPECT_EQ(fastrange64(0x7fffFFFFffffFFFF, 0x4200000002), 0x2100000000U);
+  EXPECT_EQ(fastrange64(0x8000000000000000, 0x4200000002), 0x2100000001U);
+
+  EXPECT_EQ(fastrange64(0x0000000000000000, 420000000002), 0U);
+  EXPECT_EQ(fastrange64(0x7fffFFFFffffFFFF, 420000000002), 210000000000U);
+  EXPECT_EQ(fastrange64(0x8000000000000000, 420000000002), 210000000001U);
+  EXPECT_EQ(fastrange64(0xffffFFFFffffFFFF, 420000000002), 420000000001U);
+
+  EXPECT_EQ(fastrange64(0xffffFFFFffffFFFF, 0xffffFFFFffffFFFF),
+            0xffffFFFFffffFFFEU);
+#endif
+}
+
+// for inspection of disassembly
+uint32_t fastrange32(uint32_t hash, uint32_t range) {
+  return rocksdb::fastrange32(hash, range);
+}
+
+// for inspection of disassembly
+size_t fastrange64(uint64_t hash, size_t range) {
+  return rocksdb::fastrange64(hash, range);
+}
+
+// for inspection of disassembly
+uint64_t NPHash64(const char* data, size_t n) {
+  return rocksdb::NPHash64(data, n);
+}
+
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
 

util/xxhash.h

@@ -1,8 +1,12 @@
 //  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
 /*
-   xxHash - Fast Hash algorithm
+   xxHash - Extremely Fast Hash algorithm
    Header File
-   Copyright (C) 2012-2014, Yann Collet.
+   Copyright (C) 2012-2016, 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
@@ -29,7 +33,7 @@
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
    You can contact the author at :
-   - xxHash source repository : http://code.google.com/p/xxhash/
+   - xxHash source repository : https://github.com/Cyan4973/xxHash
 */
 
 /* Notice extracted from xxHash homepage :
@@ -49,193 +53,546 @@ Lookup3         1.2 GB/s      9       Bob Jenkins
 SuperFastHash   1.2 GB/s      1       Paul Hsieh
 CityHash64      1.05 GB/s    10       Pike & Alakuijala
 FNV             0.55 GB/s     5       Fowler, Noll, Vo
-CRC32           0.43 GB/s     9
+CRC32           0.43 GB/s #   9
 MD5-32          0.33 GB/s    10       Ronald L. Rivest
 SHA1-32         0.28 GB/s    10
 
+Note #: other CRC32 implementations can be over 40x faster than SMHasher's:
+http://fastcompression.blogspot.com/2019/03/presenting-xxh3.html?showComment=1552696407071#c3490092340461170735
+
 Q.Score is a measure of quality of the hash function.
 It depends on successfully passing SMHasher test set.
 10 is a perfect score.
+
+A 64-bit version, named XXH64, is available since r35.
+It offers much better speed, but for 64-bit applications only.
+Name     Speed on 64 bits    Speed on 32 bits
+XXH64       13.8 GB/s            1.9 GB/s
+XXH32        6.8 GB/s            6.0 GB/s
 */
 
-#pragma once
+#ifndef XXHASH_H_5627135585666179
+#define XXHASH_H_5627135585666179 1
 
-#include <stdlib.h>
+/* BEGIN RocksDB customizations */
-
+#ifndef XXH_STATIC_LINKING_ONLY
-#if !defined(__VMS) &&       \
+#define XXH_STATIC_LINKING_ONLY 1 /* access experimental APIs like XXH3 */
-    (defined(__cplusplus) || \
-     (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */))
-#include <stdint.h>
 #endif
+#define XXH_NAMESPACE ROCKSDB_
+/* END RocksDB customizations */
 
 #if defined (__cplusplus)
-namespace rocksdb {
+extern "C" {
 #endif
 
 
-//****************************
+/* ****************************
-// Type
+*  Definitions
-//****************************
+******************************/
-/* size_t */
+#include <stddef.h>   /* size_t */
 typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
 
 
+/* ****************************
+ *  API modifier
+ ******************************/
+/** XXH_INLINE_ALL (and XXH_PRIVATE_API)
+ *  This build macro includes xxhash functions in `static` mode
+ *  in order to inline them, and remove their symbol from the public list.
+ *  Inlining offers great performance improvement on small keys,
+ *  and dramatic ones when length is expressed as a compile-time constant.
+ *  See https://fastcompression.blogspot.com/2018/03/xxhash-for-small-keys-impressive-power.html .
+ *  Methodology :
+ *     #define XXH_INLINE_ALL
+ *     #include "xxhash.h"
+ * `xxhash.c` is automatically included.
+ *  It's not useful to compile and link it as a separate object.
+ */
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
+#  ifndef XXH_STATIC_LINKING_ONLY
+#    define XXH_STATIC_LINKING_ONLY
+#  endif
+#  if defined(__GNUC__)
+#    define XXH_PUBLIC_API static __inline __attribute__((unused))
+#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#    define XXH_PUBLIC_API static inline
+#  elif defined(_MSC_VER)
+#    define XXH_PUBLIC_API static __inline
+#  else
+     /* this version may generate warnings for unused static functions */
+#    define XXH_PUBLIC_API static
+#  endif
+#else
+#  if defined(WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT))
+#    ifdef XXH_EXPORT
+#      define XXH_PUBLIC_API __declspec(dllexport)
+#    elif XXH_IMPORT
+#      define XXH_PUBLIC_API __declspec(dllimport)
+#    endif
+#  else
+#    define XXH_PUBLIC_API   /* do nothing */
+#  endif
+#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */
 
-//****************************
+/*! XXH_NAMESPACE, aka Namespace Emulation :
-// Simple Hash Functions
+ *
-//****************************
+ * If you want to include _and expose_ xxHash functions from within your own library,
+ * but also want to avoid symbol collisions with other libraries which may also include xxHash,
+ *
+ * you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
+ * with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
+ *
+ * Note that no change is required within the calling program as long as it includes `xxhash.h` :
+ * regular symbol name will be automatically translated by this header.
+ */
+#ifdef XXH_NAMESPACE
+#  define XXH_CAT(A,B) A##B
+#  define XXH_NAME2(A,B) XXH_CAT(A,B)
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
+#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
+#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
+#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
+#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
+#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
+#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
+#endif
 
-unsigned int XXH32 (const void* input, int len, unsigned int seed);
 
-/*
+/* *************************************
-XXH32() :
+*  Version
-    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).
+#define XXH_VERSION_MAJOR    0
+#define XXH_VERSION_MINOR    7
+#define XXH_VERSION_RELEASE  2
+#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
+XXH_PUBLIC_API unsigned XXH_versionNumber (void);
+
+
+/*-**********************************************************************
+*  32-bit hash
+************************************************************************/
+#if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+    typedef uint32_t XXH32_hash_t;
+#else
+#   include <limits.h>
+#   if UINT_MAX == 0xFFFFFFFFUL
+      typedef unsigned int XXH32_hash_t;
+#   else
+#     if ULONG_MAX == 0xFFFFFFFFUL
+        typedef unsigned long XXH32_hash_t;
+#     else
+#       error "unsupported platform : need a 32-bit type"
+#     endif
+#   endif
+#endif
+
+/*! XXH32() :
+    Calculate the 32-bit 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 */
-    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_t seed);
-    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.
-*/
 
-
+/*======   Streaming   ======*/
-
-//****************************
-// 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);
 
 /*
-These functions calculate the xxhash of an input provided in several small packets,
+ * Streaming functions generate the xxHash value from an incrememtal input.
-as opposed to an input provided as a single block.
+ * This method is slower than single-call functions, due to state management.
-
+ * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
-It must be started with :
+ *
-void* XXH32_init()
+ * XXH state must first be allocated, using XXH*_createState() .
-The function returns a pointer which holds the state of calculation.
+ *
-
+ * Start a new hash by initializing state with a seed, using XXH*_reset().
-This pointer must be provided as "void* state" parameter for XXH32_update().
+ *
-XXH32_update() can be called as many times as necessary.
+ * Then, feed the hash state by calling XXH*_update() 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.
-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.
+ * Finally, a hash value can be produced anytime, by using XXH*_digest().
-If your data is larger, it is recommended to chunk your data into blocks
+ * This function returns the nn-bits hash as an int or long long.
-of size for example 2^30 (1GB) to avoid any "int" overflow issue.
+ *
-
+ * It's still possible to continue inserting input into the hash state after a digest,
-Finally, you can end the calculation anytime, by using XXH32_digest().
+ * and generate some new hash values later on, by invoking again XXH*_digest().
-This function returns the final 32-bits hash.
+ *
-You must provide the same "void* state" parameter created by XXH32_init().
+ * When done, release the state, using XXH*_freeState().
-Memory will be freed by XXH32_digest().
  */
 
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
 
-int           XXH32_sizeofState();
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, XXH32_hash_t seed);
-XXH_errorcode XXH32_resetState(void* state, unsigned int seed);
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
 
-#define       XXH32_SIZEOFSTATE 48
+/*======   Canonical representation   ======*/
-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.
 
-XXH32_sizeofState() is used to know how much space must be allocated for the xxHash 32-bits state.
+/* Default return values from XXH functions are basic unsigned 32 and 64 bits.
-Note that the state must be aligned to access 'long long' fields. Memory must be allocated and referenced by a pointer.
+ * This the simplest and fastest format for further post-processing.
-This pointer must then be provided as 'state' into XXH32_resetState(), which initializes the state.
+ * However, this leaves open the question of what is the order of bytes,
-
+ * since little and big endian conventions will write the same number differently.
-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.
+ * The canonical representation settles this issue,
+ * by mandating big-endian convention,
+ * aka, the same convention as human-readable numbers (large digits first).
+ * When writing hash values to storage, sending them over a network, or printing them,
+ * it's highly recommended to use the canonical representation,
+ * to ensure portability across a wider range of systems, present and future.
+ *
+ * The following functions allow transformation of hash values into and from canonical format.
  */
 
-
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
-unsigned int XXH32_intermediateDigest (void* state);
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
-/*
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
-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().
-*/
 
 
-
+#ifndef XXH_NO_LONG_LONG
-//****************************
-// 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
-
 /*-**********************************************************************
 *  64-bit hash
 ************************************************************************/
+#if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+    typedef uint64_t XXH64_hash_t;
+#else
+    /* the following type must have a width of 64-bit */
     typedef unsigned long long XXH64_hash_t;
+#endif
 
 /*! XXH64() :
-    Calculate the 64-bit hash of sequence of length "len" stored at memory
+    Calculate the 64-bit hash of sequence of length "len" stored at memory address "input".
-   address "input". "seed" can be used to alter the result predictably. This
+    "seed" can be used to alter the result predictably.
-   function runs faster on 64-bit systems, but slower on 32-bit systems (see
+    This function runs faster on 64-bit systems, but slower on 32-bit systems (see benchmark).
-   benchmark).
 */
-XXH64_hash_t XXH64(const void* input, size_t length, unsigned long long seed);
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, XXH64_hash_t seed);
 
 /*======   Streaming   ======*/
 typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
-XXH64_state_t* XXH64_createState(void);
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
-XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr);
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
-void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
 
-XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed);
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, XXH64_hash_t seed);
-XXH_errorcode XXH64_update(XXH64_state_t* statePtr, const void* input,
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
-                           size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
-XXH64_hash_t XXH64_digest(const XXH64_state_t* statePtr);
 
 /*======   Canonical representation   ======*/
-typedef struct {
+typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
-  unsigned char digest[8];
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
-} XXH64_canonical_t;
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
-void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
+
-XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
+
+#endif  /* XXH_NO_LONG_LONG */
+
+
+
+#ifdef XXH_STATIC_LINKING_ONLY
+
+/* ================================================================================================
+   This section contains declarations which are not guaranteed to remain stable.
+   They may change in future versions, becoming incompatible with a different version of the library.
+   These declarations should only be used with static linking.
+   Never use them in association with dynamic linking !
+=================================================================================================== */
 
 /* These definitions are only present to allow
  * static allocation of XXH state, on stack or in a struct for example.
  * Never **ever** use members directly. */
 
-#if !defined(__VMS) &&       \
+struct XXH32_state_s {
-    (defined(__cplusplus) || \
+   XXH32_hash_t total_len_32;
-     (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */))
+   XXH32_hash_t large_len;
-
+   XXH32_hash_t v1;
-struct XXH64_state_s {
+   XXH32_hash_t v2;
-  uint64_t total_len;
+   XXH32_hash_t v3;
-  uint64_t v1;
+   XXH32_hash_t v4;
-  uint64_t v2;
+   XXH32_hash_t mem32[4];
-  uint64_t v3;
+   XXH32_hash_t memsize;
-  uint64_t v4;
+   XXH32_hash_t reserved;   /* never read nor write, might be removed in a future version */
-  uint64_t mem64[4];
+};   /* typedef'd to XXH32_state_t */
-  uint32_t memsize;
-  uint32_t reserved[2]; /* never read nor write, might be removed in a future
-                           version */
-};                      /* typedef'd to XXH64_state_t */
-
-#else
 
 #ifndef XXH_NO_LONG_LONG  /* remove 64-bit support */
 struct XXH64_state_s {
-  unsigned long long total_len;
+   XXH64_hash_t total_len;
-  unsigned long long v1;
+   XXH64_hash_t v1;
-  unsigned long long v2;
+   XXH64_hash_t v2;
-  unsigned long long v3;
+   XXH64_hash_t v3;
-  unsigned long long v4;
+   XXH64_hash_t v4;
-  unsigned long long mem64[4];
+   XXH64_hash_t mem64[4];
-  unsigned memsize;
+   XXH32_hash_t memsize;
-  unsigned reserved[2]; /* never read nor write, might be removed in a future
+   XXH32_hash_t reserved32;  /* required for padding anyway */
-                           version */
+   XXH64_hash_t reserved64;  /* never read nor write, might be removed in a future version */
 };   /* typedef'd to XXH64_state_t */
+#endif   /* XXH_NO_LONG_LONG */
+
+
+/*-**********************************************************************
+*  XXH3
+*  New experimental hash
+************************************************************************/
+#ifndef XXH_NO_LONG_LONG
+
+
+/* ============================================
+ * XXH3 is a new hash algorithm,
+ * featuring improved speed performance for both small and large inputs.
+ * See full speed analysis at : http://fastcompression.blogspot.com/2019/03/presenting-xxh3.html
+ * In general, expect XXH3 to run about ~2x faster on large inputs,
+ * and >3x faster on small ones, though exact differences depend on platform.
+ *
+ * The algorithm is portable, will generate the same hash on all platforms.
+ * It benefits greatly from vectorization units, but does not require it.
+ *
+ * XXH3 offers 2 variants, _64bits and _128bits.
+ * When only 64 bits are needed, prefer calling the _64bits variant :
+ * it reduces the amount of mixing, resulting in faster speed on small inputs.
+ * It's also generally simpler to manipulate a scalar return type than a struct.
+ *
+ * The XXH3 algorithm is still considered experimental.
+ * Produced results can still change between versions.
+ * Results produced by v0.7.x are not comparable with results from v0.7.y .
+ * It's nonetheless possible to use XXH3 for ephemeral data (local sessions),
+ * but avoid storing values in long-term storage for later reads.
+ *
+ * The API supports one-shot hashing, streaming mode, and custom secrets.
+ *
+ * There are still a number of opened questions that community can influence during the experimental period.
+ * I'm trying to list a few of them below, though don't consider this list as complete.
+ *
+ * - 128-bits output type : currently defined as a structure of two 64-bits fields.
+ *                          That's because 128-bit values do not exist in C standard.
+ *                          Note that it means that, at byte level, result is not identical depending on endianess.
+ *                          However, at field level, they are identical on all platforms.
+ *                          The canonical representation solves the issue of identical byte-level representation across platforms,
+ *                          which is necessary for serialization.
+ *                          Q1 : Would there be a better representation for a 128-bit hash result ?
+ *                          Q2 : Are the names of the inner 64-bit fields important ? Should they be changed ?
+ *
+ * - Prototype XXH128() :   XXH128() uses the same arguments as XXH64(), for consistency.
+ *                          It means it maps to XXH3p_128bits_withSeed().
+ *                          This variant is slightly slower than XXH3p_128bits(),
+ *                          because the seed is now part of the algorithm, and can't be simplified.
+ *                          Is that a good idea ?
+ *
+ * - Seed type for XXH128() : currently, it's a single 64-bit value, like the 64-bit variant.
+ *                          It could be argued that it's more logical to offer a 128-bit seed input parameter for a 128-bit hash.
+ *                          But 128-bit seed is more difficult to use, since it requires to pass a structure instead of a scalar value.
+ *                          Such a variant could either replace current one, or become an additional one.
+ *                          Farmhash, for example, offers both variants (the 128-bits seed variant is called `doubleSeed`).
+ *                          Follow up question : if both 64-bit and 128-bit seeds are allowed, which variant should be called XXH128 ?
+ *
+ * - Result for len==0 :    Currently, the result of hashing a zero-length input is always `0`.
+ *                          It seems okay as a return value when using "default" secret and seed.
+ *                          But is it still fine to return `0` when secret or seed are non-default ?
+ *                          Are there use cases which could depend on generating a different hash result for zero-length input when the secret is different ?
+ *
+ * - Consistency (1) :      Streaming XXH128 uses an XXH3 state, which is the same state as XXH3p_64bits().
+ *                          It means a 128bit streaming loop must invoke the following symbols :
+ *                          XXH3p_createState(), XXH3p_128bits_reset(), XXH3p_128bits_update() (loop), XXH3p_128bits_digest(), XXH3p_freeState().
+ *                          Is that consistent enough ?
+ *
+ * - Consistency (2) :      The canonical representation of `XXH3p_64bits` is provided by existing functions
+ *                          XXH64_canonicalFromHash(), and reverse operation XXH64_hashFromCanonical().
+ *                          As a mirror, canonical functions for XXH128_hash_t results generated by `XXH3p_128bits`
+ *                          are XXH128_canonicalFromHash() and XXH128_hashFromCanonical().
+ *                          Which means, `XXH3` doesn't appear in the names, because canonical functions operate on a type,
+ *                          independently of which algorithm was used to generate that type.
+ *                          Is that consistent enough ?
+ */
+
+#ifdef XXH_NAMESPACE
+#  define XXH3p_64bits XXH_NAME2(XXH_NAMESPACE, XXH3p_64bits)
+#  define XXH3p_64bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3p_64bits_withSecret)
+#  define XXH3p_64bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3p_64bits_withSeed)
+
+#  define XXH3p_createState XXH_NAME2(XXH_NAMESPACE, XXH3p_createState)
+#  define XXH3p_freeState XXH_NAME2(XXH_NAMESPACE, XXH3p_freeState)
+#  define XXH3p_copyState XXH_NAME2(XXH_NAMESPACE, XXH3p_copyState)
+
+#  define XXH3p_64bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3p_64bits_reset)
+#  define XXH3p_64bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3p_64bits_reset_withSeed)
+#  define XXH3p_64bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3p_64bits_reset_withSecret)
+#  define XXH3p_64bits_update XXH_NAME2(XXH_NAMESPACE, XXH3p_64bits_update)
+#  define XXH3p_64bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3p_64bits_digest)
 #endif
 
+/* XXH3p_64bits() :
+ * default 64-bit variant, using default secret and default seed of 0.
+ * It's the fastest variant. */
+XXH_PUBLIC_API XXH64_hash_t XXH3p_64bits(const void* data, size_t len);
+
+/* XXH3p_64bits_withSecret() :
+ * It's possible to provide any blob of bytes as a "secret" to generate the hash.
+ * This makes it more difficult for an external actor to prepare an intentional collision.
+ * The secret *must* be large enough (>= XXH3p_SECRET_SIZE_MIN).
+ * It should consist of random bytes.
+ * Avoid repeating same character, or sequences of bytes,
+ * and especially avoid swathes of \0.
+ * Failure to respect these conditions will result in a poor quality hash.
+ */
+#define XXH3p_SECRET_SIZE_MIN 136
+XXH_PUBLIC_API XXH64_hash_t XXH3p_64bits_withSecret(const void* data, size_t len, const void* secret, size_t secretSize);
+
+/* XXH3p_64bits_withSeed() :
+ * This variant generates on the fly a custom secret,
+ * based on the default secret, altered using the `seed` value.
+ * While this operation is decently fast, note that it's not completely free.
+ * note : seed==0 produces same results as XXH3p_64bits() */
+XXH_PUBLIC_API XXH64_hash_t XXH3p_64bits_withSeed(const void* data, size_t len, XXH64_hash_t seed);
+
+
+/* streaming 64-bit */
+
+#if defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)   /* C11+ */
+#  include <stdalign.h>
+#  define XXH_ALIGN(n)      alignas(n)
+#elif defined(__GNUC__)
+#  define XXH_ALIGN(n)      __attribute__ ((aligned(n)))
+#elif defined(_MSC_VER)
+#  define XXH_ALIGN(n)      __declspec(align(n))
+#else
+#  define XXH_ALIGN(n)   /* disabled */
 #endif
 
+typedef struct XXH3p_state_s XXH3p_state_t;
+
+#define XXH3p_SECRET_DEFAULT_SIZE 192   /* minimum XXH3p_SECRET_SIZE_MIN */
+#define XXH3p_INTERNALBUFFER_SIZE 256
+struct XXH3p_state_s {
+   XXH_ALIGN(64) XXH64_hash_t acc[8];
+   XXH_ALIGN(64) unsigned char customSecret[XXH3p_SECRET_DEFAULT_SIZE];  /* used to store a custom secret generated from the seed. Makes state larger. Design might change */
+   XXH_ALIGN(64) unsigned char buffer[XXH3p_INTERNALBUFFER_SIZE];
+   XXH32_hash_t bufferedSize;
+   XXH32_hash_t nbStripesPerBlock;
+   XXH32_hash_t nbStripesSoFar;
+   XXH32_hash_t secretLimit;
+   XXH32_hash_t reserved32;
+   XXH32_hash_t reserved32_2;
+   XXH64_hash_t totalLen;
+   XXH64_hash_t seed;
+   XXH64_hash_t reserved64;
+   const unsigned char* secret;    /* note : there is some padding after, due to alignment on 64 bytes */
+};   /* typedef'd to XXH3p_state_t */
+
+/* Streaming requires state maintenance.
+ * This operation costs memory and cpu.
+ * As a consequence, streaming is slower than one-shot hashing.
+ * For better performance, prefer using one-shot functions whenever possible. */
+
+XXH_PUBLIC_API XXH3p_state_t* XXH3p_createState(void);
+XXH_PUBLIC_API XXH_errorcode XXH3p_freeState(XXH3p_state_t* statePtr);
+XXH_PUBLIC_API void XXH3p_copyState(XXH3p_state_t* dst_state, const XXH3p_state_t* src_state);
+
+
+/* XXH3p_64bits_reset() :
+ * initialize with default parameters.
+ * result will be equivalent to `XXH3p_64bits()`. */
+XXH_PUBLIC_API XXH_errorcode XXH3p_64bits_reset(XXH3p_state_t* statePtr);
+/* XXH3p_64bits_reset_withSeed() :
+ * generate a custom secret from `seed`, and store it into state.
+ * digest will be equivalent to `XXH3p_64bits_withSeed()`. */
+XXH_PUBLIC_API XXH_errorcode XXH3p_64bits_reset_withSeed(XXH3p_state_t* statePtr, XXH64_hash_t seed);
+/* XXH3p_64bits_reset_withSecret() :
+ * `secret` is referenced, and must outlive the hash streaming session.
+ * secretSize must be >= XXH3p_SECRET_SIZE_MIN.
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3p_64bits_reset_withSecret(XXH3p_state_t* statePtr, const void* secret, size_t secretSize);
+
+XXH_PUBLIC_API XXH_errorcode XXH3p_64bits_update (XXH3p_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH3p_64bits_digest (const XXH3p_state_t* statePtr);
+
+
+/* 128-bit */
+
+#ifdef XXH_NAMESPACE
+#  define XXH128 XXH_NAME2(XXH_NAMESPACE, XXH128)
+#  define XXH3p_128bits XXH_NAME2(XXH_NAMESPACE, XXH3p_128bits)
+#  define XXH3p_128bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3p_128bits_withSeed)
+#  define XXH3p_128bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3p_128bits_withSecret)
+
+#  define XXH3p_128bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3p_128bits_reset)
+#  define XXH3p_128bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3p_128bits_reset_withSeed)
+#  define XXH3p_128bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3p_128bits_reset_withSecret)
+#  define XXH3p_128bits_update XXH_NAME2(XXH_NAMESPACE, XXH3p_128bits_update)
+#  define XXH3p_128bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3p_128bits_digest)
+
+#  define XXH128_isEqual XXH_NAME2(XXH_NAMESPACE, XXH128_isEqual)
+#  define XXH128_cmp     XXH_NAME2(XXH_NAMESPACE, XXH128_cmp)
+#  define XXH128_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH128_canonicalFromHash)
+#  define XXH128_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH128_hashFromCanonical)
+#endif
+
+typedef struct {
+    XXH64_hash_t low64;
+    XXH64_hash_t high64;
+} XXH128_hash_t;
+
+XXH_PUBLIC_API XXH128_hash_t XXH128(const void* data, size_t len, XXH64_hash_t seed);
+XXH_PUBLIC_API XXH128_hash_t XXH3p_128bits(const void* data, size_t len);
+XXH_PUBLIC_API XXH128_hash_t XXH3p_128bits_withSeed(const void* data, size_t len, XXH64_hash_t seed);  /* == XXH128() */
+XXH_PUBLIC_API XXH128_hash_t XXH3p_128bits_withSecret(const void* data, size_t len, const void* secret, size_t secretSize);
+
+XXH_PUBLIC_API XXH_errorcode XXH3p_128bits_reset(XXH3p_state_t* statePtr);
+XXH_PUBLIC_API XXH_errorcode XXH3p_128bits_reset_withSeed(XXH3p_state_t* statePtr, XXH64_hash_t seed);
+XXH_PUBLIC_API XXH_errorcode XXH3p_128bits_reset_withSecret(XXH3p_state_t* statePtr, const void* secret, size_t secretSize);
+
+XXH_PUBLIC_API XXH_errorcode XXH3p_128bits_update (XXH3p_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH128_hash_t XXH3p_128bits_digest (const XXH3p_state_t* statePtr);
+
+
+/* Note : for better performance, following functions can be inlined,
+ * using XXH_INLINE_ALL */
+
+/* return : 1 is equal, 0 if different */
+XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2);
+
+/* This comparator is compatible with stdlib's qsort().
+ * return : >0 if *h128_1  > *h128_2
+ *          <0 if *h128_1  < *h128_2
+ *          =0 if *h128_1 == *h128_2  */
+XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2);
+
+
+/*======   Canonical representation   ======*/
+typedef struct { unsigned char digest[16]; } XXH128_canonical_t;
+XXH_PUBLIC_API void XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash);
+XXH_PUBLIC_API XXH128_hash_t XXH128_hashFromCanonical(const XXH128_canonical_t* src);
+
+
+#endif  /* XXH_NO_LONG_LONG */
+
+
+/*-**********************************************************************
+*  XXH_INLINE_ALL
+************************************************************************/
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
+#  include "xxhash.cc"   /* include xxhash function bodies as `static`, for inlining */
+#endif
+
+
+
+#endif /* XXH_STATIC_LINKING_ONLY */
+
+
 #if defined (__cplusplus)
-}  // namespace rocksdb
+}
 #endif
+
+#endif /* XXHASH_H_5627135585666179 */

utilities/transactions/transaction_lock_mgr.cc

@@ -179,8 +179,7 @@ TransactionLockMgr::~TransactionLockMgr() {}
 
 size_t LockMap::GetStripe(const std::string& key) const {
   assert(num_stripes_ > 0);
-  size_t stripe = static_cast<size_t>(GetSliceNPHash64(key)) % num_stripes_;
+  return fastrange64(GetSliceNPHash64(key), num_stripes_);
-  return stripe;
 }
 
 void TransactionLockMgr::AddColumnFamily(uint32_t column_family_id) {

utilities/transactions/write_prepared_transaction_test.cc

@@ -3351,7 +3351,7 @@ TEST_P(WritePreparedTransactionTest, CommitOfDelayedPrepared) {
         snap.store(db->GetSnapshot());
         ReadOptions roptions;
         roptions.snapshot = snap.load();
-        auto s = db->Get(roptions, db->DefaultColumnFamily(), "key", &value);
+        auto s = db->Get(roptions, db->DefaultColumnFamily(), "key2", &value);
         ASSERT_OK(s);
       };
       auto callback = [&](void* param) {
@@ -3387,7 +3387,7 @@ TEST_P(WritePreparedTransactionTest, CommitOfDelayedPrepared) {
           ASSERT_OK(txn->SetName("xid"));
           std::string val_str = "value" + ToString(i);
           for (size_t b = 0; b < sub_batch_cnt; b++) {
-            ASSERT_OK(txn->Put(Slice("key"), val_str));
+            ASSERT_OK(txn->Put(Slice("key2"), val_str));
           }
           ASSERT_OK(txn->Prepare());
           // Let an eviction to kick in
@@ -3405,7 +3405,8 @@ TEST_P(WritePreparedTransactionTest, CommitOfDelayedPrepared) {
           roptions.snapshot = snap.load();
           ASSERT_NE(nullptr, roptions.snapshot);
           PinnableSlice value2;
-          auto s = db->Get(roptions, db->DefaultColumnFamily(), "key", &value2);
+          auto s =
+              db->Get(roptions, db->DefaultColumnFamily(), "key2", &value2);
           ASSERT_OK(s);
           // It should see its own write
           ASSERT_TRUE(val_str == value2);