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

cache/cache_test.cc

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

cache/fast_lru_cache.h

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

util/aligned_buffer.h

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

util/autovector.h

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

util/autovector_test.cc

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

util/bloom_test.cc

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

util/coding.cc

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

util/coding.h

@@ -25,7 +25,7 @@
 
 // Some processors does not allow unaligned access to memory
 #if defined(__sparc)
-  #define PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED
+#define PLATFORM_UNALIGNED_ACCESS_NOT_ALLOWED
 #endif
 
 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
 // nullptr on error.  These routines only look at bytes in the range
 // [p..limit-1]
-extern const char* GetVarint32Ptr(const char* p,const char* limit, uint32_t* v);
-extern const char* GetVarint64Ptr(const char* p,const char* limit, uint64_t* v);
+extern const char* GetVarint32Ptr(const char* p, const char* limit,
+                                  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,
                                         int64_t* value) {
   uint64_t u = 0;
@@ -102,11 +104,9 @@ extern char* EncodeVarint32(char* dst, uint32_t value);
 extern char* EncodeVarint64(char* dst, uint64_t value);
 
 // Internal routine for use by fallback path of GetVarint32Ptr
-extern const char* GetVarint32PtrFallback(const char* p,
-                                          const char* limit,
+extern const char* GetVarint32PtrFallback(const char* p, const char* limit,
                                           uint32_t* value);
-inline const char* GetVarint32Ptr(const char* p,
-                                  const char* limit,
+inline const char* GetVarint32Ptr(const char* p, const char* limit,
                                   uint32_t* value) {
   if (p < limit) {
     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) {
   if (port::kLittleEndian) {
     dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)),
-      sizeof(value));
+                sizeof(value));
   } else {
     char buf[sizeof(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) {
   if (port::kLittleEndian) {
     dst->append(const_cast<const char*>(reinterpret_cast<char*>(&value)),
-      sizeof(value));
+                sizeof(value));
   } else {
     char buf[sizeof(value)];
     EncodeFixed64(buf, value);
@@ -350,7 +350,7 @@ inline Slice GetSliceUntil(Slice* slice, char delimiter) {
   return ret;
 }
 
-template<class T>
+template <class T>
 #ifdef ROCKSDB_UBSAN_RUN
 #if defined(__clang__)
 __attribute__((__no_sanitize__("alignment")))
@@ -358,16 +358,17 @@ __attribute__((__no_sanitize__("alignment")))
 __attribute__((__no_sanitize_undefined__))
 #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)
-  char *nonAlignedMemory = reinterpret_cast<char*>(memory);
+  char* nonAlignedMemory = reinterpret_cast<char*>(memory);
   memcpy(nonAlignedMemory, reinterpret_cast<const char*>(&value), sizeof(T));
 #else
   *memory = value;
 #endif
 }
 
-template<class T>
+template <class T>
 #ifdef ROCKSDB_UBSAN_RUN
 #if defined(__clang__)
 __attribute__((__no_sanitize__("alignment")))
@@ -375,9 +376,10 @@ __attribute__((__no_sanitize__("alignment")))
 __attribute__((__no_sanitize_undefined__))
 #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)
-  char *nonAlignedMemory = reinterpret_cast<char*>(value);
+  char* nonAlignedMemory = reinterpret_cast<char*>(value);
   memcpy(nonAlignedMemory, reinterpret_cast<const char*>(memory), sizeof(T));
 #else
   *value = *memory;

util/coding_test.cc

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

util/comparator.cc

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

util/compression_context_cache.cc

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

util/concurrent_task_limiter_impl.cc

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

util/concurrent_task_limiter_impl.h

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

util/crc32c.cc

@@ -64,301 +64,209 @@ static int arch_ppc_crc32 = 0;
 #endif
 
 static const uint32_t table0_[256] = {
-  0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4,
-  0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
-  0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b,
-  0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
-  0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b,
-  0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
-  0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54,
-  0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b,
-  0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a,
-  0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35,
-  0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5,
-  0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
-  0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45,
-  0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a,
-  0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a,
-  0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595,
-  0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48,
-  0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
-  0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687,
-  0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198,
-  0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927,
-  0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38,
-  0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8,
-  0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
-  0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096,
-  0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789,
-  0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859,
-  0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46,
-  0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9,
-  0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
-  0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36,
-  0x3cdb9bdd, 0xceb018de, 0xdde0eb2a, 0x2f8b6829,
-  0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c,
-  0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93,
-  0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043,
-  0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
-  0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3,
-  0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc,
-  0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c,
-  0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033,
-  0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652,
-  0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
-  0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d,
-  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
-};
+    0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c,
+    0x26a1e7e8, 0xd4ca64eb, 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b,
+    0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24, 0x105ec76f, 0xe235446c,
+    0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
+    0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54, 0x5d1d08bf, 0xaf768bbc,
+    0xbc267848, 0x4e4dfb4b, 0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a,
+    0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35, 0xaa64d611, 0x580f5512,
+    0x4b5fa6e6, 0xb93425e5, 0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
+    0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad,
+    0x1642ae59, 0xe4292d5a, 0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a,
+    0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595, 0x417b1dbc, 0xb3109ebf,
+    0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
+    0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c, 0xfe53516f,
+    0xed03a29b, 0x1f682198, 0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927,
+    0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38, 0xdbfc821c, 0x2997011f,
+    0x3ac7f2eb, 0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
+    0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096, 0xa65c047d, 0x5437877e,
+    0x4767748a, 0xb50cf789, 0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859,
+    0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46, 0x7198540d, 0x83f3d70e,
+    0x90a324fa, 0x62c8a7f9, 0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
+    0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de,
+    0xdde0eb2a, 0x2f8b6829, 0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c,
+    0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93, 0x082f63b7, 0xfa44e0b4,
+    0xe9141340, 0x1b7f9043, 0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
+    0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x55326b08, 0xa759e80b,
+    0xb4091bff, 0x466298fc, 0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c,
+    0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033, 0xa24bb5a6, 0x502036a5,
+    0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
+    0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 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] = {
-  0x00000000, 0x13a29877, 0x274530ee, 0x34e7a899,
-  0x4e8a61dc, 0x5d28f9ab, 0x69cf5132, 0x7a6dc945,
-  0x9d14c3b8, 0x8eb65bcf, 0xba51f356, 0xa9f36b21,
-  0xd39ea264, 0xc03c3a13, 0xf4db928a, 0xe7790afd,
-  0x3fc5f181, 0x2c6769f6, 0x1880c16f, 0x0b225918,
-  0x714f905d, 0x62ed082a, 0x560aa0b3, 0x45a838c4,
-  0xa2d13239, 0xb173aa4e, 0x859402d7, 0x96369aa0,
-  0xec5b53e5, 0xfff9cb92, 0xcb1e630b, 0xd8bcfb7c,
-  0x7f8be302, 0x6c297b75, 0x58ced3ec, 0x4b6c4b9b,
-  0x310182de, 0x22a31aa9, 0x1644b230, 0x05e62a47,
-  0xe29f20ba, 0xf13db8cd, 0xc5da1054, 0xd6788823,
-  0xac154166, 0xbfb7d911, 0x8b507188, 0x98f2e9ff,
-  0x404e1283, 0x53ec8af4, 0x670b226d, 0x74a9ba1a,
-  0x0ec4735f, 0x1d66eb28, 0x298143b1, 0x3a23dbc6,
-  0xdd5ad13b, 0xcef8494c, 0xfa1fe1d5, 0xe9bd79a2,
-  0x93d0b0e7, 0x80722890, 0xb4958009, 0xa737187e,
-  0xff17c604, 0xecb55e73, 0xd852f6ea, 0xcbf06e9d,
-  0xb19da7d8, 0xa23f3faf, 0x96d89736, 0x857a0f41,
-  0x620305bc, 0x71a19dcb, 0x45463552, 0x56e4ad25,
-  0x2c896460, 0x3f2bfc17, 0x0bcc548e, 0x186eccf9,
-  0xc0d23785, 0xd370aff2, 0xe797076b, 0xf4359f1c,
-  0x8e585659, 0x9dface2e, 0xa91d66b7, 0xbabffec0,
-  0x5dc6f43d, 0x4e646c4a, 0x7a83c4d3, 0x69215ca4,
-  0x134c95e1, 0x00ee0d96, 0x3409a50f, 0x27ab3d78,
-  0x809c2506, 0x933ebd71, 0xa7d915e8, 0xb47b8d9f,
-  0xce1644da, 0xddb4dcad, 0xe9537434, 0xfaf1ec43,
-  0x1d88e6be, 0x0e2a7ec9, 0x3acdd650, 0x296f4e27,
-  0x53028762, 0x40a01f15, 0x7447b78c, 0x67e52ffb,
-  0xbf59d487, 0xacfb4cf0, 0x981ce469, 0x8bbe7c1e,
-  0xf1d3b55b, 0xe2712d2c, 0xd69685b5, 0xc5341dc2,
-  0x224d173f, 0x31ef8f48, 0x050827d1, 0x16aabfa6,
-  0x6cc776e3, 0x7f65ee94, 0x4b82460d, 0x5820de7a,
-  0xfbc3faf9, 0xe861628e, 0xdc86ca17, 0xcf245260,
-  0xb5499b25, 0xa6eb0352, 0x920cabcb, 0x81ae33bc,
-  0x66d73941, 0x7575a136, 0x419209af, 0x523091d8,
-  0x285d589d, 0x3bffc0ea, 0x0f186873, 0x1cbaf004,
-  0xc4060b78, 0xd7a4930f, 0xe3433b96, 0xf0e1a3e1,
-  0x8a8c6aa4, 0x992ef2d3, 0xadc95a4a, 0xbe6bc23d,
-  0x5912c8c0, 0x4ab050b7, 0x7e57f82e, 0x6df56059,
-  0x1798a91c, 0x043a316b, 0x30dd99f2, 0x237f0185,
-  0x844819fb, 0x97ea818c, 0xa30d2915, 0xb0afb162,
-  0xcac27827, 0xd960e050, 0xed8748c9, 0xfe25d0be,
-  0x195cda43, 0x0afe4234, 0x3e19eaad, 0x2dbb72da,
-  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
-};
+    0x00000000, 0x13a29877, 0x274530ee, 0x34e7a899, 0x4e8a61dc, 0x5d28f9ab,
+    0x69cf5132, 0x7a6dc945, 0x9d14c3b8, 0x8eb65bcf, 0xba51f356, 0xa9f36b21,
+    0xd39ea264, 0xc03c3a13, 0xf4db928a, 0xe7790afd, 0x3fc5f181, 0x2c6769f6,
+    0x1880c16f, 0x0b225918, 0x714f905d, 0x62ed082a, 0x560aa0b3, 0x45a838c4,
+    0xa2d13239, 0xb173aa4e, 0x859402d7, 0x96369aa0, 0xec5b53e5, 0xfff9cb92,
+    0xcb1e630b, 0xd8bcfb7c, 0x7f8be302, 0x6c297b75, 0x58ced3ec, 0x4b6c4b9b,
+    0x310182de, 0x22a31aa9, 0x1644b230, 0x05e62a47, 0xe29f20ba, 0xf13db8cd,
+    0xc5da1054, 0xd6788823, 0xac154166, 0xbfb7d911, 0x8b507188, 0x98f2e9ff,
+    0x404e1283, 0x53ec8af4, 0x670b226d, 0x74a9ba1a, 0x0ec4735f, 0x1d66eb28,
+    0x298143b1, 0x3a23dbc6, 0xdd5ad13b, 0xcef8494c, 0xfa1fe1d5, 0xe9bd79a2,
+    0x93d0b0e7, 0x80722890, 0xb4958009, 0xa737187e, 0xff17c604, 0xecb55e73,
+    0xd852f6ea, 0xcbf06e9d, 0xb19da7d8, 0xa23f3faf, 0x96d89736, 0x857a0f41,
+    0x620305bc, 0x71a19dcb, 0x45463552, 0x56e4ad25, 0x2c896460, 0x3f2bfc17,
+    0x0bcc548e, 0x186eccf9, 0xc0d23785, 0xd370aff2, 0xe797076b, 0xf4359f1c,
+    0x8e585659, 0x9dface2e, 0xa91d66b7, 0xbabffec0, 0x5dc6f43d, 0x4e646c4a,
+    0x7a83c4d3, 0x69215ca4, 0x134c95e1, 0x00ee0d96, 0x3409a50f, 0x27ab3d78,
+    0x809c2506, 0x933ebd71, 0xa7d915e8, 0xb47b8d9f, 0xce1644da, 0xddb4dcad,
+    0xe9537434, 0xfaf1ec43, 0x1d88e6be, 0x0e2a7ec9, 0x3acdd650, 0x296f4e27,
+    0x53028762, 0x40a01f15, 0x7447b78c, 0x67e52ffb, 0xbf59d487, 0xacfb4cf0,
+    0x981ce469, 0x8bbe7c1e, 0xf1d3b55b, 0xe2712d2c, 0xd69685b5, 0xc5341dc2,
+    0x224d173f, 0x31ef8f48, 0x050827d1, 0x16aabfa6, 0x6cc776e3, 0x7f65ee94,
+    0x4b82460d, 0x5820de7a, 0xfbc3faf9, 0xe861628e, 0xdc86ca17, 0xcf245260,
+    0xb5499b25, 0xa6eb0352, 0x920cabcb, 0x81ae33bc, 0x66d73941, 0x7575a136,
+    0x419209af, 0x523091d8, 0x285d589d, 0x3bffc0ea, 0x0f186873, 0x1cbaf004,
+    0xc4060b78, 0xd7a4930f, 0xe3433b96, 0xf0e1a3e1, 0x8a8c6aa4, 0x992ef2d3,
+    0xadc95a4a, 0xbe6bc23d, 0x5912c8c0, 0x4ab050b7, 0x7e57f82e, 0x6df56059,
+    0x1798a91c, 0x043a316b, 0x30dd99f2, 0x237f0185, 0x844819fb, 0x97ea818c,
+    0xa30d2915, 0xb0afb162, 0xcac27827, 0xd960e050, 0xed8748c9, 0xfe25d0be,
+    0x195cda43, 0x0afe4234, 0x3e19eaad, 0x2dbb72da, 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] = {
-  0x00000000, 0xa541927e, 0x4f6f520d, 0xea2ec073,
-  0x9edea41a, 0x3b9f3664, 0xd1b1f617, 0x74f06469,
-  0x38513ec5, 0x9d10acbb, 0x773e6cc8, 0xd27ffeb6,
-  0xa68f9adf, 0x03ce08a1, 0xe9e0c8d2, 0x4ca15aac,
-  0x70a27d8a, 0xd5e3eff4, 0x3fcd2f87, 0x9a8cbdf9,
-  0xee7cd990, 0x4b3d4bee, 0xa1138b9d, 0x045219e3,
-  0x48f3434f, 0xedb2d131, 0x079c1142, 0xa2dd833c,
-  0xd62de755, 0x736c752b, 0x9942b558, 0x3c032726,
-  0xe144fb14, 0x4405696a, 0xae2ba919, 0x0b6a3b67,
-  0x7f9a5f0e, 0xdadbcd70, 0x30f50d03, 0x95b49f7d,
-  0xd915c5d1, 0x7c5457af, 0x967a97dc, 0x333b05a2,
-  0x47cb61cb, 0xe28af3b5, 0x08a433c6, 0xade5a1b8,
-  0x91e6869e, 0x34a714e0, 0xde89d493, 0x7bc846ed,
-  0x0f382284, 0xaa79b0fa, 0x40577089, 0xe516e2f7,
-  0xa9b7b85b, 0x0cf62a25, 0xe6d8ea56, 0x43997828,
-  0x37691c41, 0x92288e3f, 0x78064e4c, 0xdd47dc32,
-  0xc76580d9, 0x622412a7, 0x880ad2d4, 0x2d4b40aa,
-  0x59bb24c3, 0xfcfab6bd, 0x16d476ce, 0xb395e4b0,
-  0xff34be1c, 0x5a752c62, 0xb05bec11, 0x151a7e6f,
-  0x61ea1a06, 0xc4ab8878, 0x2e85480b, 0x8bc4da75,
-  0xb7c7fd53, 0x12866f2d, 0xf8a8af5e, 0x5de93d20,
-  0x29195949, 0x8c58cb37, 0x66760b44, 0xc337993a,
-  0x8f96c396, 0x2ad751e8, 0xc0f9919b, 0x65b803e5,
-  0x1148678c, 0xb409f5f2, 0x5e273581, 0xfb66a7ff,
-  0x26217bcd, 0x8360e9b3, 0x694e29c0, 0xcc0fbbbe,
-  0xb8ffdfd7, 0x1dbe4da9, 0xf7908dda, 0x52d11fa4,
-  0x1e704508, 0xbb31d776, 0x511f1705, 0xf45e857b,
-  0x80aee112, 0x25ef736c, 0xcfc1b31f, 0x6a802161,
-  0x56830647, 0xf3c29439, 0x19ec544a, 0xbcadc634,
-  0xc85da25d, 0x6d1c3023, 0x8732f050, 0x2273622e,
-  0x6ed23882, 0xcb93aafc, 0x21bd6a8f, 0x84fcf8f1,
-  0xf00c9c98, 0x554d0ee6, 0xbf63ce95, 0x1a225ceb,
-  0x8b277743, 0x2e66e53d, 0xc448254e, 0x6109b730,
-  0x15f9d359, 0xb0b84127, 0x5a968154, 0xffd7132a,
-  0xb3764986, 0x1637dbf8, 0xfc191b8b, 0x595889f5,
-  0x2da8ed9c, 0x88e97fe2, 0x62c7bf91, 0xc7862def,
-  0xfb850ac9, 0x5ec498b7, 0xb4ea58c4, 0x11abcaba,
-  0x655baed3, 0xc01a3cad, 0x2a34fcde, 0x8f756ea0,
-  0xc3d4340c, 0x6695a672, 0x8cbb6601, 0x29faf47f,
-  0x5d0a9016, 0xf84b0268, 0x1265c21b, 0xb7245065,
-  0x6a638c57, 0xcf221e29, 0x250cde5a, 0x804d4c24,
-  0xf4bd284d, 0x51fcba33, 0xbbd27a40, 0x1e93e83e,
-  0x5232b292, 0xf77320ec, 0x1d5de09f, 0xb81c72e1,
-  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
-};
+    0x00000000, 0xa541927e, 0x4f6f520d, 0xea2ec073, 0x9edea41a, 0x3b9f3664,
+    0xd1b1f617, 0x74f06469, 0x38513ec5, 0x9d10acbb, 0x773e6cc8, 0xd27ffeb6,
+    0xa68f9adf, 0x03ce08a1, 0xe9e0c8d2, 0x4ca15aac, 0x70a27d8a, 0xd5e3eff4,
+    0x3fcd2f87, 0x9a8cbdf9, 0xee7cd990, 0x4b3d4bee, 0xa1138b9d, 0x045219e3,
+    0x48f3434f, 0xedb2d131, 0x079c1142, 0xa2dd833c, 0xd62de755, 0x736c752b,
+    0x9942b558, 0x3c032726, 0xe144fb14, 0x4405696a, 0xae2ba919, 0x0b6a3b67,
+    0x7f9a5f0e, 0xdadbcd70, 0x30f50d03, 0x95b49f7d, 0xd915c5d1, 0x7c5457af,
+    0x967a97dc, 0x333b05a2, 0x47cb61cb, 0xe28af3b5, 0x08a433c6, 0xade5a1b8,
+    0x91e6869e, 0x34a714e0, 0xde89d493, 0x7bc846ed, 0x0f382284, 0xaa79b0fa,
+    0x40577089, 0xe516e2f7, 0xa9b7b85b, 0x0cf62a25, 0xe6d8ea56, 0x43997828,
+    0x37691c41, 0x92288e3f, 0x78064e4c, 0xdd47dc32, 0xc76580d9, 0x622412a7,
+    0x880ad2d4, 0x2d4b40aa, 0x59bb24c3, 0xfcfab6bd, 0x16d476ce, 0xb395e4b0,
+    0xff34be1c, 0x5a752c62, 0xb05bec11, 0x151a7e6f, 0x61ea1a06, 0xc4ab8878,
+    0x2e85480b, 0x8bc4da75, 0xb7c7fd53, 0x12866f2d, 0xf8a8af5e, 0x5de93d20,
+    0x29195949, 0x8c58cb37, 0x66760b44, 0xc337993a, 0x8f96c396, 0x2ad751e8,
+    0xc0f9919b, 0x65b803e5, 0x1148678c, 0xb409f5f2, 0x5e273581, 0xfb66a7ff,
+    0x26217bcd, 0x8360e9b3, 0x694e29c0, 0xcc0fbbbe, 0xb8ffdfd7, 0x1dbe4da9,
+    0xf7908dda, 0x52d11fa4, 0x1e704508, 0xbb31d776, 0x511f1705, 0xf45e857b,
+    0x80aee112, 0x25ef736c, 0xcfc1b31f, 0x6a802161, 0x56830647, 0xf3c29439,
+    0x19ec544a, 0xbcadc634, 0xc85da25d, 0x6d1c3023, 0x8732f050, 0x2273622e,
+    0x6ed23882, 0xcb93aafc, 0x21bd6a8f, 0x84fcf8f1, 0xf00c9c98, 0x554d0ee6,
+    0xbf63ce95, 0x1a225ceb, 0x8b277743, 0x2e66e53d, 0xc448254e, 0x6109b730,
+    0x15f9d359, 0xb0b84127, 0x5a968154, 0xffd7132a, 0xb3764986, 0x1637dbf8,
+    0xfc191b8b, 0x595889f5, 0x2da8ed9c, 0x88e97fe2, 0x62c7bf91, 0xc7862def,
+    0xfb850ac9, 0x5ec498b7, 0xb4ea58c4, 0x11abcaba, 0x655baed3, 0xc01a3cad,
+    0x2a34fcde, 0x8f756ea0, 0xc3d4340c, 0x6695a672, 0x8cbb6601, 0x29faf47f,
+    0x5d0a9016, 0xf84b0268, 0x1265c21b, 0xb7245065, 0x6a638c57, 0xcf221e29,
+    0x250cde5a, 0x804d4c24, 0xf4bd284d, 0x51fcba33, 0xbbd27a40, 0x1e93e83e,
+    0x5232b292, 0xf77320ec, 0x1d5de09f, 0xb81c72e1, 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] = {
-  0x00000000, 0xdd45aab8, 0xbf672381, 0x62228939,
-  0x7b2231f3, 0xa6679b4b, 0xc4451272, 0x1900b8ca,
-  0xf64463e6, 0x2b01c95e, 0x49234067, 0x9466eadf,
-  0x8d665215, 0x5023f8ad, 0x32017194, 0xef44db2c,
-  0xe964b13d, 0x34211b85, 0x560392bc, 0x8b463804,
-  0x924680ce, 0x4f032a76, 0x2d21a34f, 0xf06409f7,
-  0x1f20d2db, 0xc2657863, 0xa047f15a, 0x7d025be2,
-  0x6402e328, 0xb9474990, 0xdb65c0a9, 0x06206a11,
-  0xd725148b, 0x0a60be33, 0x6842370a, 0xb5079db2,
-  0xac072578, 0x71428fc0, 0x136006f9, 0xce25ac41,
-  0x2161776d, 0xfc24ddd5, 0x9e0654ec, 0x4343fe54,
-  0x5a43469e, 0x8706ec26, 0xe524651f, 0x3861cfa7,
-  0x3e41a5b6, 0xe3040f0e, 0x81268637, 0x5c632c8f,
-  0x45639445, 0x98263efd, 0xfa04b7c4, 0x27411d7c,
-  0xc805c650, 0x15406ce8, 0x7762e5d1, 0xaa274f69,
-  0xb327f7a3, 0x6e625d1b, 0x0c40d422, 0xd1057e9a,
-  0xaba65fe7, 0x76e3f55f, 0x14c17c66, 0xc984d6de,
-  0xd0846e14, 0x0dc1c4ac, 0x6fe34d95, 0xb2a6e72d,
-  0x5de23c01, 0x80a796b9, 0xe2851f80, 0x3fc0b538,
-  0x26c00df2, 0xfb85a74a, 0x99a72e73, 0x44e284cb,
-  0x42c2eeda, 0x9f874462, 0xfda5cd5b, 0x20e067e3,
-  0x39e0df29, 0xe4a57591, 0x8687fca8, 0x5bc25610,
-  0xb4868d3c, 0x69c32784, 0x0be1aebd, 0xd6a40405,
-  0xcfa4bccf, 0x12e11677, 0x70c39f4e, 0xad8635f6,
-  0x7c834b6c, 0xa1c6e1d4, 0xc3e468ed, 0x1ea1c255,
-  0x07a17a9f, 0xdae4d027, 0xb8c6591e, 0x6583f3a6,
-  0x8ac7288a, 0x57828232, 0x35a00b0b, 0xe8e5a1b3,
-  0xf1e51979, 0x2ca0b3c1, 0x4e823af8, 0x93c79040,
-  0x95e7fa51, 0x48a250e9, 0x2a80d9d0, 0xf7c57368,
-  0xeec5cba2, 0x3380611a, 0x51a2e823, 0x8ce7429b,
-  0x63a399b7, 0xbee6330f, 0xdcc4ba36, 0x0181108e,
-  0x1881a844, 0xc5c402fc, 0xa7e68bc5, 0x7aa3217d,
-  0x52a0c93f, 0x8fe56387, 0xedc7eabe, 0x30824006,
-  0x2982f8cc, 0xf4c75274, 0x96e5db4d, 0x4ba071f5,
-  0xa4e4aad9, 0x79a10061, 0x1b838958, 0xc6c623e0,
-  0xdfc69b2a, 0x02833192, 0x60a1b8ab, 0xbde41213,
-  0xbbc47802, 0x6681d2ba, 0x04a35b83, 0xd9e6f13b,
-  0xc0e649f1, 0x1da3e349, 0x7f816a70, 0xa2c4c0c8,
-  0x4d801be4, 0x90c5b15c, 0xf2e73865, 0x2fa292dd,
-  0x36a22a17, 0xebe780af, 0x89c50996, 0x5480a32e,
-  0x8585ddb4, 0x58c0770c, 0x3ae2fe35, 0xe7a7548d,
-  0xfea7ec47, 0x23e246ff, 0x41c0cfc6, 0x9c85657e,
-  0x73c1be52, 0xae8414ea, 0xcca69dd3, 0x11e3376b,
-  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
-};
+    0x00000000, 0xdd45aab8, 0xbf672381, 0x62228939, 0x7b2231f3, 0xa6679b4b,
+    0xc4451272, 0x1900b8ca, 0xf64463e6, 0x2b01c95e, 0x49234067, 0x9466eadf,
+    0x8d665215, 0x5023f8ad, 0x32017194, 0xef44db2c, 0xe964b13d, 0x34211b85,
+    0x560392bc, 0x8b463804, 0x924680ce, 0x4f032a76, 0x2d21a34f, 0xf06409f7,
+    0x1f20d2db, 0xc2657863, 0xa047f15a, 0x7d025be2, 0x6402e328, 0xb9474990,
+    0xdb65c0a9, 0x06206a11, 0xd725148b, 0x0a60be33, 0x6842370a, 0xb5079db2,
+    0xac072578, 0x71428fc0, 0x136006f9, 0xce25ac41, 0x2161776d, 0xfc24ddd5,
+    0x9e0654ec, 0x4343fe54, 0x5a43469e, 0x8706ec26, 0xe524651f, 0x3861cfa7,
+    0x3e41a5b6, 0xe3040f0e, 0x81268637, 0x5c632c8f, 0x45639445, 0x98263efd,
+    0xfa04b7c4, 0x27411d7c, 0xc805c650, 0x15406ce8, 0x7762e5d1, 0xaa274f69,
+    0xb327f7a3, 0x6e625d1b, 0x0c40d422, 0xd1057e9a, 0xaba65fe7, 0x76e3f55f,
+    0x14c17c66, 0xc984d6de, 0xd0846e14, 0x0dc1c4ac, 0x6fe34d95, 0xb2a6e72d,
+    0x5de23c01, 0x80a796b9, 0xe2851f80, 0x3fc0b538, 0x26c00df2, 0xfb85a74a,
+    0x99a72e73, 0x44e284cb, 0x42c2eeda, 0x9f874462, 0xfda5cd5b, 0x20e067e3,
+    0x39e0df29, 0xe4a57591, 0x8687fca8, 0x5bc25610, 0xb4868d3c, 0x69c32784,
+    0x0be1aebd, 0xd6a40405, 0xcfa4bccf, 0x12e11677, 0x70c39f4e, 0xad8635f6,
+    0x7c834b6c, 0xa1c6e1d4, 0xc3e468ed, 0x1ea1c255, 0x07a17a9f, 0xdae4d027,
+    0xb8c6591e, 0x6583f3a6, 0x8ac7288a, 0x57828232, 0x35a00b0b, 0xe8e5a1b3,
+    0xf1e51979, 0x2ca0b3c1, 0x4e823af8, 0x93c79040, 0x95e7fa51, 0x48a250e9,
+    0x2a80d9d0, 0xf7c57368, 0xeec5cba2, 0x3380611a, 0x51a2e823, 0x8ce7429b,
+    0x63a399b7, 0xbee6330f, 0xdcc4ba36, 0x0181108e, 0x1881a844, 0xc5c402fc,
+    0xa7e68bc5, 0x7aa3217d, 0x52a0c93f, 0x8fe56387, 0xedc7eabe, 0x30824006,
+    0x2982f8cc, 0xf4c75274, 0x96e5db4d, 0x4ba071f5, 0xa4e4aad9, 0x79a10061,
+    0x1b838958, 0xc6c623e0, 0xdfc69b2a, 0x02833192, 0x60a1b8ab, 0xbde41213,
+    0xbbc47802, 0x6681d2ba, 0x04a35b83, 0xd9e6f13b, 0xc0e649f1, 0x1da3e349,
+    0x7f816a70, 0xa2c4c0c8, 0x4d801be4, 0x90c5b15c, 0xf2e73865, 0x2fa292dd,
+    0x36a22a17, 0xebe780af, 0x89c50996, 0x5480a32e, 0x8585ddb4, 0x58c0770c,
+    0x3ae2fe35, 0xe7a7548d, 0xfea7ec47, 0x23e246ff, 0x41c0cfc6, 0x9c85657e,
+    0x73c1be52, 0xae8414ea, 0xcca69dd3, 0x11e3376b, 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
-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));
 }
 
 #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));
 }
 #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));
   *p += 4;
