@nxtedition/rocksdb 10.0.13 → 10.0.15

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

@@ -33,10 +33,11 @@ class SeqnoTimeTest : public DBTestBase {
   void SetUp() override {
     mock_clock_->InstallTimedWaitFixCallback();
     SyncPoint::GetInstance()->SetCallBack(
-        "DBImpl::StartPeriodicTaskScheduler:Init", [&](void* arg) {
+        "DBImpl::StartPeriodicTaskScheduler:Init",
+        [mock_clock = mock_clock_](void* arg) {
           auto periodic_task_scheduler_ptr =
-              reinterpret_cast<PeriodicTaskScheduler*>(arg);
-          periodic_task_scheduler_ptr->TEST_OverrideTimer(mock_clock_.get());
+              static_cast<PeriodicTaskScheduler*>(arg);
+          periodic_task_scheduler_ptr->TEST_OverrideTimer(mock_clock.get());
         });
     mock_clock_->SetCurrentTime(kMockStartTime);
   }
@@ -78,7 +79,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicUniversal) {
   options.compaction_style = kCompactionStyleUniversal;
   options.preclude_last_level_data_seconds = 10000;
   options.env = mock_env_.get();
-  options.bottommost_temperature = Temperature::kCold;
+  options.last_level_temperature = Temperature::kCold;
   options.num_levels = kNumLevels;
   DestroyAndReopen(options);
 
@@ -180,7 +181,7 @@ TEST_F(SeqnoTimeTest, TemperatureBasicLevel) {
   Options options = CurrentOptions();
   options.preclude_last_level_data_seconds = 10000;
   options.env = mock_env_.get();
-  options.bottommost_temperature = Temperature::kCold;
+  options.last_level_temperature = Temperature::kCold;
   options.num_levels = kNumLevels;
   options.level_compaction_dynamic_level_bytes = true;
   // TODO(zjay): for level compaction, auto-compaction may stuck in deadloop, if
@@ -330,25 +331,41 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   ASSERT_EQ(tables_props.size(), 1);
   auto it = tables_props.begin();
   SeqnoToTimeMapping tp_mapping;
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
-  ASSERT_OK(tp_mapping.Sort());
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
   ASSERT_FALSE(tp_mapping.Empty());
   auto seqs = tp_mapping.TEST_GetInternalMapping();
   // about ~20 seqs->time entries, because the sample rate is 10000/100, and it
   // passes 2k time. Add (roughly) one for starting entry.
-  ASSERT_GE(seqs.size(), 20);
-  ASSERT_LE(seqs.size(), 22);
-  SequenceNumber seq_end = dbfull()->GetLatestSequenceNumber() + 1;
-  for (auto i = start_seq; i < seq_end; i++) {
-    // The result is within the range
-    ASSERT_GE(tp_mapping.GetProximalTimeBeforeSeqno(i),
-              start_time + (i - start_seq) * 10 - 100);
-    ASSERT_LE(tp_mapping.GetProximalTimeBeforeSeqno(i),
-              start_time + (i - start_seq) * 10);
-  }
+  // Revised: with automatic pre-population of mappings, some of these entries
+  // might be purged to keep the DB mapping within capacity.
+  EXPECT_GE(seqs.size(), 20 / 2);
+  EXPECT_LE(seqs.size(), 22);
+
+  auto ValidateProximalSeqnos = [&](const char* name, double fuzz_ratio) {
+    SequenceNumber seq_end = dbfull()->GetLatestSequenceNumber() + 1;
+    uint64_t end_time = mock_clock_->NowSeconds();
+    uint64_t seqno_fuzz =
+        static_cast<uint64_t>((seq_end - start_seq) * fuzz_ratio + 0.999999);
+    for (unsigned time_pct = 0; time_pct <= 100; time_pct++) {
+      SCOPED_TRACE("name=" + std::string(name) +
+                   " time_pct=" + std::to_string(time_pct));
+      // Validate the important proximal API (GetProximalSeqnoBeforeTime)
+      uint64_t t = start_time + time_pct * (end_time - start_time) / 100;
+      auto seqno_reported = tp_mapping.GetProximalSeqnoBeforeTime(t);
+      auto seqno_expected = start_seq + time_pct * (seq_end - start_seq) / 100;
+      EXPECT_LE(seqno_reported, seqno_expected);
+      if (end_time - t < 10000) {
+        EXPECT_LE(seqno_expected, seqno_reported + seqno_fuzz);
+      }
+    }
+    start_seq = seq_end;
+    start_time = end_time;
+  };
+
+  ValidateProximalSeqnos("a", 0.1);
+
   checked_file_nums.insert(it->second->orig_file_number);
-  start_seq = seq_end;
-  start_time = mock_clock_->NowSeconds();
 
   // Write a key every 1 seconds
   for (int i = 0; i < 200; i++) {
@@ -356,7 +373,7 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
     dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(1)); });
   }
-  seq_end = dbfull()->GetLatestSequenceNumber() + 1;
+
   ASSERT_OK(Flush());
   tables_props.clear();
   ASSERT_OK(dbfull()->GetPropertiesOfAllTables(&tables_props));
