@nxtedition/rocksdb 8.0.1 → 8.0.3

package/deps/rocksdb/rocksdb/db/import_column_family_job.cc

@@ -4,6 +4,7 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
+#include "db/version_builder.h"
 #ifndef ROCKSDB_LITE
 
 #include "db/import_column_family_job.h"
@@ -45,40 +46,6 @@ Status ImportColumnFamilyJob::Prepare(uint64_t next_file_number,
   auto num_files = files_to_import_.size();
   if (num_files == 0) {
     return Status::InvalidArgument("The list of files is empty");
-  } else if (num_files > 1) {
-    // Verify that passed files don't have overlapping ranges in any particular
-    // level.
-    int min_level = 1;  // Check for overlaps in Level 1 and above.
-    int max_level = -1;
-    for (const auto& file_metadata : metadata_) {
-      if (file_metadata.level > max_level) {
-        max_level = file_metadata.level;
-      }
-    }
-    for (int level = min_level; level <= max_level; ++level) {
-      autovector<const IngestedFileInfo*> sorted_files;
-      for (size_t i = 0; i < num_files; i++) {
-        if (metadata_[i].level == level) {
-          sorted_files.push_back(&files_to_import_[i]);
-        }
-      }
-
-      std::sort(
-          sorted_files.begin(), sorted_files.end(),
-          [this](const IngestedFileInfo* info1, const IngestedFileInfo* info2) {
-            return cfd_->internal_comparator().Compare(
-                       info1->smallest_internal_key,
-                       info2->smallest_internal_key) < 0;
-          });
-
-      for (size_t i = 0; i + 1 < sorted_files.size(); i++) {
-        if (cfd_->internal_comparator().Compare(
-                sorted_files[i]->largest_internal_key,
-                sorted_files[i + 1]->smallest_internal_key) >= 0) {
-          return Status::InvalidArgument("Files have overlapping ranges");
-        }
-      }
-    }
   }
 
   for (const auto& f : files_to_import_) {
@@ -143,9 +110,6 @@ Status ImportColumnFamilyJob::Prepare(uint64_t next_file_number,
 // REQUIRES: we have become the only writer by entering both write_thread_ and
 // nonmem_write_thread_
 Status ImportColumnFamilyJob::Run() {
-  Status status;
-  edit_.SetColumnFamily(cfd_->GetID());
-
   // We use the import time as the ancester time. This is the time the data
   // is written to the database.
   int64_t temp_current_time = 0;
@@ -156,27 +120,67 @@ Status ImportColumnFamilyJob::Run() {
         static_cast<uint64_t>(temp_current_time);
   }
 
-  for (size_t i = 0; i < files_to_import_.size(); ++i) {
+  // Recover files' epoch number using dummy VersionStorageInfo
+  VersionBuilder dummy_version_builder(
+      cfd_->current()->version_set()->file_options(), cfd_->ioptions(),
+      cfd_->table_cache(), cfd_->current()->storage_info(),
+      cfd_->current()->version_set(),
+      cfd_->GetFileMetadataCacheReservationManager());
+  VersionStorageInfo dummy_vstorage(
+      &cfd_->internal_comparator(), cfd_->user_comparator(),
+      cfd_->NumberLevels(), cfd_->ioptions()->compaction_style,
+      nullptr /* src_vstorage */, cfd_->ioptions()->force_consistency_checks,
+      EpochNumberRequirement::kMightMissing);
+  Status s;
+  for (size_t i = 0; s.ok() && i < files_to_import_.size(); ++i) {
     const auto& f = files_to_import_[i];
     const auto& file_metadata = metadata_[i];
 
-    edit_.AddFile(file_metadata.level, f.fd.GetNumber(), f.fd.GetPathId(),
-                  f.fd.GetFileSize(), f.smallest_internal_key,
-                  f.largest_internal_key, file_metadata.smallest_seqno,
-                  file_metadata.largest_seqno, false, file_metadata.temperature,
-                  kInvalidBlobFileNumber, oldest_ancester_time, current_time,
-                  kUnknownFileChecksum, kUnknownFileChecksumFuncName,
-                  f.unique_id);
-
-    // If incoming sequence number is higher, update local sequence number.
-    if (file_metadata.largest_seqno > versions_->LastSequence()) {
-      versions_->SetLastAllocatedSequence(file_metadata.largest_seqno);
-      versions_->SetLastPublishedSequence(file_metadata.largest_seqno);
-      versions_->SetLastSequence(file_metadata.largest_seqno);
+    VersionEdit dummy_version_edit;
+    dummy_version_edit.AddFile(
+        file_metadata.level, f.fd.GetNumber(), f.fd.GetPathId(),
+        f.fd.GetFileSize(), f.smallest_internal_key, f.largest_internal_key,
+        file_metadata.smallest_seqno, file_metadata.largest_seqno, false,
+        file_metadata.temperature, kInvalidBlobFileNumber, oldest_ancester_time,
+        current_time, file_metadata.epoch_number, kUnknownFileChecksum,
+        kUnknownFileChecksumFuncName, f.unique_id);
+    s = dummy_version_builder.Apply(&dummy_version_edit);
+  }
+  if (s.ok()) {
+    s = dummy_version_builder.SaveTo(&dummy_vstorage);
+  }
+  if (s.ok()) {
+    dummy_vstorage.RecoverEpochNumbers(cfd_);
+  }
+
+  // Record changes from this CF import in VersionEdit, including files with
+  // recovered epoch numbers
+  if (s.ok()) {
+    edit_.SetColumnFamily(cfd_->GetID());
+
+    for (int level = 0; level < dummy_vstorage.num_levels(); level++) {
+      for (FileMetaData* file_meta : dummy_vstorage.LevelFiles(level)) {
+        edit_.AddFile(level, *file_meta);
+        // If incoming sequence number is higher, update local sequence number.
+        if (file_meta->fd.largest_seqno > versions_->LastSequence()) {
+          versions_->SetLastAllocatedSequence(file_meta->fd.largest_seqno);
+          versions_->SetLastPublishedSequence(file_meta->fd.largest_seqno);
+          versions_->SetLastSequence(file_meta->fd.largest_seqno);
+        }
+      }
     }
   }
 
-  return status;
+  // Release resources occupied by the dummy VersionStorageInfo
+  for (int level = 0; level < dummy_vstorage.num_levels(); level++) {
+    for (FileMetaData* file_meta : dummy_vstorage.LevelFiles(level)) {
+      file_meta->refs--;
+      if (file_meta->refs <= 0) {
+        delete file_meta;
+      }
+    }
+  }
+  return s;
 }
 
 void ImportColumnFamilyJob::Cleanup(const Status& status) {
@@ -306,7 +310,6 @@ Status ImportColumnFamilyJob::GetIngestedFileInfo(
 
   return status;
 }
-
 }  // namespace ROCKSDB_NAMESPACE
 
 #endif  // !ROCKSDB_LITE

package/deps/rocksdb/rocksdb/db/import_column_family_test.cc

@@ -556,10 +556,9 @@ TEST_F(ImportColumnFamilyTest, ImportColumnFamilyNegativeTest) {
         LiveFileMetaDataInit(file2_sst_name, sst_files_dir_, 1, 10, 19));
     metadata.db_comparator_name = options.comparator->Name();
 
-    ASSERT_EQ(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "yoyo",
-                                                ImportColumnFamilyOptions(),
-                                                metadata, &import_cfh_),
-              Status::InvalidArgument("Files have overlapping ranges"));
+    ASSERT_NOK(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "yoyo",
+                                                 ImportColumnFamilyOptions(),
+                                                 metadata, &import_cfh_));
     ASSERT_EQ(import_cfh_, nullptr);
   }
 

package/deps/rocksdb/rocksdb/db/merge_helper.cc

@@ -224,6 +224,10 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
       s = Status::ShutdownInProgress();
       return s;
     }
+    // Skip range tombstones emitted by the compaction iterator.
+    if (iter->IsDeleteRangeSentinelKey()) {
+      continue;
+    }
 
     ParsedInternalKey ikey;
     assert(keys_.size() == merge_context_.GetNumOperands());

package/deps/rocksdb/rocksdb/db/periodic_task_scheduler_test.cc

@@ -65,7 +65,7 @@ TEST_F(PeriodicTaskSchedulerTest, Basic) {
   ASSERT_EQ(kPeriodSec, dbfull()->GetDBOptions().stats_persist_period_sec);
 
   ASSERT_GT(kPeriodSec, 1u);
-  dbfull()->TEST_WaitForPeridicTaskRun([&] {
+  dbfull()->TEST_WaitForPeriodicTaskRun([&] {
     mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec) - 1);
   });
 
@@ -77,14 +77,14 @@ TEST_F(PeriodicTaskSchedulerTest, Basic) {
   ASSERT_EQ(1, pst_st_counter);
   ASSERT_EQ(1, flush_info_log_counter);
 
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
 
   ASSERT_EQ(2, dump_st_counter);
   ASSERT_EQ(2, pst_st_counter);
   ASSERT_EQ(2, flush_info_log_counter);
 
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
 
   ASSERT_EQ(3, dump_st_counter);
@@ -98,7 +98,7 @@ TEST_F(PeriodicTaskSchedulerTest, Basic) {
   ASSERT_EQ(0u, dbfull()->GetDBOptions().stats_persist_period_sec);
 
   // Info log flush should still run.
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
   ASSERT_EQ(3, dump_st_counter);
   ASSERT_EQ(3, pst_st_counter);
@@ -113,7 +113,7 @@ TEST_F(PeriodicTaskSchedulerTest, Basic) {
 
   ASSERT_EQ(2, scheduler.TEST_GetValidTaskNum());
 
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kPeriodSec)); });
   ASSERT_EQ(4, dump_st_counter);
   ASSERT_EQ(3, pst_st_counter);
@@ -154,19 +154,19 @@ TEST_F(PeriodicTaskSchedulerTest, MultiInstances) {
   ASSERT_EQ(kInstanceNum * 3, scheduler.TEST_GetValidTaskNum());
 
   int expected_run = kInstanceNum;
-  dbi->TEST_WaitForPeridicTaskRun(
+  dbi->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(kPeriodSec - 1); });
   ASSERT_EQ(expected_run, dump_st_counter);
   ASSERT_EQ(expected_run, pst_st_counter);
 
   expected_run += kInstanceNum;
-  dbi->TEST_WaitForPeridicTaskRun(
+  dbi->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(kPeriodSec); });
   ASSERT_EQ(expected_run, dump_st_counter);
   ASSERT_EQ(expected_run, pst_st_counter);
 
   expected_run += kInstanceNum;
