@nxtedition/rocksdb 7.1.29 → 7.1.31

package/deps/rocksdb/rocksdb/utilities/merge_operators/string_append/stringappend_test.cc

@@ -10,7 +10,7 @@
  *
  * @author Deon Nicholas (dnicholas@fb.com)
  * Copyright 2013 Facebook, Inc.
-*/
+ */
 
 #include "utilities/merge_operators/string_append/stringappend.h"
 
@@ -27,7 +27,6 @@
 #include "utilities/merge_operators.h"
 #include "utilities/merge_operators/string_append/stringappend2.h"
 
-
 namespace ROCKSDB_NAMESPACE {
 
 // Path to the database on file system
@@ -73,18 +72,15 @@ std::shared_ptr<DB> OpenTtlDb(const std::string& delim) {
 /// Supports Append(list, string) and Get(list)
 class StringLists {
  public:
-
-  //Constructor: specifies the rocksdb db
+  // Constructor: specifies the rocksdb db
   /* implicit */
   StringLists(std::shared_ptr<DB> db)
-      : db_(db),
-        merge_option_(),
-        get_option_() {
+      : db_(db), merge_option_(), get_option_() {
     assert(db);
   }
 
   // Append string val onto the list defined by key; return true on success
-  bool Append(const std::string& key, const std::string& val){
+  bool Append(const std::string& key, const std::string& val) {
     Slice valSlice(val.data(), val.size());
     auto s = db_->Merge(merge_option_, key, valSlice);
 
@@ -97,8 +93,8 @@ class StringLists {
   }
 
   // Returns the list of strings associated with key (or "" if does not exist)
-  bool Get(const std::string& key, std::string* const result){
-    assert(result != nullptr); // we should have a place to store the result
+  bool Get(const std::string& key, std::string* const result) {
+    assert(result != nullptr);  // we should have a place to store the result
     auto s = db_->Get(get_option_, key, result);
 
     if (s.ok()) {
@@ -106,10 +102,10 @@ class StringLists {
     }
 
     // Either key does not exist, or there is some error.
-    *result = "";       // Always return empty string (just for convention)
+    *result = "";  // Always return empty string (just for convention)
 
-    //NotFound is okay; just return empty (similar to std::map)
-    //But network or db errors, etc, should fail the test (or at least yell)
+    // NotFound is okay; just return empty (similar to std::map)
+    // But network or db errors, etc, should fail the test (or at least yell)
     if (!s.IsNotFound()) {
       std::cerr << "ERROR " << s.ToString() << std::endl;
     }
@@ -118,15 +114,12 @@ class StringLists {
     return false;
   }
 
-
  private:
   std::shared_ptr<DB> db_;
   WriteOptions merge_option_;
   ReadOptions get_option_;
-
 };
 
-
 // The class for unit-testing
 class StringAppendOperatorTest : public testing::Test,
                                  public ::testing::WithParamInterface<bool> {
@@ -153,14 +146,13 @@ class StringAppendOperatorTest : public testing::Test,
 
   // Allows user to open databases with different configurations.
   // e.g.: Can open a DB or a TtlDB, etc.
-  static void SetOpenDbFunction(OpenFuncPtr func) {
-    OpenDb = func;
-  }
+  static void SetOpenDbFunction(OpenFuncPtr func) { OpenDb = func; }
 
  protected:
   static OpenFuncPtr OpenDb;
 };
-StringAppendOperatorTest::OpenFuncPtr StringAppendOperatorTest::OpenDb = nullptr;
+StringAppendOperatorTest::OpenFuncPtr StringAppendOperatorTest::OpenDb =
+    nullptr;
 
 // THE TEST CASES BEGIN HERE
 
@@ -206,7 +198,6 @@ TEST_P(StringAppendOperatorTest, IteratorTest) {
     }
   }
 
-
   // Should release the snapshot and be aware of the new stuff now
   it.reset(db_->NewIterator(ReadOptions()));
   first = true;
@@ -236,7 +227,7 @@ TEST_P(StringAppendOperatorTest, IteratorTest) {
   it.reset(db_->NewIterator(ReadOptions()));
   first = true;
   std::string k3("k3");
-  for(it->Seek(k2); it->Valid(); it->Next()) {
+  for (it->Seek(k2); it->Valid(); it->Next()) {
     res = it->value().ToString();
     if (first) {
       ASSERT_EQ(res, "a1,a2,a3,a4");
@@ -245,7 +236,7 @@ TEST_P(StringAppendOperatorTest, IteratorTest) {
       ASSERT_EQ(res, "g1");
     }
   }
-  for(it->Seek(k3); it->Valid(); it->Next()) {
+  for (it->Seek(k3); it->Valid(); it->Next()) {
     res = it->value().ToString();
     if (first) {
       // should not be hit
@@ -353,7 +344,7 @@ TEST_P(StringAppendOperatorTest, VariousKeys) {
   sb = slists.Get("b", &b);
   sc = slists.Get("c", &c);
 
-  ASSERT_TRUE(sa && sb && sc); // All three keys should have been found
+  ASSERT_TRUE(sa && sb && sc);  // All three keys should have been found
 
   ASSERT_EQ(a, "x\nt\nr");
   ASSERT_EQ(b, "y\n2");
@@ -367,22 +358,23 @@ TEST_P(StringAppendOperatorTest, RandomMixGetAppend) {
 
   // Generate a list of random keys and values
   const int kWordCount = 15;
-  std::string words[] = {"sdasd", "triejf", "fnjsdfn", "dfjisdfsf", "342839",
-                         "dsuha", "mabuais", "sadajsid", "jf9834hf", "2d9j89",
-                         "dj9823jd", "a", "dk02ed2dh", "$(jd4h984$(*", "mabz"};
+  std::string words[] = {"sdasd",     "triejf",       "fnjsdfn",  "dfjisdfsf",
+                         "342839",    "dsuha",        "mabuais",  "sadajsid",
+                         "jf9834hf",  "2d9j89",       "dj9823jd", "a",
+                         "dk02ed2dh", "$(jd4h984$(*", "mabz"};
   const int kKeyCount = 6;
-  std::string keys[] = {"dhaiusdhu", "denidw", "daisda", "keykey", "muki",
-                        "shzassdianmd"};
+  std::string keys[] = {"dhaiusdhu", "denidw", "daisda",
+                        "keykey",    "muki",   "shzassdianmd"};
 
   // Will store a local copy of all data in order to verify correctness
   std::map<std::string, std::string> parallel_copy;
 
   // Generate a bunch of random queries (Append and Get)!
-  enum query_t  { APPEND_OP, GET_OP, NUM_OPS };
-  Random randomGen(1337);       //deterministic seed; always get same results!
+  enum query_t { APPEND_OP, GET_OP, NUM_OPS };
+  Random randomGen(1337);  // deterministic seed; always get same results!
 
   const int kNumQueries = 30;
-  for (int q=0; q<kNumQueries; ++q) {
+  for (int q = 0; q < kNumQueries; ++q) {
     // Generate a random query (Append or Get) and random parameters
     query_t query = (query_t)randomGen.Uniform((int)NUM_OPS);
     std::string key = keys[randomGen.Uniform((int)kKeyCount)];
@@ -390,9 +382,8 @@ TEST_P(StringAppendOperatorTest, RandomMixGetAppend) {
 
     // Apply the query and any checks.
     if (query == APPEND_OP) {
-
       // Apply the rocksdb test-harness Append defined above
-      slists.Append(key, word);  //apply the rocksdb append
+      slists.Append(key, word);  // apply the rocksdb append
 
       // Apply the similar "Append" to the parallel copy
       if (parallel_copy[key].size() > 0) {
@@ -407,7 +398,6 @@ TEST_P(StringAppendOperatorTest, RandomMixGetAppend) {
       slists.Get(key, &res);
       ASSERT_EQ(res, parallel_copy[key]);
     }
-
   }
 }
 
@@ -417,32 +407,32 @@ TEST_P(StringAppendOperatorTest, BIGRandomMixGetAppend) {
 
   // Generate a list of random keys and values
   const int kWordCount = 15;
-  std::string words[] = {"sdasd", "triejf", "fnjsdfn", "dfjisdfsf", "342839",
-                         "dsuha", "mabuais", "sadajsid", "jf9834hf", "2d9j89",
-                         "dj9823jd", "a", "dk02ed2dh", "$(jd4h984$(*", "mabz"};
+  std::string words[] = {"sdasd",     "triejf",       "fnjsdfn",  "dfjisdfsf",
+                         "342839",    "dsuha",        "mabuais",  "sadajsid",
+                         "jf9834hf",  "2d9j89",       "dj9823jd", "a",
+                         "dk02ed2dh", "$(jd4h984$(*", "mabz"};
   const int kKeyCount = 6;
-  std::string keys[] = {"dhaiusdhu", "denidw", "daisda", "keykey", "muki",
-                        "shzassdianmd"};
+  std::string keys[] = {"dhaiusdhu", "denidw", "daisda",
+                        "keykey",    "muki",   "shzassdianmd"};
 
   // Will store a local copy of all data in order to verify correctness
   std::map<std::string, std::string> parallel_copy;
 
   // Generate a bunch of random queries (Append and Get)!
-  enum query_t  { APPEND_OP, GET_OP, NUM_OPS };
-  Random randomGen(9138204);       // deterministic seed
+  enum query_t { APPEND_OP, GET_OP, NUM_OPS };
+  Random randomGen(9138204);  // deterministic seed
 
   const int kNumQueries = 1000;
-  for (int q=0; q<kNumQueries; ++q) {
+  for (int q = 0; q < kNumQueries; ++q) {
     // Generate a random query (Append or Get) and random parameters
     query_t query = (query_t)randomGen.Uniform((int)NUM_OPS);
     std::string key = keys[randomGen.Uniform((int)kKeyCount)];
     std::string word = words[randomGen.Uniform((int)kWordCount)];
 
-    //Apply the query and any checks.
+    // Apply the query and any checks.
     if (query == APPEND_OP) {
-
       // Apply the rocksdb test-harness Append defined above
-      slists.Append(key, word);  //apply the rocksdb append
+      slists.Append(key, word);  // apply the rocksdb append
 
       // Apply the similar "Append" to the parallel copy
       if (parallel_copy[key].size() > 0) {
@@ -457,7 +447,6 @@ TEST_P(StringAppendOperatorTest, BIGRandomMixGetAppend) {
       slists.Get(key, &res);
       ASSERT_EQ(res, parallel_copy[key]);
     }
-
   }
 }
 
@@ -578,7 +567,7 @@ TEST_P(StringAppendOperatorTest, PersistentFlushAndCompaction) {
     ASSERT_TRUE(slists.Get("a", &a));
     ASSERT_EQ(a, "x\nt\nr");
 
-    //Append, Compact, Get
+    // Append, Compact, Get
     slists.Append("c", "bbnagnagsx");
     slists.Append("a", "sa");
     slists.Append("b", "df");
@@ -629,8 +618,8 @@ TEST_P(StringAppendOperatorTest, SimpleTestNullDelimiter) {
   ASSERT_TRUE(slists.Get("k1", &res));
 
   // Construct the desired string. Default constructor doesn't like '\0' chars.
-  std::string checker("v1,v2,v3");    // Verify that the string is right size.
-  checker[2] = '\0';                  // Use null delimiter instead of comma.
+  std::string checker("v1,v2,v3");  // Verify that the string is right size.
+  checker[2] = '\0';                // Use null delimiter instead of comma.
   checker[5] = '\0';
   ASSERT_EQ(checker.size(), 8);  // Verify it is still the correct size
 

package/deps/rocksdb/rocksdb/utilities/merge_operators/uint64add.cc

@@ -12,7 +12,7 @@
 #include "util/coding.h"
 #include "utilities/merge_operators.h"
 
-namespace { // anonymous namespace
+namespace {  // anonymous namespace
 
 using ROCKSDB_NAMESPACE::AssociativeMergeOperator;
 using ROCKSDB_NAMESPACE::InfoLogLevel;
@@ -27,7 +27,7 @@ class UInt64AddOperator : public AssociativeMergeOperator {
              const Slice& value, std::string* new_value,
              Logger* logger) const override {
     uint64_t orig_value = 0;
-    if (existing_value){
+    if (existing_value) {
       orig_value = DecodeInteger(*existing_value, logger);
     }
     uint64_t operand = DecodeInteger(value, logger);

package/deps/rocksdb/rocksdb/utilities/merge_operators.h

@@ -4,13 +4,13 @@
 //  (found in the LICENSE.Apache file in the root directory).
 //
 #pragma once
-#include "rocksdb/merge_operator.h"
-
 #include <stdio.h>
 
 #include <memory>
 #include <string>
 
+#include "rocksdb/merge_operator.h"
+
 namespace ROCKSDB_NAMESPACE {
 
 class MergeOperators {
@@ -19,7 +19,8 @@ class MergeOperators {
   static std::shared_ptr<MergeOperator> CreateDeprecatedPutOperator();
   static std::shared_ptr<MergeOperator> CreateUInt64AddOperator();
   static std::shared_ptr<MergeOperator> CreateStringAppendOperator();
-  static std::shared_ptr<MergeOperator> CreateStringAppendOperator(char delim_char);
+  static std::shared_ptr<MergeOperator> CreateStringAppendOperator(
+      char delim_char);
   static std::shared_ptr<MergeOperator> CreateStringAppendOperator(
       const std::string& delim);
   static std::shared_ptr<MergeOperator> CreateStringAppendTESTOperator();

package/deps/rocksdb/rocksdb/utilities/options/options_util.cc

@@ -57,8 +57,8 @@ Status LoadOptionsFromFile(const ConfigOptions& config_options,
   return Status::OK();
 }
 
-Status GetLatestOptionsFileName(const std::string& dbpath,
-                                Env* env, std::string* options_file_name) {
+Status GetLatestOptionsFileName(const std::string& dbpath, Env* env,
+                                std::string* options_file_name) {
   Status s;
   std::string latest_file_name;
   uint64_t latest_time_stamp = 0;

package/deps/rocksdb/rocksdb/utilities/persistent_cache/block_cache_tier.cc

@@ -132,7 +132,7 @@ Status BlockCacheTier::Close() {
   return Status::OK();
 }
 
-template<class T>
+template <class T>
 void Add(std::map<std::string, double>* stats, const std::string& key,
          const T& t) {
   stats->insert({key, static_cast<double>(t)});
@@ -148,8 +148,7 @@ PersistentCache::StatsType BlockCacheTier::Stats() {
       stats_.bytes_read_.Average());
   Add(&stats, "persistentcache.blockcachetier.insert_dropped",
       stats_.insert_dropped_);
-  Add(&stats, "persistentcache.blockcachetier.cache_hits",
-      stats_.cache_hits_);
+  Add(&stats, "persistentcache.blockcachetier.cache_hits", stats_.cache_hits_);
   Add(&stats, "persistentcache.blockcachetier.cache_misses",
       stats_.cache_misses_);
   Add(&stats, "persistentcache.blockcachetier.cache_errors",
@@ -326,10 +325,9 @@ Status BlockCacheTier::NewCacheFile() {
   TEST_SYNC_POINT_CALLBACK("BlockCacheTier::NewCacheFile:DeleteDir",
                            (void*)(GetCachePath().c_str()));
 
-  std::unique_ptr<WriteableCacheFile> f(
-    new WriteableCacheFile(opt_.env, &buffer_allocator_, &writer_,
-                           GetCachePath(), writer_cache_id_,
-                           opt_.cache_file_size, opt_.log));
+  std::unique_ptr<WriteableCacheFile> f(new WriteableCacheFile(
+      opt_.env, &buffer_allocator_, &writer_, GetCachePath(), writer_cache_id_,
+      opt_.cache_file_size, opt_.log));
 
   bool status = f->Create(opt_.enable_direct_writes, opt_.enable_direct_reads);
   if (!status) {

package/deps/rocksdb/rocksdb/utilities/persistent_cache/block_cache_tier.h

@@ -6,9 +6,9 @@
 
 #ifndef ROCKSDB_LITE
 
-#ifndef  OS_WIN
+#ifndef OS_WIN
 #include <unistd.h>
-#endif // ! OS_WIN
+#endif  // ! OS_WIN
 
 #include <atomic>
 #include <list>
@@ -45,7 +45,8 @@ class BlockCacheTier : public PersistentCacheTier {
       : opt_(opt),
         insert_ops_(static_cast<size_t>(opt_.max_write_pipeline_backlog_size)),
         buffer_allocator_(opt.write_buffer_size, opt.write_buffer_count()),
-        writer_(this, opt_.writer_qdepth, static_cast<size_t>(opt_.writer_dispatch_size)) {
+        writer_(this, opt_.writer_qdepth,
+                static_cast<size_t>(opt_.writer_dispatch_size)) {
     Info(opt_.log, "Initializing allocator. size=%d B count=%" ROCKSDB_PRIszt,
          opt_.write_buffer_size, opt_.write_buffer_count());
   }
@@ -147,7 +148,7 @@ class BlockCacheTier : public PersistentCacheTier {
   ThreadedWriter writer_;                       // Writer threads
   BlockCacheTierMetadata metadata_;             // Cache meta data manager
   std::atomic<uint64_t> size_{0};               // Size of the cache
-  Statistics stats_;                                 // Statistics
+  Statistics stats_;                            // Statistics
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/persistent_cache/block_cache_tier_file.cc

@@ -68,8 +68,7 @@ Status BlockCacheFile::Delete(uint64_t* size) {
 // <-- 4 --><-- 4  --><-- 4   --><-- 4     --><-- key size  --><-- v-size -->
 //
 struct CacheRecordHeader {
-  CacheRecordHeader()
-    : magic_(0), crc_(0), key_size_(0), val_size_(0) {}
+  CacheRecordHeader() : magic_(0), crc_(0), key_size_(0), val_size_(0) {}
   CacheRecordHeader(const uint32_t magic, const uint32_t key_size,
                     const uint32_t val_size)
       : magic_(magic), crc_(0), key_size_(key_size), val_size_(val_size) {}

package/deps/rocksdb/rocksdb/utilities/persistent_cache/block_cache_tier_file.h

@@ -12,19 +12,16 @@
 #include <vector>
 
 #include "file/random_access_file_reader.h"
-
+#include "port/port.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/env.h"
-
+#include "util/crc32c.h"
+#include "util/mutexlock.h"
 #include "utilities/persistent_cache/block_cache_tier_file_buffer.h"
 #include "utilities/persistent_cache/lrulist.h"
 #include "utilities/persistent_cache/persistent_cache_tier.h"
 #include "utilities/persistent_cache/persistent_cache_util.h"
 
-#include "port/port.h"
-#include "util/crc32c.h"
-#include "util/mutexlock.h"
-
 // The io code path of persistent cache uses pipelined architecture
 //
 // client -> In Queue <-- BlockCacheTier --> Out Queue <-- Writer <--> Kernel

package/deps/rocksdb/rocksdb/utilities/persistent_cache/block_cache_tier_file_buffer.h

@@ -8,8 +8,8 @@
 #include <memory>
 #include <string>
 
-#include "rocksdb/comparator.h"
 #include "memory/arena.h"
+#include "rocksdb/comparator.h"
 #include "util/mutexlock.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/utilities/persistent_cache/block_cache_tier_metadata.cc

@@ -32,8 +32,8 @@ BlockCacheFile* BlockCacheTierMetadata::Evict() {
 }
 
 void BlockCacheTierMetadata::Clear() {
-  cache_file_index_.Clear([](BlockCacheFile* arg){ delete arg; });
-  block_index_.Clear([](BlockInfo* arg){ delete arg; });
+  cache_file_index_.Clear([](BlockCacheFile* arg) { delete arg; });
+  block_index_.Clear([](BlockInfo* arg) { delete arg; });
 }
 
 BlockInfo* BlockCacheTierMetadata::Insert(const Slice& key, const LBA& lba) {

package/deps/rocksdb/rocksdb/utilities/persistent_cache/block_cache_tier_metadata.h

@@ -11,7 +11,6 @@
 #include <unordered_map>
 
 #include "rocksdb/slice.h"
-
 #include "utilities/persistent_cache/block_cache_tier_file.h"
 #include "utilities/persistent_cache/hash_table.h"
 #include "utilities/persistent_cache/hash_table_evictable.h"

package/deps/rocksdb/rocksdb/utilities/persistent_cache/hash_table.h

@@ -8,6 +8,7 @@
 #ifndef ROCKSDB_LITE
 
 #include <assert.h>
+
 #include <list>
 #include <vector>
 

package/deps/rocksdb/rocksdb/utilities/persistent_cache/hash_table_test.cc

@@ -3,7 +3,10 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 //
+#include "utilities/persistent_cache/hash_table.h"
+
 #include <stdlib.h>
+
 #include <iostream>
 #include <set>
 #include <string>
@@ -12,7 +15,6 @@
 #include "memory/arena.h"
 #include "test_util/testharness.h"
 #include "util/random.h"
-#include "utilities/persistent_cache/hash_table.h"
 #include "utilities/persistent_cache/hash_table_evictable.h"
 
 #ifndef ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/persistent_cache/persistent_cache_bench.cc

@@ -234,7 +234,7 @@ class CacheTierBenchmark {
       fprintf(stderr, "%s\n", status.ToString().c_str());
     }
     assert(status.ok());
-    assert(size == (size_t) FLAGS_iosize);
+    assert(size == (size_t)FLAGS_iosize);
 
     // adjust stats
     const size_t elapsed_micro = timer.ElapsedNanos() / 1000;

package/deps/rocksdb/rocksdb/utilities/persistent_cache/persistent_cache_test.cc

@@ -84,7 +84,8 @@ std::unique_ptr<PersistentCacheTier> NewBlockCache(
     Env* env, const std::string& path,
     const uint64_t max_size = std::numeric_limits<uint64_t>::max(),
     const bool enable_direct_writes = false) {
-  const uint32_t max_file_size = static_cast<uint32_t>(12 * 1024 * 1024 * kStressFactor);
+  const uint32_t max_file_size =
+      static_cast<uint32_t>(12 * 1024 * 1024 * kStressFactor);
   auto log = std::make_shared<ConsoleLogger>();
   PersistentCacheConfig opt(env, path, max_size, log);
   opt.cache_file_size = max_file_size;
@@ -101,7 +102,8 @@ std::unique_ptr<PersistentTieredCache> NewTieredCache(
     Env* env, const std::string& path, const uint64_t max_volatile_cache_size,
     const uint64_t max_block_cache_size =
         std::numeric_limits<uint64_t>::max()) {
-  const uint32_t max_file_size = static_cast<uint32_t>(12 * 1024 * 1024 * kStressFactor);
+  const uint32_t max_file_size =
+      static_cast<uint32_t>(12 * 1024 * 1024 * kStressFactor);
   auto log = std::make_shared<ConsoleLogger>();
   auto opt = PersistentCacheConfig(env, path, max_block_cache_size, log);
   opt.cache_file_size = max_file_size;
@@ -126,13 +128,13 @@ PersistentCacheTierTest::PersistentCacheTierTest()
 TEST_F(PersistentCacheTierTest, DISABLED_BlockCacheInsertWithFileCreateError) {
   cache_ = NewBlockCache(Env::Default(), path_,
                          /*size=*/std::numeric_limits<uint64_t>::max(),
-                         /*direct_writes=*/ false);
+                         /*direct_writes=*/false);
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
       "BlockCacheTier::NewCacheFile:DeleteDir", OnDeleteDir);
 
-  RunNegativeInsertTest(/*nthreads=*/ 1,
+  RunNegativeInsertTest(/*nthreads=*/1,
                         /*max_keys*/
-                          static_cast<size_t>(10 * 1024 * kStressFactor));
+                        static_cast<size_t>(10 * 1024 * kStressFactor));
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
 }
@@ -171,7 +173,8 @@ TEST_F(PersistentCacheTierTest, DISABLED_VolatileCacheInsertWithEviction) {
   for (auto nthreads : {1, 5}) {
     for (auto max_keys : {1 * 1024 * 1024 * kStressFactor}) {
       cache_ = std::make_shared<VolatileCacheTier>(
-          /*compressed=*/true, /*size=*/static_cast<size_t>(1 * 1024 * 1024 * kStressFactor));
+          /*compressed=*/true,
+          /*size=*/static_cast<size_t>(1 * 1024 * 1024 * kStressFactor));
       RunInsertTestWithEviction(nthreads, static_cast<size_t>(max_keys));
     }
   }
@@ -197,8 +200,9 @@ TEST_F(PersistentCacheTierTest, DISABLED_BlockCacheInsert) {
 TEST_F(PersistentCacheTierTest, DISABLED_BlockCacheInsertWithEviction) {
   for (auto nthreads : {1, 5}) {
     for (auto max_keys : {1 * 1024 * 1024 * kStressFactor}) {
-      cache_ = NewBlockCache(Env::Default(), path_,
-                             /*max_size=*/static_cast<size_t>(200 * 1024 * 1024 * kStressFactor));
+      cache_ = NewBlockCache(
+          Env::Default(), path_,
+          /*max_size=*/static_cast<size_t>(200 * 1024 * 1024 * kStressFactor));
       RunInsertTestWithEviction(nthreads, static_cast<size_t>(max_keys));
     }
   }
@@ -210,8 +214,9 @@ TEST_F(PersistentCacheTierTest, DISABLED_TieredCacheInsert) {
   for (auto nthreads : {1, 5}) {
     for (auto max_keys :
          {10 * 1024 * kStressFactor, 1 * 1024 * 1024 * kStressFactor}) {
-      cache_ = NewTieredCache(Env::Default(), path_,
-                              /*memory_size=*/static_cast<size_t>(1 * 1024 * 1024 * kStressFactor));
+      cache_ = NewTieredCache(
+          Env::Default(), path_,
+          /*memory_size=*/static_cast<size_t>(1 * 1024 * 1024 * kStressFactor));
       RunInsertTest(nthreads, static_cast<size_t>(max_keys));
     }
   }
@@ -226,7 +231,8 @@ TEST_F(PersistentCacheTierTest, DISABLED_TieredCacheInsertWithEviction) {
       cache_ = NewTieredCache(
           Env::Default(), path_,
           /*memory_size=*/static_cast<size_t>(1 * 1024 * 1024 * kStressFactor),
-          /*block_cache_size*/ static_cast<size_t>(200 * 1024 * 1024 * kStressFactor));
+          /*block_cache_size*/
+          static_cast<size_t>(200 * 1024 * 1024 * kStressFactor));
       RunInsertTestWithEviction(nthreads, static_cast<size_t>(max_keys));
     }
   }
@@ -291,14 +297,13 @@ PersistentCacheDBTest::PersistentCacheDBTest()
 void PersistentCacheDBTest::RunTest(
     const std::function<std::shared_ptr<PersistentCacheTier>(bool)>& new_pcache,
     const size_t max_keys = 100 * 1024, const size_t max_usecase = 5) {
-
   // number of insertion interations
   int num_iter = static_cast<int>(max_keys * kStressFactor);
 
   for (size_t iter = 0; iter < max_usecase; iter++) {
     Options options;
     options.write_buffer_size =
-      static_cast<size_t>(64 * 1024 * kStressFactor);  // small write buffer
+        static_cast<size_t>(64 * 1024 * kStressFactor);  // small write buffer
     options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
     options = CurrentOptions(options);
 

package/deps/rocksdb/rocksdb/utilities/table_properties_collectors/compact_on_deletion_collector.h

@@ -41,9 +41,7 @@ class CompactOnDeletionCollector : public TablePropertiesCollector {
   }
 
   // EXPERIMENTAL Return whether the output file should be further compacted
-  virtual bool NeedCompact() const override {
-    return need_compaction_;
-  }
+  virtual bool NeedCompact() const override { return need_compaction_; }
 
   static const int kNumBuckets = 128;
 

package/deps/rocksdb/rocksdb/utilities/table_properties_collectors/compact_on_deletion_collector_test.cc

@@ -80,10 +80,10 @@ TEST(CompactOnDeletionCollector, DeletionRatio) {
 }
 
 TEST(CompactOnDeletionCollector, SlidingWindow) {
-  const int kWindowSizes[] =
-      {1000, 10000, 10000, 127, 128, 129, 255, 256, 257, 2, 10000};
-  const int kDeletionTriggers[] =
-      {500, 9500, 4323, 47, 61, 128, 250, 250, 250, 2, 2};
+  const int kWindowSizes[] = {1000, 10000, 10000, 127, 128,  129,
+                              255,  256,   257,   2,   10000};
+  const int kDeletionTriggers[] = {500, 9500, 4323, 47, 61, 128,
+                                   250, 250,  250,  2,  2};
   TablePropertiesCollectorFactory::Context context;
   context.column_family_id =
       TablePropertiesCollectorFactory::Context::kUnknownColumnFamily;
@@ -134,13 +134,13 @@ TEST(CompactOnDeletionCollector, SlidingWindow) {
                 collector->AddUserKey("hello", "rocksdb", kEntryPut, 0, 0));
           }
         }
-        if (collector->NeedCompact() !=
-            (deletions >= kNumDeletionTrigger) &&
+        if (collector->NeedCompact() != (deletions >= kNumDeletionTrigger) &&
             std::abs(deletions - kNumDeletionTrigger) > kBias) {
-          fprintf(stderr, "[Error] collector->NeedCompact() != (%d >= %d)"
+          fprintf(stderr,
+                  "[Error] collector->NeedCompact() != (%d >= %d)"
                   " with kWindowSize = %d and kNumDeletionTrigger = %d\n",
-                  deletions, kNumDeletionTrigger,
-                  kWindowSize, kNumDeletionTrigger);
+                  deletions, kNumDeletionTrigger, kWindowSize,
+                  kNumDeletionTrigger);
           ASSERT_TRUE(false);
         }
         ASSERT_OK(collector->Finish(nullptr));
@@ -182,11 +182,11 @@ TEST(CompactOnDeletionCollector, SlidingWindow) {
         }
         if (collector->NeedCompact() != (deletions >= kNumDeletionTrigger) &&
             std::abs(deletions - kNumDeletionTrigger) > kBias) {
-          fprintf(stderr, "[Error] collector->NeedCompact() %d != (%d >= %d)"
+          fprintf(stderr,
+                  "[Error] collector->NeedCompact() %d != (%d >= %d)"
                   " with kWindowSize = %d, kNumDeletionTrigger = %d\n",
-                  collector->NeedCompact(),
-                  deletions, kNumDeletionTrigger, kWindowSize,
-                  kNumDeletionTrigger);
+                  collector->NeedCompact(), deletions, kNumDeletionTrigger,
+                  kWindowSize, kNumDeletionTrigger);
           ASSERT_TRUE(false);
         }
         ASSERT_OK(collector->Finish(nullptr));
@@ -218,7 +218,8 @@ TEST(CompactOnDeletionCollector, SlidingWindow) {
         }
         if (collector->NeedCompact() &&
             std::abs(kDeletionsPerSection - kNumDeletionTrigger) > kBias) {
-          fprintf(stderr, "[Error] collector->NeedCompact() != false"
+          fprintf(stderr,
+                  "[Error] collector->NeedCompact() != false"
                   " with kWindowSize = %d and kNumDeletionTrigger = %d\n",
                   kWindowSize, kNumDeletionTrigger);
           ASSERT_TRUE(false);