@nxtedition/rocksdb 7.1.14 → 7.1.16

package/deps/rocksdb/rocksdb/utilities/option_change_migration/option_change_migration_test.cc

@@ -20,7 +20,7 @@ namespace ROCKSDB_NAMESPACE {
 class DBOptionChangeMigrationTests
     : public DBTestBase,
       public testing::WithParamInterface<
-          std::tuple<int, int, bool, int, int, bool>> {
+          std::tuple<int, int, bool, int, int, bool, uint64_t>> {
  public:
   DBOptionChangeMigrationTests()
       : DBTestBase("db_option_change_migration_test", /*env_do_fsync=*/true) {
@@ -31,6 +31,7 @@ class DBOptionChangeMigrationTests
     level2_ = std::get<3>(GetParam());
     compaction_style2_ = std::get<4>(GetParam());
     is_dynamic2_ = std::get<5>(GetParam());
+    fifo_max_table_files_size_ = std::get<6>(GetParam());
   }
 
   // Required if inheriting from testing::WithParamInterface<>
@@ -44,6 +45,8 @@ class DBOptionChangeMigrationTests
   int level2_;
   int compaction_style2_;
   bool is_dynamic2_;
+
+  uint64_t fifo_max_table_files_size_;
 };
 
 #ifndef ROCKSDB_LITE
@@ -97,6 +100,10 @@ TEST_P(DBOptionChangeMigrationTests, Migrate1) {
   if (new_options.compaction_style == CompactionStyle::kCompactionStyleFIFO) {
     new_options.max_open_files = -1;
   }
+  if (fifo_max_table_files_size_ != 0) {
+    new_options.compaction_options_fifo.max_table_files_size =
+        fifo_max_table_files_size_;
+  }
   new_options.target_file_size_base = 256 * 1024;
   new_options.num_levels = level2_;
   new_options.max_bytes_for_level_base = 150 * 1024;
@@ -172,6 +179,10 @@ TEST_P(DBOptionChangeMigrationTests, Migrate2) {
   if (new_options.compaction_style == CompactionStyle::kCompactionStyleFIFO) {
     new_options.max_open_files = -1;
   }
+  if (fifo_max_table_files_size_ != 0) {
+    new_options.compaction_options_fifo.max_table_files_size =
+        fifo_max_table_files_size_;
+  }
   new_options.target_file_size_base = 256 * 1024;
   new_options.num_levels = level1_;
   new_options.max_bytes_for_level_base = 150 * 1024;
@@ -251,6 +262,10 @@ TEST_P(DBOptionChangeMigrationTests, Migrate3) {
   if (new_options.compaction_style == CompactionStyle::kCompactionStyleFIFO) {
     new_options.max_open_files = -1;
   }
+  if (fifo_max_table_files_size_ != 0) {
+    new_options.compaction_options_fifo.max_table_files_size =
+        fifo_max_table_files_size_;
+  }
   new_options.target_file_size_base = 256 * 1024;
   new_options.num_levels = level2_;
   new_options.max_bytes_for_level_base = 150 * 1024;
@@ -332,6 +347,10 @@ TEST_P(DBOptionChangeMigrationTests, Migrate4) {
   if (new_options.compaction_style == CompactionStyle::kCompactionStyleFIFO) {
     new_options.max_open_files = -1;
   }
+  if (fifo_max_table_files_size_ != 0) {
+    new_options.compaction_options_fifo.max_table_files_size =
+        fifo_max_table_files_size_;
+  }
   new_options.target_file_size_base = 256 * 1024;
   new_options.num_levels = level1_;
   new_options.max_bytes_for_level_base = 150 * 1024;
@@ -357,21 +376,100 @@ TEST_P(DBOptionChangeMigrationTests, Migrate4) {
 
 INSTANTIATE_TEST_CASE_P(
     DBOptionChangeMigrationTests, DBOptionChangeMigrationTests,
-    ::testing::Values(std::make_tuple(3, 0, false, 4, 0, false),
-                      std::make_tuple(3, 0, true, 4, 0, true),
-                      std::make_tuple(3, 0, true, 4, 0, false),
-                      std::make_tuple(3, 0, false, 4, 0, true),
-                      std::make_tuple(3, 1, false, 4, 1, false),
-                      std::make_tuple(1, 1, false, 4, 1, false),
-                      std::make_tuple(3, 0, false, 4, 1, false),
-                      std::make_tuple(3, 0, false, 1, 1, false),
-                      std::make_tuple(3, 0, true, 4, 1, false),
-                      std::make_tuple(3, 0, true, 1, 1, false),
-                      std::make_tuple(1, 1, false, 4, 0, false),
-                      std::make_tuple(4, 0, false, 1, 2, false),
-                      std::make_tuple(3, 0, true, 2, 2, false),
-                      std::make_tuple(3, 1, false, 3, 2, false),
-                      std::make_tuple(1, 1, false, 4, 2, false)));
+    ::testing::Values(
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 0 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        true /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 0 /* new compaction style */,
+                        true /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        true /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 0 /* new compaction style */,
+                        false, 0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 0 /* new compaction style */,
+                        true /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 1 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 1 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(1 /* old num_levels */, 1 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 1 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 1 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        1 /* old num_levels */, 1 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        true /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 1 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        true /* is dynamic leveling in old option */,
+                        1 /* old num_levels */, 1 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(1 /* old num_levels */, 1 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 0 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(4 /* old num_levels */, 0 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        1 /* old num_levels */, 2 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        true /* is dynamic leveling in old option */,
+                        2 /* old num_levels */, 2 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 1 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        3 /* old num_levels */, 2 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        0 /*fifo max_table_files_size*/),
+        std::make_tuple(1 /* old num_levels */, 1 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 2 /* new compaction style */,
+                        false /* is dynamic leveling in new option */, 0),
+        std::make_tuple(4 /* old num_levels */, 0 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        1 /* old num_levels */, 2 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        5 * 1024 * 1024 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 0 /* old compaction style */,
+                        true /* is dynamic leveling in old option */,
+                        2 /* old num_levels */, 2 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        5 * 1024 * 1024 /*fifo max_table_files_size*/),
+        std::make_tuple(3 /* old num_levels */, 1 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        3 /* old num_levels */, 2 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        5 * 1024 * 1024 /*fifo max_table_files_size*/),
+        std::make_tuple(1 /* old num_levels */, 1 /* old compaction style */,
+                        false /* is dynamic leveling in old option */,
+                        4 /* old num_levels */, 2 /* new compaction style */,
+                        false /* is dynamic leveling in new option */,
+                        5 * 1024 * 1024 /*fifo max_table_files_size*/)));
 
 class DBOptionChangeMigrationTest : public DBTestBase {
  public:

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

@@ -140,7 +140,7 @@ TEST_F(PersistentCacheTierTest, DISABLED_BlockCacheInsertWithFileCreateError) {
 // Travis is unable to handle the normal version of the tests running out of
 // fds, out of space and timeouts. This is an easier version of the test
 // specifically written for Travis
-TEST_F(PersistentCacheTierTest, BasicTest) {
+TEST_F(PersistentCacheTierTest, DISABLED_BasicTest) {
   cache_ = std::make_shared<VolatileCacheTier>();
   RunInsertTest(/*nthreads=*/1, /*max_keys=*/1024);
 

package/deps/rocksdb/rocksdb/utilities/transactions/optimistic_transaction_test.cc

@@ -166,6 +166,65 @@ TEST_P(OptimisticTransactionTest, WriteConflictTest2) {
   delete txn;
 }
 
+TEST_P(OptimisticTransactionTest, WriteConflictTest3) {
+  ASSERT_OK(txn_db->Put(WriteOptions(), "foo", "bar"));
+
+  Transaction* txn = txn_db->BeginTransaction(WriteOptions());
+  ASSERT_NE(txn, nullptr);
+
+  std::string value;
+  ASSERT_OK(txn->GetForUpdate(ReadOptions(), "foo", &value));
+  ASSERT_EQ(value, "bar");
+  ASSERT_OK(txn->Merge("foo", "bar3"));
+
+  // Merge outside of a transaction should conflict with the previous merge
+  ASSERT_OK(txn_db->Merge(WriteOptions(), "foo", "bar2"));
+  ASSERT_OK(txn_db->Get(ReadOptions(), "foo", &value));
+  ASSERT_EQ(value, "bar2");
+
+  ASSERT_EQ(1, txn->GetNumKeys());
+
+  Status s = txn->Commit();
+  EXPECT_TRUE(s.IsBusy());  // Txn should not commit
+
+  // Verify that transaction did not write anything
+  ASSERT_OK(txn_db->Get(ReadOptions(), "foo", &value));
+  ASSERT_EQ(value, "bar2");
+
+  delete txn;
+}
+
+TEST_P(OptimisticTransactionTest, WriteConflict4) {
+  ASSERT_OK(txn_db->Put(WriteOptions(), "foo", "bar"));
+
+  Transaction* txn = txn_db->BeginTransaction(WriteOptions());
+  ASSERT_NE(txn, nullptr);
+
+  std::string value;
+  ASSERT_OK(txn->GetForUpdate(ReadOptions(), "foo", &value));
+  ASSERT_EQ(value, "bar");
+  ASSERT_OK(txn->Merge("foo", "bar3"));
+
+  // Range delete outside of a transaction should conflict with the previous
+  // merge inside txn
+  auto* dbimpl = static_cast_with_check<DBImpl>(txn_db->GetRootDB());
+  ColumnFamilyHandle* default_cf = dbimpl->DefaultColumnFamily();
+  ASSERT_OK(dbimpl->DeleteRange(WriteOptions(), default_cf, "foo", "foo1"));
+  Status s = txn_db->Get(ReadOptions(), "foo", &value);
+  ASSERT_TRUE(s.IsNotFound());
+
+  ASSERT_EQ(1, txn->GetNumKeys());
+
+  s = txn->Commit();
+  EXPECT_TRUE(s.IsBusy());  // Txn should not commit
+
+  // Verify that transaction did not write anything
+  s = txn_db->Get(ReadOptions(), "foo", &value);
+  ASSERT_TRUE(s.IsNotFound());
+
+  delete txn;
+}
+
 TEST_P(OptimisticTransactionTest, ReadConflictTest) {
   WriteOptions write_options;
   ReadOptions read_options, snapshot_read_options;

package/deps/rocksdb/rocksdb/utilities/transactions/pessimistic_transaction.cc

@@ -100,6 +100,9 @@ void PessimisticTransaction::Initialize(const TransactionOptions& txn_options) {
   use_only_the_last_commit_time_batch_for_recovery_ =
       txn_options.use_only_the_last_commit_time_batch_for_recovery;
   skip_prepare_ = txn_options.skip_prepare;
+
+  read_timestamp_ = kMaxTxnTimestamp;
+  commit_timestamp_ = kMaxTxnTimestamp;
 }
 
 PessimisticTransaction::~PessimisticTransaction() {

package/deps/rocksdb/rocksdb/utilities/transactions/timestamped_snapshot_test.cc

@@ -115,6 +115,45 @@ TEST_P(TransactionTest, WithoutCommitTs) {
   ASSERT_TRUE(s.IsInvalidArgument());
 }
 
+TEST_P(TransactionTest, ReuseExistingTxn) {
+  Transaction* txn = db->BeginTransaction(WriteOptions(), TransactionOptions());
+  assert(txn);
+  ASSERT_OK(txn->SetName("txn0"));
+  ASSERT_OK(txn->Put("a", "v1"));
+  ASSERT_OK(txn->Prepare());
+
+  auto notifier = std::make_shared<TsCheckingTxnNotifier>();
+  std::shared_ptr<const Snapshot> snapshot1;
+  Status s =
+      txn->CommitAndTryCreateSnapshot(notifier, /*commit_ts=*/100, &snapshot1);
+  ASSERT_OK(s);
+  ASSERT_EQ(100, snapshot1->GetTimestamp());
+
+  Transaction* txn1 =
+      db->BeginTransaction(WriteOptions(), TransactionOptions(), txn);
+  assert(txn1 == txn);
+  ASSERT_OK(txn1->SetName("txn1"));
+  ASSERT_OK(txn->Put("a", "v2"));
+  ASSERT_OK(txn->Prepare());
+  std::shared_ptr<const Snapshot> snapshot2;
+  s = txn->CommitAndTryCreateSnapshot(notifier, /*commit_ts=*/110, &snapshot2);
+  ASSERT_OK(s);
+  ASSERT_EQ(110, snapshot2->GetTimestamp());
+  delete txn;
+
+  {
+    std::string value;
+    ReadOptions read_opts;
+    read_opts.snapshot = snapshot1.get();
+    ASSERT_OK(db->Get(read_opts, "a", &value));
+    ASSERT_EQ("v1", value);
+
+    read_opts.snapshot = snapshot2.get();
+    ASSERT_OK(db->Get(read_opts, "a", &value));
+    ASSERT_EQ("v2", value);
+  }
+}
+
 TEST_P(TransactionTest, CreateSnapshotWhenCommit) {
   std::unique_ptr<Transaction> txn(
       db->BeginTransaction(WriteOptions(), TransactionOptions()));

package/deps/rocksdb/rocksdb.gyp

@@ -234,7 +234,6 @@
         "rocksdb/db/merge_helper.cc",
         "rocksdb/db/merge_operator.cc",
         "rocksdb/db/output_validator.cc",
-        "rocksdb/db/periodic_work_scheduler.cc",
         "rocksdb/db/range_del_aggregator.cc",
         "rocksdb/db/range_tombstone_fragmenter.cc",
         "rocksdb/db/repair.cc",

package/index.js

@@ -360,7 +360,7 @@ class RocksLevel extends AbstractLevel {
         const buffer = new Readable({
           signal: ac.signal,
           objectMode: true,
-          readableHighWaterMark: 1024,
+          readableHighWaterMark: 8192,
           construct (callback) {
             this._next = (update) => {
               if (!this.push(update)) {
@@ -389,7 +389,7 @@ class RocksLevel extends AbstractLevel {
               ...options,
               signal: ac.signal,
               // HACK: https://github.com/facebook/rocksdb/issues/10476
-              since: Math.max(0, options.since - 2048)
+              since: Math.max(0, options.since - 8192)
             })) {
               if (first) {
                 if (update.sequence > since) {
@@ -398,10 +398,8 @@ class RocksLevel extends AbstractLevel {
                 first = false
               }
 
-              if (update.sequence >= since) {
-                yield update
-                since = update.sequence + update.count
-              }
+              yield update
+              since = update.sequence + update.count
             }
           }
         } catch (err) {
@@ -422,10 +420,8 @@ class RocksLevel extends AbstractLevel {
             }
             first = false
           }
-          if (update.sequence >= since) {
-            yield update
-            since = update.sequence + update.count
-          }
+          yield update
+          since = update.sequence + update.count
         }
       }
     } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "7.1.14",
+  "version": "7.1.16",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",

package/deps/rocksdb/rocksdb/db/periodic_work_scheduler.cc

@@ -1,168 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/periodic_work_scheduler.h"
-
-#include "db/db_impl/db_impl.h"
-#include "rocksdb/system_clock.h"
-
-#ifndef ROCKSDB_LITE
-namespace ROCKSDB_NAMESPACE {
-
-const std::string PeriodicWorkTaskNames::kDumpStats = "dump_st";
-const std::string PeriodicWorkTaskNames::kPersistStats = "pst_st";
-const std::string PeriodicWorkTaskNames::kFlushInfoLog = "flush_info_log";
-const std::string PeriodicWorkTaskNames::kRecordSeqnoTime = "record_seq_time";
-
-PeriodicWorkScheduler::PeriodicWorkScheduler(
-    const std::shared_ptr<SystemClock>& clock) {
-  timer = std::unique_ptr<Timer>(new Timer(clock.get()));
-}
-
-Status PeriodicWorkScheduler::Register(DBImpl* dbi,
-                                       unsigned int stats_dump_period_sec,
-                                       unsigned int stats_persist_period_sec) {
-  MutexLock l(&timer_mu_);
-  static std::atomic<uint64_t> initial_delay(0);
-  timer->Start();
-  if (stats_dump_period_sec > 0) {
-    bool succeeded = timer->Add(
-        [dbi]() { dbi->DumpStats(); },
-        GetTaskName(dbi, PeriodicWorkTaskNames::kDumpStats),
-        initial_delay.fetch_add(1) %
-            static_cast<uint64_t>(stats_dump_period_sec) * kMicrosInSecond,
-        static_cast<uint64_t>(stats_dump_period_sec) * kMicrosInSecond);
-    if (!succeeded) {
-      return Status::Aborted("Unable to add periodic task DumpStats");
-    }
-  }
-  if (stats_persist_period_sec > 0) {
-    bool succeeded = timer->Add(
-        [dbi]() { dbi->PersistStats(); },
-        GetTaskName(dbi, PeriodicWorkTaskNames::kPersistStats),
-        initial_delay.fetch_add(1) %
-            static_cast<uint64_t>(stats_persist_period_sec) * kMicrosInSecond,
-        static_cast<uint64_t>(stats_persist_period_sec) * kMicrosInSecond);
-    if (!succeeded) {
-      return Status::Aborted("Unable to add periodic task PersistStats");
-    }
-  }
-  bool succeeded =
-      timer->Add([dbi]() { dbi->FlushInfoLog(); },
-                 GetTaskName(dbi, PeriodicWorkTaskNames::kFlushInfoLog),
-                 initial_delay.fetch_add(1) % kDefaultFlushInfoLogPeriodSec *
-                     kMicrosInSecond,
-                 kDefaultFlushInfoLogPeriodSec * kMicrosInSecond);
-  if (!succeeded) {
-    return Status::Aborted("Unable to add periodic task FlushInfoLog");
-  }
-  return Status::OK();
-}
-
-Status PeriodicWorkScheduler::RegisterRecordSeqnoTimeWorker(
-    DBImpl* dbi, uint64_t record_cadence_sec) {
-  MutexLock l(&timer_mu_);
-  timer->Start();
-  static std::atomic_uint64_t initial_delay(0);
-  bool succeeded = timer->Add(
-      [dbi]() { dbi->RecordSeqnoToTimeMapping(); },
-      GetTaskName(dbi, PeriodicWorkTaskNames::kRecordSeqnoTime),
-      initial_delay.fetch_add(1) % record_cadence_sec * kMicrosInSecond,
-      record_cadence_sec * kMicrosInSecond);
-  if (!succeeded) {
-    return Status::NotSupported(
-        "Updating seqno to time worker cadence is not supported yet");
-  }
-  return Status::OK();
-}
-
-void PeriodicWorkScheduler::UnregisterRecordSeqnoTimeWorker(DBImpl* dbi) {
-  MutexLock l(&timer_mu_);
-  timer->Cancel(GetTaskName(dbi, PeriodicWorkTaskNames::kRecordSeqnoTime));
-  if (!timer->HasPendingTask()) {
-    timer->Shutdown();
-  }
-}
-
-void PeriodicWorkScheduler::Unregister(DBImpl* dbi) {
-  MutexLock l(&timer_mu_);
-  timer->Cancel(GetTaskName(dbi, PeriodicWorkTaskNames::kDumpStats));
-  timer->Cancel(GetTaskName(dbi, PeriodicWorkTaskNames::kPersistStats));
-  timer->Cancel(GetTaskName(dbi, PeriodicWorkTaskNames::kFlushInfoLog));
-  if (!timer->HasPendingTask()) {
-    timer->Shutdown();
-  }
-}
-
-PeriodicWorkScheduler* PeriodicWorkScheduler::Default() {
-  // Always use the default SystemClock for the scheduler, as we only use the
-  // NowMicros which is the same for all clocks. The Env could only be
-  // overridden in test.
-  static PeriodicWorkScheduler scheduler(SystemClock::Default());
-  return &scheduler;
-}
-
-std::string PeriodicWorkScheduler::GetTaskName(
-    const DBImpl* dbi, const std::string& func_name) const {
-  std::string db_session_id;
-  // TODO: Should this error be ignored?
-  dbi->GetDbSessionId(db_session_id).PermitUncheckedError();
-  return db_session_id + ":" + func_name;
-}
-
-#ifndef NDEBUG
-
-// Get the static scheduler. For a new SystemClock, it needs to re-create the
-// internal timer, so only re-create it when there's no running task. Otherwise,
-// return the existing scheduler. Which means if the unittest needs to update
-// MockClock, Close all db instances and then re-open them.
-PeriodicWorkTestScheduler* PeriodicWorkTestScheduler::Default(
-    const std::shared_ptr<SystemClock>& clock) {
-  static PeriodicWorkTestScheduler scheduler(clock);
-  static port::Mutex mutex;
-  {
-    MutexLock l(&mutex);
-    if (scheduler.timer.get() != nullptr &&
-        scheduler.timer->TEST_GetPendingTaskNum() == 0) {
-      {
-        MutexLock timer_mu_guard(&scheduler.timer_mu_);
-        scheduler.timer->Shutdown();
-      }
-      scheduler.timer.reset(new Timer(clock.get()));
-    }
-  }
-  return &scheduler;
-}
-
-void PeriodicWorkTestScheduler::TEST_WaitForRun(
-    std::function<void()> callback) const {
-  if (timer != nullptr) {
-    timer->TEST_WaitForRun(callback);
-  }
-}
-
-size_t PeriodicWorkTestScheduler::TEST_GetValidTaskNum() const {
-  if (timer != nullptr) {
-    return timer->TEST_GetPendingTaskNum();
-  }
-  return 0;
-}
-
-bool PeriodicWorkTestScheduler::TEST_HasValidTask(
-    const DBImpl* dbi, const std::string& func_name) const {
-  if (timer == nullptr) {
-    return false;
-  }
-  return timer->TEST_HasVaildTask(GetTaskName(dbi, func_name));
-}
-
-PeriodicWorkTestScheduler::PeriodicWorkTestScheduler(
-    const std::shared_ptr<SystemClock>& clock)
-    : PeriodicWorkScheduler(clock) {}
-
-#endif  // !NDEBUG
-}  // namespace ROCKSDB_NAMESPACE
-
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/db/periodic_work_scheduler.h

@@ -1,90 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#ifndef ROCKSDB_LITE
-
-#include "db/db_impl/db_impl.h"
-#include "util/timer.h"
-
-namespace ROCKSDB_NAMESPACE {
-class SystemClock;
-
-// PeriodicWorkScheduler is a singleton object, which is scheduling/running
-// DumpStats(), PersistStats(), and FlushInfoLog() for all DB instances. All DB
-// instances use the same object from `Default()`.
-//
-// Internally, it uses a single threaded timer object to run the periodic work
-// functions. Timer thread will always be started since the info log flushing
-// cannot be disabled.
-class PeriodicWorkScheduler {
- public:
-  static PeriodicWorkScheduler* Default();
-
-  PeriodicWorkScheduler() = delete;
-  PeriodicWorkScheduler(const PeriodicWorkScheduler&) = delete;
-  PeriodicWorkScheduler(PeriodicWorkScheduler&&) = delete;
-  PeriodicWorkScheduler& operator=(const PeriodicWorkScheduler&) = delete;
-  PeriodicWorkScheduler& operator=(PeriodicWorkScheduler&&) = delete;
-
-  Status Register(DBImpl* dbi, unsigned int stats_dump_period_sec,
-                  unsigned int stats_persist_period_sec);
-  Status RegisterRecordSeqnoTimeWorker(DBImpl* dbi, uint64_t record_cadence);
-
-  void Unregister(DBImpl* dbi);
-  void UnregisterRecordSeqnoTimeWorker(DBImpl* dbi);
-
-  // Periodically flush info log out of application buffer at a low frequency.
-  // This improves debuggability in case of RocksDB hanging since it ensures the
-  // log messages leading up to the hang will eventually become visible in the
-  // log.
-  static const uint64_t kDefaultFlushInfoLogPeriodSec = 10;
-
- protected:
-  std::unique_ptr<Timer> timer;
-  // `timer_mu_` serves two purposes currently:
-  // (1) to ensure calls to `Start()` and `Shutdown()` are serialized, as
-  //     they are currently not implemented in a thread-safe way; and
-  // (2) to ensure the `Timer::Add()`s and `Timer::Start()` run atomically, and
-  //     the `Timer::Cancel()`s and `Timer::Shutdown()` run atomically.
-  port::Mutex timer_mu_;
-
-  explicit PeriodicWorkScheduler(const std::shared_ptr<SystemClock>& clock);
-
-  // Get the unique task name (prefix with db session id)
-  std::string GetTaskName(const DBImpl* dbi,
-                          const std::string& func_name) const;
-};
-
-#ifndef NDEBUG
-// PeriodicWorkTestScheduler is for unittest, which can specify the SystemClock
-// It also contains functions for unittest.
-class PeriodicWorkTestScheduler : public PeriodicWorkScheduler {
- public:
-  static PeriodicWorkTestScheduler* Default(
-      const std::shared_ptr<SystemClock>& clock);
-
-  void TEST_WaitForRun(std::function<void()> callback) const;
-
-  size_t TEST_GetValidTaskNum() const;
-
-  bool TEST_HasValidTask(const DBImpl* dbi, const std::string& func_name) const;
-
- private:
-  explicit PeriodicWorkTestScheduler(const std::shared_ptr<SystemClock>& clock);
-};
-#endif  // !NDEBUG
-
-struct PeriodicWorkTaskNames {
-  static const std::string kDumpStats;
-  static const std::string kPersistStats;
-  static const std::string kFlushInfoLog;
-  static const std::string kRecordSeqnoTime;
-};
-
-}  // namespace ROCKSDB_NAMESPACE
-
-#endif  // ROCKSDB_LITE