@nxtedition/rocksdb 8.1.2 → 8.1.4

package/deps/rocksdb/rocksdb/db/version_set.cc

@@ -39,8 +39,6 @@
 #include "db/table_cache.h"
 #include "db/version_builder.h"
 #include "db/version_edit_handler.h"
-#include "table/compaction_merging_iterator.h"
-
 #if USE_COROUTINES
 #include "folly/experimental/coro/BlockingWait.h"
 #include "folly/experimental/coro/Collect.h"
@@ -1773,8 +1771,8 @@ void Version::GetColumnFamilyMetaData(ColumnFamilyMetaData* cf_meta) {
           file->stats.num_reads_sampled.load(std::memory_order_relaxed),
           file->being_compacted, file->temperature,
           file->oldest_blob_file_number, file->TryGetOldestAncesterTime(),
-          file->TryGetFileCreationTime(), file->epoch_number,
-          file->file_checksum, file->file_checksum_func_name);
+          file->TryGetFileCreationTime(), file->file_checksum,
+          file->file_checksum_func_name);
       files.back().num_entries = file->num_entries;
       files.back().num_deletions = file->num_deletions;
       level_size += file->fd.GetFileSize();
@@ -2038,8 +2036,7 @@ VersionStorageInfo::VersionStorageInfo(
     const InternalKeyComparator* internal_comparator,
     const Comparator* user_comparator, int levels,
     CompactionStyle compaction_style, VersionStorageInfo* ref_vstorage,
-    bool _force_consistency_checks,
-    EpochNumberRequirement epoch_number_requirement)
+    bool _force_consistency_checks)
     : internal_comparator_(internal_comparator),
       user_comparator_(user_comparator),
       // cfd is nullptr if Version is dummy
@@ -2067,8 +2064,7 @@ VersionStorageInfo::VersionStorageInfo(
       current_num_samples_(0),
       estimated_compaction_needed_bytes_(0),
       finalized_(false),
-      force_consistency_checks_(_force_consistency_checks),
-      epoch_number_requirement_(epoch_number_requirement) {
+      force_consistency_checks_(_force_consistency_checks) {
   if (ref_vstorage != nullptr) {
     accumulated_file_size_ = ref_vstorage->accumulated_file_size_;
     accumulated_raw_key_size_ = ref_vstorage->accumulated_raw_key_size_;
@@ -2089,8 +2085,7 @@ Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
                  const FileOptions& file_opt,
                  const MutableCFOptions mutable_cf_options,
                  const std::shared_ptr<IOTracer>& io_tracer,
-                 uint64_t version_number,
-                 EpochNumberRequirement epoch_number_requirement)
+                 uint64_t version_number)
     : env_(vset->env_),
       clock_(vset->clock_),
       cfd_(column_family_data),
@@ -2109,8 +2104,7 @@ Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
           (cfd_ == nullptr || cfd_->current() == nullptr)
               ? nullptr
               : cfd_->current()->storage_info(),
-          cfd_ == nullptr ? false : cfd_->ioptions()->force_consistency_checks,
-          epoch_number_requirement),
+          cfd_ == nullptr ? false : cfd_->ioptions()->force_consistency_checks),
       vset_(vset),
       next_(this),
       prev_(this),
@@ -2960,7 +2954,7 @@ bool Version::MaybeInitializeFileMetaData(FileMetaData* file_meta) {
   file_meta->num_deletions = tp->num_deletions;
   file_meta->raw_value_size = tp->raw_value_size;
   file_meta->raw_key_size = tp->raw_key_size;
-  file_meta->num_range_deletions = tp->num_range_deletions;
+
   return true;
 }
 
@@ -3062,15 +3056,11 @@ void VersionStorageInfo::ComputeCompensatedSizes() {
         // size of deletion entries in a stable workload, the deletion
         // compensation logic might introduce unwanted effet which changes the
         // shape of LSM tree.
-        if ((file_meta->num_deletions - file_meta->num_range_deletions) * 2 >=
-            file_meta->num_entries) {
+        if (file_meta->num_deletions * 2 >= file_meta->num_entries) {
           file_meta->compensated_file_size +=
-              ((file_meta->num_deletions - file_meta->num_range_deletions) * 2 -
-               file_meta->num_entries) *
+              (file_meta->num_deletions * 2 - file_meta->num_entries) *
               average_value_size * kDeletionWeightOnCompaction;
         }
-        file_meta->compensated_file_size +=
-            file_meta->compensated_range_deletion_size;
       }
     }
   }
