@nxtedition/rocksdb 15.4.1 → 16.0.0

package/deps/rocksdb/rocksdb/db/db_impl/db_impl_open.cc

@@ -12,6 +12,7 @@
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
 #include "db/periodic_task_scheduler.h"
+#include "db/version_util.h"
 #include "env/composite_env_wrapper.h"
 #include "file/filename.h"
 #include "file/read_write_util.h"
@@ -657,7 +658,8 @@ Status DBImpl::Recover(
                            f->file_creation_time, f->epoch_number,
                            f->file_checksum, f->file_checksum_func_name,
                            f->unique_id, f->compensated_range_deletion_size,
-                           f->tail_size, f->user_defined_timestamps_persisted);
+                           f->tail_size, f->user_defined_timestamps_persisted,
+                           f->min_timestamp, f->max_timestamp);
               ROCKS_LOG_WARN(immutable_db_options_.info_log,
                              "[%s] Moving #%" PRIu64
                              " from from_level-%d to from_level-%d %" PRIu64
@@ -1491,8 +1493,8 @@ Status DBImpl::ProcessLogRecord(
   }
 
   assert(process_status.ok());
-  process_status = InsertLogRecordToMemtable(batch_to_use, wal_number,
-                                             next_sequence, &has_valid_writes);
+  process_status = InsertLogRecordToMemtable(
+      batch_to_use, wal_number, next_sequence, &has_valid_writes, read_only);
   MaybeIgnoreError(&process_status);
   // We are treating this as a failure while reading since we read valid
   // blocks that do not form coherent data
@@ -1570,7 +1572,8 @@ void DBImpl::MaybeReviseStopReplayForCorruption(
 Status DBImpl::InsertLogRecordToMemtable(WriteBatch* batch_to_use,
                                          uint64_t wal_number,
                                          SequenceNumber* next_sequence,
-                                         bool* has_valid_writes) {
+                                         bool* has_valid_writes,
+                                         bool read_only) {
   // If column family was not found, it might mean that the WAL write
   // batch references to the column family that was dropped after the
   // insert. We don't want to fail the whole write batch in that case --
@@ -1583,6 +1586,34 @@ Status DBImpl::InsertLogRecordToMemtable(WriteBatch* batch_to_use,
       &trim_history_scheduler_, true, wal_number, this,
       false /* concurrent_memtable_writes */, next_sequence, has_valid_writes,
       seq_per_batch_, batch_per_txn_);
+
+  // Check WriteBufferManager global limit during recovery.
+  // When multiple RocksDB instances share a WriteBufferManager, a recovering
+  // instance could exceed the global memory limit. Schedule flushes when needed
+  // to prevent OOM during WAL recovery.
+  //
+  // Skip scheduling in read-only mode since flushes cannot be performed and
+  // the scheduler would never be drained, causing assertion failures on
+  // duplicate ScheduleWork() calls.
+  //
+  // TODO: Currently we schedule all CFs with non-empty memtables for flush
+  // (similar to the atomic_flush=false path in the normal write flow). This
+  // may produce more, smaller L0 files in some CFs. A future improvement
+  // could flush only the oldest CF or pick CFs more selectively to reduce
+  // unnecessary L0 file creation.
+  if (status.ok() && *has_valid_writes && !read_only &&
+      immutable_db_options_.enforce_write_buffer_manager_during_recovery &&
+      write_buffer_manager_ != nullptr &&
+      write_buffer_manager_->ShouldFlush()) {
+    for (auto cfd : *versions_->GetColumnFamilySet()) {
+      if (cfd->mem() != nullptr && cfd->mem()->GetFirstSequenceNumber() != 0 &&
+          !cfd->mem()->HasFlushScheduled()) {
+        cfd->mem()->MarkFlushScheduled();
+        flush_scheduler_.ScheduleWork(cfd);
+      }
+    }
+  }
+
   return status;
 }
 
@@ -2263,7 +2294,7 @@ Status DB::OpenAndTrimHistory(
     return s;
   }
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   s = DB::Open(db_options, dbname, column_families, handles, &db);
   if (!s.ok()) {
     return s;
@@ -2272,7 +2303,7 @@ Status DB::OpenAndTrimHistory(
   CompactRangeOptions options;
   options.bottommost_level_compaction =
       BottommostLevelCompaction::kForceOptimized;
-  auto db_impl = static_cast_with_check<DBImpl>(db);
+  auto db_impl = static_cast_with_check<DBImpl>(db.get());
   for (auto handle : *handles) {
     assert(handle != nullptr);
     auto cfh = static_cast_with_check<ColumnFamilyHandleImpl>(handle);
@@ -2294,14 +2325,14 @@ Status DB::OpenAndTrimHistory(
       assert(temp_s.ok());
     }
     handles->clear();
-    delete db;
+    db.reset();
   };
   if (!s.ok()) {
     clean_op();
     return s;
   }
 
-  dbptr->reset(db);
+  *dbptr = std::move(db);
   return s;
 }
 
@@ -2656,6 +2687,10 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
     impl->DeleteObsoleteFiles();
     TEST_SYNC_POINT("DBImpl::Open:AfterDeleteFiles");
     impl->MaybeScheduleFlushOrCompaction();
+
+    if (impl->immutable_db_options_.open_files_async) {
+      impl->ScheduleAsyncFileOpening();
+    }
     impl->mutex_.Unlock();
   }
 
@@ -2704,4 +2739,125 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
   }
   return s;
 }
