@nxtedition/rocksdb 8.1.6 → 8.1.8

package/deps/rocksdb/rocksdb/file/delete_scheduler.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "file/delete_scheduler.h"
 
@@ -408,4 +407,3 @@ void DeleteScheduler::MaybeCreateBackgroundThread() {
 
 }  // namespace ROCKSDB_NAMESPACE
 
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/file/delete_scheduler.h

@@ -5,7 +5,6 @@
 
 #pragma once
 
-#ifndef ROCKSDB_LITE
 
 #include <map>
 #include <queue>
@@ -146,4 +145,3 @@ class DeleteScheduler {
 
 }  // namespace ROCKSDB_NAMESPACE
 
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/file/delete_scheduler_test.cc

@@ -18,7 +18,6 @@
 #include "test_util/testharness.h"
 #include "util/string_util.h"
 
-#ifndef ROCKSDB_LITE
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -716,9 +715,3 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-#else
-int main(int /*argc*/, char** /*argv*/) {
-  printf("DeleteScheduler is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-#endif  // ROCKSDB_LITE

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

@@ -569,10 +569,11 @@ Status FilePrefetchBuffer::PrefetchAsyncInternal(
     bufs_[second].offset_ = rounddown_start2;
     assert(roundup_len2 >= chunk_len2);
     uint64_t read_len2 = static_cast<size_t>(roundup_len2 - chunk_len2);
-    Status tmp_s = ReadAsync(opts, reader, read_len2, rounddown_start2, second);
-    if (!tmp_s.ok()) {
+    s = ReadAsync(opts, reader, read_len2, rounddown_start2, second);
+    if (!s.ok()) {
       DestroyAndClearIOHandle(second);
       bufs_[second].buffer_.Clear();
+      return s;
     }
   }
 

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

@@ -116,7 +116,6 @@ IOStatus CreateFile(FileSystem* fs, const std::string& destination,
 Status DeleteDBFile(const ImmutableDBOptions* db_options,
                     const std::string& fname, const std::string& dir_to_sync,
                     const bool force_bg, const bool force_fg) {
-#ifndef ROCKSDB_LITE
   SstFileManagerImpl* sfm =
       static_cast<SstFileManagerImpl*>(db_options->sst_file_manager.get());
   if (sfm && !force_fg) {
@@ -124,14 +123,6 @@ Status DeleteDBFile(const ImmutableDBOptions* db_options,
   } else {
     return db_options->env->DeleteFile(fname);
   }
-#else
-  (void)dir_to_sync;
-  (void)force_bg;
-  (void)force_fg;
-  // SstFileManager is not supported in ROCKSDB_LITE
-  // Delete file immediately
-  return db_options->env->DeleteFile(fname);
-#endif
 }
 
 // requested_checksum_func_name brings the function name of the checksum

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

@@ -207,7 +207,6 @@ TEST_P(PrefetchTest, Basic) {
   Close();
 }
 
-#ifndef ROCKSDB_LITE
 // This test verifies BlockBasedTableOptions.max_auto_readahead_size is
 // configured dynamically.
 TEST_P(PrefetchTest, ConfigureAutoMaxReadaheadSize) {
@@ -559,7 +558,6 @@ TEST_P(PrefetchTest, ConfigureNumFilesReadsForReadaheadSize) {
   SyncPoint::GetInstance()->ClearAllCallBacks();
   Close();
 }
-#endif  // !ROCKSDB_LITE
 
 // This test verifies the basic functionality of implicit autoreadahead:
 // - Enable implicit autoreadahead and prefetch only if sequential blocks are
@@ -949,7 +947,6 @@ TEST_P(PrefetchTest, PrefetchWhenReseekwithCache) {
   Close();
 }
 
-#ifndef ROCKSDB_LITE
 // This test verifies the functionality of ReadOptions.adaptive_readahead.
 TEST_P(PrefetchTest, DBIterLevelReadAhead) {
   const int kNumKeys = 1000;
@@ -1158,7 +1155,6 @@ TEST_P(PrefetchTest, DBIterLevelReadAheadWithAsyncIO) {
   }
   Close();
 }
-#endif  //! ROCKSDB_LITE
 
 class PrefetchTest1 : public DBTestBase,
                       public ::testing::WithParamInterface<bool> {
@@ -1189,7 +1185,6 @@ class PrefetchTest1 : public DBTestBase,
 
 INSTANTIATE_TEST_CASE_P(PrefetchTest1, PrefetchTest1, ::testing::Bool());
 
-#ifndef ROCKSDB_LITE
 // This test verifies the functionality of ReadOptions.adaptive_readahead when
 // reads are not sequential.
 TEST_P(PrefetchTest1, NonSequentialReadsWithAdaptiveReadahead) {
@@ -1272,7 +1267,6 @@ TEST_P(PrefetchTest1, NonSequentialReadsWithAdaptiveReadahead) {
   }
   Close();
 }
-#endif  //! ROCKSDB_LITE
 
 // This test verifies the functionality of adaptive_readaheadsize with cache and
 // if block is found in cache, decrease the readahead_size if
@@ -1513,7 +1507,6 @@ TEST_P(PrefetchTest1, SeekParallelizationTest) {
 extern "C" bool RocksDbIOUringEnable() { return true; }
 
 namespace {
-#ifndef ROCKSDB_LITE
 #ifdef GFLAGS
 const int kMaxArgCount = 100;
 const size_t kArgBufferSize = 100000;
@@ -1538,7 +1531,6 @@ void RunIOTracerParserTool(std::string trace_file) {
   ASSERT_EQ(0, ROCKSDB_NAMESPACE::io_tracer_parser(argc, argv));
 }
 #endif  // GFLAGS
-#endif  // ROCKSDB_LITE
 }  // namespace
 
 // Tests the default implementation of ReadAsync API with PosixFileSystem during
@@ -1617,27 +1609,23 @@ TEST_P(PrefetchTest, ReadAsyncWithPosixFS) {
       num_keys++;
     }
 
-    ASSERT_EQ(num_keys, total_keys);
-    ASSERT_GT(buff_prefetch_count, 0);
-
-    // Check stats to make sure async prefetch is done.
-    {
+    if (read_async_called) {
+      ASSERT_EQ(num_keys, total_keys);
+      ASSERT_GT(buff_prefetch_count, 0);
+      // Check stats to make sure async prefetch is done.
       HistogramData async_read_bytes;
       options.statistics->histogramData(ASYNC_READ_BYTES, &async_read_bytes);
       HistogramData prefetched_bytes_discarded;
       options.statistics->histogramData(PREFETCHED_BYTES_DISCARDED,
                                         &prefetched_bytes_discarded);
-
+      ASSERT_GT(async_read_bytes.count, 0);
+      ASSERT_GT(prefetched_bytes_discarded.count, 0);
+      ASSERT_EQ(get_perf_context()->number_async_seek, 0);
+    } else {
       // Not all platforms support iouring. In that case, ReadAsync in posix
       // won't submit async requests.
-      if (read_async_called) {
-        ASSERT_GT(async_read_bytes.count, 0);
-      } else {
-        ASSERT_EQ(async_read_bytes.count, 0);
-      }
-      ASSERT_GT(prefetched_bytes_discarded.count, 0);
+      ASSERT_EQ(iter->status(), Status::NotSupported());
     }
-    ASSERT_EQ(get_perf_context()->number_async_seek, 0);
   }
 
   SyncPoint::GetInstance()->DisableProcessing();
@@ -1748,22 +1736,19 @@ TEST_P(PrefetchTest, MultipleSeekWithPosixFS) {
         num_keys++;
         iter->Next();
       }
-      ASSERT_OK(iter->status());
-      ASSERT_EQ(num_keys, num_keys_first_batch);
-      // Check stats to make sure async prefetch is done.
-      {
+
+      if (read_async_called) {
+        ASSERT_OK(iter->status());
+        ASSERT_EQ(num_keys, num_keys_first_batch);
+        // Check stats to make sure async prefetch is done.
         HistogramData async_read_bytes;
         options.statistics->histogramData(ASYNC_READ_BYTES, &async_read_bytes);
-
+        ASSERT_GT(async_read_bytes.count, 0);
+        ASSERT_GT(get_perf_context()->number_async_seek, 0);
+      } else {
         // Not all platforms support iouring. In that case, ReadAsync in posix
         // won't submit async requests.
-        if (read_async_called) {
-          ASSERT_GT(async_read_bytes.count, 0);
-          ASSERT_GT(get_perf_context()->number_async_seek, 0);
-        } else {
-          ASSERT_EQ(async_read_bytes.count, 0);
-          ASSERT_EQ(get_perf_context()->number_async_seek, 0);
-        }
+        ASSERT_EQ(iter->status(), Status::NotSupported());
       }
     }
 
@@ -1779,29 +1764,26 @@ TEST_P(PrefetchTest, MultipleSeekWithPosixFS) {
         num_keys++;
         iter->Next();
       }
-      ASSERT_OK(iter->status());
-      ASSERT_EQ(num_keys, num_keys_second_batch);
 
-      ASSERT_GT(buff_prefetch_count, 0);
+      if (read_async_called) {
+        ASSERT_OK(iter->status());
+        ASSERT_EQ(num_keys, num_keys_second_batch);
 
-      // Check stats to make sure async prefetch is done.
-      {
+        ASSERT_GT(buff_prefetch_count, 0);
+
+        // Check stats to make sure async prefetch is done.
         HistogramData async_read_bytes;
         options.statistics->histogramData(ASYNC_READ_BYTES, &async_read_bytes);
         HistogramData prefetched_bytes_discarded;
         options.statistics->histogramData(PREFETCHED_BYTES_DISCARDED,
                                           &prefetched_bytes_discarded);
-
+        ASSERT_GT(async_read_bytes.count, 0);
+        ASSERT_GT(get_perf_context()->number_async_seek, 0);
+        ASSERT_GT(prefetched_bytes_discarded.count, 0);
+      } else {
         // Not all platforms support iouring. In that case, ReadAsync in posix
         // won't submit async requests.
-        if (read_async_called) {
-          ASSERT_GT(async_read_bytes.count, 0);
-          ASSERT_GT(get_perf_context()->number_async_seek, 0);
-        } else {
-          ASSERT_EQ(async_read_bytes.count, 0);
-          ASSERT_EQ(get_perf_context()->number_async_seek, 0);
-        }
-        ASSERT_GT(prefetched_bytes_discarded.count, 0);
+        ASSERT_EQ(iter->status(), Status::NotSupported());
       }
     }
   }
@@ -1880,56 +1862,56 @@ TEST_P(PrefetchTest, SeekParallelizationTestWithPosix) {
     // Each block contains around 4 keys.
     auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ro));
     iter->Seek(BuildKey(0));  // Prefetch data because of seek parallelization.
-    ASSERT_TRUE(iter->Valid());
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
+    if (std::get<1>(GetParam()) && !read_async_called) {
+      ASSERT_EQ(iter->status(), Status::NotSupported());
+    } else {
+      ASSERT_TRUE(iter->Valid());
+      iter->Next();
+      ASSERT_TRUE(iter->Valid());
+      iter->Next();
+      ASSERT_TRUE(iter->Valid());
+      iter->Next();
+      ASSERT_TRUE(iter->Valid());
 
-    // New data block. Since num_file_reads in FilePrefetch after this read is
-    // 2, it won't go for prefetching.
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
+      // New data block. Since num_file_reads in FilePrefetch after this read is
+      // 2, it won't go for prefetching.
+      iter->Next();
+      ASSERT_TRUE(iter->Valid());
+      iter->Next();
+      ASSERT_TRUE(iter->Valid());
+      iter->Next();
+      ASSERT_TRUE(iter->Valid());
+      iter->Next();
+      ASSERT_TRUE(iter->Valid());
 
-    // Prefetch data.
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
+      // Prefetch data.
+      iter->Next();
 
-    // Check stats to make sure async prefetch is done.
-    {
-      HistogramData async_read_bytes;
-      options.statistics->histogramData(ASYNC_READ_BYTES, &async_read_bytes);
-      // Not all platforms support iouring. In that case, ReadAsync in posix
-      // won't submit async requests.
       if (read_async_called) {
-        ASSERT_GT(async_read_bytes.count, 0);
-        ASSERT_GT(get_perf_context()->number_async_seek, 0);
-        if (std::get<1>(GetParam())) {
-          ASSERT_EQ(buff_prefetch_count, 1);
-        } else {
-          ASSERT_EQ(buff_prefetch_count, 2);
+        ASSERT_TRUE(iter->Valid());
+        // Check stats to make sure async prefetch is done.
+        {
+          HistogramData async_read_bytes;
+          options.statistics->histogramData(ASYNC_READ_BYTES,
+                                            &async_read_bytes);
+          ASSERT_GT(async_read_bytes.count, 0);
+          ASSERT_GT(get_perf_context()->number_async_seek, 0);
+          if (std::get<1>(GetParam())) {
+            ASSERT_EQ(buff_prefetch_count, 1);
+          } else {
+            ASSERT_EQ(buff_prefetch_count, 2);
+          }
         }
       } else {
-        ASSERT_EQ(async_read_bytes.count, 0);
-        ASSERT_EQ(get_perf_context()->number_async_seek, 0);
-        ASSERT_EQ(buff_prefetch_count, 1);
+        // Not all platforms support iouring. In that case, ReadAsync in posix
+        // won't submit async requests.
+        ASSERT_EQ(iter->status(), Status::NotSupported());
       }
     }
-
-    buff_prefetch_count = 0;
   }
   Close();
 }
 
-#ifndef ROCKSDB_LITE
 #ifdef GFLAGS
 // This test verifies io_tracing with PosixFileSystem during prefetching.
 TEST_P(PrefetchTest, TraceReadAsyncWithCallbackWrapper) {
@@ -2018,20 +2000,17 @@ TEST_P(PrefetchTest, TraceReadAsyncWithCallbackWrapper) {
     ASSERT_OK(db_->EndIOTrace());
     ASSERT_OK(env_->FileExists(trace_file_path));
 
-    ASSERT_EQ(num_keys, total_keys);
-    ASSERT_GT(buff_prefetch_count, 0);
-
-    // Check stats to make sure async prefetch is done.
-    {
+    if (read_async_called) {
+      ASSERT_EQ(num_keys, total_keys);
+      ASSERT_GT(buff_prefetch_count, 0);
+      // Check stats to make sure async prefetch is done.
       HistogramData async_read_bytes;
       options.statistics->histogramData(ASYNC_READ_BYTES, &async_read_bytes);
+      ASSERT_GT(async_read_bytes.count, 0);
+    } else {
       // Not all platforms support iouring. In that case, ReadAsync in posix
       // won't submit async requests.
-      if (read_async_called) {
-        ASSERT_GT(async_read_bytes.count, 0);
-      } else {
-        ASSERT_EQ(async_read_bytes.count, 0);
-      }
+      ASSERT_EQ(iter->status(), Status::NotSupported());
     }
 
     // Check the file to see if ReadAsync is logged.
@@ -2111,8 +2090,13 @@ TEST_F(FilePrefetchBufferTest, SeekWithBlockCacheHit) {
   // Simulate a seek of 4096 bytes at offset 0. Due to the readahead settings,
   // it will do two reads of 4096+8192 and 8192
   Status s = fpb.PrefetchAsync(IOOptions(), r.get(), 0, 4096, &result);
-  // Platforms that don't have IO uring may not support async IO
-  ASSERT_TRUE(s.IsTryAgain() || s.IsNotSupported());
+
+  // Platforms that don't have IO uring may not support async IO.
+  if (s.IsNotSupported()) {
+    return;
+  }
+
+  ASSERT_TRUE(s.IsTryAgain());
   // Simulate a block cache hit
   fpb.UpdateReadPattern(0, 4096, false);
   // Now read some data that straddles the two prefetch buffers - offset 8192 to
@@ -2146,9 +2130,13 @@ TEST_F(FilePrefetchBufferTest, NoSyncWithAsyncIO) {
   // Simulate a seek of 4000 bytes at offset 3000. Due to the readahead
   // settings, it will do two reads of 4000+4096 and 4096
   Status s = fpb.PrefetchAsync(IOOptions(), r.get(), 3000, 4000, &async_result);
+
   // Platforms that don't have IO uring may not support async IO
-  ASSERT_TRUE(s.IsTryAgain() || s.IsNotSupported());
+  if (s.IsNotSupported()) {
+    return;
+  }
 
+  ASSERT_TRUE(s.IsTryAgain());
   ASSERT_TRUE(fpb.TryReadFromCacheAsync(IOOptions(), r.get(), /*offset=*/3000,
                                         /*length=*/4000, &async_result, &s,
                                         Env::IOPriority::IO_LOW));
@@ -2167,7 +2155,6 @@ TEST_F(FilePrefetchBufferTest, NoSyncWithAsyncIO) {
   ASSERT_EQ(result, async_result);
 }
 
-#endif  // ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

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

@@ -99,7 +99,6 @@ IOStatus RandomAccessFileReader::Read(
     auto prev_perf_level = GetPerfLevel();
     IOSTATS_TIMER_GUARD(read_nanos);
     if (use_direct_io()) {
-#ifndef ROCKSDB_LITE
       size_t alignment = file_->GetRequiredBufferAlignment();
       size_t aligned_offset =
           TruncateToPageBoundary(alignment, static_cast<size_t>(offset));
@@ -165,7 +164,6 @@ IOStatus RandomAccessFileReader::Read(
         }
       }
       *result = Slice(scratch, res_len);
-#endif  // !ROCKSDB_LITE
     } else {
       size_t pos = 0;
       const char* res_scratch = nullptr;
@@ -187,12 +185,10 @@ IOStatus RandomAccessFileReader::Read(
         }
         Slice tmp_result;
 
-#ifndef ROCKSDB_LITE
         FileOperationInfo::StartTimePoint start_ts;
         if (ShouldNotifyListeners()) {
           start_ts = FileOperationInfo::StartNow();
         }
-#endif
 
         {
           IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, clock_);
@@ -204,7 +200,6 @@ IOStatus RandomAccessFileReader::Read(
           io_s = file_->Read(offset + pos, allowed, opts, &tmp_result,
                              scratch + pos, nullptr);
         }
-#ifndef ROCKSDB_LITE
         if (ShouldNotifyListeners()) {
           auto finish_ts = FileOperationInfo::FinishNow();
           NotifyOnFileReadFinish(offset + pos, tmp_result.size(), start_ts,
@@ -215,7 +210,6 @@ IOStatus RandomAccessFileReader::Read(
                             tmp_result.size(), offset + pos);
           }
         }
-#endif
         if (res_scratch == nullptr) {
           // we can't simply use `scratch` because reads of mmap'd files return
           // data in a different buffer.
@@ -301,7 +295,6 @@ IOStatus RandomAccessFileReader::MultiRead(
 
     FSReadRequest* fs_reqs = read_reqs;
     size_t num_fs_reqs = num_reqs;
-#ifndef ROCKSDB_LITE
     std::vector<FSReadRequest> aligned_reqs;
     if (use_direct_io()) {
       // num_reqs is the max possible size,
@@ -345,14 +338,11 @@ IOStatus RandomAccessFileReader::MultiRead(
       fs_reqs = aligned_reqs.data();
       num_fs_reqs = aligned_reqs.size();
     }
-#endif  // ROCKSDB_LITE
 
-#ifndef ROCKSDB_LITE
     FileOperationInfo::StartTimePoint start_ts;
     if (ShouldNotifyListeners()) {
       start_ts = FileOperationInfo::StartNow();
     }
-#endif  // ROCKSDB_LITE
 
     {
       IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, clock_);
@@ -384,7 +374,6 @@ IOStatus RandomAccessFileReader::MultiRead(
       RecordInHistogram(stats_, MULTIGET_IO_BATCH_SIZE, num_fs_reqs);
     }
 
-#ifndef ROCKSDB_LITE
     if (use_direct_io()) {
       // Populate results in the unaligned read requests.
       size_t aligned_i = 0;
@@ -410,10 +399,8 @@ IOStatus RandomAccessFileReader::MultiRead(
         }
       }
     }
-#endif  // ROCKSDB_LITE
 
     for (size_t i = 0; i < num_reqs; ++i) {
-#ifndef ROCKSDB_LITE
       if (ShouldNotifyListeners()) {
         auto finish_ts = FileOperationInfo::FinishNow();
         NotifyOnFileReadFinish(read_reqs[i].offset, read_reqs[i].result.size(),
@@ -425,7 +412,6 @@ IOStatus RandomAccessFileReader::MultiRead(
                         read_reqs[i].offset);
       }
 
-#endif  // ROCKSDB_LITE
       RecordIOStats(stats_, file_temperature_, is_last_level_,
                     read_reqs[i].result.size());
     }
@@ -459,11 +445,9 @@ IOStatus RandomAccessFileReader::ReadAsync(
   ReadAsyncInfo* read_async_info =
       new ReadAsyncInfo(cb, cb_arg, clock_->NowMicros());
 
-#ifndef ROCKSDB_LITE
   if (ShouldNotifyListeners()) {
     read_async_info->fs_start_ts_ = FileOperationInfo::StartNow();
   }
-#endif
 
   size_t alignment = file_->GetRequiredBufferAlignment();
   bool is_aligned = (req.offset & (alignment - 1)) == 0 &&
@@ -584,7 +568,6 @@ void RandomAccessFileReader::ReadAsyncCallback(const FSReadRequest& req,
   } else if (!req.status.IsAborted()) {
     RecordTick(stats_, ASYNC_READ_ERROR_COUNT, 1);
   }
-#ifndef ROCKSDB_LITE
   if (ShouldNotifyListeners()) {
     auto finish_ts = FileOperationInfo::FinishNow();
     NotifyOnFileReadFinish(req.offset, req.result.size(),
@@ -595,7 +578,6 @@ void RandomAccessFileReader::ReadAsyncCallback(const FSReadRequest& req,
     NotifyOnIOError(req.status, FileOperationType::kRead, file_name(),
                     req.result.size(), req.offset);
   }
-#endif
   RecordIOStats(stats_, file_temperature_, is_last_level_, req.result.size());
   delete read_async_info;
 }

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

@@ -46,7 +46,6 @@ bool TryMerge(FSReadRequest* dest, const FSReadRequest& src);
 // - Updating IO stats.
 class RandomAccessFileReader {
  private:
-#ifndef ROCKSDB_LITE
   void NotifyOnFileReadFinish(
       uint64_t offset, size_t length,
       const FileOperationInfo::StartTimePoint& start_ts,
@@ -77,7 +76,6 @@ class RandomAccessFileReader {
     io_status.PermitUncheckedError();
   }
 
-#endif  // ROCKSDB_LITE
 
   bool ShouldNotifyListeners() const { return !listeners_.empty(); }
 
@@ -107,9 +105,7 @@ class RandomAccessFileReader {
     std::function<void(const FSReadRequest&, void*)> cb_;
     void* cb_arg_;
     uint64_t start_time_;
-#ifndef ROCKSDB_LITE
     FileOperationInfo::StartTimePoint fs_start_ts_;
-#endif
     // Below fields stores the parameters passed by caller in case of direct_io.
     char* user_scratch_;
     AlignedBuf* user_aligned_buf_;
@@ -142,16 +138,12 @@ class RandomAccessFileReader {
         listeners_(),
         file_temperature_(file_temperature),
         is_last_level_(is_last_level) {
-#ifndef ROCKSDB_LITE
     std::for_each(listeners.begin(), listeners.end(),
                   [this](const std::shared_ptr<EventListener>& e) {
                     if (e->ShouldBeNotifiedOnFileIO()) {
                       listeners_.emplace_back(e);
                     }
                   });
-#else  // !ROCKSDB_LITE
-    (void)listeners;
-#endif
   }
 
   static IOStatus Create(const std::shared_ptr<FileSystem>& fs,

package/deps/rocksdb/rocksdb/file/random_access_file_reader_test.cc

@@ -64,7 +64,6 @@ class RandomAccessFileReaderTest : public testing::Test {
 };
 
 // Skip the following tests in lite mode since direct I/O is unsupported.
-#ifndef ROCKSDB_LITE
 
 TEST_F(RandomAccessFileReaderTest, ReadDirectIO) {
   std::string fname = "read-direct-io";
@@ -284,7 +283,6 @@ TEST_F(RandomAccessFileReaderTest, MultiReadDirectIO) {
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
 }
 
-#endif  // ROCKSDB_LITE
 
 TEST(FSReadRequest, Align) {
   FSReadRequest r;

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

@@ -39,7 +39,6 @@ IOStatus SequentialFileReader::Read(size_t n, Slice* result, char* scratch,
                                     Env::IOPriority rate_limiter_priority) {
   IOStatus io_s;
   if (use_direct_io()) {
-#ifndef ROCKSDB_LITE
     //
     //    |-offset_advance-|---bytes returned--|
     //    |----------------------buf size-------------------------|
@@ -95,7 +94,6 @@ IOStatus SequentialFileReader::Read(size_t n, Slice* result, char* scratch,
                    std::min(buf.CurrentSize() - offset_advance, n));
     }
     *result = Slice(scratch, r);
-#endif  // !ROCKSDB_LITE
   } else {
     // To be paranoid, modify scratch a little bit, so in case underlying
     // FileSystem doesn't fill the buffer but return success and `scratch`
@@ -116,22 +114,18 @@ IOStatus SequentialFileReader::Read(size_t n, Slice* result, char* scratch,
       } else {
         allowed = n;
       }
-#ifndef ROCKSDB_LITE
       FileOperationInfo::StartTimePoint start_ts;
       if (ShouldNotifyListeners()) {
         start_ts = FileOperationInfo::StartNow();
       }
-#endif
       Slice tmp;
       io_s = file_->Read(allowed, IOOptions(), &tmp, scratch + read,
                          nullptr /* dbg */);
-#ifndef ROCKSDB_LITE
       if (ShouldNotifyListeners()) {
         auto finish_ts = FileOperationInfo::FinishNow();
         size_t offset = offset_.fetch_add(tmp.size());
         NotifyOnFileReadFinish(offset, tmp.size(), start_ts, finish_ts, io_s);
       }
-#endif
       read += tmp.size();
       if (!io_s.ok() || tmp.size() < allowed) {
         break;
@@ -144,12 +138,10 @@ IOStatus SequentialFileReader::Read(size_t n, Slice* result, char* scratch,
 }
 
 IOStatus SequentialFileReader::Skip(uint64_t n) {
-#ifndef ROCKSDB_LITE
   if (use_direct_io()) {
     offset_ += static_cast<size_t>(n);
     return IOStatus::OK();
   }
-#endif  // !ROCKSDB_LITE
   return file_->Skip(n);
 }
 

package/deps/rocksdb/rocksdb/file/sequence_file_reader.h

@@ -23,7 +23,6 @@ namespace ROCKSDB_NAMESPACE {
 // cache disabled) reads appropriately, and also updates the IO stats.
 class SequentialFileReader {
  private:
-#ifndef ROCKSDB_LITE
   void NotifyOnFileReadFinish(
       uint64_t offset, size_t length,
       const FileOperationInfo::StartTimePoint& start_ts,
@@ -49,7 +48,6 @@ class SequentialFileReader {
                     }
                   });
   }
-#endif  // ROCKSDB_LITE
 
   bool ShouldNotifyListeners() const { return !listeners_.empty(); }
 
@@ -70,11 +68,7 @@ class SequentialFileReader {
         file_(std::move(_file), io_tracer, _file_name),
         listeners_(),
         rate_limiter_(rate_limiter) {
-#ifndef ROCKSDB_LITE
     AddFileIOListeners(listeners);
-#else
-    (void)listeners;
-#endif
   }
 
   explicit SequentialFileReader(
@@ -89,11 +83,7 @@ class SequentialFileReader {
               io_tracer, _file_name),
         listeners_(),
         rate_limiter_(rate_limiter) {
-#ifndef ROCKSDB_LITE
     AddFileIOListeners(listeners);
-#else
-    (void)listeners;
-#endif
   }
   static IOStatus Create(const std::shared_ptr<FileSystem>& fs,
                          const std::string& fname, const FileOptions& file_opts,