@nxtedition/rocksdb 8.1.7 → 8.1.9

package/deps/rocksdb/rocksdb/file/sst_file_manager_impl.cc

@@ -18,7 +18,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-#ifndef ROCKSDB_LITE
 SstFileManagerImpl::SstFileManagerImpl(
     const std::shared_ptr<SystemClock>& clock,
     const std::shared_ptr<FileSystem>& fs,
@@ -504,22 +503,5 @@ SstFileManager* NewSstFileManager(Env* env, std::shared_ptr<FileSystem> fs,
   return res;
 }
 
-#else
-
-SstFileManager* NewSstFileManager(Env* /*env*/,
-                                  std::shared_ptr<Logger> /*info_log*/,
-                                  std::string /*trash_dir*/,
-                                  int64_t /*rate_bytes_per_sec*/,
-                                  bool /*delete_existing_trash*/,
-                                  Status* status, double /*max_trash_db_ratio*/,
-                                  uint64_t /*bytes_max_delete_chunk*/) {
-  if (status) {
-    *status =
-        Status::NotSupported("SstFileManager is not supported in ROCKSDB_LITE");
-  }
-  return nullptr;
-}
-
-#endif  // ROCKSDB_LITE
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/file/sst_file_manager_impl.h

@@ -5,7 +5,6 @@
 
 #pragma once
 
-#ifndef ROCKSDB_LITE
 
 #include <string>
 
@@ -192,4 +191,3 @@ class SstFileManagerImpl : public SstFileManager {
 
 }  // namespace ROCKSDB_NAMESPACE
 
-#endif  // ROCKSDB_LITE

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

@@ -249,15 +249,12 @@ IOStatus WritableFileWriter::Close() {
   // we need to let the file know where data ends.
   if (use_direct_io()) {
     {
-#ifndef ROCKSDB_LITE
       FileOperationInfo::StartTimePoint start_ts;
       if (ShouldNotifyListeners()) {
         start_ts = FileOperationInfo::StartNow();
       }
-#endif
       uint64_t filesz = filesize_.load(std::memory_order_acquire);
       interim = writable_file_->Truncate(filesz, io_options, nullptr);
-#ifndef ROCKSDB_LITE
       if (ShouldNotifyListeners()) {
         auto finish_ts = FileOperationInfo::FinishNow();
         NotifyOnFileTruncateFinish(start_ts, finish_ts, s);
@@ -266,18 +263,14 @@ IOStatus WritableFileWriter::Close() {
                           filesz);
         }
       }
-#endif
     }
     if (interim.ok()) {
       {
-#ifndef ROCKSDB_LITE
         FileOperationInfo::StartTimePoint start_ts;
         if (ShouldNotifyListeners()) {
           start_ts = FileOperationInfo::StartNow();
         }
-#endif
         interim = writable_file_->Fsync(io_options, nullptr);
-#ifndef ROCKSDB_LITE
         if (ShouldNotifyListeners()) {
           auto finish_ts = FileOperationInfo::FinishNow();
           NotifyOnFileSyncFinish(start_ts, finish_ts, s,
@@ -286,7 +279,6 @@ IOStatus WritableFileWriter::Close() {
             NotifyOnIOError(interim, FileOperationType::kFsync, file_name());
           }
         }
-#endif
       }
     }
     if (!interim.ok() && s.ok()) {
@@ -296,14 +288,11 @@ IOStatus WritableFileWriter::Close() {
 
   TEST_KILL_RANDOM("WritableFileWriter::Close:0");
   {
-#ifndef ROCKSDB_LITE
     FileOperationInfo::StartTimePoint start_ts;
     if (ShouldNotifyListeners()) {
       start_ts = FileOperationInfo::StartNow();
     }
-#endif
     interim = writable_file_->Close(io_options, nullptr);
-#ifndef ROCKSDB_LITE
     if (ShouldNotifyListeners()) {
       auto finish_ts = FileOperationInfo::FinishNow();
       NotifyOnFileCloseFinish(start_ts, finish_ts, s);
@@ -311,7 +300,6 @@ IOStatus WritableFileWriter::Close() {
         NotifyOnIOError(interim, FileOperationType::kClose, file_name());
       }
     }
-#endif
   }
   if (!interim.ok() && s.ok()) {
     s = interim;
@@ -344,7 +332,6 @@ IOStatus WritableFileWriter::Flush(Env::IOPriority op_rate_limiter_priority) {
 
   if (buf_.CurrentSize() > 0) {
     if (use_direct_io()) {
-#ifndef ROCKSDB_LITE
       if (pending_sync_) {
         if (perform_data_verification_ && buffered_data_with_checksum_) {
           s = WriteDirectWithChecksum(op_rate_limiter_priority);
@@ -352,7 +339,6 @@ IOStatus WritableFileWriter::Flush(Env::IOPriority op_rate_limiter_priority) {
           s = WriteDirect(op_rate_limiter_priority);
         }
       }
-#endif  // !ROCKSDB_LITE
     } else {
       if (perform_data_verification_ && buffered_data_with_checksum_) {
         s = WriteBufferedWithChecksum(buf_.BufferStart(), buf_.CurrentSize(),
@@ -369,18 +355,15 @@ IOStatus WritableFileWriter::Flush(Env::IOPriority op_rate_limiter_priority) {
   }
 
   {
-#ifndef ROCKSDB_LITE
     FileOperationInfo::StartTimePoint start_ts;
     if (ShouldNotifyListeners()) {
       start_ts = FileOperationInfo::StartNow();
     }
-#endif
     IOOptions io_options;
     io_options.rate_limiter_priority =
         WritableFileWriter::DecideRateLimiterPriority(
             writable_file_->GetIOPriority(), op_rate_limiter_priority);
     s = writable_file_->Flush(io_options, nullptr);
-#ifndef ROCKSDB_LITE
     if (ShouldNotifyListeners()) {
       auto finish_ts = std::chrono::steady_clock::now();
       NotifyOnFileFlushFinish(start_ts, finish_ts, s);
@@ -388,7 +371,6 @@ IOStatus WritableFileWriter::Flush(Env::IOPriority op_rate_limiter_priority) {
         NotifyOnIOError(s, FileOperationType::kFlush, file_name());
       }
     }
-#endif
   }
 
   if (!s.ok()) {
@@ -500,12 +482,10 @@ IOStatus WritableFileWriter::SyncInternal(bool use_fsync) {
 
   IOSTATS_CPU_TIMER_GUARD(cpu_write_nanos, clock_);
 
-#ifndef ROCKSDB_LITE
   FileOperationInfo::StartTimePoint start_ts;
   if (ShouldNotifyListeners()) {
     start_ts = FileOperationInfo::StartNow();
   }
-#endif
 
   IOOptions io_options;
   io_options.rate_limiter_priority = writable_file_->GetIOPriority();
@@ -514,7 +494,6 @@ IOStatus WritableFileWriter::SyncInternal(bool use_fsync) {
   } else {
     s = writable_file_->Sync(io_options, nullptr);
   }
-#ifndef ROCKSDB_LITE
   if (ShouldNotifyListeners()) {
     auto finish_ts = std::chrono::steady_clock::now();
     NotifyOnFileSyncFinish(
@@ -526,7 +505,6 @@ IOStatus WritableFileWriter::SyncInternal(bool use_fsync) {
           file_name());
     }
   }
-#endif
   SetPerfLevel(prev_perf_level);
 
   // The caller will be responsible to call set_seen_error() if s is not OK.
@@ -540,19 +518,16 @@ IOStatus WritableFileWriter::RangeSync(uint64_t offset, uint64_t nbytes) {
 
   IOSTATS_TIMER_GUARD(range_sync_nanos);
   TEST_SYNC_POINT("WritableFileWriter::RangeSync:0");
-#ifndef ROCKSDB_LITE
   FileOperationInfo::StartTimePoint start_ts;
   if (ShouldNotifyListeners()) {
     start_ts = FileOperationInfo::StartNow();
   }
-#endif
   IOOptions io_options;
   io_options.rate_limiter_priority = writable_file_->GetIOPriority();
   IOStatus s = writable_file_->RangeSync(offset, nbytes, io_options, nullptr);
   if (!s.ok()) {
     set_seen_error();
   }
-#ifndef ROCKSDB_LITE
   if (ShouldNotifyListeners()) {
     auto finish_ts = std::chrono::steady_clock::now();
     NotifyOnFileRangeSyncFinish(offset, nbytes, start_ts, finish_ts, s);
@@ -561,7 +536,6 @@ IOStatus WritableFileWriter::RangeSync(uint64_t offset, uint64_t nbytes) {
                       offset);
     }
   }
-#endif
   return s;
 }
 
@@ -598,14 +572,12 @@ IOStatus WritableFileWriter::WriteBuffered(
       IOSTATS_TIMER_GUARD(write_nanos);
       TEST_SYNC_POINT("WritableFileWriter::Flush:BeforeAppend");
 
-#ifndef ROCKSDB_LITE
       FileOperationInfo::StartTimePoint start_ts;
       uint64_t old_size = writable_file_->GetFileSize(io_options, nullptr);
       if (ShouldNotifyListeners()) {
         start_ts = FileOperationInfo::StartNow();
         old_size = next_write_offset_;
       }
-#endif
       {
         auto prev_perf_level = GetPerfLevel();
 
@@ -633,7 +605,6 @@ IOStatus WritableFileWriter::WriteBuffered(
         }
         SetPerfLevel(prev_perf_level);
       }
-#ifndef ROCKSDB_LITE
       if (ShouldNotifyListeners()) {
         auto finish_ts = std::chrono::steady_clock::now();
         NotifyOnFileWriteFinish(old_size, allowed, start_ts, finish_ts, s);
@@ -642,7 +613,6 @@ IOStatus WritableFileWriter::WriteBuffered(
                           old_size);
         }
       }
-#endif
       if (!s.ok()) {
         set_seen_error();
         return s;
@@ -702,14 +672,12 @@ IOStatus WritableFileWriter::WriteBufferedWithChecksum(
     IOSTATS_TIMER_GUARD(write_nanos);
     TEST_SYNC_POINT("WritableFileWriter::Flush:BeforeAppend");
 
-#ifndef ROCKSDB_LITE
     FileOperationInfo::StartTimePoint start_ts;
     uint64_t old_size = writable_file_->GetFileSize(io_options, nullptr);
     if (ShouldNotifyListeners()) {
       start_ts = FileOperationInfo::StartNow();
       old_size = next_write_offset_;
     }
-#endif
     {
       auto prev_perf_level = GetPerfLevel();
 
@@ -720,7 +688,6 @@ IOStatus WritableFileWriter::WriteBufferedWithChecksum(
       s = writable_file_->Append(Slice(src, left), io_options, v_info, nullptr);
       SetPerfLevel(prev_perf_level);
     }
-#ifndef ROCKSDB_LITE
     if (ShouldNotifyListeners()) {
       auto finish_ts = std::chrono::steady_clock::now();
       NotifyOnFileWriteFinish(old_size, left, start_ts, finish_ts, s);
@@ -729,7 +696,6 @@ IOStatus WritableFileWriter::WriteBufferedWithChecksum(
                         old_size);
       }
     }
-#endif
     if (!s.ok()) {
       // If writable_file_->Append() failed, then the data may or may not
       // exist in the underlying memory buffer, OS page cache, remote file
@@ -789,7 +755,6 @@ void WritableFileWriter::Crc32cHandoffChecksumCalculation(const char* data,
 // whole number of pages to be written again on the next flush because we can
 // only write on aligned
 // offsets.
-#ifndef ROCKSDB_LITE
 IOStatus WritableFileWriter::WriteDirect(
     Env::IOPriority op_rate_limiter_priority) {
   if (seen_error()) {
@@ -1006,7 +971,6 @@ IOStatus WritableFileWriter::WriteDirectWithChecksum(
   }
   return s;
 }
-#endif  // !ROCKSDB_LITE
 Env::IOPriority WritableFileWriter::DecideRateLimiterPriority(
     Env::IOPriority writable_file_io_priority,
     Env::IOPriority op_rate_limiter_priority) {

package/deps/rocksdb/rocksdb/file/writable_file_writer.h

@@ -35,7 +35,6 @@ class SystemClock;
 // - Update IO stats.
 class WritableFileWriter {
  private:
-#ifndef ROCKSDB_LITE
   void NotifyOnFileWriteFinish(
       uint64_t offset, size_t length,
       const FileOperationInfo::StartTimePoint& start_ts,
@@ -128,7 +127,6 @@ class WritableFileWriter {
     }
     io_error_info.io_status.PermitUncheckedError();
   }
-#endif  // ROCKSDB_LITE
 
   bool ShouldNotifyListeners() const { return !listeners_.empty(); }
   void UpdateFileChecksum(const Slice& data);
@@ -144,12 +142,10 @@ class WritableFileWriter {
   // not counting padding data
   std::atomic<uint64_t> filesize_;
   std::atomic<uint64_t> flushed_size_;
-#ifndef ROCKSDB_LITE
   // This is necessary when we use unbuffered access
   // and writes must happen on aligned offsets
   // so we need to go back and write that page again
   uint64_t next_write_offset_;
-#endif  // ROCKSDB_LITE
   bool pending_sync_;
   std::atomic<bool> seen_error_;
 #ifndef NDEBUG
@@ -169,9 +165,7 @@ class WritableFileWriter {
   bool perform_data_verification_;
   uint32_t buffered_data_crc32c_checksum_;
   bool buffered_data_with_checksum_;
-#ifndef ROCKSDB_LITE
   Temperature temperature_;
-#endif  // ROCKSDB_LITE
 
  public:
   WritableFileWriter(
@@ -190,9 +184,7 @@ class WritableFileWriter {
         max_buffer_size_(options.writable_file_max_buffer_size),
         filesize_(0),
         flushed_size_(0),
-#ifndef ROCKSDB_LITE
         next_write_offset_(0),
-#endif  // ROCKSDB_LITE
         pending_sync_(false),
         seen_error_(false),
         last_sync_size_(0),
@@ -205,24 +197,18 @@ class WritableFileWriter {
         perform_data_verification_(perform_data_verification),
         buffered_data_crc32c_checksum_(0),
         buffered_data_with_checksum_(buffered_data_with_checksum) {
-#ifndef ROCKSDB_LITE
     temperature_ = options.temperature;
-#endif  // ROCKSDB_LITE
     assert(!use_direct_io() || max_buffer_size_ > 0);
     TEST_SYNC_POINT_CALLBACK("WritableFileWriter::WritableFileWriter:0",
                              reinterpret_cast<void*>(max_buffer_size_));
     buf_.Alignment(writable_file_->GetRequiredBufferAlignment());
     buf_.AllocateNewBuffer(std::min((size_t)65536, max_buffer_size_));
-#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
     if (file_checksum_gen_factory != nullptr) {
       FileChecksumGenContext checksum_gen_context;
       checksum_gen_context.file_name = _file_name;
@@ -321,10 +307,8 @@ class WritableFileWriter {
 
   // Used when os buffering is OFF and we are writing
   // DMA such as in Direct I/O mode
-#ifndef ROCKSDB_LITE
   IOStatus WriteDirect(Env::IOPriority op_rate_limiter_priority);
   IOStatus WriteDirectWithChecksum(Env::IOPriority op_rate_limiter_priority);
-#endif  // !ROCKSDB_LITE
   // Normal write.
   IOStatus WriteBuffered(const char* data, size_t size,
                          Env::IOPriority op_rate_limiter_priority);