@nxtedition/rocksdb 6.0.1 → 7.0.0-alpha.1

package/deps/rocksdb/rocksdb/utilities/backup/backup_engine.cc

@@ -48,6 +48,7 @@
 #include "util/coding.h"
 #include "util/crc32c.h"
 #include "util/math.h"
+#include "util/rate_limiter.h"
 #include "util/string_util.h"
 #include "utilities/backup/backup_engine_impl.h"
 #include "utilities/checkpoint/checkpoint_impl.h"
@@ -181,6 +182,61 @@ class BackupEngineImpl {
            BackupEngineOptions::kMaskNamingFlags;
   }
 
+  void TEST_SetDefaultRateLimitersClock(
+      const std::shared_ptr<SystemClock>& backup_rate_limiter_clock,
+      const std::shared_ptr<SystemClock>& restore_rate_limiter_clock) {
+    if (backup_rate_limiter_clock) {
+      assert(options_.backup_rate_limiter->IsInstanceOf(
+          GenericRateLimiter::kClassName()));
+      auto* backup_rate_limiter_options =
+          options_.backup_rate_limiter
+              ->GetOptions<GenericRateLimiter::GenericRateLimiterOptions>();
+
+      assert(backup_rate_limiter_options);
+      RateLimiter::Mode backup_rate_limiter_mode;
+      if (!options_.backup_rate_limiter->IsRateLimited(
+              RateLimiter::OpType::kRead)) {
+        backup_rate_limiter_mode = RateLimiter::Mode::kWritesOnly;
+      } else if (!options_.backup_rate_limiter->IsRateLimited(
+                     RateLimiter::OpType::kWrite)) {
+        backup_rate_limiter_mode = RateLimiter::Mode::kReadsOnly;
+      } else {
+        backup_rate_limiter_mode = RateLimiter::Mode::kAllIo;
+      }
+      options_.backup_rate_limiter.reset(new GenericRateLimiter(
+          backup_rate_limiter_options->max_bytes_per_sec,
+          backup_rate_limiter_options->refill_period_us,
+          backup_rate_limiter_options->fairness, backup_rate_limiter_mode,
+          backup_rate_limiter_clock, backup_rate_limiter_options->auto_tuned));
+    }
+
+    if (restore_rate_limiter_clock) {
+      assert(options_.restore_rate_limiter->IsInstanceOf(
+          GenericRateLimiter::kClassName()));
+      auto* restore_rate_limiter_options =
+          options_.restore_rate_limiter
+              ->GetOptions<GenericRateLimiter::GenericRateLimiterOptions>();
+      assert(restore_rate_limiter_options);
+
+      RateLimiter::Mode restore_rate_limiter_mode;
+      if (!options_.restore_rate_limiter->IsRateLimited(
+              RateLimiter::OpType::kRead)) {
+        restore_rate_limiter_mode = RateLimiter::Mode::kWritesOnly;
+      } else if (!options_.restore_rate_limiter->IsRateLimited(
+                     RateLimiter::OpType::kWrite)) {
+        restore_rate_limiter_mode = RateLimiter::Mode::kReadsOnly;
+      } else {
+        restore_rate_limiter_mode = RateLimiter::Mode::kAllIo;
+      }
+      options_.restore_rate_limiter.reset(new GenericRateLimiter(
+          restore_rate_limiter_options->max_bytes_per_sec,
+          restore_rate_limiter_options->refill_period_us,
+          restore_rate_limiter_options->fairness, restore_rate_limiter_mode,
+          restore_rate_limiter_clock,
+          restore_rate_limiter_options->auto_tuned));
+    }
+  }
+
  private:
   void DeleteChildren(const std::string& dir,
                       uint32_t file_type_filter = 0) const;