@@ -4290,74 +4280,6 @@ const char* VersionStorageInfo::LevelFileSummary(FileSummaryStorage* scratch,
   return scratch->buffer;
 }
 
-bool VersionStorageInfo::HasMissingEpochNumber() const {
-  for (int level = 0; level < num_levels_; ++level) {
-    for (const FileMetaData* f : files_[level]) {
-      if (f->epoch_number == kUnknownEpochNumber) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-uint64_t VersionStorageInfo::GetMaxEpochNumberOfFiles() const {
-  uint64_t max_epoch_number = kUnknownEpochNumber;
-  for (int level = 0; level < num_levels_; ++level) {
-    for (const FileMetaData* f : files_[level]) {
-      max_epoch_number = std::max(max_epoch_number, f->epoch_number);
-    }
-  }
-  return max_epoch_number;
-}
-
-void VersionStorageInfo::RecoverEpochNumbers(ColumnFamilyData* cfd) {
-  cfd->ResetNextEpochNumber();
-
-  bool reserve_epoch_num_for_file_ingested_behind =
-      cfd->ioptions()->allow_ingest_behind;
-  if (reserve_epoch_num_for_file_ingested_behind) {
-    uint64_t reserved_epoch_number = cfd->NewEpochNumber();
-    assert(reserved_epoch_number == kReservedEpochNumberForFileIngestedBehind);
-    ROCKS_LOG_INFO(cfd->ioptions()->info_log.get(),
-                   "[%s]CF has reserved epoch number %" PRIu64
-                   " for files ingested "
-                   "behind since `Options::allow_ingest_behind` is true",
-                   cfd->GetName().c_str(), reserved_epoch_number);
-  }
-
-  if (HasMissingEpochNumber()) {
-    assert(epoch_number_requirement_ == EpochNumberRequirement::kMightMissing);
-    assert(num_levels_ >= 1);
-
-    for (int level = num_levels_ - 1; level >= 1; --level) {
-      auto& files_at_level = files_[level];
-      if (files_at_level.empty()) {
-        continue;
-      }
-      uint64_t next_epoch_number = cfd->NewEpochNumber();
-      for (FileMetaData* f : files_at_level) {
-        f->epoch_number = next_epoch_number;
-      }
-    }
-
-    for (auto file_meta_iter = files_[0].rbegin();
-         file_meta_iter != files_[0].rend(); file_meta_iter++) {
-      FileMetaData* f = *file_meta_iter;
-      f->epoch_number = cfd->NewEpochNumber();
-    }
-
-    ROCKS_LOG_WARN(cfd->ioptions()->info_log.get(),
-                   "[%s]CF's epoch numbers are inferred based on seqno",
-                   cfd->GetName().c_str());
-    epoch_number_requirement_ = EpochNumberRequirement::kMustPresent;
-  } else {
-    assert(epoch_number_requirement_ == EpochNumberRequirement::kMustPresent);
-    cfd->SetNextEpochNumber(
-        std::max(GetMaxEpochNumberOfFiles() + 1, cfd->GetNextEpochNumber()));
-  }
-}
-
 uint64_t VersionStorageInfo::MaxNextLevelOverlappingBytes() {
   uint64_t result = 0;
   std::vector<FileMetaData*> overlaps;
@@ -5055,15 +4977,10 @@ Status VersionSet::ProcessManifestWrites(
   if (!descriptor_log_ ||
       manifest_file_size_ > db_options_->max_manifest_file_size) {
     TEST_SYNC_POINT("VersionSet::ProcessManifestWrites:BeforeNewManifest");
-    TEST_SYNC_POINT_CALLBACK(
-        "VersionSet::ProcessManifestWrites:BeforeNewManifest", nullptr);
     new_descriptor_log = true;
   } else {
     pending_manifest_file_number_ = manifest_file_number_;
   }
-  TEST_SYNC_POINT_CALLBACK(
-      "VersionSet::ProcessManifestWrites:PostDecidingCreateNewManifestOrNot",
-      &new_descriptor_log);
 
   // Local cached copy of state variable(s). WriteCurrentStateToManifest()
   // reads its content after releasing db mutex to avoid race with
@@ -5192,7 +5109,6 @@ Status VersionSet::ProcessManifestWrites(
           break;
         }
       }
-
       if (s.ok()) {
         io_s = SyncManifest(db_options_, descriptor_log_->file());
         manifest_io_status = io_s;
@@ -5600,8 +5516,7 @@ Status VersionSet::GetCurrentManifestPath(const std::string& dbname,
 Status VersionSet::Recover(
     const std::vector<ColumnFamilyDescriptor>& column_families, bool read_only,
     std::string* db_id, bool no_error_if_files_missing) {
-  // Read "CURRENT" file, which contains a pointer to the current manifest
-  // file
+  // Read "CURRENT" file, which contains a pointer to the current manifest file
   std::string manifest_path;
   Status s = GetCurrentManifestPath(dbname_, fs_.get(), &manifest_path,
                                     &manifest_file_number_);
@@ -5635,8 +5550,7 @@ Status VersionSet::Recover(
                        true /* checksum */, 0 /* log_number */);
     VersionEditHandler handler(
         read_only, column_families, const_cast<VersionSet*>(this),
-        /*track_missing_files=*/false, no_error_if_files_missing, io_tracer_,
-        EpochNumberRequirement::kMightMissing);
+        /*track_missing_files=*/false, no_error_if_files_missing, io_tracer_);
     handler.Iterate(reader, &log_read_status);
     s = handler.status();
     if (s.ok()) {
@@ -5645,9 +5559,6 @@ Status VersionSet::Recover(
       assert(current_manifest_file_size != 0);
       handler.GetDbId(db_id);
     }
-    if (s.ok()) {
-      RecoverEpochNumbers();
-    }
   }
 
   if (s.ok()) {
@@ -5807,8 +5718,7 @@ Status VersionSet::TryRecoverFromOneManifest(
   log::Reader reader(nullptr, std::move(manifest_file_reader), &reporter,
                      /*checksum=*/true, /*log_num=*/0);
   VersionEditHandlerPointInTime handler_pit(
-      read_only, column_families, const_cast<VersionSet*>(this), io_tracer_,
-      EpochNumberRequirement::kMightMissing);
+      read_only, column_families, const_cast<VersionSet*>(this), io_tracer_);
 
   handler_pit.Iterate(reader, &s);
 
@@ -5817,21 +5727,7 @@ Status VersionSet::TryRecoverFromOneManifest(
   assert(nullptr != has_missing_table_file);
   *has_missing_table_file = handler_pit.HasMissingFiles();
 
-  s = handler_pit.status();
-  if (s.ok()) {
-    RecoverEpochNumbers();
-  }
-  return s;
-}
-
-void VersionSet::RecoverEpochNumbers() {
-  for (auto cfd : *column_family_set_) {
-    if (cfd->IsDropped()) {
-      continue;
-    }
-    assert(cfd->initialized());
-    cfd->RecoverEpochNumbers();
-  }
+  return handler_pit.status();
 }
 
 Status VersionSet::ListColumnFamilies(std::vector<std::string>* column_families,
@@ -6151,22 +6047,6 @@ Status VersionSet::WriteCurrentStateToManifest(
     }
   }
 
-  // New manifest should rollover the WAL deletion record from previous
-  // manifest. Otherwise, when an addition record of a deleted WAL gets added to
-  // this new manifest later (which can happens in e.g, SyncWAL()), this new
-  // manifest creates an illusion that such WAL hasn't been deleted.
-  VersionEdit wal_deletions;
-  wal_deletions.DeleteWalsBefore(min_log_number_to_keep());
-  std::string wal_deletions_record;
-  if (!wal_deletions.EncodeTo(&wal_deletions_record)) {
-    return Status::Corruption("Unable to Encode VersionEdit: " +
-                              wal_deletions.DebugString(true));
-  }
-  io_s = log->AddRecord(wal_deletions_record);
-  if (!io_s.ok()) {
-    return io_s;
-  }
-
   for (auto cfd : *column_family_set_) {
     assert(cfd);
 
@@ -6218,9 +6098,8 @@ Status VersionSet::WriteCurrentStateToManifest(
                        f->fd.smallest_seqno, f->fd.largest_seqno,
                        f->marked_for_compaction, f->temperature,
                        f->oldest_blob_file_number, f->oldest_ancester_time,
-                       f->file_creation_time, f->epoch_number, f->file_checksum,
-                       f->file_checksum_func_name, f->unique_id,
-                       f->compensated_range_deletion_size);
+                       f->file_creation_time, f->file_checksum,
+                       f->file_checksum_func_name, f->unique_id);
         }
       }
 
@@ -6298,9 +6177,8 @@ uint64_t VersionSet::ApproximateSize(const SizeApproximationOptions& options,
   const int num_non_empty_levels = vstorage->num_non_empty_levels();
   end_level = (end_level == -1) ? num_non_empty_levels
                                 : std::min(end_level, num_non_empty_levels);
-  if (end_level <= start_level) {
-    return 0;
-  }
+
+  assert(start_level <= end_level);
 
   // Outline of the optimization that uses options.files_size_error_margin.
   // When approximating the files total size that is used to store a keys range,
@@ -6592,14 +6470,6 @@ InternalIterator* VersionSet::MakeInputIterator(
                                               c->num_input_levels() - 1
                                         : c->num_input_levels());
   InternalIterator** list = new InternalIterator*[space];
-  // First item in the pair is a pointer to range tombstones.
-  // Second item is a pointer to a member of a LevelIterator,
-  // that will be initialized to where CompactionMergingIterator stores
-  // pointer to its range tombstones. This is used by LevelIterator
-  // to update pointer to range tombstones as it traverse different SST files.
-  std::vector<
-      std::pair<TruncatedRangeDelIterator*, TruncatedRangeDelIterator***>>
-      range_tombstones;
   size_t num = 0;
   for (size_t which = 0; which < c->num_input_levels(); which++) {
     if (c->input_levels(which)->num_files != 0) {
@@ -6620,7 +6490,7 @@ InternalIterator* VersionSet::MakeInputIterator(
                   end.value(), fmd.smallest.user_key()) < 0) {
             continue;
           }
-          TruncatedRangeDelIterator* range_tombstone_iter = nullptr;
+
           list[num++] = cfd->table_cache()->NewIterator(
               read_options, file_options_compactions,
               cfd->internal_comparator(), fmd, range_del_agg,
@@ -6633,13 +6503,10 @@ InternalIterator* VersionSet::MakeInputIterator(
               MaxFileSizeForL0MetaPin(*c->mutable_cf_options()),
               /*smallest_compaction_key=*/nullptr,
               /*largest_compaction_key=*/nullptr,
-              /*allow_unprepared_value=*/false,
-              /*range_del_iter=*/&range_tombstone_iter);
-          range_tombstones.emplace_back(range_tombstone_iter, nullptr);
+              /*allow_unprepared_value=*/false);
         }
       } else {
         // Create concatenating iterator for the files from this level
-        TruncatedRangeDelIterator*** tombstone_iter_ptr = nullptr;
         list[num++] = new LevelIterator(
             cfd->table_cache(), read_options, file_options_compactions,
             cfd->internal_comparator(), c->input_levels(which),
@@ -6648,15 +6515,14 @@ InternalIterator* VersionSet::MakeInputIterator(
             /*no per level latency histogram=*/nullptr,
             TableReaderCaller::kCompaction, /*skip_filters=*/false,
             /*level=*/static_cast<int>(c->level(which)), range_del_agg,
-            c->boundaries(which), false, &tombstone_iter_ptr);
-        range_tombstones.emplace_back(nullptr, tombstone_iter_ptr);
+            c->boundaries(which));
       }
     }
   }
   assert(num <= space);
-  InternalIterator* result = NewCompactionMergingIterator(
-      &c->column_family_data()->internal_comparator(), list,
-      static_cast<int>(num), range_tombstones);
+  InternalIterator* result =
+      NewMergingIterator(&c->column_family_data()->internal_comparator(), list,
+                         static_cast<int>(num));
   delete[] list;
   return result;
 }
@@ -6723,7 +6589,6 @@ void VersionSet::GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata) {
         filemetadata.temperature = file->temperature;
         filemetadata.oldest_ancester_time = file->TryGetOldestAncesterTime();
         filemetadata.file_creation_time = file->TryGetFileCreationTime();
-        filemetadata.epoch_number = file->epoch_number;
         metadata->push_back(filemetadata);
       }
     }