@@ -371,21 +388,17 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   ASSERT_TRUE(it != tables_props.end());
 
   tp_mapping.Clear();
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
-  ASSERT_OK(tp_mapping.Sort());
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
   seqs = tp_mapping.TEST_GetInternalMapping();
   // There only a few time sample
   ASSERT_GE(seqs.size(), 1);
   ASSERT_LE(seqs.size(), 3);
-  for (auto i = start_seq; i < seq_end; i++) {
-    ASSERT_GE(tp_mapping.GetProximalTimeBeforeSeqno(i),
-              start_time + (i - start_seq) - 100);
-    ASSERT_LE(tp_mapping.GetProximalTimeBeforeSeqno(i),
-              start_time + (i - start_seq));
-  }
+
+  // High fuzz ratio because of low number of samples
+  ValidateProximalSeqnos("b", 0.5);
+
   checked_file_nums.insert(it->second->orig_file_number);
-  start_seq = seq_end;
-  start_time = mock_clock_->NowSeconds();
 
   // Write a key every 200 seconds
   for (int i = 0; i < 200; i++) {
@@ -393,7 +406,7 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
     dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(200)); });
   }
-  seq_end = dbfull()->GetLatestSequenceNumber() + 1;
+  // seq_end = dbfull()->GetLatestSequenceNumber() + 1;
   ASSERT_OK(Flush());
   tables_props.clear();
   ASSERT_OK(dbfull()->GetPropertiesOfAllTables(&tables_props));
@@ -408,24 +421,16 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   ASSERT_TRUE(it != tables_props.end());
 
   tp_mapping.Clear();
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
-  ASSERT_OK(tp_mapping.Sort());
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
   seqs = tp_mapping.TEST_GetInternalMapping();
-  // The sequence number -> time entries should be maxed
-  ASSERT_GE(seqs.size(), 99);
-  ASSERT_LE(seqs.size(), 101);
-  for (auto i = start_seq; i < seq_end; i++) {
-    // aged out entries allowed to report time=0
-    if ((seq_end - i) * 200 <= 10000) {
-      ASSERT_GE(tp_mapping.GetProximalTimeBeforeSeqno(i),
-                start_time + (i - start_seq) * 200 - 100);
-    }
-    ASSERT_LE(tp_mapping.GetProximalTimeBeforeSeqno(i),
-              start_time + (i - start_seq) * 200);
-  }
+  // For the preserved time span, only 10000/200=50 (+1) entries were recorded
+  ASSERT_GE(seqs.size(), 50);
+  ASSERT_LE(seqs.size(), 51);
+
+  ValidateProximalSeqnos("c", 0.04);
+
   checked_file_nums.insert(it->second->orig_file_number);
-  start_seq = seq_end;
-  start_time = mock_clock_->NowSeconds();
 
   // Write a key every 100 seconds
   for (int i = 0; i < 200; i++) {
@@ -433,7 +438,6 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
     dbfull()->TEST_WaitForPeriodicTaskRun(
         [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(100)); });
   }
-  seq_end = dbfull()->GetLatestSequenceNumber() + 1;
   ASSERT_OK(Flush());
   tables_props.clear();
   ASSERT_OK(dbfull()->GetPropertiesOfAllTables(&tables_props));
@@ -447,9 +451,11 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   }
   ASSERT_TRUE(it != tables_props.end());
   tp_mapping.Clear();
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
-  ASSERT_OK(tp_mapping.Sort());
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
   seqs = tp_mapping.TEST_GetInternalMapping();
+  // For the preserved time span, max entries were recorded and
+  // preserved (10000/100=100 (+1))
   ASSERT_GE(seqs.size(), 99);
   ASSERT_LE(seqs.size(), 101);
 
@@ -474,21 +480,14 @@ TEST_P(SeqnoTimeTablePropTest, BasicSeqnoToTimeMapping) {
   }
   ASSERT_TRUE(it != tables_props.end());
   tp_mapping.Clear();
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
-  ASSERT_OK(tp_mapping.Sort());
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
   seqs = tp_mapping.TEST_GetInternalMapping();
   ASSERT_GE(seqs.size(), 99);
   ASSERT_LE(seqs.size(), 101);
-  for (auto i = start_seq; i < seq_end; i++) {
-    // aged out entries allowed to report time=0
-    // FIXME: should be <=
-    if ((seq_end - i) * 100 < 10000) {
-      ASSERT_GE(tp_mapping.GetProximalTimeBeforeSeqno(i),
-                start_time + (i - start_seq) * 100 - 100);
-    }
-    ASSERT_LE(tp_mapping.GetProximalTimeBeforeSeqno(i),
-              start_time + (i - start_seq) * 100);
-  }
+
+  ValidateProximalSeqnos("d", 0.02);
+
   ASSERT_OK(db_->Close());
 }
 
@@ -545,8 +544,8 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   ASSERT_EQ(tables_props.size(), 1);
   it = tables_props.begin();
   SeqnoToTimeMapping tp_mapping;
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
-  ASSERT_OK(tp_mapping.Sort());
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
   ASSERT_FALSE(tp_mapping.Empty());
   auto seqs = tp_mapping.TEST_GetInternalMapping();
   ASSERT_GE(seqs.size(), 1);