@@ -496,8 +552,8 @@ class BackupEngineImpl {
                                        bool tmp = false,
                                        const std::string& file = "") const {
     assert(file.size() == 0 || file[0] != '/');
-    return kPrivateDirSlash + ROCKSDB_NAMESPACE::ToString(backup_id) +
-           (tmp ? ".tmp" : "") + "/" + file;
+    return kPrivateDirSlash + std::to_string(backup_id) + (tmp ? ".tmp" : "") +
+           "/" + file;
   }
   inline std::string GetSharedFileRel(const std::string& file = "",
                                       bool tmp = false) const {
@@ -524,13 +580,13 @@ class BackupEngineImpl {
     if (UseLegacyNaming(db_session_id)) {
       assert(!checksum_hex.empty());
       file_copy.insert(file_copy.find_last_of('.'),
-                       "_" + ToString(ChecksumHexToInt32(checksum_hex)) + "_" +
-                           ToString(file_size));
+                       "_" + std::to_string(ChecksumHexToInt32(checksum_hex)) +
+                           "_" + std::to_string(file_size));
     } else {
       file_copy.insert(file_copy.find_last_of('.'), "_s" + db_session_id);
       if (GetNamingFlags() & BackupEngineOptions::kFlagIncludeFileSize) {
         file_copy.insert(file_copy.find_last_of('.'),
-                         "_" + ToString(file_size));
+                         "_" + std::to_string(file_size));
       }
     }
     return file_copy;
@@ -544,7 +600,7 @@ class BackupEngineImpl {
   }
   inline std::string GetBackupMetaFile(BackupID backup_id, bool tmp) const {
     return GetAbsolutePath(kMetaDirName) + "/" + (tmp ? "." : "") +
-           ROCKSDB_NAMESPACE::ToString(backup_id) + (tmp ? ".tmp" : "");
+           std::to_string(backup_id) + (tmp ? ".tmp" : "");
   }
 
   // If size_limit == 0, there is no size limit, copy everything.
@@ -942,6 +998,15 @@ class BackupEngineImplThreadSafe : public BackupEngine,
     impl_.schema_test_options_.reset(new TEST_BackupMetaSchemaOptions(options));
   }
 
+  // Not public API but used in testing
+  void TEST_SetDefaultRateLimitersClock(
+      const std::shared_ptr<SystemClock>& backup_rate_limiter_clock = nullptr,
+      const std::shared_ptr<SystemClock>& restore_rate_limiter_clock =
+          nullptr) {
+    impl_.TEST_SetDefaultRateLimitersClock(backup_rate_limiter_clock,
+                                           restore_rate_limiter_clock);
+  }
+
  private:
   mutable port::RWMutex mutex_;
   BackupEngineImpl impl_;