-  dbi->TEST_WaitForPeridicTaskRun(
+  dbi->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(kPeriodSec); });
   ASSERT_EQ(expected_run, dump_st_counter);
   ASSERT_EQ(expected_run, pst_st_counter);
@@ -178,9 +178,9 @@ TEST_F(PeriodicTaskSchedulerTest, MultiInstances) {
 
   expected_run += (kInstanceNum - half) * 2;
 
-  dbi->TEST_WaitForPeridicTaskRun(
+  dbi->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(kPeriodSec); });
-  dbi->TEST_WaitForPeridicTaskRun(
+  dbi->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(kPeriodSec); });
   ASSERT_EQ(expected_run, dump_st_counter);
   ASSERT_EQ(expected_run, pst_st_counter);

package/deps/rocksdb/rocksdb/db/repair.cc

@@ -59,6 +59,7 @@
 //   Store per-table metadata (smallest, largest, largest-seq#, ...)
 //   in the table's meta section to speed up ScanTable.
 
+#include "db/version_builder.h"
 #ifndef ROCKSDB_LITE
 
 #include <cinttypes>
@@ -640,38 +641,79 @@ class Repairer {
     for (const auto& cf_id_and_tables : cf_id_to_tables) {
       auto* cfd =
           vset_.GetColumnFamilySet()->GetColumnFamily(cf_id_and_tables.first);
-      VersionEdit edit;
-      edit.SetComparatorName(cfd->user_comparator()->Name());
-      edit.SetLogNumber(0);
-      edit.SetNextFile(next_file_number_);
-      edit.SetColumnFamily(cfd->GetID());
 
-      // TODO(opt): separate out into multiple levels
+      // Recover files' epoch number using dummy VersionStorageInfo
+      VersionBuilder dummy_version_builder(
+          cfd->current()->version_set()->file_options(), cfd->ioptions(),
+          cfd->table_cache(), cfd->current()->storage_info(),
+          cfd->current()->version_set(),
+          cfd->GetFileMetadataCacheReservationManager());
+      VersionStorageInfo dummy_vstorage(
+          &cfd->internal_comparator(), cfd->user_comparator(),
+          cfd->NumberLevels(), cfd->ioptions()->compaction_style,
+          nullptr /* src_vstorage */, cfd->ioptions()->force_consistency_checks,
+          EpochNumberRequirement::kMightMissing);
+      Status s;
+      VersionEdit dummy_edit;
       for (const auto* table : cf_id_and_tables.second) {
-        edit.AddFile(
+        // TODO(opt): separate out into multiple levels
+        dummy_edit.AddFile(
             0, table->meta.fd.GetNumber(), table->meta.fd.GetPathId(),
             table->meta.fd.GetFileSize(), table->meta.smallest,
             table->meta.largest, table->meta.fd.smallest_seqno,
             table->meta.fd.largest_seqno, table->meta.marked_for_compaction,
             table->meta.temperature, table->meta.oldest_blob_file_number,
             table->meta.oldest_ancester_time, table->meta.file_creation_time,
-            table->meta.file_checksum, table->meta.file_checksum_func_name,
-            table->meta.unique_id);
+            table->meta.epoch_number, table->meta.file_checksum,
+            table->meta.file_checksum_func_name, table->meta.unique_id);
       }
-      assert(next_file_number_ > 0);
-      vset_.MarkFileNumberUsed(next_file_number_ - 1);
-      mutex_.Lock();
-      std::unique_ptr<FSDirectory> db_dir;
-      Status status = env_->GetFileSystem()->NewDirectory(dbname_, IOOptions(),
-                                                          &db_dir, nullptr);
-      if (status.ok()) {
-        status = vset_.LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
-                                   &edit, &mutex_, db_dir.get(),
-                                   false /* new_descriptor_log */);
+      s = dummy_version_builder.Apply(&dummy_edit);
+      if (s.ok()) {
+        s = dummy_version_builder.SaveTo(&dummy_vstorage);
       }
-      mutex_.Unlock();
-      if (!status.ok()) {
-        return status;
+      if (s.ok()) {
+        dummy_vstorage.RecoverEpochNumbers(cfd);
+      }
+      if (s.ok()) {
+        // Record changes from this repair in VersionEdit, including files with
+        // recovered epoch numbers
+        VersionEdit edit;
+        edit.SetComparatorName(cfd->user_comparator()->Name());
+        edit.SetLogNumber(0);
+        edit.SetNextFile(next_file_number_);
+        edit.SetColumnFamily(cfd->GetID());
+        for (int level = 0; level < dummy_vstorage.num_levels(); ++level) {
+          for (FileMetaData* file_meta : dummy_vstorage.LevelFiles(level)) {
+            edit.AddFile(level, *file_meta);
+          }
+        }
+
+        // Release resources occupied by the dummy VersionStorageInfo
+        for (int level = 0; level < dummy_vstorage.num_levels(); ++level) {
+          for (FileMetaData* file_meta : dummy_vstorage.LevelFiles(level)) {
+            file_meta->refs--;
+            if (file_meta->refs <= 0) {
+              delete file_meta;
+            }
+          }
+        }
+
+        // Persist record of changes
+        assert(next_file_number_ > 0);
+        vset_.MarkFileNumberUsed(next_file_number_ - 1);
+        mutex_.Lock();
+        std::unique_ptr<FSDirectory> db_dir;
+        s = env_->GetFileSystem()->NewDirectory(dbname_, IOOptions(), &db_dir,
+                                                nullptr);
+        if (s.ok()) {
+          s = vset_.LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(), &edit,
+                                &mutex_, db_dir.get(),
+                                false /* new_descriptor_log */);
+        }
+        mutex_.Unlock();
+      }
+      if (!s.ok()) {
+        return s;
       }
     }
     return Status::OK();

package/deps/rocksdb/rocksdb/db/repair_test.cc

@@ -62,8 +62,62 @@ class RepairTest : public DBTestBase {
     ASSERT_GT(verify_passed, 0);
     SyncPoint::GetInstance()->DisableProcessing();
   }
+
+  std::vector<FileMetaData*> GetLevelFileMetadatas(int level, int cf = 0) {
+    VersionSet* const versions = dbfull()->GetVersionSet();
+    assert(versions);
+    ColumnFamilyData* const cfd =
+        versions->GetColumnFamilySet()->GetColumnFamily(cf);
+    assert(cfd);
+    Version* const current = cfd->current();
+    assert(current);
+    VersionStorageInfo* const storage_info = current->storage_info();
+    assert(storage_info);
+    return storage_info->LevelFiles(level);
+  }
 };
 
