dolysis
/
rocksdb
mirror of https://github.com/facebook/rocksdb.git
3
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Peter Dillinger 2022-10-26 12:08:20 -07:00 committed by Facebook GitHub Bot
parent 5f915b447d
commit 7fff38b1fe
47 changed files with 618 additions and 835 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
cache/cache_test.cc vendored
View File

@ -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;

1
cache/fast_lru_cache.h vendored
View File

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

43
util/aligned_buffer.h
View File

@ -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

9
util/autovector.h
View File

@ -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()) {

24
util/autovector_test.cc
View File

@ -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,

20
util/bloom_test.cc
View File

@ -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));
} }

1
util/coding.cc
View File

@ -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"

32
util/coding.h
View File

@ -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;

29
util/coding_test.cc
View File

@ -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);
} }

8
util/comparator.cc
View File

@ -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);

4
util/compression_context_cache.cc
View File

@ -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 {

13
util/concurrent_task_limiter_impl.cc
View File

@ -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);
} }

2
util/concurrent_task_limiter_impl.h
View File

@ -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 {

499
util/crc32c.cc
View File

@ -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[] = {

5
util/crc32c.h
View File

@ -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;

93
util/crc32c_test.cc
View File

@ -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;

3
util/defer.h
View File

@ -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
util/defer_test.cc
View File

@ -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 {

3
util/duplicate_detector.h
View File

@ -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. "

2
util/dynamic_bloom.cc
View File

@ -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
util/dynamic_bloom.h
View File

@ -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;

2
util/dynamic_bloom_test.cc
View File

@ -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);

57
util/filelock_test.cc
View File

@ -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) { return env_->UnlockFile(db_lock); }
bool AssertFileIsLocked() {
return CheckFileLock(/* lock_expected = */ true);
} }
Status UnlockFile(FileLock* db_lock) { bool AssertFileIsNotLocked() {
return env_->UnlockFile(db_lock); return CheckFileLock(/* lock_expected = */ false);
} }
bool AssertFileIsLocked(){ bool CheckFileLock(bool lock_expected) {
return CheckFileLock( /* lock_expected = */ true);
}
bool AssertFileIsNotLocked(){
return CheckFileLock( /* lock_expected = */ false);
}
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

8
util/filter_bench.cc
View File

@ -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;

4
util/hash_test.cc
View File

@ -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();

9
util/heap.h
View File

@ -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_);

40
util/heap_test.cc
View File

@ -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

2
util/kv_map.h
View File

@ -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

7
util/murmurhash.h
View File

@ -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

16
util/mutexlock.h
View File

@ -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() {

1
util/random.cc
View File

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

6
util/random.h
View File

@ -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_(); }

3
util/random_test.cc
View File

@ -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;

7
util/ribbon_test.cc
View File

@ -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));
} }

2
util/slice.cc
View File

@ -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(); }

3
util/slice_test.cc
View File

@ -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);

2
util/status.cc
View File

@ -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 {

2
util/string_util.cc
View File

@ -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"

140
util/thread_list_test.cc
View File

@ -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);

50
util/thread_local.cc
View File

@ -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);

5
util/thread_local.h
View File

@ -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_;

77
util/thread_operation.h
View File

@ -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

121
util/threadpool_imp.cc
View File

@ -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() { impl_->JoinThreads(false); }
}
void ThreadPoolImpl::JoinAllThreads() {
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); }

36
util/threadpool_imp.h
View File

@ -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

13
util/timer.h
View File

@ -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.

1
util/timer_queue.h
View File

@ -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>

1
util/timer_queue_test.cc
View File

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