@nxtedition/rocksdb 8.2.8 → 9.0.1

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

@@ -70,24 +70,28 @@ class Block_kMetaIndex : public Block {
 struct BlockCreateContext : public Cache::CreateContext {
   BlockCreateContext() {}
   BlockCreateContext(const BlockBasedTableOptions* _table_options,
-                     Statistics* _statistics, bool _using_zstd,
-                     uint8_t _protection_bytes_per_key,
+                     const ImmutableOptions* _ioptions, Statistics* _statistics,
+                     bool _using_zstd, uint8_t _protection_bytes_per_key,
                      const Comparator* _raw_ucmp,
                      bool _index_value_is_full = false,
                      bool _index_has_first_key = false)
       : table_options(_table_options),
+        ioptions(_ioptions),
         statistics(_statistics),
+        raw_ucmp(_raw_ucmp),
         using_zstd(_using_zstd),
         protection_bytes_per_key(_protection_bytes_per_key),
-        raw_ucmp(_raw_ucmp),
         index_value_is_full(_index_value_is_full),
         index_has_first_key(_index_has_first_key) {}
 
   const BlockBasedTableOptions* table_options = nullptr;
+  const ImmutableOptions* ioptions = nullptr;
   Statistics* statistics = nullptr;
+  const Comparator* raw_ucmp = nullptr;
+  const UncompressionDict* dict = nullptr;
+  uint32_t format_version;
   bool using_zstd = false;
   uint8_t protection_bytes_per_key = 0;
-  const Comparator* raw_ucmp = nullptr;
   bool index_value_is_full;
   bool index_has_first_key;
 
@@ -95,9 +99,24 @@ struct BlockCreateContext : public Cache::CreateContext {
   template <typename TBlocklike>
   inline void Create(std::unique_ptr<TBlocklike>* parsed_out,
                      size_t* charge_out, const Slice& data,
-                     MemoryAllocator* alloc) {
-    Create(parsed_out,
-           BlockContents(AllocateAndCopyBlock(data, alloc), data.size()));
+                     CompressionType type, MemoryAllocator* alloc) {
+    BlockContents uncompressed_block_contents;
+    if (type != CompressionType::kNoCompression) {
+      assert(dict != nullptr);
+      UncompressionContext context(type);
+      UncompressionInfo info(context, *dict, type);
+      Status s = UncompressBlockData(
+          info, data.data(), data.size(), &uncompressed_block_contents,
+          table_options->format_version, *ioptions, alloc);
+      if (!s.ok()) {
+        parsed_out->reset();
+        return;
+      }
+    } else {
+      uncompressed_block_contents =
+          BlockContents(AllocateAndCopyBlock(data, alloc), data.size());
+    }
+    Create(parsed_out, std::move(uncompressed_block_contents));
     *charge_out = parsed_out->get()->ApproximateMemoryUsage();
   }
 

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

@@ -15,15 +15,40 @@ namespace ROCKSDB_NAMESPACE {
 void BlockPrefetcher::PrefetchIfNeeded(
     const BlockBasedTable::Rep* rep, const BlockHandle& handle,
     const size_t readahead_size, bool is_for_compaction,
-    const bool no_sequential_checking,
-    const Env::IOPriority rate_limiter_priority) {
-  // num_file_reads is used  by FilePrefetchBuffer only when
-  // implicit_auto_readahead is set.
+    const bool no_sequential_checking, const ReadOptions& read_options,
+    const std::function<void(uint64_t, size_t, size_t&)>& readaheadsize_cb) {
+  const size_t len = BlockBasedTable::BlockSizeWithTrailer(handle);
+  const size_t offset = handle.offset();
   if (is_for_compaction) {
+    if (!rep->file->use_direct_io() && compaction_readahead_size_ > 0) {
+      // If FS supports prefetching (readahead_limit_ will be non zero in that
+      // case) and current block exists in prefetch buffer then return.
+      if (offset + len <= readahead_limit_) {
+        return;
+      }
+      IOOptions opts;
+      Status s = rep->file->PrepareIOOptions(read_options, opts);
+      if (!s.ok()) {
+        return;
+      }
+      s = rep->file->Prefetch(opts, offset, len + compaction_readahead_size_);
+      if (s.ok()) {
+        readahead_limit_ = offset + len + compaction_readahead_size_;
+        return;
+      } else if (!s.IsNotSupported()) {
+        return;
+      }
+    }
+    // If FS prefetch is not supported, fall back to use internal prefetch
+    // buffer.
+    //
+    // num_file_reads is used  by FilePrefetchBuffer only when
+    // implicit_auto_readahead is set.
     rep->CreateFilePrefetchBufferIfNotExists(
         compaction_readahead_size_, compaction_readahead_size_,
         &prefetch_buffer_, /*implicit_auto_readahead=*/false,
-        /*num_file_reads=*/0, /*num_file_reads_for_auto_readahead=*/0);
+        /*num_file_reads=*/0, /*num_file_reads_for_auto_readahead=*/0,
+        /*upper_bound_offset=*/0, /*readaheadsize_cb=*/nullptr);
     return;
   }
 
@@ -32,7 +57,9 @@ void BlockPrefetcher::PrefetchIfNeeded(
     rep->CreateFilePrefetchBufferIfNotExists(
         readahead_size, readahead_size, &prefetch_buffer_,
         /*implicit_auto_readahead=*/false, /*num_file_reads=*/0,
-        /*num_file_reads_for_auto_readahead=*/0);
+        /*num_file_reads_for_auto_readahead=*/0, upper_bound_offset_,
+        readaheadsize_cb,
+        /*usage=*/FilePrefetchBufferUsage::kUserScanPrefetch);
     return;
   }
 
@@ -56,13 +83,12 @@ void BlockPrefetcher::PrefetchIfNeeded(
         initial_auto_readahead_size_, max_auto_readahead_size,
         &prefetch_buffer_, /*implicit_auto_readahead=*/true,
         /*num_file_reads=*/0,
-        rep->table_options.num_file_reads_for_auto_readahead);
+        rep->table_options.num_file_reads_for_auto_readahead,
+        upper_bound_offset_, readaheadsize_cb,
+        /*usage=*/FilePrefetchBufferUsage::kUserScanPrefetch);
     return;
   }
 
-  size_t len = BlockBasedTable::BlockSizeWithTrailer(handle);
-  size_t offset = handle.offset();
-
   // If FS supports prefetching (readahead_limit_ will be non zero in that case)
   // and current block exists in prefetch buffer then return.
   if (offset + len <= readahead_limit_) {
@@ -89,7 +115,9 @@ void BlockPrefetcher::PrefetchIfNeeded(
     rep->CreateFilePrefetchBufferIfNotExists(
         initial_auto_readahead_size_, max_auto_readahead_size,
         &prefetch_buffer_, /*implicit_auto_readahead=*/true, num_file_reads_,
-        rep->table_options.num_file_reads_for_auto_readahead);
+        rep->table_options.num_file_reads_for_auto_readahead,
+        upper_bound_offset_, readaheadsize_cb,
+        /*usage=*/FilePrefetchBufferUsage::kUserScanPrefetch);
     return;
   }
 
@@ -98,17 +126,21 @@ void BlockPrefetcher::PrefetchIfNeeded(
   }
 
   // If prefetch is not supported, fall back to use internal prefetch buffer.
-  // Discarding other return status of Prefetch calls intentionally, as
-  // we can fallback to reading from disk if Prefetch fails.
-  Status s = rep->file->Prefetch(
-      handle.offset(),
-      BlockBasedTable::BlockSizeWithTrailer(handle) + readahead_size_,
-      rate_limiter_priority);
+  IOOptions opts;
+  Status s = rep->file->PrepareIOOptions(read_options, opts);
+  if (!s.ok()) {
+    return;
+  }
+  s = rep->file->Prefetch(
+      opts, handle.offset(),
+      BlockBasedTable::BlockSizeWithTrailer(handle) + readahead_size_);
   if (s.IsNotSupported()) {
     rep->CreateFilePrefetchBufferIfNotExists(
         initial_auto_readahead_size_, max_auto_readahead_size,
         &prefetch_buffer_, /*implicit_auto_readahead=*/true, num_file_reads_,
-        rep->table_options.num_file_reads_for_auto_readahead);
+        rep->table_options.num_file_reads_for_auto_readahead,
+        upper_bound_offset_, readaheadsize_cb,
+        /*usage=*/FilePrefetchBufferUsage::kUserScanPrefetch);
     return;
   }
 

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