+TEST_F(RepairTest, SortRepairedDBL0ByEpochNumber) {
+  Options options = CurrentOptions();
+  DestroyAndReopen(options);
+
+  ASSERT_OK(Put("k1", "oldest"));
+  ASSERT_OK(Put("k1", "older"));
+  ASSERT_OK(Flush());
+  MoveFilesToLevel(1);
+
+  ASSERT_OK(Put("k1", "old"));
+  ASSERT_OK(Flush());
+
+  ASSERT_OK(Put("k1", "new"));
+
+  std::vector<FileMetaData*> level0_files = GetLevelFileMetadatas(0 /* level*/);
+  ASSERT_EQ(level0_files.size(), 1);
+  ASSERT_EQ(level0_files[0]->epoch_number, 2);
+  std::vector<FileMetaData*> level1_files = GetLevelFileMetadatas(1 /* level*/);
+  ASSERT_EQ(level1_files.size(), 1);
+  ASSERT_EQ(level1_files[0]->epoch_number, 1);
+
+  std::string manifest_path =
+      DescriptorFileName(dbname_, dbfull()->TEST_Current_Manifest_FileNo());
+  Close();
+  ASSERT_OK(env_->FileExists(manifest_path));
+  ASSERT_OK(env_->DeleteFile(manifest_path));
+
+  ASSERT_OK(RepairDB(dbname_, CurrentOptions()));
+  ReopenWithSstIdVerify();
+
+  EXPECT_EQ(Get("k1"), "new");
+
+  level0_files = GetLevelFileMetadatas(0 /* level*/);
+  ASSERT_EQ(level0_files.size(), 3);
+  EXPECT_EQ(level0_files[0]->epoch_number, 3);
+  EXPECT_EQ(level0_files[1]->epoch_number, 2);
+  EXPECT_EQ(level0_files[2]->epoch_number, 1);
+  level1_files = GetLevelFileMetadatas(1 /* level*/);
+  ASSERT_EQ(level1_files.size(), 0);
+}
+
 TEST_F(RepairTest, LostManifest) {
   // Add a couple SST files, delete the manifest, and verify RepairDB() saves
   // the day.

package/deps/rocksdb/rocksdb/db/seqno_time_test.cc

@@ -80,7 +80,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicUniversal) {
 
   // pass some time first, otherwise the first a few keys write time are going
   // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec)); });
 
   int sst_num = 0;
@@ -88,7 +88,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicUniversal) {
   for (; sst_num < kNumTrigger; sst_num++) {
     for (int i = 0; i < kNumKeys; i++) {
       ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
         mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
       });
     }