-  *l = table3_[c & 0xff] ^
-  table2_[(c >> 8) & 0xff] ^
-  table1_[(c >> 16) & 0xff] ^
-  table0_[c >> 24];
+  *l = table3_[c & 0xff] ^ table2_[(c >> 8) & 0xff] ^
+       table1_[(c >> 16) & 0xff] ^ table0_[c >> 24];
   // DO it twice.
   c = static_cast<uint32_t>(*l ^ LE_LOAD32(*p));
   *p += 4;
-  *l = table3_[c & 0xff] ^
-  table2_[(c >> 8) & 0xff] ^
-  table1_[(c >> 16) & 0xff] ^
-  table0_[c >> 24];
+  *l = table3_[c & 0xff] ^ table2_[(c >> 8) & 0xff] ^
+       table1_[(c >> 16) & 0xff] ^ table0_[c >> 24];
 }
 
 #if (!(defined(HAVE_POWER8) && defined(HAS_ALTIVEC))) && \
         (!defined(HAVE_ARM64_CRC)) ||                    \
     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
   Slow_CRC32(l, p);
 #elif defined(__LP64__) || defined(_WIN64)
@@ -373,21 +281,20 @@ static inline void Fast_CRC32(uint64_t* l, uint8_t const **p) {
 }
 #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) {
