@nxtedition/rocksdb 7.1.14 → 7.1.16

package/deps/rocksdb/rocksdb/db/range_del_aggregator.cc

@@ -37,7 +37,6 @@ TruncatedRangeDelIterator::TruncatedRangeDelIterator(
                                          false /* log_err_key */);  // TODO
     pik_status.PermitUncheckedError();
     assert(pik_status.ok());
-
     smallest_ = &parsed_smallest;
   }
   if (largest != nullptr) {
@@ -69,12 +68,16 @@ TruncatedRangeDelIterator::TruncatedRangeDelIterator(
       // the truncated end key can cover the largest key in this sstable, reduce
       // its sequence number by 1.
       parsed_largest.sequence -= 1;
+      // This line is not needed for correctness, but it ensures that the
+      // truncated end key is not covering keys from the next SST file.
+      parsed_largest.type = kValueTypeForSeek;
     }
     largest_ = &parsed_largest;
   }
 }
 
 bool TruncatedRangeDelIterator::Valid() const {
+  assert(iter_ != nullptr);
   return iter_->Valid() &&
          (smallest_ == nullptr ||
           icmp_->Compare(*smallest_, iter_->parsed_end_key()) < 0) &&
@@ -82,12 +85,6 @@ bool TruncatedRangeDelIterator::Valid() const {
           icmp_->Compare(iter_->parsed_start_key(), *largest_) < 0);
 }
 