@@ -110,7 +110,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicUniversal) {
   for (; sst_num < kNumTrigger * 2; sst_num++) {
     for (int i = 0; i < kNumKeys; i++) {
       ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
         mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
       });
     }
@@ -124,7 +124,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicUniversal) {
   for (; sst_num < kNumTrigger * 3; sst_num++) {
     for (int i = 0; i < kNumKeys; i++) {
       ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
         mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
       });
     }
@@ -143,7 +143,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicUniversal) {
   AssertKeyTemperature(20, Temperature::kCold);
 
   for (int i = 0; i < 30; i++) {
-    dbfull()->TEST_WaitForPeridicTaskRun([&] {
+    dbfull()->TEST_WaitForPeriodicTaskRun([&] {
       mock_clock_->MockSleepForSeconds(static_cast<int>(20 * kKeyPerSec));
     });
     ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
@@ -161,7 +161,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicUniversal) {
   // the compaction will not get the new seqno->time sampling to decide the last
   // a few data's time.
   for (int i = 0; i < 5; i++) {
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1000)); });
     ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
   }
@@ -192,7 +192,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicLevel) {
 
   // pass some time first, otherwise the first a few keys write time are going
   // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
 
   int sst_num = 0;
@@ -200,7 +200,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicLevel) {
   for (; sst_num < 4; sst_num++) {
     for (int i = 0; i < kNumKeys; i++) {
       ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun(
+      dbfull()->TEST_WaitForPeriodicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
     }
     ASSERT_OK(Flush());
@@ -222,7 +222,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicLevel) {
   for (; sst_num < 14; sst_num++) {
     for (int i = 0; i < kNumKeys; i++) {
       ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun(
+      dbfull()->TEST_WaitForPeriodicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
     }
     ASSERT_OK(Flush());
@@ -243,7 +243,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicLevel) {
   // Wait some time, with each wait, the cold data is increasing and hot data is
   // decreasing
   for (int i = 0; i < 30; i++) {
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(200)); });
     ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
     uint64_t pre_hot = hot_data_size;
@@ -262,7 +262,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicLevel) {
   // hot data might not be empty, because if we don't write new data, there's
   // no seqno->time sampling available to the compaction
   for (int i = 0; i < 5; i++) {
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1000)); });
     ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
   }