+
+struct AsyncFileOpenContext {
+  DBImpl* db = nullptr;
+  FileOptions file_options;
+  std::vector<Version*> versions;
+
+  AsyncFileOpenContext() = default;
+  AsyncFileOpenContext(const AsyncFileOpenContext&) = delete;
+  AsyncFileOpenContext& operator=(const AsyncFileOpenContext&) = delete;
+  AsyncFileOpenContext(AsyncFileOpenContext&&) = delete;
+  AsyncFileOpenContext& operator=(AsyncFileOpenContext&&) = delete;
+
+  ~AsyncFileOpenContext() {
+    db->mutex()->AssertHeld();
+    for (auto* v : versions) {
+      // must unref version before cfd
+      ColumnFamilyData* cfd = v->cfd();
+      v->Unref();
+      cfd->UnrefAndTryDelete();
+    }
+  }
+};
+
+void DBImpl::ScheduleAsyncFileOpening() {
+  mutex_.AssertHeld();
+
+  auto* ctx = new AsyncFileOpenContext();
+  ctx->db = this;
+  ctx->file_options = versions_->file_options();
+
+  for (auto cfd : *versions_->GetColumnFamilySet()) {
+    assert(!cfd->IsDropped());
+    Version* current = cfd->current();
+    VersionStorageInfo* vstorage = current->storage_info();
+    bool has_files = false;
+    for (int level = 0; level < vstorage->num_levels() && !has_files; level++) {
+      has_files = !vstorage->LevelFiles(level).empty();
+    }
+    if (has_files) {
+      cfd->Ref();
+      current->Ref();
+      ctx->versions.push_back(current);
+    }
+  }
+
+  bg_async_file_open_state_ = AsyncFileOpenState::kScheduled;
+
+  // since this is a one time job, best to schedule it with high priority
+  env_->Schedule(&DBImpl::BGWorkAsyncFileOpen, ctx, Env::Priority::HIGH,
+                 nullptr);
+}
+
+void DBImpl::MarkAsyncFileOpenNotNeeded() {
+  mutex_.AssertHeld();
+  assert(bg_async_file_open_state_ == AsyncFileOpenState::kNotScheduled);
+  bg_async_file_open_state_ = AsyncFileOpenState::kComplete;
+}
+
+void DBImpl::BGWorkAsyncFileOpen(void* arg) {
+  TEST_SYNC_POINT("DBImpl::BGWorkAsyncFileOpen::Start");
+
+  AsyncFileOpenContext* raw_ctx = static_cast<AsyncFileOpenContext*>(arg);
+  DBImpl* db = raw_ctx->db;
+
+  auto deleter = [](AsyncFileOpenContext* p) {
+    auto* dbPtr = p->db;
+    InstrumentedMutexLock l(&dbPtr->mutex_);
+    delete p;
+    dbPtr->bg_async_file_open_state_ = AsyncFileOpenState::kComplete;
+    dbPtr->bg_cv_.SignalAll();
+  };
+  std::unique_ptr<AsyncFileOpenContext, decltype(deleter)> ctx(raw_ctx,
+                                                               deleter);
+
+  ReadOptions ro;
+  for (size_t i = 0; i < ctx->versions.size(); i++) {
+    auto* version = ctx->versions[i];
+    ColumnFamilyData* cfd = version->cfd();
+
+    // Skip column families that were dropped after scheduling
+    if (cfd->IsDropped()) {
+      continue;
+    }
+
+    VersionStorageInfo* vstorage = version->storage_info();
+
+    MutableCFOptions mutable_cf_options;
+    {
+      InstrumentedMutexLock l(&db->mutex_);
+      mutable_cf_options = cfd->GetLatestMutableCFOptions();
+    }
+    size_t max_file_size_for_l0_meta_pin =
+        MaxFileSizeForL0MetaPin(mutable_cf_options);
+
+    std::vector<std::pair<FileMetaData*, int>> files_meta;
+    for (int level = 0; level < vstorage->num_levels(); level++) {
+      for (FileMetaData* file_meta : vstorage->LevelFiles(level)) {
+        files_meta.emplace_back(file_meta, level);
+      }
+    }
+
+    Status s = LoadTableHandlersHelper(
+        files_meta, cfd->table_cache(), ctx->file_options,
+        *vstorage->InternalComparator(), cfd->internal_stats(),
+        db->immutable_db_options_.max_file_opening_threads,
+        false /* prefetch_index_and_filter_in_cache */, mutable_cf_options,
+        max_file_size_for_l0_meta_pin, ro, &db->shutting_down_);
+    if (!s.ok()) {
+      ROCKS_LOG_ERROR(
+          db->immutable_db_options_.info_log,
+          "BGWorkAsyncFileOpen: LoadTableHandlers failed for CF %s: "
+          "%s",
+          cfd->GetName().c_str(), s.ToString().c_str());
+      InstrumentedMutexLock l(&db->mutex_);
+      db->error_handler_.SetBGError(s, BackgroundErrorReason::kAsyncFileOpen);
+      break;
+    }
+  }
+  TEST_SYNC_POINT("DBImpl::BGWorkAsyncFileOpen:Done");
+}
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db/db_impl/db_impl_readonly.cc

