@nxtedition/rocksdb 8.2.0 → 8.2.2

package/deps/rocksdb/rocksdb/env/env_posix.cc

@@ -213,13 +213,14 @@ class PosixEnv : public CompositeEnv {
   const char* Name() const override { return kClassName(); }
   const char* NickName() const override { return kDefaultName(); }
 
-  ~PosixEnv() override {
-    if (this == Env::Default()) {
-      for (const auto tid : threads_to_join_) {
+  struct JoinThreadsOnExit {
+    explicit JoinThreadsOnExit(PosixEnv& _deflt) : deflt(_deflt) {}
+    ~JoinThreadsOnExit() {
+      for (const auto tid : deflt.threads_to_join_) {
         pthread_join(tid, nullptr);
       }
       for (int pool_id = 0; pool_id < Env::Priority::TOTAL; ++pool_id) {
-        thread_pools_[pool_id].JoinAllThreads();
+        deflt.thread_pools_[pool_id].JoinAllThreads();
       }
       // Do not delete the thread_status_updater_ in order to avoid the
       // free after use when Env::Default() is destructed while some other
@@ -227,7 +228,8 @@ class PosixEnv : public CompositeEnv {
       // PosixEnv instances use the same thread_status_updater_, so never
       // explicitly delete it.
     }
-  }
+    PosixEnv& deflt;
+  };
 
   void SetFD_CLOEXEC(int fd, const EnvOptions* options) {
     if ((options == nullptr || options->set_fd_cloexec) && fd > 0) {
@@ -501,9 +503,11 @@ Env* Env::Default() {
   ThreadLocalPtr::InitSingletons();
   CompressionContextCache::InitSingleton();
   INIT_SYNC_POINT_SINGLETONS();
-  // ~PosixEnv must be called on exit
-  //**TODO: Can we make this a STATIC_AVOID_DESTRUCTION?
-  static PosixEnv default_env;
+  // Avoid problems with accessing most members of Env::Default() during
+  // static destruction.
+  STATIC_AVOID_DESTRUCTION(PosixEnv, default_env);
+  // This destructor must be called on exit
+  static PosixEnv::JoinThreadsOnExit thread_joiner(default_env);
   return &default_env;
 }
 

package/deps/rocksdb/rocksdb/env/env_test.cc

@@ -3134,6 +3134,20 @@ TEST_F(EnvTest, SemiStructuredUniqueIdGenTest) {
   t.Run();
 }
 
+TEST_F(EnvTest, SemiStructuredUniqueIdGenTestSmaller) {
+  // For small generated types, will cycle through all the possible values.
+  SemiStructuredUniqueIdGen gen;
+  std::vector<bool> hit(256);
+  for (int i = 0; i < 256; ++i) {
+    auto val = gen.GenerateNext<uint8_t>();
+    ASSERT_FALSE(hit[val]);
+    hit[val] = true;
+  }
+  for (int i = 0; i < 256; ++i) {
+    ASSERT_TRUE(hit[i]);
+  }
+}
+
 TEST_F(EnvTest, FailureToCreateLockFile) {
   auto env = Env::Default();
   auto fs = env->GetFileSystem();
@@ -3537,6 +3551,23 @@ TEST_F(TestAsyncRead, ReadAsync) {
     }
   }
 }
+
+struct StaticDestructionTester {
+  bool activated = false;
+  ~StaticDestructionTester() {
+    if (activated && !kMustFreeHeapAllocations) {
+      // Make sure we can still call some things on default Env.
+      std::string hostname;
+      Env::Default()->GetHostNameString(&hostname);
+    }
+  }
+} static_destruction_tester;
+
+TEST(EnvTestMisc, StaticDestruction) {
+  // Check for any crashes during static destruction.
+  static_destruction_tester.activated = true;
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/env/mock_env.cc

@@ -21,7 +21,7 @@
 #include "util/cast_util.h"
 #include "util/hash.h"
 #include "util/random.h"
-#include "util/rate_limiter.h"
+#include "util/rate_limiter_impl.h"
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/env/unique_id_gen.h

@@ -14,6 +14,7 @@
 
 #include <atomic>
 #include <cstdint>
+#include <type_traits>
 
 #include "rocksdb/rocksdb_namespace.h"
 
@@ -61,6 +62,19 @@ class SemiStructuredUniqueIdGen {
   // to the next (thread safe).
   void GenerateNext(uint64_t* upper, uint64_t* lower);
 
+  // For generating smaller values. Will cycle through all the possibilities
+  // before repeating.
+  template <typename T>
+  T GenerateNext() {
+    static_assert(sizeof(T) <= sizeof(uint64_t));
+    static_assert(std::is_integral_v<T>);
+    uint64_t ignore, val;
+    GenerateNext(&ignore, &val);
+    return static_cast<T>(val);
+  }
+
+  uint64_t GetBaseUpper() const { return base_upper_; }
+
  private:
   uint64_t base_upper_;
   uint64_t base_lower_;

package/deps/rocksdb/rocksdb/file/file_prefetch_buffer.cc

@@ -18,7 +18,7 @@
 #include "port/port.h"
 #include "test_util/sync_point.h"
 #include "util/random.h"
-#include "util/rate_limiter.h"
+#include "util/rate_limiter_impl.h"
 
 namespace ROCKSDB_NAMESPACE {
 

package/deps/rocksdb/rocksdb/file/file_prefetch_buffer.h

@@ -15,7 +15,7 @@
 #include <string>
 
 #include "file/readahead_file_info.h"
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "port/port.h"
 #include "rocksdb/env.h"
 #include "rocksdb/file_system.h"
@@ -180,6 +180,8 @@ class FilePrefetchBuffer {
     RecordInHistogram(stats_, PREFETCHED_BYTES_DISCARDED, bytes_discarded);
   }
 
+  bool Enabled() const { return enable_; }
+
   // Load data into the buffer from a file.
   // reader                : the file reader.
   // offset                : the file offset to start reading from.
@@ -232,6 +234,8 @@ class FilePrefetchBuffer {
   // tracked if track_min_offset = true.
   size_t min_offset_read() const { return min_offset_read_; }
 
+  size_t GetPrefetchOffset() const { return bufs_[curr_].offset_; }
+
   // Called in case of implicit auto prefetching.
   void UpdateReadPattern(const uint64_t& offset, const size_t& len,
                          bool decrease_readaheadsize) {

package/deps/rocksdb/rocksdb/file/file_util.cc

@@ -185,9 +185,9 @@ IOStatus GenerateOneFileChecksum(
     if (!io_s.ok()) {
       return io_s;
     }
-    reader.reset(new RandomAccessFileReader(std::move(r_file), file_path,
-                                            nullptr /*Env*/, io_tracer, nullptr,
-                                            0, nullptr, rate_limiter));
+    reader.reset(new RandomAccessFileReader(
+        std::move(r_file), file_path, nullptr /*Env*/, io_tracer, nullptr,
+        Histograms::HISTOGRAM_ENUM_MAX, nullptr, rate_limiter));
   }
 
   // Found that 256 KB readahead size provides the best performance, based on

package/deps/rocksdb/rocksdb/file/file_util.h

@@ -80,6 +80,8 @@ inline IOStatus PrepareIOFromReadOptions(const ReadOptions& ro,
   }
 
   opts.rate_limiter_priority = ro.rate_limiter_priority;
+  opts.io_activity = ro.io_activity;
+
   return IOStatus::OK();
 }
 

package/deps/rocksdb/rocksdb/file/prefetch_test.cc

@@ -220,6 +220,7 @@ TEST_P(PrefetchTest, Basic) {
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
       num_keys++;
     }
+    (void)num_keys;
   }
 
   // Make sure prefetch is called only if file system support prefetch.
@@ -235,6 +236,93 @@ TEST_P(PrefetchTest, Basic) {
   Close();
 }
 
+TEST_P(PrefetchTest, BlockBasedTableTailPrefetch) {
+  const bool support_prefetch =
+      std::get<0>(GetParam()) &&
+      test::IsPrefetchSupported(env_->GetFileSystem(), dbname_);
+  // Second param is if directIO is enabled or not
+  const bool use_direct_io = std::get<1>(GetParam());
+  const bool use_file_prefetch_buffer = !support_prefetch || use_direct_io;
+
+  std::shared_ptr<MockFS> fs =
+      std::make_shared<MockFS>(env_->GetFileSystem(), support_prefetch);
+  std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
+
+  Options options;
+  SetGenericOptions(env.get(), use_direct_io, options);
+  options.statistics = CreateDBStatistics();
+
+  BlockBasedTableOptions bbto;
+  bbto.index_type = BlockBasedTableOptions::kTwoLevelIndexSearch;
+  bbto.partition_filters = true;
+  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
+  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+
+  Status s = TryReopen(options);
+  if (use_direct_io && (s.IsNotSupported() || s.IsInvalidArgument())) {
+    // If direct IO is not supported, skip the test
+    ROCKSDB_GTEST_BYPASS("Direct IO is not supported");
+    return;
+  } else {
+    ASSERT_OK(s);
+  }
+
+  ASSERT_OK(Put("k1", "v1"));
+
+  HistogramData pre_flush_file_read;
+  options.statistics->histogramData(FILE_READ_FLUSH_MICROS,
+                                    &pre_flush_file_read);
+  ASSERT_OK(Flush());
+  HistogramData post_flush_file_read;
+  options.statistics->histogramData(FILE_READ_FLUSH_MICROS,
+                                    &post_flush_file_read);
+  if (use_file_prefetch_buffer) {
+    // `PartitionedFilterBlockReader/PartitionIndexReader::CacheDependencies()`
+    // should read from the prefetched tail in file prefetch buffer instead of
+    // initiating extra SST reads. Therefore `BlockBasedTable::PrefetchTail()`
+    // should be the only SST read in table verification during flush.
+    ASSERT_EQ(post_flush_file_read.count - pre_flush_file_read.count, 1);
+  } else {
+    // Without the prefetched tail in file prefetch buffer,
+    // `PartitionedFilterBlockReader/PartitionIndexReader::CacheDependencies()`
+    // will initiate extra SST reads
+    ASSERT_GT(post_flush_file_read.count - pre_flush_file_read.count, 1);
+  }
+  ASSERT_OK(Put("k1", "v2"));
+  ASSERT_OK(Put("k2", "v2"));
+  ASSERT_OK(Flush());
+
+  CompactRangeOptions cro;
+  HistogramData pre_compaction_file_read;
+  options.statistics->histogramData(FILE_READ_COMPACTION_MICROS,
+                                    &pre_compaction_file_read);
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  HistogramData post_compaction_file_read;
+  options.statistics->histogramData(FILE_READ_COMPACTION_MICROS,
+                                    &post_compaction_file_read);
+  if (use_file_prefetch_buffer) {
+    // `PartitionedFilterBlockReader/PartitionIndexReader::CacheDependencies()`
+    // should read from the prefetched tail in file prefetch buffer instead of
+    // initiating extra SST reads.
+    //
+    // Therefore the 3 reads are
+    // (1) `ProcessKeyValueCompaction()` of input file 1
+    // (2) `ProcessKeyValueCompaction()` of input file 2
+    // (3) `BlockBasedTable::PrefetchTail()` of output file during table
+    // verification in compaction
+    ASSERT_EQ(post_compaction_file_read.count - pre_compaction_file_read.count,
+              3);
+  } else {
+    // Without the prefetched tail in file prefetch buffer,
+    // `PartitionedFilterBlockReader/PartitionIndexReader::CacheDependencies()`
+    // as well as reading other parts of the tail (e.g, footer, table
+    // properties..) will initiate extra SST reads
+    ASSERT_GT(post_compaction_file_read.count - pre_compaction_file_read.count,
+              3);
+  }
+  Close();
+}
+
 // This test verifies BlockBasedTableOptions.max_auto_readahead_size is
 // configured dynamically.
 TEST_P(PrefetchTest, ConfigureAutoMaxReadaheadSize) {
@@ -1803,6 +1891,7 @@ TEST_P(PrefetchTest, MultipleSeekWithPosixFS) {
     }
     MoveFilesToLevel(2);
   }
+  (void)total_keys;
 
   int num_keys_first_batch = 0;
   int num_keys_second_batch = 0;

package/deps/rocksdb/rocksdb/file/random_access_file_reader.cc

@@ -19,10 +19,15 @@
 #include "table/format.h"
 #include "test_util/sync_point.h"
 #include "util/random.h"
-#include "util/rate_limiter.h"
+#include "util/rate_limiter_impl.h"
 
 namespace ROCKSDB_NAMESPACE {
-
+const std::array<Histograms, std::size_t(Env::IOActivity::kUnknown)>
+    kReadHistograms{{
+        FILE_READ_FLUSH_MICROS,
+        FILE_READ_COMPACTION_MICROS,
+        FILE_READ_DB_OPEN_MICROS,
+    }};
 inline void RecordIOStats(Statistics* stats, Temperature file_temperature,
                           bool is_last_level, size_t size) {
   IOSTATS_ADD(bytes_read, size);
@@ -94,6 +99,9 @@ IOStatus RandomAccessFileReader::Read(
   uint64_t elapsed = 0;
   {
     StopWatch sw(clock_, stats_, hist_type_,
+                 (opts.io_activity != Env::IOActivity::kUnknown)
+                     ? kReadHistograms[(std::size_t)(opts.io_activity)]
+                     : Histograms::HISTOGRAM_ENUM_MAX,
                  (stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/,
                  true /*delay_enabled*/);
     auto prev_perf_level = GetPerfLevel();
@@ -288,6 +296,9 @@ IOStatus RandomAccessFileReader::MultiRead(
   uint64_t elapsed = 0;
   {
     StopWatch sw(clock_, stats_, hist_type_,
+                 (opts.io_activity != Env::IOActivity::kUnknown)
+                     ? kReadHistograms[(std::size_t)(opts.io_activity)]
+                     : Histograms::HISTOGRAM_ENUM_MAX,
                  (stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/,
                  true /*delay_enabled*/);
     auto prev_perf_level = GetPerfLevel();
@@ -425,7 +436,7 @@ IOStatus RandomAccessFileReader::MultiRead(
 }
 
 IOStatus RandomAccessFileReader::PrepareIOOptions(const ReadOptions& ro,
-                                                  IOOptions& opts) {
+                                                  IOOptions& opts) const {
   if (clock_ != nullptr) {
     return PrepareIOFromReadOptions(ro, clock_, opts);
   } else {
@@ -476,13 +487,17 @@ IOStatus RandomAccessFileReader::ReadAsync(
 
     assert(read_async_info->buf_.CurrentSize() == 0);
 
-    StopWatch sw(clock_, nullptr /*stats*/, 0 /*hist_type*/, &elapsed,
-                 true /*overwrite*/, true /*delay_enabled*/);
+    StopWatch sw(clock_, nullptr /*stats*/,
+                 Histograms::HISTOGRAM_ENUM_MAX /*hist_type*/,
+                 Histograms::HISTOGRAM_ENUM_MAX, &elapsed, true /*overwrite*/,
+                 true /*delay_enabled*/);
     s = file_->ReadAsync(aligned_req, opts, read_async_callback,
                          read_async_info, io_handle, del_fn, nullptr /*dbg*/);
   } else {
-    StopWatch sw(clock_, nullptr /*stats*/, 0 /*hist_type*/, &elapsed,
-                 true /*overwrite*/, true /*delay_enabled*/);
+    StopWatch sw(clock_, nullptr /*stats*/,
+                 Histograms::HISTOGRAM_ENUM_MAX /*hist_type*/,
+                 Histograms::HISTOGRAM_ENUM_MAX, &elapsed, true /*overwrite*/,
+                 true /*delay_enabled*/);
     s = file_->ReadAsync(req, opts, read_async_callback, read_async_info,
                          io_handle, del_fn, nullptr /*dbg*/);
   }

package/deps/rocksdb/rocksdb/file/random_access_file_reader.h

@@ -122,7 +122,8 @@ class RandomAccessFileReader {
       std::unique_ptr<FSRandomAccessFile>&& raf, const std::string& _file_name,
       SystemClock* clock = nullptr,
       const std::shared_ptr<IOTracer>& io_tracer = nullptr,
-      Statistics* stats = nullptr, uint32_t hist_type = 0,
+      Statistics* stats = nullptr,
+      uint32_t hist_type = Histograms::HISTOGRAM_ENUM_MAX,
       HistogramImpl* file_read_hist = nullptr,
       RateLimiter* rate_limiter = nullptr,
       const std::vector<std::shared_ptr<EventListener>>& listeners = {},
@@ -197,7 +198,7 @@ class RandomAccessFileReader {
 
   bool use_direct_io() const { return file_->use_direct_io(); }
 
-  IOStatus PrepareIOOptions(const ReadOptions& ro, IOOptions& opts);
+  IOStatus PrepareIOOptions(const ReadOptions& ro, IOOptions& opts) const;
 
   IOStatus ReadAsync(FSReadRequest& req, const IOOptions& opts,
                      std::function<void(const FSReadRequest&, void*)> cb,

package/deps/rocksdb/rocksdb/file/readahead_raf.cc

@@ -15,7 +15,7 @@
 #include "file/read_write_util.h"
 #include "rocksdb/file_system.h"
 #include "util/aligned_buffer.h"
-#include "util/rate_limiter.h"
+#include "util/rate_limiter_impl.h"
 
 namespace ROCKSDB_NAMESPACE {
 namespace {

package/deps/rocksdb/rocksdb/file/sequence_file_reader.cc

@@ -19,7 +19,7 @@
 #include "test_util/sync_point.h"
 #include "util/aligned_buffer.h"
 #include "util/random.h"
-#include "util/rate_limiter.h"
+#include "util/rate_limiter_impl.h"
 
 namespace ROCKSDB_NAMESPACE {
 IOStatus SequentialFileReader::Create(

package/deps/rocksdb/rocksdb/file/writable_file_writer.cc

@@ -21,7 +21,7 @@
 #include "test_util/sync_point.h"
 #include "util/crc32c.h"
 #include "util/random.h"
-#include "util/rate_limiter.h"
+#include "util/rate_limiter_impl.h"
 
 namespace ROCKSDB_NAMESPACE {
 IOStatus WritableFileWriter::Create(const std::shared_ptr<FileSystem>& fs,

package/deps/rocksdb/rocksdb/include/rocksdb/advanced_cache.h

@@ -404,6 +404,9 @@ class Cache {
 
   MemoryAllocator* memory_allocator() const { return memory_allocator_.get(); }
 
+  // See ShardedCacheOptions::hash_seed
+  virtual uint32_t GetHashSeed() const { return 0; }
+
   // EXPERIMENTAL
   // The following APIs are experimental and might change in the future.