@@ -6926,17 +6791,12 @@ Status ReactiveVersionSet::Recover(
   log::Reader* reader = manifest_reader->get();
   assert(reader);
 
-  manifest_tailer_.reset(
-      new ManifestTailer(column_families, const_cast<ReactiveVersionSet*>(this),
-                         io_tracer_, EpochNumberRequirement::kMightMissing));
+  manifest_tailer_.reset(new ManifestTailer(
+      column_families, const_cast<ReactiveVersionSet*>(this), io_tracer_));
 
   manifest_tailer_->Iterate(*reader, manifest_reader_status->get());
 
-  s = manifest_tailer_->status();
-  if (s.ok()) {
-    RecoverEpochNumbers();
-  }
-  return s;
+  return manifest_tailer_->status();
 }
 
 Status ReactiveVersionSet::ReadAndApply(

package/deps/rocksdb/rocksdb/db/version_set.h

@@ -116,10 +116,6 @@ extern bool SomeFileOverlapsRange(const InternalKeyComparator& icmp,
 extern void DoGenerateLevelFilesBrief(LevelFilesBrief* file_level,
                                       const std::vector<FileMetaData*>& files,
                                       Arena* arena);
-enum EpochNumberRequirement {
-  kMightMissing,
-  kMustPresent,
-};
 
 // Information of the storage associated with each Version, including number of
 // levels of LSM tree, files information at each level, files marked for
@@ -130,9 +126,7 @@ class VersionStorageInfo {
                      const Comparator* user_comparator, int num_levels,
                      CompactionStyle compaction_style,
                      VersionStorageInfo* src_vstorage,
-                     bool _force_consistency_checks,
-                     EpochNumberRequirement epoch_number_requirement =
-                         EpochNumberRequirement::kMustPresent);
+                     bool _force_consistency_checks);
   // No copying allowed
   VersionStorageInfo(const VersionStorageInfo&) = delete;
   void operator=(const VersionStorageInfo&) = delete;
@@ -325,17 +319,6 @@ class VersionStorageInfo {
     return files_[level];
   }
 
-  bool HasMissingEpochNumber() const;
-  uint64_t GetMaxEpochNumberOfFiles() const;
-  EpochNumberRequirement GetEpochNumberRequirement() const {
-    return epoch_number_requirement_;
-  }
-  void SetEpochNumberRequirement(
-      EpochNumberRequirement epoch_number_requirement) {
-    epoch_number_requirement_ = epoch_number_requirement;
-  }
-  void RecoverEpochNumbers(ColumnFamilyData* cfd);
-
   class FileLocation {
    public:
     FileLocation() = default;
@@ -457,11 +440,6 @@ class VersionStorageInfo {
     return files_marked_for_compaction_;
   }
 
-  void TEST_AddFileMarkedForCompaction(int level, FileMetaData* f) {
-    f->marked_for_compaction = true;
-    files_marked_for_compaction_.emplace_back(level, f);
-  }
-
   // REQUIRES: ComputeCompactionScore has been called
   // REQUIRES: DB mutex held during access
   const autovector<std::pair<int, FileMetaData*>>& ExpiredTtlFiles() const {
@@ -745,8 +723,6 @@ class VersionStorageInfo {
   // is compiled in release mode
   bool force_consistency_checks_;
 
-  EpochNumberRequirement epoch_number_requirement_;
-
   friend class Version;
   friend class VersionSet;
 };
@@ -1071,9 +1047,7 @@ class Version {
   Version(ColumnFamilyData* cfd, VersionSet* vset, const FileOptions& file_opt,
           MutableCFOptions mutable_cf_options,
           const std::shared_ptr<IOTracer>& io_tracer,
-          uint64_t version_number = 0,
-          EpochNumberRequirement epoch_number_requirement =
-              EpochNumberRequirement::kMustPresent);
+          uint64_t version_number = 0);
 
   ~Version();
 
@@ -1214,10 +1188,6 @@ class VersionSet {
       const std::vector<ColumnFamilyDescriptor>& column_families,
       bool read_only, std::string* db_id, bool* has_missing_table_file);
 
-  // Recover the next epoch number of each CFs and epoch number
-  // of their files (if missing)
-  void RecoverEpochNumbers();
-
   // Reads a manifest file and returns a list of column families in
   // column_families.
   static Status ListColumnFamilies(std::vector<std::string>* column_families,

package/deps/rocksdb/rocksdb/db/version_set_test.cc

@@ -14,7 +14,6 @@
 #include "db/db_impl/db_impl.h"
 #include "db/db_test_util.h"
 #include "db/log_writer.h"
-#include "db/version_edit.h"
 #include "rocksdb/advanced_options.h"
 #include "rocksdb/convenience.h"
 #include "rocksdb/file_system.h"
@@ -50,8 +49,8 @@ class GenerateLevelFilesBriefTest : public testing::Test {
         InternalKey(largest, largest_seq, kTypeValue), smallest_seq,
         largest_seq, /* marked_for_compact */ false, Temperature::kUnknown,
         kInvalidBlobFileNumber, kUnknownOldestAncesterTime,
-        kUnknownFileCreationTime, kUnknownEpochNumber, kUnknownFileChecksum,
-        kUnknownFileChecksumFuncName, kNullUniqueId64x2, 0);
+        kUnknownFileCreationTime, kUnknownFileChecksum,
+        kUnknownFileChecksumFuncName, kNullUniqueId64x2);
     files_.push_back(f);
   }
 
@@ -143,27 +142,24 @@ class VersionStorageInfoTestBase : public testing::Test {
 
   void Add(int level, uint32_t file_number, const char* smallest,
            const char* largest, uint64_t file_size = 0,
-           uint64_t oldest_blob_file_number = kInvalidBlobFileNumber,
-           uint64_t compensated_range_deletion_size = 0) {
+           uint64_t oldest_blob_file_number = kInvalidBlobFileNumber) {
     constexpr SequenceNumber dummy_seq = 0;
 
     Add(level, file_number, GetInternalKey(smallest, dummy_seq),
-        GetInternalKey(largest, dummy_seq), file_size, oldest_blob_file_number,
-        compensated_range_deletion_size);
+        GetInternalKey(largest, dummy_seq), file_size, oldest_blob_file_number);
   }
 
   void Add(int level, uint32_t file_number, const InternalKey& smallest,
            const InternalKey& largest, uint64_t file_size = 0,
-           uint64_t oldest_blob_file_number = kInvalidBlobFileNumber,
-           uint64_t compensated_range_deletion_size = 0) {
+           uint64_t oldest_blob_file_number = kInvalidBlobFileNumber) {
     assert(level < vstorage_.num_levels());
     FileMetaData* f = new FileMetaData(
         file_number, 0, file_size, smallest, largest, /* smallest_seq */ 0,
         /* largest_seq */ 0, /* marked_for_compact */ false,
         Temperature::kUnknown, oldest_blob_file_number,
         kUnknownOldestAncesterTime, kUnknownFileCreationTime,
-        kUnknownEpochNumber, kUnknownFileChecksum, kUnknownFileChecksumFuncName,
-        kNullUniqueId64x2, compensated_range_deletion_size);
+        kUnknownFileChecksum, kUnknownFileChecksumFuncName, kNullUniqueId64x2);
+    f->compensated_file_size = file_size;
     vstorage_.AddFile(level, f);
   }
 
@@ -2138,17 +2134,6 @@ TEST_F(VersionSetTest, AtomicGroupWithWalEdits) {
   }
 }
 