@@ -18,11 +18,11 @@ class BlockPrefetcher {
         readahead_size_(initial_auto_readahead_size),
         initial_auto_readahead_size_(initial_auto_readahead_size) {}
 
-  void PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
-                        const BlockHandle& handle, size_t readahead_size,
-                        bool is_for_compaction,
-                        const bool no_sequential_checking,
-                        Env::IOPriority rate_limiter_priority);
+  void PrefetchIfNeeded(
+      const BlockBasedTable::Rep* rep, const BlockHandle& handle,
+      size_t readahead_size, bool is_for_compaction,
+      const bool no_sequential_checking, const ReadOptions& read_options,
+      const std::function<void(uint64_t, size_t, size_t&)>& readaheadsize_cb);
   FilePrefetchBuffer* prefetch_buffer() { return prefetch_buffer_.get(); }
 
   void UpdateReadPattern(const uint64_t& offset, const size_t& len) {
@@ -53,20 +53,32 @@ class BlockPrefetcher {
                              &initial_auto_readahead_size_);
   }
 
+  void SetUpperBoundOffset(uint64_t upper_bound_offset) {
+    upper_bound_offset_ = upper_bound_offset;
+    if (prefetch_buffer() != nullptr) {
+      // Upper bound can be changed on reseek. So update that in
+      // FilePrefetchBuffer.
+      prefetch_buffer()->ResetUpperBoundOffset(upper_bound_offset);
+    }
+  }
+
  private:
   // Readahead size used in compaction, its value is used only if
   // lookup_context_.caller = kCompaction.
   size_t compaction_readahead_size_;
 
-  // readahead_size_ is used if underlying FS supports prefetching.
+  // readahead_size_ is used in non-compaction read if underlying FS supports
+  // prefetching.
   size_t readahead_size_;
   size_t readahead_limit_ = 0;
-  // initial_auto_readahead_size_ is used if RocksDB uses internal prefetch
-  // buffer.
+  // initial_auto_readahead_size_ is used in non-compaction read if RocksDB uses
+  // internal prefetch buffer.
   uint64_t initial_auto_readahead_size_;
   uint64_t num_file_reads_ = 0;
   uint64_t prev_offset_ = 0;
   size_t prev_len_ = 0;
   std::unique_ptr<FilePrefetchBuffer> prefetch_buffer_;
+
+  uint64_t upper_bound_offset_ = 0;
 };
 }  // namespace ROCKSDB_NAMESPACE