@@ -357,6 +357,12 @@ Status DBImplReadOnly::OpenForReadOnlyWithoutCheck(
       sv_context.NewSuperVersion();
       cfd->InstallSuperVersion(&sv_context, &impl->mutex_);
     }
+
+    impl->opened_successfully_ = true;
+
+    if (db_options.open_files_async) {
+      impl->ScheduleAsyncFileOpening();
+    }
   }
   impl->mutex_.Unlock();
   sv_context.Clean();

package/deps/rocksdb/rocksdb/db/db_impl/db_impl_readonly.h

@@ -121,6 +121,11 @@ class DBImplReadOnly : public DBImpl {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 
+  using DBImpl::FlushWAL;
+  Status FlushWAL(const FlushWALOptions& /*options*/) override {
+    return Status::NotSupported("Not supported operation in read only mode.");
+  }
+
   using DB::IngestExternalFile;
   Status IngestExternalFile(
       ColumnFamilyHandle* /*column_family*/,

package/deps/rocksdb/rocksdb/db/db_impl/db_impl_secondary.cc

@@ -43,7 +43,6 @@ Status DBImplSecondary::Recover(
     RecoveryContext* /*recovery_ctx*/, bool* /*can_retry*/) {
   mutex_.AssertHeld();
 
-  JobContext job_context(0);
   Status s;
   s = static_cast<ReactiveVersionSet*>(versions_.get())
           ->Recover(column_families, &manifest_reader_, &manifest_reporter_,
@@ -61,24 +60,12 @@ Status DBImplSecondary::Recover(
     max_total_in_memory_state_ += mutable_cf_options.write_buffer_size *
                                   mutable_cf_options.max_write_buffer_number;
   }
-  if (s.ok()) {
-    default_cf_handle_ = new ColumnFamilyHandleImpl(
-        versions_->GetColumnFamilySet()->GetDefault(), this, &mutex_);
-    default_cf_internal_stats_ = default_cf_handle_->cfd()->internal_stats();
+  default_cf_handle_ = new ColumnFamilyHandleImpl(
+      versions_->GetColumnFamilySet()->GetDefault(), this, &mutex_);
+  default_cf_internal_stats_ = default_cf_handle_->cfd()->internal_stats();
 
-    std::unordered_set<ColumnFamilyData*> cfds_changed;
-    s = FindAndRecoverLogFiles(&cfds_changed, &job_context);
-  }
-
-  if (s.IsPathNotFound()) {
-    ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "Secondary tries to read WAL, but WAL file(s) have already "
-                   "been purged by primary.");
-    s = Status::OK();
-  }
   // TODO: update options_file_number_ needed?
 
-  job_context.Clean();
   return s;
 }
 
@@ -88,6 +75,7 @@ Status DBImplSecondary::FindAndRecoverLogFiles(
     JobContext* job_context) {
   assert(nullptr != cfds_changed);
   assert(nullptr != job_context);
+  TEST_SYNC_POINT("DBImplSecondary::FindAndRecoverLogFiles:Begin");
   Status s;
   std::vector<uint64_t> logs;
   s = FindNewLogNumbers(&logs);
@@ -509,10 +497,6 @@ Iterator* DBImplSecondary::NewIterator(const ReadOptions& _read_options,
   if (read_options.io_activity == Env::IOActivity::kUnknown) {
     read_options.io_activity = Env::IOActivity::kDBIterator;
   }
-  if (read_options.managed) {
-    return NewErrorIterator(
-        Status::NotSupported("Managed iterator is not supported anymore."));
-  }
   if (read_options.read_tier == kPersistedTier) {
     return NewErrorIterator(Status::NotSupported(
         "ReadTier::kPersistedData is not yet supported in iterators."));
@@ -588,9 +572,6 @@ Status DBImplSecondary::NewIterators(
   if (read_options.io_activity == Env::IOActivity::kUnknown) {
     read_options.io_activity = Env::IOActivity::kDBIterator;
   }
-  if (read_options.managed) {
-    return Status::NotSupported("Managed iterator is not supported anymore.");
-  }
   if (read_options.read_tier == kPersistedTier) {
     return Status::NotSupported(
         "ReadTier::kPersistedData is not yet supported in iterators.");
@@ -747,6 +728,17 @@ Status DB::OpenAsSecondary(
     const std::string& secondary_path,
     const std::vector<ColumnFamilyDescriptor>& column_families,
     std::vector<ColumnFamilyHandle*>* handles, std::unique_ptr<DB>* dbptr) {
+  return DBImplSecondary::OpenAsSecondaryImpl(
+      db_options, dbname, secondary_path, column_families, handles, dbptr,
+      /*recover_wal=*/true);
+}
+
+Status DBImplSecondary::OpenAsSecondaryImpl(
+    const DBOptions& db_options, const std::string& dbname,
+    const std::string& secondary_path,
+    const std::vector<ColumnFamilyDescriptor>& column_families,
+    std::vector<ColumnFamilyHandle*>* handles, std::unique_ptr<DB>* dbptr,
+    bool recover_wal) {
   *dbptr = nullptr;
 
   DBOptions tmp_opts(db_options);
@@ -791,7 +783,21 @@ Status DB::OpenAsSecondary(
   impl->wal_in_db_path_ = impl->immutable_db_options_.IsWalDirSameAsDBPath();
 
   impl->mutex_.Lock();
+  JobContext job_context(0);
   s = impl->Recover(column_families, true, false, false);
+  // WAL recovery is optional: DB::OpenAsSecondary() needs it to replay
+  // memtable data, while DB::OpenAndCompact() skips it since remote
+  // compaction only needs LSM state from MANIFEST.
+  if (s.ok() && recover_wal) {
+    std::unordered_set<ColumnFamilyData*> cfds_changed;
+    s = impl->FindAndRecoverLogFiles(&cfds_changed, &job_context);
+    if (s.IsPathNotFound()) {
+      ROCKS_LOG_INFO(impl->immutable_db_options_.info_log,
+                     "Secondary tries to read WAL, but WAL file(s) have "
+                     "already been purged by primary.");
+      s = Status::OK();
+    }
+  }
   if (s.ok()) {
     for (const auto& cf : column_families) {
       auto cfd =
@@ -809,9 +815,11 @@ Status DB::OpenAsSecondary(
       sv_context.NewSuperVersion();
       cfd->InstallSuperVersion(&sv_context, &impl->mutex_);
     }
+    impl->MarkAsyncFileOpenNotNeeded();
   }
   impl->mutex_.Unlock();
   sv_context.Clean();
+  job_context.Clean();
   if (s.ok()) {
     dbptr->reset(impl);
     for (auto h : *handles) {
@@ -987,11 +995,8 @@ Status DBImplSecondary::ParseCompactionProgressFile(
   Slice slice;
   std::string record;
 
-  while (compaction_progress_reader.ReadRecord(&slice, &record)) {
-    if (!reader_status.ok()) {
-      return reader_status;
-    }
-
+  while (compaction_progress_reader.ReadRecord(&slice, &record) &&
+         reader_status.ok()) {
     VersionEdit edit;
     s = edit.DecodeFrom(slice);
     if (!s.ok()) {
@@ -1004,6 +1009,10 @@ Status DBImplSecondary::ParseCompactionProgressFile(
     }
   }
 
+  if (!reader_status.ok()) {
+    return reader_status;
+  }
+
   if (!s.ok()) {
     return s;
   }
@@ -1544,18 +1553,20 @@ Status DB::OpenAndCompact(
     }
   }
 
-  // 5. Open db As Secondary
-  DB* db;
+  // 5. Open db As Secondary (skip WAL recovery — remote compaction only
+  //    needs LSM state from MANIFEST, not memtable data from WAL replay)
+  std::unique_ptr<DB> db;
   std::vector<ColumnFamilyHandle*> handles;
-  s = DB::OpenAsSecondary(db_options, name, output_directory, column_families,
-                          &handles, &db);
+  s = DBImplSecondary::OpenAsSecondaryImpl(db_options, name, output_directory,
+                                           column_families, &handles, &db,
+                                           /*recover_wal=*/false);
   if (!s.ok()) {
     return s;
   }
   assert(db);
 
   TEST_SYNC_POINT_CALLBACK(
-      "DBImplSecondary::OpenAndCompact::AfterOpenAsSecondary:0", db);
+      "DBImplSecondary::OpenAndCompact::AfterOpenAsSecondary:0", db.get());
 
   // 6. Find the handle of the Column Family that this will compact
   ColumnFamilyHandle* cfh = nullptr;
@@ -1570,7 +1581,8 @@ Status DB::OpenAndCompact(
   // 7. Run the compaction without installation.
   // Output will be stored in the directory specified by output_directory
   CompactionServiceResult compaction_result;
-  DBImplSecondary* db_secondary = static_cast_with_check<DBImplSecondary>(db);
+  DBImplSecondary* db_secondary =
+      static_cast_with_check<DBImplSecondary>(db.get());
   s = db_secondary->CompactWithoutInstallation(options, cfh, compaction_input,
                                                &compaction_result);
 
@@ -1581,7 +1593,7 @@ Status DB::OpenAndCompact(
   for (auto& handle : handles) {
     delete handle;
   }
-  delete db;
+  db.reset();
   if (s.ok()) {
     return serialization_status;
   } else {

package/deps/rocksdb/rocksdb/db/db_impl/db_impl_secondary.h

@@ -78,8 +78,9 @@ class DBImplSecondary : public DBImpl {
                   std::string secondary_path);
   ~DBImplSecondary() override;
 
-  // Recover by replaying MANIFEST and WAL. Also initialize manifest_reader_
-  // and log_readers_ to facilitate future operations.
+  // Recover by replaying MANIFEST only. Also initialize manifest_reader_
+  // to facilitate future operations. WAL recovery, if needed, is done
+  // separately after opening (see DB::OpenAsSecondary).
   Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
                  bool read_only, bool error_if_wal_file_exists,
                  bool error_if_data_exists_in_wals, bool is_retry = false,
@@ -194,10 +195,11 @@ class DBImplSecondary : public DBImpl {
     return Status::NotSupported("Not supported operation in secondary mode.");
   }
 
-  Status GetLiveFiles(std::vector<std::string>&,
-                      uint64_t* /*manifest_file_size*/,
-                      bool /*flush_memtable*/ = true) override {
-    return Status::NotSupported("Not supported operation in secondary mode.");
+  Status GetLiveFiles(std::vector<std::string>& ret,
+                      uint64_t* manifest_file_size,
+                      bool /*flush_memtable*/) override {
+    return DBImpl::GetLiveFiles(ret, manifest_file_size,
+                                false /* flush_memtable */);
   }
 
   using DBImpl::Flush;
@@ -216,9 +218,9 @@ class DBImplSecondary : public DBImpl {
 
   using DBImpl::SetOptions;
   Status SetOptions(
-      ColumnFamilyHandle* /*cfd*/,
-      const std::unordered_map<std::string, std::string>& /*options_map*/)
-      override {
+      const std::unordered_map<ColumnFamilyHandle*,
+                               std::unordered_map<std::string, std::string>>&
+      /*column_families_opts_map*/) override {
     // Currently not supported because changing certain options may cause
     // flush/compaction and/or write to MANIFEST.
     return Status::NotSupported("Not supported operation in secondary mode.");
@@ -384,6 +386,17 @@ class DBImplSecondary : public DBImpl {
   uint64_t CalculateResumedCompactionBytes(
       const CompactionProgress& compaction_progress) const;
 
+  // Internal helper for opening a secondary instance. Recover() replays
+  // MANIFEST only. When recover_wal is true, WAL files are also replayed
+  // (needed by DB::OpenAsSecondary). When false, WAL replay is skipped
+  // (used by DB::OpenAndCompact which only needs LSM state).
+  static Status OpenAsSecondaryImpl(
+      const DBOptions& db_options, const std::string& dbname,
+      const std::string& secondary_path,
+      const std::vector<ColumnFamilyDescriptor>& column_families,
+      std::vector<ColumnFamilyHandle*>* handles, std::unique_ptr<DB>* dbptr,
+      bool recover_wal);
+
   // Cache log readers for each log number, used for continue WAL replay
   // after recovery
   std::map<uint64_t, std::unique_ptr<LogReaderContainer>> log_readers_;

package/deps/rocksdb/rocksdb/db/db_iter.cc

@@ -23,6 +23,7 @@
 #include "memory/arena.h"
 #include "monitoring/perf_context_imp.h"
 #include "rocksdb/env.h"
+#include "rocksdb/io_dispatcher.h"
 #include "rocksdb/iterator.h"
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/options.h"
@@ -1621,6 +1622,14 @@ void DBIter::Prepare(const MultiScanArgs& scan_opts) {
   new_scan_opts.emplace(scan_opts);
   scan_opts_.swap(new_scan_opts);
   scan_index_ = 0;
+
+  // Create a shared IODispatcher if not provided. This allows all
+  // BlockBasedTableIterators in this scan to share a single dispatcher,
+  // enabling better IO coordination and future rate limiting.
+  if (!scan_opts_.value().io_dispatcher) {
+    scan_opts_->io_dispatcher.reset(NewIODispatcher());
+  }
+
   if (!scan_opts.empty()) {
     iter_.Prepare(&scan_opts_.value());
   } else {