-TEST_F(VersionStorageInfoTest, AddRangeDeletionCompensatedFileSize) {
-  // Tests that compensated range deletion size is added to compensated file
-  // size.
-  Add(4, 100U, "1", "2", 100U, kInvalidBlobFileNumber, 1000U);
-
-  UpdateVersionStorageInfo();
-
-  auto meta = vstorage_.GetFileMetaDataByNumber(100U);
-  ASSERT_EQ(meta->compensated_file_size, 100U + 1000U);
-}
-
 class VersionSetWithTimestampTest : public VersionSetTest {
  public:
   static const std::string kNewCfName;
@@ -3206,19 +3191,15 @@ class VersionSetTestMissingFiles : public VersionSetTestBase,
     std::string column_family;
     std::string key;  // the only key
     int level = 0;
-    uint64_t epoch_number;
     SstInfo(uint64_t file_num, const std::string& cf_name,
-            const std::string& _key,
-            uint64_t _epoch_number = kUnknownEpochNumber)
-        : SstInfo(file_num, cf_name, _key, 0, _epoch_number) {}
+            const std::string& _key)
+        : SstInfo(file_num, cf_name, _key, 0) {}
     SstInfo(uint64_t file_num, const std::string& cf_name,
-            const std::string& _key, int lvl,
-            uint64_t _epoch_number = kUnknownEpochNumber)
+            const std::string& _key, int lvl)
         : file_number(file_num),
           column_family(cf_name),
           key(_key),