-void TruncatedRangeDelIterator::Next() { iter_->TopNext(); }
-
-void TruncatedRangeDelIterator::Prev() { iter_->TopPrev(); }
-
-void TruncatedRangeDelIterator::InternalNext() { iter_->Next(); }
-
 // NOTE: target is a user key
 void TruncatedRangeDelIterator::Seek(const Slice& target) {
   if (largest_ != nullptr &&
@@ -149,9 +146,8 @@ TruncatedRangeDelIterator::SplitBySnapshot(
   std::for_each(
       split_untruncated_iters.begin(), split_untruncated_iters.end(),
       [&](FragmentedIterPair& iter_pair) {
-        std::unique_ptr<TruncatedRangeDelIterator> truncated_iter(
-            new TruncatedRangeDelIterator(std::move(iter_pair.second), icmp_,
-                                          smallest_ikey_, largest_ikey_));
+        auto truncated_iter = std::make_unique<TruncatedRangeDelIterator>(
+            std::move(iter_pair.second), icmp_, smallest_ikey_, largest_ikey_);
         split_truncated_iters.emplace(iter_pair.first,
                                       std::move(truncated_iter));
       });
@@ -322,9 +318,8 @@ void ReadRangeDelAggregator::AddTombstones(
   if (input_iter == nullptr || input_iter->empty()) {
     return;
   }
-  rep_.AddTombstones(
-      std::unique_ptr<TruncatedRangeDelIterator>(new TruncatedRangeDelIterator(
-          std::move(input_iter), icmp_, smallest, largest)));
+  rep_.AddTombstones(std::make_unique<TruncatedRangeDelIterator>(
+      std::move(input_iter), icmp_, smallest, largest));
 }
 
 bool ReadRangeDelAggregator::ShouldDeleteImpl(const ParsedInternalKey& parsed,
@@ -471,19 +466,16 @@ CompactionRangeDelAggregator::NewIterator(const Slice* lower_bound,
                                           const Slice* upper_bound,
                                           bool upper_bound_inclusive) {
   InvalidateRangeDelMapPositions();
-  std::unique_ptr<TruncatedRangeDelMergingIter> merging_iter(
-      new TruncatedRangeDelMergingIter(icmp_, lower_bound, upper_bound,
-                                       upper_bound_inclusive, parent_iters_));
+  auto merging_iter = std::make_unique<TruncatedRangeDelMergingIter>(
+      icmp_, lower_bound, upper_bound, upper_bound_inclusive, parent_iters_);
 
   auto fragmented_tombstone_list =
       std::make_shared<FragmentedRangeTombstoneList>(
           std::move(merging_iter), *icmp_, true /* for_compaction */,
           *snapshots_);
 
-  return std::unique_ptr<FragmentedRangeTombstoneIterator>(
-      new FragmentedRangeTombstoneIterator(
-          fragmented_tombstone_list, *icmp_,
-          kMaxSequenceNumber /* upper_bound */));
+  return std::make_unique<FragmentedRangeTombstoneIterator>(
+      fragmented_tombstone_list, *icmp_, kMaxSequenceNumber /* upper_bound */);
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db/range_del_aggregator.h

@@ -38,14 +38,15 @@ class TruncatedRangeDelIterator {
 
   bool Valid() const;
 
-  void Next();
-  void Prev();
+  void Next() { iter_->TopNext(); }
+  void Prev() { iter_->TopPrev(); }
 
-  void InternalNext();
+  void InternalNext() { iter_->Next(); }
 
   // Seeks to the tombstone with the highest visible sequence number that covers
   // target (a user key). If no such tombstone exists, the position will be at
   // the earliest tombstone that ends after target.
+  // REQUIRES: target is a user key.
   void Seek(const Slice& target);
 
   // Seeks to the tombstone with the highest visible sequence number that covers
@@ -281,11 +282,11 @@ class RangeDelAggregator {
       const InternalKey* smallest = nullptr,
       const InternalKey* largest = nullptr) = 0;
 
-  bool ShouldDelete(const Slice& key, RangeDelPositioningMode mode) {
+  bool ShouldDelete(const Slice& ikey, RangeDelPositioningMode mode) {
     ParsedInternalKey parsed;
 
     Status pik_status =
-        ParseInternalKey(key, &parsed, false /* log_err_key */);  // TODO
+        ParseInternalKey(ikey, &parsed, false /* log_err_key */);  // TODO
     assert(pik_status.ok());
     if (!pik_status.ok()) {
       return false;

package/deps/rocksdb/rocksdb/db/range_del_aggregator_test.cc

@@ -76,8 +76,9 @@ ParsedInternalKey UncutEndpoint(const Slice& s) {
   return ParsedInternalKey(s, kMaxSequenceNumber, kTypeRangeDeletion);
 }
 
-ParsedInternalKey InternalValue(const Slice& key, SequenceNumber seq) {
-  return ParsedInternalKey(key, seq, kTypeValue);
+ParsedInternalKey InternalValue(const Slice& key, SequenceNumber seq,
+                                ValueType type = kTypeValue) {
+  return ParsedInternalKey(key, seq, type);
 }
 
 void VerifyIterator(
@@ -292,16 +293,18 @@ TEST_F(RangeDelAggregatorTest, TruncatedIterPartiallyCutTombstones) {
   TruncatedRangeDelIterator iter(std::move(input_iter), &bytewise_icmp,
                                  &smallest, &largest);
 
-  VerifyIterator(&iter, bytewise_icmp,
-                 {{InternalValue("d", 7), UncutEndpoint("e"), 10},
-                  {UncutEndpoint("e"), UncutEndpoint("g"), 8},
-                  {UncutEndpoint("j"), InternalValue("m", 8), 4}});
+  VerifyIterator(
+      &iter, bytewise_icmp,
+      {{InternalValue("d", 7), UncutEndpoint("e"), 10},
+       {UncutEndpoint("e"), UncutEndpoint("g"), 8},
+       {UncutEndpoint("j"), InternalValue("m", 8, kValueTypeForSeek), 4}});
 
   VerifySeek(
       &iter, bytewise_icmp,
       {{"d", InternalValue("d", 7), UncutEndpoint("e"), 10},
        {"e", UncutEndpoint("e"), UncutEndpoint("g"), 8},
-       {"ia", UncutEndpoint("j"), InternalValue("m", 8), 4},
+       {"ia", UncutEndpoint("j"), InternalValue("m", 8, kValueTypeForSeek), 4,
+        false /* invalid */},
        {"n", UncutEndpoint(""), UncutEndpoint(""), 0, true /* invalid */},
        {"", InternalValue("d", 7), UncutEndpoint("e"), 10}});
 
@@ -310,7 +313,8 @@ TEST_F(RangeDelAggregatorTest, TruncatedIterPartiallyCutTombstones) {
       {{"d", InternalValue("d", 7), UncutEndpoint("e"), 10},
        {"e", UncutEndpoint("e"), UncutEndpoint("g"), 8},
        {"ia", UncutEndpoint("e"), UncutEndpoint("g"), 8},
-       {"n", UncutEndpoint("j"), InternalValue("m", 8), 4},
+       {"n", UncutEndpoint("j"), InternalValue("m", 8, kValueTypeForSeek), 4,
+        false /* invalid */},
        {"", UncutEndpoint(""), UncutEndpoint(""), 0, true /* invalid */}});
 }
 

package/deps/rocksdb/rocksdb/db/range_tombstone_fragmenter.cc

@@ -67,8 +67,8 @@ FragmentedRangeTombstoneList::FragmentedRangeTombstoneList(
                         unfragmented_tombstones->value().size());
   }
   // VectorIterator implicitly sorts by key during construction.
-  auto iter = std::unique_ptr<VectorIterator>(
-      new VectorIterator(std::move(keys), std::move(values), &icmp));
+  auto iter = std::make_unique<VectorIterator>(std::move(keys),
+                                               std::move(values), &icmp);
   FragmentTombstones(std::move(iter), icmp, for_compaction, snapshots);
 }
 
@@ -251,6 +251,22 @@ FragmentedRangeTombstoneIterator::FragmentedRangeTombstoneIterator(
   Invalidate();
 }
 
+FragmentedRangeTombstoneIterator::FragmentedRangeTombstoneIterator(
+    const std::shared_ptr<FragmentedRangeTombstoneListCache>& tombstones_cache,
+    const InternalKeyComparator& icmp, SequenceNumber _upper_bound,
+    SequenceNumber _lower_bound)
+    : tombstone_start_cmp_(icmp.user_comparator()),
+      tombstone_end_cmp_(icmp.user_comparator()),
+      icmp_(&icmp),
+      ucmp_(icmp.user_comparator()),
+      tombstones_cache_ref_(tombstones_cache),
+      tombstones_(tombstones_cache_ref_->tombstones.get()),
+      upper_bound_(_upper_bound),
+      lower_bound_(_lower_bound) {
+  assert(tombstones_ != nullptr);
+  Invalidate();
+}
+
 void FragmentedRangeTombstoneIterator::SeekToFirst() {
   pos_ = tombstones_->begin();
   seq_pos_ = tombstones_->seq_begin();
@@ -433,9 +449,8 @@ FragmentedRangeTombstoneIterator::SplitBySnapshot(
       upper = snapshots[i];
     }
     if (tombstones_->ContainsRange(lower, upper)) {
-      splits.emplace(upper, std::unique_ptr<FragmentedRangeTombstoneIterator>(
-                                new FragmentedRangeTombstoneIterator(
-                                    tombstones_, *icmp_, upper, lower)));
+      splits.emplace(upper, std::make_unique<FragmentedRangeTombstoneIterator>(
+                                tombstones_, *icmp_, upper, lower));
     }
     lower = upper + 1;
   }

package/deps/rocksdb/rocksdb/db/range_tombstone_fragmenter.h

@@ -17,6 +17,15 @@
 #include "table/internal_iterator.h"
 
 namespace ROCKSDB_NAMESPACE {
+struct FragmentedRangeTombstoneList;
+
+struct FragmentedRangeTombstoneListCache {
+  // ensure only the first reader needs to initialize l
+  std::mutex reader_mutex;
+  std::unique_ptr<FragmentedRangeTombstoneList> tombstones = nullptr;
+  // readers will first check this bool to avoid
+  std::atomic<bool> initialized = false;
+};
 
 struct FragmentedRangeTombstoneList {
  public:
@@ -113,6 +122,10 @@ class FragmentedRangeTombstoneIterator : public InternalIterator {
       const std::shared_ptr<const FragmentedRangeTombstoneList>& tombstones,
       const InternalKeyComparator& icmp, SequenceNumber upper_bound,
       SequenceNumber lower_bound = 0);
+  FragmentedRangeTombstoneIterator(
+      const std::shared_ptr<FragmentedRangeTombstoneListCache>& tombstones,
+      const InternalKeyComparator& icmp, SequenceNumber upper_bound,
+      SequenceNumber lower_bound = 0);
 
   void SeekToFirst() override;
   void SeekToLast() override;
@@ -260,6 +273,7 @@ class FragmentedRangeTombstoneIterator : public InternalIterator {
   const InternalKeyComparator* icmp_;
   const Comparator* ucmp_;
   std::shared_ptr<const FragmentedRangeTombstoneList> tombstones_ref_;
+  std::shared_ptr<FragmentedRangeTombstoneListCache> tombstones_cache_ref_;
   const FragmentedRangeTombstoneList* tombstones_;
   SequenceNumber upper_bound_;
   SequenceNumber lower_bound_;

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

@@ -162,9 +162,13 @@ class Repairer {
     edit.AddColumnFamily(cf_name);
 
     mutex_.Lock();
-    Status status = vset_.LogAndApply(cfd, mut_cf_opts, &edit, &mutex_,
-                                      nullptr /* db_directory */,
-                                      false /* new_descriptor_log */, cf_opts);
+    std::unique_ptr<FSDirectory> db_dir;
+    Status status = env_->GetFileSystem()->NewDirectory(dbname_, IOOptions(),
+                                                        &db_dir, nullptr);
+    if (status.ok()) {
+      status = vset_.LogAndApply(cfd, mut_cf_opts, &edit, &mutex_, db_dir.get(),
+                                 false /* new_descriptor_log */, cf_opts);
+    }
     mutex_.Unlock();
     return status;
   }
@@ -504,8 +508,8 @@ class Repairer {
                                 file_size);
     std::shared_ptr<const TableProperties> props;
     if (status.ok()) {
-      status = table_cache_->GetTableProperties(file_options_, icmp_,
-                                                t->meta.fd, &props);
+      status = table_cache_->GetTableProperties(file_options_, icmp_, t->meta,
+                                                &props);
     }
     if (status.ok()) {
       auto s =
@@ -656,9 +660,14 @@ class Repairer {
       assert(next_file_number_ > 0);
       vset_.MarkFileNumberUsed(next_file_number_ - 1);
       mutex_.Lock();
-      Status status = vset_.LogAndApply(
-          cfd, *cfd->GetLatestMutableCFOptions(), &edit, &mutex_,
-          nullptr /* db_directory */, false /* new_descriptor_log */);
+      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 */);
+      }
       mutex_.Unlock();
       if (!status.ok()) {
         return status;

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

@@ -48,7 +48,7 @@ class RepairTest : public DBTestBase {
   void ReopenWithSstIdVerify() {
     std::atomic_int verify_passed{0};
     SyncPoint::GetInstance()->SetCallBack(
-        "Version::VerifySstUniqueIds::Passed", [&](void* arg) {
+        "BlockBasedTable::Open::PassedVerifyUniqueId", [&](void* arg) {
           // override job status
           auto id = static_cast<UniqueId64x2*>(arg);
           assert(*id != kNullUniqueId64x2);
@@ -60,6 +60,7 @@ class RepairTest : public DBTestBase {
     Reopen(options);
 
     ASSERT_GT(verify_passed, 0);
+    SyncPoint::GetInstance()->DisableProcessing();
   }
 };
 

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

@@ -5,7 +5,7 @@
 //  (found in the LICENSE.Apache file in the root directory).
 
 #include "db/db_test_util.h"
-#include "db/periodic_work_scheduler.h"
+#include "db/periodic_task_scheduler.h"
 #include "db/seqno_to_time_mapping.h"
 #include "port/stack_trace.h"
 #include "rocksdb/iostats_context.h"
@@ -29,11 +29,10 @@ class SeqnoTimeTest : public DBTestBase {
   void SetUp() override {
     mock_clock_->InstallTimedWaitFixCallback();
     SyncPoint::GetInstance()->SetCallBack(
-        "DBImpl::StartPeriodicWorkScheduler:Init", [&](void* arg) {
-          auto* periodic_work_scheduler_ptr =
-              reinterpret_cast<PeriodicWorkScheduler**>(arg);
-          *periodic_work_scheduler_ptr =
-              PeriodicWorkTestScheduler::Default(mock_clock_);
+        "DBImpl::StartPeriodicTaskScheduler:Init", [&](void* arg) {
+          auto periodic_task_scheduler_ptr =
+              reinterpret_cast<PeriodicTaskScheduler*>(arg);
+          periodic_task_scheduler_ptr->TEST_OverrideTimer(mock_clock_.get());
         });
   }
 
@@ -80,7 +79,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_WaitForPeridicWorkerRun(
+  dbfull()->TEST_WaitForPeridicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec)); });
 
   int sst_num = 0;
@@ -88,7 +87,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_WaitForPeridicWorkerRun([&] {
+      dbfull()->TEST_WaitForPeridicTaskRun([&] {
         mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
       });
     }
@@ -110,7 +109,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_WaitForPeridicWorkerRun([&] {
+      dbfull()->TEST_WaitForPeridicTaskRun([&] {
         mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
       });
     }
@@ -124,7 +123,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_WaitForPeridicWorkerRun([&] {
+      dbfull()->TEST_WaitForPeridicTaskRun([&] {
         mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
       });
     }
@@ -142,36 +141,31 @@ TEST_F(SeqnoTimeTest, TemperatureBasicUniversal) {
   // the first a few key should be cold
   AssertKetTemperature(20, Temperature::kCold);
 
-  // Wait some time, each time after compaction, the cold data size is
-  // increasing and hot data size is decreasing
   for (int i = 0; i < 30; i++) {
-    dbfull()->TEST_WaitForPeridicWorkerRun([&] {
+    dbfull()->TEST_WaitForPeridicTaskRun([&] {
       mock_clock_->MockSleepForSeconds(static_cast<int>(20 * kKeyPerSec));
     });
     ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-    uint64_t pre_hot = hot_data_size;
-    uint64_t pre_cold = cold_data_size;
-    hot_data_size = GetSstSizeHelper(Temperature::kUnknown);
-    cold_data_size = GetSstSizeHelper(Temperature::kCold);
-    ASSERT_LT(hot_data_size, pre_hot);
-    ASSERT_GT(cold_data_size, pre_cold);
 
     // the hot/cold data cut off range should be between i * 20 + 200 -> 250
     AssertKetTemperature(i * 20 + 250, Temperature::kUnknown);
     AssertKetTemperature(i * 20 + 200, Temperature::kCold);
   }
 
-  // Wait again, all data should be cold after that
+  ASSERT_LT(GetSstSizeHelper(Temperature::kUnknown), hot_data_size);
+  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), cold_data_size);
+
+  // Wait again, the most of the data should be cold after that
+  // but it may not be all cold, because if there's no new data write to SST,
+  // 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_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1000)); });
     ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
   }
 
-  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown), 0);
-  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
-
-  // any random data should be cold
+  // any random data close to the end should be cold
   AssertKetTemperature(1000, Temperature::kCold);
 
   // close explicitly, because the env is local variable which will be released
@@ -197,7 +191,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_WaitForPeridicWorkerRun(
+  dbfull()->TEST_WaitForPeridicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
 
   int sst_num = 0;
@@ -205,7 +199,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_WaitForPeridicWorkerRun(
+      dbfull()->TEST_WaitForPeridicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
     }
     ASSERT_OK(Flush());
@@ -227,7 +221,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_WaitForPeridicWorkerRun(
+      dbfull()->TEST_WaitForPeridicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
     }
     ASSERT_OK(Flush());
@@ -248,7 +242,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_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(200)); });
     ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
     uint64_t pre_hot = hot_data_size;
@@ -263,17 +257,16 @@ TEST_F(SeqnoTimeTest, TemperatureBasicLevel) {
     AssertKetTemperature(i * 20 + 400, Temperature::kCold);
   }
 
-  // Wait again, all data should be cold after that
+  // Wait again, the most of the data should be cold after that
+  // 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_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1000)); });
     ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
   }
 
-  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown), 0);
-  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
-
-  // any random data should be cold
+  // any random data close to the end should be cold
   AssertKetTemperature(1000, Temperature::kCold);
 
   Close();
@@ -291,7 +284,7 @@ TEST_F(SeqnoTimeTest, BasicSeqnoToTimeMapping) {
   // Write a key every 10 seconds
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
   }
   ASSERT_OK(Flush());
@@ -322,7 +315,7 @@ TEST_F(SeqnoTimeTest, BasicSeqnoToTimeMapping) {
   // Write a key every 1 seconds
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i + 190), "value"));
-    dbfull()->TEST_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1)); });
   }
   seq_end = dbfull()->GetLatestSequenceNumber();
@@ -358,7 +351,7 @@ TEST_F(SeqnoTimeTest, BasicSeqnoToTimeMapping) {
   // Write a key every 200 seconds
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i + 380), "value"));
-    dbfull()->TEST_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(200)); });
   }
   seq_end = dbfull()->GetLatestSequenceNumber();