-
-  const uint8_t *p = reinterpret_cast<const uint8_t *>(buf);
-  const uint8_t *e = p + size;
+  const uint8_t* p = reinterpret_cast<const uint8_t*>(buf);
+  const uint8_t* e = p + size;
   uint64_t l = crc ^ 0xffffffffu;
 
 // Align n to (1 << m) byte boundary
-#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 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)
 
   // Point x at first 16-byte aligned byte in string.  This might be
   // 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
-  while ((e-p) >= 16) {
+  while ((e - p) >= 16) {
     CRC32(&l, &p);
     CRC32(&l, &p);
   }
   // Process bytes 8 at a time
-  while ((e-p) >= 8) {
+  while ((e - p) >= 8) {
     CRC32(&l, &p);
   }
   // Process the last few bytes
@@ -440,8 +347,8 @@ static bool isSSE42() {
 
 static bool isPCLMULQDQ() {
 #ifndef HAVE_SSE42
-// in build_detect_platform we set this macro when both SSE42 and PCLMULQDQ are
-// supported by compiler
+  // in build_detect_platform we set this macro when both SSE42 and PCLMULQDQ
+  // are supported by compiler
   return false;
 #elif defined(__GNUC__) && defined(__x86_64__) && !defined(IOS_CROSS_COMPILE)
   uint32_t c_;
@@ -462,8 +369,8 @@ static bool isPCLMULQDQ() {
 using Function = uint32_t (*)(uint32_t, const char*, size_t);
 
 #if defined(HAVE_POWER8) && defined(HAS_ALTIVEC)
-uint32_t ExtendPPCImpl(uint32_t crc, const char *buf, size_t size) {
-  return crc32c_ppc(crc, (const unsigned char *)buf, size);
+uint32_t ExtendPPCImpl(uint32_t crc, const char* buf, size_t size) {
+  return crc32c_ppc(crc, (const unsigned char*)buf, size);
 }
 
 #if __linux__
@@ -500,8 +407,8 @@ static bool isAltiVec() {
 #endif
 
 #if defined(HAVE_ARM64_CRC)
-uint32_t ExtendARMImpl(uint32_t crc, const char *buf, size_t size) {
-  return crc32c_arm64(crc, (const unsigned char *)buf, size);
+uint32_t ExtendARMImpl(uint32_t crc, const char* buf, size_t size) {
+  return crc32c_arm64(crc, (const unsigned char*)buf, size);
 }
 #endif
 
@@ -534,14 +441,12 @@ std::string IsFastCrc32Supported() {
 #endif
   if (has_fast_crc) {
     fast_zero_msg.append("Supported on " + arch);
-  }
-  else {
+  } else {
     fast_zero_msg.append("Not supported on " + arch);
   }
   return fast_zero_msg;
 }
 
-
 /*
  * Copyright 2016 Ferry Toth, Exalon Delft BV, The Netherlands
  *  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"
  * 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
 
 #define CRCtriplet(crc, buf, offset)                  \
@@ -582,10 +488,9 @@ std::string IsFastCrc32Supported() {
   crc##0 = _mm_crc32_u64(crc##0, *(buf##0 + 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));
 
-
 // Numbers taken directly from intel whitepaper.
 // clang-format off
 const uint64_t clmul_constants[] = {

util/crc32c.h

@@ -10,6 +10,7 @@
 #pragma once
 #include <stddef.h>
 #include <stdint.h>
+
 #include <string>
 
 #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);
 
 // Return the crc32c of data[0,n-1]
-inline uint32_t Value(const char* data, size_t n) {
-  return Extend(0, data, n);
-}
+inline uint32_t Value(const char* data, size_t n) { return Extend(0, data, n); }
 
 static const uint32_t kMaskDelta = 0xa282ead8ul;
 

util/crc32c_test.cc

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

util/defer.h

@@ -37,7 +37,8 @@ namespace ROCKSDB_NAMESPACE {
 //    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
-// 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 {
  public:
   explicit Defer(std::function<void()>&& fn) : fn_(std::move(fn)) {}

util/defer_test.cc

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

util/duplicate_detector.h

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

util/dynamic_bloom.cc

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

util/dynamic_bloom.h

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

util/dynamic_bloom_test.cc

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

util/filelock_test.cc

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

util/filter_bench.cc

@@ -195,7 +195,7 @@ struct KeyMaker {
       len += FastRange32(
           (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
     // 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
@@ -378,9 +378,9 @@ void FilterBench::Go() {
                                     FLAGS_average_keys_per_filter);
   const uint32_t variance_offset = variance_range / 2;
 
-  const std::vector<TestMode> &testModes =
-      FLAGS_best_case ? bestCaseTestModes
-                      : FLAGS_quick ? quickTestModes : allTestModes;
+  const std::vector<TestMode> &testModes = FLAGS_best_case ? bestCaseTestModes
+                                           : FLAGS_quick   ? quickTestModes
+                                                           : allTestModes;
 
   m_queries_ = FLAGS_m_queries;
   double working_mem_size_mb = FLAGS_working_mem_size_mb;

util/hash_test.cc

@@ -547,7 +547,7 @@ TEST(FastRangeGenericTest, Values) {
             uint16_t{6234});
   // Not recommended for typical use because for example this could fail on
   // 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{6234});
 }
@@ -843,7 +843,7 @@ TEST(MathTest, CodingGeneric) {
   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",
           static_cast<int>(ROCKSDB_NAMESPACE::GetSliceNPHash64("RocksDB")));
   ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();

util/heap.h

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

util/heap_test.cc

@@ -31,8 +31,7 @@ namespace ROCKSDB_NAMESPACE {
 using HeapTestValue = uint64_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) {
   // 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::uniform_int_distribution<HeapTestValue> value_dist(0, MAX_VALUE);
   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;
   for (int64_t i = 0; i < FLAGS_iters; ++i) {
     if (size == 0) {
       draining = false;
     }
 
-    if (!draining &&
-        (size == 0 || std::bernoulli_distribution(0.4)(rng))) {
+    if (!draining && (size == 0 || std::bernoulli_distribution(0.4)(rng))) {
       // insert
       HeapTestValue val = value_dist(rng);
       heap.push(val);
@@ -104,30 +102,22 @@ TEST_P(HeapTest, Test) {
 }
 
 // Basic test, MAX_VALUE = 3*MAX_HEAP_SIZE (occasional duplicates)
-INSTANTIATE_TEST_CASE_P(
-  Basic, HeapTest,
-  ::testing::Values(Params(1000, 3000, 0x1b575cf05b708945))
-);
+INSTANTIATE_TEST_CASE_P(Basic, HeapTest,
+                        ::testing::Values(Params(1000, 3000,
+                                                 0x1b575cf05b708945)));
 // Mid-size heap with small values (many duplicates)
-INSTANTIATE_TEST_CASE_P(
-  SmallValues, HeapTest,
-  ::testing::Values(Params(100, 10, 0x5ae213f7bd5dccd0))
-);
+INSTANTIATE_TEST_CASE_P(SmallValues, HeapTest,
+                        ::testing::Values(Params(100, 10, 0x5ae213f7bd5dccd0)));
 // Small heap, large value range (no duplicates)
-INSTANTIATE_TEST_CASE_P(
-  SmallHeap, HeapTest,
-  ::testing::Values(Params(10, ULLONG_MAX, 0x3e1fa8f4d01707cf))
-);
+INSTANTIATE_TEST_CASE_P(SmallHeap, HeapTest,
+                        ::testing::Values(Params(10, ULLONG_MAX,
+                                                 0x3e1fa8f4d01707cf)));
 // Two-element heap
-INSTANTIATE_TEST_CASE_P(
-  TwoElementHeap, HeapTest,
-  ::testing::Values(Params(2, 5, 0x4b5e13ea988c6abc))
-);
+INSTANTIATE_TEST_CASE_P(TwoElementHeap, HeapTest,
+                        ::testing::Values(Params(2, 5, 0x4b5e13ea988c6abc)));
 // One-element heap
-INSTANTIATE_TEST_CASE_P(
-  OneElementHeap, HeapTest,
-  ::testing::Values(Params(1, 3, 0x176a1019ab0b612e))
-);
+INSTANTIATE_TEST_CASE_P(OneElementHeap, HeapTest,
+                        ::testing::Values(Params(1, 3, 0x176a1019ab0b612e)));
 
 }  // namespace ROCKSDB_NAMESPACE
 

util/kv_map.h

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

util/murmurhash.h

@@ -11,23 +11,24 @@
 */
 #pragma once
 #include <stdint.h>
+
 #include "rocksdb/slice.h"
 
 #if defined(__x86_64__)
 #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
 using murmur_t = uint64_t;
 
 #elif defined(__i386__)
 #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
 using murmur_t = unsigned int;
 
 #else
 #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
 using murmur_t = unsigned int;
 #endif

util/mutexlock.h

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

util/random.cc

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

util/random.h

@@ -85,9 +85,7 @@ class Random {
   // Skewed: pick "base" uniformly from range [0,max_log] and then
   // 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.
-  uint32_t Skewed(int max_log) {
-    return Uniform(1 << Uniform(max_log + 1));
-  }
+  uint32_t Skewed(int max_log) { return Uniform(1 << Uniform(max_log + 1)); }
 
   // Returns a random string of length "len"
   std::string RandomString(int len);
@@ -153,7 +151,7 @@ class Random64 {
   std::mt19937_64 generator_;
 
  public:
-  explicit Random64(uint64_t s) : generator_(s) { }
+  explicit Random64(uint64_t s) : generator_(s) {}
 
   // Generates the next random number
   uint64_t Next() { return generator_(); }

util/random_test.cc

@@ -7,11 +7,12 @@
 // 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.
 
+#include "util/random.h"
+
 #include <cstring>
 #include <vector>
 
 #include "test_util/testharness.h"
-#include "util/random.h"
 
 using ROCKSDB_NAMESPACE::Random;
 

util/ribbon_test.cc

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

util/slice.cc

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

util/slice_test.cc

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

util/status.cc

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

util/string_util.cc

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

util/thread_list_test.cc

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

util/thread_local.cc

@@ -8,10 +8,12 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "util/thread_local.h"
-#include "util/mutexlock.h"
-#include "port/likely.h"
+
 #include <stdlib.h>
 
+#include "port/likely.h"
+#include "util/mutexlock.h"
+
 namespace ROCKSDB_NAMESPACE {
 
 struct Entry {
@@ -39,10 +41,7 @@ class StaticMeta;
 //     ---------------------------------------------------
 struct ThreadData {
   explicit ThreadData(ThreadLocalPtr::StaticMeta* _inst)
-    : entries(),
-      next(nullptr),
-      prev(nullptr),
-      inst(_inst) {}
+      : entries(), next(nullptr), prev(nullptr), inst(_inst) {}
   std::vector<Entry> entries;
   ThreadData* next;
   ThreadData* prev;
@@ -50,7 +49,7 @@ struct ThreadData {
 };
 
 class ThreadLocalPtr::StaticMeta {
-public:
+ public:
   StaticMeta();
 
   // Return the next available Id
@@ -107,7 +106,7 @@ public:
   // should be used.  One example is OnThreadExit() function.
   port::Mutex* MemberMutex() { return &mutex_; }
 
-private:
+ private:
   // Get UnrefHandler for id with acquiring mutex
   // REQUIRES: mutex locked
   UnrefHandler GetHandler(uint32_t id);
@@ -173,7 +172,7 @@ namespace wintlscleanup {
 
 // This is set to OnThreadExit in StaticMeta singleton constructor
 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.
 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
 // linker /INCLUDE:symbol pragma above.
@@ -298,9 +297,7 @@ void ThreadLocalPtr::StaticMeta::OnThreadExit(void* ptr) {
 }
 
 ThreadLocalPtr::StaticMeta::StaticMeta()
-  : next_instance_id_(0),
-    head_(this),
-    pthread_key_(0) {
+    : next_instance_id_(0), head_(this), pthread_key_(0) {
   if (pthread_key_create(&pthread_key_, &OnThreadExit) != 0) {
     abort();
   }
@@ -345,8 +342,7 @@ void ThreadLocalPtr::StaticMeta::AddThreadData(ThreadData* d) {
   head_.prev = d;
 }
 
-void ThreadLocalPtr::StaticMeta::RemoveThreadData(
-    ThreadData* d) {
+void ThreadLocalPtr::StaticMeta::RemoveThreadData(ThreadData* d) {
   Mutex()->AssertHeld();
   d->next->prev = d->prev;
   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,
-    void*& expected) {
+                                                void*& expected) {
   auto* tls = GetThreadLocal();
   if (UNLIKELY(id >= tls->entries.size())) {
     // 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* const replacement) {
+                                        void* const replacement) {
   MutexLock l(Mutex());
   for (ThreadData* t = head_.next; t != &head_; t = t->next) {
     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() {
-  return Instance()->PeekId();
-}
+uint32_t ThreadLocalPtr::TEST_PeekId() { return Instance()->PeekId(); }
 
 void ThreadLocalPtr::StaticMeta::SetHandler(uint32_t id, UnrefHandler handler) {
   MutexLock l(Mutex());
@@ -504,21 +498,13 @@ ThreadLocalPtr::ThreadLocalPtr(UnrefHandler handler)
   }
 }
 
-ThreadLocalPtr::~ThreadLocalPtr() {
-  Instance()->ReclaimId(id_);
-}
+ThreadLocalPtr::~ThreadLocalPtr() { Instance()->ReclaimId(id_); }
 
-void* ThreadLocalPtr::Get() const {
-  return Instance()->Get(id_);
-}
+void* ThreadLocalPtr::Get() const { return Instance()->Get(id_); }
 
-void ThreadLocalPtr::Reset(void* ptr) {
-  Instance()->Reset(id_, ptr);
-}
+void ThreadLocalPtr::Reset(void* ptr) { Instance()->Reset(id_, ptr); }
 
-void* ThreadLocalPtr::Swap(void* ptr) {
-  return Instance()->Swap(id_, ptr);
-}
+void* ThreadLocalPtr::Swap(void* ptr) { return Instance()->Swap(id_, ptr); }
 
 bool ThreadLocalPtr::CompareAndSwap(void* ptr, void*& expected) {
   return Instance()->CompareAndSwap(id_, ptr, expected);

util/thread_local.h

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

util/thread_operation.h

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

util/threadpool_imp.cc

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

util/threadpool_imp.h

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

util/timer.h

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

util/timer_queue.h

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

util/timer_queue_test.cc

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