clang-format cache/ and util/ directories (#10867)

Summary:
This is purely the result of running `clang-format -i` on files, except some files have been excluded for manual intervention in a separate PR

Pull Request resolved: https://github.com/facebook/rocksdb/pull/10867

Test Plan: `make check`, `make check-headers`, `make format`

Reviewed By: jay-zhuang

Differential Revision: D40682086

Pulled By: pdillinger

fbshipit-source-id: 8673d978553ab99b516da7fb63ba0b82523337f8
main
Peter Dillinger 2 years ago committed by Facebook GitHub Bot
parent 5f915b447d
commit 7fff38b1fe
  1. 38
      cache/cache_test.cc
  2. 1
      cache/fast_lru_cache.h
  3. 43
      util/aligned_buffer.h
  4. 9
      util/autovector.h
  5. 24
      util/autovector_test.cc
  6. 20
      util/bloom_test.cc
  7. 1
      util/coding.cc
  8. 32
      util/coding.h
  9. 29
      util/coding_test.cc
  10. 8
      util/comparator.cc
  11. 4
      util/compression_context_cache.cc
  12. 13
      util/concurrent_task_limiter_impl.cc
  13. 2
      util/concurrent_task_limiter_impl.h
  14. 499
      util/crc32c.cc
  15. 5
      util/crc32c.h
  16. 93
      util/crc32c_test.cc
  17. 3
      util/defer.h
  18. 3
      util/defer_test.cc
  19. 3
      util/duplicate_detector.h
  20. 2
      util/dynamic_bloom.cc
  21. 6
      util/dynamic_bloom.h
  22. 2
      util/dynamic_bloom_test.cc
  23. 53
      util/filelock_test.cc
  24. 8
      util/filter_bench.cc
  25. 4
      util/hash_test.cc
  26. 9
      util/heap.h
  27. 40
      util/heap_test.cc
  28. 2
      util/kv_map.h
  29. 7
      util/murmurhash.h
  30. 16
      util/mutexlock.h
  31. 1
      util/random.cc
  32. 6
      util/random.h
  33. 3
      util/random_test.cc
  34. 7
      util/ribbon_test.cc
  35. 2
      util/slice.cc
  36. 3
      util/slice_test.cc
  37. 2
      util/status.cc
  38. 2
      util/string_util.cc
  39. 140
      util/thread_list_test.cc
  40. 50
      util/thread_local.cc
  41. 5
      util/thread_local.h
  42. 77
      util/thread_operation.h
  43. 127
      util/threadpool_imp.cc
  44. 36
      util/threadpool_imp.h
  45. 13
      util/timer.h
  46. 1
      util/timer_queue.h
  47. 1
      util/timer_queue_test.cc

@ -202,29 +202,21 @@ class CacheTest : public testing::TestWithParam<std::string> {
cache->Erase(EncodeKey(key)); cache->Erase(EncodeKey(key));
} }
int Lookup(int key) { int Lookup(int key) { return Lookup(cache_, key); }
return Lookup(cache_, key);
}
void Insert(int key, int value, int charge = 1) { void Insert(int key, int value, int charge = 1) {
Insert(cache_, key, value, charge); Insert(cache_, key, value, charge);
} }
void Erase(int key) { void Erase(int key) { Erase(cache_, key); }
Erase(cache_, key);
}
int Lookup2(int key) { int Lookup2(int key) { return Lookup(cache2_, key); }
return Lookup(cache2_, key);
}
void Insert2(int key, int value, int charge = 1) { void Insert2(int key, int value, int charge = 1) {
Insert(cache2_, key, value, charge); Insert(cache2_, key, value, charge);
} }
void Erase2(int key) { void Erase2(int key) { Erase(cache2_, key); }
Erase(cache2_, key);
}
}; };
CacheTest* CacheTest::current_; CacheTest* CacheTest::current_;
@ -418,13 +410,13 @@ TEST_P(CacheTest, HitAndMiss) {
Insert(100, 101); Insert(100, 101);
ASSERT_EQ(101, Lookup(100)); ASSERT_EQ(101, Lookup(100));
ASSERT_EQ(-1, Lookup(200)); ASSERT_EQ(-1, Lookup(200));
ASSERT_EQ(-1, Lookup(300)); ASSERT_EQ(-1, Lookup(300));
Insert(200, 201); Insert(200, 201);
ASSERT_EQ(101, Lookup(100)); ASSERT_EQ(101, Lookup(100));
ASSERT_EQ(201, Lookup(200)); ASSERT_EQ(201, Lookup(200));
ASSERT_EQ(-1, Lookup(300)); ASSERT_EQ(-1, Lookup(300));
Insert(100, 102); Insert(100, 102);
if (GetParam() == kHyperClock) { if (GetParam() == kHyperClock) {
@ -434,7 +426,7 @@ TEST_P(CacheTest, HitAndMiss) {
ASSERT_EQ(102, Lookup(100)); ASSERT_EQ(102, Lookup(100));
} }
ASSERT_EQ(201, Lookup(200)); ASSERT_EQ(201, Lookup(200));
ASSERT_EQ(-1, Lookup(300)); ASSERT_EQ(-1, Lookup(300));
ASSERT_EQ(1U, deleted_keys_.size()); ASSERT_EQ(1U, deleted_keys_.size());
ASSERT_EQ(100, deleted_keys_[0]); ASSERT_EQ(100, deleted_keys_[0]);
@ -463,14 +455,14 @@ TEST_P(CacheTest, Erase) {
Insert(100, 101); Insert(100, 101);
Insert(200, 201); Insert(200, 201);
Erase(100); Erase(100);
ASSERT_EQ(-1, Lookup(100)); ASSERT_EQ(-1, Lookup(100));
ASSERT_EQ(201, Lookup(200)); ASSERT_EQ(201, Lookup(200));
ASSERT_EQ(1U, deleted_keys_.size()); ASSERT_EQ(1U, deleted_keys_.size());
ASSERT_EQ(100, deleted_keys_[0]); ASSERT_EQ(100, deleted_keys_[0]);
ASSERT_EQ(101, deleted_values_[0]); ASSERT_EQ(101, deleted_values_[0]);
Erase(100); Erase(100);
ASSERT_EQ(-1, Lookup(100)); ASSERT_EQ(-1, Lookup(100));
ASSERT_EQ(201, Lookup(200)); ASSERT_EQ(201, Lookup(200));
ASSERT_EQ(1U, deleted_keys_.size()); ASSERT_EQ(1U, deleted_keys_.size());
} }
@ -515,7 +507,7 @@ TEST_P(CacheTest, EvictionPolicy) {
Insert(200, 201); Insert(200, 201);
// Frequently used entry must be kept around // Frequently used entry must be kept around
for (int i = 0; i < 2 * kCacheSize; i++) { for (int i = 0; i < 2 * kCacheSize; i++) {
Insert(1000+i, 2000+i); Insert(1000 + i, 2000 + i);
ASSERT_EQ(101, Lookup(100)); ASSERT_EQ(101, Lookup(100));
} }
ASSERT_EQ(101, Lookup(100)); ASSERT_EQ(101, Lookup(100));
@ -686,7 +678,7 @@ TEST_P(CacheTest, HeavyEntries) {
ASSERT_EQ(1000 + i, r); ASSERT_EQ(1000 + i, r);
} }
} }
ASSERT_LE(cached_weight, kCacheSize + kCacheSize/10); ASSERT_LE(cached_weight, kCacheSize + kCacheSize / 10);
} }
TEST_P(CacheTest, NewId) { TEST_P(CacheTest, NewId) {
@ -704,7 +696,7 @@ class Value {
namespace { namespace {
void deleter(const Slice& /*key*/, void* value) { void deleter(const Slice& /*key*/, void* value) {
delete static_cast<Value *>(value); delete static_cast<Value*>(value);
} }
} // namespace } // namespace
@ -859,7 +851,7 @@ TEST_P(CacheTest, OverCapacity) {
// a LRUCache with n entries and one shard only // a LRUCache with n entries and one shard only
std::shared_ptr<Cache> cache = NewCache(n, 0, false); std::shared_ptr<Cache> cache = NewCache(n, 0, false);
std::vector<Cache::Handle*> handles(n+1); std::vector<Cache::Handle*> handles(n + 1);
// Insert n+1 entries, but not releasing. // Insert n+1 entries, but not releasing.
for (int i = 0; i < static_cast<int>(n + 1); i++) { for (int i = 0; i < static_cast<int>(n + 1); i++) {
@ -919,7 +911,7 @@ void legacy_callback(void* value, size_t charge) {
legacy_callback_state.push_back( legacy_callback_state.push_back(
{DecodeValue(value), static_cast<int>(charge)}); {DecodeValue(value), static_cast<int>(charge)});
} }
}; }; // namespace
TEST_P(CacheTest, ApplyToAllCacheEntriesTest) { TEST_P(CacheTest, ApplyToAllCacheEntriesTest) {
std::vector<std::pair<int, int>> inserted; std::vector<std::pair<int, int>> inserted;

@ -235,7 +235,6 @@ struct LRUHandle {
} }
}; };
class LRUHandleTable { class LRUHandleTable {
public: public:
explicit LRUHandleTable(int hash_bits); explicit LRUHandleTable(int hash_bits);

@ -9,6 +9,7 @@
#pragma once #pragma once
#include <algorithm> #include <algorithm>
#include "port/port.h" #include "port/port.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
@ -30,9 +31,7 @@ inline size_t TruncateToPageBoundary(size_t page_size, size_t s) {
// Example: // Example:
// Roundup(13, 5) => 15 // Roundup(13, 5) => 15
// Roundup(201, 16) => 208 // Roundup(201, 16) => 208
inline size_t Roundup(size_t x, size_t y) { inline size_t Roundup(size_t x, size_t y) { return ((x + y - 1) / y) * y; }
return ((x + y - 1) / y) * y;
}
// Round down x to a multiple of y. // Round down x to a multiple of y.
// Example: // Example:
@ -61,13 +60,9 @@ class AlignedBuffer {
size_t cursize_; size_t cursize_;
char* bufstart_; char* bufstart_;
public: public:
AlignedBuffer() AlignedBuffer()
: alignment_(), : alignment_(), capacity_(0), cursize_(0), bufstart_(nullptr) {}
capacity_(0),
cursize_(0),
bufstart_(nullptr) {
}
AlignedBuffer(AlignedBuffer&& o) noexcept { *this = std::move(o); } AlignedBuffer(AlignedBuffer&& o) noexcept { *this = std::move(o); }
@ -92,27 +87,17 @@ public:
return n % alignment == 0; return n % alignment == 0;
} }
size_t Alignment() const { size_t Alignment() const { return alignment_; }
return alignment_;
}
size_t Capacity() const { size_t Capacity() const { return capacity_; }
return capacity_;
}
size_t CurrentSize() const { size_t CurrentSize() const { return cursize_; }
return cursize_;
}
const char* BufferStart() const { const char* BufferStart() const { return bufstart_; }
return bufstart_;
}
char* BufferStart() { return bufstart_; } char* BufferStart() { return bufstart_; }
void Clear() { void Clear() { cursize_ = 0; }
cursize_ = 0;
}
char* Release() { char* Release() {
cursize_ = 0; cursize_ = 0;
@ -202,7 +187,7 @@ public:
assert(offset < cursize_); assert(offset < cursize_);
size_t to_read = 0; size_t to_read = 0;
if(offset < cursize_) { if (offset < cursize_) {
to_read = std::min(cursize_ - offset, read_size); to_read = std::min(cursize_ - offset, read_size);
} }
if (to_read > 0) { if (to_read > 0) {
@ -242,12 +227,8 @@ public:
// the buffer is modified without using the write APIs or encapsulation // the buffer is modified without using the write APIs or encapsulation
// offered by AlignedBuffer. It is up to the user to guard against such // offered by AlignedBuffer. It is up to the user to guard against such
// errors. // errors.
char* Destination() { char* Destination() { return bufstart_ + cursize_; }
return bufstart_ + cursize_;
}
void Size(size_t cursize) { void Size(size_t cursize) { cursize_ = cursize; }
cursize_ = cursize;
}
}; };
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

@ -73,7 +73,7 @@ class autovector {
using iterator_category = std::random_access_iterator_tag; using iterator_category = std::random_access_iterator_tag;
iterator_impl(TAutoVector* vect, size_t index) iterator_impl(TAutoVector* vect, size_t index)
: vect_(vect), index_(index) {}; : vect_(vect), index_(index){};
iterator_impl(const iterator_impl&) = default; iterator_impl(const iterator_impl&) = default;
~iterator_impl() {} ~iterator_impl() {}
iterator_impl& operator=(const iterator_impl&) = default; iterator_impl& operator=(const iterator_impl&) = default;
@ -139,9 +139,7 @@ class autovector {
return &(*vect_)[index_]; return &(*vect_)[index_];
} }
reference operator[](difference_type len) const { reference operator[](difference_type len) const { return *(*this + len); }
return *(*this + len);
}
// -- Logical Operators // -- Logical Operators
bool operator==(const self_type& other) const { bool operator==(const self_type& other) const {
@ -303,7 +301,7 @@ class autovector {
reference emplace_back(Args&&... args) { reference emplace_back(Args&&... args) {
if (num_stack_items_ < kSize) { if (num_stack_items_ < kSize) {
return *(new ((void*)(&values_[num_stack_items_++])) return *(new ((void*)(&values_[num_stack_items_++]))
value_type(std::forward<Args>(args)...)); value_type(std::forward<Args>(args)...));
} else { } else {
return vect_.emplace_back(std::forward<Args>(args)...); return vect_.emplace_back(std::forward<Args>(args)...);
} }
@ -319,7 +317,6 @@ class autovector {
} }
#endif #endif
void pop_back() { void pop_back() {
assert(!empty()); assert(!empty());
if (!vect_.empty()) { if (!vect_.empty()) {

@ -3,6 +3,8 @@
// COPYING file in the root directory) and Apache 2.0 License // COPYING file in the root directory) and Apache 2.0 License
// (found in the LICENSE.Apache file in the root directory). // (found in the LICENSE.Apache file in the root directory).
#include "util/autovector.h"
#include <atomic> #include <atomic>
#include <iostream> #include <iostream>
#include <string> #include <string>
@ -11,7 +13,6 @@
#include "rocksdb/env.h" #include "rocksdb/env.h"
#include "test_util/testharness.h" #include "test_util/testharness.h"
#include "test_util/testutil.h" #include "test_util/testutil.h"
#include "util/autovector.h"
#include "util/string_util.h" #include "util/string_util.h"
using std::cout; using std::cout;
@ -28,8 +29,8 @@ void AssertAutoVectorOnlyInStack(autovector<T, kSize>* vec, bool result) {
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
ASSERT_EQ(vec->only_in_stack(), result); ASSERT_EQ(vec->only_in_stack(), result);
#else #else
(void) vec; (void)vec;
(void) result; (void)result;
#endif // !ROCKSDB_LITE #endif // !ROCKSDB_LITE
} }
} // namespace } // namespace
@ -109,8 +110,8 @@ TEST_F(AutoVectorTest, Resize) {
} }
namespace { namespace {
void AssertEqual( void AssertEqual(const autovector<size_t, kSize>& a,
const autovector<size_t, kSize>& a, const autovector<size_t, kSize>& b) { const autovector<size_t, kSize>& b) {
ASSERT_EQ(a.size(), b.size()); ASSERT_EQ(a.size(), b.size());
ASSERT_EQ(a.empty(), b.empty()); ASSERT_EQ(a.empty(), b.empty());
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
@ -124,7 +125,7 @@ void AssertEqual(
TEST_F(AutoVectorTest, CopyAndAssignment) { TEST_F(AutoVectorTest, CopyAndAssignment) {
// Test both heap-allocated and stack-allocated cases. // Test both heap-allocated and stack-allocated cases.
for (auto size : { kSize / 2, kSize * 1000 }) { for (auto size : {kSize / 2, kSize * 1000}) {
autovector<size_t, kSize> vec; autovector<size_t, kSize> vec;
for (size_t i = 0; i < size; ++i) { for (size_t i = 0; i < size; ++i) {
vec.push_back(i); vec.push_back(i);
@ -223,7 +224,7 @@ void BenchmarkVectorCreationAndInsertion(
int index = 0; int index = 0;
auto start_time = env->NowNanos(); auto start_time = env->NowNanos();
auto ops_remaining = ops; auto ops_remaining = ops;
while(ops_remaining--) { while (ops_remaining--) {
TVector v; TVector v;
for (size_t i = 0; i < item_size; ++i) { for (size_t i = 0; i < item_size; ++i) {
v.push_back(items[index++]); v.push_back(items[index++]);
@ -283,7 +284,7 @@ TEST_F(AutoVectorTest, PerfBench) {
// pre-generated unique keys // pre-generated unique keys
auto string_keys = GetTestKeys(kOps * 2 * kSize); auto string_keys = GetTestKeys(kOps * 2 * kSize);
for (auto insertions : { 0ul, 1ul, kSize / 2, kSize, 2 * kSize }) { for (auto insertions : {0ul, 1ul, kSize / 2, kSize, 2 * kSize}) {
BenchmarkVectorCreationAndInsertion<std::vector<std::string>>( BenchmarkVectorCreationAndInsertion<std::vector<std::string>>(
"std::vector<std::string>", kOps, insertions, string_keys); "std::vector<std::string>", kOps, insertions, string_keys);
BenchmarkVectorCreationAndInsertion<autovector<std::string, kSize>>( BenchmarkVectorCreationAndInsertion<autovector<std::string, kSize>>(
@ -300,12 +301,11 @@ TEST_F(AutoVectorTest, PerfBench) {
for (size_t i = 0; i < kOps * 2 * kSize; ++i) { for (size_t i = 0; i < kOps * 2 * kSize; ++i) {
int_keys[i] = i; int_keys[i] = i;
} }
for (auto insertions : { 0ul, 1ul, kSize / 2, kSize, 2 * kSize }) { for (auto insertions : {0ul, 1ul, kSize / 2, kSize, 2 * kSize}) {
BenchmarkVectorCreationAndInsertion<std::vector<uint64_t>>( BenchmarkVectorCreationAndInsertion<std::vector<uint64_t>>(
"std::vector<uint64_t>", kOps, insertions, int_keys); "std::vector<uint64_t>", kOps, insertions, int_keys);
BenchmarkVectorCreationAndInsertion<autovector<uint64_t, kSize>>( BenchmarkVectorCreationAndInsertion<autovector<uint64_t, kSize>>(
"autovector<uint64_t>", kOps, insertions, int_keys "autovector<uint64_t>", kOps, insertions, int_keys);
);
cout << "-----------------------------------" << endl; cout << "-----------------------------------" << endl;
} }
@ -313,7 +313,7 @@ TEST_F(AutoVectorTest, PerfBench) {
cout << "=====================================================" << endl; cout << "=====================================================" << endl;
cout << "Sequence Access Test" << endl; cout << "Sequence Access Test" << endl;
cout << "=====================================================" << endl; cout << "=====================================================" << endl;
for (auto elem_size : { kSize / 2, kSize, 2 * kSize }) { for (auto elem_size : {kSize / 2, kSize, 2 * kSize}) {
BenchmarkSequenceAccess<std::vector<std::string>>("std::vector", kOps, BenchmarkSequenceAccess<std::vector<std::string>>("std::vector", kOps,
elem_size); elem_size);
BenchmarkSequenceAccess<autovector<std::string, kSize>>("autovector", kOps, BenchmarkSequenceAccess<autovector<std::string, kSize>>("autovector", kOps,

@ -110,9 +110,7 @@ class FullBloomTest : public testing::TestWithParam<std::string> {
void ResetPolicy() { ResetPolicy(FLAGS_bits_per_key); } void ResetPolicy() { ResetPolicy(FLAGS_bits_per_key); }
void Add(const Slice& s) { void Add(const Slice& s) { bits_builder_->AddKey(s); }
bits_builder_->AddKey(s);
}
void OpenRaw(const Slice& s) { void OpenRaw(const Slice& s) {
bits_reader_.reset(policy_->GetFilterBitsReader(s)); bits_reader_.reset(policy_->GetFilterBitsReader(s));
@ -124,9 +122,7 @@ class FullBloomTest : public testing::TestWithParam<std::string> {
filter_size_ = filter.size(); filter_size_ = filter.size();
} }
size_t FilterSize() const { size_t FilterSize() const { return filter_size_; }
return filter_size_;
}
Slice FilterData() { return Slice(buf_.get(), filter_size_); } Slice FilterData() { return Slice(buf_.get(), filter_size_); }
@ -319,7 +315,7 @@ TEST_P(FullBloomTest, FullVaryingLengths) {
double rate = FalsePositiveRate(); double rate = FalsePositiveRate();
if (kVerbose >= 1) { if (kVerbose >= 1) {
fprintf(stderr, "False positives: %5.2f%% @ length = %6d ; bytes = %6d\n", fprintf(stderr, "False positives: %5.2f%% @ length = %6d ; bytes = %6d\n",
rate*100.0, length, static_cast<int>(FilterSize())); rate * 100.0, length, static_cast<int>(FilterSize()));
} }
if (FLAGS_bits_per_key == 10) { if (FLAGS_bits_per_key == 10) {
EXPECT_LE(rate, 0.02); // Must not be over 2% EXPECT_LE(rate, 0.02); // Must not be over 2%
@ -331,8 +327,8 @@ TEST_P(FullBloomTest, FullVaryingLengths) {
} }
} }
if (kVerbose >= 1) { if (kVerbose >= 1) {
fprintf(stderr, "Filters: %d good, %d mediocre\n", fprintf(stderr, "Filters: %d good, %d mediocre\n", good_filters,
good_filters, mediocre_filters); mediocre_filters);
} }
EXPECT_LE(mediocre_filters, good_filters / 5); EXPECT_LE(mediocre_filters, good_filters / 5);
} }
@ -817,7 +813,7 @@ struct RawFilterTester {
RawFilterTester() : metadata_ptr_(&*(data_.end() - 5)) {} RawFilterTester() : metadata_ptr_(&*(data_.end() - 5)) {}
Slice ResetNoFill(uint32_t len_without_metadata, uint32_t num_lines, Slice ResetNoFill(uint32_t len_without_metadata, uint32_t num_lines,
uint32_t num_probes) { uint32_t num_probes) {
metadata_ptr_[0] = static_cast<char>(num_probes); metadata_ptr_[0] = static_cast<char>(num_probes);
EncodeFixed32(metadata_ptr_ + 1, num_lines); EncodeFixed32(metadata_ptr_ + 1, num_lines);
uint32_t len = len_without_metadata + /*metadata*/ 5; uint32_t len = len_without_metadata + /*metadata*/ 5;
@ -826,13 +822,13 @@ struct RawFilterTester {
} }
Slice Reset(uint32_t len_without_metadata, uint32_t num_lines, Slice Reset(uint32_t len_without_metadata, uint32_t num_lines,
uint32_t num_probes, bool fill_ones) { uint32_t num_probes, bool fill_ones) {
data_.fill(fill_ones ? 0xff : 0); data_.fill(fill_ones ? 0xff : 0);
return ResetNoFill(len_without_metadata, num_lines, num_probes); return ResetNoFill(len_without_metadata, num_lines, num_probes);
} }
Slice ResetWeirdFill(uint32_t len_without_metadata, uint32_t num_lines, Slice ResetWeirdFill(uint32_t len_without_metadata, uint32_t num_lines,
uint32_t num_probes) { uint32_t num_probes) {
for (uint32_t i = 0; i < data_.size(); ++i) { for (uint32_t i = 0; i < data_.size(); ++i) {
data_[i] = static_cast<char>(0x7b7b >> (i % 7)); data_[i] = static_cast<char>(0x7b7b >> (i % 7));
} }

@ -10,6 +10,7 @@
#include "util/coding.h" #include "util/coding.h"
#include <algorithm> #include <algorithm>
#include "rocksdb/slice.h" #include "rocksdb/slice.h"
#include "rocksdb/slice_transform.h" #include "rocksdb/slice_transform.h"

@ -25,7 +25,7 @@
// Some processors does not allow unaligned access to memory // Some processors does not allow unaligned access to memory
#if defined(__sparc) #if defined(__sparc)
#define PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED #define PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED
#endif #endif
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
@ -82,8 +82,10 @@ inline int64_t zigzagToI64(uint64_t n) {
// in *v and return a pointer just past the parsed value, or return // in *v and return a pointer just past the parsed value, or return
// nullptr on error. These routines only look at bytes in the range // nullptr on error. These routines only look at bytes in the range
// [p..limit-1] // [p..limit-1]
extern const char* GetVarint32Ptr(const char* p,const char* limit, uint32_t* v); extern const char* GetVarint32Ptr(const char* p, const char* limit,
extern const char* GetVarint64Ptr(const char* p,const char* limit, uint64_t* v); uint32_t* v);
extern const char* GetVarint64Ptr(const char* p, const char* limit,
uint64_t* v);
inline const char* GetVarsignedint64Ptr(const char* p, const char* limit, inline const char* GetVarsignedint64Ptr(const char* p, const char* limit,
int64_t* value) { int64_t* value) {
uint64_t u = 0; uint64_t u = 0;
@ -102,11 +104,9 @@ extern char* EncodeVarint32(char* dst, uint32_t value);
extern char* EncodeVarint64(char* dst, uint64_t value); extern char* EncodeVarint64(char* dst, uint64_t value);
// Internal routine for use by fallback path of GetVarint32Ptr // Internal routine for use by fallback path of GetVarint32Ptr
extern const char* GetVarint32PtrFallback(const char* p, extern const char* GetVarint32PtrFallback(const char* p, const char* limit,
const char* limit,
uint32_t* value); uint32_t* value);
inline const char* GetVarint32Ptr(const char* p, inline const char* GetVarint32Ptr(const char* p, const char* limit,
const char* limit,
uint32_t* value) { uint32_t* value) {
if (p < limit) { if (p < limit) {
uint32_t result = *(reinterpret_cast<const unsigned char*>(p)); uint32_t result = *(reinterpret_cast<const unsigned char*>(p));
@ -133,7 +133,7 @@ inline void PutFixed16(std::string* dst, uint16_t value) {
inline void PutFixed32(std::string* dst, uint32_t value) { inline void PutFixed32(std::string* dst, uint32_t value) {
if (port::kLittleEndian) { if (port::kLittleEndian) {
dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)), dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)),
sizeof(value)); sizeof(value));
} else { } else {
char buf[sizeof(value)]; char buf[sizeof(value)];
EncodeFixed32(buf, value); EncodeFixed32(buf, value);
@ -144,7 +144,7 @@ inline void PutFixed32(std::string* dst, uint32_t value) {
inline void PutFixed64(std::string* dst, uint64_t value) { inline void PutFixed64(std::string* dst, uint64_t value) {
if (port::kLittleEndian) { if (port::kLittleEndian) {
dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)), dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)),
sizeof(value)); sizeof(value));
} else { } else {
char buf[sizeof(value)]; char buf[sizeof(value)];
EncodeFixed64(buf, value); EncodeFixed64(buf, value);
@ -350,7 +350,7 @@ inline Slice GetSliceUntil(Slice* slice, char delimiter) {
return ret; return ret;
} }
template<class T> template <class T>
#ifdef ROCKSDB_UBSAN_RUN #ifdef ROCKSDB_UBSAN_RUN
#if defined(__clang__) #if defined(__clang__)
__attribute__((__no_sanitize__("alignment"))) __attribute__((__no_sanitize__("alignment")))
@ -358,16 +358,17 @@ __attribute__((__no_sanitize__("alignment")))
__attribute__((__no_sanitize_undefined__)) __attribute__((__no_sanitize_undefined__))
#endif #endif
#endif #endif
inline void PutUnaligned(T *memory, const T &value) { inline void
PutUnaligned(T* memory, const T& value) {
#if defined(PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED) #if defined(PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED)
char *nonAlignedMemory = reinterpret_cast<char*>(memory); char* nonAlignedMemory = reinterpret_cast<char*>(memory);
memcpy(nonAlignedMemory, reinterpret_cast<const char*>(&value), sizeof(T)); memcpy(nonAlignedMemory, reinterpret_cast<const char*>(&value), sizeof(T));
#else #else
*memory = value; *memory = value;
#endif #endif
} }
template<class T> template <class T>
#ifdef ROCKSDB_UBSAN_RUN #ifdef ROCKSDB_UBSAN_RUN
#if defined(__clang__) #if defined(__clang__)
__attribute__((__no_sanitize__("alignment"))) __attribute__((__no_sanitize__("alignment")))
@ -375,9 +376,10 @@ __attribute__((__no_sanitize__("alignment")))
__attribute__((__no_sanitize_undefined__)) __attribute__((__no_sanitize_undefined__))
#endif #endif
#endif #endif
inline void GetUnaligned(const T *memory, T *value) { inline void
GetUnaligned(const T* memory, T* value) {
#if defined(PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED) #if defined(PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED)
char *nonAlignedMemory = reinterpret_cast<char*>(value); char* nonAlignedMemory = reinterpret_cast<char*>(value);
memcpy(nonAlignedMemory, reinterpret_cast<const char*>(memory), sizeof(T)); memcpy(nonAlignedMemory, reinterpret_cast<const char*>(memory), sizeof(T));
#else #else
*value = *memory; *value = *memory;

@ -13,7 +13,7 @@
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
class Coding { }; class Coding {};
TEST(Coding, Fixed16) { TEST(Coding, Fixed16) {
std::string s; std::string s;
for (uint16_t v = 0; v < 0xFFFF; v++) { for (uint16_t v = 0; v < 0xFFFF; v++) {
@ -56,15 +56,15 @@ TEST(Coding, Fixed64) {
uint64_t v = static_cast<uint64_t>(1) << power; uint64_t v = static_cast<uint64_t>(1) << power;
uint64_t actual = 0; uint64_t actual = 0;
actual = DecodeFixed64(p); actual = DecodeFixed64(p);
ASSERT_EQ(v-1, actual); ASSERT_EQ(v - 1, actual);
p += sizeof(uint64_t); p += sizeof(uint64_t);
actual = DecodeFixed64(p); actual = DecodeFixed64(p);
ASSERT_EQ(v+0, actual); ASSERT_EQ(v + 0, actual);
p += sizeof(uint64_t); p += sizeof(uint64_t);
actual = DecodeFixed64(p); actual = DecodeFixed64(p);
ASSERT_EQ(v+1, actual); ASSERT_EQ(v + 1, actual);
p += sizeof(uint64_t); p += sizeof(uint64_t);
} }
} }
@ -125,8 +125,8 @@ TEST(Coding, Varint64) {
// Test values near powers of two // Test values near powers of two
const uint64_t power = 1ull << k; const uint64_t power = 1ull << k;
values.push_back(power); values.push_back(power);
values.push_back(power-1); values.push_back(power - 1);
values.push_back(power+1); values.push_back(power + 1);
}; };
std::string s; std::string s;
@ -146,14 +146,13 @@ TEST(Coding, Varint64) {
ASSERT_EQ(VarintLength(actual), p - start); ASSERT_EQ(VarintLength(actual), p - start);
} }
ASSERT_EQ(p, limit); ASSERT_EQ(p, limit);
} }
TEST(Coding, Varint32Overflow) { TEST(Coding, Varint32Overflow) {
uint32_t result; uint32_t result;
std::string input("\x81\x82\x83\x84\x85\x11"); std::string input("\x81\x82\x83\x84\x85\x11");
ASSERT_TRUE(GetVarint32Ptr(input.data(), input.data() + input.size(), &result) ASSERT_TRUE(GetVarint32Ptr(input.data(), input.data() + input.size(),
== nullptr); &result) == nullptr);
} }
TEST(Coding, Varint32Truncation) { TEST(Coding, Varint32Truncation) {
@ -164,16 +163,16 @@ TEST(Coding, Varint32Truncation) {
for (unsigned int len = 0; len + 1 < s.size(); len++) { for (unsigned int len = 0; len + 1 < s.size(); len++) {
ASSERT_TRUE(GetVarint32Ptr(s.data(), s.data() + len, &result) == nullptr); ASSERT_TRUE(GetVarint32Ptr(s.data(), s.data() + len, &result) == nullptr);
} }
ASSERT_TRUE( ASSERT_TRUE(GetVarint32Ptr(s.data(), s.data() + s.size(), &result) !=
GetVarint32Ptr(s.data(), s.data() + s.size(), &result) != nullptr); nullptr);
ASSERT_EQ(large_value, result); ASSERT_EQ(large_value, result);
} }
TEST(Coding, Varint64Overflow) { TEST(Coding, Varint64Overflow) {
uint64_t result; uint64_t result;
std::string input("\x81\x82\x83\x84\x85\x81\x82\x83\x84\x85\x11"); std::string input("\x81\x82\x83\x84\x85\x81\x82\x83\x84\x85\x11");
ASSERT_TRUE(GetVarint64Ptr(input.data(), input.data() + input.size(), &result) ASSERT_TRUE(GetVarint64Ptr(input.data(), input.data() + input.size(),
== nullptr); &result) == nullptr);
} }
TEST(Coding, Varint64Truncation) { TEST(Coding, Varint64Truncation) {
@ -184,8 +183,8 @@ TEST(Coding, Varint64Truncation) {
for (unsigned int len = 0; len + 1 < s.size(); len++) { for (unsigned int len = 0; len + 1 < s.size(); len++) {
ASSERT_TRUE(GetVarint64Ptr(s.data(), s.data() + len, &result) == nullptr); ASSERT_TRUE(GetVarint64Ptr(s.data(), s.data() + len, &result) == nullptr);
} }
ASSERT_TRUE( ASSERT_TRUE(GetVarint64Ptr(s.data(), s.data() + s.size(), &result) !=
GetVarint64Ptr(s.data(), s.data() + s.size(), &result) != nullptr); nullptr);
ASSERT_EQ(large_value, result); ASSERT_EQ(large_value, result);
} }

@ -29,7 +29,7 @@ namespace ROCKSDB_NAMESPACE {
namespace { namespace {
class BytewiseComparatorImpl : public Comparator { class BytewiseComparatorImpl : public Comparator {
public: public:
BytewiseComparatorImpl() { } BytewiseComparatorImpl() {}
static const char* kClassName() { return "leveldb.BytewiseComparator"; } static const char* kClassName() { return "leveldb.BytewiseComparator"; }
const char* Name() const override { return kClassName(); } const char* Name() const override { return kClassName(); }
@ -97,7 +97,7 @@ class BytewiseComparatorImpl : public Comparator {
const uint8_t byte = (*key)[i]; const uint8_t byte = (*key)[i];
if (byte != static_cast<uint8_t>(0xff)) { if (byte != static_cast<uint8_t>(0xff)) {
(*key)[i] = byte + 1; (*key)[i] = byte + 1;
key->resize(i+1); key->resize(i + 1);
return; return;
} }
} }
@ -147,7 +147,7 @@ class BytewiseComparatorImpl : public Comparator {
class ReverseBytewiseComparatorImpl : public BytewiseComparatorImpl { class ReverseBytewiseComparatorImpl : public BytewiseComparatorImpl {
public: public:
ReverseBytewiseComparatorImpl() { } ReverseBytewiseComparatorImpl() {}
static const char* kClassName() { static const char* kClassName() {
return "rocksdb.ReverseBytewiseComparator"; return "rocksdb.ReverseBytewiseComparator";
@ -298,7 +298,7 @@ class ComparatorWithU64TsImpl : public Comparator {
TComparator cmp_without_ts_; TComparator cmp_without_ts_;
}; };
}// namespace } // namespace
const Comparator* BytewiseComparator() { const Comparator* BytewiseComparator() {
STATIC_AVOID_DESTRUCTION(BytewiseComparatorImpl, bytewise); STATIC_AVOID_DESTRUCTION(BytewiseComparatorImpl, bytewise);

@ -9,11 +9,11 @@
#include "util/compression_context_cache.h" #include "util/compression_context_cache.h"
#include <atomic>
#include "util/compression.h" #include "util/compression.h"
#include "util/core_local.h" #include "util/core_local.h"
#include <atomic>
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
namespace compression_cache { namespace compression_cache {

@ -8,6 +8,7 @@
// found in the LICENSE file. See the AUTHORS file for names of contributors. // found in the LICENSE file. See the AUTHORS file for names of contributors.
#include "util/concurrent_task_limiter_impl.h" #include "util/concurrent_task_limiter_impl.h"
#include "rocksdb/concurrent_task_limiter.h" #include "rocksdb/concurrent_task_limiter.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
@ -16,17 +17,13 @@ ConcurrentTaskLimiterImpl::ConcurrentTaskLimiterImpl(
const std::string& name, int32_t max_outstanding_task) const std::string& name, int32_t max_outstanding_task)
: name_(name), : name_(name),
max_outstanding_tasks_{max_outstanding_task}, max_outstanding_tasks_{max_outstanding_task},
outstanding_tasks_{0} { outstanding_tasks_{0} {}
}
ConcurrentTaskLimiterImpl::~ConcurrentTaskLimiterImpl() { ConcurrentTaskLimiterImpl::~ConcurrentTaskLimiterImpl() {
assert(outstanding_tasks_ == 0); assert(outstanding_tasks_ == 0);
} }
const std::string& ConcurrentTaskLimiterImpl::GetName() const { const std::string& ConcurrentTaskLimiterImpl::GetName() const { return name_; }
return name_;
}
void ConcurrentTaskLimiterImpl::SetMaxOutstandingTask(int32_t limit) { void ConcurrentTaskLimiterImpl::SetMaxOutstandingTask(int32_t limit) {
max_outstanding_tasks_.store(limit, std::memory_order_relaxed); max_outstanding_tasks_.store(limit, std::memory_order_relaxed);
@ -54,8 +51,8 @@ std::unique_ptr<TaskLimiterToken> ConcurrentTaskLimiterImpl::GetToken(
return nullptr; return nullptr;
} }
ConcurrentTaskLimiter* NewConcurrentTaskLimiter( ConcurrentTaskLimiter* NewConcurrentTaskLimiter(const std::string& name,
const std::string& name, int32_t limit) { int32_t limit) {
return new ConcurrentTaskLimiterImpl(name, limit); return new ConcurrentTaskLimiterImpl(name, limit);
} }

@ -11,8 +11,8 @@
#include <atomic> #include <atomic>
#include <memory> #include <memory>
#include "rocksdb/env.h"
#include "rocksdb/concurrent_task_limiter.h" #include "rocksdb/concurrent_task_limiter.h"
#include "rocksdb/env.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {

@ -64,301 +64,209 @@ static int arch_ppc_crc32 = 0;
#endif #endif
static const uint32_t table0_[256] = { static const uint32_t table0_[256] = {
0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c,
0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb, 0x26a1e7e8, 0xd4ca64eb, 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b,
0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24, 0x105ec76f, 0xe235446c,
0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54, 0x5d1d08bf, 0xaf768bbc,
0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384, 0xbc267848, 0x4e4dfb4b, 0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a,
0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54, 0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35, 0xaa64d611, 0x580f5512,
0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b, 0x4b5fa6e6, 0xb93425e5, 0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a, 0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad,
0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35, 0x1642ae59, 0xe4292d5a, 0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a,
0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5, 0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595, 0x417b1dbc, 0xb3109ebf,
0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa, 0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c, 0xfe53516f,
0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a, 0xed03a29b, 0x1f682198, 0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927,
0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a, 0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38, 0xdbfc821c, 0x2997011f,
0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595, 0x3ac7f2eb, 0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48, 0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096, 0xa65c047d, 0x5437877e,
0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957, 0x4767748a, 0xb50cf789, 0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859,
0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46, 0x7198540d, 0x83f3d70e,
0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198, 0x90a324fa, 0x62c8a7f9, 0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927, 0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de,
0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38, 0xdde0eb2a, 0x2f8b6829, 0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c,
0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8, 0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93, 0x082f63b7, 0xfa44e0b4,
0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7, 0xe9141340, 0x1b7f9043, 0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096, 0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x55326b08, 0xa759e80b,
0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789, 0xb4091bff, 0x466298fc, 0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c,
0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859, 0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033, 0xa24bb5a6, 0x502036a5,
0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46, 0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9, 0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 0xef087a76, 0x1d63f975,
0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6, 0x0e330a81, 0xfc588982, 0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d,
0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622, 0x38cc2a06, 0xcaa7a905,
0x3cdb9bdd, 0xceb018de, 0xdde0eb2a, 0x2f8b6829, 0xd9f75af1, 0x2b9cd9f2, 0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed,
0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c, 0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530, 0x0417b1db, 0xf67c32d8,
0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93, 0xe52cc12c, 0x1747422f, 0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff,
0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043, 0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0, 0xd3d3e1ab, 0x21b862a8,
0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c, 0x32e8915c, 0xc083125f, 0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90, 0x9e902e7b, 0x6cfbad78,
0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc, 0x7fab5e8c, 0x8dc0dd8f, 0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee,
0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c, 0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1, 0x69e9f0d5, 0x9b8273d6,
0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033, 0x88d28022, 0x7ab90321, 0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e,
0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652, 0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81, 0x34f4f86a, 0xc69f7b69,
0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d, 0xd5cf889d, 0x27a40b9e, 0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e,
0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351};
0xef087a76, 0x1d63f975, 0x0e330a81, 0xfc588982,
0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d,
0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622,
0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2,
0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed,
0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530,
0x0417b1db, 0xf67c32d8, 0xe52cc12c, 0x1747422f,
0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff,
0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0,
0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f,
0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90,
0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f,
0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee,
0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1,
0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321,
0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e,
0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81,
0x34f4f86a, 0xc69f7b69, 0xd5cf889d, 0x27a40b9e,
0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e,
0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351
};
static const uint32_t table1_[256] = { static const uint32_t table1_[256] = {
0x00000000, 0x13a29877, 0x274530ee, 0x34e7a899, 0x00000000, 0x13a29877, 0x274530ee, 0x34e7a899, 0x4e8a61dc, 0x5d28f9ab,
0x4e8a61dc, 0x5d28f9ab, 0x69cf5132, 0x7a6dc945, 0x69cf5132, 0x7a6dc945, 0x9d14c3b8, 0x8eb65bcf, 0xba51f356, 0xa9f36b21,
0x9d14c3b8, 0x8eb65bcf, 0xba51f356, 0xa9f36b21, 0xd39ea264, 0xc03c3a13, 0xf4db928a, 0xe7790afd, 0x3fc5f181, 0x2c6769f6,
0xd39ea264, 0xc03c3a13, 0xf4db928a, 0xe7790afd, 0x1880c16f, 0x0b225918, 0x714f905d, 0x62ed082a, 0x560aa0b3, 0x45a838c4,
0x3fc5f181, 0x2c6769f6, 0x1880c16f, 0x0b225918, 0xa2d13239, 0xb173aa4e, 0x859402d7, 0x96369aa0, 0xec5b53e5, 0xfff9cb92,
0x714f905d, 0x62ed082a, 0x560aa0b3, 0x45a838c4, 0xcb1e630b, 0xd8bcfb7c, 0x7f8be302, 0x6c297b75, 0x58ced3ec, 0x4b6c4b9b,
0xa2d13239, 0xb173aa4e, 0x859402d7, 0x96369aa0, 0x310182de, 0x22a31aa9, 0x1644b230, 0x05e62a47, 0xe29f20ba, 0xf13db8cd,
0xec5b53e5, 0xfff9cb92, 0xcb1e630b, 0xd8bcfb7c, 0xc5da1054, 0xd6788823, 0xac154166, 0xbfb7d911, 0x8b507188, 0x98f2e9ff,
0x7f8be302, 0x6c297b75, 0x58ced3ec, 0x4b6c4b9b, 0x404e1283, 0x53ec8af4, 0x670b226d, 0x74a9ba1a, 0x0ec4735f, 0x1d66eb28,
0x310182de, 0x22a31aa9, 0x1644b230, 0x05e62a47, 0x298143b1, 0x3a23dbc6, 0xdd5ad13b, 0xcef8494c, 0xfa1fe1d5, 0xe9bd79a2,
0xe29f20ba, 0xf13db8cd, 0xc5da1054, 0xd6788823, 0x93d0b0e7, 0x80722890, 0xb4958009, 0xa737187e, 0xff17c604, 0xecb55e73,
0xac154166, 0xbfb7d911, 0x8b507188, 0x98f2e9ff, 0xd852f6ea, 0xcbf06e9d, 0xb19da7d8, 0xa23f3faf, 0x96d89736, 0x857a0f41,
0x404e1283, 0x53ec8af4, 0x670b226d, 0x74a9ba1a, 0x620305bc, 0x71a19dcb, 0x45463552, 0x56e4ad25, 0x2c896460, 0x3f2bfc17,
0x0ec4735f, 0x1d66eb28, 0x298143b1, 0x3a23dbc6, 0x0bcc548e, 0x186eccf9, 0xc0d23785, 0xd370aff2, 0xe797076b, 0xf4359f1c,
0xdd5ad13b, 0xcef8494c, 0xfa1fe1d5, 0xe9bd79a2, 0x8e585659, 0x9dface2e, 0xa91d66b7, 0xbabffec0, 0x5dc6f43d, 0x4e646c4a,
0x93d0b0e7, 0x80722890, 0xb4958009, 0xa737187e, 0x7a83c4d3, 0x69215ca4, 0x134c95e1, 0x00ee0d96, 0x3409a50f, 0x27ab3d78,
0xff17c604, 0xecb55e73, 0xd852f6ea, 0xcbf06e9d, 0x809c2506, 0x933ebd71, 0xa7d915e8, 0xb47b8d9f, 0xce1644da, 0xddb4dcad,
0xb19da7d8, 0xa23f3faf, 0x96d89736, 0x857a0f41, 0xe9537434, 0xfaf1ec43, 0x1d88e6be, 0x0e2a7ec9, 0x3acdd650, 0x296f4e27,
0x620305bc, 0x71a19dcb, 0x45463552, 0x56e4ad25, 0x53028762, 0x40a01f15, 0x7447b78c, 0x67e52ffb, 0xbf59d487, 0xacfb4cf0,
0x2c896460, 0x3f2bfc17, 0x0bcc548e, 0x186eccf9, 0x981ce469, 0x8bbe7c1e, 0xf1d3b55b, 0xe2712d2c, 0xd69685b5, 0xc5341dc2,
0xc0d23785, 0xd370aff2, 0xe797076b, 0xf4359f1c, 0x224d173f, 0x31ef8f48, 0x050827d1, 0x16aabfa6, 0x6cc776e3, 0x7f65ee94,
0x8e585659, 0x9dface2e, 0xa91d66b7, 0xbabffec0, 0x4b82460d, 0x5820de7a, 0xfbc3faf9, 0xe861628e, 0xdc86ca17, 0xcf245260,
0x5dc6f43d, 0x4e646c4a, 0x7a83c4d3, 0x69215ca4, 0xb5499b25, 0xa6eb0352, 0x920cabcb, 0x81ae33bc, 0x66d73941, 0x7575a136,
0x134c95e1, 0x00ee0d96, 0x3409a50f, 0x27ab3d78, 0x419209af, 0x523091d8, 0x285d589d, 0x3bffc0ea, 0x0f186873, 0x1cbaf004,
0x809c2506, 0x933ebd71, 0xa7d915e8, 0xb47b8d9f, 0xc4060b78, 0xd7a4930f, 0xe3433b96, 0xf0e1a3e1, 0x8a8c6aa4, 0x992ef2d3,
0xce1644da, 0xddb4dcad, 0xe9537434, 0xfaf1ec43, 0xadc95a4a, 0xbe6bc23d, 0x5912c8c0, 0x4ab050b7, 0x7e57f82e, 0x6df56059,
0x1d88e6be, 0x0e2a7ec9, 0x3acdd650, 0x296f4e27, 0x1798a91c, 0x043a316b, 0x30dd99f2, 0x237f0185, 0x844819fb, 0x97ea818c,
0x53028762, 0x40a01f15, 0x7447b78c, 0x67e52ffb, 0xa30d2915, 0xb0afb162, 0xcac27827, 0xd960e050, 0xed8748c9, 0xfe25d0be,
0xbf59d487, 0xacfb4cf0, 0x981ce469, 0x8bbe7c1e, 0x195cda43, 0x0afe4234, 0x3e19eaad, 0x2dbb72da, 0x57d6bb9f, 0x447423e8,
0xf1d3b55b, 0xe2712d2c, 0xd69685b5, 0xc5341dc2, 0x70938b71, 0x63311306, 0xbb8de87a, 0xa82f700d, 0x9cc8d894, 0x8f6a40e3,
0x224d173f, 0x31ef8f48, 0x050827d1, 0x16aabfa6, 0xf50789a6, 0xe6a511d1, 0xd242b948, 0xc1e0213f, 0x26992bc2, 0x353bb3b5,
0x6cc776e3, 0x7f65ee94, 0x4b82460d, 0x5820de7a, 0x01dc1b2c, 0x127e835b, 0x68134a1e, 0x7bb1d269, 0x4f567af0, 0x5cf4e287,
0xfbc3faf9, 0xe861628e, 0xdc86ca17, 0xcf245260, 0x04d43cfd, 0x1776a48a, 0x23910c13, 0x30339464, 0x4a5e5d21, 0x59fcc556,
0xb5499b25, 0xa6eb0352, 0x920cabcb, 0x81ae33bc, 0x6d1b6dcf, 0x7eb9f5b8, 0x99c0ff45, 0x8a626732, 0xbe85cfab, 0xad2757dc,
0x66d73941, 0x7575a136, 0x419209af, 0x523091d8, 0xd74a9e99, 0xc4e806ee, 0xf00fae77, 0xe3ad3600, 0x3b11cd7c, 0x28b3550b,
0x285d589d, 0x3bffc0ea, 0x0f186873, 0x1cbaf004, 0x1c54fd92, 0x0ff665e5, 0x759baca0, 0x663934d7, 0x52de9c4e, 0x417c0439,
0xc4060b78, 0xd7a4930f, 0xe3433b96, 0xf0e1a3e1, 0xa6050ec4, 0xb5a796b3, 0x81403e2a, 0x92e2a65d, 0xe88f6f18, 0xfb2df76f,
0x8a8c6aa4, 0x992ef2d3, 0xadc95a4a, 0xbe6bc23d, 0xcfca5ff6, 0xdc68c781, 0x7b5fdfff, 0x68fd4788, 0x5c1aef11, 0x4fb87766,
0x5912c8c0, 0x4ab050b7, 0x7e57f82e, 0x6df56059, 0x35d5be23, 0x26772654, 0x12908ecd, 0x013216ba, 0xe64b1c47, 0xf5e98430,
0x1798a91c, 0x043a316b, 0x30dd99f2, 0x237f0185, 0xc10e2ca9, 0xd2acb4de, 0xa8c17d9b, 0xbb63e5ec, 0x8f844d75, 0x9c26d502,
0x844819fb, 0x97ea818c, 0xa30d2915, 0xb0afb162, 0x449a2e7e, 0x5738b609, 0x63df1e90, 0x707d86e7, 0x0a104fa2, 0x19b2d7d5,
0xcac27827, 0xd960e050, 0xed8748c9, 0xfe25d0be, 0x2d557f4c, 0x3ef7e73b, 0xd98eedc6, 0xca2c75b1, 0xfecbdd28, 0xed69455f,
0x195cda43, 0x0afe4234, 0x3e19eaad, 0x2dbb72da, 0x97048c1a, 0x84a6146d, 0xb041bcf4, 0xa3e32483};
0x57d6bb9f, 0x447423e8, 0x70938b71, 0x63311306,
0xbb8de87a, 0xa82f700d, 0x9cc8d894, 0x8f6a40e3,
0xf50789a6, 0xe6a511d1, 0xd242b948, 0xc1e0213f,
0x26992bc2, 0x353bb3b5, 0x01dc1b2c, 0x127e835b,
0x68134a1e, 0x7bb1d269, 0x4f567af0, 0x5cf4e287,
0x04d43cfd, 0x1776a48a, 0x23910c13, 0x30339464,
0x4a5e5d21, 0x59fcc556, 0x6d1b6dcf, 0x7eb9f5b8,
0x99c0ff45, 0x8a626732, 0xbe85cfab, 0xad2757dc,
0xd74a9e99, 0xc4e806ee, 0xf00fae77, 0xe3ad3600,
0x3b11cd7c, 0x28b3550b, 0x1c54fd92, 0x0ff665e5,
0x759baca0, 0x663934d7, 0x52de9c4e, 0x417c0439,
0xa6050ec4, 0xb5a796b3, 0x81403e2a, 0x92e2a65d,
0xe88f6f18, 0xfb2df76f, 0xcfca5ff6, 0xdc68c781,
0x7b5fdfff, 0x68fd4788, 0x5c1aef11, 0x4fb87766,
0x35d5be23, 0x26772654, 0x12908ecd, 0x013216ba,
0xe64b1c47, 0xf5e98430, 0xc10e2ca9, 0xd2acb4de,
0xa8c17d9b, 0xbb63e5ec, 0x8f844d75, 0x9c26d502,
0x449a2e7e, 0x5738b609, 0x63df1e90, 0x707d86e7,
0x0a104fa2, 0x19b2d7d5, 0x2d557f4c, 0x3ef7e73b,
0xd98eedc6, 0xca2c75b1, 0xfecbdd28, 0xed69455f,
0x97048c1a, 0x84a6146d, 0xb041bcf4, 0xa3e32483
};
static const uint32_t table2_[256] = { static const uint32_t table2_[256] = {
0x00000000, 0xa541927e, 0x4f6f520d, 0xea2ec073, 0x00000000, 0xa541927e, 0x4f6f520d, 0xea2ec073, 0x9edea41a, 0x3b9f3664,
0x9edea41a, 0x3b9f3664, 0xd1b1f617, 0x74f06469, 0xd1b1f617, 0x74f06469, 0x38513ec5, 0x9d10acbb, 0x773e6cc8, 0xd27ffeb6,
0x38513ec5, 0x9d10acbb, 0x773e6cc8, 0xd27ffeb6, 0xa68f9adf, 0x03ce08a1, 0xe9e0c8d2, 0x4ca15aac, 0x70a27d8a, 0xd5e3eff4,
0xa68f9adf, 0x03ce08a1, 0xe9e0c8d2, 0x4ca15aac, 0x3fcd2f87, 0x9a8cbdf9, 0xee7cd990, 0x4b3d4bee, 0xa1138b9d, 0x045219e3,
0x70a27d8a, 0xd5e3eff4, 0x3fcd2f87, 0x9a8cbdf9, 0x48f3434f, 0xedb2d131, 0x079c1142, 0xa2dd833c, 0xd62de755, 0x736c752b,
0xee7cd990, 0x4b3d4bee, 0xa1138b9d, 0x045219e3, 0x9942b558, 0x3c032726, 0xe144fb14, 0x4405696a, 0xae2ba919, 0x0b6a3b67,
0x48f3434f, 0xedb2d131, 0x079c1142, 0xa2dd833c, 0x7f9a5f0e, 0xdadbcd70, 0x30f50d03, 0x95b49f7d, 0xd915c5d1, 0x7c5457af,
0xd62de755, 0x736c752b, 0x9942b558, 0x3c032726, 0x967a97dc, 0x333b05a2, 0x47cb61cb, 0xe28af3b5, 0x08a433c6, 0xade5a1b8,
0xe144fb14, 0x4405696a, 0xae2ba919, 0x0b6a3b67, 0x91e6869e, 0x34a714e0, 0xde89d493, 0x7bc846ed, 0x0f382284, 0xaa79b0fa,
0x7f9a5f0e, 0xdadbcd70, 0x30f50d03, 0x95b49f7d, 0x40577089, 0xe516e2f7, 0xa9b7b85b, 0x0cf62a25, 0xe6d8ea56, 0x43997828,
0xd915c5d1, 0x7c5457af, 0x967a97dc, 0x333b05a2, 0x37691c41, 0x92288e3f, 0x78064e4c, 0xdd47dc32, 0xc76580d9, 0x622412a7,
0x47cb61cb, 0xe28af3b5, 0x08a433c6, 0xade5a1b8, 0x880ad2d4, 0x2d4b40aa, 0x59bb24c3, 0xfcfab6bd, 0x16d476ce, 0xb395e4b0,
0x91e6869e, 0x34a714e0, 0xde89d493, 0x7bc846ed, 0xff34be1c, 0x5a752c62, 0xb05bec11, 0x151a7e6f, 0x61ea1a06, 0xc4ab8878,
0x0f382284, 0xaa79b0fa, 0x40577089, 0xe516e2f7, 0x2e85480b, 0x8bc4da75, 0xb7c7fd53, 0x12866f2d, 0xf8a8af5e, 0x5de93d20,
0xa9b7b85b, 0x0cf62a25, 0xe6d8ea56, 0x43997828, 0x29195949, 0x8c58cb37, 0x66760b44, 0xc337993a, 0x8f96c396, 0x2ad751e8,
0x37691c41, 0x92288e3f, 0x78064e4c, 0xdd47dc32, 0xc0f9919b, 0x65b803e5, 0x1148678c, 0xb409f5f2, 0x5e273581, 0xfb66a7ff,
0xc76580d9, 0x622412a7, 0x880ad2d4, 0x2d4b40aa, 0x26217bcd, 0x8360e9b3, 0x694e29c0, 0xcc0fbbbe, 0xb8ffdfd7, 0x1dbe4da9,
0x59bb24c3, 0xfcfab6bd, 0x16d476ce, 0xb395e4b0, 0xf7908dda, 0x52d11fa4, 0x1e704508, 0xbb31d776, 0x511f1705, 0xf45e857b,
0xff34be1c, 0x5a752c62, 0xb05bec11, 0x151a7e6f, 0x80aee112, 0x25ef736c, 0xcfc1b31f, 0x6a802161, 0x56830647, 0xf3c29439,
0x61ea1a06, 0xc4ab8878, 0x2e85480b, 0x8bc4da75, 0x19ec544a, 0xbcadc634, 0xc85da25d, 0x6d1c3023, 0x8732f050, 0x2273622e,
0xb7c7fd53, 0x12866f2d, 0xf8a8af5e, 0x5de93d20, 0x6ed23882, 0xcb93aafc, 0x21bd6a8f, 0x84fcf8f1, 0xf00c9c98, 0x554d0ee6,
0x29195949, 0x8c58cb37, 0x66760b44, 0xc337993a, 0xbf63ce95, 0x1a225ceb, 0x8b277743, 0x2e66e53d, 0xc448254e, 0x6109b730,
0x8f96c396, 0x2ad751e8, 0xc0f9919b, 0x65b803e5, 0x15f9d359, 0xb0b84127, 0x5a968154, 0xffd7132a, 0xb3764986, 0x1637dbf8,
0x1148678c, 0xb409f5f2, 0x5e273581, 0xfb66a7ff, 0xfc191b8b, 0x595889f5, 0x2da8ed9c, 0x88e97fe2, 0x62c7bf91, 0xc7862def,
0x26217bcd, 0x8360e9b3, 0x694e29c0, 0xcc0fbbbe, 0xfb850ac9, 0x5ec498b7, 0xb4ea58c4, 0x11abcaba, 0x655baed3, 0xc01a3cad,
0xb8ffdfd7, 0x1dbe4da9, 0xf7908dda, 0x52d11fa4, 0x2a34fcde, 0x8f756ea0, 0xc3d4340c, 0x6695a672, 0x8cbb6601, 0x29faf47f,
0x1e704508, 0xbb31d776, 0x511f1705, 0xf45e857b, 0x5d0a9016, 0xf84b0268, 0x1265c21b, 0xb7245065, 0x6a638c57, 0xcf221e29,
0x80aee112, 0x25ef736c, 0xcfc1b31f, 0x6a802161, 0x250cde5a, 0x804d4c24, 0xf4bd284d, 0x51fcba33, 0xbbd27a40, 0x1e93e83e,
0x56830647, 0xf3c29439, 0x19ec544a, 0xbcadc634, 0x5232b292, 0xf77320ec, 0x1d5de09f, 0xb81c72e1, 0xccec1688, 0x69ad84f6,
0xc85da25d, 0x6d1c3023, 0x8732f050, 0x2273622e, 0x83834485, 0x26c2d6fb, 0x1ac1f1dd, 0xbf8063a3, 0x55aea3d0, 0xf0ef31ae,
0x6ed23882, 0xcb93aafc, 0x21bd6a8f, 0x84fcf8f1, 0x841f55c7, 0x215ec7b9, 0xcb7007ca, 0x6e3195b4, 0x2290cf18, 0x87d15d66,
0xf00c9c98, 0x554d0ee6, 0xbf63ce95, 0x1a225ceb, 0x6dff9d15, 0xc8be0f6b, 0xbc4e6b02, 0x190ff97c, 0xf321390f, 0x5660ab71,
0x8b277743, 0x2e66e53d, 0xc448254e, 0x6109b730, 0x4c42f79a, 0xe90365e4, 0x032da597, 0xa66c37e9, 0xd29c5380, 0x77ddc1fe,
0x15f9d359, 0xb0b84127, 0x5a968154, 0xffd7132a, 0x9df3018d, 0x38b293f3, 0x7413c95f, 0xd1525b21, 0x3b7c9b52, 0x9e3d092c,
0xb3764986, 0x1637dbf8, 0xfc191b8b, 0x595889f5, 0xeacd6d45, 0x4f8cff3b, 0xa5a23f48, 0x00e3ad36, 0x3ce08a10, 0x99a1186e,
0x2da8ed9c, 0x88e97fe2, 0x62c7bf91, 0xc7862def, 0x738fd81d, 0xd6ce4a63, 0xa23e2e0a, 0x077fbc74, 0xed517c07, 0x4810ee79,
0xfb850ac9, 0x5ec498b7, 0xb4ea58c4, 0x11abcaba, 0x04b1b4d5, 0xa1f026ab, 0x4bdee6d8, 0xee9f74a6, 0x9a6f10cf, 0x3f2e82b1,
0x655baed3, 0xc01a3cad, 0x2a34fcde, 0x8f756ea0, 0xd50042c2, 0x7041d0bc, 0xad060c8e, 0x08479ef0, 0xe2695e83, 0x4728ccfd,
0xc3d4340c, 0x6695a672, 0x8cbb6601, 0x29faf47f, 0x33d8a894, 0x96993aea, 0x7cb7fa99, 0xd9f668e7, 0x9557324b, 0x3016a035,
0x5d0a9016, 0xf84b0268, 0x1265c21b, 0xb7245065, 0xda386046, 0x7f79f238, 0x0b899651, 0xaec8042f, 0x44e6c45c, 0xe1a75622,
0x6a638c57, 0xcf221e29, 0x250cde5a, 0x804d4c24, 0xdda47104, 0x78e5e37a, 0x92cb2309, 0x378ab177, 0x437ad51e, 0xe63b4760,
0xf4bd284d, 0x51fcba33, 0xbbd27a40, 0x1e93e83e, 0x0c158713, 0xa954156d, 0xe5f54fc1, 0x40b4ddbf, 0xaa9a1dcc, 0x0fdb8fb2,
0x5232b292, 0xf77320ec, 0x1d5de09f, 0xb81c72e1, 0x7b2bebdb, 0xde6a79a5, 0x3444b9d6, 0x91052ba8};
0xccec1688, 0x69ad84f6, 0x83834485, 0x26c2d6fb,
0x1ac1f1dd, 0xbf8063a3, 0x55aea3d0, 0xf0ef31ae,
0x841f55c7, 0x215ec7b9, 0xcb7007ca, 0x6e3195b4,
0x2290cf18, 0x87d15d66, 0x6dff9d15, 0xc8be0f6b,
0xbc4e6b02, 0x190ff97c, 0xf321390f, 0x5660ab71,
0x4c42f79a, 0xe90365e4, 0x032da597, 0xa66c37e9,
0xd29c5380, 0x77ddc1fe, 0x9df3018d, 0x38b293f3,
0x7413c95f, 0xd1525b21, 0x3b7c9b52, 0x9e3d092c,
0xeacd6d45, 0x4f8cff3b, 0xa5a23f48, 0x00e3ad36,
0x3ce08a10, 0x99a1186e, 0x738fd81d, 0xd6ce4a63,
0xa23e2e0a, 0x077fbc74, 0xed517c07, 0x4810ee79,
0x04b1b4d5, 0xa1f026ab, 0x4bdee6d8, 0xee9f74a6,
0x9a6f10cf, 0x3f2e82b1, 0xd50042c2, 0x7041d0bc,
0xad060c8e, 0x08479ef0, 0xe2695e83, 0x4728ccfd,
0x33d8a894, 0x96993aea, 0x7cb7fa99, 0xd9f668e7,
0x9557324b, 0x3016a035, 0xda386046, 0x7f79f238,
0x0b899651, 0xaec8042f, 0x44e6c45c, 0xe1a75622,
0xdda47104, 0x78e5e37a, 0x92cb2309, 0x378ab177,
0x437ad51e, 0xe63b4760, 0x0c158713, 0xa954156d,
0xe5f54fc1, 0x40b4ddbf, 0xaa9a1dcc, 0x0fdb8fb2,
0x7b2bebdb, 0xde6a79a5, 0x3444b9d6, 0x91052ba8
};
static const uint32_t table3_[256] = { static const uint32_t table3_[256] = {
0x00000000, 0xdd45aab8, 0xbf672381, 0x62228939, 0x00000000, 0xdd45aab8, 0xbf672381, 0x62228939, 0x7b2231f3, 0xa6679b4b,
0x7b2231f3, 0xa6679b4b, 0xc4451272, 0x1900b8ca, 0xc4451272, 0x1900b8ca, 0xf64463e6, 0x2b01c95e, 0x49234067, 0x9466eadf,
0xf64463e6, 0x2b01c95e, 0x49234067, 0x9466eadf, 0x8d665215, 0x5023f8ad, 0x32017194, 0xef44db2c, 0xe964b13d, 0x34211b85,
0x8d665215, 0x5023f8ad, 0x32017194, 0xef44db2c, 0x560392bc, 0x8b463804, 0x924680ce, 0x4f032a76, 0x2d21a34f, 0xf06409f7,
0xe964b13d, 0x34211b85, 0x560392bc, 0x8b463804, 0x1f20d2db, 0xc2657863, 0xa047f15a, 0x7d025be2, 0x6402e328, 0xb9474990,
0x924680ce, 0x4f032a76, 0x2d21a34f, 0xf06409f7, 0xdb65c0a9, 0x06206a11, 0xd725148b, 0x0a60be33, 0x6842370a, 0xb5079db2,
0x1f20d2db, 0xc2657863, 0xa047f15a, 0x7d025be2, 0xac072578, 0x71428fc0, 0x136006f9, 0xce25ac41, 0x2161776d, 0xfc24ddd5,
0x6402e328, 0xb9474990, 0xdb65c0a9, 0x06206a11, 0x9e0654ec, 0x4343fe54, 0x5a43469e, 0x8706ec26, 0xe524651f, 0x3861cfa7,
0xd725148b, 0x0a60be33, 0x6842370a, 0xb5079db2, 0x3e41a5b6, 0xe3040f0e, 0x81268637, 0x5c632c8f, 0x45639445, 0x98263efd,
0xac072578, 0x71428fc0, 0x136006f9, 0xce25ac41, 0xfa04b7c4, 0x27411d7c, 0xc805c650, 0x15406ce8, 0x7762e5d1, 0xaa274f69,
0x2161776d, 0xfc24ddd5, 0x9e0654ec, 0x4343fe54, 0xb327f7a3, 0x6e625d1b, 0x0c40d422, 0xd1057e9a, 0xaba65fe7, 0x76e3f55f,
0x5a43469e, 0x8706ec26, 0xe524651f, 0x3861cfa7, 0x14c17c66, 0xc984d6de, 0xd0846e14, 0x0dc1c4ac, 0x6fe34d95, 0xb2a6e72d,
0x3e41a5b6, 0xe3040f0e, 0x81268637, 0x5c632c8f, 0x5de23c01, 0x80a796b9, 0xe2851f80, 0x3fc0b538, 0x26c00df2, 0xfb85a74a,
0x45639445, 0x98263efd, 0xfa04b7c4, 0x27411d7c, 0x99a72e73, 0x44e284cb, 0x42c2eeda, 0x9f874462, 0xfda5cd5b, 0x20e067e3,
0xc805c650, 0x15406ce8, 0x7762e5d1, 0xaa274f69, 0x39e0df29, 0xe4a57591, 0x8687fca8, 0x5bc25610, 0xb4868d3c, 0x69c32784,
0xb327f7a3, 0x6e625d1b, 0x0c40d422, 0xd1057e9a, 0x0be1aebd, 0xd6a40405, 0xcfa4bccf, 0x12e11677, 0x70c39f4e, 0xad8635f6,
0xaba65fe7, 0x76e3f55f, 0x14c17c66, 0xc984d6de, 0x7c834b6c, 0xa1c6e1d4, 0xc3e468ed, 0x1ea1c255, 0x07a17a9f, 0xdae4d027,
0xd0846e14, 0x0dc1c4ac, 0x6fe34d95, 0xb2a6e72d, 0xb8c6591e, 0x6583f3a6, 0x8ac7288a, 0x57828232, 0x35a00b0b, 0xe8e5a1b3,
0x5de23c01, 0x80a796b9, 0xe2851f80, 0x3fc0b538, 0xf1e51979, 0x2ca0b3c1, 0x4e823af8, 0x93c79040, 0x95e7fa51, 0x48a250e9,
0x26c00df2, 0xfb85a74a, 0x99a72e73, 0x44e284cb, 0x2a80d9d0, 0xf7c57368, 0xeec5cba2, 0x3380611a, 0x51a2e823, 0x8ce7429b,
0x42c2eeda, 0x9f874462, 0xfda5cd5b, 0x20e067e3, 0x63a399b7, 0xbee6330f, 0xdcc4ba36, 0x0181108e, 0x1881a844, 0xc5c402fc,
0x39e0df29, 0xe4a57591, 0x8687fca8, 0x5bc25610, 0xa7e68bc5, 0x7aa3217d, 0x52a0c93f, 0x8fe56387, 0xedc7eabe, 0x30824006,
0xb4868d3c, 0x69c32784, 0x0be1aebd, 0xd6a40405, 0x2982f8cc, 0xf4c75274, 0x96e5db4d, 0x4ba071f5, 0xa4e4aad9, 0x79a10061,
0xcfa4bccf, 0x12e11677, 0x70c39f4e, 0xad8635f6, 0x1b838958, 0xc6c623e0, 0xdfc69b2a, 0x02833192, 0x60a1b8ab, 0xbde41213,
0x7c834b6c, 0xa1c6e1d4, 0xc3e468ed, 0x1ea1c255, 0xbbc47802, 0x6681d2ba, 0x04a35b83, 0xd9e6f13b, 0xc0e649f1, 0x1da3e349,
0x07a17a9f, 0xdae4d027, 0xb8c6591e, 0x6583f3a6, 0x7f816a70, 0xa2c4c0c8, 0x4d801be4, 0x90c5b15c, 0xf2e73865, 0x2fa292dd,
0x8ac7288a, 0x57828232, 0x35a00b0b, 0xe8e5a1b3, 0x36a22a17, 0xebe780af, 0x89c50996, 0x5480a32e, 0x8585ddb4, 0x58c0770c,
0xf1e51979, 0x2ca0b3c1, 0x4e823af8, 0x93c79040, 0x3ae2fe35, 0xe7a7548d, 0xfea7ec47, 0x23e246ff, 0x41c0cfc6, 0x9c85657e,
0x95e7fa51, 0x48a250e9, 0x2a80d9d0, 0xf7c57368, 0x73c1be52, 0xae8414ea, 0xcca69dd3, 0x11e3376b, 0x08e38fa1, 0xd5a62519,
0xeec5cba2, 0x3380611a, 0x51a2e823, 0x8ce7429b, 0xb784ac20, 0x6ac10698, 0x6ce16c89, 0xb1a4c631, 0xd3864f08, 0x0ec3e5b0,
0x63a399b7, 0xbee6330f, 0xdcc4ba36, 0x0181108e, 0x17c35d7a, 0xca86f7c2, 0xa8a47efb, 0x75e1d443, 0x9aa50f6f, 0x47e0a5d7,
0x1881a844, 0xc5c402fc, 0xa7e68bc5, 0x7aa3217d, 0x25c22cee, 0xf8878656, 0xe1873e9c, 0x3cc29424, 0x5ee01d1d, 0x83a5b7a5,
0x52a0c93f, 0x8fe56387, 0xedc7eabe, 0x30824006, 0xf90696d8, 0x24433c60, 0x4661b559, 0x9b241fe1, 0x8224a72b, 0x5f610d93,
0x2982f8cc, 0xf4c75274, 0x96e5db4d, 0x4ba071f5, 0x3d4384aa, 0xe0062e12, 0x0f42f53e, 0xd2075f86, 0xb025d6bf, 0x6d607c07,
0xa4e4aad9, 0x79a10061, 0x1b838958, 0xc6c623e0, 0x7460c4cd, 0xa9256e75, 0xcb07e74c, 0x16424df4, 0x106227e5, 0xcd278d5d,
0xdfc69b2a, 0x02833192, 0x60a1b8ab, 0xbde41213, 0xaf050464, 0x7240aedc, 0x6b401616, 0xb605bcae, 0xd4273597, 0x09629f2f,
0xbbc47802, 0x6681d2ba, 0x04a35b83, 0xd9e6f13b, 0xe6264403, 0x3b63eebb, 0x59416782, 0x8404cd3a, 0x9d0475f0, 0x4041df48,
0xc0e649f1, 0x1da3e349, 0x7f816a70, 0xa2c4c0c8, 0x22635671, 0xff26fcc9, 0x2e238253, 0xf36628eb, 0x9144a1d2, 0x4c010b6a,
0x4d801be4, 0x90c5b15c, 0xf2e73865, 0x2fa292dd, 0x5501b3a0, 0x88441918, 0xea669021, 0x37233a99, 0xd867e1b5, 0x05224b0d,
0x36a22a17, 0xebe780af, 0x89c50996, 0x5480a32e, 0x6700c234, 0xba45688c, 0xa345d046, 0x7e007afe, 0x1c22f3c7, 0xc167597f,
0x8585ddb4, 0x58c0770c, 0x3ae2fe35, 0xe7a7548d, 0xc747336e, 0x1a0299d6, 0x782010ef, 0xa565ba57, 0xbc65029d, 0x6120a825,
0xfea7ec47, 0x23e246ff, 0x41c0cfc6, 0x9c85657e, 0x0302211c, 0xde478ba4, 0x31035088, 0xec46fa30, 0x8e647309, 0x5321d9b1,
0x73c1be52, 0xae8414ea, 0xcca69dd3, 0x11e3376b, 0x4a21617b, 0x9764cbc3, 0xf54642fa, 0x2803e842};
0x08e38fa1, 0xd5a62519, 0xb784ac20, 0x6ac10698,
0x6ce16c89, 0xb1a4c631, 0xd3864f08, 0x0ec3e5b0,
0x17c35d7a, 0xca86f7c2, 0xa8a47efb, 0x75e1d443,
0x9aa50f6f, 0x47e0a5d7, 0x25c22cee, 0xf8878656,
0xe1873e9c, 0x3cc29424, 0x5ee01d1d, 0x83a5b7a5,
0xf90696d8, 0x24433c60, 0x4661b559, 0x9b241fe1,
0x8224a72b, 0x5f610d93, 0x3d4384aa, 0xe0062e12,
0x0f42f53e, 0xd2075f86, 0xb025d6bf, 0x6d607c07,
0x7460c4cd, 0xa9256e75, 0xcb07e74c, 0x16424df4,
0x106227e5, 0xcd278d5d, 0xaf050464, 0x7240aedc,
0x6b401616, 0xb605bcae, 0xd4273597, 0x09629f2f,
0xe6264403, 0x3b63eebb, 0x59416782, 0x8404cd3a,
0x9d0475f0, 0x4041df48, 0x22635671, 0xff26fcc9,
0x2e238253, 0xf36628eb, 0x9144a1d2, 0x4c010b6a,
0x5501b3a0, 0x88441918, 0xea669021, 0x37233a99,
0xd867e1b5, 0x05224b0d, 0x6700c234, 0xba45688c,
0xa345d046, 0x7e007afe, 0x1c22f3c7, 0xc167597f,
0xc747336e, 0x1a0299d6, 0x782010ef, 0xa565ba57,
0xbc65029d, 0x6120a825, 0x0302211c, 0xde478ba4,
0x31035088, 0xec46fa30, 0x8e647309, 0x5321d9b1,
0x4a21617b, 0x9764cbc3, 0xf54642fa, 0x2803e842
};
// Used to fetch a naturally-aligned 32-bit word in little endian byte-order // Used to fetch a naturally-aligned 32-bit word in little endian byte-order
static inline uint32_t LE_LOAD32(const uint8_t *p) { static inline uint32_t LE_LOAD32(const uint8_t* p) {
return DecodeFixed32(reinterpret_cast<const char*>(p)); return DecodeFixed32(reinterpret_cast<const char*>(p));
} }
#if defined(HAVE_SSE42) && (defined(__LP64__) || defined(_WIN64)) #if defined(HAVE_SSE42) && (defined(__LP64__) || defined(_WIN64))
static inline uint64_t LE_LOAD64(const uint8_t *p) { static inline uint64_t LE_LOAD64(const uint8_t* p) {
return DecodeFixed64(reinterpret_cast<const char*>(p)); return DecodeFixed64(reinterpret_cast<const char*>(p));
} }
#endif #endif
static inline void Slow_CRC32(uint64_t* l, uint8_t const **p) { static inline void Slow_CRC32(uint64_t* l, uint8_t const** p) {
uint32_t c = static_cast<uint32_t>(*l ^ LE_LOAD32(*p)); uint32_t c = static_cast<uint32_t>(*l ^ LE_LOAD32(*p));
*p += 4; *p += 4;
*l = table3_[c & 0xff] ^ *l = table3_[c & 0xff] ^ table2_[(c >> 8) & 0xff] ^
table2_[(c >> 8) & 0xff] ^ table1_[(c >> 16) & 0xff] ^ table0_[c >> 24];
table1_[(c >> 16) & 0xff] ^
table0_[c >> 24];
// DO it twice. // DO it twice.
c = static_cast<uint32_t>(*l ^ LE_LOAD32(*p)); c = static_cast<uint32_t>(*l ^ LE_LOAD32(*p));
*p += 4; *p += 4;
*l = table3_[c & 0xff] ^ *l = table3_[c & 0xff] ^ table2_[(c >> 8) & 0xff] ^
table2_[(c >> 8) & 0xff] ^ table1_[(c >> 16) & 0xff] ^ table0_[c >> 24];
table1_[(c >> 16) & 0xff] ^
table0_[c >> 24];
} }
#if (!(defined(HAVE_POWER8) && defined(HAS_ALTIVEC))) && \ #if (!(defined(HAVE_POWER8) && defined(HAS_ALTIVEC))) && \
(!defined(HAVE_ARM64_CRC)) || \ (!defined(HAVE_ARM64_CRC)) || \
defined(NO_THREEWAY_CRC32C) defined(NO_THREEWAY_CRC32C)
static inline void Fast_CRC32(uint64_t* l, uint8_t const **p) { static inline void Fast_CRC32(uint64_t* l, uint8_t const** p) {
#ifndef HAVE_SSE42 #ifndef HAVE_SSE42
Slow_CRC32(l, p); Slow_CRC32(l, p);
#elif defined(__LP64__) || defined(_WIN64) #elif defined(__LP64__) || defined(_WIN64)
@ -373,21 +281,20 @@ static inline void Fast_CRC32(uint64_t* l, uint8_t const **p) {
} }
#endif #endif
template<void (*CRC32)(uint64_t*, uint8_t const**)> template <void (*CRC32)(uint64_t*, uint8_t const**)>
uint32_t ExtendImpl(uint32_t crc, const char* buf, size_t size) { uint32_t ExtendImpl(uint32_t crc, const char* buf, size_t size) {
const uint8_t* p = reinterpret_cast<const uint8_t*>(buf);
const uint8_t *p = reinterpret_cast<const uint8_t *>(buf); const uint8_t* e = p + size;
const uint8_t *e = p + size;
uint64_t l = crc ^ 0xffffffffu; uint64_t l = crc ^ 0xffffffffu;
// Align n to (1 << m) byte boundary // Align n to (1 << m) byte boundary
#define ALIGN(n, m) ((n + ((1 << m) - 1)) & ~((1 << m) - 1)) #define ALIGN(n, m) ((n + ((1 << m) - 1)) & ~((1 << m) - 1))
#define STEP1 do { \
int c = (l & 0xff) ^ *p++; \
l = table0_[c] ^ (l >> 8); \
} while (0)
#define STEP1 \
do { \
int c = (l & 0xff) ^ *p++; \
l = table0_[c] ^ (l >> 8); \
} while (0)
// Point x at first 16-byte aligned byte in string. This might be // Point x at first 16-byte aligned byte in string. This might be
// just past the end of the string. // just past the end of the string.
@ -400,12 +307,12 @@ uint32_t ExtendImpl(uint32_t crc, const char* buf, size_t size) {
} }
} }
// Process bytes 16 at a time // Process bytes 16 at a time
while ((e-p) >= 16) { while ((e - p) >= 16) {
CRC32(&l, &p); CRC32(&l, &p);
CRC32(&l, &p); CRC32(&l, &p);
} }
// Process bytes 8 at a time // Process bytes 8 at a time
while ((e-p) >= 8) { while ((e - p) >= 8) {
CRC32(&l, &p); CRC32(&l, &p);
} }
// Process the last few bytes // Process the last few bytes
@ -440,8 +347,8 @@ static bool isSSE42() {
static bool isPCLMULQDQ() { static bool isPCLMULQDQ() {
#ifndef HAVE_SSE42 #ifndef HAVE_SSE42
// in build_detect_platform we set this macro when both SSE42 and PCLMULQDQ are // in build_detect_platform we set this macro when both SSE42 and PCLMULQDQ
// supported by compiler // are supported by compiler
return false; return false;
#elif defined(__GNUC__) && defined(__x86_64__) && !defined(IOS_CROSS_COMPILE) #elif defined(__GNUC__) && defined(__x86_64__) && !defined(IOS_CROSS_COMPILE)
uint32_t c_; uint32_t c_;
@ -462,8 +369,8 @@ static bool isPCLMULQDQ() {
using Function = uint32_t (*)(uint32_t, const char*, size_t); using Function = uint32_t (*)(uint32_t, const char*, size_t);
#if defined(HAVE_POWER8) && defined(HAS_ALTIVEC) #if defined(HAVE_POWER8) && defined(HAS_ALTIVEC)
uint32_t ExtendPPCImpl(uint32_t crc, const char *buf, size_t size) { uint32_t ExtendPPCImpl(uint32_t crc, const char* buf, size_t size) {
return crc32c_ppc(crc, (const unsigned char *)buf, size); return crc32c_ppc(crc, (const unsigned char*)buf, size);
} }
#if __linux__ #if __linux__
@ -500,8 +407,8 @@ static bool isAltiVec() {
#endif #endif
#if defined(HAVE_ARM64_CRC) #if defined(HAVE_ARM64_CRC)
uint32_t ExtendARMImpl(uint32_t crc, const char *buf, size_t size) { uint32_t ExtendARMImpl(uint32_t crc, const char* buf, size_t size) {
return crc32c_arm64(crc, (const unsigned char *)buf, size); return crc32c_arm64(crc, (const unsigned char*)buf, size);
} }
#endif #endif
@ -534,14 +441,12 @@ std::string IsFastCrc32Supported() {
#endif #endif
if (has_fast_crc) { if (has_fast_crc) {
fast_zero_msg.append("Supported on " + arch); fast_zero_msg.append("Supported on " + arch);
} } else {
else {
fast_zero_msg.append("Not supported on " + arch); fast_zero_msg.append("Not supported on " + arch);
} }
return fast_zero_msg; return fast_zero_msg;
} }
/* /*
* Copyright 2016 Ferry Toth, Exalon Delft BV, The Netherlands * Copyright 2016 Ferry Toth, Exalon Delft BV, The Netherlands
* This software is provided 'as-is', without any express or implied * This software is provided 'as-is', without any express or implied
@ -568,9 +473,10 @@ std::string IsFastCrc32Supported() {
* "Fast CRC Computation for iSCSI Polynomial Using CRC32 Instruction" * "Fast CRC Computation for iSCSI Polynomial Using CRC32 Instruction"
* https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/crc-iscsi-polynomial-crc32-instruction-paper.pdf * https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/crc-iscsi-polynomial-crc32-instruction-paper.pdf
* *
* This version is from the folly library, created by Dave Watson <davejwatson@fb.com> * This version is from the folly library, created by Dave Watson
* <davejwatson@fb.com>
* *
*/ */
#if defined HAVE_SSE42 && defined HAVE_PCLMUL #if defined HAVE_SSE42 && defined HAVE_PCLMUL
#define CRCtriplet(crc, buf, offset) \ #define CRCtriplet(crc, buf, offset) \
@ -582,10 +488,9 @@ std::string IsFastCrc32Supported() {
crc##0 = _mm_crc32_u64(crc##0, *(buf##0 + offset)); \ crc##0 = _mm_crc32_u64(crc##0, *(buf##0 + offset)); \
crc##1 = _mm_crc32_u64(crc##1, *(buf##1 + offset)); crc##1 = _mm_crc32_u64(crc##1, *(buf##1 + offset));
#define CRCsinglet(crc, buf, offset) \ #define CRCsinglet(crc, buf, offset) \
crc = _mm_crc32_u64(crc, *(uint64_t*)(buf + offset)); crc = _mm_crc32_u64(crc, *(uint64_t*)(buf + offset));
// Numbers taken directly from intel whitepaper. // Numbers taken directly from intel whitepaper.
// clang-format off // clang-format off
const uint64_t clmul_constants[] = { const uint64_t clmul_constants[] = {

@ -10,6 +10,7 @@
#pragma once #pragma once
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <string> #include <string>
#include "rocksdb/rocksdb_namespace.h" #include "rocksdb/rocksdb_namespace.h"
@ -31,9 +32,7 @@ extern uint32_t Extend(uint32_t init_crc, const char* data, size_t n);
extern uint32_t Crc32cCombine(uint32_t crc1, uint32_t crc2, size_t crc2len); extern uint32_t Crc32cCombine(uint32_t crc1, uint32_t crc2, size_t crc2len);
// Return the crc32c of data[0,n-1] // Return the crc32c of data[0,n-1]
inline uint32_t Value(const char* data, size_t n) { inline uint32_t Value(const char* data, size_t n) { return Extend(0, data, n); }
return Extend(0, data, n);
}
static const uint32_t kMaskDelta = 0xa282ead8ul; static const uint32_t kMaskDelta = 0xa282ead8ul;

@ -15,8 +15,7 @@
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
namespace crc32c { namespace crc32c {
class CRC { }; class CRC {};
// Tests for 3-way crc32c algorithm. We need these tests because it uses // Tests for 3-way crc32c algorithm. We need these tests because it uses
// different lookup tables than the original Fast_CRC32 // different lookup tables than the original Fast_CRC32
@ -31,42 +30,41 @@ struct ExpectedResult {
ExpectedResult expectedResults[] = { ExpectedResult expectedResults[] = {
// Zero-byte input // Zero-byte input
{ 0, 0, ~0U }, {0, 0, ~0U},
// Small aligned inputs to test special cases in SIMD implementations // Small aligned inputs to test special cases in SIMD implementations
{ 8, 1, 1543413366 }, {8, 1, 1543413366},
{ 8, 2, 523493126 }, {8, 2, 523493126},
{ 8, 3, 1560427360 }, {8, 3, 1560427360},
{ 8, 4, 3422504776 }, {8, 4, 3422504776},
{ 8, 5, 447841138 }, {8, 5, 447841138},
{ 8, 6, 3910050499 }, {8, 6, 3910050499},
{ 8, 7, 3346241981 }, {8, 7, 3346241981},
// Small unaligned inputs // Small unaligned inputs
{ 9, 1, 3855826643 }, {9, 1, 3855826643},
{ 10, 2, 560880875 }, {10, 2, 560880875},
{ 11, 3, 1479707779 }, {11, 3, 1479707779},
{ 12, 4, 2237687071 }, {12, 4, 2237687071},
{ 13, 5, 4063855784 }, {13, 5, 4063855784},
{ 14, 6, 2553454047 }, {14, 6, 2553454047},
{ 15, 7, 1349220140 }, {15, 7, 1349220140},
// Larger inputs to test leftover chunks at the end of aligned blocks // Larger inputs to test leftover chunks at the end of aligned blocks
{ 8, 8, 627613930 }, {8, 8, 627613930},
{ 8, 9, 2105929409 }, {8, 9, 2105929409},
{ 8, 10, 2447068514 }, {8, 10, 2447068514},
{ 8, 11, 863807079 }, {8, 11, 863807079},
{ 8, 12, 292050879 }, {8, 12, 292050879},
{ 8, 13, 1411837737 }, {8, 13, 1411837737},
{ 8, 14, 2614515001 }, {8, 14, 2614515001},
{ 8, 15, 3579076296 }, {8, 15, 3579076296},
{ 8, 16, 2897079161 }, {8, 16, 2897079161},
{ 8, 17, 675168386 }, {8, 17, 675168386},
// // Much larger inputs // // Much larger inputs
{ 0, BUFFER_SIZE, 2096790750 }, {0, BUFFER_SIZE, 2096790750},
{ 1, BUFFER_SIZE / 2, 3854797577 }, {1, BUFFER_SIZE / 2, 3854797577},
}; };
TEST(CRC, StandardResults) { TEST(CRC, StandardResults) {
// Original Fast_CRC32 tests. // Original Fast_CRC32 tests.
// From rfc3720 section B.4. // From rfc3720 section B.4.
char buf[32]; char buf[32];
@ -88,18 +86,10 @@ TEST(CRC, StandardResults) {
ASSERT_EQ(0x113fdb5cU, Value(buf, sizeof(buf))); ASSERT_EQ(0x113fdb5cU, Value(buf, sizeof(buf)));
unsigned char data[48] = { unsigned char data[48] = {
0x01, 0xc0, 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x14,
0x00, 0x00, 0x00, 0x18,
0x28, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}; };
ASSERT_EQ(0xd9963a56, Value(reinterpret_cast<char*>(data), sizeof(data))); ASSERT_EQ(0xd9963a56, Value(reinterpret_cast<char*>(data), sizeof(data)));
@ -114,21 +104,17 @@ TEST(CRC, StandardResults) {
for (auto expected : expectedResults) { for (auto expected : expectedResults) {
size_t partialLength = expected.length / 2; size_t partialLength = expected.length / 2;
uint32_t partialChecksum = Value(buffer + expected.offset, partialLength); uint32_t partialChecksum = Value(buffer + expected.offset, partialLength);
uint32_t result = Extend(partialChecksum, uint32_t result =
buffer + expected.offset + partialLength, Extend(partialChecksum, buffer + expected.offset + partialLength,
expected.length - partialLength); expected.length - partialLength);
EXPECT_EQ(~expected.crc32c, result); EXPECT_EQ(~expected.crc32c, result);
} }
} }
TEST(CRC, Values) { TEST(CRC, Values) { ASSERT_NE(Value("a", 1), Value("foo", 3)); }
ASSERT_NE(Value("a", 1), Value("foo", 3));
}
TEST(CRC, Extend) { TEST(CRC, Extend) {
ASSERT_EQ(Value("hello world", 11), ASSERT_EQ(Value("hello world", 11), Extend(Value("hello ", 6), "world", 5));
Extend(Value("hello ", 6), "world", 5));
} }
TEST(CRC, Mask) { TEST(CRC, Mask) {
@ -189,15 +175,14 @@ TEST(CRC, Crc32cCombineBigSizeTest) {
// copied from folly // copied from folly
const uint64_t FNV_64_HASH_START = 14695981039346656037ULL; const uint64_t FNV_64_HASH_START = 14695981039346656037ULL;
inline uint64_t fnv64_buf(const void* buf, inline uint64_t fnv64_buf(const void* buf, size_t n,
size_t n,
uint64_t hash = FNV_64_HASH_START) { uint64_t hash = FNV_64_HASH_START) {
// forcing signed char, since other platforms can use unsigned // forcing signed char, since other platforms can use unsigned
const signed char* char_buf = reinterpret_cast<const signed char*>(buf); const signed char* char_buf = reinterpret_cast<const signed char*>(buf);
for (size_t i = 0; i < n; ++i) { for (size_t i = 0; i < n; ++i) {
hash += (hash << 1) + (hash << 4) + (hash << 5) + (hash << 7) + hash += (hash << 1) + (hash << 4) + (hash << 5) + (hash << 7) +
(hash << 8) + (hash << 40); (hash << 8) + (hash << 40);
hash ^= char_buf[i]; hash ^= char_buf[i];
} }
return hash; return hash;

@ -37,7 +37,8 @@ namespace ROCKSDB_NAMESPACE {
// but sometimes, this might lead to nested blocks of "if (s.ok()) {...}". // but sometimes, this might lead to nested blocks of "if (s.ok()) {...}".
// //
// With the help of Defer, you can centralize the cleanup logic inside the // With the help of Defer, you can centralize the cleanup logic inside the
// lambda passed to Defer, and you can return immediately on failure when necessary. // lambda passed to Defer, and you can return immediately on failure when
// necessary.
class Defer final { class Defer final {
public: public:
explicit Defer(std::function<void()>&& fn) : fn_(std::move(fn)) {} explicit Defer(std::function<void()>&& fn) : fn_(std::move(fn)) {}

@ -3,10 +3,11 @@
// COPYING file in the root directory) and Apache 2.0 License // COPYING file in the root directory) and Apache 2.0 License
// (found in the LICENSE.Apache file in the root directory). // (found in the LICENSE.Apache file in the root directory).
#include "util/defer.h"
#include "port/port.h" #include "port/port.h"
#include "port/stack_trace.h" #include "port/stack_trace.h"
#include "test_util/testharness.h" #include "test_util/testharness.h"
#include "util/defer.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {

@ -54,7 +54,8 @@ class DuplicateDetector {
db_->immutable_db_options().info_log, db_->immutable_db_options().info_log,
"Recovering an entry from the dropped column family %" PRIu32 "Recovering an entry from the dropped column family %" PRIu32
". WAL must must have been emptied before dropping the column " ". WAL must must have been emptied before dropping the column "
"family", cf); "family",
cf);
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
throw std::runtime_error( throw std::runtime_error(
"Recovering an entry from a dropped column family. " "Recovering an entry from a dropped column family. "

@ -23,7 +23,7 @@ uint32_t roundUpToPow2(uint32_t x) {
} }
return rv; return rv;
} }
} } // namespace
DynamicBloom::DynamicBloom(Allocator* allocator, uint32_t total_bits, DynamicBloom::DynamicBloom(Allocator* allocator, uint32_t total_bits,
uint32_t num_probes, size_t huge_page_tlb_size, uint32_t num_probes, size_t huge_page_tlb_size,

@ -6,15 +6,15 @@
#pragma once #pragma once
#include <array> #include <array>
#include <atomic>
#include <memory>
#include <string> #include <string>
#include "port/port.h" #include "port/port.h"
#include "rocksdb/slice.h" #include "rocksdb/slice.h"
#include "table/multiget_context.h" #include "table/multiget_context.h"
#include "util/hash.h" #include "util/hash.h"
#include <atomic>
#include <memory>
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
class Slice; class Slice;

@ -314,7 +314,7 @@ TEST_F(DynamicBloomTest, concurrent_with_perf) {
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE
int main(int argc, char** argv) { int main(int argc, char **argv) {
ROCKSDB_NAMESPACE::port::InstallStackTraceHandler(); ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
::testing::InitGoogleTest(&argc, argv); ::testing::InitGoogleTest(&argc, argv);
ParseCommandLineFlags(&argc, &argv, true); ParseCommandLineFlags(&argc, &argv, true);

@ -3,15 +3,16 @@
// COPYING file in the root directory) and Apache 2.0 License // COPYING file in the root directory) and Apache 2.0 License
// (found in the LICENSE.Apache file in the root directory). // (found in the LICENSE.Apache file in the root directory).
// //
#include "rocksdb/status.h"
#include "rocksdb/env.h"
#include <fcntl.h> #include <fcntl.h>
#include "rocksdb/env.h"
#include "rocksdb/status.h"
#ifdef __FreeBSD__ #ifdef __FreeBSD__
#include <sys/types.h> #include <sys/types.h>
#include <sys/wait.h> #include <sys/wait.h>
#endif #endif
#include <vector> #include <vector>
#include "test_util/testharness.h" #include "test_util/testharness.h"
#include "util/coding.h" #include "util/coding.h"
#include "util/string_util.h" #include "util/string_util.h"
@ -32,23 +33,19 @@ class LockTest : public testing::Test {
~LockTest() override {} ~LockTest() override {}
Status LockFile(FileLock** db_lock) { Status LockFile(FileLock** db_lock) { return env_->LockFile(file_, db_lock); }
return env_->LockFile(file_, db_lock);
}
Status UnlockFile(FileLock* db_lock) { Status UnlockFile(FileLock* db_lock) { return env_->UnlockFile(db_lock); }
return env_->UnlockFile(db_lock);
}
bool AssertFileIsLocked(){ bool AssertFileIsLocked() {
return CheckFileLock( /* lock_expected = */ true); return CheckFileLock(/* lock_expected = */ true);
} }
bool AssertFileIsNotLocked(){ bool AssertFileIsNotLocked() {
return CheckFileLock( /* lock_expected = */ false); return CheckFileLock(/* lock_expected = */ false);
} }
bool CheckFileLock(bool lock_expected){ bool CheckFileLock(bool lock_expected) {
// We need to fork to check the fcntl lock as we need // We need to fork to check the fcntl lock as we need
// to open and close the file from a different process // to open and close the file from a different process
// to avoid either releasing the lock on close, or not // to avoid either releasing the lock on close, or not
@ -63,13 +60,13 @@ class LockTest : public testing::Test {
#else #else
pid_t pid = fork(); pid_t pid = fork();
if ( 0 == pid ) { if (0 == pid) {
// child process // child process
int exit_val = EXIT_FAILURE; int exit_val = EXIT_FAILURE;
int fd = open(file_.c_str(), O_RDWR | O_CREAT, 0644); int fd = open(file_.c_str(), O_RDWR | O_CREAT, 0644);
if (fd < 0) { if (fd < 0) {
// could not open file, could not check if it was locked // could not open file, could not check if it was locked
fprintf( stderr, "Open on on file %s failed.\n",file_.c_str()); fprintf(stderr, "Open on on file %s failed.\n", file_.c_str());
exit(exit_val); exit(exit_val);
} }
@ -78,23 +75,24 @@ class LockTest : public testing::Test {
f.l_type = (F_WRLCK); f.l_type = (F_WRLCK);
f.l_whence = SEEK_SET; f.l_whence = SEEK_SET;
f.l_start = 0; f.l_start = 0;
f.l_len = 0; // Lock/unlock entire file f.l_len = 0; // Lock/unlock entire file
int value = fcntl(fd, F_SETLK, &f); int value = fcntl(fd, F_SETLK, &f);
if( value == -1 ){ if (value == -1) {
if( lock_expected ){ if (lock_expected) {
exit_val = EXIT_SUCCESS; exit_val = EXIT_SUCCESS;
} }
} else { } else {
if( ! lock_expected ){ if (!lock_expected) {
exit_val = EXIT_SUCCESS; exit_val = EXIT_SUCCESS;
} }
} }
close(fd); // lock is released for child process close(fd); // lock is released for child process
exit(exit_val); exit(exit_val);
} else if (pid > 0) { } else if (pid > 0) {
// parent process // parent process
int status; int status;
while (-1 == waitpid(pid, &status, 0)); while (-1 == waitpid(pid, &status, 0))
;
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
// child process exited with non success status // child process exited with non success status
return false; return false;
@ -102,15 +100,13 @@ class LockTest : public testing::Test {
return true; return true;
} }
} else { } else {
fprintf( stderr, "Fork failed\n" ); fprintf(stderr, "Fork failed\n");
return false; return false;
} }
return false; return false;
#endif #endif
} }
}; };
LockTest* LockTest::current_; LockTest* LockTest::current_;
@ -122,7 +118,7 @@ TEST_F(LockTest, LockBySameThread) {
ASSERT_OK(LockFile(&lock1)); ASSERT_OK(LockFile(&lock1));
// check the file is locked // check the file is locked
ASSERT_TRUE( AssertFileIsLocked() ); ASSERT_TRUE(AssertFileIsLocked());
// re-acquire the lock on the same file. This should fail. // re-acquire the lock on the same file. This should fail.
Status s = LockFile(&lock2); Status s = LockFile(&lock2);
@ -134,14 +130,13 @@ TEST_F(LockTest, LockBySameThread) {
#endif #endif
// check the file is locked // check the file is locked
ASSERT_TRUE( AssertFileIsLocked() ); ASSERT_TRUE(AssertFileIsLocked());
// release the lock // release the lock
ASSERT_OK(UnlockFile(lock1)); ASSERT_OK(UnlockFile(lock1));
// check the file is not locked // check the file is not locked
ASSERT_TRUE( AssertFileIsNotLocked() ); ASSERT_TRUE(AssertFileIsNotLocked());
} }
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

@ -195,7 +195,7 @@ struct KeyMaker {
len += FastRange32( len += FastRange32(
(val_num >> FLAGS_vary_key_size_log2_interval) * 1234567891, 5); (val_num >> FLAGS_vary_key_size_log2_interval) * 1234567891, 5);
} }
char * data = buf_.get() + start; char *data = buf_.get() + start;
// Populate key data such that all data makes it into a key of at // Populate key data such that all data makes it into a key of at
// least 8 bytes. We also don't want all the within-filter key // least 8 bytes. We also don't want all the within-filter key
// variance confined to a contiguous 32 bits, because then a 32 bit // variance confined to a contiguous 32 bits, because then a 32 bit
@ -378,9 +378,9 @@ void FilterBench::Go() {
FLAGS_average_keys_per_filter); FLAGS_average_keys_per_filter);
const uint32_t variance_offset = variance_range / 2; const uint32_t variance_offset = variance_range / 2;
const std::vector<TestMode> &testModes = const std::vector<TestMode> &testModes = FLAGS_best_case ? bestCaseTestModes
FLAGS_best_case ? bestCaseTestModes : FLAGS_quick ? quickTestModes
: FLAGS_quick ? quickTestModes : allTestModes; : allTestModes;
m_queries_ = FLAGS_m_queries; m_queries_ = FLAGS_m_queries;
double working_mem_size_mb = FLAGS_working_mem_size_mb; double working_mem_size_mb = FLAGS_working_mem_size_mb;

@ -547,7 +547,7 @@ TEST(FastRangeGenericTest, Values) {
uint16_t{6234}); uint16_t{6234});
// Not recommended for typical use because for example this could fail on // Not recommended for typical use because for example this could fail on
// some platforms and pass on others: // some platforms and pass on others:
//EXPECT_EQ(FastRangeGeneric(static_cast<unsigned long>(0x80000000), // EXPECT_EQ(FastRangeGeneric(static_cast<unsigned long>(0x80000000),
// uint16_t{12468}), // uint16_t{12468}),
// uint16_t{6234}); // uint16_t{6234});
} }
@ -843,7 +843,7 @@ TEST(MathTest, CodingGeneric) {
EXPECT_EQ(std::string("_12"), std::string(out)); EXPECT_EQ(std::string("_12"), std::string(out));
} }
int main(int argc, char** argv) { int main(int argc, char **argv) {
fprintf(stderr, "NPHash64 id: %x\n", fprintf(stderr, "NPHash64 id: %x\n",
static_cast<int>(ROCKSDB_NAMESPACE::GetSliceNPHash64("RocksDB"))); static_cast<int>(ROCKSDB_NAMESPACE::GetSliceNPHash64("RocksDB")));
ROCKSDB_NAMESPACE::port::InstallStackTraceHandler(); ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();

@ -8,6 +8,7 @@
#include <algorithm> #include <algorithm>
#include <cstdint> #include <cstdint>
#include <functional> #include <functional>
#include "port/port.h" #include "port/port.h"
#include "util/autovector.h" #include "util/autovector.h"
@ -37,11 +38,11 @@ namespace ROCKSDB_NAMESPACE {
// std::priority_queue: the comparison operator is expected to provide the // std::priority_queue: the comparison operator is expected to provide the
// less-than relation, but top() will return the maximum. // less-than relation, but top() will return the maximum.
template<typename T, typename Compare = std::less<T>> template <typename T, typename Compare = std::less<T>>
class BinaryHeap { class BinaryHeap {
public: public:
BinaryHeap() { } BinaryHeap() {}
explicit BinaryHeap(Compare cmp) : cmp_(std::move(cmp)) { } explicit BinaryHeap(Compare cmp) : cmp_(std::move(cmp)) {}
void push(const T& value) { void push(const T& value) {
data_.push_back(value); data_.push_back(value);
@ -86,7 +87,7 @@ class BinaryHeap {
} }
} }
void swap(BinaryHeap &other) { void swap(BinaryHeap& other) {
std::swap(cmp_, other.cmp_); std::swap(cmp_, other.cmp_);
data_.swap(other.data_); data_.swap(other.data_);
std::swap(root_cmp_cache_, other.root_cmp_cache_); std::swap(root_cmp_cache_, other.root_cmp_cache_);

@ -31,8 +31,7 @@ namespace ROCKSDB_NAMESPACE {
using HeapTestValue = uint64_t; using HeapTestValue = uint64_t;
using Params = std::tuple<size_t, HeapTestValue, int64_t>; using Params = std::tuple<size_t, HeapTestValue, int64_t>;
class HeapTest : public ::testing::TestWithParam<Params> { class HeapTest : public ::testing::TestWithParam<Params> {};
};
TEST_P(HeapTest, Test) { TEST_P(HeapTest, Test) {
// This test performs the same pseudorandom sequence of operations on a // This test performs the same pseudorandom sequence of operations on a
@ -54,15 +53,14 @@ TEST_P(HeapTest, Test) {
std::mt19937 rng(static_cast<unsigned int>(RNG_SEED)); std::mt19937 rng(static_cast<unsigned int>(RNG_SEED));
std::uniform_int_distribution<HeapTestValue> value_dist(0, MAX_VALUE); std::uniform_int_distribution<HeapTestValue> value_dist(0, MAX_VALUE);
int ndrains = 0; int ndrains = 0;
bool draining = false; // hit max size, draining until we empty the heap bool draining = false; // hit max size, draining until we empty the heap
size_t size = 0; size_t size = 0;
for (int64_t i = 0; i < FLAGS_iters; ++i) { for (int64_t i = 0; i < FLAGS_iters; ++i) {
if (size == 0) { if (size == 0) {
draining = false; draining = false;
} }
if (!draining && if (!draining && (size == 0 || std::bernoulli_distribution(0.4)(rng))) {
(size == 0 || std::bernoulli_distribution(0.4)(rng))) {
// insert // insert
HeapTestValue val = value_dist(rng); HeapTestValue val = value_dist(rng);
heap.push(val); heap.push(val);
@ -104,30 +102,22 @@ TEST_P(HeapTest, Test) {
} }
// Basic test, MAX_VALUE = 3*MAX_HEAP_SIZE (occasional duplicates) // Basic test, MAX_VALUE = 3*MAX_HEAP_SIZE (occasional duplicates)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(Basic, HeapTest,
Basic, HeapTest, ::testing::Values(Params(1000, 3000,
::testing::Values(Params(1000, 3000, 0x1b575cf05b708945)) 0x1b575cf05b708945)));
);
// Mid-size heap with small values (many duplicates) // Mid-size heap with small values (many duplicates)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(SmallValues, HeapTest,
SmallValues, HeapTest, ::testing::Values(Params(100, 10, 0x5ae213f7bd5dccd0)));
::testing::Values(Params(100, 10, 0x5ae213f7bd5dccd0))
);
// Small heap, large value range (no duplicates) // Small heap, large value range (no duplicates)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(SmallHeap, HeapTest,
SmallHeap, HeapTest, ::testing::Values(Params(10, ULLONG_MAX,
::testing::Values(Params(10, ULLONG_MAX, 0x3e1fa8f4d01707cf)) 0x3e1fa8f4d01707cf)));
);
// Two-element heap // Two-element heap
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(TwoElementHeap, HeapTest,
TwoElementHeap, HeapTest, ::testing::Values(Params(2, 5, 0x4b5e13ea988c6abc)));
::testing::Values(Params(2, 5, 0x4b5e13ea988c6abc))
);
// One-element heap // One-element heap
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(OneElementHeap, HeapTest,
OneElementHeap, HeapTest, ::testing::Values(Params(1, 3, 0x176a1019ab0b612e)));
::testing::Values(Params(1, 3, 0x176a1019ab0b612e))
);
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

@ -29,5 +29,5 @@ struct LessOfComparator {
}; };
using KVMap = std::map<std::string, std::string, LessOfComparator>; using KVMap = std::map<std::string, std::string, LessOfComparator>;
} } // namespace stl_wrappers
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

@ -11,23 +11,24 @@
*/ */
#pragma once #pragma once
#include <stdint.h> #include <stdint.h>
#include "rocksdb/slice.h" #include "rocksdb/slice.h"
#if defined(__x86_64__) #if defined(__x86_64__)
#define MURMUR_HASH MurmurHash64A #define MURMUR_HASH MurmurHash64A
uint64_t MurmurHash64A ( const void * key, int len, unsigned int seed ); uint64_t MurmurHash64A(const void* key, int len, unsigned int seed);
#define MurmurHash MurmurHash64A #define MurmurHash MurmurHash64A
using murmur_t = uint64_t; using murmur_t = uint64_t;
#elif defined(__i386__) #elif defined(__i386__)
#define MURMUR_HASH MurmurHash2 #define MURMUR_HASH MurmurHash2
unsigned int MurmurHash2 ( const void * key, int len, unsigned int seed ); unsigned int MurmurHash2(const void* key, int len, unsigned int seed);
#define MurmurHash MurmurHash2 #define MurmurHash MurmurHash2
using murmur_t = unsigned int; using murmur_t = unsigned int;
#else #else
#define MURMUR_HASH MurmurHashNeutral2 #define MURMUR_HASH MurmurHashNeutral2
unsigned int MurmurHashNeutral2 ( const void * key, int len, unsigned int seed ); unsigned int MurmurHashNeutral2(const void* key, int len, unsigned int seed);
#define MurmurHash MurmurHashNeutral2 #define MurmurHash MurmurHashNeutral2
using murmur_t = unsigned int; using murmur_t = unsigned int;
#endif #endif

@ -9,9 +9,11 @@
#pragma once #pragma once
#include <assert.h> #include <assert.h>
#include <atomic> #include <atomic>
#include <mutex> #include <mutex>
#include <thread> #include <thread>
#include "port/port.h" #include "port/port.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
@ -28,9 +30,7 @@ namespace ROCKSDB_NAMESPACE {
class MutexLock { class MutexLock {
public: public:
explicit MutexLock(port::Mutex *mu) : mu_(mu) { explicit MutexLock(port::Mutex *mu) : mu_(mu) { this->mu_->Lock(); }
this->mu_->Lock();
}
// No copying allowed // No copying allowed
MutexLock(const MutexLock &) = delete; MutexLock(const MutexLock &) = delete;
void operator=(const MutexLock &) = delete; void operator=(const MutexLock &) = delete;
@ -48,9 +48,7 @@ class MutexLock {
// //
class ReadLock { class ReadLock {
public: public:
explicit ReadLock(port::RWMutex *mu) : mu_(mu) { explicit ReadLock(port::RWMutex *mu) : mu_(mu) { this->mu_->ReadLock(); }
this->mu_->ReadLock();
}
// No copying allowed // No copying allowed
ReadLock(const ReadLock &) = delete; ReadLock(const ReadLock &) = delete;
void operator=(const ReadLock &) = delete; void operator=(const ReadLock &) = delete;
@ -84,9 +82,7 @@ class ReadUnlock {
// //
class WriteLock { class WriteLock {
public: public:
explicit WriteLock(port::RWMutex *mu) : mu_(mu) { explicit WriteLock(port::RWMutex *mu) : mu_(mu) { this->mu_->WriteLock(); }
this->mu_->WriteLock();
}
// No copying allowed // No copying allowed
WriteLock(const WriteLock &) = delete; WriteLock(const WriteLock &) = delete;
void operator=(const WriteLock &) = delete; void operator=(const WriteLock &) = delete;
@ -152,13 +148,11 @@ class Striped {
public: public:
Striped(size_t stripes, std::function<uint64_t(const P &)> hash) Striped(size_t stripes, std::function<uint64_t(const P &)> hash)
: stripes_(stripes), hash_(hash) { : stripes_(stripes), hash_(hash) {
locks_ = reinterpret_cast<LockData<T> *>( locks_ = reinterpret_cast<LockData<T> *>(
port::cacheline_aligned_alloc(sizeof(LockData<T>) * stripes)); port::cacheline_aligned_alloc(sizeof(LockData<T>) * stripes));
for (size_t i = 0; i < stripes; i++) { for (size_t i = 0; i < stripes; i++) {
new (&locks_[i]) LockData<T>(); new (&locks_[i]) LockData<T>();
} }
} }
virtual ~Striped() { virtual ~Striped() {

@ -8,6 +8,7 @@
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include <thread> #include <thread>
#include <utility> #include <utility>

@ -85,9 +85,7 @@ class Random {
// Skewed: pick "base" uniformly from range [0,max_log] and then // Skewed: pick "base" uniformly from range [0,max_log] and then
// return "base" random bits. The effect is to pick a number in the // return "base" random bits. The effect is to pick a number in the
// range [0,2^max_log-1] with exponential bias towards smaller numbers. // range [0,2^max_log-1] with exponential bias towards smaller numbers.
uint32_t Skewed(int max_log) { uint32_t Skewed(int max_log) { return Uniform(1 << Uniform(max_log + 1)); }
return Uniform(1 << Uniform(max_log + 1));
}
// Returns a random string of length "len" // Returns a random string of length "len"
std::string RandomString(int len); std::string RandomString(int len);
@ -153,7 +151,7 @@ class Random64 {
std::mt19937_64 generator_; std::mt19937_64 generator_;
public: public:
explicit Random64(uint64_t s) : generator_(s) { } explicit Random64(uint64_t s) : generator_(s) {}
// Generates the next random number // Generates the next random number
uint64_t Next() { return generator_(); } uint64_t Next() { return generator_(); }

@ -7,11 +7,12 @@
// Use of this source code is governed by a BSD-style license that can be // 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. // found in the LICENSE file. See the AUTHORS file for names of contributors.
#include "util/random.h"
#include <cstring> #include <cstring>
#include <vector> #include <vector>
#include "test_util/testharness.h" #include "test_util/testharness.h"
#include "util/random.h"
using ROCKSDB_NAMESPACE::Random; using ROCKSDB_NAMESPACE::Random;

@ -836,9 +836,10 @@ TYPED_TEST(RibbonTypeParamTest, CompactnessAndBacktrackAndFpRate) {
double single_failure_rate = 1.0 * total_single_failures / total_singles; double single_failure_rate = 1.0 * total_single_failures / total_singles;
fprintf(stderr, "Add'l single, failure rate: %g\n", single_failure_rate); fprintf(stderr, "Add'l single, failure rate: %g\n", single_failure_rate);
// A rough bound (one sided) based on nothing in particular // A rough bound (one sided) based on nothing in particular
double expected_single_failures = double expected_single_failures = 1.0 * total_singles /
1.0 * total_singles / (sizeof(CoeffRow) == 16 ? 128
(sizeof(CoeffRow) == 16 ? 128 : TypeParam::kUseSmash ? 64 : 32); : TypeParam::kUseSmash ? 64
: 32);
EXPECT_LE(total_single_failures, EXPECT_LE(total_single_failures,
InfrequentPoissonUpperBound(expected_single_failures)); InfrequentPoissonUpperBound(expected_single_failures));
} }

@ -128,7 +128,7 @@ class CappedPrefixTransform : public SliceTransform {
class NoopTransform : public SliceTransform { class NoopTransform : public SliceTransform {
public: public:
explicit NoopTransform() { } explicit NoopTransform() {}
static const char* kClassName() { return "rocksdb.Noop"; } static const char* kClassName() { return "rocksdb.Noop"; }
const char* Name() const override { return kClassName(); } const char* Name() const override { return kClassName(); }

@ -32,8 +32,7 @@ void Multiplier(void* arg1, void* arg2) {
class PinnableSliceTest : public testing::Test { class PinnableSliceTest : public testing::Test {
public: public:
void AssertSameData(const std::string& expected, void AssertSameData(const std::string& expected, const PinnableSlice& slice) {
const PinnableSlice& slice) {
std::string got; std::string got;
got.assign(slice.data(), slice.size()); got.assign(slice.data(), slice.size());
ASSERT_EQ(expected, got); ASSERT_EQ(expected, got);

@ -8,11 +8,13 @@
// found in the LICENSE file. See the AUTHORS file for names of contributors. // found in the LICENSE file. See the AUTHORS file for names of contributors.
#include "rocksdb/status.h" #include "rocksdb/status.h"
#include <stdio.h> #include <stdio.h>
#ifdef OS_WIN #ifdef OS_WIN
#include <string.h> #include <string.h>
#endif #endif
#include <cstring> #include <cstring>
#include "port/port.h" #include "port/port.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {

@ -8,6 +8,7 @@
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <algorithm> #include <algorithm>
#include <cinttypes> #include <cinttypes>
#include <cmath> #include <cmath>
@ -15,6 +16,7 @@
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "port/port.h" #include "port/port.h"
#include "port/sys_time.h" #include "port/sys_time.h"
#include "rocksdb/slice.h" #include "rocksdb/slice.h"

@ -3,8 +3,8 @@
// COPYING file in the root directory) and Apache 2.0 License // COPYING file in the root directory) and Apache 2.0 License
// (found in the LICENSE.Apache file in the root directory). // (found in the LICENSE.Apache file in the root directory).
#include <mutex>
#include <condition_variable> #include <condition_variable>
#include <mutex>
#include "monitoring/thread_status_updater.h" #include "monitoring/thread_status_updater.h"
#include "rocksdb/db.h" #include "rocksdb/db.h"
@ -17,16 +17,19 @@ namespace ROCKSDB_NAMESPACE {
class SimulatedBackgroundTask { class SimulatedBackgroundTask {
public: public:
SimulatedBackgroundTask( SimulatedBackgroundTask(
const void* db_key, const std::string& db_name, const void* db_key, const std::string& db_name, const void* cf_key,
const void* cf_key, const std::string& cf_name, const std::string& cf_name,
const ThreadStatus::OperationType operation_type = const ThreadStatus::OperationType operation_type =
ThreadStatus::OP_UNKNOWN, ThreadStatus::OP_UNKNOWN,
const ThreadStatus::StateType state_type = const ThreadStatus::StateType state_type = ThreadStatus::STATE_UNKNOWN)
ThreadStatus::STATE_UNKNOWN) : db_key_(db_key),
: db_key_(db_key), db_name_(db_name), db_name_(db_name),
cf_key_(cf_key), cf_name_(cf_name), cf_key_(cf_key),
operation_type_(operation_type), state_type_(state_type), cf_name_(cf_name),
should_run_(true), running_count_(0) { operation_type_(operation_type),
state_type_(state_type),
should_run_(true),
running_count_(0) {
Env::Default()->GetThreadStatusUpdater()->NewColumnFamilyInfo( Env::Default()->GetThreadStatusUpdater()->NewColumnFamilyInfo(
db_key_, db_name_, cf_key_, cf_name_); db_key_, db_name_, cf_key_, cf_name_);
} }
@ -92,24 +95,22 @@ class SimulatedBackgroundTask {
class ThreadListTest : public testing::Test { class ThreadListTest : public testing::Test {
public: public:
ThreadListTest() { ThreadListTest() {}
}
}; };
TEST_F(ThreadListTest, GlobalTables) { TEST_F(ThreadListTest, GlobalTables) {
// verify the global tables for operations and states are properly indexed. // verify the global tables for operations and states are properly indexed.
for (int type = 0; type != ThreadStatus::NUM_OP_TYPES; ++type) { for (int type = 0; type != ThreadStatus::NUM_OP_TYPES; ++type) {
ASSERT_EQ(global_operation_table[type].type, type); ASSERT_EQ(global_operation_table[type].type, type);
ASSERT_EQ(global_operation_table[type].name, ASSERT_EQ(
ThreadStatus::GetOperationName( global_operation_table[type].name,
ThreadStatus::OperationType(type))); ThreadStatus::GetOperationName(ThreadStatus::OperationType(type)));
} }
for (int type = 0; type != ThreadStatus::NUM_STATE_TYPES; ++type) { for (int type = 0; type != ThreadStatus::NUM_STATE_TYPES; ++type) {
ASSERT_EQ(global_state_table[type].type, type); ASSERT_EQ(global_state_table[type].type, type);
ASSERT_EQ(global_state_table[type].name, ASSERT_EQ(global_state_table[type].name,
ThreadStatus::GetStateName( ThreadStatus::GetStateName(ThreadStatus::StateType(type)));
ThreadStatus::StateType(type)));
} }
for (int stage = 0; stage != ThreadStatus::NUM_OP_STAGES; ++stage) { for (int stage = 0; stage != ThreadStatus::NUM_OP_STAGES; ++stage) {
@ -131,18 +132,18 @@ TEST_F(ThreadListTest, SimpleColumnFamilyInfoTest) {
env->SetBackgroundThreads(kLowPriorityThreads, Env::LOW); env->SetBackgroundThreads(kLowPriorityThreads, Env::LOW);
// Wait 1 second so that threads start // Wait 1 second so that threads start
Env::Default()->SleepForMicroseconds(kDelayMicros); Env::Default()->SleepForMicroseconds(kDelayMicros);
SimulatedBackgroundTask running_task( SimulatedBackgroundTask running_task(reinterpret_cast<void*>(1234), "running",
reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
reinterpret_cast<void*>(5678), "pikachu"); "pikachu");
for (int test = 0; test < kSimulatedHighPriThreads; ++test) { for (int test = 0; test < kSimulatedHighPriThreads; ++test) {
env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, &running_task,
&running_task, Env::Priority::HIGH); Env::Priority::HIGH);
} }
for (int test = 0; test < kSimulatedLowPriThreads; ++test) { for (int test = 0; test < kSimulatedLowPriThreads; ++test) {
env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, &running_task,
&running_task, Env::Priority::LOW); Env::Priority::LOW);
} }
running_task.WaitUntilScheduled(kSimulatedHighPriThreads + running_task.WaitUntilScheduled(kSimulatedHighPriThreads +
kSimulatedLowPriThreads); kSimulatedLowPriThreads);
@ -168,14 +169,10 @@ TEST_F(ThreadListTest, SimpleColumnFamilyInfoTest) {
ASSERT_EQ(0, env->ReserveThreads(kHighPriorityThreads, Env::Priority::HIGH)); ASSERT_EQ(0, env->ReserveThreads(kHighPriorityThreads, Env::Priority::HIGH));
ASSERT_EQ(0, env->ReserveThreads(kLowPriorityThreads, Env::Priority::LOW)); ASSERT_EQ(0, env->ReserveThreads(kLowPriorityThreads, Env::Priority::LOW));
ASSERT_EQ( ASSERT_EQ(running_count[ThreadStatus::HIGH_PRIORITY],
running_count[ThreadStatus::HIGH_PRIORITY], kSimulatedHighPriThreads);
kSimulatedHighPriThreads); ASSERT_EQ(running_count[ThreadStatus::LOW_PRIORITY], kSimulatedLowPriThreads);
ASSERT_EQ( ASSERT_EQ(running_count[ThreadStatus::USER], 0);
running_count[ThreadStatus::LOW_PRIORITY],
kSimulatedLowPriThreads);
ASSERT_EQ(
running_count[ThreadStatus::USER], 0);
running_task.FinishAllTasks(); running_task.FinishAllTasks();
running_task.WaitUntilDone(); running_task.WaitUntilDone();
@ -197,37 +194,33 @@ TEST_F(ThreadListTest, SimpleColumnFamilyInfoTest) {
} }
} }
ASSERT_EQ( ASSERT_EQ(running_count[ThreadStatus::HIGH_PRIORITY], 0);
running_count[ThreadStatus::HIGH_PRIORITY], 0); ASSERT_EQ(running_count[ThreadStatus::LOW_PRIORITY], 0);
ASSERT_EQ( ASSERT_EQ(running_count[ThreadStatus::USER], 0);
running_count[ThreadStatus::LOW_PRIORITY], 0);
ASSERT_EQ(
running_count[ThreadStatus::USER], 0);
} }
namespace { namespace {
void UpdateStatusCounts( void UpdateStatusCounts(const std::vector<ThreadStatus>& thread_list,
const std::vector<ThreadStatus>& thread_list, int operation_counts[], int state_counts[]) {
int operation_counts[], int state_counts[]) { for (auto thread_status : thread_list) {
for (auto thread_status : thread_list) { operation_counts[thread_status.operation_type]++;
operation_counts[thread_status.operation_type]++; state_counts[thread_status.state_type]++;
state_counts[thread_status.state_type]++;
}
} }
}
void VerifyAndResetCounts( void VerifyAndResetCounts(const int correct_counts[], int collected_counts[],
const int correct_counts[], int collected_counts[], int size) { int size) {
for (int i = 0; i < size; ++i) { for (int i = 0; i < size; ++i) {
ASSERT_EQ(collected_counts[i], correct_counts[i]); ASSERT_EQ(collected_counts[i], correct_counts[i]);
collected_counts[i] = 0; collected_counts[i] = 0;
}
} }
}
void UpdateCount( void UpdateCount(int operation_counts[], int from_event, int to_event,
int operation_counts[], int from_event, int to_event, int amount) { int amount) {
operation_counts[from_event] -= amount; operation_counts[from_event] -= amount;
operation_counts[to_event] += amount; operation_counts[to_event] += amount;
} }
} // namespace } // namespace
TEST_F(ThreadListTest, SimpleEventTest) { TEST_F(ThreadListTest, SimpleEventTest) {
@ -236,62 +229,57 @@ TEST_F(ThreadListTest, SimpleEventTest) {
// simulated tasks // simulated tasks
const int kFlushWriteTasks = 3; const int kFlushWriteTasks = 3;
SimulatedBackgroundTask flush_write_task( SimulatedBackgroundTask flush_write_task(
reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
reinterpret_cast<void*>(5678), "pikachu", "pikachu", ThreadStatus::OP_FLUSH);
ThreadStatus::OP_FLUSH);
const int kCompactionWriteTasks = 4; const int kCompactionWriteTasks = 4;
SimulatedBackgroundTask compaction_write_task( SimulatedBackgroundTask compaction_write_task(
reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
reinterpret_cast<void*>(5678), "pikachu", "pikachu", ThreadStatus::OP_COMPACTION);
ThreadStatus::OP_COMPACTION);
const int kCompactionReadTasks = 5; const int kCompactionReadTasks = 5;
SimulatedBackgroundTask compaction_read_task( SimulatedBackgroundTask compaction_read_task(
reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
reinterpret_cast<void*>(5678), "pikachu", "pikachu", ThreadStatus::OP_COMPACTION);
ThreadStatus::OP_COMPACTION);
const int kCompactionWaitTasks = 6; const int kCompactionWaitTasks = 6;
SimulatedBackgroundTask compaction_wait_task( SimulatedBackgroundTask compaction_wait_task(
reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
reinterpret_cast<void*>(5678), "pikachu", "pikachu", ThreadStatus::OP_COMPACTION);
ThreadStatus::OP_COMPACTION);
// setup right answers // setup right answers
int correct_operation_counts[ThreadStatus::NUM_OP_TYPES] = {0}; int correct_operation_counts[ThreadStatus::NUM_OP_TYPES] = {0};
correct_operation_counts[ThreadStatus::OP_FLUSH] = correct_operation_counts[ThreadStatus::OP_FLUSH] = kFlushWriteTasks;
kFlushWriteTasks;
correct_operation_counts[ThreadStatus::OP_COMPACTION] = correct_operation_counts[ThreadStatus::OP_COMPACTION] =
kCompactionWriteTasks + kCompactionReadTasks + kCompactionWaitTasks; kCompactionWriteTasks + kCompactionReadTasks + kCompactionWaitTasks;
env->SetBackgroundThreads( env->SetBackgroundThreads(correct_operation_counts[ThreadStatus::OP_FLUSH],
correct_operation_counts[ThreadStatus::OP_FLUSH], Env::HIGH); Env::HIGH);
env->SetBackgroundThreads( env->SetBackgroundThreads(
correct_operation_counts[ThreadStatus::OP_COMPACTION], Env::LOW); correct_operation_counts[ThreadStatus::OP_COMPACTION], Env::LOW);
// schedule the simulated tasks // schedule the simulated tasks
for (int t = 0; t < kFlushWriteTasks; ++t) { for (int t = 0; t < kFlushWriteTasks; ++t) {
env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, &flush_write_task,
&flush_write_task, Env::Priority::HIGH); Env::Priority::HIGH);
} }
flush_write_task.WaitUntilScheduled(kFlushWriteTasks); flush_write_task.WaitUntilScheduled(kFlushWriteTasks);
for (int t = 0; t < kCompactionWriteTasks; ++t) { for (int t = 0; t < kCompactionWriteTasks; ++t) {
env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
&compaction_write_task, Env::Priority::LOW); &compaction_write_task, Env::Priority::LOW);
} }
compaction_write_task.WaitUntilScheduled(kCompactionWriteTasks); compaction_write_task.WaitUntilScheduled(kCompactionWriteTasks);
for (int t = 0; t < kCompactionReadTasks; ++t) { for (int t = 0; t < kCompactionReadTasks; ++t) {
env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
&compaction_read_task, Env::Priority::LOW); &compaction_read_task, Env::Priority::LOW);
} }
compaction_read_task.WaitUntilScheduled(kCompactionReadTasks); compaction_read_task.WaitUntilScheduled(kCompactionReadTasks);
for (int t = 0; t < kCompactionWaitTasks; ++t) { for (int t = 0; t < kCompactionWaitTasks; ++t) {
env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
&compaction_wait_task, Env::Priority::LOW); &compaction_wait_task, Env::Priority::LOW);
} }
compaction_wait_task.WaitUntilScheduled(kCompactionWaitTasks); compaction_wait_task.WaitUntilScheduled(kCompactionWaitTasks);

@ -8,10 +8,12 @@
// found in the LICENSE file. See the AUTHORS file for names of contributors. // found in the LICENSE file. See the AUTHORS file for names of contributors.
#include "util/thread_local.h" #include "util/thread_local.h"
#include "util/mutexlock.h"
#include "port/likely.h"
#include <stdlib.h> #include <stdlib.h>
#include "port/likely.h"
#include "util/mutexlock.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
struct Entry { struct Entry {
@ -39,10 +41,7 @@ class StaticMeta;
// --------------------------------------------------- // ---------------------------------------------------
struct ThreadData { struct ThreadData {
explicit ThreadData(ThreadLocalPtr::StaticMeta* _inst) explicit ThreadData(ThreadLocalPtr::StaticMeta* _inst)
: entries(), : entries(), next(nullptr), prev(nullptr), inst(_inst) {}
next(nullptr),
prev(nullptr),
inst(_inst) {}
std::vector<Entry> entries; std::vector<Entry> entries;
ThreadData* next; ThreadData* next;
ThreadData* prev; ThreadData* prev;
@ -50,7 +49,7 @@ struct ThreadData {
}; };
class ThreadLocalPtr::StaticMeta { class ThreadLocalPtr::StaticMeta {
public: public:
StaticMeta(); StaticMeta();
// Return the next available Id // Return the next available Id
@ -107,7 +106,7 @@ public:
// should be used. One example is OnThreadExit() function. // should be used. One example is OnThreadExit() function.
port::Mutex* MemberMutex() { return &mutex_; } port::Mutex* MemberMutex() { return &mutex_; }
private: private:
// Get UnrefHandler for id with acquiring mutex // Get UnrefHandler for id with acquiring mutex
// REQUIRES: mutex locked // REQUIRES: mutex locked
UnrefHandler GetHandler(uint32_t id); UnrefHandler GetHandler(uint32_t id);
@ -173,7 +172,7 @@ namespace wintlscleanup {
// This is set to OnThreadExit in StaticMeta singleton constructor // This is set to OnThreadExit in StaticMeta singleton constructor
UnrefHandler thread_local_inclass_routine = nullptr; UnrefHandler thread_local_inclass_routine = nullptr;
pthread_key_t thread_local_key = pthread_key_t (-1); pthread_key_t thread_local_key = pthread_key_t(-1);
// Static callback function to call with each thread termination. // Static callback function to call with each thread termination.
void NTAPI WinOnThreadExit(PVOID module, DWORD reason, PVOID reserved) { void NTAPI WinOnThreadExit(PVOID module, DWORD reason, PVOID reserved) {
@ -189,7 +188,7 @@ void NTAPI WinOnThreadExit(PVOID module, DWORD reason, PVOID reserved) {
} }
} }
} // wintlscleanup } // namespace wintlscleanup
// extern "C" suppresses C++ name mangling so we know the symbol name for the // extern "C" suppresses C++ name mangling so we know the symbol name for the
// linker /INCLUDE:symbol pragma above. // linker /INCLUDE:symbol pragma above.
@ -298,9 +297,7 @@ void ThreadLocalPtr::StaticMeta::OnThreadExit(void* ptr) {
} }
ThreadLocalPtr::StaticMeta::StaticMeta() ThreadLocalPtr::StaticMeta::StaticMeta()
: next_instance_id_(0), : next_instance_id_(0), head_(this), pthread_key_(0) {
head_(this),
pthread_key_(0) {
if (pthread_key_create(&pthread_key_, &OnThreadExit) != 0) { if (pthread_key_create(&pthread_key_, &OnThreadExit) != 0) {
abort(); abort();
} }
@ -345,8 +342,7 @@ void ThreadLocalPtr::StaticMeta::AddThreadData(ThreadData* d) {
head_.prev = d; head_.prev = d;
} }
void ThreadLocalPtr::StaticMeta::RemoveThreadData( void ThreadLocalPtr::StaticMeta::RemoveThreadData(ThreadData* d) {
ThreadData* d) {
Mutex()->AssertHeld(); Mutex()->AssertHeld();
d->next->prev = d->prev; d->next->prev = d->prev;
d->prev->next = d->next; d->prev->next = d->next;
@ -406,7 +402,7 @@ void* ThreadLocalPtr::StaticMeta::Swap(uint32_t id, void* ptr) {
} }
bool ThreadLocalPtr::StaticMeta::CompareAndSwap(uint32_t id, void* ptr, bool ThreadLocalPtr::StaticMeta::CompareAndSwap(uint32_t id, void* ptr,
void*& expected) { void*& expected) {
auto* tls = GetThreadLocal(); auto* tls = GetThreadLocal();
if (UNLIKELY(id >= tls->entries.size())) { if (UNLIKELY(id >= tls->entries.size())) {
// Need mutex to protect entries access within ReclaimId // Need mutex to protect entries access within ReclaimId
@ -418,7 +414,7 @@ bool ThreadLocalPtr::StaticMeta::CompareAndSwap(uint32_t id, void* ptr,
} }
void ThreadLocalPtr::StaticMeta::Scrape(uint32_t id, autovector<void*>* ptrs, void ThreadLocalPtr::StaticMeta::Scrape(uint32_t id, autovector<void*>* ptrs,
void* const replacement) { void* const replacement) {
MutexLock l(Mutex()); MutexLock l(Mutex());
for (ThreadData* t = head_.next; t != &head_; t = t->next) { for (ThreadData* t = head_.next; t != &head_; t = t->next) {
if (id < t->entries.size()) { if (id < t->entries.size()) {
@ -443,9 +439,7 @@ void ThreadLocalPtr::StaticMeta::Fold(uint32_t id, FoldFunc func, void* res) {
} }
} }
uint32_t ThreadLocalPtr::TEST_PeekId() { uint32_t ThreadLocalPtr::TEST_PeekId() { return Instance()->PeekId(); }
return Instance()->PeekId();
}
void ThreadLocalPtr::StaticMeta::SetHandler(uint32_t id, UnrefHandler handler) { void ThreadLocalPtr::StaticMeta::SetHandler(uint32_t id, UnrefHandler handler) {
MutexLock l(Mutex()); MutexLock l(Mutex());
@ -504,21 +498,13 @@ ThreadLocalPtr::ThreadLocalPtr(UnrefHandler handler)
} }
} }
ThreadLocalPtr::~ThreadLocalPtr() { ThreadLocalPtr::~ThreadLocalPtr() { Instance()->ReclaimId(id_); }
Instance()->ReclaimId(id_);
}
void* ThreadLocalPtr::Get() const { void* ThreadLocalPtr::Get() const { return Instance()->Get(id_); }
return Instance()->Get(id_);
}
void ThreadLocalPtr::Reset(void* ptr) { void ThreadLocalPtr::Reset(void* ptr) { Instance()->Reset(id_, ptr); }
Instance()->Reset(id_, ptr);
}
void* ThreadLocalPtr::Swap(void* ptr) { void* ThreadLocalPtr::Swap(void* ptr) { return Instance()->Swap(id_, ptr); }
return Instance()->Swap(id_, ptr);
}
bool ThreadLocalPtr::CompareAndSwap(void* ptr, void*& expected) { bool ThreadLocalPtr::CompareAndSwap(void* ptr, void*& expected) {
return Instance()->CompareAndSwap(id_, ptr, expected); return Instance()->CompareAndSwap(id_, ptr, expected);

@ -15,8 +15,8 @@
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include "util/autovector.h"
#include "port/port.h" #include "port/port.h"
#include "util/autovector.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
@ -91,8 +91,7 @@ class ThreadLocalPtr {
class StaticMeta; class StaticMeta;
private: private:
static StaticMeta* Instance(); static StaticMeta* Instance();
const uint32_t id_; const uint32_t id_;

@ -13,10 +13,10 @@
#pragma once #pragma once
#include "rocksdb/thread_status.h"
#include <string> #include <string>
#include "rocksdb/thread_status.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
#ifdef ROCKSDB_USING_THREAD_STATUS #ifdef ROCKSDB_USING_THREAD_STATUS
@ -36,10 +36,9 @@ struct OperationInfo {
// Note that it's not designed to be constant as in the future we // Note that it's not designed to be constant as in the future we
// might consider adding global count to the OperationInfo. // might consider adding global count to the OperationInfo.
static OperationInfo global_operation_table[] = { static OperationInfo global_operation_table[] = {
{ThreadStatus::OP_UNKNOWN, ""}, {ThreadStatus::OP_UNKNOWN, ""},
{ThreadStatus::OP_COMPACTION, "Compaction"}, {ThreadStatus::OP_COMPACTION, "Compaction"},
{ThreadStatus::OP_FLUSH, "Flush"} {ThreadStatus::OP_FLUSH, "Flush"}};
};
struct OperationStageInfo { struct OperationStageInfo {
const ThreadStatus::OperationStage stage; const ThreadStatus::OperationStage stage;
@ -50,27 +49,22 @@ struct OperationStageInfo {
// Note that the string must be changed accordingly when the // Note that the string must be changed accordingly when the
// associated function name changed. // associated function name changed.
static OperationStageInfo global_op_stage_table[] = { static OperationStageInfo global_op_stage_table[] = {
{ThreadStatus::STAGE_UNKNOWN, ""}, {ThreadStatus::STAGE_UNKNOWN, ""},
{ThreadStatus::STAGE_FLUSH_RUN, {ThreadStatus::STAGE_FLUSH_RUN, "FlushJob::Run"},
"FlushJob::Run"}, {ThreadStatus::STAGE_FLUSH_WRITE_L0, "FlushJob::WriteLevel0Table"},
{ThreadStatus::STAGE_FLUSH_WRITE_L0, {ThreadStatus::STAGE_COMPACTION_PREPARE, "CompactionJob::Prepare"},
"FlushJob::WriteLevel0Table"}, {ThreadStatus::STAGE_COMPACTION_RUN, "CompactionJob::Run"},
{ThreadStatus::STAGE_COMPACTION_PREPARE, {ThreadStatus::STAGE_COMPACTION_PROCESS_KV,
"CompactionJob::Prepare"}, "CompactionJob::ProcessKeyValueCompaction"},
{ThreadStatus::STAGE_COMPACTION_RUN, {ThreadStatus::STAGE_COMPACTION_INSTALL, "CompactionJob::Install"},
"CompactionJob::Run"}, {ThreadStatus::STAGE_COMPACTION_SYNC_FILE,
{ThreadStatus::STAGE_COMPACTION_PROCESS_KV, "CompactionJob::FinishCompactionOutputFile"},
"CompactionJob::ProcessKeyValueCompaction"}, {ThreadStatus::STAGE_PICK_MEMTABLES_TO_FLUSH,
{ThreadStatus::STAGE_COMPACTION_INSTALL, "MemTableList::PickMemtablesToFlush"},
"CompactionJob::Install"}, {ThreadStatus::STAGE_MEMTABLE_ROLLBACK,
{ThreadStatus::STAGE_COMPACTION_SYNC_FILE, "MemTableList::RollbackMemtableFlush"},
"CompactionJob::FinishCompactionOutputFile"}, {ThreadStatus::STAGE_MEMTABLE_INSTALL_FLUSH_RESULTS,
{ThreadStatus::STAGE_PICK_MEMTABLES_TO_FLUSH, "MemTableList::TryInstallMemtableFlushResults"},
"MemTableList::PickMemtablesToFlush"},
{ThreadStatus::STAGE_MEMTABLE_ROLLBACK,
"MemTableList::RollbackMemtableFlush"},
{ThreadStatus::STAGE_MEMTABLE_INSTALL_FLUSH_RESULTS,
"MemTableList::TryInstallMemtableFlushResults"},
}; };
// The structure that describes a state. // The structure that describes a state.
@ -85,8 +79,8 @@ struct StateInfo {
// of the current ThreadStatusData will be pointing to one of the // of the current ThreadStatusData will be pointing to one of the
// rows in this global table. // rows in this global table.
static StateInfo global_state_table[] = { static StateInfo global_state_table[] = {
{ThreadStatus::STATE_UNKNOWN, ""}, {ThreadStatus::STATE_UNKNOWN, ""},
{ThreadStatus::STATE_MUTEX_WAIT, "Mutex Wait"}, {ThreadStatus::STATE_MUTEX_WAIT, "Mutex Wait"},
}; };
struct OperationProperty { struct OperationProperty {
@ -95,27 +89,24 @@ struct OperationProperty {
}; };
static OperationProperty compaction_operation_properties[] = { static OperationProperty compaction_operation_properties[] = {
{ThreadStatus::COMPACTION_JOB_ID, "JobID"}, {ThreadStatus::COMPACTION_JOB_ID, "JobID"},
{ThreadStatus::COMPACTION_INPUT_OUTPUT_LEVEL, "InputOutputLevel"}, {ThreadStatus::COMPACTION_INPUT_OUTPUT_LEVEL, "InputOutputLevel"},
{ThreadStatus::COMPACTION_PROP_FLAGS, "Manual/Deletion/Trivial"}, {ThreadStatus::COMPACTION_PROP_FLAGS, "Manual/Deletion/Trivial"},
{ThreadStatus::COMPACTION_TOTAL_INPUT_BYTES, "TotalInputBytes"}, {ThreadStatus::COMPACTION_TOTAL_INPUT_BYTES, "TotalInputBytes"},
{ThreadStatus::COMPACTION_BYTES_READ, "BytesRead"}, {ThreadStatus::COMPACTION_BYTES_READ, "BytesRead"},
{ThreadStatus::COMPACTION_BYTES_WRITTEN, "BytesWritten"}, {ThreadStatus::COMPACTION_BYTES_WRITTEN, "BytesWritten"},
}; };
static OperationProperty flush_operation_properties[] = { static OperationProperty flush_operation_properties[] = {
{ThreadStatus::FLUSH_JOB_ID, "JobID"}, {ThreadStatus::FLUSH_JOB_ID, "JobID"},
{ThreadStatus::FLUSH_BYTES_MEMTABLES, "BytesMemtables"}, {ThreadStatus::FLUSH_BYTES_MEMTABLES, "BytesMemtables"},
{ThreadStatus::FLUSH_BYTES_WRITTEN, "BytesWritten"} {ThreadStatus::FLUSH_BYTES_WRITTEN, "BytesWritten"}};
};
#else #else
struct OperationInfo { struct OperationInfo {};
};
struct StateInfo { struct StateInfo {};
};
#endif // ROCKSDB_USING_THREAD_STATUS #endif // ROCKSDB_USING_THREAD_STATUS
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

@ -10,12 +10,12 @@
#include "util/threadpool_imp.h" #include "util/threadpool_imp.h"
#ifndef OS_WIN #ifndef OS_WIN
# include <unistd.h> #include <unistd.h>
#endif #endif
#ifdef OS_LINUX #ifdef OS_LINUX
# include <sys/syscall.h> #include <sys/resource.h>
# include <sys/resource.h> #include <sys/syscall.h>
#endif #endif
#include <stdlib.h> #include <stdlib.h>
@ -44,7 +44,6 @@ void ThreadPoolImpl::PthreadCall(const char* label, int result) {
} }
struct ThreadPoolImpl::Impl { struct ThreadPoolImpl::Impl {
Impl(); Impl();
~Impl(); ~Impl();
@ -61,16 +60,14 @@ struct ThreadPoolImpl::Impl {
void LowerCPUPriority(CpuPriority pri); void LowerCPUPriority(CpuPriority pri);
void WakeUpAllThreads() { void WakeUpAllThreads() { bgsignal_.notify_all(); }
bgsignal_.notify_all();
}
void BGThread(size_t thread_id); void BGThread(size_t thread_id);
void StartBGThreads(); void StartBGThreads();
void Submit(std::function<void()>&& schedule, void Submit(std::function<void()>&& schedule,
std::function<void()>&& unschedule, void* tag); std::function<void()>&& unschedule, void* tag);
int UnSchedule(void* arg); int UnSchedule(void* arg);
@ -124,41 +121,41 @@ struct ThreadPoolImpl::Impl {
return released_threads_in_success; return released_threads_in_success;
} }
private: private:
static void BGThreadWrapper(void* arg); static void BGThreadWrapper(void* arg);
bool low_io_priority_; bool low_io_priority_;
CpuPriority cpu_priority_; CpuPriority cpu_priority_;
Env::Priority priority_; Env::Priority priority_;
Env* env_; Env* env_;
int total_threads_limit_; int total_threads_limit_;
std::atomic_uint queue_len_; // Queue length. Used for stats reporting std::atomic_uint queue_len_; // Queue length. Used for stats reporting
// Number of reserved threads, managed by ReserveThreads(..) and // Number of reserved threads, managed by ReserveThreads(..) and
// ReleaseThreads(..), if num_waiting_threads_ is no larger than // ReleaseThreads(..), if num_waiting_threads_ is no larger than
// reserved_threads_, its thread will be blocked to ensure the reservation // reserved_threads_, its thread will be blocked to ensure the reservation
// mechanism // mechanism
int reserved_threads_; int reserved_threads_;
// Number of waiting threads (Maximum number of threads that can be // Number of waiting threads (Maximum number of threads that can be
// reserved), in rare cases, num_waiting_threads_ could be less than // reserved), in rare cases, num_waiting_threads_ could be less than
// reserved_threads due to SetBackgroundThreadInternal or last // reserved_threads due to SetBackgroundThreadInternal or last
// excessive threads. // excessive threads.
int num_waiting_threads_; int num_waiting_threads_;
bool exit_all_threads_; bool exit_all_threads_;
bool wait_for_jobs_to_complete_; bool wait_for_jobs_to_complete_;
// Entry per Schedule()/Submit() call // Entry per Schedule()/Submit() call
struct BGItem { struct BGItem {
void* tag = nullptr; void* tag = nullptr;
std::function<void()> function; std::function<void()> function;
std::function<void()> unschedFunction; std::function<void()> unschedFunction;
}; };
using BGQueue = std::deque<BGItem>; using BGQueue = std::deque<BGItem>;
BGQueue queue_; BGQueue queue_;
std::mutex mu_; std::mutex mu_;
std::condition_variable bgsignal_; std::condition_variable bgsignal_;
std::vector<port::Thread> bgthreads_; std::vector<port::Thread> bgthreads_;
}; };
@ -178,11 +175,9 @@ inline ThreadPoolImpl::Impl::Impl()
bgsignal_(), bgsignal_(),
bgthreads_() {} bgthreads_() {}
inline inline ThreadPoolImpl::Impl::~Impl() { assert(bgthreads_.size() == 0U); }
ThreadPoolImpl::Impl::~Impl() { assert(bgthreads_.size() == 0U); }
void ThreadPoolImpl::Impl::JoinThreads(bool wait_for_jobs_to_complete) { void ThreadPoolImpl::Impl::JoinThreads(bool wait_for_jobs_to_complete) {
std::unique_lock<std::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
assert(!exit_all_threads_); assert(!exit_all_threads_);
@ -208,8 +203,7 @@ void ThreadPoolImpl::Impl::JoinThreads(bool wait_for_jobs_to_complete) {
wait_for_jobs_to_complete_ = false; wait_for_jobs_to_complete_ = false;
} }
inline inline void ThreadPoolImpl::Impl::LowerIOPriority() {
void ThreadPoolImpl::Impl::LowerIOPriority() {
std::lock_guard<std::mutex> lock(mu_); std::lock_guard<std::mutex> lock(mu_);
low_io_priority_ = true; low_io_priority_ = true;
} }
@ -247,10 +241,9 @@ void ThreadPoolImpl::Impl::BGThread(size_t thread_id) {
if (exit_all_threads_) { // mechanism to let BG threads exit safely if (exit_all_threads_) { // mechanism to let BG threads exit safely
if (!wait_for_jobs_to_complete_ || if (!wait_for_jobs_to_complete_ || queue_.empty()) {
queue_.empty()) {
break; break;
} }
} else if (IsLastExcessiveThread(thread_id)) { } else if (IsLastExcessiveThread(thread_id)) {
// Current thread is the last generated one and is excessive. // Current thread is the last generated one and is excessive.
// We always terminate excessive thread in the reverse order of // We always terminate excessive thread in the reverse order of
@ -365,7 +358,7 @@ void ThreadPoolImpl::Impl::BGThreadWrapper(void* arg) {
} }
void ThreadPoolImpl::Impl::SetBackgroundThreadsInternal(int num, void ThreadPoolImpl::Impl::SetBackgroundThreadsInternal(int num,
bool allow_reduce) { bool allow_reduce) {
std::lock_guard<std::mutex> lock(mu_); std::lock_guard<std::mutex> lock(mu_);
if (exit_all_threads_) { if (exit_all_threads_) {
return; return;
@ -387,7 +380,7 @@ void ThreadPoolImpl::Impl::StartBGThreads() {
// Start background thread if necessary // Start background thread if necessary
while ((int)bgthreads_.size() < total_threads_limit_) { while ((int)bgthreads_.size() < total_threads_limit_) {
port::Thread p_t(&BGThreadWrapper, port::Thread p_t(&BGThreadWrapper,
new BGThreadMetadata(this, bgthreads_.size())); new BGThreadMetadata(this, bgthreads_.size()));
// Set the thread name to aid debugging // Set the thread name to aid debugging
#if defined(_GNU_SOURCE) && defined(__GLIBC_PREREQ) #if defined(_GNU_SOURCE) && defined(__GLIBC_PREREQ)
@ -407,8 +400,8 @@ void ThreadPoolImpl::Impl::StartBGThreads() {
} }
void ThreadPoolImpl::Impl::Submit(std::function<void()>&& schedule, void ThreadPoolImpl::Impl::Submit(std::function<void()>&& schedule,
std::function<void()>&& unschedule, void* tag) { std::function<void()>&& unschedule,
void* tag) {
std::lock_guard<std::mutex> lock(mu_); std::lock_guard<std::mutex> lock(mu_);
if (exit_all_threads_) { if (exit_all_threads_) {
@ -426,7 +419,7 @@ void ThreadPoolImpl::Impl::Submit(std::function<void()>&& schedule,
item.unschedFunction = std::move(unschedule); item.unschedFunction = std::move(unschedule);
queue_len_.store(static_cast<unsigned int>(queue_.size()), queue_len_.store(static_cast<unsigned int>(queue_.size()),
std::memory_order_relaxed); std::memory_order_relaxed);
if (!HasExcessiveThread()) { if (!HasExcessiveThread()) {
// Wake up at least one waiting thread. // Wake up at least one waiting thread.
@ -459,11 +452,10 @@ int ThreadPoolImpl::Impl::UnSchedule(void* arg) {
} }
} }
queue_len_.store(static_cast<unsigned int>(queue_.size()), queue_len_.store(static_cast<unsigned int>(queue_.size()),
std::memory_order_relaxed); std::memory_order_relaxed);
} }
// Run unschedule functions outside the mutex
// Run unschedule functions outside the mutex
for (auto& f : candidates) { for (auto& f : candidates) {
f(); f();
} }
@ -471,17 +463,11 @@ int ThreadPoolImpl::Impl::UnSchedule(void* arg) {
return count; return count;
} }
ThreadPoolImpl::ThreadPoolImpl() : ThreadPoolImpl::ThreadPoolImpl() : impl_(new Impl()) {}
impl_(new Impl()) {
}
ThreadPoolImpl::~ThreadPoolImpl() { ThreadPoolImpl::~ThreadPoolImpl() {}
}
void ThreadPoolImpl::JoinAllThreads() { void ThreadPoolImpl::JoinAllThreads() { impl_->JoinThreads(false); }
impl_->JoinThreads(false);
}
void ThreadPoolImpl::SetBackgroundThreads(int num) { void ThreadPoolImpl::SetBackgroundThreads(int num) {
impl_->SetBackgroundThreadsInternal(num, true); impl_->SetBackgroundThreadsInternal(num, true);
@ -499,9 +485,7 @@ void ThreadPoolImpl::WaitForJobsAndJoinAllThreads() {
impl_->JoinThreads(true); impl_->JoinThreads(true);
} }
void ThreadPoolImpl::LowerIOPriority() { void ThreadPoolImpl::LowerIOPriority() { impl_->LowerIOPriority(); }
impl_->LowerIOPriority();
}
void ThreadPoolImpl::LowerCPUPriority(CpuPriority pri) { void ThreadPoolImpl::LowerCPUPriority(CpuPriority pri) {
impl_->LowerCPUPriority(pri); impl_->LowerCPUPriority(pri);
@ -516,13 +500,12 @@ void ThreadPoolImpl::SubmitJob(const std::function<void()>& job) {
impl_->Submit(std::move(copy), std::function<void()>(), nullptr); impl_->Submit(std::move(copy), std::function<void()>(), nullptr);
} }
void ThreadPoolImpl::SubmitJob(std::function<void()>&& job) { void ThreadPoolImpl::SubmitJob(std::function<void()>&& job) {
impl_->Submit(std::move(job), std::function<void()>(), nullptr); impl_->Submit(std::move(job), std::function<void()>(), nullptr);
} }
void ThreadPoolImpl::Schedule(void(*function)(void* arg1), void* arg, void ThreadPoolImpl::Schedule(void (*function)(void* arg1), void* arg,
void* tag, void(*unschedFunction)(void* arg)) { void* tag, void (*unschedFunction)(void* arg)) {
if (unschedFunction == nullptr) { if (unschedFunction == nullptr) {
impl_->Submit(std::bind(function, arg), std::function<void()>(), tag); impl_->Submit(std::bind(function, arg), std::function<void()>(), tag);
} else { } else {
@ -531,9 +514,7 @@ void ThreadPoolImpl::Schedule(void(*function)(void* arg1), void* arg,
} }
} }
int ThreadPoolImpl::UnSchedule(void* arg) { int ThreadPoolImpl::UnSchedule(void* arg) { return impl_->UnSchedule(arg); }
return impl_->UnSchedule(arg);
}
void ThreadPoolImpl::SetHostEnv(Env* env) { impl_->SetHostEnv(env); } void ThreadPoolImpl::SetHostEnv(Env* env) { impl_->SetHostEnv(env); }

@ -8,11 +8,11 @@
// found in the LICENSE file. See the AUTHORS file for names of contributors. // found in the LICENSE file. See the AUTHORS file for names of contributors.
#pragma once #pragma once
#include "rocksdb/threadpool.h"
#include "rocksdb/env.h"
#include <memory>
#include <functional> #include <functional>
#include <memory>
#include "rocksdb/env.h"
#include "rocksdb/threadpool.h"
namespace ROCKSDB_NAMESPACE { namespace ROCKSDB_NAMESPACE {
@ -101,20 +101,20 @@ class ThreadPoolImpl : public ThreadPool {
struct Impl; struct Impl;
private: private:
// Current public virtual interface does not provide usable
// Current public virtual interface does not provide usable // functionality and thus can not be used internally to
// functionality and thus can not be used internally to // facade different implementations.
// facade different implementations. //
// // We propose a pimpl idiom in order to easily replace the thread pool impl
// We propose a pimpl idiom in order to easily replace the thread pool impl // w/o touching the header file but providing a different .cc potentially
// w/o touching the header file but providing a different .cc potentially // CMake option driven.
// CMake option driven. //
// // Another option is to introduce a Env::MakeThreadPool() virtual interface
// Another option is to introduce a Env::MakeThreadPool() virtual interface // and override the environment. This would require refactoring ThreadPool
// and override the environment. This would require refactoring ThreadPool usage. // usage.
// //
// We can also combine these two approaches // We can also combine these two approaches
std::unique_ptr<Impl> impl_; std::unique_ptr<Impl> impl_;
}; };
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

@ -194,7 +194,6 @@ class Timer {
#endif // NDEBUG #endif // NDEBUG
private: private:
void Run() { void Run() {
InstrumentedMutexLock l(&mutex_); InstrumentedMutexLock l(&mutex_);
@ -302,9 +301,7 @@ class Timer {
repeat_every_us(_repeat_every_us), repeat_every_us(_repeat_every_us),
valid(true) {} valid(true) {}
void Cancel() { void Cancel() { valid = false; }
valid = false;
}
bool IsValid() const { return valid; } bool IsValid() const { return valid; }
}; };
@ -318,8 +315,7 @@ class Timer {
} }
struct RunTimeOrder { struct RunTimeOrder {
bool operator()(const FunctionInfo* f1, bool operator()(const FunctionInfo* f1, const FunctionInfo* f2) {
const FunctionInfo* f2) {
return f1->next_run_time_us > f2->next_run_time_us; return f1->next_run_time_us > f2->next_run_time_us;
} }
}; };
@ -333,9 +329,8 @@ class Timer {
bool running_; bool running_;
bool executing_task_; bool executing_task_;
std::priority_queue<FunctionInfo*, std::priority_queue<FunctionInfo*, std::vector<FunctionInfo*>, RunTimeOrder>
std::vector<FunctionInfo*>, heap_;
RunTimeOrder> heap_;
// In addition to providing a mapping from a function name to a function, // In addition to providing a mapping from a function name to a function,
// it is also responsible for memory management. // it is also responsible for memory management.

@ -23,6 +23,7 @@
#pragma once #pragma once
#include <assert.h> #include <assert.h>
#include <chrono> #include <chrono>
#include <condition_variable> #include <condition_variable>
#include <functional> #include <functional>

@ -25,6 +25,7 @@
// //
#include "util/timer_queue.h" #include "util/timer_queue.h"
#include <future> #include <future>
namespace Timing { namespace Timing {

Loading…
Cancel
Save