@@ -400,7 +393,7 @@ TEST_F(SeqnoTimeTest, BasicSeqnoToTimeMapping) {
   // Write a key every 100 seconds
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i + 570), "value"));
-    dbfull()->TEST_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   seq_end = dbfull()->GetLatestSequenceNumber();
@@ -464,9 +457,7 @@ TEST_F(SeqnoTimeTest, BasicSeqnoToTimeMapping) {
   ASSERT_OK(db_->Close());
 }
 
-// TODO(zjay): Disabled, until New CF bug with preclude_last_level_data_seconds
-//  is fixed
-TEST_F(SeqnoTimeTest, DISABLED_MultiCFs) {
+TEST_F(SeqnoTimeTest, MultiCFs) {
   Options options = CurrentOptions();
   options.preclude_last_level_data_seconds = 0;
   options.env = mock_env_.get();
@@ -474,14 +465,14 @@ TEST_F(SeqnoTimeTest, DISABLED_MultiCFs) {
   options.stats_persist_period_sec = 0;
   ReopenWithColumnFamilies({"default"}, options);
 
-  auto scheduler = dbfull()->TEST_GetPeriodicWorkScheduler();
-  ASSERT_FALSE(scheduler->TEST_HasValidTask(
-      dbfull(), PeriodicWorkTaskNames::kRecordSeqnoTime));
+  const PeriodicTaskScheduler& scheduler =
+      dbfull()->TEST_GetPeriodicTaskScheduler();
+  ASSERT_FALSE(scheduler.TEST_HasTask(PeriodicTaskType::kRecordSeqnoTime));
 
   // Write some data and increase the current time
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(Put(Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   ASSERT_OK(Flush());
@@ -496,26 +487,20 @@ TEST_F(SeqnoTimeTest, DISABLED_MultiCFs) {
   Options options_1 = options;
   options_1.preclude_last_level_data_seconds = 10000;  // 10k
   CreateColumnFamilies({"one"}, options_1);
-  ASSERT_TRUE(scheduler->TEST_HasValidTask(
-      dbfull(), PeriodicWorkTaskNames::kRecordSeqnoTime));
+  ASSERT_TRUE(scheduler.TEST_HasTask(PeriodicTaskType::kRecordSeqnoTime));
 
   // 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_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   ASSERT_OK(Flush());
 
-  // in memory mapping won't increase because CFs with preclude_last_level
-  // feature doesn't have memtable
-  auto queue = dbfull()->TEST_GetSeqnoToTimeMapping().TEST_GetInternalMapping();
-  ASSERT_LT(queue.size(), 5);
-
   // Write some data to the CF one
   for (int i = 0; i < 20; i++) {
     ASSERT_OK(Put(1, Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
   }
   ASSERT_OK(Flush(1));
@@ -539,7 +524,7 @@ TEST_F(SeqnoTimeTest, DISABLED_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_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   seqs = dbfull()->TEST_GetSeqnoToTimeMapping().TEST_GetInternalMapping();
@@ -563,11 +548,10 @@ TEST_F(SeqnoTimeTest, DISABLED_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_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   seqs = dbfull()->TEST_GetSeqnoToTimeMapping().TEST_GetInternalMapping();
-  ASSERT_LE(seqs.size(), 5);
   ASSERT_OK(Flush(0));
 
   // trigger compaction for CF "two" and make sure the compaction output has
@@ -575,7 +559,7 @@ TEST_F(SeqnoTimeTest, DISABLED_MultiCFs) {
   for (int j = 0; j < 3; j++) {
     for (int i = 0; i < 200; i++) {
       ASSERT_OK(Put(2, Key(i), "value"));
-      dbfull()->TEST_WaitForPeridicWorkerRun(
+      dbfull()->TEST_WaitForPeridicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
     }
     ASSERT_OK(Flush(2));
@@ -595,7 +579,7 @@ TEST_F(SeqnoTimeTest, DISABLED_MultiCFs) {
   for (int j = 0; j < 2; j++) {
     for (int i = 0; i < 200; i++) {
       ASSERT_OK(Put(0, Key(i), "value"));
-      dbfull()->TEST_WaitForPeridicWorkerRun(
+      dbfull()->TEST_WaitForPeridicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
     }
     ASSERT_OK(Flush(0));
@@ -610,7 +594,7 @@ TEST_F(SeqnoTimeTest, DISABLED_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_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   ASSERT_GE(
@@ -630,8 +614,7 @@ TEST_F(SeqnoTimeTest, DISABLED_MultiCFs) {
       0);
 
   // And the timer worker is stopped
-  ASSERT_FALSE(scheduler->TEST_HasValidTask(
-      dbfull(), PeriodicWorkTaskNames::kRecordSeqnoTime));
+  ASSERT_FALSE(scheduler.TEST_HasTask(PeriodicTaskType::kRecordSeqnoTime));
   Close();
 }
 
@@ -655,7 +638,7 @@ TEST_F(SeqnoTimeTest, MultiInstancesBasic) {
   WriteOptions wo;
   for (int i = 0; i < 200; i++) {
     ASSERT_OK(dbi->Put(wo, Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
   SeqnoToTimeMapping seqno_to_time_mapping = dbi->TEST_GetSeqnoToTimeMapping();
@@ -678,7 +661,7 @@ TEST_F(SeqnoTimeTest, SeqnoToTimeMappingUniversal) {
   for (int j = 0; j < 3; j++) {
     for (int i = 0; i < 100; i++) {
       ASSERT_OK(Put(Key(i), "value"));
-      dbfull()->TEST_WaitForPeridicWorkerRun(
+      dbfull()->TEST_WaitForPeridicTaskRun(
           [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
     }
     ASSERT_OK(Flush());
@@ -700,7 +683,7 @@ TEST_F(SeqnoTimeTest, SeqnoToTimeMappingUniversal) {
   // Trigger a compaction
   for (int i = 0; i < 100; i++) {
     ASSERT_OK(Put(Key(i), "value"));
-    dbfull()->TEST_WaitForPeridicWorkerRun(
+    dbfull()->TEST_WaitForPeridicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
   }
   ASSERT_OK(Flush());