@nxtedition/rocksdb 15.1.2 → 15.1.4

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader.h

@@ -208,10 +208,12 @@ class BlockBasedTable : public TableReader {
   size_t ApproximateMemoryUsage() const override;
 
   // convert SST file to a human readable form
-  Status DumpTable(WritableFile* out_file) override;
+  Status DumpTable(WritableFile* out_file,
+                   bool show_sequence_number_type = false) override;
 
   Status VerifyChecksum(const ReadOptions& readOptions,
-                        TableReaderCaller caller) override;
+                        TableReaderCaller caller,
+                        bool meta_blocks_only = false) override;
 
   void MarkObsolete(uint32_t uncache_aggressiveness) override;
 
@@ -429,7 +431,7 @@ class BlockBasedTable : public TableReader {
   //  3. We disallowed any io to be performed, that is, read_options ==
   //     kBlockCacheTier
   InternalIteratorBase<IndexValue>* NewIndexIterator(
-      const ReadOptions& read_options, bool need_upper_bound_check,
+      const ReadOptions& read_options, bool disable_prefix_seek,
       IndexBlockIter* input_iter, GetContext* get_context,
       BlockCacheLookupContext* lookup_context) const;
 
@@ -548,9 +550,11 @@ class BlockBasedTable : public TableReader {
 
   // Helper functions for DumpTable()
   Status DumpIndexBlock(std::ostream& out_stream);
-  Status DumpDataBlocks(std::ostream& out_stream);
+  Status DumpDataBlocks(std::ostream& out_stream,
+                        bool show_sequence_number_type = false);
   void DumpKeyValue(const Slice& key, const Slice& value,
-                    std::ostream& out_stream);
+                    std::ostream& out_stream,
+                    bool show_sequence_number_type = false);
 
   // Returns false if prefix_extractor exists and is compatible with that used
   // in building the table file, otherwise true.

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_test.cc

@@ -1274,13 +1274,13 @@ TEST_P(BlockBasedTableReaderMultiScanAsyncIOTest, MultiScanPrepare) {
                       ExtractUserKey(kv[33 * kEntriesPerBlock].first));
   iter->Prepare(&scan_options);
   iter->Seek(kv[32 * kEntriesPerBlock].first);
+  auto key = iter->key();
   ASSERT_OK(iter->status());
-  iter->Seek(kv[34 * kEntriesPerBlock].first);
-  ASSERT_OK(iter->status());
-  // Seek key could not going backward
   iter->Seek(kv[30 * kEntriesPerBlock].first);
-  ASSERT_EQ(iter->status(),
-            Status::InvalidArgument("Unexpected seek key moving backward"));
+  // When seek key goes backward, it is adjusted to the last seeked position.
+  // Assert the key read is same as before.
+  ASSERT_EQ(key, iter->key());
+  ASSERT_OK(iter->status());
 
   // Test prefetch limit reached.
   iter.reset(table->NewIterator(
@@ -1333,9 +1333,10 @@ TEST_P(BlockBasedTableReaderMultiScanAsyncIOTest, MultiScanPrepare) {
     std::cout << random_seed << std::endl;
     SCOPED_TRACE("Random seed " + std::to_string(random_seed));
 
-    int last_read_key_index = rnd.Uniform(100);
-    while (last_read_key_index < 100) {
-      iter->Seek(kv[last_read_key_index * kEntriesPerBlock].first);
+    // Search key always start from the start key of first prepared range.
+    int last_read_key_index = rnd.Uniform(100) + 5 * kEntriesPerBlock;
+    while (last_read_key_index < 100 * kEntriesPerBlock) {
+      iter->Seek(kv[last_read_key_index].first);
       EXPECT_OK(iter->status());
       // iterate for a few keys
       while (iter->Valid()) {

package/deps/rocksdb/rocksdb/table/block_based/filter_block.h

@@ -68,6 +68,18 @@ class FilterBlockBuilder {
   // For reporting stats on how many entries the builder considered unique
   virtual size_t EstimateEntriesAdded() = 0;
 
+  // Returns an estimate of the current filter size based on the builder's
+  // state. Implementations should cache the estimate and update it via
+  // UpdateFilterSizeEstimate() to avoid recalculating on every key add.
+  //
+  // Can be called at any time during table construction, even before calling
+  // Finish(). Used during table construction to determine when to cut files.
+  virtual size_t CurrentFilterSizeEstimate() = 0;
+
+  // Provides a hook for filter builder when a data block is finalized, such as
+  // to update cached filter size estimates.
+  virtual void OnDataBlockFinalized(uint64_t /* num_data_blocks */) {}
+
   // When using AddWithPrevKey, this must be called before Finish(). (May also
   // be called without AddWithPrevKey, but prev_key_without_ts must be
   // accurate regardless.)
@@ -110,6 +122,11 @@ class FilterBlockBuilder {
     return filter;
   }
 #endif  // NDEBUG
+
+ protected:
+  // Update cached filter size estimate. Subclasses should override to update
+  // estimates based on their internal state.
+  virtual void UpdateFilterSizeEstimate(uint64_t /* num_data_blocks */) {}
 };
 
 // A FilterBlockReader is used to parse filter from SST table.

package/deps/rocksdb/rocksdb/table/block_based/filter_policy.cc

@@ -17,7 +17,6 @@
 #include <limits>
 #include <memory>
 
-#include "cache/cache_entry_roles.h"
 #include "cache/cache_reservation_manager.h"
 #include "logging/logging.h"
 #include "port/lang.h"
@@ -29,8 +28,8 @@
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/filter_policy_internal.h"
 #include "table/block_based/full_filter_block.h"
+#include "util/atomic.h"
 #include "util/bloom_impl.h"
-#include "util/coding.h"
 #include "util/hash.h"
 #include "util/math.h"
 #include "util/ribbon_config.h"
@@ -61,7 +60,7 @@ Slice FinishAlwaysTrue(std::unique_ptr<const char[]>* /*buf*/) {
 
 // Base class for filter builders using the XXH3 preview hash,
 // also known as Hash64 or GetSliceHash64.
-class XXPH3FilterBitsBuilder : public BuiltinFilterBitsBuilder {
+class XXPH3FilterBitsBuilder : public FilterBitsBuilder {
  public:
   explicit XXPH3FilterBitsBuilder(
       std::atomic<int64_t>* aggregate_rounding_balance,
@@ -126,8 +125,11 @@ class XXPH3FilterBitsBuilder : public BuiltinFilterBitsBuilder {
     }
   }
 
+  // Returns an estimate of the number of entries added to the
+  // filter. This method is thread-safe and can be safely called
+  // from background threads during parallel compression.
   size_t EstimateEntriesAdded() override {
-    return hash_entries_info_.entries.size();
+    return hash_entries_info_.entries_count.LoadRelaxed();
   }
 
   Status MaybePostVerify(const Slice& filter_content) override;
@@ -147,6 +149,7 @@ class XXPH3FilterBitsBuilder : public BuiltinFilterBitsBuilder {
       hash_entries_info_.xor_checksum ^= hash;
     }
     hash_entries_info_.entries.push_back(hash);
+    hash_entries_info_.entries_count.FetchAddRelaxed(1);
     if (cache_res_mgr_ &&
         // Traditional rounding to whole bucket size
         ((hash_entries_info_.entries.size() %
@@ -314,6 +317,10 @@ class XXPH3FilterBitsBuilder : public BuiltinFilterBitsBuilder {
     // and has near-minimal peak memory use.
     std::deque<uint64_t> entries;
 
+    // Tracks the number of entries added for thread-safe
+    // size estimation.
+    RelaxedAtomic<size_t> entries_count{0};
+
     // If cache_res_mgr_ != nullptr,
     // it manages cache charge for buckets of hash entries in (new) Bloom
     // or Ribbon Filter construction.
@@ -332,6 +339,8 @@ class XXPH3FilterBitsBuilder : public BuiltinFilterBitsBuilder {
     void Swap(HashEntriesInfo* other) {
       assert(other != nullptr);
       std::swap(entries, other->entries);
+      entries_count.StoreRelaxed(
+          other->entries_count.ExchangeRelaxed(entries_count.LoadRelaxed()));
       std::swap(cache_res_bucket_handles, other->cache_res_bucket_handles);
       std::swap(xor_checksum, other->xor_checksum);
       std::swap(prev_alt_hash, other->prev_alt_hash);
@@ -339,6 +348,7 @@ class XXPH3FilterBitsBuilder : public BuiltinFilterBitsBuilder {
 
     void Reset() {
       entries.clear();
+      entries_count.StoreRelaxed(0);
       cache_res_bucket_handles.clear();
       xor_checksum = 0;
       prev_alt_hash = {};
@@ -1066,7 +1076,7 @@ class Standard128RibbonBitsReader : public BuiltinFilterBitsReader {
 
 using LegacyBloomImpl = LegacyLocalityBloomImpl</*ExtraRotates*/ false>;
 
-class LegacyBloomBitsBuilder : public BuiltinFilterBitsBuilder {
+class LegacyBloomBitsBuilder : public FilterBitsBuilder {
  public:
   explicit LegacyBloomBitsBuilder(const int bits_per_key, Logger* info_log);
 

package/deps/rocksdb/rocksdb/table/block_based/filter_policy_internal.h

@@ -90,6 +90,19 @@ class FilterBitsBuilder {
   // <= the specified number of bytes. Callers (including RocksDB) should
   // only use this result for optimizing performance and not as a guarantee.
   virtual size_t ApproximateNumEntries(size_t bytes) = 0;
+
+  // Calculate number of bytes needed for a new filter, including
+  // metadata. Passing the result to ApproximateNumEntries should
+  // (ideally, usually) return >= the num_entry passed in.
+  // When optimize_filters_for_memory is enabled, this function
+  // is not authoritative but represents a target size that should
+  // be close to the average size.
+  virtual size_t CalculateSpace(size_t num_entries) = 0;
+
+  // Returns an estimate of the FP rate of the returned filter if
+  // `num_entries` keys are added and the filter returned by Finish
+  // is `bytes` bytes.
+  virtual double EstimatedFpRate(size_t num_entries, size_t bytes) = 0;
 };
 
 // A class that checks if a key can be in filter
@@ -109,24 +122,6 @@ class FilterBitsReader {
   }
 };
 
-// Exposes any extra information needed for testing built-in
-// FilterBitsBuilders
-class BuiltinFilterBitsBuilder : public FilterBitsBuilder {
- public:
-  // Calculate number of bytes needed for a new filter, including
-  // metadata. Passing the result to ApproximateNumEntries should
-  // (ideally, usually) return >= the num_entry passed in.
-  // When optimize_filters_for_memory is enabled, this function
-  // is not authoritative but represents a target size that should
-  // be close to the average size.
-  virtual size_t CalculateSpace(size_t num_entries) = 0;
-
-  // Returns an estimate of the FP rate of the returned filter if
-  // `num_entries` keys are added and the filter returned by Finish
-  // is `bytes` bytes.
-  virtual double EstimatedFpRate(size_t num_entries, size_t bytes) = 0;
-};
-
 // Base class for RocksDB built-in filter reader with
 // extra useful functionalities for inernal.
 class BuiltinFilterBitsReader : public FilterBitsReader {

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block.cc

@@ -30,6 +30,35 @@ size_t FullFilterBlockBuilder::EstimateEntriesAdded() {
   return filter_bits_builder_->EstimateEntriesAdded();
 }
 
+void FullFilterBlockBuilder::OnDataBlockFinalized(uint64_t num_data_blocks) {
+  UpdateFilterSizeEstimate(num_data_blocks);
+}
+
+size_t FullFilterBlockBuilder::CurrentFilterSizeEstimate() {
+  return estimated_filter_size_;
+}
+
+void FullFilterBlockBuilder::UpdateFilterSizeEstimate(
+    uint64_t num_data_blocks) {
+  size_t entries_added = filter_bits_builder_->EstimateEntriesAdded();
+
+  if (entries_added == 0) {
+    estimated_filter_size_ = 0;
+    return;
+  }
+
+  size_t filter_size = filter_bits_builder_->CalculateSpace(entries_added);
+
+  // Reserve filter space for next data block ~2x the average.
+  size_t buffer_size = 0;
+  if (num_data_blocks > 0) {
+    buffer_size = (filter_size / num_data_blocks) * 2;
+    estimated_filter_size_ = filter_size + buffer_size;
+  } else {
+    estimated_filter_size_ = filter_size;
+  }
+}
+
 void FullFilterBlockBuilder::AddWithPrevKey(
     const Slice& key_without_ts, const Slice& /*prev_key_without_ts*/) {
   FullFilterBlockBuilder::Add(key_without_ts);

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block.h

@@ -57,6 +57,8 @@ class FullFilterBlockBuilder : public FilterBlockBuilder {
     return filter_bits_builder_->EstimateEntriesAdded() == 0;
   }
   size_t EstimateEntriesAdded() override;
+  size_t CurrentFilterSizeEstimate() override;
+  void OnDataBlockFinalized(uint64_t num_data_blocks) override;
   Status Finish(const BlockHandle& last_partition_block_handle, Slice* filter,
                 std::unique_ptr<const char[]>* filter_owner = nullptr) override;
   using FilterBlockBuilder::Finish;
@@ -73,6 +75,8 @@ class FullFilterBlockBuilder : public FilterBlockBuilder {
 
   std::unique_ptr<FilterBitsBuilder> filter_bits_builder_;
 
+  void UpdateFilterSizeEstimate(uint64_t num_data_blocks_written) override;
+
  private:
   // important: all of these might point to invalid addresses
   // at the time of destruction of this filter block. destructor
@@ -80,6 +84,8 @@ class FullFilterBlockBuilder : public FilterBlockBuilder {
   const SliceTransform* const prefix_extractor_;
   const bool whole_key_filtering_;
   std::unique_ptr<const char[]> filter_data_;
+
+  size_t estimated_filter_size_ = 0;
 };
 
 // A FilterBlockReader is used to parse filter from SST table.

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block_test.cc

@@ -52,6 +52,13 @@ class TestFilterBitsBuilder : public FilterBitsBuilder {
 
   size_t ApproximateNumEntries(size_t bytes) override { return bytes / 4; }
 
+  size_t CalculateSpace(size_t num_entries) override { return num_entries * 4; }
+
+  double EstimatedFpRate(size_t /* num_entries */,
+                         size_t /* bytes */) override {
+    return 0.0;
+  }
+
  private:
   std::vector<uint32_t> hash_entries_;
 };
@@ -229,6 +236,14 @@ class CountUniqueFilterBitsBuilderWrapper : public FilterBitsBuilder {
     return b_->ApproximateNumEntries(bytes);
   }
 
+  size_t CalculateSpace(size_t num_entries) override {
+    return b_->CalculateSpace(num_entries);
+  }
+
+  double EstimatedFpRate(size_t num_entries, size_t bytes) override {
+    return b_->EstimatedFpRate(num_entries, bytes);
+  }
+
   size_t CountUnique() { return uniq_.size(); }
 };
 

package/deps/rocksdb/rocksdb/table/block_based/index_builder.cc

@@ -117,20 +117,18 @@ Slice ShortenedIndexBuilder::FindShortInternalKeySuccessor(
   }
 }
 
-uint64_t ShortenedIndexBuilder::EstimateCurrentIndexSize() const {
+void ShortenedIndexBuilder::UpdateIndexSizeEstimate() {
   uint64_t current_size =
-      must_use_separator_with_seq_
+      must_use_separator_with_seq_.LoadRelaxed()
           ? index_block_builder_.CurrentSizeEstimate()
           : index_block_builder_without_seq_.CurrentSizeEstimate();
 
-  if (num_index_entries_ == 0) {
-    return current_size;
+  uint64_t final_estimate = current_size;
+  if (num_index_entries_ > 0) {
+    // Add buffer to generously account (in most cases) for the next index entry
+    final_estimate += (2 * (current_size / num_index_entries_));
   }
-
-  uint64_t avg_entry_size = current_size / num_index_entries_;
-
-  // Add buffer to generously account (in most cases) for the next index entry
-  return current_size + (2 * avg_entry_size);
+  estimated_index_size_.StoreRelaxed(final_estimate);
 }
 
 PartitionedIndexBuilder* PartitionedIndexBuilder::CreateIndexBuilder(
@@ -188,8 +186,8 @@ void PartitionedIndexBuilder::MakeNewSubIndexBuilder() {
   // must_use_separator_with_seq_ is true (internal-key mode) (set to false by
   // default on Creation) so that flush policy can point to
   // sub_index_builder_->index_block_builder_
-  if (must_use_separator_with_seq_) {
-    sub_index_builder_->must_use_separator_with_seq_ = true;
+  if (must_use_separator_with_seq_.LoadRelaxed()) {
+    sub_index_builder_->must_use_separator_with_seq_.StoreRelaxed(true);
     builder_to_monitor = &sub_index_builder_->index_block_builder_;
   } else {
     builder_to_monitor = &sub_index_builder_->index_block_builder_without_seq_;
@@ -237,6 +235,11 @@ void PartitionedIndexBuilder::MaybeFlush(const Slice& index_key,
                        index_key, EncodedBlockHandle(index_value).AsSlice()));
   if (do_flush) {
     assert(entries_.back().value.get() == sub_index_builder_);
+
+    // Update estimate of completed partitions when a partition is flushed
+    estimated_completed_partitions_size_.FetchAddRelaxed(
+        sub_index_builder_->CurrentIndexSizeEstimate());
+
     cut_filter_block = true;
     MakeNewSubIndexBuilder();
   }
@@ -254,9 +257,15 @@ void PartitionedIndexBuilder::FinishIndexEntry(const BlockHandle& block_handle,
                                        skip_delta_encoding);
   std::swap(entries_.back().key, entry->separator_with_seq);
 
-  if (!must_use_separator_with_seq_ && entry->must_use_separator_with_seq) {
+  // Update cached size estimate when data blocks are finalized for more
+  // accurate tail size estimation. This is needed for parallel compression
+  // which uses FinishIndexEntry() instead of AddIndexEntry().
+  UpdateIndexSizeEstimate();
+
+  if (!must_use_separator_with_seq_.LoadRelaxed() &&
+      entry->must_use_separator_with_seq) {
     // We need to apply !must_use_separator_with_seq to all sub-index builders
-    must_use_separator_with_seq_ = true;
+    must_use_separator_with_seq_.StoreRelaxed(true);
     flush_policy_->Retarget(sub_index_builder_->index_block_builder_);
   }
   // NOTE: not compatible with coupled partitioned filters so don't need to
@@ -278,10 +287,15 @@ Slice PartitionedIndexBuilder::AddIndexEntry(
       separator_scratch, skip_delta_encoding);
   entries_.back().key.assign(sep.data(), sep.size());
 
-  if (!must_use_separator_with_seq_ &&
-      sub_index_builder_->must_use_separator_with_seq_) {
+  // Update cached size estimate when data blocks are finalized for more
+  // accurate tail size estimation. This ensures the estimate reflects current
+  // state after each data block is added.
+  UpdateIndexSizeEstimate();
+
+  if (!must_use_separator_with_seq_.LoadRelaxed() &&
+      sub_index_builder_->must_use_separator_with_seq_.LoadRelaxed()) {
     // We need to apply !must_use_separator_with_seq to all sub-index builders
-    must_use_separator_with_seq_ = true;
+    must_use_separator_with_seq_.StoreRelaxed(true);
     flush_policy_->Retarget(sub_index_builder_->index_block_builder_);
   }
   if (UNLIKELY(first_key_in_next_block == nullptr)) {
@@ -315,7 +329,7 @@ Status PartitionedIndexBuilder::Finish(
     const Slice handle_delta_encoding_slice(handle_delta_encoding);
     index_block_builder_.Add(last_entry.key, handle_encoding.AsSlice(),
                              &handle_delta_encoding_slice);
-    if (!must_use_separator_with_seq_) {
+    if (!must_use_separator_with_seq_.LoadRelaxed()) {
       index_block_builder_without_seq_.Add(ExtractUserKey(last_entry.key),
                                            handle_encoding.AsSlice(),
                                            &handle_delta_encoding_slice);
@@ -324,7 +338,7 @@ Status PartitionedIndexBuilder::Finish(
   }
   // If there is no sub_index left, then return the 2nd level index.
   if (UNLIKELY(entries_.empty())) {
-    if (must_use_separator_with_seq_) {
+    if (must_use_separator_with_seq_.LoadRelaxed()) {
       index_blocks->index_block_contents = index_block_builder_.Finish();
     } else {
       index_blocks->index_block_contents =
@@ -338,7 +352,8 @@ Status PartitionedIndexBuilder::Finish(
     // expect more calls to Finish
     Entry& entry = entries_.front();
     // Apply the policy to all sub-indexes
-    entry.value->must_use_separator_with_seq_ = must_use_separator_with_seq_;
+    entry.value->must_use_separator_with_seq_.StoreRelaxed(
+        must_use_separator_with_seq_.LoadRelaxed());
     auto s = entry.value->Finish(index_blocks);
     index_size_ += index_blocks->index_block_contents.size();
     finishing_indexes_ = true;
@@ -347,4 +362,49 @@ Status PartitionedIndexBuilder::Finish(
 }
 
 size_t PartitionedIndexBuilder::NumPartitions() const { return partition_cnt_; }
+
+void PartitionedIndexBuilder::UpdateIndexSizeEstimate() {
+  uint64_t total_size = 0;
+
+  // Ignore last entry which is a placeholder for the partition being built
+  size_t completed_partitions = entries_.size() > 0 ? entries_.size() - 1 : 0;
+
+  // Use running estimate of completed partitions instead of IndexSize() which
+  // is only available after calling Finish().
+  uint64_t completed_partitions_size =
+      estimated_completed_partitions_size_.LoadRelaxed();
+  total_size += completed_partitions_size;
+
+  // Add current active partition size if it exists
+  uint64_t current_sub_index_size = 0;
+  if (sub_index_builder_ != nullptr) {
+    current_sub_index_size = sub_index_builder_->CurrentIndexSizeEstimate();
+    total_size += current_sub_index_size;
+  }
+
+  // Add buffer for top-level index and next partition
+  uint64_t buffer_size = 0;
+  if (completed_partitions > 0) {
+    // Calculate top-level index size. Each top-level entry consists of:
+    // separator key (~20-50 bytes) + BlockHandle (~20 bytes) + overhead
+    // Estimate ~70 bytes per top-level entry as a reasonable average
+    auto estimated_top_level_size = completed_partitions * 70;
+    total_size += completed_partitions * 70;
+
+    // Buffer for next partition + next top-level entry
+    uint64_t avg_partition_size =
+        completed_partitions_size / completed_partitions;
+    uint64_t avg_top_level_entry_size =
+        estimated_top_level_size / completed_partitions;
+
+    buffer_size = 2 * (avg_partition_size + avg_top_level_entry_size);
+    total_size += buffer_size;
+  } else if (sub_index_builder_ != nullptr) {
+    // For the first partition, estimate using the current partition's state
+    buffer_size = 2 * current_sub_index_size;
+    total_size += buffer_size;
+  }
+  estimated_index_size_.StoreRelaxed(total_size);
+}
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/index_builder.h

@@ -158,12 +158,15 @@ class IndexBuilder {
   // Get the size for index block. Must be called after ::Finish.
   virtual size_t IndexSize() const = 0;
 
-  // Get an estimate for current total index size based on current builder
-  // state.
+  // Returns an estimate of the current index size based on the builder's state.
+  // Implementations should cache the estimate and update it via
+  // UpdateIndexSizeEstimate() to avoid recalculating on every key add,
+  // which is critical for performance in the compaction hot path.
   //
-  // Called during compaction to estimate final index size for file cutting
-  // decisions.
-  virtual uint64_t EstimateCurrentIndexSize() const = 0;
+  // This function is only called by the SST "emit thread" but must be
+  // thread safe with concurrent calls to UpdateIndexSizeEstimate() from another
+  // thread (such as during parallel compression).
+  virtual uint64_t CurrentIndexSizeEstimate() const = 0;
 
   virtual bool separator_is_key_plus_seq() { return true; }
 
@@ -187,6 +190,13 @@ class IndexBuilder {
                      l_user_key, r_user_key) == 0;
   }
 
+  // Updates the cached index size estimate used by CurrentIndexSizeEstimate().
+  //
+  // This function can be called from the SST "write thread" (via
+  // FinishIndexEntry()), and needs to be thread safe with
+  // CurrentIndexSizeEstimate() called from the SST "emit thread".
+  virtual void UpdateIndexSizeEstimate() {}
+
   const InternalKeyComparator* comparator_;
   // Size of user-defined timestamp in bytes.
   size_t ts_sz_;
@@ -234,7 +244,7 @@ class ShortenedIndexBuilder : public IndexBuilder {
         include_first_key_(include_first_key),
         shortening_mode_(shortening_mode) {
     // Making the default true will disable the feature for old versions
-    must_use_separator_with_seq_ = (format_version <= 2);
+    must_use_separator_with_seq_.StoreRelaxed(format_version <= 2);
   }
 
   void OnKeyAdded(const Slice& key,
@@ -257,10 +267,10 @@ class ShortenedIndexBuilder : public IndexBuilder {
       } else {
         separator_with_seq = last_key_in_current_block;
       }
-      if (!must_use_separator_with_seq_ &&
+      if (!must_use_separator_with_seq_.LoadRelaxed() &&
           ShouldUseKeyPlusSeqAsSeparator(last_key_in_current_block,
                                          *first_key_in_next_block)) {
-        must_use_separator_with_seq_ = true;
+        must_use_separator_with_seq_.StoreRelaxed(true);
       }
     } else {
       if (shortening_mode_ == BlockBasedTableOptions::IndexShorteningMode::
@@ -333,6 +343,7 @@ class ShortenedIndexBuilder : public IndexBuilder {
     }
 
     ++num_index_entries_;
+    UpdateIndexSizeEstimate();
   }
 
   Slice AddIndexEntry(const Slice& last_key_in_current_block,
@@ -347,7 +358,8 @@ class ShortenedIndexBuilder : public IndexBuilder {
     Slice first_internal_key = GetFirstInternalKey(&first_internal_key_buf);
 
     AddIndexEntryImpl(separator_with_seq, first_internal_key, block_handle,
-                      must_use_separator_with_seq_, skip_delta_encoding);
+                      must_use_separator_with_seq_.LoadRelaxed(),
+                      skip_delta_encoding);
     current_block_first_internal_key_.clear();
     return separator_with_seq;
   }
@@ -396,7 +408,7 @@ class ShortenedIndexBuilder : public IndexBuilder {
                             &entry->separator_with_seq);
     Slice first_internal_key = GetFirstInternalKey(&entry->first_internal_key);
     entry->SaveFrom(separator, first_internal_key,
-                    must_use_separator_with_seq_);
+                    must_use_separator_with_seq_.LoadRelaxed());
     current_block_first_internal_key_.clear();
   }
 
@@ -413,7 +425,7 @@ class ShortenedIndexBuilder : public IndexBuilder {
   using IndexBuilder::Finish;
   Status Finish(IndexBlocks* index_blocks,
                 const BlockHandle& /*last_partition_block_handle*/) override {
-    if (must_use_separator_with_seq_) {
+    if (must_use_separator_with_seq_.LoadRelaxed()) {
       index_blocks->index_block_contents = index_block_builder_.Finish();
     } else {
       index_blocks->index_block_contents =
@@ -425,10 +437,15 @@ class ShortenedIndexBuilder : public IndexBuilder {
 
   size_t IndexSize() const override { return index_size_; }
 
-  uint64_t EstimateCurrentIndexSize() const override;
+  uint64_t CurrentIndexSizeEstimate() const override {
+    return estimated_index_size_.LoadRelaxed();
+  }
+
+  // Updates the cached size estimate to minimize CPU usage in hot path
+  void UpdateIndexSizeEstimate() override;
 
   bool separator_is_key_plus_seq() override {
-    return must_use_separator_with_seq_;
+    return must_use_separator_with_seq_.LoadRelaxed();
   }
 
   // Changes *key to a short string >= *key.
@@ -452,12 +469,14 @@ class ShortenedIndexBuilder : public IndexBuilder {
   // before).
   BlockBuilder index_block_builder_without_seq_;
   const bool use_value_delta_encoding_;
-  bool must_use_separator_with_seq_;
+  RelaxedAtomic<bool> must_use_separator_with_seq_;
   const bool include_first_key_;
   BlockBasedTableOptions::IndexShorteningMode shortening_mode_;
   BlockHandle last_encoded_handle_ = BlockHandle::NullBlockHandle();
   std::string current_block_first_internal_key_;
   uint64_t num_index_entries_ = 0;
+  // Cache for index size estimate to avoid recalculating in hot path
+  RelaxedAtomic<uint64_t> estimated_index_size_{0};
 };
 
 // HashIndexBuilder contains a binary-searchable primary index and the
@@ -579,8 +598,7 @@ class HashIndexBuilder : public IndexBuilder {
            prefix_meta_block_.size();
   }
 
-  // TODO: implement
-  uint64_t EstimateCurrentIndexSize() const override { return 0; }
+  uint64_t CurrentIndexSizeEstimate() const override { return 0; }
 
   bool separator_is_key_plus_seq() override {
     return primary_index_builder_.separator_is_key_plus_seq();
@@ -658,8 +676,11 @@ class PartitionedIndexBuilder : public IndexBuilder {
   size_t TopLevelIndexSize(uint64_t) const { return top_level_index_size_; }
   size_t NumPartitions() const;
 
-  // TODO: implement
-  uint64_t EstimateCurrentIndexSize() const override { return 0; }
+  // Returns a cached estimate of the current index size. This
+  // estimate is updated when data blocks are added.
+  uint64_t CurrentIndexSizeEstimate() const override {
+    return estimated_index_size_.LoadRelaxed();
+  }
 
   inline bool ShouldCutFilterBlock() {
     // Current policy is to align the partitions of index and filters
@@ -679,8 +700,10 @@ class PartitionedIndexBuilder : public IndexBuilder {
   // cutting the next partition
   void RequestPartitionCut();
 
+  // This function must be thread safe because multiple worker threads might
+  // update the index builder state during parallel compression.
   bool separator_is_key_plus_seq() override {
-    return must_use_separator_with_seq_;
+    return must_use_separator_with_seq_.LoadRelaxed();
   }
 
   bool get_use_value_delta_encoding() const {
@@ -694,6 +717,7 @@ class PartitionedIndexBuilder : public IndexBuilder {
   size_t partition_cnt_ = 0;
 
   void MakeNewSubIndexBuilder();
+  void UpdateIndexSizeEstimate() override;
 
   struct Entry {
     std::string key;
@@ -713,7 +737,7 @@ class PartitionedIndexBuilder : public IndexBuilder {
   // true if Finish is called once but not complete yet.
   bool finishing_indexes_ = false;
   const BlockBasedTableOptions& table_opt_;
-  bool must_use_separator_with_seq_;
+  RelaxedAtomic<bool> must_use_separator_with_seq_;
   bool use_value_delta_encoding_;
   // true if an external entity (such as filter partition builder) request
   // cutting the next partition
@@ -721,5 +745,9 @@ class PartitionedIndexBuilder : public IndexBuilder {
   // true if it should cut the next filter partition block
   bool cut_filter_block = false;
   BlockHandle last_encoded_handle_;
+  // Cached estimate of current index size, updated when data blocks are added
+  RelaxedAtomic<uint64_t> estimated_index_size_{0};
+  // Running estimate of completed partitions total size
+  RelaxedAtomic<uint64_t> estimated_completed_partitions_size_{0};
 };
 }  // namespace ROCKSDB_NAMESPACE