-          level(lvl),
-          epoch_number(_epoch_number) {}
+          level(lvl) {}
   };
 
   // Create dummy sst, return their metadata. Note that only file name and size
@@ -3254,9 +3235,8 @@ class VersionSetTestMissingFiles : public VersionSetTestBase,
       ASSERT_NE(0, file_size);
       file_metas->emplace_back(file_num, /*file_path_id=*/0, file_size, ikey,
                                ikey, 0, 0, false, Temperature::kUnknown, 0, 0,
-                               0, info.epoch_number, kUnknownFileChecksum,
-                               kUnknownFileChecksumFuncName, kNullUniqueId64x2,
-                               0);
+                               0, kUnknownFileChecksum,
+                               kUnknownFileChecksumFuncName, kNullUniqueId64x2);
     }
   }
 
@@ -3293,11 +3273,11 @@ class VersionSetTestMissingFiles : public VersionSetTestBase,
 
 TEST_F(VersionSetTestMissingFiles, ManifestFarBehindSst) {
   std::vector<SstInfo> existing_files = {
-      SstInfo(100, kDefaultColumnFamilyName, "a", 100 /* epoch_number */),
-      SstInfo(102, kDefaultColumnFamilyName, "b", 102 /* epoch_number */),
-      SstInfo(103, kDefaultColumnFamilyName, "c", 103 /* epoch_number */),
-      SstInfo(107, kDefaultColumnFamilyName, "d", 107 /* epoch_number */),
-      SstInfo(110, kDefaultColumnFamilyName, "e", 110 /* epoch_number */)};
+      SstInfo(100, kDefaultColumnFamilyName, "a"),
+      SstInfo(102, kDefaultColumnFamilyName, "b"),
+      SstInfo(103, kDefaultColumnFamilyName, "c"),
+      SstInfo(107, kDefaultColumnFamilyName, "d"),
+      SstInfo(110, kDefaultColumnFamilyName, "e")};
   std::vector<FileMetaData> file_metas;
   CreateDummyTableFiles(existing_files, &file_metas);
 