@@ -1012,8 +1077,9 @@ IOStatus BackupEngineImpl::Initialize() {
     // we might need to clean up from previous crash or I/O errors
     might_need_garbage_collect_ = true;
 
-    if (options_.max_valid_backups_to_open != port::kMaxInt32) {
-      options_.max_valid_backups_to_open = port::kMaxInt32;
+    if (options_.max_valid_backups_to_open !=
+        std::numeric_limits<int32_t>::max()) {
+      options_.max_valid_backups_to_open = std::numeric_limits<int32_t>::max();
       ROCKS_LOG_WARN(
           options_.info_log,
           "`max_valid_backups_to_open` is not set to the default value. Ignoring "
@@ -1066,7 +1132,7 @@ IOStatus BackupEngineImpl::Initialize() {
     ROCKS_LOG_INFO(options_.info_log, "Detected backup %s", file.c_str());
     BackupID backup_id = 0;
     sscanf(file.c_str(), "%u", &backup_id);
-    if (backup_id == 0 || file != ROCKSDB_NAMESPACE::ToString(backup_id)) {
+    if (backup_id == 0 || file != std::to_string(backup_id)) {
       // Invalid file name, will be deleted with auto-GC when user
       // initiates an append or write operation. (Behave as read-only until
       // then.)
@@ -1434,7 +1500,8 @@ IOStatus BackupEngineImpl::CreateNewBackupWithMetadata(
               contents.size(), db_options.statistics.get(), 0 /* size_limit */,
               false /* shared_checksum */, options.progress_callback, contents);
         } /* create_file_cb */,
-        &sequence_number, options.flush_before_backup ? 0 : port::kMaxUint64,
+        &sequence_number,
+        options.flush_before_backup ? 0 : std::numeric_limits<uint64_t>::max(),
         compare_checksum));
     if (io_s.ok()) {
       new_backup->SetSequenceNumber(sequence_number);
@@ -1664,8 +1731,8 @@ void BackupEngineImpl::SetBackupInfoFromBackupMeta(
     bool include_file_details) const {
   *backup_info = BackupInfo(id, meta.GetTimestamp(), meta.GetSize(),
                             meta.GetNumberFiles(), meta.GetAppMetadata());
-  std::string dir = options_.backup_dir + "/" + kPrivateDirSlash +
-                    ROCKSDB_NAMESPACE::ToString(id);
+  std::string dir =
+      options_.backup_dir + "/" + kPrivateDirSlash + std::to_string(id);
   if (include_file_details) {
     auto& file_details = backup_info->file_details;
     file_details.reserve(meta.GetFiles().size());
@@ -1960,9 +2027,9 @@ IOStatus BackupEngineImpl::VerifyBackup(BackupID backup_id,
     // verify file size
     if (file_info->size != curr_abs_path_to_size[abs_path]) {
       std::string size_info("Expected file size is " +
-                            ToString(file_info->size) +
+                            std::to_string(file_info->size) +
                             " while found file size is " +
-                            ToString(curr_abs_path_to_size[abs_path]));
+                            std::to_string(curr_abs_path_to_size[abs_path]));
       return IOStatus::Corruption("File corrupted: File size mismatch for " +
                                   abs_path + ": " + size_info);
     }
@@ -2171,7 +2238,7 @@ IOStatus BackupEngineImpl::AddBackupFileWorkItem(
         return io_s;
       }
     }
-    if (size_bytes == port::kMaxUint64) {
+    if (size_bytes == std::numeric_limits<uint64_t>::max()) {
       return IOStatus::NotFound("File missing: " + src_path);
     }
     // dst_relative depends on the following conditions:
@@ -2643,8 +2710,8 @@ IOStatus BackupEngineImpl::BackupMeta::AddFile(
     if (itr->second->size != file_info->size) {
       std::string msg = "Size mismatch for existing backup file: ";
       msg.append(file_info->filename);
-      msg.append(" Size in backup is " + ToString(itr->second->size) +
-                 " while size in DB is " + ToString(file_info->size));
+      msg.append(" Size in backup is " + std::to_string(itr->second->size) +
+                 " while size in DB is " + std::to_string(file_info->size));
       msg.append(
           " If this DB file checks as not corrupt, try deleting old"
           " backups or backing up to a different backup directory.");
@@ -2937,7 +3004,7 @@ IOStatus BackupEngineImpl::BackupMeta::LoadFromFile(
       if (field_name == kFileCrc32cFieldName) {
         uint32_t checksum_value =
             static_cast<uint32_t>(strtoul(field_data.c_str(), nullptr, 10));
-        if (field_data != ROCKSDB_NAMESPACE::ToString(checksum_value)) {
+        if (field_data != std::to_string(checksum_value)) {
           return IOStatus::Corruption("Invalid checksum value for " + filename +
                                       " in " + meta_filename_);
         }
@@ -2947,8 +3014,9 @@ IOStatus BackupEngineImpl::BackupMeta::LoadFromFile(
             std::strtoull(field_data.c_str(), nullptr, /*base*/ 10);
         if (ex_size != actual_size) {
           return IOStatus::Corruption(
-              "For file " + filename + " expected size " + ToString(ex_size) +
-              " but found size" + ToString(actual_size));
+              "For file " + filename + " expected size " +
+              std::to_string(ex_size) + " but found size" +
+              std::to_string(actual_size));
         }
       } else if (field_name == kTemperatureFieldName) {
         auto iter = temperature_string_map.find(field_data);
@@ -3046,7 +3114,7 @@ IOStatus BackupEngineImpl::BackupMeta::StoreToFile(
   if (schema_version > static_cast<int>(minor_version_strings.size() - 1)) {
     return IOStatus::NotSupported(
         "Only BackupEngineOptions::schema_version <= " +
-        ToString(minor_version_strings.size() - 1) + " is supported");
+        std::to_string(minor_version_strings.size() - 1) + " is supported");
   }
   std::string ver = minor_version_strings[schema_version];
 
@@ -3101,7 +3169,7 @@ IOStatus BackupEngineImpl::BackupMeta::StoreToFile(
           << temperature_to_string[file->temp];
     }
     if (schema_test_options && schema_test_options->file_sizes) {
-      buf << " " << kFileSizeFieldName << " " << ToString(file->size);
+      buf << " " << kFileSizeFieldName << " " << std::to_string(file->size);
     }
     if (schema_test_options) {
       for (auto& e : schema_test_options->file_fields) {
@@ -3159,6 +3227,15 @@ void TEST_SetBackupMetaSchemaOptions(
   impl->TEST_SetBackupMetaSchemaOptions(options);
 }
 
+void TEST_SetDefaultRateLimitersClock(
+    BackupEngine* engine,
+    const std::shared_ptr<SystemClock>& backup_rate_limiter_clock,
+    const std::shared_ptr<SystemClock>& restore_rate_limiter_clock) {
+  BackupEngineImplThreadSafe* impl =
+      static_cast_with_check<BackupEngineImplThreadSafe>(engine);
+  impl->TEST_SetDefaultRateLimitersClock(backup_rate_limiter_clock,
+                                         restore_rate_limiter_clock);
+}
 }  // namespace ROCKSDB_NAMESPACE
 
 #endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/backup/backup_engine_impl.h

@@ -25,5 +25,12 @@ struct TEST_BackupMetaSchemaOptions {
 void TEST_SetBackupMetaSchemaOptions(
     BackupEngine *engine, const TEST_BackupMetaSchemaOptions &options);
 
+// Modifies the BackupEngine(Impl) to use specified clocks for backup and
+// restore rate limiters created by default if not specified by users for
+// test speedup.
+void TEST_SetDefaultRateLimitersClock(
+    BackupEngine* engine,
+    const std::shared_ptr<SystemClock>& backup_rate_limiter_clock = nullptr,
+    const std::shared_ptr<SystemClock>& restore_rate_limiter_clock = nullptr);
 }  // namespace ROCKSDB_NAMESPACE
 #endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/backup/backup_engine_test.cc

@@ -564,8 +564,8 @@ size_t FillDB(DB* db, int from, int to,
               FillDBFlushAction flush_action = kFlushMost) {
   size_t bytes_written = 0;
   for (int i = from; i < to; ++i) {
-    std::string key = "testkey" + ToString(i);
-    std::string value = "testvalue" + ToString(i);
+    std::string key = "testkey" + std::to_string(i);
+    std::string value = "testvalue" + std::to_string(i);
     bytes_written += key.size() + value.size();
 
     EXPECT_OK(db->Put(WriteOptions(), Slice(key), Slice(value)));
@@ -582,17 +582,17 @@ size_t FillDB(DB* db, int from, int to,
 
 void AssertExists(DB* db, int from, int to) {
   for (int i = from; i < to; ++i) {
-    std::string key = "testkey" + ToString(i);
+    std::string key = "testkey" + std::to_string(i);
     std::string value;
     Status s = db->Get(ReadOptions(), Slice(key), &value);
-    ASSERT_EQ(value, "testvalue" + ToString(i));
+    ASSERT_EQ(value, "testvalue" + std::to_string(i));
   }
 }
 
 void AssertEmpty(DB* db, int from, int to) {
   for (int i = from; i < to; ++i) {
-    std::string key = "testkey" + ToString(i);
-    std::string value = "testvalue" + ToString(i);
+    std::string key = "testkey" + std::to_string(i);
+    std::string value = "testvalue" + std::to_string(i);
 
     Status s = db->Get(ReadOptions(), Slice(key), &value);
     ASSERT_TRUE(s.IsNotFound());
@@ -955,7 +955,7 @@ class BackupEngineTest : public testing::Test {
       ASSERT_LT(last_underscore, last_dot);
       std::string s = child.name.substr(last_underscore + 1,
                                         last_dot - (last_underscore + 1));
-      ASSERT_EQ(s, ToString(child.size_bytes));
+      ASSERT_EQ(s, std::to_string(child.size_bytes));
       ++found_count;
     }
     ASSERT_GE(found_count, minimum_count);
@@ -2598,80 +2598,119 @@ INSTANTIATE_TEST_CASE_P(
 
 TEST_P(BackupEngineRateLimitingTestWithParam, RateLimiting) {
   size_t const kMicrosPerSec = 1000 * 1000LL;
-
-  std::shared_ptr<RateLimiter> backupThrottler(NewGenericRateLimiter(1));
-  std::shared_ptr<RateLimiter> restoreThrottler(NewGenericRateLimiter(1));
-
-  bool makeThrottler = std::get<0>(GetParam());
-  if (makeThrottler) {
-    engine_options_->backup_rate_limiter = backupThrottler;
-    engine_options_->restore_rate_limiter = restoreThrottler;
-  }
-
+  const bool custom_rate_limiter = std::get<0>(GetParam());
   // iter 0 -- single threaded
   // iter 1 -- multi threaded
-  int iter = std::get<1>(GetParam());
+  const int iter = std::get<1>(GetParam());
   const std::pair<uint64_t, uint64_t> limit = std::get<2>(GetParam());
-
+  std::unique_ptr<Env> special_env(
+      new SpecialEnv(db_chroot_env_.get(), /*time_elapse_only_sleep*/ true));
   // destroy old data
-  DestroyDB(dbname_, Options());
-  if (makeThrottler) {
-    backupThrottler->SetBytesPerSecond(limit.first);
-    restoreThrottler->SetBytesPerSecond(limit.second);
+  Options options;
+  options.env = special_env.get();
+  DestroyDB(dbname_, options);
+
+  if (custom_rate_limiter) {
+    std::shared_ptr<RateLimiter> backup_rate_limiter =
+        std::make_shared<GenericRateLimiter>(
+            limit.first, 100 * 1000 /* refill_period_us */, 10 /* fairness */,
+            RateLimiter::Mode::kWritesOnly /* mode */,
+            special_env->GetSystemClock(), false /* auto_tuned */);
+    std::shared_ptr<RateLimiter> restore_rate_limiter =
+        std::make_shared<GenericRateLimiter>(
+            limit.second, 100 * 1000 /* refill_period_us */, 10 /* fairness */,
+            RateLimiter::Mode::kWritesOnly /* mode */,
+            special_env->GetSystemClock(), false /* auto_tuned */);
+    engine_options_->backup_rate_limiter = backup_rate_limiter;
+    engine_options_->restore_rate_limiter = restore_rate_limiter;
   } else {
     engine_options_->backup_rate_limit = limit.first;
     engine_options_->restore_rate_limit = limit.second;
   }
+
   engine_options_->max_background_operations = (iter == 0) ? 1 : 10;
   options_.compression = kNoCompression;
+
+  // Rate limiter uses `CondVar::TimedWait()`, which does not have access to the
+  // `Env` to advance its time according to the fake wait duration. The
+  // workaround is to install a callback that advance the `Env`'s mock time.
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "GenericRateLimiter::Request:PostTimedWait", [&](void* arg) {
+        int64_t time_waited_us = *static_cast<int64_t*>(arg);
+        special_env->SleepForMicroseconds(static_cast<int>(time_waited_us));
+      });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
+
   OpenDBAndBackupEngine(true);
-  size_t bytes_written = FillDB(db_.get(), 0, 100000);
+  TEST_SetDefaultRateLimitersClock(backup_engine_.get(),
+                                   special_env->GetSystemClock());
 
-  auto start_backup = db_chroot_env_->NowMicros();
+  size_t bytes_written = FillDB(db_.get(), 0, 10000);
+
+  auto start_backup = special_env->NowMicros();
   ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), false));
-  auto backup_time = db_chroot_env_->NowMicros() - start_backup;
+  auto backup_time = special_env->NowMicros() - start_backup;
+  CloseDBAndBackupEngine();
   auto rate_limited_backup_time = (bytes_written * kMicrosPerSec) / limit.first;
   ASSERT_GT(backup_time, 0.8 * rate_limited_backup_time);
 
-  CloseDBAndBackupEngine();
-
   OpenBackupEngine();
-  auto start_restore = db_chroot_env_->NowMicros();
+  TEST_SetDefaultRateLimitersClock(backup_engine_.get(),
+                                   special_env->GetSystemClock());
+
+  auto start_restore = special_env->NowMicros();
   ASSERT_OK(backup_engine_->RestoreDBFromLatestBackup(dbname_, dbname_));
-  auto restore_time = db_chroot_env_->NowMicros() - start_restore;
+  auto restore_time = special_env->NowMicros() - start_restore;
   CloseBackupEngine();
   auto rate_limited_restore_time =
       (bytes_written * kMicrosPerSec) / limit.second;
   ASSERT_GT(restore_time, 0.8 * rate_limited_restore_time);
 
-  AssertBackupConsistency(0, 0, 100000, 100010);
+  AssertBackupConsistency(0, 0, 10000, 10100);
+
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearCallBack(
+      "GenericRateLimiter::Request:PostTimedWait");
 }
 
 TEST_P(BackupEngineRateLimitingTestWithParam, RateLimitingVerifyBackup) {
   const std::size_t kMicrosPerSec = 1000 * 1000LL;
-  std::shared_ptr<RateLimiter> backupThrottler(NewGenericRateLimiter(
-      1, 100 * 1000 /* refill_period_us */, 10 /* fairness */,
-      RateLimiter::Mode::kAllIo /* mode */));
-
-  bool makeThrottler = std::get<0>(GetParam());
-  if (makeThrottler) {
-    engine_options_->backup_rate_limiter = backupThrottler;
-  }
-
-  bool is_single_threaded = std::get<1>(GetParam()) == 0 ? true : false;
-  engine_options_->max_background_operations = is_single_threaded ? 1 : 10;
-
+  const bool custom_rate_limiter = std::get<0>(GetParam());
   const std::uint64_t backup_rate_limiter_limit = std::get<2>(GetParam()).first;
-  if (makeThrottler) {
-    engine_options_->backup_rate_limiter->SetBytesPerSecond(
-        backup_rate_limiter_limit);
+  const bool is_single_threaded = std::get<1>(GetParam()) == 0 ? true : false;
+  std::unique_ptr<Env> special_env(
+      new SpecialEnv(db_chroot_env_.get(), /*time_elapse_only_sleep*/ true));
+
+  if (custom_rate_limiter) {
+    std::shared_ptr<RateLimiter> backup_rate_limiter =
+        std::make_shared<GenericRateLimiter>(
+            backup_rate_limiter_limit, 100 * 1000 /* refill_period_us */,
+            10 /* fairness */, RateLimiter::Mode::kAllIo /* mode */,
+            special_env->GetSystemClock(), false /* auto_tuned */);
+    engine_options_->backup_rate_limiter = backup_rate_limiter;
   } else {
     engine_options_->backup_rate_limit = backup_rate_limiter_limit;
   }
 
-  DestroyDB(dbname_, Options());
+  engine_options_->max_background_operations = is_single_threaded ? 1 : 10;
+
+  Options options;
+  options.env = special_env.get();
+  DestroyDB(dbname_, options);
+  // Rate limiter uses `CondVar::TimedWait()`, which does not have access to the
+  // `Env` to advance its time according to the fake wait duration. The
+  // workaround is to install a callback that advance the `Env`'s mock time.
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "GenericRateLimiter::Request:PostTimedWait", [&](void* arg) {
+        int64_t time_waited_us = *static_cast<int64_t*>(arg);
+        special_env->SleepForMicroseconds(static_cast<int>(time_waited_us));
+      });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
   OpenDBAndBackupEngine(true /* destroy_old_data */);
-  FillDB(db_.get(), 0, 100000);
+  TEST_SetDefaultRateLimitersClock(backup_engine_.get(),
+                                   special_env->GetSystemClock(), nullptr);
+  FillDB(db_.get(), 0, 10000);
+
   ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(),
                                             false /* flush_before_backup */));
 
@@ -2688,21 +2727,24 @@ TEST_P(BackupEngineRateLimitingTestWithParam, RateLimitingVerifyBackup) {
   for (BackupFileInfo backup_file_info : backup_info.file_details) {
     bytes_read_during_verify_backup += backup_file_info.size;
   }
-
-  auto start_verify_backup = db_chroot_env_->NowMicros();
+  auto start_verify_backup = special_env->NowMicros();
   ASSERT_OK(
       backup_engine_->VerifyBackup(backup_id, true /* verify_with_checksum */));
-  auto verify_backup_time = db_chroot_env_->NowMicros() - start_verify_backup;
+  auto verify_backup_time = special_env->NowMicros() - start_verify_backup;
   auto rate_limited_verify_backup_time =
       (bytes_read_during_verify_backup * kMicrosPerSec) /
       backup_rate_limiter_limit;
-
-  if (makeThrottler) {
+  if (custom_rate_limiter) {
     EXPECT_GE(verify_backup_time, 0.8 * rate_limited_verify_backup_time);
   }
+
   CloseDBAndBackupEngine();
-  AssertBackupConsistency(backup_id, 0, 100000, 100010);
-  DestroyDB(dbname_, Options());
+  AssertBackupConsistency(backup_id, 0, 10000, 10010);
+  DestroyDB(dbname_, options);
+
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearCallBack(
+      "GenericRateLimiter::Request:PostTimedWait");
 }
 
 TEST_P(BackupEngineRateLimitingTestWithParam, RateLimitingChargeReadInBackup) {
@@ -3285,7 +3327,7 @@ TEST_F(BackupEngineTest, MetaSchemaVersion2_SizeCorruption) {
 
   for (int id = 1; id <= 3; ++id) {
     ASSERT_OK(file_manager_->WriteToFile(
-        private_dir + "/" + ToString(id) + "/CURRENT", "x"));
+        private_dir + "/" + std::to_string(id) + "/CURRENT", "x"));
   }
   // Except corrupt Backup 4 with same size CURRENT file
   {
@@ -3518,7 +3560,7 @@ TEST_F(BackupEngineTest, Concurrency) {
           ASSERT_EQ(ids.size(), 0U);
 
           // (Eventually, see below) Restore one of the backups, or "latest"
-          std::string restore_db_dir = dbname_ + "/restore" + ToString(i);
+          std::string restore_db_dir = dbname_ + "/restore" + std::to_string(i);
           DestroyDir(test_db_env_.get(), restore_db_dir).PermitUncheckedError();
           BackupID to_restore;
           if (latest) {
@@ -3756,7 +3798,8 @@ TEST_F(BackupEngineTest, WriteOnlyEngineNoSharedFileDeletion) {
     }
     CloseDBAndBackupEngine();
 
-    engine_options_->max_valid_backups_to_open = port::kMaxInt32;
+    engine_options_->max_valid_backups_to_open =
+        std::numeric_limits<int32_t>::max();
     AssertBackupConsistency(i + 1, 0, (i + 1) * kNumKeys);
   }
 }
@@ -4110,7 +4153,7 @@ TEST_F(BackupEngineTest, FileTemperatures) {
     }
 
     // Restore backup to another virtual (tiered) dir
-    const std::string restore_dir = "/restore" + ToString(i);
+    const std::string restore_dir = "/restore" + std::to_string(i);
     ASSERT_OK(backup_engine_->RestoreDBFromLatestBackup(
         RestoreOptions(), restore_dir, restore_dir));