@@ -324,7 +324,7 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   // Write a key every 10 seconds
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
   }
   ASSERT_OK(Flush());
@@ -357,7 +357,7 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   // Write a key every 1 seconds
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i + 190), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1)); });
   }
   seq_end = dbfull()->GetLatestSequenceNumber();
@@ -393,7 +393,7 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   // Write a key every 200 seconds
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i + 380), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(200)); });
   }
   seq_end = dbfull()->GetLatestSequenceNumber();
@@ -435,7 +435,7 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   // Write a key every 100 seconds
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i + 570), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   seq_end = dbfull()->GetLatestSequenceNumber();
@@ -516,7 +516,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   // Write some data and increase the current time
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   ASSERT_OK(Flush());
@@ -536,7 +536,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   // Write some data to the default CF (without preclude_last_level feature)
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   ASSERT_OK(Flush());
@@ -544,7 +544,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   // Write some data to the CF one
   for (int i = 0; i < 20; i++) {
     ASSERT_OK(Put(1, Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
   }
   ASSERT_OK(Flush(1));
@@ -568,7 +568,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   // Add more data to CF "two" to fill the in memory mapping
   for (int i = 0; i < 2000; i++) {
     ASSERT_OK(Put(2, Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   seqs = dbfull()->TEST_GetSeqnoToTimeMapping().TEST_GetInternalMapping();
@@ -592,7 +592,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   // enabled have flushed, the in-memory seqno->time mapping should be cleared
   for (int i = 0; i < 10; i++) {
     ASSERT_OK(Put(0, Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   seqs = dbfull()->TEST_GetSeqnoToTimeMapping().TEST_GetInternalMapping();
@@ -603,7 +603,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   for (int j = 0; j < 3; j++) {
     for (int i = 0; i < 200; i++) {
       ASSERT_OK(Put(2, Key(i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun(
+      dbfull()->TEST_WaitForPeriodicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
     }
     ASSERT_OK(Flush(2));
@@ -623,7 +623,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   for (int j = 0; j < 2; j++) {
     for (int i = 0; i < 200; i++) {
       ASSERT_OK(Put(0, Key(i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun(
+      dbfull()->TEST_WaitForPeriodicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
     }
     ASSERT_OK(Flush(0));
@@ -638,7 +638,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   // Write some data to CF "two", but don't flush to accumulate
   for (int i = 0; i < 1000; i++) {
     ASSERT_OK(Put(2, Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   ASSERT_GE(
@@ -682,7 +682,7 @@ TEST_P(SeqnoTimeTablePropTest, MultiInstancesBasic) {
   WriteOptions wo;
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(dbi->Put(wo, Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   SeqnoToTimeMapping seqno_to_time_mapping = dbi->TEST_GetSeqnoToTimeMapping();
@@ -720,7 +720,7 @@ TEST_P(SeqnoTimeTablePropTest, SeqnoToTimeMappingUniversal) {
   for (; sst_num < kNumTrigger - 1; sst_num++) {
     for (int i = 0; i < kNumKeys; i++) {
       ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun(
+      dbfull()->TEST_WaitForPeriodicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
     }
     ASSERT_OK(Flush());
@@ -742,7 +742,7 @@ TEST_P(SeqnoTimeTablePropTest, SeqnoToTimeMappingUniversal) {
   // Trigger a compaction
   for (int i = 0; i < kNumKeys; i++) {
     ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
   }
   sst_num++;

package/deps/rocksdb/rocksdb/db/table_cache.cc

@@ -127,6 +127,8 @@ Status TableCache::GetTableReader(
   FileOptions fopts = file_options;
   fopts.temperature = file_temperature;
   Status s = PrepareIOFromReadOptions(ro, ioptions_.clock, fopts.io_options);
+  TEST_SYNC_POINT_CALLBACK("TableCache::GetTableReader:BeforeOpenFile",
+                           const_cast<Status*>(&s));
   if (s.ok()) {
     s = ioptions_.fs->NewRandomAccessFile(fname, fopts, &file, nullptr);
   }