@@ -3308,12 +3288,10 @@ TEST_F(VersionSetTestMissingFiles, ManifestFarBehindSst) {
     std::string largest_ukey = "b";
     InternalKey smallest_ikey(smallest_ukey, 1, ValueType::kTypeValue);
     InternalKey largest_ikey(largest_ukey, 1, ValueType::kTypeValue);
-
     FileMetaData meta = FileMetaData(
         file_num, /*file_path_id=*/0, /*file_size=*/12, smallest_ikey,
         largest_ikey, 0, 0, false, Temperature::kUnknown, 0, 0, 0,
-        file_num /* epoch_number */, kUnknownFileChecksum,
-        kUnknownFileChecksumFuncName, kNullUniqueId64x2, 0);
+        kUnknownFileChecksum, kUnknownFileChecksumFuncName, kNullUniqueId64x2);
     added_files.emplace_back(0, meta);
   }
   WriteFileAdditionAndDeletionToManifest(
@@ -3343,16 +3321,11 @@ TEST_F(VersionSetTestMissingFiles, ManifestFarBehindSst) {
 
 TEST_F(VersionSetTestMissingFiles, ManifestAheadofSst) {
   std::vector<SstInfo> existing_files = {
-      SstInfo(100, kDefaultColumnFamilyName, "a", 0 /* level */,
-              100 /* epoch_number */),
-      SstInfo(102, kDefaultColumnFamilyName, "b", 0 /* level */,
-              102 /* epoch_number */),
-      SstInfo(103, kDefaultColumnFamilyName, "c", 0 /* level */,
-              103 /* epoch_number */),
-      SstInfo(107, kDefaultColumnFamilyName, "d", 0 /* level */,
-              107 /* epoch_number */),
-      SstInfo(110, kDefaultColumnFamilyName, "e", 0 /* level */,
-              110 /* epoch_number */)};
+      SstInfo(100, kDefaultColumnFamilyName, "a"),
+      SstInfo(102, kDefaultColumnFamilyName, "b"),
+      SstInfo(103, kDefaultColumnFamilyName, "c"),
+      SstInfo(107, kDefaultColumnFamilyName, "d"),
+      SstInfo(110, kDefaultColumnFamilyName, "e")};
   std::vector<FileMetaData> file_metas;
   CreateDummyTableFiles(existing_files, &file_metas);
 
@@ -3373,8 +3346,7 @@ TEST_F(VersionSetTestMissingFiles, ManifestAheadofSst) {
     FileMetaData meta = FileMetaData(
         file_num, /*file_path_id=*/0, /*file_size=*/12, smallest_ikey,
         largest_ikey, 0, 0, false, Temperature::kUnknown, 0, 0, 0,
-        file_num /* epoch_number */, kUnknownFileChecksum,
-        kUnknownFileChecksumFuncName, kNullUniqueId64x2, 0);
+        kUnknownFileChecksum, kUnknownFileChecksumFuncName, kNullUniqueId64x2);
     added_files.emplace_back(0, meta);
   }
   WriteFileAdditionAndDeletionToManifest(
@@ -3409,16 +3381,11 @@ TEST_F(VersionSetTestMissingFiles, ManifestAheadofSst) {
 
 TEST_F(VersionSetTestMissingFiles, NoFileMissing) {
   std::vector<SstInfo> existing_files = {
-      SstInfo(100, kDefaultColumnFamilyName, "a", 0 /* level */,
-              100 /* epoch_number */),
-      SstInfo(102, kDefaultColumnFamilyName, "b", 0 /* level */,
-              102 /* epoch_number */),
-      SstInfo(103, kDefaultColumnFamilyName, "c", 0 /* level */,
-              103 /* epoch_number */),
-      SstInfo(107, kDefaultColumnFamilyName, "d", 0 /* level */,
-              107 /* epoch_number */),
-      SstInfo(110, kDefaultColumnFamilyName, "e", 0 /* level */,
-              110 /* epoch_number */)};
+      SstInfo(100, kDefaultColumnFamilyName, "a"),
+      SstInfo(102, kDefaultColumnFamilyName, "b"),
+      SstInfo(103, kDefaultColumnFamilyName, "c"),
+      SstInfo(107, kDefaultColumnFamilyName, "d"),
+      SstInfo(110, kDefaultColumnFamilyName, "e")};
   std::vector<FileMetaData> file_metas;
   CreateDummyTableFiles(existing_files, &file_metas);
 
@@ -3468,8 +3435,7 @@ TEST_F(VersionSetTestMissingFiles, MinLogNumberToKeep2PC) {
   db_options_.allow_2pc = true;
   NewDB();
 
-  SstInfo sst(100, kDefaultColumnFamilyName, "a", 0 /* level */,
-              100 /* epoch_number */);
+  SstInfo sst(100, kDefaultColumnFamilyName, "a");
   std::vector<FileMetaData> file_metas;
   CreateDummyTableFiles({sst}, &file_metas);
 

package/deps/rocksdb/rocksdb/db/write_thread.cc

@@ -360,11 +360,8 @@ void WriteThread::EndWriteStall() {
   // Unlink write_stall_dummy_ from the write queue. This will unblock
   // pending write threads to enqueue themselves
   assert(newest_writer_.load(std::memory_order_relaxed) == &write_stall_dummy_);
-  // write_stall_dummy_.link_older can be nullptr only if LockWAL() has been
-  // called.
-  if (write_stall_dummy_.link_older) {
-    write_stall_dummy_.link_older->link_newer = write_stall_dummy_.link_newer;
-  }
+  assert(write_stall_dummy_.link_older != nullptr);
+  write_stall_dummy_.link_older->link_newer = write_stall_dummy_.link_newer;
   newest_writer_.exchange(write_stall_dummy_.link_older);
 
   // Wake up writers