@@ -565,7 +564,8 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   }
   seqs = dbfull()->TEST_GetSeqnoToTimeMapping().TEST_GetInternalMapping();
   ASSERT_GE(seqs.size(), 1000 - 1);
-  ASSERT_LE(seqs.size(), 1000 + 1);
+  // Non-strict limit can exceed capacity by a reasonable fraction
+  ASSERT_LE(seqs.size(), 1000 * 9 / 8);
 
   ASSERT_OK(Flush(2));
   tables_props.clear();
@@ -573,8 +573,8 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   ASSERT_EQ(tables_props.size(), 1);
   it = tables_props.begin();
   tp_mapping.Clear();
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
-  ASSERT_OK(tp_mapping.Sort());
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
   seqs = tp_mapping.TEST_GetInternalMapping();
   // the max encoded entries is 100
   ASSERT_GE(seqs.size(), 100 - 1);
@@ -606,8 +606,8 @@ TEST_P(SeqnoTimeTablePropTest, MultiCFs) {
   ASSERT_EQ(tables_props.size(), 1);
   it = tables_props.begin();
   tp_mapping.Clear();
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
-  ASSERT_OK(tp_mapping.Sort());
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
   seqs = tp_mapping.TEST_GetInternalMapping();
   ASSERT_GE(seqs.size(), 99);
   ASSERT_LE(seqs.size(), 101);
@@ -721,8 +721,8 @@ TEST_P(SeqnoTimeTablePropTest, SeqnoToTimeMappingUniversal) {
   for (const auto& props : tables_props) {
     ASSERT_FALSE(props.second->seqno_to_time_mapping.empty());
     SeqnoToTimeMapping tp_mapping;
-    ASSERT_OK(tp_mapping.Add(props.second->seqno_to_time_mapping));
-    ASSERT_OK(tp_mapping.Sort());
+    ASSERT_OK(tp_mapping.DecodeFrom(props.second->seqno_to_time_mapping));
+    ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
     ASSERT_FALSE(tp_mapping.Empty());
     auto seqs = tp_mapping.TEST_GetInternalMapping();
     // Add (roughly) one for starting entry.
@@ -746,7 +746,8 @@ TEST_P(SeqnoTimeTablePropTest, SeqnoToTimeMappingUniversal) {
   auto it = tables_props.begin();
   SeqnoToTimeMapping tp_mapping;
   ASSERT_FALSE(it->second->seqno_to_time_mapping.empty());
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
 
   // compact to the last level
   CompactRangeOptions cro;
@@ -773,7 +774,8 @@ TEST_P(SeqnoTimeTablePropTest, SeqnoToTimeMappingUniversal) {
 
   it = tables_props.begin();
   ASSERT_FALSE(it->second->seqno_to_time_mapping.empty());
-  ASSERT_OK(tp_mapping.Add(it->second->seqno_to_time_mapping));
+  ASSERT_OK(tp_mapping.DecodeFrom(it->second->seqno_to_time_mapping));
+  ASSERT_TRUE(tp_mapping.TEST_IsEnforced());
 
   // make half of the data expired
   mock_clock_->MockSleepForSeconds(static_cast<int>(8000));
@@ -929,7 +931,7 @@ TEST_P(SeqnoTimeTablePropTest, PrePopulateInDB) {
   DestroyAndReopen(track_options);
 
   // Ensure pre-population
-  constexpr auto kPrePopPairs = SeqnoToTimeMapping::kMaxSeqnoTimePairsPerSST;
+  constexpr auto kPrePopPairs = kMaxSeqnoTimePairsPerSST;
   sttm = dbfull()->TEST_GetSeqnoToTimeMapping();
   latest_seqno = db_->GetLatestSequenceNumber();
   start_time = mock_clock_->NowSeconds();
@@ -970,7 +972,7 @@ TEST_P(SeqnoTimeTablePropTest, PrePopulateInDB) {
   sttm = dbfull()->TEST_GetSeqnoToTimeMapping();
   latest_seqno = db_->GetLatestSequenceNumber();
   end_time = mock_clock_->NowSeconds();
-  ASSERT_EQ(sttm.Size(), kPrePopPairs);
+  ASSERT_GE(sttm.Size(), kPrePopPairs);
   ASSERT_EQ(sttm.GetProximalSeqnoBeforeTime(end_time), latest_seqno);
   ASSERT_EQ(sttm.GetProximalSeqnoBeforeTime(start_time - kPreserveSecs / 2),
             kPrePopPairs / 2);
@@ -1015,42 +1017,153 @@ TEST_P(SeqnoTimeTablePropTest, PrePopulateInDB) {
 }
 
 TEST_F(SeqnoTimeTest, MappingAppend) {
-  SeqnoToTimeMapping test(/*max_time_duration=*/100, /*max_capacity=*/10);
+  using P = SeqnoToTimeMapping::SeqnoTimePair;
+  SeqnoToTimeMapping test;
+  test.SetMaxTimeSpan(100).SetCapacity(10);
 
   // ignore seqno == 0, as it may mean the seqno is zeroed out
-  ASSERT_FALSE(test.Append(0, 9));
+  ASSERT_FALSE(test.Append(0, 100));
 
-  ASSERT_TRUE(test.Append(3, 10));
+  ASSERT_TRUE(test.Append(3, 200));
   auto size = test.Size();
   // normal add
-  ASSERT_TRUE(test.Append(10, 11));
+  ASSERT_TRUE(test.Append(10, 300));
   size++;
   ASSERT_EQ(size, test.Size());
 
-  // Append unsorted
-  ASSERT_FALSE(test.Append(8, 12));
-  ASSERT_EQ(size, test.Size());
-
   // Append with the same seqno, newer time is rejected because that makes
   // GetProximalSeqnoBeforeTime queries worse (see later test)
-  ASSERT_FALSE(test.Append(10, 12));
+  ASSERT_FALSE(test.Append(10, 301));
   ASSERT_EQ(size, test.Size());
-  // older time will be ignored
-  ASSERT_FALSE(test.Append(10, 9));
+  ASSERT_EQ(test.TEST_GetLastEntry(), P({10, 300}));
+
+  // Same or new seqno with same or older time (as last successfully added) is
+  // accepted by replacing last entry (improves GetProximalSeqnoBeforeTime
+  // queries without blowing up size)
+  ASSERT_FALSE(test.Append(10, 299));
   ASSERT_EQ(size, test.Size());
+  ASSERT_EQ(test.TEST_GetLastEntry(), P({10, 299}));
 
-  // new seqno with old time will be ignored
-  ASSERT_FALSE(test.Append(12, 8));
+  ASSERT_FALSE(test.Append(11, 299));
   ASSERT_EQ(size, test.Size());
+  ASSERT_EQ(test.TEST_GetLastEntry(), P({11, 299}));
 
-  // new seqno with same time is accepted by replacing last entry
-  // (improves GetProximalSeqnoBeforeTime queries without blowing up size)
-  ASSERT_TRUE(test.Append(12, 11));
+  ASSERT_FALSE(test.Append(11, 250));
   ASSERT_EQ(size, test.Size());
+  ASSERT_EQ(test.TEST_GetLastEntry(), P({11, 250}));
+}
+
+TEST_F(SeqnoTimeTest, CapacityLimits) {
+  using P = SeqnoToTimeMapping::SeqnoTimePair;
+  SeqnoToTimeMapping test;
+
+  test.SetCapacity(3);
+  EXPECT_TRUE(test.Append(10, 300));
+  EXPECT_TRUE(test.Append(20, 400));
+  EXPECT_TRUE(test.Append(30, 500));
+  EXPECT_TRUE(test.Append(40, 600));
+  // Capacity 3 is small enough that the non-strict limit is
+  // equal to the strict limit.
+  EXPECT_EQ(3U, test.Size());
+  EXPECT_EQ(test.TEST_GetLastEntry(), P({40, 600}));
+
+  // Same for Capacity 2
+  test.SetCapacity(2);
+  EXPECT_EQ(2U, test.Size());
+  EXPECT_EQ(test.TEST_GetLastEntry(), P({40, 600}));
+
+  EXPECT_TRUE(test.Append(50, 700));
+  EXPECT_EQ(2U, test.Size());
+  EXPECT_EQ(test.TEST_GetLastEntry(), P({50, 700}));
+
+  // Capacity 1 is difficult to work with internally, so is
+  // coerced to 2.
+  test.SetCapacity(1);
+  EXPECT_EQ(2U, test.Size());
+  EXPECT_EQ(test.TEST_GetLastEntry(), P({50, 700}));
+
+  EXPECT_TRUE(test.Append(60, 800));
+  EXPECT_EQ(2U, test.Size());
+  EXPECT_EQ(test.TEST_GetLastEntry(), P({60, 800}));
+
+  // Capacity 0 means throw everything away
+  test.SetCapacity(0);
+  EXPECT_EQ(0U, test.Size());
+
+  EXPECT_FALSE(test.Append(70, 900));
+  EXPECT_EQ(0U, test.Size());
+
+  // Unlimited capacity
+  test.SetCapacity(UINT64_MAX);
+  for (unsigned i = 1; i <= 10101U; i++) {
+    EXPECT_TRUE(test.Append(i, 11U * i));
+  }
+  EXPECT_EQ(10101U, test.Size());
+}
+
+TEST_F(SeqnoTimeTest, TimeSpanLimits) {
+  SeqnoToTimeMapping test;
+
+  // Default: no limit
+  for (unsigned i = 1; i <= 63U; i++) {
+    EXPECT_TRUE(test.Append(1000 + i, uint64_t{1} << i));
+  }
+  // None dropped.
+  EXPECT_EQ(63U, test.Size());
+
+  test.Clear();
+
+  // Explicit no limit
+  test.SetMaxTimeSpan(UINT64_MAX);
+  for (unsigned i = 1; i <= 63U; i++) {
+    EXPECT_TRUE(test.Append(1000 + i, uint64_t{1} << i));
+  }
+  // None dropped.
+  EXPECT_EQ(63U, test.Size());
+
+  // We generally keep 2 entries as long as the configured max time span
+  // is non-zero
+  test.SetMaxTimeSpan(10);
+  EXPECT_EQ(2U, test.Size());
+
+  test.SetMaxTimeSpan(1);
+  EXPECT_EQ(2U, test.Size());
+
+  // But go down to 1 entry if the max time span is zero
+  test.SetMaxTimeSpan(0);
+  EXPECT_EQ(1U, test.Size());
+
+  EXPECT_TRUE(test.Append(2000, (uint64_t{1} << 63) + 42U));
+  EXPECT_EQ(1U, test.Size());
+
+  test.Clear();
+
+  // Test more typical behavior. Note that one entry at or beyond the max span
+  // is kept.
+  test.SetMaxTimeSpan(100);
+  EXPECT_TRUE(test.Append(1001, 123));
+  EXPECT_TRUE(test.Append(1002, 134));
+  EXPECT_TRUE(test.Append(1003, 150));
+  EXPECT_TRUE(test.Append(1004, 189));
+  EXPECT_TRUE(test.Append(1005, 220));
+  EXPECT_EQ(5U, test.Size());
+  EXPECT_TRUE(test.Append(1006, 233));
+  EXPECT_EQ(6U, test.Size());
+  EXPECT_TRUE(test.Append(1007, 234));
+  EXPECT_EQ(6U, test.Size());
+  EXPECT_TRUE(test.Append(1008, 235));
+  EXPECT_EQ(7U, test.Size());
+  EXPECT_TRUE(test.Append(1009, 300));
+  EXPECT_EQ(6U, test.Size());
+  EXPECT_TRUE(test.Append(1010, 350));
+  EXPECT_EQ(3U, test.Size());
+  EXPECT_TRUE(test.Append(1011, 470));
+  EXPECT_EQ(2U, test.Size());
 }
 
 TEST_F(SeqnoTimeTest, ProximalFunctions) {
-  SeqnoToTimeMapping test(/*max_time_duration=*/100, /*max_capacity=*/10);
+  SeqnoToTimeMapping test;
+  test.SetCapacity(10);
 
   EXPECT_EQ(test.GetProximalTimeBeforeSeqno(1), kUnknownTimeBeforeAll);
   EXPECT_EQ(test.GetProximalTimeBeforeSeqno(1000000000000U),
@@ -1081,6 +1194,7 @@ TEST_F(SeqnoTimeTest, ProximalFunctions) {
   // More samples
   EXPECT_TRUE(test.Append(20, 600));
   EXPECT_TRUE(test.Append(30, 700));
+  EXPECT_EQ(test.Size(), 3U);
 
   EXPECT_EQ(test.GetProximalTimeBeforeSeqno(10), kUnknownTimeBeforeAll);
   EXPECT_EQ(test.GetProximalTimeBeforeSeqno(11), 500U);
@@ -1140,8 +1254,9 @@ TEST_F(SeqnoTimeTest, ProximalFunctions) {
 
   // Burst of writes during a short time creates an opportunity
   // for better results from GetProximalSeqnoBeforeTime(), at the
-  // expense of GetProximalTimeBeforeSeqno().
-  EXPECT_TRUE(test.Append(50, 900));
+  // expense of GetProximalTimeBeforeSeqno(). False return indicates
+  // merge with previous entry.
+  EXPECT_FALSE(test.Append(50, 900));
 
   // These are subject to later revision depending on priorities
   EXPECT_EQ(test.GetProximalTimeBeforeSeqno(49), 700U);
@@ -1151,7 +1266,8 @@ TEST_F(SeqnoTimeTest, ProximalFunctions) {
 }
 
 TEST_F(SeqnoTimeTest, PrePopulate) {
-  SeqnoToTimeMapping test(/*max_time_duration=*/100, /*max_capacity=*/10);
+  SeqnoToTimeMapping test;
+  test.SetMaxTimeSpan(100).SetCapacity(10);
 
   EXPECT_EQ(test.Size(), 0U);
 
@@ -1194,14 +1310,102 @@ TEST_F(SeqnoTimeTest, PrePopulate) {
   }
 }
 
-TEST_F(SeqnoTimeTest, TruncateOldEntries) {
-  constexpr uint64_t kMaxTimeDuration = 42;
-  SeqnoToTimeMapping test(kMaxTimeDuration, /*max_capacity=*/10);
+TEST_F(SeqnoTimeTest, CopyFromSeqnoRange) {
+  SeqnoToTimeMapping test_from;
+  SeqnoToTimeMapping test_to;
+
+  // With zero to draw from
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 0, 1000000);
+  EXPECT_EQ(test_to.Size(), 0U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 100, 100);
+  EXPECT_EQ(test_to.Size(), 0U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, kMaxSequenceNumber, 0);
+  EXPECT_EQ(test_to.Size(), 0U);
+
+  // With one to draw from
+  EXPECT_TRUE(test_from.Append(10, 500));
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 0, 1000000);
+  EXPECT_EQ(test_to.Size(), 1U);
+
+  // Includes one entry before range
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 100, 100);
+  EXPECT_EQ(test_to.Size(), 1U);
+
+  // Includes one entry before range (even if somewhat nonsensical)
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, kMaxSequenceNumber, 0);
+  EXPECT_EQ(test_to.Size(), 1U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 0, 9);
+  EXPECT_EQ(test_to.Size(), 0U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 0, 10);
+  EXPECT_EQ(test_to.Size(), 1U);
+
+  // With more to draw from
+  EXPECT_TRUE(test_from.Append(20, 600));
+  EXPECT_TRUE(test_from.Append(30, 700));
+  EXPECT_TRUE(test_from.Append(40, 800));
+  EXPECT_TRUE(test_from.Append(50, 900));
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 0, 1000000);
+  EXPECT_EQ(test_to.Size(), 5U);
+
+  // Includes one entry before range
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 100, 100);
+  EXPECT_EQ(test_to.Size(), 1U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 19, 19);
+  EXPECT_EQ(test_to.Size(), 1U);
+
+  // Includes one entry before range (even if somewhat nonsensical)
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, kMaxSequenceNumber, 0);
+  EXPECT_EQ(test_to.Size(), 1U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 0, 9);
+  EXPECT_EQ(test_to.Size(), 0U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 0, 10);
+  EXPECT_EQ(test_to.Size(), 1U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 20, 20);
+  EXPECT_EQ(test_to.Size(), 2U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 20, 29);
+  EXPECT_EQ(test_to.Size(), 2U);
+
+  test_to.Clear();
+  test_to.CopyFromSeqnoRange(test_from, 20, 30);
+  EXPECT_EQ(test_to.Size(), 3U);
+}
+
+TEST_F(SeqnoTimeTest, EnforceWithNow) {
+  constexpr uint64_t kMaxTimeSpan = 420;
+  SeqnoToTimeMapping test;
+  test.SetMaxTimeSpan(kMaxTimeSpan).SetCapacity(10);
 
   EXPECT_EQ(test.Size(), 0U);
 
   // Safe on empty mapping
-  test.TruncateOldEntries(500);
+  test.Enforce(/*now=*/500);
 
   EXPECT_EQ(test.Size(), 0U);
 
@@ -1223,13 +1427,13 @@ TEST_F(SeqnoTimeTest, TruncateOldEntries) {
   // etc.
 
   // Must keep first entry
-  test.TruncateOldEntries(500 + kMaxTimeDuration);
+  test.Enforce(/*now=*/500 + kMaxTimeSpan);
   EXPECT_EQ(test.Size(), 5U);
-  test.TruncateOldEntries(599 + kMaxTimeDuration);
+  test.Enforce(/*now=*/599 + kMaxTimeSpan);
   EXPECT_EQ(test.Size(), 5U);
 
   // Purges first entry
-  test.TruncateOldEntries(600 + kMaxTimeDuration);
+  test.Enforce(/*now=*/600 + kMaxTimeSpan);
   EXPECT_EQ(test.Size(), 4U);
 
   EXPECT_EQ(test.GetProximalSeqnoBeforeTime(500), kUnknownSeqnoBeforeAll);
@@ -1239,20 +1443,20 @@ TEST_F(SeqnoTimeTest, TruncateOldEntries) {
   EXPECT_EQ(test.GetProximalSeqnoBeforeTime(700), 30U);
 
   // No effect
-  test.TruncateOldEntries(600 + kMaxTimeDuration);
+  test.Enforce(/*now=*/600 + kMaxTimeSpan);
   EXPECT_EQ(test.Size(), 4U);
-  test.TruncateOldEntries(699 + kMaxTimeDuration);
+  test.Enforce(/*now=*/699 + kMaxTimeSpan);
   EXPECT_EQ(test.Size(), 4U);
 
   // Purges next two
-  test.TruncateOldEntries(899 + kMaxTimeDuration);
+  test.Enforce(/*now=*/899 + kMaxTimeSpan);
   EXPECT_EQ(test.Size(), 2U);
 
   EXPECT_EQ(test.GetProximalSeqnoBeforeTime(799), kUnknownSeqnoBeforeAll);
   EXPECT_EQ(test.GetProximalSeqnoBeforeTime(899), 40U);
 
   // Always keep last entry, to have a non-trivial seqno bound
-  test.TruncateOldEntries(10000000);
+  test.Enforce(/*now=*/10000000);
   EXPECT_EQ(test.Size(), 1U);
 
   EXPECT_EQ(test.GetProximalSeqnoBeforeTime(10000000), 50U);
@@ -1262,67 +1466,114 @@ TEST_F(SeqnoTimeTest, Sort) {
   SeqnoToTimeMapping test;
 
   // single entry
-  test.Add(10, 11);
-  ASSERT_OK(test.Sort());
+  test.AddUnenforced(10, 11);
+  test.Enforce();
   ASSERT_EQ(test.Size(), 1);
 
-  // duplicate, should be removed by sort
-  test.Add(10, 11);
-  // same seqno, but older time, should be removed
-  test.Add(10, 9);
+  // duplicate is ignored
+  test.AddUnenforced(10, 11);
+  test.Enforce();
+  ASSERT_EQ(test.Size(), 1);
 
-  // unuseful ones, should be removed by sort
-  test.Add(11, 9);
-  test.Add(9, 8);
+  // add some revised mappings for that seqno
+  test.AddUnenforced(10, 10);
+  test.AddUnenforced(10, 12);
 
-  // Good ones
-  test.Add(1, 10);
-  test.Add(100, 100);
+  // We currently favor GetProximalSeqnoBeforeTime over
+  // GetProximalTimeBeforeSeqno by keeping the older time.
+  test.Enforce();
+  auto seqs = test.TEST_GetInternalMapping();
+  std::deque<SeqnoToTimeMapping::SeqnoTimePair> expected;
+  expected.emplace_back(10, 10);
+  ASSERT_EQ(expected, seqs);
 
-  ASSERT_OK(test.Sort());
+  // add an inconsistent / unuseful mapping
+  test.AddUnenforced(9, 11);
+  test.Enforce();
+  seqs = test.TEST_GetInternalMapping();
+  ASSERT_EQ(expected, seqs);
 
-  auto seqs = test.TEST_GetInternalMapping();
+  // And a mapping that is considered more useful (for
+  // GetProximalSeqnoBeforeTime) and thus replaces that one
+  test.AddUnenforced(11, 9);
+  test.Enforce();
+  seqs = test.TEST_GetInternalMapping();
+  expected.clear();
+  expected.emplace_back(11, 9);
+  ASSERT_EQ(expected, seqs);
 
-  std::deque<SeqnoToTimeMapping::SeqnoTimePair> expected;
-  expected.emplace_back(1, 10);
-  expected.emplace_back(10, 11);
+  // Add more good, non-mergable entries
+  test.AddUnenforced(1, 5);
+  test.AddUnenforced(100, 100);
+  test.Enforce();
+  seqs = test.TEST_GetInternalMapping();
+  expected.clear();
+  expected.emplace_back(1, 5);
+  expected.emplace_back(11, 9);
   expected.emplace_back(100, 100);
-
   ASSERT_EQ(expected, seqs);
 }
 
 TEST_F(SeqnoTimeTest, EncodeDecodeBasic) {
-  SeqnoToTimeMapping test(0, 1000);
+  constexpr uint32_t kOriginalSamples = 1000;
+  SeqnoToTimeMapping test;
+  test.SetCapacity(kOriginalSamples);
 
   std::string output;
-  test.Encode(output, 0, 1000, 100);
+  test.EncodeTo(output);
   ASSERT_TRUE(output.empty());
 
-  for (int i = 1; i <= 1000; i++) {
-    ASSERT_TRUE(test.Append(i, i * 10));
-  }
-  test.Encode(output, 0, 1000, 100);
+  ASSERT_OK(test.DecodeFrom(output));
+  ASSERT_EQ(test.Size(), 0U);
 
+  Random rnd(123);
+  for (uint32_t i = 1; i <= kOriginalSamples; i++) {
+    ASSERT_TRUE(test.Append(i, i * 10 + rnd.Uniform(10)));
+  }
+  output.clear();
+  test.EncodeTo(output);
   ASSERT_FALSE(output.empty());
 
   SeqnoToTimeMapping decoded;
-  ASSERT_OK(decoded.Add(output));
-  ASSERT_OK(decoded.Sort());
-  ASSERT_EQ(decoded.Size(), SeqnoToTimeMapping::kMaxSeqnoTimePairsPerSST);
-  ASSERT_EQ(test.Size(), 1000);
-
-  for (SequenceNumber seq = 0; seq <= 1000; seq++) {
-    // test has the more accurate time mapping, encode only pick
-    // kMaxSeqnoTimePairsPerSST number of entries, which is less accurate
-    uint64_t target_time = test.GetProximalTimeBeforeSeqno(seq);
-    ASSERT_GE(decoded.GetProximalTimeBeforeSeqno(seq),
-              target_time < 200 ? 0 : target_time - 200);
-    ASSERT_LE(decoded.GetProximalTimeBeforeSeqno(seq), target_time);
+  ASSERT_OK(decoded.DecodeFrom(output));
+  ASSERT_TRUE(decoded.TEST_IsEnforced());
+  ASSERT_EQ(test.Size(), decoded.Size());
+  ASSERT_EQ(test.TEST_GetInternalMapping(), decoded.TEST_GetInternalMapping());
+
+  // Encode a reduced set of mappings
+  constexpr uint32_t kReducedSize = 51U;
+  output.clear();
+  SeqnoToTimeMapping(test).SetCapacity(kReducedSize).EncodeTo(output);
+
+  decoded.Clear();
+  ASSERT_OK(decoded.DecodeFrom(output));
+  ASSERT_TRUE(decoded.TEST_IsEnforced());
+  ASSERT_EQ(decoded.Size(), kReducedSize);
+
+  for (uint64_t t = 1; t <= kOriginalSamples * 11; t += 1 + t / 100) {
+    SCOPED_TRACE("t=" + std::to_string(t));
+    // `test` has the more accurate time mapping, but the reduced set should
+    // nicely span and approximate the whole range
+    auto orig_s = test.GetProximalSeqnoBeforeTime(t);
+    auto approx_s = decoded.GetProximalSeqnoBeforeTime(t);
+    // The oldest entry should be preserved exactly
+    ASSERT_EQ(orig_s == kUnknownSeqnoBeforeAll,
+              approx_s == kUnknownSeqnoBeforeAll);
+    // The newest entry should be preserved exactly
+    ASSERT_EQ(orig_s == kOriginalSamples, approx_s == kOriginalSamples);
+
+    // Approximate seqno before time should err toward older seqno to avoid
+    // classifying data as old too early, but should be within a reasonable
+    // bound.
+    constexpr uint32_t kSeqnoFuzz = kOriginalSamples * 3 / 2 / kReducedSize;
+    EXPECT_GE(approx_s + kSeqnoFuzz, orig_s);
+    EXPECT_GE(orig_s, approx_s);
   }
 }
 
-TEST_F(SeqnoTimeTest, EncodeDecodePerferNewTime) {
-  SeqnoToTimeMapping test(0, 10);
+TEST_F(SeqnoTimeTest, EncodeDecodeMinimizeTimeGaps) {
+  SeqnoToTimeMapping test;
+  test.SetCapacity(10);
 
   test.Append(1, 10);
   test.Append(5, 17);
@@ -1330,45 +1581,66 @@ TEST_F(SeqnoTimeTest, EncodeDecodePerferNewTime) {
   test.Append(8, 30);
 
   std::string output;
-  test.Encode(output, 1, 10, 0, 3);
+  SeqnoToTimeMapping(test).SetCapacity(3).EncodeTo(output);
 
   SeqnoToTimeMapping decoded;
-  ASSERT_OK(decoded.Add(output));
-  ASSERT_OK(decoded.Sort());
+  ASSERT_OK(decoded.DecodeFrom(output));
+  ASSERT_TRUE(decoded.TEST_IsEnforced());
 
   ASSERT_EQ(decoded.Size(), 3);
 
   auto seqs = decoded.TEST_GetInternalMapping();
   std::deque<SeqnoToTimeMapping::SeqnoTimePair> expected;
   expected.emplace_back(1, 10);
-  expected.emplace_back(6, 25);
+  expected.emplace_back(5, 17);
   expected.emplace_back(8, 30);
   ASSERT_EQ(expected, seqs);
 
   // Add a few large time number
   test.Append(10, 100);
   test.Append(13, 200);
-  test.Append(16, 300);
+  test.Append(40, 250);
+  test.Append(70, 300);
 
   output.clear();
-  test.Encode(output, 1, 20, 0, 4);
+  SeqnoToTimeMapping(test).SetCapacity(4).EncodeTo(output);
   decoded.Clear();
-  ASSERT_OK(decoded.Add(output));
-  ASSERT_OK(decoded.Sort());
+  ASSERT_OK(decoded.DecodeFrom(output));
+  ASSERT_TRUE(decoded.TEST_IsEnforced());
   ASSERT_EQ(decoded.Size(), 4);
 
   expected.clear();
+  // Except for beginning and end, entries are removed that minimize the
+  // remaining time gaps, regardless of seqno gaps.
   expected.emplace_back(1, 10);
-  // entry #6, #8 are skipped as they are too close to #1.
-  // entry #100 is also within skip range, but if it's skipped, there not enough
-  // number to fill 4 entries, so select it.
   expected.emplace_back(10, 100);
   expected.emplace_back(13, 200);
-  expected.emplace_back(16, 300);
+  expected.emplace_back(70, 300);
   seqs = decoded.TEST_GetInternalMapping();
   ASSERT_EQ(expected, seqs);
 }
 
+TEST(PackValueAndSeqnoTest, Basic) {
+  std::string packed_value_buf;
+  Slice packed_value_slice =
+      PackValueAndWriteTime("foo", 30u, &packed_value_buf);
+  auto [unpacked_value, write_time] =
+      ParsePackedValueWithWriteTime(packed_value_slice);
+  ASSERT_EQ(unpacked_value, "foo");
+  ASSERT_EQ(write_time, 30u);
+  ASSERT_EQ(ParsePackedValueForValue(packed_value_slice), "foo");
+}
+
+TEST(PackValueAndWriteTimeTest, Basic) {
+  std::string packed_value_buf;
+  Slice packed_value_slice = PackValueAndSeqno("foo", 30u, &packed_value_buf);
+  auto [unpacked_value, write_time] =
+      ParsePackedValueWithSeqno(packed_value_slice);
+  ASSERT_EQ(unpacked_value, "foo");
+  ASSERT_EQ(write_time, 30u);
+  ASSERT_EQ(ParsePackedValueForValue(packed_value_slice), "foo");
+}
+
 }  // namespace ROCKSDB_NAMESPACE