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
This commit is contained in:
Peter Dillinger
Facebook Github Bot
parent
ec11eff3bc
commit
ca7ccbe2ea
@ -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.
|
||||
|
||||
4
cache/cache_test.cc
vendored
4
cache/cache_test.cc
vendored
@ -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);
|
||||
}
|
||||
|
||||
|
||||
@ -871,11 +871,12 @@ TEST_F(DBBasicTest, ChecksumTest) {
|
||||
ASSERT_OK(Flush());
|
||||
}
|
||||
|
||||
// verify data with each type of checksum
|
||||
for (int i = 0; i <= kxxHash64; ++i) {
|
||||
// with each valid checksum type setting...
|
||||
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)));
|
||||
}
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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) %
|
||||
bucket_size_;
|
||||
return fastrange64(GetSliceNPHash64(slice), bucket_size_);
|
||||
}
|
||||
|
||||
Pointer* GetBucket(size_t i) const {
|
||||
|
||||
@ -733,11 +733,13 @@ void BlockBasedTableBuilder::WriteRawBlock(const Slice& block_contents,
|
||||
break;
|
||||
}
|
||||
case kxxHash: {
|
||||
void* xxh = XXH32_init(0);
|
||||
XXH32_update(xxh, block_contents.data(),
|
||||
XXH32_state_t* const state = XXH32_createState();
|
||||
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
|
||||
EncodeFixed32(trailer_without_type, XXH32_digest(xxh));
|
||||
XXH32_update(state, trailer, 1); // Extend to cover block type
|
||||
EncodeFixed32(trailer_without_type, XXH32_digest(state));
|
||||
XXH32_freeState(state);
|
||||
break;
|
||||
}
|
||||
case kxxHash64: {
|
||||
|
||||
@ -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 {
|
||||
|
||||
|
||||
@ -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 hash % trace_options.sampling_frequency == 0;
|
||||
return 0 == fastrange64(GetSliceNPHash64(block_key),
|
||||
trace_options.sampling_frequency);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
|
||||
61
util/hash.h
61
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
|
||||
// The hash results are applicable to change.
|
||||
extern uint64_t NPHash64(const char* data, size_t n, uint32_t seed);
|
||||
// Non-persistent hash. Must only used for in-memory data structure.
|
||||
// The hash results are thus applicable to change. (Thus, it rarely makes
|
||||
// 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/pdillinger/wormhashing/blob/2c4035a4462194bf15f3e9fc180c27c513335225/bloom_simulation_tests/foo.cc#L57
|
||||
inline uint32_t fastrange32(uint32_t a, uint32_t h) {
|
||||
uint64_t product = static_cast<uint64_t>(a) * h;
|
||||
// https://github.com/lemire/fastrange
|
||||
inline uint32_t fastrange32(uint32_t hash, uint32_t range) {
|
||||
uint64_t product = uint64_t{range} * hash;
|
||||
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
|
||||
|
||||
@ -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);
|
||||
|
||||
|
||||
1643
util/xxh3p.h
Normal file
1643
util/xxh3p.h
Normal file
File diff suppressed because it is too large
Load Diff
1834
util/xxhash.cc
1834
util/xxhash.cc
File diff suppressed because it is too large
Load Diff
655
util/xxhash.h
655
util/xxhash.h
@ -1,8 +1,12 @@
|
||||
// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
// 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>
|
||||
|
||||
#if !defined(__VMS) && \
|
||||
(defined(__cplusplus) || \
|
||||
(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */))
|
||||
#include <stdint.h>
|
||||
/* BEGIN RocksDB customizations */
|
||||
#ifndef XXH_STATIC_LINKING_ONLY
|
||||
#define XXH_STATIC_LINKING_ONLY 1 /* access experimental APIs like XXH3 */
|
||||
#endif
|
||||
#define XXH_NAMESPACE ROCKSDB_
|
||||
/* END RocksDB customizations */
|
||||
|
||||
#if defined (__cplusplus)
|
||||
namespace rocksdb {
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
//****************************
|
||||
// Type
|
||||
//****************************
|
||||
/* size_t */
|
||||
/* ****************************
|
||||
* Definitions
|
||||
******************************/
|
||||
#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 */
|
||||
|
||||
//****************************
|
||||
// Simple Hash Functions
|
||||
//****************************
|
||||
|
||||
unsigned int XXH32 (const void* input, int len, unsigned int 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).
|
||||
"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.
|
||||
*/
|
||||
/*! XXH_NAMESPACE, aka Namespace Emulation :
|
||||
*
|
||||
* 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
|
||||
|
||||
|
||||
/* *************************************
|
||||
* Version
|
||||
***************************************/
|
||||
#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);
|
||||
|
||||
//****************************
|
||||
// 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,
|
||||
as opposed to an input provided as a single block.
|
||||
|
||||
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().
|
||||
*/
|
||||
|
||||
|
||||
int XXH32_sizeofState();
|
||||
XXH_errorcode XXH32_resetState(void* state, unsigned int seed);
|
||||
|
||||
#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.
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
|
||||
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().
|
||||
*/
|
||||
|
||||
|
||||
|
||||
//****************************
|
||||
// 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
|
||||
************************************************************************/
|
||||
typedef unsigned long long XXH64_hash_t;
|
||||
* 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
|
||||
|
||||
/*! XXH64() :
|
||||
Calculate the 64-bit hash of sequence of length "len" stored at memory
|
||||
address "input". "seed" can be used to alter the result predictably. This
|
||||
function runs faster on 64-bit systems, but slower on 32-bit systems (see
|
||||
benchmark).
|
||||
*/
|
||||
XXH64_hash_t XXH64(const void* input, size_t length, unsigned long long seed);
|
||||
/*! 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.
|
||||
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);
|
||||
|
||||
/*====== Streaming ======*/
|
||||
typedef struct XXH64_state_s XXH64_state_t; /* incomplete type */
|
||||
XXH64_state_t* XXH64_createState(void);
|
||||
XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr);
|
||||
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_errorcode XXH64_update(XXH64_state_t* statePtr, const void* input,
|
||||
size_t length);
|
||||
XXH64_hash_t XXH64_digest(const XXH64_state_t* statePtr);
|
||||
/*
|
||||
* Streaming functions generate the xxHash value from an incrememtal input.
|
||||
* This method is slower than single-call functions, due to state management.
|
||||
* For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
|
||||
*
|
||||
* XXH state must first be allocated, using XXH*_createState() .
|
||||
*
|
||||
* Start a new hash by initializing state with a seed, using XXH*_reset().
|
||||
*
|
||||
* Then, feed the hash state by calling XXH*_update() as many times as necessary.
|
||||
* The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
|
||||
*
|
||||
* Finally, a hash value can be produced anytime, by using XXH*_digest().
|
||||
* This function returns the nn-bits hash as an int or long long.
|
||||
*
|
||||
* It's still possible to continue inserting input into the hash state after a digest,
|
||||
* and generate some new hash values later on, by invoking again XXH*_digest().
|
||||
*
|
||||
* When done, release the state, using XXH*_freeState().
|
||||
*/
|
||||
|
||||
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);
|
||||
|
||||
XXH_PUBLIC_API XXH_errorcode XXH32_reset (XXH32_state_t* statePtr, XXH32_hash_t 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);
|
||||
|
||||
/*====== Canonical representation ======*/
|
||||
typedef struct {
|
||||
unsigned char digest[8];
|
||||
} XXH64_canonical_t;
|
||||
void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
|
||||
XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
|
||||
|
||||
/* Default return values from XXH functions are basic unsigned 32 and 64 bits.
|
||||
* This the simplest and fastest format for further post-processing.
|
||||
* 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.
|
||||
*
|
||||
* 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;
|
||||
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);
|
||||
|
||||
|
||||
#ifndef XXH_NO_LONG_LONG
|
||||
/*-**********************************************************************
|
||||
* 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 address "input".
|
||||
"seed" can be used to alter the result predictably.
|
||||
This function runs faster on 64-bit systems, but slower on 32-bit systems (see benchmark).
|
||||
*/
|
||||
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 */
|
||||
XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
|
||||
XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr);
|
||||
XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
|
||||
|
||||
XXH_PUBLIC_API XXH_errorcode XXH64_reset (XXH64_state_t* statePtr, XXH64_hash_t seed);
|
||||
XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
|
||||
XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* statePtr);
|
||||
|
||||
/*====== Canonical representation ======*/
|
||||
typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
|
||||
XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
|
||||
XXH_PUBLIC_API 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) && \
|
||||
(defined(__cplusplus) || \
|
||||
(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */))
|
||||
struct XXH32_state_s {
|
||||
XXH32_hash_t total_len_32;
|
||||
XXH32_hash_t large_len;
|
||||
XXH32_hash_t v1;
|
||||
XXH32_hash_t v2;
|
||||
XXH32_hash_t v3;
|
||||
XXH32_hash_t v4;
|
||||
XXH32_hash_t mem32[4];
|
||||
XXH32_hash_t memsize;
|
||||
XXH32_hash_t reserved; /* never read nor write, might be removed in a future version */
|
||||
}; /* typedef'd to XXH32_state_t */
|
||||
|
||||
#ifndef XXH_NO_LONG_LONG /* remove 64-bit support */
|
||||
struct XXH64_state_s {
|
||||
uint64_t total_len;
|
||||
uint64_t v1;
|
||||
uint64_t v2;
|
||||
uint64_t v3;
|
||||
uint64_t v4;
|
||||
uint64_t mem64[4];
|
||||
uint32_t memsize;
|
||||
uint32_t reserved[2]; /* never read nor write, might be removed in a future
|
||||
version */
|
||||
}; /* typedef'd to XXH64_state_t */
|
||||
XXH64_hash_t total_len;
|
||||
XXH64_hash_t v1;
|
||||
XXH64_hash_t v2;
|
||||
XXH64_hash_t v3;
|
||||
XXH64_hash_t v4;
|
||||
XXH64_hash_t mem64[4];
|
||||
XXH32_hash_t memsize;
|
||||
XXH32_hash_t reserved32; /* required for padding anyway */
|
||||
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
|
||||
|
||||
#ifndef XXH_NO_LONG_LONG /* remove 64-bit support */
|
||||
struct XXH64_state_s {
|
||||
unsigned long long total_len;
|
||||
unsigned long long v1;
|
||||
unsigned long long v2;
|
||||
unsigned long long v3;
|
||||
unsigned long long v4;
|
||||
unsigned long long mem64[4];
|
||||
unsigned memsize;
|
||||
unsigned reserved[2]; /* never read nor write, might be removed in a future
|
||||
version */
|
||||
}; /* typedef'd to XXH64_state_t */
|
||||
# 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 */
|
||||
|
||||
@ -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 stripe;
|
||||
return fastrange64(GetSliceNPHash64(key), num_stripes_);
|
||||
}
|
||||
|
||||
void TransactionLockMgr::AddColumnFamily(uint32_t column_family_id) {
|
||||
|
||||
@ -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);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user