StackableDB optionally take shared ownership of the underlying DB

HISTORY.md

@@ -1,53 +1,9 @@
 # Rocksdb Change Log
 ## Unreleased
 ### Public API Change
-* RocksDBOptionsParser::Parse()'s `ignore_unknown_options` argument will only be effective if the option file shows it is generated using a higher version of RocksDB than the current version.
-* Remove CompactionEventListener.
-
-### New Features
-* Avoid unnecessarily flushing in `CompactRange()` when the range specified by the user does not overlap unflushed memtables.
-* Add "rocksdb.live-sst-files-size" DB property to return total bytes of all SST files belong to the latest LSM tree.
-
-### Bug Fixes
-* Fix a leak in prepared_section_completed_ where the zeroed entries would not removed from the map.
-
-## 5.12.0 (2/14/2018)
-### Public API Change
 * Iterator::SeekForPrev is now a pure virtual method. This is to prevent user who implement the Iterator interface fail to implement SeekForPrev by mistake.
-* Add `include_end` option to make the range end exclusive when `include_end == false` in `DeleteFilesInRange()`.
-* Add `CompactRangeOptions::allow_write_stall`, which makes `CompactRange` start working immediately, even if it causes user writes to stall. The default value is false, meaning we add delay to `CompactRange` calls until stalling can be avoided when possible. Note this delay is not present in previous RocksDB versions.
-* Creating checkpoint with empty directory now returns `Status::InvalidArgument`; previously, it returned `Status::IOError`.
-* Adds a BlockBasedTableOption to turn off index block compression.
-* Close() method now returns a status when closing a db.
-
-### New Features
-* Improve the performance of iterators doing long range scans by using readahead.
-* Add new function `DeleteFilesInRanges()` to delete files in multiple ranges at once for better performance.
-* FreeBSD build support for RocksDB and RocksJava.
-* Improved performance of long range scans with readahead.
-* Updated to and now continuously tested in Visual Studio 2017.
-
 ### Bug Fixes
 * Fix `DisableFileDeletions()` followed by `GetSortedWalFiles()` to not return obsolete WAL files that `PurgeObsoleteFiles()` is going to delete.
-* Fix Handle error return from WriteBuffer() during WAL file close and DB close.
-* Fix advance reservation of arena block addresses.
-* Fix handling of empty string as checkpoint directory.
-
-## 5.11.0 (01/08/2018)
-### Public API Change
-* Add `autoTune` and `getBytesPerSecond()` to RocksJava RateLimiter
-
-### New Features
-* Add a new histogram stat called rocksdb.db.flush.micros for memtable flush.
-* Add "--use_txn" option to use transactional API in db_stress.
-* Disable onboard cache for compaction output in Windows platform.
-* Improve the performance of iterators doing long range scans by using readahead.
-
-### Bug Fixes
-* Fix a stack-use-after-scope bug in ForwardIterator.
-* Fix builds on platforms including Linux, Windows, and PowerPC.
-* Fix buffer overrun in backup engine for DBs with huge number of files.
-* Fix a mislabel bug for bottom-pri compaction threads.
 * Fix DB::Flush() keep waiting after flush finish under certain condition.
 
 ## 5.10.0 (12/11/2017)

LANGUAGE-BINDINGS.md

@@ -15,4 +15,3 @@ This is the list of all known third-party language bindings for RocksDB. If some
 * D programming language - https://github.com/b1naryth1ef/rocksdb
 * Erlang - https://gitlab.com/barrel-db/erlang-rocksdb
 * Elixir - https://github.com/urbint/rox
-* Nim - https://github.com/status-im/nim-rocksdb

Makefile

@@ -232,13 +232,9 @@ endif
 # USAN doesn't work well with jemalloc. If we're compiling with USAN, we should use regular malloc.
 ifdef COMPILE_WITH_UBSAN
 	DISABLE_JEMALLOC=1
-	# Suppress alignment warning because murmurhash relies on casting unaligned
-	# memory to integer. Fixing it may cause performance regression. 3-way crc32
-	# relies on it too, although it can be rewritten to eliminate with minimal
-	# performance regression.
-	EXEC_LDFLAGS += -fsanitize=undefined -fno-sanitize-recover=all
-	PLATFORM_CCFLAGS += -fsanitize=undefined -fno-sanitize-recover=all -DROCKSDB_UBSAN_RUN
-	PLATFORM_CXXFLAGS += -fsanitize=undefined -fno-sanitize-recover=all -DROCKSDB_UBSAN_RUN
+	EXEC_LDFLAGS += -fsanitize=undefined
+	PLATFORM_CCFLAGS += -fsanitize=undefined -DROCKSDB_UBSAN_RUN
+	PLATFORM_CXXFLAGS += -fsanitize=undefined -DROCKSDB_UBSAN_RUN
 endif
 
 ifdef ROCKSDB_VALGRIND_RUN
@@ -527,10 +523,6 @@ PARALLEL_TEST = \
 	transaction_test \
 	write_prepared_transaction_test \
 
-# options_settable_test doesn't pass with UBSAN as we use hack in the test
-ifdef COMPILE_WITH_UBSAN
-        TESTS := $(shell echo $(TESTS) | sed 's/\boptions_settable_test\b//g')
-endif
 SUBSET := $(TESTS)
 ifdef ROCKSDBTESTS_START
         SUBSET := $(shell echo $(SUBSET) | sed 's/^.*$(ROCKSDBTESTS_START)/$(ROCKSDBTESTS_START)/')

Vagrantfile

@@ -14,11 +14,6 @@ Vagrant.configure("2") do |config|
     box.vm.box = "chef/centos-6.5"
   end
 
-  config.vm.define "centos7" do |box|
-    box.vm.box = "centos/7"
-    box.vm.provision "shell", path: "build_tools/setup_centos7.sh"
-  end
-
   config.vm.define "FreeBSD10" do |box|
     box.vm.guest = :freebsd
     box.vm.box = "robin/freebsd-10"

appveyor.yml

@@ -1,9 +1,9 @@
 version: 1.0.{build}
-image: Visual Studio 2017
+image: Visual Studio 2015
 before_build:
 - md %APPVEYOR_BUILD_FOLDER%\build
 - cd %APPVEYOR_BUILD_FOLDER%\build
-- cmake -G "Visual Studio 15 Win64" -DOPTDBG=1 -DWITH_XPRESS=1 -DPORTABLE=1 ..
+- cmake -G "Visual Studio 14 Win64" -DOPTDBG=1 -DWITH_XPRESS=1 -DPORTABLE=1 ..
 - cd ..
 build:
   project: build\rocksdb.sln

buckifier/buckify_rocksdb.py

@@ -36,7 +36,7 @@ def parse_src_mk(repo_path):
 # get all .cc / .c files
 def get_cc_files(repo_path):
     cc_files = []
-    for root, dirnames, filenames in os.walk(repo_path):  # noqa: B007 T25377293 Grandfathered in
+    for root, dirnames, filenames in os.walk(repo_path):
         root = root[(len(repo_path) + 1):]
         if "java" in root:
             # Skip java

buckifier/rocks_test_runner.sh

@@ -1,5 +1,4 @@
 #!/usr/bin/env bash
 # Create a tmp directory for the test to use
 TEST_DIR=$(mktemp -d /dev/shm/fbcode_rocksdb_XXXXXXX)
-# shellcheck disable=SC2068
 TEST_TMPDIR="$TEST_DIR" $@ && rm -rf "$TEST_DIR"

build_tools/cont_integration.sh

@@ -13,12 +13,10 @@ error=0
 
 function log {
   DATE=`date +%Y-%m-%d:%H:%M:%S`
-  # shellcheck disable=SC2068
   echo $DATE $@
 }
 
 function log_err {
-  # shellcheck disable=SC2145
   log "ERROR: $@ Error code: $error."
 }
 

build_tools/dependencies.sh

@@ -1,4 +1,3 @@
-# shellcheck disable=SC2148
 GCC_BASE=/mnt/gvfs/third-party2/gcc/8219ec1bcedf8ad9da05e121e193364de2cc4f61/5.x/centos6-native/c447969
 CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/64d8d58e3d84f8bde7a029763d4f5baf39d0d5b9/stable/centos6-native/6aaf4de
 LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/ba9be983c81de7299b59fe71950c664a84dcb5f8/5.x/gcc-5-glibc-2.23/339d858

build_tools/dependencies_4.8.1.sh

@@ -1,4 +1,3 @@
-# shellcheck disable=SC2148
 GCC_BASE=/mnt/gvfs/third-party2/gcc/cf7d14c625ce30bae1a4661c2319c5a283e4dd22/4.8.1/centos6-native/cc6c9dc
 CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/8598c375b0e94e1448182eb3df034704144a838d/stable/centos6-native/3f16ddd
 LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/d6e0a7da6faba45f5e5b1638f9edd7afc2f34e7d/4.8.1/gcc-4.8.1-glibc-2.17/8aac7fc

build_tools/make_package.sh

@@ -1,4 +1,3 @@
-# shellcheck disable=SC1113
 #/usr/bin/env bash
 
 set -e
@@ -29,14 +28,12 @@ function package() {
     if dpkg --get-selections | grep --quiet $1; then
       log "$1 is already installed. skipping."
     else
-      # shellcheck disable=SC2068
       apt-get install $@ -y
     fi
   elif [[ $OS = "centos" ]]; then
     if rpm -qa | grep --quiet $1; then
       log "$1 is already installed. skipping."
     else
-      # shellcheck disable=SC2068
       yum install $@ -y
     fi
   fi
@@ -55,7 +52,6 @@ function gem_install() {
   if gem list | grep --quiet $1; then
     log "$1 is already installed. skipping."
   else
-    # shellcheck disable=SC2068
     gem install $@
   fi
 }
@@ -129,5 +125,4 @@ function main() {
     include $LIB_DIR
 }
 
-# shellcheck disable=SC2068
 main $@

build_tools/rocksdb-lego-determinator

@@ -352,22 +352,6 @@ LITE_BUILD_COMMANDS="[
     }
 ]"
 
-#
-# Report RocksDB lite binary size to scuba
-REPORT_LITE_BINARY_SIZE_COMMANDS="[
-    {
-        'name':'Rocksdb Lite Binary Size',
-        'oncall':'$ONCALL',
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Report RocksDB Lite binary size to scuba',
-                'shell':'tools/report_lite_binary_size.sh',
-                'user':'root',
-            },
-        ],
-]"
-
 #
 # RocksDB stress/crash test
 #
@@ -744,9 +728,6 @@ case $1 in
   lite)
     echo $LITE_BUILD_COMMANDS
     ;;
-  report_lite_binary_size)
-    echo $REPORT_LITE_BINARY_SIZE_COMMANDS
-    ;;
   stress_crash)
     echo $STRESS_CRASH_TEST_COMMANDS
     ;;

build_tools/setup_centos7.sh

@@ -1,43 +0,0 @@
-#!/bin/bash
-set -e
-
-ROCKSDB_VERSION="5.10.3"
-ZSTD_VERSION="1.1.3"
-
-echo "This script configures CentOS with everything needed to build and run RocksDB"
-
-yum update -y && yum install epel-release -y
-
-yum install -y \
-  wget \
-  gcc-c++ \
-  snappy snappy-devel \
-  zlib zlib-devel \
-  bzip2 bzip2-devel \
-  lz4-devel \
-  libasan \
-  gflags
-
-mkdir -pv /usr/local/rocksdb-${ROCKSDB_VERSION}
-ln -sfT /usr/local/rocksdb-${ROCKSDB_VERSION} /usr/local/rocksdb
-
-wget -qO /tmp/zstd-${ZSTD_VERSION}.tar.gz https://github.com/facebook/zstd/archive/v${ZSTD_VERSION}.tar.gz
-wget -qO /tmp/rocksdb-${ROCKSDB_VERSION}.tar.gz https://github.com/facebook/rocksdb/archive/v${ROCKSDB_VERSION}.tar.gz
-
-cd /tmp
-
-tar xzvf zstd-${ZSTD_VERSION}.tar.gz
-tar xzvf rocksdb-${ROCKSDB_VERSION}.tar.gz -C /usr/local/
-
-echo "Installing ZSTD..."
-pushd zstd-${ZSTD_VERSION}
-make && make install
-popd
-
-echo "Compiling RocksDB..."
-cd /usr/local/rocksdb
-chown -R vagrant:vagrant /usr/local/rocksdb/
-sudo -u vagrant make static_lib
-cd examples/
-sudo -u vagrant make all
-sudo -u vagrant ./c_simple_example

cache/cache_test.cc

@@ -40,9 +40,9 @@ static int DecodeValue(void* v) {
 const std::string kLRU = "lru";
 const std::string kClock = "clock";
 
-void dumbDeleter(const Slice& /*key*/, void* /*value*/) {}
+void dumbDeleter(const Slice& key, void* value) {}
 
-void eraseDeleter(const Slice& /*key*/, void* value) {
+void eraseDeleter(const Slice& key, void* value) {
   Cache* cache = reinterpret_cast<Cache*>(value);
   cache->Erase("foo");
 }
@@ -470,7 +470,7 @@ class Value {
 };
 
 namespace {
-void deleter(const Slice& /*key*/, void* value) {
+void deleter(const Slice& key, void* value) {
   delete static_cast<Value *>(value);
 }
 }  // namespace

cache/clock_cache.cc

@@ -586,7 +586,7 @@ Status ClockCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
                                size_t charge,
                                void (*deleter)(const Slice& key, void* value),
                                Cache::Handle** out_handle,
-                               Cache::Priority /*priority*/) {
+                               Cache::Priority priority) {
   CleanupContext context;
   HashTable::accessor accessor;
   char* key_data = new char[key.size()];

cache/lru_cache.h

@@ -57,7 +57,7 @@ struct LRUHandle {
   // Include the following flags:
   //   in_cache:    whether this entry is referenced by the hash table.
   //   is_high_pri: whether this entry is high priority entry.
-  //   in_high_pri_pool: whether this entry is in high-pri pool.
+  //   in_high_pro_pool: whether this entry is in high-pri pool.
   char flags;
 
   uint32_t hash;     // Hash of key(); used for fast sharding and comparisons

cache/sharded_cache.cc

@@ -53,7 +53,7 @@ Status ShardedCache::Insert(const Slice& key, void* value, size_t charge,
       ->Insert(key, hash, value, charge, deleter, handle, priority);
 }
 
-Cache::Handle* ShardedCache::Lookup(const Slice& key, Statistics* /*stats*/) {
+Cache::Handle* ShardedCache::Lookup(const Slice& key, Statistics* stats) {
   uint32_t hash = HashSlice(key);
   return GetShard(Shard(hash))->Lookup(key, hash);
 }

coverage/parse_gcov_output.py

@@ -72,7 +72,7 @@ def display_file_coverage(per_file_coverage, total_coverage):
     header_template = \
         "%" + str(max_file_name_length) + "s\t%s\t%s"
     separator = "-" * (max_file_name_length + 10 + 20)
-    print header_template % ("Filename", "Coverage", "Lines")  # noqa: E999 T25377293 Grandfathered in
+    print header_template % ("Filename", "Coverage", "Lines")
     print separator
 
     # -- Print body

db/builder.cc

@@ -61,10 +61,10 @@ TableBuilder* NewTableBuilder(
 
 Status BuildTable(
     const std::string& dbname, Env* env, const ImmutableCFOptions& ioptions,
-    const MutableCFOptions& /*mutable_cf_options*/,
-    const EnvOptions& env_options, TableCache* table_cache,
-    InternalIterator* iter, std::unique_ptr<InternalIterator> range_del_iter,
-    FileMetaData* meta, const InternalKeyComparator& internal_comparator,
+    const MutableCFOptions& mutable_cf_options, const EnvOptions& env_options,
+    TableCache* table_cache, InternalIterator* iter,
+    std::unique_ptr<InternalIterator> range_del_iter, FileMetaData* meta,
+    const InternalKeyComparator& internal_comparator,
     const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
         int_tbl_prop_collector_factories,
     uint32_t column_family_id, const std::string& column_family_name,
@@ -131,8 +131,7 @@ Status BuildTable(
     MergeHelper merge(env, internal_comparator.user_comparator(),
                       ioptions.merge_operator, nullptr, ioptions.info_log,
                       true /* internal key corruption is not ok */,
-                      snapshots.empty() ? 0 : snapshots.back(),
-                      snapshot_checker);
+                      snapshots.empty() ? 0 : snapshots.back());
 
     CompactionIterator c_iter(
         iter, internal_comparator.user_comparator(), &merge, kMaxSequenceNumber,

db/c.cc

@@ -252,7 +252,7 @@ struct rocksdb_comparator_t : public Comparator {
   // No-ops since the C binding does not support key shortening methods.
   virtual void FindShortestSeparator(std::string*,
                                      const Slice&) const override {}
-  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortSuccessor(std::string* key) const override {}
 };
 
 struct rocksdb_filterpolicy_t : public FilterPolicy {
@@ -367,7 +367,7 @@ struct rocksdb_mergeoperator_t : public MergeOperator {
   virtual bool PartialMergeMulti(const Slice& key,
                                  const std::deque<Slice>& operand_list,
                                  std::string* new_value,
-                                 Logger* /*logger*/) const override {
+                                 Logger* logger) const override {
     size_t operand_count = operand_list.size();
     std::vector<const char*> operand_pointers(operand_count);
     std::vector<size_t> operand_sizes(operand_count);
@@ -2166,8 +2166,8 @@ void rocksdb_options_set_level0_stop_writes_trigger(
   opt->rep.level0_stop_writes_trigger = n;
 }
 
-void rocksdb_options_set_max_mem_compaction_level(rocksdb_options_t* /*opt*/,
-                                                  int /*n*/) {}
+void rocksdb_options_set_max_mem_compaction_level(rocksdb_options_t* opt,
+                                                  int n) {}
 
 void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt,int mode) {
   opt->rep.wal_recovery_mode = static_cast<WALRecoveryMode>(mode);
@@ -2231,8 +2231,8 @@ void rocksdb_options_set_manifest_preallocation_size(
 }
 
 // noop
-void rocksdb_options_set_purge_redundant_kvs_while_flush(
-    rocksdb_options_t* /*opt*/, unsigned char /*v*/) {}
+void rocksdb_options_set_purge_redundant_kvs_while_flush(rocksdb_options_t* opt,
+                                                         unsigned char v) {}
 
 void rocksdb_options_set_use_direct_reads(rocksdb_options_t* opt,
                                           unsigned char v) {
@@ -2402,7 +2402,7 @@ void rocksdb_options_set_table_cache_numshardbits(
 }
 
 void rocksdb_options_set_table_cache_remove_scan_count_limit(
-    rocksdb_options_t* /*opt*/, int /*v*/) {
+    rocksdb_options_t* opt, int v) {
   // this option is deprecated
 }
 
@@ -2973,7 +2973,7 @@ rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create(
 
 rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create_with_comparator(
     const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options,
-    const rocksdb_comparator_t* /*comparator*/) {
+    const rocksdb_comparator_t* comparator) {
   rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t;
   writer->rep = new SstFileWriter(env->rep, io_options->rep);
   return writer;

db/column_family.cc

@@ -31,7 +31,6 @@
 #include "monitoring/thread_status_util.h"
 #include "options/options_helper.h"
 #include "table/block_based_table_factory.h"
-#include "table/merging_iterator.h"
 #include "util/autovector.h"
 #include "util/compression.h"
 
@@ -345,13 +344,12 @@ void SuperVersionUnrefHandle(void* ptr) {
   // When latter happens, we are in ~ColumnFamilyData(), no get should happen as
   // well.
   SuperVersion* sv = static_cast<SuperVersion*>(ptr);
-  bool was_last_ref __attribute__((__unused__));
-  was_last_ref = sv->Unref();
-  // Thread-local SuperVersions can't outlive ColumnFamilyData::super_version_.
-  // This is important because we can't do SuperVersion cleanup here.
-  // That would require locking DB mutex, which would deadlock because
-  // SuperVersionUnrefHandle is called with locked ThreadLocalPtr mutex.
-  assert(!was_last_ref);
+  if (sv->Unref()) {
+    sv->db_mutex->Lock();
+    sv->Cleanup();
+    sv->db_mutex->Unlock();
+    delete sv;
+  }
 }
 }  // anonymous namespace
 
@@ -383,7 +381,6 @@ ColumnFamilyData::ColumnFamilyData(
       next_(nullptr),
       prev_(nullptr),
       log_number_(0),
-      flush_reason_(FlushReason::kUnknown),
       column_family_set_(column_family_set),
       pending_flush_(false),
       pending_compaction_(false),
@@ -472,7 +469,7 @@ ColumnFamilyData::~ColumnFamilyData() {
     local_sv_.reset();
     super_version_->db_mutex->Lock();
 
-    bool is_last_reference __attribute__((__unused__));
+    bool is_last_reference __attribute__((unused));
     is_last_reference = super_version_->Unref();
     assert(is_last_reference);
     super_version_->Cleanup();
@@ -483,7 +480,7 @@ ColumnFamilyData::~ColumnFamilyData() {
   if (dummy_versions_ != nullptr) {
     // List must be empty
     assert(dummy_versions_->TEST_Next() == dummy_versions_);
-    bool deleted __attribute__((__unused__));
+    bool deleted __attribute__((unused));
     deleted = dummy_versions_->Unref();
     assert(deleted);
   }
@@ -634,41 +631,6 @@ int GetL0ThresholdSpeedupCompaction(int level0_file_num_compaction_trigger,
 }
 }  // namespace
 
-std::pair<WriteStallCondition, ColumnFamilyData::WriteStallCause>
-ColumnFamilyData::GetWriteStallConditionAndCause(
-    int num_unflushed_memtables, int num_l0_files,
-    uint64_t num_compaction_needed_bytes,
-    const MutableCFOptions& mutable_cf_options) {
-  if (num_unflushed_memtables >= mutable_cf_options.max_write_buffer_number) {
-    return {WriteStallCondition::kStopped, WriteStallCause::kMemtableLimit};
-  } else if (!mutable_cf_options.disable_auto_compactions &&
-             num_l0_files >= mutable_cf_options.level0_stop_writes_trigger) {
-    return {WriteStallCondition::kStopped, WriteStallCause::kL0FileCountLimit};
-  } else if (!mutable_cf_options.disable_auto_compactions &&
-             mutable_cf_options.hard_pending_compaction_bytes_limit > 0 &&
-             num_compaction_needed_bytes >=
-                 mutable_cf_options.hard_pending_compaction_bytes_limit) {
-    return {WriteStallCondition::kStopped,
-            WriteStallCause::kPendingCompactionBytes};
-  } else if (mutable_cf_options.max_write_buffer_number > 3 &&
-             num_unflushed_memtables >=
-                 mutable_cf_options.max_write_buffer_number - 1) {
-    return {WriteStallCondition::kDelayed, WriteStallCause::kMemtableLimit};
-  } else if (!mutable_cf_options.disable_auto_compactions &&
-             mutable_cf_options.level0_slowdown_writes_trigger >= 0 &&
-             num_l0_files >=
-                 mutable_cf_options.level0_slowdown_writes_trigger) {
-    return {WriteStallCondition::kDelayed, WriteStallCause::kL0FileCountLimit};
-  } else if (!mutable_cf_options.disable_auto_compactions &&
-             mutable_cf_options.soft_pending_compaction_bytes_limit > 0 &&
-             num_compaction_needed_bytes >=
-                 mutable_cf_options.soft_pending_compaction_bytes_limit) {
-    return {WriteStallCondition::kDelayed,
-            WriteStallCause::kPendingCompactionBytes};
-  }
-  return {WriteStallCondition::kNormal, WriteStallCause::kNone};
-}
-
 WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
       const MutableCFOptions& mutable_cf_options) {
   auto write_stall_condition = WriteStallCondition::kNormal;
@@ -678,29 +640,25 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
     uint64_t compaction_needed_bytes =
         vstorage->estimated_compaction_needed_bytes();
 
-    auto write_stall_condition_and_cause = GetWriteStallConditionAndCause(
-        imm()->NumNotFlushed(), vstorage->l0_delay_trigger_count(),
-        vstorage->estimated_compaction_needed_bytes(), mutable_cf_options);
-    write_stall_condition = write_stall_condition_and_cause.first;
-    auto write_stall_cause = write_stall_condition_and_cause.second;
-
     bool was_stopped = write_controller->IsStopped();
     bool needed_delay = write_controller->NeedsDelay();
 
-    if (write_stall_condition == WriteStallCondition::kStopped &&
-        write_stall_cause == WriteStallCause::kMemtableLimit) {
+    if (imm()->NumNotFlushed() >= mutable_cf_options.max_write_buffer_number) {
       write_controller_token_ = write_controller->GetStopToken();
       internal_stats_->AddCFStats(InternalStats::MEMTABLE_LIMIT_STOPS, 1);
+      write_stall_condition = WriteStallCondition::kStopped;
       ROCKS_LOG_WARN(
           ioptions_.info_log,
           "[%s] Stopping writes because we have %d immutable memtables "
           "(waiting for flush), max_write_buffer_number is set to %d",
           name_.c_str(), imm()->NumNotFlushed(),
           mutable_cf_options.max_write_buffer_number);
-    } else if (write_stall_condition == WriteStallCondition::kStopped &&
-               write_stall_cause == WriteStallCause::kL0FileCountLimit) {
+    } else if (!mutable_cf_options.disable_auto_compactions &&
+               vstorage->l0_delay_trigger_count() >=
+                   mutable_cf_options.level0_stop_writes_trigger) {
       write_controller_token_ = write_controller->GetStopToken();
       internal_stats_->AddCFStats(InternalStats::L0_FILE_COUNT_LIMIT_STOPS, 1);
+      write_stall_condition = WriteStallCondition::kStopped;
       if (compaction_picker_->IsLevel0CompactionInProgress()) {
         internal_stats_->AddCFStats(
             InternalStats::LOCKED_L0_FILE_COUNT_LIMIT_STOPS, 1);
@@ -708,23 +666,28 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
       ROCKS_LOG_WARN(ioptions_.info_log,
                      "[%s] Stopping writes because we have %d level-0 files",
                      name_.c_str(), vstorage->l0_delay_trigger_count());
-    } else if (write_stall_condition == WriteStallCondition::kStopped &&
-               write_stall_cause == WriteStallCause::kPendingCompactionBytes) {
+    } else if (!mutable_cf_options.disable_auto_compactions &&
+               mutable_cf_options.hard_pending_compaction_bytes_limit > 0 &&
+               compaction_needed_bytes >=
+                   mutable_cf_options.hard_pending_compaction_bytes_limit) {
       write_controller_token_ = write_controller->GetStopToken();
       internal_stats_->AddCFStats(
           InternalStats::PENDING_COMPACTION_BYTES_LIMIT_STOPS, 1);
+      write_stall_condition = WriteStallCondition::kStopped;
       ROCKS_LOG_WARN(
           ioptions_.info_log,
           "[%s] Stopping writes because of estimated pending compaction "
           "bytes %" PRIu64,
           name_.c_str(), compaction_needed_bytes);
-    } else if (write_stall_condition == WriteStallCondition::kDelayed &&
-               write_stall_cause == WriteStallCause::kMemtableLimit) {
+    } else if (mutable_cf_options.max_write_buffer_number > 3 &&
+               imm()->NumNotFlushed() >=
+                   mutable_cf_options.max_write_buffer_number - 1) {
       write_controller_token_ =
           SetupDelay(write_controller, compaction_needed_bytes,
                      prev_compaction_needed_bytes_, was_stopped,
                      mutable_cf_options.disable_auto_compactions);
       internal_stats_->AddCFStats(InternalStats::MEMTABLE_LIMIT_SLOWDOWNS, 1);
+      write_stall_condition = WriteStallCondition::kDelayed;
       ROCKS_LOG_WARN(
           ioptions_.info_log,
           "[%s] Stalling writes because we have %d immutable memtables "
@@ -733,8 +696,10 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
           name_.c_str(), imm()->NumNotFlushed(),
           mutable_cf_options.max_write_buffer_number,
           write_controller->delayed_write_rate());
-    } else if (write_stall_condition == WriteStallCondition::kDelayed &&
-               write_stall_cause == WriteStallCause::kL0FileCountLimit) {
+    } else if (!mutable_cf_options.disable_auto_compactions &&
+               mutable_cf_options.level0_slowdown_writes_trigger >= 0 &&
+               vstorage->l0_delay_trigger_count() >=
+                   mutable_cf_options.level0_slowdown_writes_trigger) {
       // L0 is the last two files from stopping.
       bool near_stop = vstorage->l0_delay_trigger_count() >=
                        mutable_cf_options.level0_stop_writes_trigger - 2;
@@ -744,6 +709,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
                      mutable_cf_options.disable_auto_compactions);
       internal_stats_->AddCFStats(InternalStats::L0_FILE_COUNT_LIMIT_SLOWDOWNS,
                                   1);
+      write_stall_condition = WriteStallCondition::kDelayed;
       if (compaction_picker_->IsLevel0CompactionInProgress()) {
         internal_stats_->AddCFStats(
             InternalStats::LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS, 1);
@@ -753,8 +719,10 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
                      "rate %" PRIu64,
                      name_.c_str(), vstorage->l0_delay_trigger_count(),
                      write_controller->delayed_write_rate());
-    } else if (write_stall_condition == WriteStallCondition::kDelayed &&
-               write_stall_cause == WriteStallCause::kPendingCompactionBytes) {
+    } else if (!mutable_cf_options.disable_auto_compactions &&
+               mutable_cf_options.soft_pending_compaction_bytes_limit > 0 &&
+               vstorage->estimated_compaction_needed_bytes() >=
+                   mutable_cf_options.soft_pending_compaction_bytes_limit) {
       // If the distance to hard limit is less than 1/4 of the gap between soft
       // and
       // hard bytes limit, we think it is near stop and speed up the slowdown.
@@ -772,6 +740,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
                      mutable_cf_options.disable_auto_compactions);
       internal_stats_->AddCFStats(
           InternalStats::PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS, 1);
+      write_stall_condition = WriteStallCondition::kDelayed;
       ROCKS_LOG_WARN(
           ioptions_.info_log,
           "[%s] Stalling writes because of estimated pending compaction "
@@ -779,7 +748,6 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
           name_.c_str(), vstorage->estimated_compaction_needed_bytes(),
           write_controller->delayed_write_rate());
     } else {
-      assert(write_stall_condition == WriteStallCondition::kNormal);
       if (vstorage->l0_delay_trigger_count() >=
           GetL0ThresholdSpeedupCompaction(
               mutable_cf_options.level0_file_num_compaction_trigger,
@@ -846,10 +814,6 @@ uint64_t ColumnFamilyData::GetTotalSstFilesSize() const {
   return VersionSet::GetTotalSstFilesSize(dummy_versions_);
 }
 
-uint64_t ColumnFamilyData::GetLiveSstFilesSize() const {
-  return current_->GetSstFilesSize();
-}
-
 MemTable* ColumnFamilyData::ConstructNewMemtable(
     const MutableCFOptions& mutable_cf_options, SequenceNumber earliest_seq) {
   return new MemTable(internal_comparator_, ioptions_, mutable_cf_options,
@@ -886,68 +850,6 @@ bool ColumnFamilyData::RangeOverlapWithCompaction(
       smallest_user_key, largest_user_key, level);
 }
 
-Status ColumnFamilyData::RangesOverlapWithMemtables(
-    const autovector<Range>& ranges, SuperVersion* super_version,
-    bool* overlap) {
-  assert(overlap != nullptr);
-  *overlap = false;
-  // Create an InternalIterator over all unflushed memtables
-  Arena arena;
-  ReadOptions read_opts;
-  read_opts.total_order_seek = true;
-  MergeIteratorBuilder merge_iter_builder(&internal_comparator_, &arena);
-  merge_iter_builder.AddIterator(
-      super_version->mem->NewIterator(read_opts, &arena));
-  super_version->imm->AddIterators(read_opts, &merge_iter_builder);
-  ScopedArenaIterator memtable_iter(merge_iter_builder.Finish());
-
-  std::vector<InternalIterator*> memtable_range_del_iters;
-  auto* active_range_del_iter =
-      super_version->mem->NewRangeTombstoneIterator(read_opts);
-  if (active_range_del_iter != nullptr) {
-    memtable_range_del_iters.push_back(active_range_del_iter);
-  }
-  super_version->imm->AddRangeTombstoneIterators(read_opts,
-                                                 &memtable_range_del_iters);
-  RangeDelAggregator range_del_agg(internal_comparator_, {} /* snapshots */,
-                                   false /* collapse_deletions */);
-  Status status;
-  {
-    std::unique_ptr<InternalIterator> memtable_range_del_iter(
-        NewMergingIterator(&internal_comparator_,
-                           memtable_range_del_iters.empty()
-                               ? nullptr
-                               : &memtable_range_del_iters[0],
-                           static_cast<int>(memtable_range_del_iters.size())));
-    status = range_del_agg.AddTombstones(std::move(memtable_range_del_iter));
-  }
-  for (size_t i = 0; i < ranges.size() && status.ok() && !*overlap; ++i) {
-    auto* vstorage = super_version->current->storage_info();
-    auto* ucmp = vstorage->InternalComparator()->user_comparator();
-    InternalKey range_start(ranges[i].start, kMaxSequenceNumber,
-                            kValueTypeForSeek);
-    memtable_iter->Seek(range_start.Encode());
-    status = memtable_iter->status();
-    ParsedInternalKey seek_result;
-    if (status.ok()) {
-      if (memtable_iter->Valid() &&
-          !ParseInternalKey(memtable_iter->key(), &seek_result)) {
-        status = Status::Corruption("DB have corrupted keys");
-      }
-    }
-    if (status.ok()) {
-      if (memtable_iter->Valid() &&
-          ucmp->Compare(seek_result.user_key, ranges[i].limit) <= 0) {
-        *overlap = true;
-      } else if (range_del_agg.IsRangeOverlapped(ranges[i].start,
-                                                 ranges[i].limit)) {
-        *overlap = true;
-      }
-    }
-  }
-  return status;
-}
-
 const int ColumnFamilyData::kCompactAllLevels = -1;
 const int ColumnFamilyData::kCompactToBaseLevel = -2;
 
@@ -966,7 +868,8 @@ Compaction* ColumnFamilyData::CompactRange(
 
 SuperVersion* ColumnFamilyData::GetReferencedSuperVersion(
     InstrumentedMutex* db_mutex) {
-  SuperVersion* sv = GetThreadLocalSuperVersion(db_mutex);
+  SuperVersion* sv = nullptr;
+  sv = GetThreadLocalSuperVersion(db_mutex);
   sv->Ref();
   if (!ReturnThreadLocalSuperVersion(sv)) {
     // This Unref() corresponds to the Ref() in GetThreadLocalSuperVersion()
@@ -980,6 +883,7 @@ SuperVersion* ColumnFamilyData::GetReferencedSuperVersion(
 
 SuperVersion* ColumnFamilyData::GetThreadLocalSuperVersion(
     InstrumentedMutex* db_mutex) {
+  SuperVersion* sv = nullptr;
   // The SuperVersion is cached in thread local storage to avoid acquiring
   // mutex when SuperVersion does not change since the last use. When a new
   // SuperVersion is installed, the compaction or flush thread cleans up
@@ -998,7 +902,7 @@ SuperVersion* ColumnFamilyData::GetThreadLocalSuperVersion(
   // should only keep kSVInUse before ReturnThreadLocalSuperVersion call
   // (if no Scrape happens).
   assert(ptr != SuperVersion::kSVInUse);
-  SuperVersion* sv = static_cast<SuperVersion*>(ptr);
+  sv = static_cast<SuperVersion*>(ptr);
   if (sv == SuperVersion::kSVObsolete ||
       sv->version_number != super_version_number_.load()) {
     RecordTick(ioptions_.statistics, NUMBER_SUPERVERSION_ACQUIRES);
@@ -1062,12 +966,6 @@ void ColumnFamilyData::InstallSuperVersion(
       RecalculateWriteStallConditions(mutable_cf_options);
 
   if (old_superversion != nullptr) {
-    // Reset SuperVersions cached in thread local storage.
-    // This should be done before old_superversion->Unref(). That's to ensure
-    // that local_sv_ never holds the last reference to SuperVersion, since
-    // it has no means to safely do SuperVersion cleanup.
-    ResetThreadLocalSuperVersions();
-
     if (old_superversion->mutable_cf_options.write_buffer_size !=
         mutable_cf_options.write_buffer_size) {
       mem_->UpdateWriteBufferSize(mutable_cf_options.write_buffer_size);
@@ -1083,6 +981,9 @@ void ColumnFamilyData::InstallSuperVersion(
       sv_context->superversions_to_free.push_back(old_superversion);
     }
   }
+
+  // Reset SuperVersions cached in thread local storage
+  ResetThreadLocalSuperVersions();
 }
 
 void ColumnFamilyData::ResetThreadLocalSuperVersions() {
@@ -1094,12 +995,10 @@ void ColumnFamilyData::ResetThreadLocalSuperVersions() {
       continue;
     }
     auto sv = static_cast<SuperVersion*>(ptr);
-    bool was_last_ref __attribute__((__unused__));
-    was_last_ref = sv->Unref();
-    // sv couldn't have been the last reference because
-    // ResetThreadLocalSuperVersions() is called before
-    // unref'ing super_version_.
-    assert(!was_last_ref);
+    if (sv->Unref()) {
+      sv->Cleanup();
+      delete sv;
+    }
   }
 }
 
@@ -1161,13 +1060,11 @@ ColumnFamilySet::~ColumnFamilySet() {
   while (column_family_data_.size() > 0) {
     // cfd destructor will delete itself from column_family_data_
     auto cfd = column_family_data_.begin()->second;
-    bool last_ref __attribute__((__unused__));
-    last_ref = cfd->Unref();
+    bool last_ref __attribute__((__unused__)) = cfd->Unref();
     assert(last_ref);
     delete cfd;
   }
-  bool dummy_last_ref __attribute__((__unused__));
-  dummy_last_ref = dummy_cfd_->Unref();
+  bool dummy_last_ref __attribute__((__unused__)) = dummy_cfd_->Unref();
   assert(dummy_last_ref);
   delete dummy_cfd_;
 }

db/column_family.h

@@ -30,7 +30,6 @@ namespace rocksdb {
 
 class Version;
 class VersionSet;
-class VersionStorageInfo;
 class MemTable;
 class MemTableListVersion;
 class CompactionPicker;
@@ -203,10 +202,6 @@ class ColumnFamilyData {
   void SetLogNumber(uint64_t log_number) { log_number_ = log_number; }
   uint64_t GetLogNumber() const { return log_number_; }
 
-  void SetFlushReason(FlushReason flush_reason) {
-    flush_reason_ = flush_reason;
-  }
-  FlushReason GetFlushReason() const { return flush_reason_; }
   // thread-safe
   const EnvOptions* soptions() const;
   const ImmutableCFOptions* ioptions() const { return &ioptions_; }
@@ -244,7 +239,6 @@ class ColumnFamilyData {
   void SetCurrent(Version* _current);
   uint64_t GetNumLiveVersions() const;  // REQUIRE: DB mutex held
   uint64_t GetTotalSstFilesSize() const;  // REQUIRE: DB mutex held
-  uint64_t GetLiveSstFilesSize() const;   // REQUIRE: DB mutex held
   void SetMemtable(MemTable* new_mem) {
     uint64_t memtable_id = last_memtable_id_.fetch_add(1) + 1;
     new_mem->SetID(memtable_id);
@@ -275,16 +269,6 @@ class ColumnFamilyData {
                                   const Slice& largest_user_key,
                                   int level) const;
 
-  // Check if the passed ranges overlap with any unflushed memtables
-  // (immutable or mutable).
-  //
-  // @param super_version A referenced SuperVersion that will be held for the
-  //    duration of this function.
-  //
-  // Thread-safe
-  Status RangesOverlapWithMemtables(const autovector<Range>& ranges,
-                                    SuperVersion* super_version, bool* overlap);
-
   // A flag to tell a manual compaction is to compact all levels together
   // instead of a specific level.
   static const int kCompactAllLevels;
@@ -347,17 +331,6 @@ class ColumnFamilyData {
   bool pending_flush() { return pending_flush_; }
   bool pending_compaction() { return pending_compaction_; }
 
-  enum class WriteStallCause {
-    kNone,
-    kMemtableLimit,
-    kL0FileCountLimit,
-    kPendingCompactionBytes,
-  };
-  static std::pair<WriteStallCondition, WriteStallCause>
-  GetWriteStallConditionAndCause(int num_unflushed_memtables, int num_l0_files,
-                                 uint64_t num_compaction_needed_bytes,
-                                 const MutableCFOptions& mutable_cf_options);
-
   // Recalculate some small conditions, which are changed only during
   // compaction, adding new memtable and/or
   // recalculation of compaction score. These values are used in
@@ -431,8 +404,6 @@ class ColumnFamilyData {
   // recovered from
   uint64_t log_number_;
 
-  std::atomic<FlushReason> flush_reason_;
-
   // An object that keeps all the compaction stats
   // and picks the next compaction
   std::unique_ptr<CompactionPicker> compaction_picker_;

db/column_family_test.cc

@@ -1168,14 +1168,13 @@ TEST_F(ColumnFamilyTest, MemtableNotSupportSnapshot) {
 #endif  // !ROCKSDB_LITE
 
 class TestComparator : public Comparator {
-  int Compare(const rocksdb::Slice& /*a*/,
-              const rocksdb::Slice& /*b*/) const override {
+  int Compare(const rocksdb::Slice& a, const rocksdb::Slice& b) const override {
     return 0;
   }
   const char* Name() const override { return "Test"; }
-  void FindShortestSeparator(std::string* /*start*/,
-                             const rocksdb::Slice& /*limit*/) const override {}
-  void FindShortSuccessor(std::string* /*key*/) const override {}
+  void FindShortestSeparator(std::string* start,
+                             const rocksdb::Slice& limit) const override {}
+  void FindShortSuccessor(std::string* key) const override {}
 };
 
 static TestComparator third_comparator;

db/compact_files_test.cc

@@ -37,7 +37,8 @@ class FlushedFileCollector : public EventListener {
   FlushedFileCollector() {}
   ~FlushedFileCollector() {}
 
-  virtual void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
+  virtual void OnFlushCompleted(
+      DB* db, const FlushJobInfo& info) override {
     std::lock_guard<std::mutex> lock(mutex_);
     flushed_files_.push_back(info.file_path);
   }
@@ -256,9 +257,9 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) {
 TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
   class FilterWithGet : public CompactionFilter {
    public:
-    virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                        const Slice& /*value*/, std::string* /*new_value*/,
-                        bool* /*value_changed*/) const override {
+    virtual bool Filter(int level, const Slice& key, const Slice& value,
+                        std::string* new_value,
+                        bool* value_changed) const override {
       if (db_ == nullptr) {
         return true;
       }

db/compacted_db_impl.h

@@ -32,56 +32,55 @@ class CompactedDBImpl : public DBImpl {
     override;
 
   using DBImpl::Put;
-  virtual Status Put(const WriteOptions& /*options*/,
-                     ColumnFamilyHandle* /*column_family*/,
-                     const Slice& /*key*/, const Slice& /*value*/) override {
+  virtual Status Put(const WriteOptions& options,
+                     ColumnFamilyHandle* column_family, const Slice& key,
+                     const Slice& value) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
   using DBImpl::Merge;
-  virtual Status Merge(const WriteOptions& /*options*/,
-                       ColumnFamilyHandle* /*column_family*/,
-                       const Slice& /*key*/, const Slice& /*value*/) override {
+  virtual Status Merge(const WriteOptions& options,
+                       ColumnFamilyHandle* column_family, const Slice& key,
+                       const Slice& value) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
   using DBImpl::Delete;
-  virtual Status Delete(const WriteOptions& /*options*/,
-                        ColumnFamilyHandle* /*column_family*/,
-                        const Slice& /*key*/) override {
+  virtual Status Delete(const WriteOptions& options,
+                        ColumnFamilyHandle* column_family,
+                        const Slice& key) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
-  virtual Status Write(const WriteOptions& /*options*/,
-                       WriteBatch* /*updates*/) override {
+  virtual Status Write(const WriteOptions& options,
+                       WriteBatch* updates) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
   using DBImpl::CompactRange;
-  virtual Status CompactRange(const CompactRangeOptions& /*options*/,
-                              ColumnFamilyHandle* /*column_family*/,
-                              const Slice* /*begin*/,
-                              const Slice* /*end*/) override {
+  virtual Status CompactRange(const CompactRangeOptions& options,
+                              ColumnFamilyHandle* column_family,
+                              const Slice* begin, const Slice* end) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
 
   virtual Status DisableFileDeletions() override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
-  virtual Status EnableFileDeletions(bool /*force*/) override {
+  virtual Status EnableFileDeletions(bool force) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
   virtual Status GetLiveFiles(std::vector<std::string>&,
-                              uint64_t* /*manifest_file_size*/,
-                              bool /*flush_memtable*/ = true) override {
+                              uint64_t* manifest_file_size,
+                              bool flush_memtable = true) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
   using DBImpl::Flush;
-  virtual Status Flush(const FlushOptions& /*options*/,
-                       ColumnFamilyHandle* /*column_family*/) override {
+  virtual Status Flush(const FlushOptions& options,
+                       ColumnFamilyHandle* column_family) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
   using DB::IngestExternalFile;
   virtual Status IngestExternalFile(
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*external_files*/,
-      const IngestExternalFileOptions& /*ingestion_options*/) override {
+      ColumnFamilyHandle* column_family,
+      const std::vector<std::string>& external_files,
+      const IngestExternalFileOptions& ingestion_options) override {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
 

db/compaction_iterator.cc

@@ -12,6 +12,31 @@
 
 namespace rocksdb {
 
+#ifndef ROCKSDB_LITE
+CompactionEventListener::CompactionListenerValueType fromInternalValueType(
+    ValueType vt) {
+  switch (vt) {
+    case kTypeDeletion:
+      return CompactionEventListener::CompactionListenerValueType::kDelete;
+    case kTypeValue:
+      return CompactionEventListener::CompactionListenerValueType::kValue;
+    case kTypeMerge:
+      return CompactionEventListener::CompactionListenerValueType::
+          kMergeOperand;
+    case kTypeSingleDeletion:
+      return CompactionEventListener::CompactionListenerValueType::
+          kSingleDelete;
+    case kTypeRangeDeletion:
+      return CompactionEventListener::CompactionListenerValueType::kRangeDelete;
+    case kTypeBlobIndex:
+      return CompactionEventListener::CompactionListenerValueType::kBlobIndex;
+    default:
+      assert(false);
+      return CompactionEventListener::CompactionListenerValueType::kInvalid;
+  }
+}
+#endif  // ROCKSDB_LITE
+
 CompactionIterator::CompactionIterator(
     InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
     SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
@@ -19,6 +44,7 @@ CompactionIterator::CompactionIterator(
     const SnapshotChecker* snapshot_checker, Env* env,
     bool expect_valid_internal_key, RangeDelAggregator* range_del_agg,
     const Compaction* compaction, const CompactionFilter* compaction_filter,
+    CompactionEventListener* compaction_listener,
     const std::atomic<bool>* shutting_down,
     const SequenceNumber preserve_deletes_seqnum)
     : CompactionIterator(
@@ -27,18 +53,21 @@ CompactionIterator::CompactionIterator(
           expect_valid_internal_key, range_del_agg,
           std::unique_ptr<CompactionProxy>(
               compaction ? new CompactionProxy(compaction) : nullptr),
-          compaction_filter, shutting_down, preserve_deletes_seqnum) {}
+          compaction_filter, compaction_listener, shutting_down,
+          preserve_deletes_seqnum) {}
 
 CompactionIterator::CompactionIterator(
     InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
-    SequenceNumber /*last_sequence*/, std::vector<SequenceNumber>* snapshots,
+    SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
     SequenceNumber earliest_write_conflict_snapshot,
     const SnapshotChecker* snapshot_checker, Env* env,
     bool expect_valid_internal_key, RangeDelAggregator* range_del_agg,
     std::unique_ptr<CompactionProxy> compaction,
     const CompactionFilter* compaction_filter,
+    CompactionEventListener* compaction_listener,
     const std::atomic<bool>* shutting_down,
-    const SequenceNumber preserve_deletes_seqnum)
+    const SequenceNumber preserve_deletes_seqnum
+  )
     : input_(input),
       cmp_(cmp),
       merge_helper_(merge_helper),
@@ -50,6 +79,9 @@ CompactionIterator::CompactionIterator(
       range_del_agg_(range_del_agg),
       compaction_(std::move(compaction)),
       compaction_filter_(compaction_filter),
+#ifndef ROCKSDB_LITE
+      compaction_listener_(compaction_listener),
+#endif  // ROCKSDB_LITE
       shutting_down_(shutting_down),
       preserve_deletes_seqnum_(preserve_deletes_seqnum),
       ignore_snapshots_(false),
@@ -261,12 +293,28 @@ void CompactionIterator::NextFromInput() {
           (snapshot_checker_ == nullptr ||
            snapshot_checker_->IsInSnapshot(ikey_.sequence, kMaxSequenceNumber));
 
+#ifndef ROCKSDB_LITE
+      if (compaction_listener_) {
+        compaction_listener_->OnCompaction(compaction_->level(), ikey_.user_key,
+                                           fromInternalValueType(ikey_.type),
+                                           value_, ikey_.sequence, true);
+      }
+#endif  // !ROCKSDB_LITE
+
       // Apply the compaction filter to the first committed version of the user
       // key.
       if (current_key_committed_) {
         InvokeFilterIfNeeded(&need_skip, &skip_until);
       }
     } else {
+#ifndef ROCKSDB_LITE
+      if (compaction_listener_) {
+        compaction_listener_->OnCompaction(compaction_->level(), ikey_.user_key,
+                                           fromInternalValueType(ikey_.type),
+                                           value_, ikey_.sequence, false);
+      }
+#endif  // ROCKSDB_LITE
+
       // Update the current key to reflect the new sequence number/type without
       // copying the user key.
       // TODO(rven): Compaction filter does not process keys in this path
@@ -489,11 +537,6 @@ void CompactionIterator::NextFromInput() {
       //
       // Note:  Dropping this Delete will not affect TransactionDB
       // write-conflict checking since it is earlier than any snapshot.
-      //
-      // It seems that we can also drop deletion later than earliest snapshot
-      // given that:
-      // (1) The deletion is earlier than earliest_write_conflict_snapshot, and
-      // (2) No value exist earlier than the deletion.
       ++iter_stats_.num_record_drop_obsolete;
       if (!bottommost_level_) {
         ++iter_stats_.num_optimized_del_drop_obsolete;
@@ -511,6 +554,10 @@ void CompactionIterator::NextFromInput() {
       // have hit (A)
       // We encapsulate the merge related state machine in a different
       // object to minimize change to the existing flow.
+      // In case snapshot_checker is present, we can probably merge further
+      // beyond prev_snapshot, since there could be more keys with sequence
+      // smaller than prev_snapshot, but reported by snapshot_checker as not
+      // visible by prev_snapshot. But it will make the logic more complicated.
       Status s = merge_helper_->MergeUntil(input_, range_del_agg_,
                                            prev_snapshot, bottommost_level_);
       merge_out_iter_.SeekToFirst();
@@ -574,12 +621,9 @@ void CompactionIterator::PrepareOutput() {
   // and the earliest snapshot is larger than this seqno
   // and the userkey differs from the last userkey in compaction
   // then we can squash the seqno to zero.
-  //
+
   // This is safe for TransactionDB write-conflict checking since transactions
   // only care about sequence number larger than any active snapshots.
-  //
-  // Can we do the same for levels above bottom level as long as
-  // KeyNotExistsBeyondOutputLevel() return true?
   if ((compaction_ != nullptr &&
       !compaction_->allow_ingest_behind()) &&
       ikeyNotNeededForIncrementalSnapshot() &&

db/compaction_iterator.h

@@ -20,6 +20,8 @@
 
 namespace rocksdb {
 
+class CompactionEventListener;
+
 class CompactionIterator {
  public:
   // A wrapper around Compaction. Has a much smaller interface, only what
@@ -30,7 +32,7 @@ class CompactionIterator {
         : compaction_(compaction) {}
 
     virtual ~CompactionProxy() = default;
-    virtual int level(size_t /*compaction_input_level*/ = 0) const {
+    virtual int level(size_t compaction_input_level = 0) const {
       return compaction_->level();
     }
     virtual bool KeyNotExistsBeyondOutputLevel(
@@ -67,6 +69,7 @@ class CompactionIterator {
                      RangeDelAggregator* range_del_agg,
                      const Compaction* compaction = nullptr,
                      const CompactionFilter* compaction_filter = nullptr,
+                     CompactionEventListener* compaction_listener = nullptr,
                      const std::atomic<bool>* shutting_down = nullptr,
                      const SequenceNumber preserve_deletes_seqnum = 0);
 
@@ -80,6 +83,7 @@ class CompactionIterator {
                      RangeDelAggregator* range_del_agg,
                      std::unique_ptr<CompactionProxy> compaction,
                      const CompactionFilter* compaction_filter = nullptr,
+                     CompactionEventListener* compaction_listener = nullptr,
                      const std::atomic<bool>* shutting_down = nullptr,
                      const SequenceNumber preserve_deletes_seqnum = 0);
 
@@ -143,6 +147,9 @@ class CompactionIterator {
   RangeDelAggregator* range_del_agg_;
   std::unique_ptr<CompactionProxy> compaction_;
   const CompactionFilter* compaction_filter_;
+#ifndef ROCKSDB_LITE
+  CompactionEventListener* compaction_listener_;
+#endif  // !ROCKSDB_LITE
   const std::atomic<bool>* shutting_down_;
   const SequenceNumber preserve_deletes_seqnum_;
   bool bottommost_level_;

db/compaction_iterator_test.cc

@@ -9,25 +9,23 @@
 #include <vector>
 
 #include "port/port.h"
-#include "util/string_util.h"
 #include "util/testharness.h"
 #include "util/testutil.h"
-#include "utilities/merge_operators.h"
 
 namespace rocksdb {
 
 // Expects no merging attempts.
 class NoMergingMergeOp : public MergeOperator {
  public:
-  bool FullMergeV2(const MergeOperationInput& /*merge_in*/,
-                   MergeOperationOutput* /*merge_out*/) const override {
+  bool FullMergeV2(const MergeOperationInput& merge_in,
+                   MergeOperationOutput* merge_out) const override {
     ADD_FAILURE();
     return false;
   }
-  bool PartialMergeMulti(const Slice& /*key*/,
-                         const std::deque<Slice>& /*operand_list*/,
-                         std::string* /*new_value*/,
-                         Logger* /*logger*/) const override {
+  bool PartialMergeMulti(const Slice& key,
+                         const std::deque<Slice>& operand_list,
+                         std::string* new_value,
+                         Logger* logger) const override {
     ADD_FAILURE();
     return false;
   }
@@ -41,9 +39,9 @@ class NoMergingMergeOp : public MergeOperator {
 // Always returns Decition::kRemove.
 class StallingFilter : public CompactionFilter {
  public:
-  Decision FilterV2(int /*level*/, const Slice& key, ValueType /*type*/,
-                    const Slice& /*existing_value*/, std::string* /*new_value*/,
-                    std::string* /*skip_until*/) const override {
+  virtual Decision FilterV2(int level, const Slice& key, ValueType t,
+                            const Slice& existing_value, std::string* new_value,
+                            std::string* skip_until) const override {
     int k = std::atoi(key.ToString().c_str());
     last_seen.store(k);
     while (k >= stall_at.load()) {
@@ -74,18 +72,6 @@ class StallingFilter : public CompactionFilter {
   mutable std::atomic<int> last_seen{0};
 };
 
-// Compaction filter that filter out all keys.
-class FilterAllKeysCompactionFilter : public CompactionFilter {
- public:
-  Decision FilterV2(int /*level*/, const Slice& /*key*/, ValueType /*type*/,
-                    const Slice& /*existing_value*/, std::string* /*new_value*/,
-                    std::string* /*skip_until*/) const override {
-    return Decision::kRemove;
-  }
-
-  const char* Name() const override { return "AllKeysCompactionFilter"; }
-};
-
 class LoggingForwardVectorIterator : public InternalIterator {
  public:
   struct Action {
@@ -126,7 +112,7 @@ class LoggingForwardVectorIterator : public InternalIterator {
                keys_.begin();
   }
 
-  virtual void SeekForPrev(const Slice& /*target*/) override { assert(false); }
+  virtual void SeekForPrev(const Slice& target) override { assert(false); }
 
   virtual void Next() override {
     assert(Valid());
@@ -158,149 +144,76 @@ class FakeCompaction : public CompactionIterator::CompactionProxy {
  public:
   FakeCompaction() = default;
 
-  virtual int level(size_t /*compaction_input_level*/) const override {
-    return 0;
-  }
+  virtual int level(size_t compaction_input_level) const { return 0; }
   virtual bool KeyNotExistsBeyondOutputLevel(
-      const Slice& /*user_key*/,
-      std::vector<size_t>* /*level_ptrs*/) const override {
-    return is_bottommost_level || key_not_exists_beyond_output_level;
+      const Slice& user_key, std::vector<size_t>* level_ptrs) const {
+    return key_not_exists_beyond_output_level;
   }
-  virtual bool bottommost_level() const override { return is_bottommost_level; }
-  virtual int number_levels() const override { return 1; }
-  virtual Slice GetLargestUserKey() const override {
+  virtual bool bottommost_level() const { return false; }
+  virtual int number_levels() const { return 1; }
+  virtual Slice GetLargestUserKey() const {
     return "\xff\xff\xff\xff\xff\xff\xff\xff\xff";
   }
-  virtual bool allow_ingest_behind() const override { return false; }
+  virtual bool allow_ingest_behind() const { return false; }
 
-  virtual bool preserve_deletes() const override { return false; }
+  virtual bool preserve_deletes() const {return false; }
 
   bool key_not_exists_beyond_output_level = false;
-
-  bool is_bottommost_level = false;
 };
 
-// A simplifed snapshot checker which assumes each snapshot has a global
-// last visible sequence.
-class TestSnapshotChecker : public SnapshotChecker {
- public:
-  explicit TestSnapshotChecker(
-      SequenceNumber last_committed_sequence,
-      const std::unordered_map<SequenceNumber, SequenceNumber>& snapshots = {})
-      : last_committed_sequence_(last_committed_sequence),
-        snapshots_(snapshots) {}
-
-  bool IsInSnapshot(SequenceNumber seq,
-                    SequenceNumber snapshot_seq) const override {
-    if (snapshot_seq == kMaxSequenceNumber) {
-      return seq <= last_committed_sequence_;
-    }
-    assert(snapshots_.count(snapshot_seq) > 0);
-    return seq <= snapshots_.at(snapshot_seq);
-  }
-
- private:
-  SequenceNumber last_committed_sequence_;
-  // A map of valid snapshot to last visible sequence to the snapshot.
-  std::unordered_map<SequenceNumber, SequenceNumber> snapshots_;
-};
-
-// Test param:
-//   bool: whether to pass snapshot_checker to compaction iterator.
-class CompactionIteratorTest : public testing::TestWithParam<bool> {
+class CompactionIteratorTest : public testing::Test {
  public:
   CompactionIteratorTest()
       : cmp_(BytewiseComparator()), icmp_(cmp_), snapshots_({}) {}
 
-  void InitIterators(
-      const std::vector<std::string>& ks, const std::vector<std::string>& vs,
-      const std::vector<std::string>& range_del_ks,
-      const std::vector<std::string>& range_del_vs,
-      SequenceNumber last_sequence,
-      SequenceNumber last_committed_sequence = kMaxSequenceNumber,
-      MergeOperator* merge_op = nullptr, CompactionFilter* filter = nullptr,
-      bool bottommost_level = false,
-      SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber) {
+  void InitIterators(const std::vector<std::string>& ks,
+                     const std::vector<std::string>& vs,
+                     const std::vector<std::string>& range_del_ks,
+                     const std::vector<std::string>& range_del_vs,
+                     SequenceNumber last_sequence,
+                     MergeOperator* merge_op = nullptr,
+                     CompactionFilter* filter = nullptr) {
     std::unique_ptr<InternalIterator> range_del_iter(
         new test::VectorIterator(range_del_ks, range_del_vs));
     range_del_agg_.reset(new RangeDelAggregator(icmp_, snapshots_));
     ASSERT_OK(range_del_agg_->AddTombstones(std::move(range_del_iter)));
 
     std::unique_ptr<CompactionIterator::CompactionProxy> compaction;
-    if (filter || bottommost_level) {
+    if (filter) {
       compaction_proxy_ = new FakeCompaction();
-      compaction_proxy_->is_bottommost_level = bottommost_level;
       compaction.reset(compaction_proxy_);
     }
-    bool use_snapshot_checker = UseSnapshotChecker() || GetParam();
-    if (use_snapshot_checker || last_committed_sequence < kMaxSequenceNumber) {
-      snapshot_checker_.reset(
-          new TestSnapshotChecker(last_committed_sequence, snapshot_map_));
-    }
-    merge_helper_.reset(
-        new MergeHelper(Env::Default(), cmp_, merge_op, filter, nullptr, false,
-                        0 /*latest_snapshot*/, snapshot_checker_.get(),
-                        0 /*level*/, nullptr /*statistics*/, &shutting_down_));
+    // TODO(yiwu) add a mock snapshot checker and add test for it.
+    SnapshotChecker* snapshot_checker = nullptr;
 
+    merge_helper_.reset(new MergeHelper(Env::Default(), cmp_, merge_op, filter,
+                                        nullptr, false, 0, 0, nullptr,
+                                        &shutting_down_));
     iter_.reset(new LoggingForwardVectorIterator(ks, vs));
     iter_->SeekToFirst();
     c_iter_.reset(new CompactionIterator(
         iter_.get(), cmp_, merge_helper_.get(), last_sequence, &snapshots_,
-        earliest_write_conflict_snapshot, snapshot_checker_.get(),
-        Env::Default(), false, range_del_agg_.get(), std::move(compaction),
-        filter, &shutting_down_));
+        kMaxSequenceNumber, snapshot_checker, Env::Default(), false,
+        range_del_agg_.get(), std::move(compaction), filter, nullptr,
+        &shutting_down_));
   }
 
-  void AddSnapshot(SequenceNumber snapshot,
-                   SequenceNumber last_visible_seq = kMaxSequenceNumber) {
-    snapshots_.push_back(snapshot);
-    snapshot_map_[snapshot] = last_visible_seq;
-  }
-
-  virtual bool UseSnapshotChecker() const { return false; }
-
-  void RunTest(
-      const std::vector<std::string>& input_keys,
-      const std::vector<std::string>& input_values,
-      const std::vector<std::string>& expected_keys,
-      const std::vector<std::string>& expected_values,
-      SequenceNumber last_committed_seq = kMaxSequenceNumber,
-      MergeOperator* merge_operator = nullptr,
-      CompactionFilter* compaction_filter = nullptr,
-      bool bottommost_level = false,
-      SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber) {
-    InitIterators(input_keys, input_values, {}, {}, kMaxSequenceNumber,
-                  last_committed_seq, merge_operator, compaction_filter,
-                  bottommost_level, earliest_write_conflict_snapshot);
-    c_iter_->SeekToFirst();
-    for (size_t i = 0; i < expected_keys.size(); i++) {
-      std::string info = "i = " + ToString(i);
-      ASSERT_TRUE(c_iter_->Valid()) << info;
-      ASSERT_OK(c_iter_->status()) << info;
-      ASSERT_EQ(expected_keys[i], c_iter_->key().ToString()) << info;
-      ASSERT_EQ(expected_values[i], c_iter_->value().ToString()) << info;
-      c_iter_->Next();
-    }
-    ASSERT_FALSE(c_iter_->Valid());
-  }
+  void AddSnapshot(SequenceNumber snapshot) { snapshots_.push_back(snapshot); }
 
   const Comparator* cmp_;
   const InternalKeyComparator icmp_;
   std::vector<SequenceNumber> snapshots_;
-  // A map of valid snapshot to last visible sequence to the snapshot.
-  std::unordered_map<SequenceNumber, SequenceNumber> snapshot_map_;
   std::unique_ptr<MergeHelper> merge_helper_;
   std::unique_ptr<LoggingForwardVectorIterator> iter_;
   std::unique_ptr<CompactionIterator> c_iter_;
   std::unique_ptr<RangeDelAggregator> range_del_agg_;
-  std::unique_ptr<SnapshotChecker> snapshot_checker_;
   std::atomic<bool> shutting_down_{false};
   FakeCompaction* compaction_proxy_;
 };
 
 // It is possible that the output of the compaction iterator is empty even if
 // the input is not.
-TEST_P(CompactionIteratorTest, EmptyResult) {
+TEST_F(CompactionIteratorTest, EmptyResult) {
   InitIterators({test::KeyStr("a", 5, kTypeSingleDeletion),
                  test::KeyStr("a", 3, kTypeValue)},
                 {"", "val"}, {}, {}, 5);
@@ -310,7 +223,7 @@ TEST_P(CompactionIteratorTest, EmptyResult) {
 
 // If there is a corruption after a single deletion, the corrupted key should
 // be preserved.
-TEST_P(CompactionIteratorTest, CorruptionAfterSingleDeletion) {
+TEST_F(CompactionIteratorTest, CorruptionAfterSingleDeletion) {
   InitIterators({test::KeyStr("a", 5, kTypeSingleDeletion),
                  test::KeyStr("a", 3, kTypeValue, true),
                  test::KeyStr("b", 10, kTypeValue)},
@@ -329,7 +242,7 @@ TEST_P(CompactionIteratorTest, CorruptionAfterSingleDeletion) {
   ASSERT_FALSE(c_iter_->Valid());
 }
 
-TEST_P(CompactionIteratorTest, SimpleRangeDeletion) {
+TEST_F(CompactionIteratorTest, SimpleRangeDeletion) {
   InitIterators({test::KeyStr("morning", 5, kTypeValue),
                  test::KeyStr("morning", 2, kTypeValue),
                  test::KeyStr("night", 3, kTypeValue)},
@@ -345,7 +258,7 @@ TEST_P(CompactionIteratorTest, SimpleRangeDeletion) {
   ASSERT_FALSE(c_iter_->Valid());
 }
 
-TEST_P(CompactionIteratorTest, RangeDeletionWithSnapshots) {
+TEST_F(CompactionIteratorTest, RangeDeletionWithSnapshots) {
   AddSnapshot(10);
   std::vector<std::string> ks1;
   ks1.push_back(test::KeyStr("ma", 28, kTypeRangeDeletion));
@@ -366,11 +279,11 @@ TEST_P(CompactionIteratorTest, RangeDeletionWithSnapshots) {
   ASSERT_FALSE(c_iter_->Valid());
 }
 
-TEST_P(CompactionIteratorTest, CompactionFilterSkipUntil) {
+TEST_F(CompactionIteratorTest, CompactionFilterSkipUntil) {
   class Filter : public CompactionFilter {
-    virtual Decision FilterV2(int /*level*/, const Slice& key, ValueType t,
+    virtual Decision FilterV2(int level, const Slice& key, ValueType t,
                               const Slice& existing_value,
-                              std::string* /*new_value*/,
+                              std::string* new_value,
                               std::string* skip_until) const override {
       std::string k = key.ToString();
       std::string v = existing_value.ToString();
@@ -441,7 +354,7 @@ TEST_P(CompactionIteratorTest, CompactionFilterSkipUntil) {
        test::KeyStr("j", 99, kTypeValue)},
       {"av50", "am45", "bv60", "bv40", "cv35", "dm70", "em71", "fm65", "fm30",
        "fv25", "gv90", "hv91", "im95", "jv99"},
-      {}, {}, kMaxSequenceNumber, kMaxSequenceNumber, &merge_op, &filter);
+      {}, {}, kMaxSequenceNumber, &merge_op, &filter);
 
   // Compaction should output just "a", "e" and "h" keys.
   c_iter_->SeekToFirst();
@@ -476,14 +389,13 @@ TEST_P(CompactionIteratorTest, CompactionFilterSkipUntil) {
   ASSERT_EQ(expected_actions, iter_->log);
 }
 
-TEST_P(CompactionIteratorTest, ShuttingDownInFilter) {
+TEST_F(CompactionIteratorTest, ShuttingDownInFilter) {
   NoMergingMergeOp merge_op;
   StallingFilter filter;
   InitIterators(
       {test::KeyStr("1", 1, kTypeValue), test::KeyStr("2", 2, kTypeValue),
        test::KeyStr("3", 3, kTypeValue), test::KeyStr("4", 4, kTypeValue)},
-      {"v1", "v2", "v3", "v4"}, {}, {}, kMaxSequenceNumber, kMaxSequenceNumber,
-      &merge_op, &filter);
+      {"v1", "v2", "v3", "v4"}, {}, {}, kMaxSequenceNumber, &merge_op, &filter);
   // Don't leave tombstones (kTypeDeletion) for filtered keys.
   compaction_proxy_->key_not_exists_beyond_output_level = true;
 
@@ -514,14 +426,13 @@ TEST_P(CompactionIteratorTest, ShuttingDownInFilter) {
 
 // Same as ShuttingDownInFilter, but shutdown happens during filter call for
 // a merge operand, not for a value.
-TEST_P(CompactionIteratorTest, ShuttingDownInMerge) {
+TEST_F(CompactionIteratorTest, ShuttingDownInMerge) {
   NoMergingMergeOp merge_op;
   StallingFilter filter;
   InitIterators(
       {test::KeyStr("1", 1, kTypeValue), test::KeyStr("2", 2, kTypeMerge),
        test::KeyStr("3", 3, kTypeMerge), test::KeyStr("4", 4, kTypeValue)},
-      {"v1", "v2", "v3", "v4"}, {}, {}, kMaxSequenceNumber, kMaxSequenceNumber,
-      &merge_op, &filter);
+      {"v1", "v2", "v3", "v4"}, {}, {}, kMaxSequenceNumber, &merge_op, &filter);
   compaction_proxy_->key_not_exists_beyond_output_level = true;
 
   std::atomic<bool> seek_done{false};
@@ -549,12 +460,12 @@ TEST_P(CompactionIteratorTest, ShuttingDownInMerge) {
   EXPECT_EQ(2, filter.last_seen.load());
 }
 
-TEST_P(CompactionIteratorTest, SingleMergeOperand) {
+TEST_F(CompactionIteratorTest, SingleMergeOperand) {
   class Filter : public CompactionFilter {
-    virtual Decision FilterV2(int /*level*/, const Slice& key, ValueType t,
+    virtual Decision FilterV2(int level, const Slice& key, ValueType t,
                               const Slice& existing_value,
-                              std::string* /*new_value*/,
-                              std::string* /*skip_until*/) const override {
+                              std::string* new_value,
+                              std::string* skip_until) const override {
       std::string k = key.ToString();
       std::string v = existing_value.ToString();
 
@@ -605,7 +516,7 @@ TEST_P(CompactionIteratorTest, SingleMergeOperand) {
     bool PartialMergeMulti(const Slice& key,
                            const std::deque<Slice>& operand_list,
                            std::string* new_value,
-                           Logger* /*logger*/) const override {
+                           Logger* logger) const override {
       std::string string_key = key.ToString();
       EXPECT_TRUE(string_key == "a" || string_key == "b");
 
@@ -641,7 +552,7 @@ TEST_P(CompactionIteratorTest, SingleMergeOperand) {
        // c should invoke FullMerge due to kTypeValue at the beginning.
        test::KeyStr("c", 90, kTypeMerge), test::KeyStr("c", 80, kTypeValue)},
       {"av1", "bv2", "bv1", "cv2", "cv1"}, {}, {}, kMaxSequenceNumber,
-      kMaxSequenceNumber, &merge_op, &filter);
+      &merge_op, &filter);
 
   c_iter_->SeekToFirst();
   ASSERT_TRUE(c_iter_->Valid());
@@ -654,298 +565,6 @@ TEST_P(CompactionIteratorTest, SingleMergeOperand) {
   ASSERT_EQ("cv1cv2", c_iter_->value().ToString());
 }
 
-// In bottommost level, values earlier than earliest snapshot can be output
-// with sequence = 0.
-TEST_P(CompactionIteratorTest, ZeroOutSequenceAtBottomLevel) {
-  AddSnapshot(1);
-  RunTest({test::KeyStr("a", 1, kTypeValue), test::KeyStr("b", 2, kTypeValue)},
-          {"v1", "v2"},
-          {test::KeyStr("a", 0, kTypeValue), test::KeyStr("b", 2, kTypeValue)},
-          {"v1", "v2"}, kMaxSequenceNumber /*last_commited_seq*/,
-          nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
-          true /*bottommost_level*/);
-}
-
-// In bottommost level, deletions earlier than earliest snapshot can be removed
-// permanently.
-TEST_P(CompactionIteratorTest, RemoveDeletionAtBottomLevel) {
-  AddSnapshot(1);
-  RunTest({test::KeyStr("a", 1, kTypeDeletion),
-           test::KeyStr("b", 2, kTypeDeletion)},
-          {"", ""}, {test::KeyStr("b", 2, kTypeDeletion)}, {""},
-          kMaxSequenceNumber /*last_commited_seq*/, nullptr /*merge_operator*/,
-          nullptr /*compaction_filter*/, true /*bottommost_level*/);
-}
-
-// In bottommost level, single deletions earlier than earliest snapshot can be
-// removed permanently.
-TEST_P(CompactionIteratorTest, RemoveSingleDeletionAtBottomLevel) {
-  AddSnapshot(1);
-  RunTest({test::KeyStr("a", 1, kTypeSingleDeletion),
-           test::KeyStr("b", 2, kTypeSingleDeletion)},
-          {"", ""}, {test::KeyStr("b", 2, kTypeSingleDeletion)}, {""},
-          kMaxSequenceNumber /*last_commited_seq*/, nullptr /*merge_operator*/,
-          nullptr /*compaction_filter*/, true /*bottommost_level*/);
-}
-
-INSTANTIATE_TEST_CASE_P(CompactionIteratorTestInstance, CompactionIteratorTest,
-                        testing::Values(true, false));
-
-// Tests how CompactionIterator work together with SnapshotChecker.
-class CompactionIteratorWithSnapshotCheckerTest
-    : public CompactionIteratorTest {
- public:
-  bool UseSnapshotChecker() const override { return true; }
-};
-
-// Uncommitted keys (keys with seq > last_committed_seq) should be output as-is
-// while committed version of these keys should get compacted as usual.
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       PreserveUncommittedKeys_Value) {
-  RunTest(
-      {test::KeyStr("foo", 3, kTypeValue), test::KeyStr("foo", 2, kTypeValue),
-       test::KeyStr("foo", 1, kTypeValue)},
-      {"v3", "v2", "v1"},
-      {test::KeyStr("foo", 3, kTypeValue), test::KeyStr("foo", 2, kTypeValue)},
-      {"v3", "v2"}, 2 /*last_committed_seq*/);
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       PreserveUncommittedKeys_Deletion) {
-  RunTest({test::KeyStr("foo", 2, kTypeDeletion),
-           test::KeyStr("foo", 1, kTypeValue)},
-          {"", "v1"},
-          {test::KeyStr("foo", 2, kTypeDeletion),
-           test::KeyStr("foo", 1, kTypeValue)},
-          {"", "v1"}, 1 /*last_committed_seq*/);
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       PreserveUncommittedKeys_Merge) {
-  auto merge_op = MergeOperators::CreateStringAppendOperator();
-  RunTest(
-      {test::KeyStr("foo", 3, kTypeMerge), test::KeyStr("foo", 2, kTypeMerge),
-       test::KeyStr("foo", 1, kTypeValue)},
-      {"v3", "v2", "v1"},
-      {test::KeyStr("foo", 3, kTypeMerge), test::KeyStr("foo", 2, kTypeValue)},
-      {"v3", "v1,v2"}, 2 /*last_committed_seq*/, merge_op.get());
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       PreserveUncommittedKeys_SingleDelete) {
-  RunTest({test::KeyStr("foo", 2, kTypeSingleDeletion),
-           test::KeyStr("foo", 1, kTypeValue)},
-          {"", "v1"},
-          {test::KeyStr("foo", 2, kTypeSingleDeletion),
-           test::KeyStr("foo", 1, kTypeValue)},
-          {"", "v1"}, 1 /*last_committed_seq*/);
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       PreserveUncommittedKeys_BlobIndex) {
-  RunTest({test::KeyStr("foo", 3, kTypeBlobIndex),
-           test::KeyStr("foo", 2, kTypeBlobIndex),
-           test::KeyStr("foo", 1, kTypeBlobIndex)},
-          {"v3", "v2", "v1"},
-          {test::KeyStr("foo", 3, kTypeBlobIndex),
-           test::KeyStr("foo", 2, kTypeBlobIndex)},
-          {"v3", "v2"}, 2 /*last_committed_seq*/);
-}
-
-// Test compaction iterator dedup keys visible to the same snapshot.
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest, DedupSameSnapshot_Value) {
-  AddSnapshot(2, 1);
-  RunTest(
-      {test::KeyStr("foo", 4, kTypeValue), test::KeyStr("foo", 3, kTypeValue),
-       test::KeyStr("foo", 2, kTypeValue), test::KeyStr("foo", 1, kTypeValue)},
-      {"v4", "v3", "v2", "v1"},
-      {test::KeyStr("foo", 4, kTypeValue), test::KeyStr("foo", 3, kTypeValue),
-       test::KeyStr("foo", 1, kTypeValue)},
-      {"v4", "v3", "v1"}, 3 /*last_committed_seq*/);
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest, DedupSameSnapshot_Deletion) {
-  AddSnapshot(2, 1);
-  RunTest(
-      {test::KeyStr("foo", 4, kTypeValue),
-       test::KeyStr("foo", 3, kTypeDeletion),
-       test::KeyStr("foo", 2, kTypeValue), test::KeyStr("foo", 1, kTypeValue)},
-      {"v4", "", "v2", "v1"},
-      {test::KeyStr("foo", 4, kTypeValue),
-       test::KeyStr("foo", 3, kTypeDeletion),
-       test::KeyStr("foo", 1, kTypeValue)},
-      {"v4", "", "v1"}, 3 /*last_committed_seq*/);
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest, DedupSameSnapshot_Merge) {
-  AddSnapshot(2, 1);
-  AddSnapshot(4, 3);
-  auto merge_op = MergeOperators::CreateStringAppendOperator();
-  RunTest(
-      {test::KeyStr("foo", 5, kTypeMerge), test::KeyStr("foo", 4, kTypeMerge),
-       test::KeyStr("foo", 3, kTypeMerge), test::KeyStr("foo", 2, kTypeMerge),
-       test::KeyStr("foo", 1, kTypeValue)},
-      {"v5", "v4", "v3", "v2", "v1"},
-      {test::KeyStr("foo", 5, kTypeMerge), test::KeyStr("foo", 4, kTypeMerge),
-       test::KeyStr("foo", 3, kTypeMerge), test::KeyStr("foo", 1, kTypeValue)},
-      {"v5", "v4", "v2,v3", "v1"}, 4 /*last_committed_seq*/, merge_op.get());
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       DedupSameSnapshot_SingleDeletion) {
-  AddSnapshot(2, 1);
-  RunTest(
-      {test::KeyStr("foo", 4, kTypeValue),
-       test::KeyStr("foo", 3, kTypeSingleDeletion),
-       test::KeyStr("foo", 2, kTypeValue), test::KeyStr("foo", 1, kTypeValue)},
-      {"v4", "", "v2", "v1"},
-      {test::KeyStr("foo", 4, kTypeValue), test::KeyStr("foo", 1, kTypeValue)},
-      {"v4", "v1"}, 3 /*last_committed_seq*/);
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest, DedupSameSnapshot_BlobIndex) {
-  AddSnapshot(2, 1);
-  RunTest({test::KeyStr("foo", 4, kTypeBlobIndex),
-           test::KeyStr("foo", 3, kTypeBlobIndex),
-           test::KeyStr("foo", 2, kTypeBlobIndex),
-           test::KeyStr("foo", 1, kTypeBlobIndex)},
-          {"v4", "v3", "v2", "v1"},
-          {test::KeyStr("foo", 4, kTypeBlobIndex),
-           test::KeyStr("foo", 3, kTypeBlobIndex),
-           test::KeyStr("foo", 1, kTypeBlobIndex)},
-          {"v4", "v3", "v1"}, 3 /*last_committed_seq*/);
-}
-
-// At bottom level, sequence numbers can be zero out, and deletions can be
-// removed, but only when they are visible to earliest snapshot.
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       NotZeroOutSequenceIfNotVisibleToEarliestSnapshot) {
-  AddSnapshot(2, 1);
-  RunTest({test::KeyStr("a", 1, kTypeValue), test::KeyStr("b", 2, kTypeValue),
-           test::KeyStr("c", 3, kTypeValue)},
-          {"v1", "v2", "v3"},
-          {test::KeyStr("a", 0, kTypeValue), test::KeyStr("b", 2, kTypeValue),
-           test::KeyStr("c", 3, kTypeValue)},
-          {"v1", "v2", "v3"}, kMaxSequenceNumber /*last_commited_seq*/,
-          nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
-          true /*bottommost_level*/);
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       NotRemoveDeletionIfNotVisibleToEarliestSnapshot) {
-  AddSnapshot(2, 1);
-  RunTest(
-      {test::KeyStr("a", 1, kTypeDeletion), test::KeyStr("b", 2, kTypeDeletion),
-       test::KeyStr("c", 3, kTypeDeletion)},
-      {"", "", ""},
-      {test::KeyStr("b", 2, kTypeDeletion),
-       test::KeyStr("c", 3, kTypeDeletion)},
-      {"", ""}, kMaxSequenceNumber /*last_commited_seq*/,
-      nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
-      true /*bottommost_level*/);
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       NotRemoveSingleDeletionIfNotVisibleToEarliestSnapshot) {
-  AddSnapshot(2, 1);
-  RunTest({test::KeyStr("a", 1, kTypeSingleDeletion),
-           test::KeyStr("b", 2, kTypeSingleDeletion),
-           test::KeyStr("c", 3, kTypeSingleDeletion)},
-          {"", "", ""},
-          {test::KeyStr("b", 2, kTypeSingleDeletion),
-           test::KeyStr("c", 3, kTypeSingleDeletion)},
-          {"", ""}, kMaxSequenceNumber /*last_commited_seq*/,
-          nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
-          true /*bottommost_level*/);
-}
-
-// Single delete should not cancel out values that not visible to the
-// same set of snapshots
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       SingleDeleteAcrossSnapshotBoundary) {
-  AddSnapshot(2, 1);
-  RunTest({test::KeyStr("a", 2, kTypeSingleDeletion),
-           test::KeyStr("a", 1, kTypeValue)},
-          {"", "v1"},
-          {test::KeyStr("a", 2, kTypeSingleDeletion),
-           test::KeyStr("a", 1, kTypeValue)},
-          {"", "v1"}, 2 /*last_committed_seq*/);
-}
-
-// Single delete should be kept in case it is not visible to the
-// earliest write conflict snapshot. If a single delete is kept for this reason,
-// corresponding value can be trimmed to save space.
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       KeepSingleDeletionForWriteConflictChecking) {
-  AddSnapshot(2, 0);
-  RunTest({test::KeyStr("a", 2, kTypeSingleDeletion),
-           test::KeyStr("a", 1, kTypeValue)},
-          {"", "v1"},
-          {test::KeyStr("a", 2, kTypeSingleDeletion),
-           test::KeyStr("a", 1, kTypeValue)},
-          {"", ""}, 2 /*last_committed_seq*/, nullptr /*merge_operator*/,
-          nullptr /*compaction_filter*/, false /*bottommost_level*/,
-          2 /*earliest_write_conflict_snapshot*/);
-}
-
-// Compaction filter should keep uncommitted key as-is, and
-//   * Convert the latest velue to deletion, and/or
-//   * if latest value is a merge, apply filter to all suequent merges.
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest, CompactionFilter_Value) {
-  std::unique_ptr<CompactionFilter> compaction_filter(
-      new FilterAllKeysCompactionFilter());
-  RunTest(
-      {test::KeyStr("a", 2, kTypeValue), test::KeyStr("a", 1, kTypeValue),
-       test::KeyStr("b", 3, kTypeValue), test::KeyStr("c", 1, kTypeValue)},
-      {"v2", "v1", "v3", "v4"},
-      {test::KeyStr("a", 2, kTypeValue), test::KeyStr("a", 1, kTypeDeletion),
-       test::KeyStr("b", 3, kTypeValue), test::KeyStr("c", 1, kTypeDeletion)},
-      {"v2", "", "v3", ""}, 1 /*last_committed_seq*/,
-      nullptr /*merge_operator*/, compaction_filter.get());
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest, CompactionFilter_Deletion) {
-  std::unique_ptr<CompactionFilter> compaction_filter(
-      new FilterAllKeysCompactionFilter());
-  RunTest(
-      {test::KeyStr("a", 2, kTypeDeletion), test::KeyStr("a", 1, kTypeValue)},
-      {"", "v1"},
-      {test::KeyStr("a", 2, kTypeDeletion),
-       test::KeyStr("a", 1, kTypeDeletion)},
-      {"", ""}, 1 /*last_committed_seq*/, nullptr /*merge_operator*/,
-      compaction_filter.get());
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest,
-       CompactionFilter_PartialMerge) {
-  std::shared_ptr<MergeOperator> merge_op =
-      MergeOperators::CreateStringAppendOperator();
-  std::unique_ptr<CompactionFilter> compaction_filter(
-      new FilterAllKeysCompactionFilter());
-  RunTest({test::KeyStr("a", 3, kTypeMerge), test::KeyStr("a", 2, kTypeMerge),
-           test::KeyStr("a", 1, kTypeMerge)},
-          {"v3", "v2", "v1"}, {test::KeyStr("a", 3, kTypeMerge)}, {"v3"},
-          2 /*last_committed_seq*/, merge_op.get(), compaction_filter.get());
-}
-
-TEST_F(CompactionIteratorWithSnapshotCheckerTest, CompactionFilter_FullMerge) {
-  std::shared_ptr<MergeOperator> merge_op =
-      MergeOperators::CreateStringAppendOperator();
-  std::unique_ptr<CompactionFilter> compaction_filter(
-      new FilterAllKeysCompactionFilter());
-  RunTest(
-      {test::KeyStr("a", 3, kTypeMerge), test::KeyStr("a", 2, kTypeMerge),
-       test::KeyStr("a", 1, kTypeValue)},
-      {"v3", "v2", "v1"},
-      {test::KeyStr("a", 3, kTypeMerge), test::KeyStr("a", 1, kTypeDeletion)},
-      {"v3", ""}, 2 /*last_committed_seq*/, merge_op.get(),
-      compaction_filter.get());
-}
-
 }  // namespace rocksdb
 
 int main(int argc, char** argv) {

db/compaction_job.cc

@@ -747,8 +747,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
       compaction_filter, db_options_.info_log.get(),
       false /* internal key corruption is expected */,
       existing_snapshots_.empty() ? 0 : existing_snapshots_.back(),
-      snapshot_checker_, compact_->compaction->level(),
-      db_options_.statistics.get(), shutting_down_);
+      compact_->compaction->level(), db_options_.statistics.get(),
+      shutting_down_);
 
   TEST_SYNC_POINT("CompactionJob::Run():Inprogress");
 
@@ -762,13 +762,24 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
     input->SeekToFirst();
   }
 
+  // we allow only 1 compaction event listener. Used by blob storage
+  CompactionEventListener* comp_event_listener = nullptr;
+#ifndef ROCKSDB_LITE
+  for (auto& celitr : cfd->ioptions()->listeners) {
+    comp_event_listener = celitr->GetCompactionEventListener();
+    if (comp_event_listener != nullptr) {
+      break;
+    }
+  }
+#endif  // ROCKSDB_LITE
+
   Status status;
   sub_compact->c_iter.reset(new CompactionIterator(
       input.get(), cfd->user_comparator(), &merge, versions_->LastSequence(),
       &existing_snapshots_, earliest_write_conflict_snapshot_,
       snapshot_checker_, env_, false, range_del_agg.get(),
-      sub_compact->compaction, compaction_filter, shutting_down_,
-      preserve_deletes_seqnum_));
+      sub_compact->compaction, compaction_filter, comp_event_listener,
+      shutting_down_, preserve_deletes_seqnum_));
   auto c_iter = sub_compact->c_iter.get();
   c_iter->SeekToFirst();
   if (c_iter->Valid() &&

db/compaction_job_stats_test.cc

@@ -426,7 +426,7 @@ class CompactionJobStatsChecker : public EventListener {
   // Once a compaction completed, this function will verify the returned
   // CompactionJobInfo with the oldest CompactionJobInfo added earlier
   // in "expected_stats_" which has not yet being used for verification.
-  virtual void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) {
+  virtual void OnCompactionCompleted(DB *db, const CompactionJobInfo& ci) {
     if (verify_next_comp_io_stats_) {
       ASSERT_GT(ci.stats.file_write_nanos, 0);
       ASSERT_GT(ci.stats.file_range_sync_nanos, 0);

db/compaction_picker.cc

@@ -199,7 +199,7 @@ void CompactionPicker::GetRange(const std::vector<CompactionInputFiles>& inputs,
   assert(initialized);
 }
 
-bool CompactionPicker::ExpandInputsToCleanCut(const std::string& /*cf_name*/,
+bool CompactionPicker::ExpandInputsToCleanCut(const std::string& cf_name,
                                               VersionStorageInfo* vstorage,
                                               CompactionInputFiles* inputs) {
   // This isn't good compaction
@@ -309,7 +309,7 @@ Compaction* CompactionPicker::CompactFiles(
 Status CompactionPicker::GetCompactionInputsFromFileNumbers(
     std::vector<CompactionInputFiles>* input_files,
     std::unordered_set<uint64_t>* input_set, const VersionStorageInfo* vstorage,
-    const CompactionOptions& /*compact_options*/) const {
+    const CompactionOptions& compact_options) const {
   if (input_set->size() == 0U) {
     return Status::InvalidArgument(
         "Compaction must include at least one file.");
@@ -1612,9 +1612,8 @@ Compaction* FIFOCompactionPicker::PickCompaction(
 Compaction* FIFOCompactionPicker::CompactRange(
     const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
     VersionStorageInfo* vstorage, int input_level, int output_level,
-    uint32_t /*output_path_id*/, const InternalKey* /*begin*/,
-    const InternalKey* /*end*/, InternalKey** compaction_end,
-    bool* /*manual_conflict*/) {
+    uint32_t output_path_id, const InternalKey* begin, const InternalKey* end,
+    InternalKey** compaction_end, bool* manual_conflict) {
   assert(input_level == 0);
   assert(output_level == 0);
   *compaction_end = nullptr;

db/compaction_picker.h

@@ -267,29 +267,27 @@ class NullCompactionPicker : public CompactionPicker {
   virtual ~NullCompactionPicker() {}
 
   // Always return "nullptr"
-  Compaction* PickCompaction(const std::string& /*cf_name*/,
-                             const MutableCFOptions& /*mutable_cf_options*/,
-                             VersionStorageInfo* /*vstorage*/,
-                             LogBuffer* /*log_buffer*/) override {
+  Compaction* PickCompaction(const std::string& cf_name,
+                             const MutableCFOptions& mutable_cf_options,
+                             VersionStorageInfo* vstorage,
+                             LogBuffer* log_buffer) override {
     return nullptr;
   }
 
   // Always return "nullptr"
-  Compaction* CompactRange(const std::string& /*cf_name*/,
-                           const MutableCFOptions& /*mutable_cf_options*/,
-                           VersionStorageInfo* /*vstorage*/,
-                           int /*input_level*/, int /*output_level*/,
-                           uint32_t /*output_path_id*/,
-                           const InternalKey* /*begin*/,
-                           const InternalKey* /*end*/,
-                           InternalKey** /*compaction_end*/,
-                           bool* /*manual_conflict*/) override {
+  Compaction* CompactRange(const std::string& cf_name,
+                           const MutableCFOptions& mutable_cf_options,
+                           VersionStorageInfo* vstorage, int input_level,
+                           int output_level, uint32_t output_path_id,
+                           const InternalKey* begin, const InternalKey* end,
+                           InternalKey** compaction_end,
+                           bool* manual_conflict) override {
     return nullptr;
   }
 
   // Always returns false.
   virtual bool NeedsCompaction(
-      const VersionStorageInfo* /*vstorage*/) const override {
+      const VersionStorageInfo* vstorage) const override {
     return false;
   }
 };

db/compaction_picker_test.cc

@@ -20,9 +20,7 @@ namespace rocksdb {
 class CountingLogger : public Logger {
  public:
   using Logger::Logv;
-  virtual void Logv(const char* /*format*/, va_list /*ap*/) override {
-    log_count++;
-  }
+  virtual void Logv(const char* format, va_list ap) override { log_count++; }
   size_t log_count;
 };
 

db/compaction_picker_universal.cc

@@ -204,7 +204,7 @@ void UniversalCompactionPicker::SortedRun::DumpSizeInfo(
 
 std::vector<UniversalCompactionPicker::SortedRun>
 UniversalCompactionPicker::CalculateSortedRuns(
-    const VersionStorageInfo& vstorage, const ImmutableCFOptions& /*ioptions*/,
+    const VersionStorageInfo& vstorage, const ImmutableCFOptions& ioptions,
     const MutableCFOptions& mutable_cf_options) {
   std::vector<UniversalCompactionPicker::SortedRun> ret;
   for (FileMetaData* f : vstorage.LevelFiles(0)) {
@@ -603,9 +603,9 @@ Compaction* UniversalCompactionPicker::PickCompactionToReduceSortedRuns(
 
   CompactionReason compaction_reason;
   if (max_number_of_files_to_compact == UINT_MAX) {
-    compaction_reason = CompactionReason::kUniversalSizeRatio;
-  } else {
     compaction_reason = CompactionReason::kUniversalSortedRunNum;
+  } else {
+    compaction_reason = CompactionReason::kUniversalSizeRatio;
   }
   return new Compaction(
       vstorage, ioptions_, mutable_cf_options, std::move(inputs), output_level,

db/comparator_db_test.cc

@@ -188,10 +188,10 @@ class DoubleComparator : public Comparator {
       return -1;
     }
   }
-  virtual void FindShortestSeparator(std::string* /*start*/,
-                                     const Slice& /*limit*/) const override {}
+  virtual void FindShortestSeparator(std::string* start,
+                                     const Slice& limit) const override {}
 
-  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortSuccessor(std::string* key) const override {}
 };
 
 class HashComparator : public Comparator {
@@ -211,10 +211,10 @@ class HashComparator : public Comparator {
       return -1;
     }
   }
-  virtual void FindShortestSeparator(std::string* /*start*/,
-                                     const Slice& /*limit*/) const override {}
+  virtual void FindShortestSeparator(std::string* start,
+                                     const Slice& limit) const override {}
 
-  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortSuccessor(std::string* key) const override {}
 };
 
 class TwoStrComparator : public Comparator {
@@ -243,10 +243,10 @@ class TwoStrComparator : public Comparator {
     }
     return a2.compare(b2);
   }
-  virtual void FindShortestSeparator(std::string* /*start*/,
-                                     const Slice& /*limit*/) const override {}
+  virtual void FindShortestSeparator(std::string* start,
+                                     const Slice& limit) const override {}
 
-  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortSuccessor(std::string* key) const override {}
 };
 }  // namespace
 

db/convenience.cc

@@ -19,17 +19,9 @@ void CancelAllBackgroundWork(DB* db, bool wait) {
 }
 
 Status DeleteFilesInRange(DB* db, ColumnFamilyHandle* column_family,
-                          const Slice* begin, const Slice* end,
-                          bool include_end) {
-  RangePtr range(begin, end);
-  return DeleteFilesInRanges(db, column_family, &range, 1, include_end);
-}
-
-Status DeleteFilesInRanges(DB* db, ColumnFamilyHandle* column_family,
-                           const RangePtr* ranges, size_t n,
-                           bool include_end) {
+                          const Slice* begin, const Slice* end) {
   return (static_cast_with_check<DBImpl, DB>(db->GetRootDB()))
-      ->DeleteFilesInRanges(column_family, ranges, n, include_end);
+      ->DeleteFilesInRange(column_family, begin, end);
 }
 
 Status VerifySstFileChecksum(const Options& options,

db/db_basic_test.cc

@@ -9,7 +9,6 @@
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "rocksdb/perf_context.h"
-#include "util/fault_injection_test_env.h"
 #if !defined(ROCKSDB_LITE)
 #include "util/sync_point.h"
 #endif
@@ -850,44 +849,23 @@ TEST_F(DBBasicTest, MmapAndBufferOptions) {
 
 class TestEnv : public EnvWrapper {
   public:
-    explicit TestEnv() : EnvWrapper(Env::Default()),
-                close_count(0) { }
+    explicit TestEnv(Env* base) : EnvWrapper(base) { };
 
     class TestLogger : public Logger {
       public:
         using Logger::Logv;
-        TestLogger(TestEnv *env_ptr) : Logger() { env = env_ptr; }
-        ~TestLogger() {
-          if (!closed_) {
-            CloseHelper();
-          }
-        }
-        virtual void Logv(const char* /*format*/, va_list /*ap*/) override{};
-
-       protected:
-        virtual Status CloseImpl() override {
-          return CloseHelper();
-        }
+        virtual void Logv(const char *format, va_list ap) override { };
       private:
-        Status CloseHelper() {
-          env->CloseCountInc();;
-          return Status::IOError();
+        virtual Status CloseImpl() override {
+          return Status::NotSupported();
         }
-        TestEnv *env;
     };
 
-    void CloseCountInc() { close_count++; }
-
-    int GetCloseCount() { return close_count; }
-
-    virtual Status NewLogger(const std::string& /*fname*/,
+    virtual Status NewLogger(const std::string& fname,
                              shared_ptr<Logger>* result) {
-      result->reset(new TestLogger(this));
+      result->reset(new TestLogger());
       return Status::OK();
     }
-
-  private:
-    int close_count;
 };
 
 TEST_F(DBBasicTest, DBClose) {
@@ -896,29 +874,19 @@ TEST_F(DBBasicTest, DBClose) {
   ASSERT_OK(DestroyDB(dbname, options));
 
   DB* db = nullptr;
-  TestEnv *env = new TestEnv();
   options.create_if_missing = true;
-  options.env = env;
+  options.env = new TestEnv(Env::Default());
   Status s = DB::Open(options, dbname, &db);
   ASSERT_OK(s);
   ASSERT_TRUE(db != nullptr);
 
   s = db->Close();
-  ASSERT_EQ(env->GetCloseCount(), 1);
-  ASSERT_EQ(s, Status::IOError());
+  ASSERT_EQ(s, Status::NotSupported());
 
   delete db;
-  ASSERT_EQ(env->GetCloseCount(), 1);
-
-  // Do not call DB::Close() and ensure our logger Close() still gets called
-  s = DB::Open(options, dbname, &db);
-  ASSERT_OK(s);
-  ASSERT_TRUE(db != nullptr);
-  delete db;
-  ASSERT_EQ(env->GetCloseCount(), 2);
 
   // Provide our own logger and ensure DB::Close() does not close it
-  options.info_log.reset(new TestEnv::TestLogger(env));
+  options.info_log.reset(new TestEnv::TestLogger());
   options.create_if_missing = false;
   s = DB::Open(options, dbname, &db);
   ASSERT_OK(s);
@@ -927,35 +895,9 @@ TEST_F(DBBasicTest, DBClose) {
   s = db->Close();
   ASSERT_EQ(s, Status::OK());
   delete db;
-  ASSERT_EQ(env->GetCloseCount(), 2);
-  options.info_log.reset();
-  ASSERT_EQ(env->GetCloseCount(), 3);
-
   delete options.env;
 }
 
-TEST_F(DBBasicTest, DBCloseFlushError) {
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env(
-      new FaultInjectionTestEnv(Env::Default()));
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.manual_wal_flush = true;
-  options.write_buffer_size=100;
-  options.env = fault_injection_env.get();
-
-  Reopen(options);
-  ASSERT_OK(Put("key1", "value1"));
-  ASSERT_OK(Put("key2", "value2"));
-  ASSERT_OK(dbfull()->TEST_SwitchMemtable());
-  ASSERT_OK(Put("key3", "value3"));
-  fault_injection_env->SetFilesystemActive(false);
-  Status s = dbfull()->Close();
-  fault_injection_env->SetFilesystemActive(true);
-  ASSERT_NE(s, Status::OK());
-
-  Destroy(options);
-}
-
 }  // namespace rocksdb
 
 int main(int argc, char** argv) {

db/db_block_cache_test.cc

@@ -47,7 +47,7 @@ class DBBlockCacheTest : public DBTestBase {
     return options;
   }
 
-  void InitTable(const Options& /*options*/) {
+  void InitTable(const Options& options) {
     std::string value(kValueSize, 'a');
     for (size_t i = 0; i < kNumBlocks; i++) {
       ASSERT_OK(Put(ToString(i), value.c_str()));
@@ -111,31 +111,6 @@ class DBBlockCacheTest : public DBTestBase {
   }
 };
 
-TEST_F(DBBlockCacheTest, IteratorBlockCacheUsage) {
-  ReadOptions read_options;
-  read_options.fill_cache = false;
-  auto table_options = GetTableOptions();
-  auto options = GetOptions(table_options);
-  InitTable(options);
-
-  std::shared_ptr<Cache> cache = NewLRUCache(0, 0, false);
-  table_options.block_cache = cache;
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  Reopen(options);
-  RecordCacheCounters(options);
-
-  std::vector<std::unique_ptr<Iterator>> iterators(kNumBlocks - 1);
-  Iterator* iter = nullptr;
-
-  ASSERT_EQ(0, cache->GetUsage());
-  iter = db_->NewIterator(read_options);
-  iter->Seek(ToString(0));
-  ASSERT_LT(0, cache->GetUsage());
-  delete iter;
-  iter = nullptr;
-  ASSERT_EQ(0, cache->GetUsage());
-}
-
 TEST_F(DBBlockCacheTest, TestWithoutCompressedBlockCache) {
   ReadOptions read_options;
   auto table_options = GetTableOptions();

db/db_compaction_filter_test.cc

@@ -56,9 +56,9 @@ INSTANTIATE_TEST_CASE_P(
 
 class KeepFilter : public CompactionFilter {
  public:
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& /*value*/, std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value, bool* value_changed) const
+      override {
     cfilter_count++;
     return false;
   }
@@ -68,9 +68,9 @@ class KeepFilter : public CompactionFilter {
 
 class DeleteFilter : public CompactionFilter {
  public:
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& /*value*/, std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value, bool* value_changed) const
+      override {
     cfilter_count++;
     return true;
   }
@@ -80,9 +80,9 @@ class DeleteFilter : public CompactionFilter {
 
 class DeleteISFilter : public CompactionFilter {
  public:
-  virtual bool Filter(int /*level*/, const Slice& key, const Slice& /*value*/,
-                      std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
     cfilter_count++;
     int i = std::stoi(key.ToString());
     if (i > 5 && i <= 105) {
@@ -100,10 +100,8 @@ class DeleteISFilter : public CompactionFilter {
 // zero-padded to length 10.
 class SkipEvenFilter : public CompactionFilter {
  public:
-  virtual Decision FilterV2(int /*level*/, const Slice& key,
-                            ValueType /*value_type*/,
-                            const Slice& /*existing_value*/,
-                            std::string* /*new_value*/,
+  virtual Decision FilterV2(int level, const Slice& key, ValueType value_type,
+                            const Slice& existing_value, std::string* new_value,
                             std::string* skip_until) const override {
     cfilter_count++;
     int i = std::stoi(key.ToString());
@@ -125,9 +123,9 @@ class SkipEvenFilter : public CompactionFilter {
 class DelayFilter : public CompactionFilter {
  public:
   explicit DelayFilter(DBTestBase* d) : db_test(d) {}
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& /*value*/, std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
     db_test->env_->addon_time_.fetch_add(1000);
     return true;
   }
@@ -142,9 +140,9 @@ class ConditionalFilter : public CompactionFilter {
  public:
   explicit ConditionalFilter(const std::string* filtered_value)
       : filtered_value_(filtered_value) {}
-  virtual bool Filter(int /*level*/, const Slice& /*key*/, const Slice& value,
-                      std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
     return value.ToString() == *filtered_value_;
   }
 
@@ -158,9 +156,9 @@ class ChangeFilter : public CompactionFilter {
  public:
   explicit ChangeFilter() {}
 
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& /*value*/, std::string* new_value,
-                      bool* value_changed) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value, bool* value_changed) const
+      override {
     assert(new_value != nullptr);
     *new_value = NEW_VALUE;
     *value_changed = true;
@@ -249,7 +247,7 @@ class DelayFilterFactory : public CompactionFilterFactory {
  public:
   explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {}
   virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
-      const CompactionFilter::Context& /*context*/) override {
+      const CompactionFilter::Context& context) override {
     return std::unique_ptr<CompactionFilter>(new DelayFilter(db_test));
   }
 
@@ -265,7 +263,7 @@ class ConditionalFilterFactory : public CompactionFilterFactory {
       : filtered_value_(filtered_value.ToString()) {}
 
   virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
-      const CompactionFilter::Context& /*context*/) override {
+      const CompactionFilter::Context& context) override {
     return std::unique_ptr<CompactionFilter>(
         new ConditionalFilter(&filtered_value_));
   }
@@ -283,7 +281,7 @@ class ChangeFilterFactory : public CompactionFilterFactory {
   explicit ChangeFilterFactory() {}
 
   virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
-      const CompactionFilter::Context& /*context*/) override {
+      const CompactionFilter::Context& context) override {
     return std::unique_ptr<CompactionFilter>(new ChangeFilter());
   }
 

db/db_compaction_test.cc

@@ -53,7 +53,7 @@ class FlushedFileCollector : public EventListener {
   FlushedFileCollector() {}
   ~FlushedFileCollector() {}
 
-  virtual void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
+  virtual void OnFlushCompleted(DB* db, const FlushJobInfo& info) override {
     std::lock_guard<std::mutex> lock(mutex_);
     flushed_files_.push_back(info.file_path);
   }
@@ -1517,122 +1517,6 @@ TEST_F(DBCompactionTest, DeleteFileRange) {
   ASSERT_GT(old_num_files, new_num_files);
 }
 
-TEST_F(DBCompactionTest, DeleteFilesInRanges) {
-  Options options = CurrentOptions();
-  options.write_buffer_size = 10 * 1024 * 1024;
-  options.max_bytes_for_level_multiplier = 2;
-  options.num_levels = 4;
-  options.max_background_compactions = 3;
-  options.disable_auto_compactions = true;
-
-  DestroyAndReopen(options);
-  int32_t value_size = 10 * 1024;  // 10 KB
-
-  Random rnd(301);
-  std::map<int32_t, std::string> values;
-
-  // file [0 => 100), [100 => 200), ... [900, 1000)
-  for (auto i = 0; i < 10; i++) {
-    for (auto j = 0; j < 100; j++) {
-      auto k = i * 100 + j;
-      values[k] = RandomString(&rnd, value_size);
-      ASSERT_OK(Put(Key(k), values[k]));
-    }
-    ASSERT_OK(Flush());
-  }
-  ASSERT_EQ("10", FilesPerLevel(0));
-  CompactRangeOptions compact_options;
-  compact_options.change_level = true;
-  compact_options.target_level = 2;
-  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
-  ASSERT_EQ("0,0,10", FilesPerLevel(0));
-
-  // file [0 => 100), [200 => 300), ... [800, 900)
-  for (auto i = 0; i < 10; i+=2) {
-    for (auto j = 0; j < 100; j++) {
-      auto k = i * 100 + j;
-      ASSERT_OK(Put(Key(k), values[k]));
-    }
-    ASSERT_OK(Flush());
-  }
-  ASSERT_EQ("5,0,10", FilesPerLevel(0));
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
-  ASSERT_EQ("0,5,10", FilesPerLevel(0));
-
-  // Delete files in range [0, 299] (inclusive)
-  {
-    auto begin_str1 = Key(0), end_str1 = Key(100);
-    auto begin_str2 = Key(100), end_str2 = Key(200);
-    auto begin_str3 = Key(200), end_str3 = Key(299);
-    Slice begin1(begin_str1), end1(end_str1);
-    Slice begin2(begin_str2), end2(end_str2);
-    Slice begin3(begin_str3), end3(end_str3);
-    std::vector<RangePtr> ranges;
-    ranges.push_back(RangePtr(&begin1, &end1));
-    ranges.push_back(RangePtr(&begin2, &end2));
-    ranges.push_back(RangePtr(&begin3, &end3));
-    ASSERT_OK(DeleteFilesInRanges(db_, db_->DefaultColumnFamily(),
-                                  ranges.data(), ranges.size()));
-    ASSERT_EQ("0,3,7", FilesPerLevel(0));
-
-    // Keys [0, 300) should not exist.
-    for (auto i = 0; i < 300; i++) {
-      ReadOptions ropts;
-      std::string result;
-      auto s = db_->Get(ropts, Key(i), &result);
-      ASSERT_TRUE(s.IsNotFound());
-    }
-    for (auto i = 300; i < 1000; i++) {
-      ASSERT_EQ(Get(Key(i)), values[i]);
-    }
-  }
-
-  // Delete files in range [600, 999) (exclusive)
-  {
-    auto begin_str1 = Key(600), end_str1 = Key(800);
-    auto begin_str2 = Key(700), end_str2 = Key(900);
-    auto begin_str3 = Key(800), end_str3 = Key(999);
-    Slice begin1(begin_str1), end1(end_str1);
-    Slice begin2(begin_str2), end2(end_str2);
-    Slice begin3(begin_str3), end3(end_str3);
-    std::vector<RangePtr> ranges;
-    ranges.push_back(RangePtr(&begin1, &end1));
-    ranges.push_back(RangePtr(&begin2, &end2));
-    ranges.push_back(RangePtr(&begin3, &end3));
-    ASSERT_OK(DeleteFilesInRanges(db_, db_->DefaultColumnFamily(),
-                                  ranges.data(), ranges.size(), false));
-    ASSERT_EQ("0,1,4", FilesPerLevel(0));
-
-    // Keys [600, 900) should not exist.
-    for (auto i = 600; i < 900; i++) {
-      ReadOptions ropts;
-      std::string result;
-      auto s = db_->Get(ropts, Key(i), &result);
-      ASSERT_TRUE(s.IsNotFound());
-    }
-    for (auto i = 300; i < 600; i++) {
-      ASSERT_EQ(Get(Key(i)), values[i]);
-    }
-    for (auto i = 900; i < 1000; i++) {
-      ASSERT_EQ(Get(Key(i)), values[i]);
-    }
-  }
-
-  // Delete all files.
-  {
-    RangePtr range;
-    ASSERT_OK(DeleteFilesInRanges(db_, db_->DefaultColumnFamily(), &range, 1));
-    ASSERT_EQ("", FilesPerLevel(0));
-
-    for (auto i = 0; i < 1000; i++) {
-      ReadOptions ropts;
-      std::string result;
-      auto s = db_->Get(ropts, Key(i), &result);
-      ASSERT_TRUE(s.IsNotFound());
-    }
-  }
-}
-
 TEST_F(DBCompactionTest, DeleteFileRangeFileEndpointsOverlapBug) {
   // regression test for #2833: groups of files whose user-keys overlap at the
   // endpoints could be split by `DeleteFilesInRange`. This caused old data to
@@ -3105,276 +2989,6 @@ TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
   }
 }
 
-TEST_F(DBCompactionTest, CompactRangeDelayedByL0FileCount) {
-  // Verify that, when `CompactRangeOptions::allow_write_stall == false`, manual
-  // compaction only triggers flush after it's sure stall won't be triggered for
-  // L0 file count going too high.
-  const int kNumL0FilesTrigger = 4;
-  const int kNumL0FilesLimit = 8;
-  // i == 0: verifies normal case where stall is avoided by delay
-  // i == 1: verifies no delay in edge case where stall trigger is same as
-  //         compaction trigger, so stall can't be avoided
-  for (int i = 0; i < 2; ++i) {
-    Options options = CurrentOptions();
-    options.level0_slowdown_writes_trigger = kNumL0FilesLimit;
-    if (i == 0) {
-      options.level0_file_num_compaction_trigger = kNumL0FilesTrigger;
-    } else {
-      options.level0_file_num_compaction_trigger = kNumL0FilesLimit;
-    }
-    Reopen(options);
-
-    if (i == 0) {
-      // ensure the auto compaction doesn't finish until manual compaction has
-      // had a chance to be delayed.
-      rocksdb::SyncPoint::GetInstance()->LoadDependency(
-          {{"DBImpl::CompactRange:StallWait", "CompactionJob::Run():End"}});
-    } else {
-      // ensure the auto-compaction doesn't finish until manual compaction has
-      // continued without delay.
-      rocksdb::SyncPoint::GetInstance()->LoadDependency(
-          {{"DBImpl::CompactRange:StallWaitDone", "CompactionJob::Run():End"}});
-    }
-    rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-    Random rnd(301);
-    for (int j = 0; j < kNumL0FilesLimit - 1; ++j) {
-      for (int k = 0; k < 2; ++k) {
-        ASSERT_OK(Put(Key(k), RandomString(&rnd, 1024)));
-      }
-      Flush();
-    }
-    auto manual_compaction_thread = port::Thread([this]() {
-      CompactRangeOptions cro;
-      cro.allow_write_stall = false;
-      db_->CompactRange(cro, nullptr, nullptr);
-    });
-
-    manual_compaction_thread.join();
-    dbfull()->TEST_WaitForCompact();
-    ASSERT_EQ(0, NumTableFilesAtLevel(0));
-    ASSERT_GT(NumTableFilesAtLevel(1), 0);
-    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  }
-}
-
-TEST_F(DBCompactionTest, CompactRangeDelayedByImmMemTableCount) {
-  // Verify that, when `CompactRangeOptions::allow_write_stall == false`, manual
-  // compaction only triggers flush after it's sure stall won't be triggered for
-  // immutable memtable count going too high.
-  const int kNumImmMemTableLimit = 8;
-  // i == 0: verifies normal case where stall is avoided by delay
-  // i == 1: verifies no delay in edge case where stall trigger is same as flush
-  //         trigger, so stall can't be avoided
-  for (int i = 0; i < 2; ++i) {
-    Options options = CurrentOptions();
-    options.disable_auto_compactions = true;
-    // the delay limit is one less than the stop limit. This test focuses on
-    // avoiding delay limit, but this option sets stop limit, so add one.
-    options.max_write_buffer_number = kNumImmMemTableLimit + 1;
-    if (i == 1) {
-      options.min_write_buffer_number_to_merge = kNumImmMemTableLimit;
-    }
-    Reopen(options);
-
-    if (i == 0) {
-      // ensure the flush doesn't finish until manual compaction has had a
-      // chance to be delayed.
-      rocksdb::SyncPoint::GetInstance()->LoadDependency(
-          {{"DBImpl::CompactRange:StallWait", "FlushJob::WriteLevel0Table"}});
-    } else {
-      // ensure the flush doesn't finish until manual compaction has continued
-      // without delay.
-      rocksdb::SyncPoint::GetInstance()->LoadDependency(
-          {{"DBImpl::CompactRange:StallWaitDone",
-            "FlushJob::WriteLevel0Table"}});
-    }
-    rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-    Random rnd(301);
-    for (int j = 0; j < kNumImmMemTableLimit - 1; ++j) {
-      ASSERT_OK(Put(Key(0), RandomString(&rnd, 1024)));
-      FlushOptions flush_opts;
-      flush_opts.wait = false;
-      dbfull()->Flush(flush_opts);
-    }
-
-    auto manual_compaction_thread = port::Thread([this]() {
-      CompactRangeOptions cro;
-      cro.allow_write_stall = false;
-      db_->CompactRange(cro, nullptr, nullptr);
-    });
-
-    manual_compaction_thread.join();
-    dbfull()->TEST_WaitForFlushMemTable();
-    ASSERT_EQ(0, NumTableFilesAtLevel(0));
-    ASSERT_GT(NumTableFilesAtLevel(1), 0);
-    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  }
-}
-
-TEST_F(DBCompactionTest, CompactRangeShutdownWhileDelayed) {
-  // Verify that, when `CompactRangeOptions::allow_write_stall == false`, delay
-  // does not hang if CF is dropped or DB is closed
-  const int kNumL0FilesTrigger = 4;
-  const int kNumL0FilesLimit = 8;
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = kNumL0FilesTrigger;
-  options.level0_slowdown_writes_trigger = kNumL0FilesLimit;
-  // i == 0: DB::DropColumnFamily() on CompactRange's target CF unblocks it
-  // i == 1: DB::CancelAllBackgroundWork() unblocks CompactRange. This is to
-  //         simulate what happens during Close as we can't call Close (it
-  //         blocks on the auto-compaction, making a cycle).
-  for (int i = 0; i < 2; ++i) {
-    CreateAndReopenWithCF({"one"}, options);
-    // The calls to close CF/DB wait until the manual compaction stalls.
-    // The auto-compaction waits until the manual compaction finishes to ensure
-    // the signal comes from closing CF/DB, not from compaction making progress.
-    rocksdb::SyncPoint::GetInstance()->LoadDependency(
-        {{"DBImpl::CompactRange:StallWait",
-          "DBCompactionTest::CompactRangeShutdownWhileDelayed:PreShutdown"},
-         {"DBCompactionTest::CompactRangeShutdownWhileDelayed:PostManual",
-          "CompactionJob::Run():End"}});
-    rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-    Random rnd(301);
-    for (int j = 0; j < kNumL0FilesLimit - 1; ++j) {
-      for (int k = 0; k < 2; ++k) {
-        ASSERT_OK(Put(1, Key(k), RandomString(&rnd, 1024)));
-      }
-      Flush(1);
-    }
-    auto manual_compaction_thread = port::Thread([this]() {
-      CompactRangeOptions cro;
-      cro.allow_write_stall = false;
-      ASSERT_TRUE(db_->CompactRange(cro, handles_[1], nullptr, nullptr)
-                      .IsShutdownInProgress());
-    });
-
-    TEST_SYNC_POINT(
-        "DBCompactionTest::CompactRangeShutdownWhileDelayed:PreShutdown");
-    if (i == 0) {
-      ASSERT_OK(db_->DropColumnFamily(handles_[1]));
-    } else {
-      dbfull()->CancelAllBackgroundWork(false /* wait */);
-    }
-    manual_compaction_thread.join();
-    TEST_SYNC_POINT(
-        "DBCompactionTest::CompactRangeShutdownWhileDelayed:PostManual");
-    dbfull()->TEST_WaitForCompact();
-    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  }
-}
-
-TEST_F(DBCompactionTest, CompactRangeSkipFlushAfterDelay) {
-  // Verify that, when `CompactRangeOptions::allow_write_stall == false`,
-  // CompactRange skips its flush if the delay is long enough that the memtables
-  // existing at the beginning of the call have already been flushed.
-  const int kNumL0FilesTrigger = 4;
-  const int kNumL0FilesLimit = 8;
-  Options options = CurrentOptions();
-  options.level0_slowdown_writes_trigger = kNumL0FilesLimit;
-  options.level0_file_num_compaction_trigger = kNumL0FilesTrigger;
-  Reopen(options);
-
-  Random rnd(301);
-  // The manual flush includes the memtable that was active when CompactRange
-  // began. So it unblocks CompactRange and precludes its flush. Throughout the
-  // test, stall conditions are upheld via high L0 file count.
-  rocksdb::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::CompactRange:StallWait",
-        "DBCompactionTest::CompactRangeSkipFlushAfterDelay:PreFlush"},
-       {"DBCompactionTest::CompactRangeSkipFlushAfterDelay:PostFlush",
-        "DBImpl::CompactRange:StallWaitDone"},
-       {"DBImpl::CompactRange:StallWaitDone", "CompactionJob::Run():End"}});
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  for (int i = 0; i < kNumL0FilesLimit - 1; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      ASSERT_OK(Put(Key(j), RandomString(&rnd, 1024)));
-    }
-    Flush();
-  }
-  auto manual_compaction_thread = port::Thread([this]() {
-    CompactRangeOptions cro;
-    cro.allow_write_stall = false;
-    db_->CompactRange(cro, nullptr, nullptr);
-  });
-
-  TEST_SYNC_POINT("DBCompactionTest::CompactRangeSkipFlushAfterDelay:PreFlush");
-  Put(ToString(0), RandomString(&rnd, 1024));
-  Flush();
-  Put(ToString(0), RandomString(&rnd, 1024));
-  TEST_SYNC_POINT("DBCompactionTest::CompactRangeSkipFlushAfterDelay:PostFlush");
-  manual_compaction_thread.join();
-
-  // If CompactRange's flush was skipped, the final Put above will still be
-  // in the active memtable.
-  std::string num_keys_in_memtable;
-  db_->GetProperty(DB::Properties::kNumEntriesActiveMemTable, &num_keys_in_memtable);
-  ASSERT_EQ(ToString(1), num_keys_in_memtable);
-
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_F(DBCompactionTest, CompactRangeFlushOverlappingMemtable) {
-  // Verify memtable only gets flushed if it contains data overlapping the range
-  // provided to `CompactRange`. Tests all kinds of overlap/non-overlap.
-  const int kNumEndpointKeys = 5;
-  std::string keys[kNumEndpointKeys] = {"a", "b", "c", "d", "e"};
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  Reopen(options);
-
-  // One extra iteration for nullptr, which means left side of interval is
-  // unbounded.
-  for (int i = 0; i <= kNumEndpointKeys; ++i) {
-    Slice begin;
-    Slice* begin_ptr;
-    if (i == 0) {
-      begin_ptr = nullptr;
-    } else {
-      begin = keys[i - 1];
-      begin_ptr = &begin;
-    }
-    // Start at `i` so right endpoint comes after left endpoint. One extra
-    // iteration for nullptr, which means right side of interval is unbounded.
-    for (int j = std::max(0, i - 1); j <= kNumEndpointKeys; ++j) {
-      Slice end;
-      Slice* end_ptr;
-      if (j == kNumEndpointKeys) {
-        end_ptr = nullptr;
-      } else {
-        end = keys[j];
-        end_ptr = &end;
-      }
-      ASSERT_OK(Put("b", "val"));
-      ASSERT_OK(Put("d", "val"));
-      CompactRangeOptions compact_range_opts;
-      ASSERT_OK(db_->CompactRange(compact_range_opts, begin_ptr, end_ptr));
-
-      uint64_t get_prop_tmp, num_memtable_entries = 0;
-      ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kNumEntriesImmMemTables,
-                                      &get_prop_tmp));
-      num_memtable_entries += get_prop_tmp;
-      ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
-                                      &get_prop_tmp));
-      num_memtable_entries += get_prop_tmp;
-      if (begin_ptr == nullptr || end_ptr == nullptr ||
-          (i <= 4 && j >= 1 && (begin != "c" || end != "c"))) {
-        // In this case `CompactRange`'s range overlapped in some way with the
-        // memtable's range, so flush should've happened. Then "b" and "d" won't
-        // be in the memtable.
-        ASSERT_EQ(0, num_memtable_entries);
-      } else {
-        ASSERT_EQ(2, num_memtable_entries);
-        // flush anyways to prepare for next iteration
-        db_->Flush(FlushOptions());
-      }
-    }
-  }
-}
-
 INSTANTIATE_TEST_CASE_P(DBCompactionTestWithParam, DBCompactionTestWithParam,
                         ::testing::Values(std::make_tuple(1, true),
                                           std::make_tuple(1, false),

db/db_filesnapshot.cc

@@ -93,7 +93,7 @@ Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
       }
       cfd->Ref();
       mutex_.Unlock();
-      status = FlushMemTable(cfd, FlushOptions(), FlushReason::kGetLiveFiles);
+      status = FlushMemTable(cfd, FlushOptions());
       TEST_SYNC_POINT("DBImpl::GetLiveFiles:1");
       TEST_SYNC_POINT("DBImpl::GetLiveFiles:2");
       mutex_.Lock();

db/db_flush_test.cc

@@ -137,7 +137,7 @@ TEST_F(DBFlushTest, ManualFlushWithMinWriteBufferNumberToMerge) {
       {{"DBImpl::BGWorkFlush",
         "DBFlushTest::ManualFlushWithMinWriteBufferNumberToMerge:1"},
        {"DBFlushTest::ManualFlushWithMinWriteBufferNumberToMerge:2",
-        "FlushJob::WriteLevel0Table"}});
+        "DBImpl::FlushMemTableToOutputFile:BeforeInstallSV"}});
   SyncPoint::GetInstance()->EnableProcessing();
 
   ASSERT_OK(Put("key1", "value1"));
@@ -185,26 +185,6 @@ TEST_P(DBFlushDirectIOTest, DirectIO) {
   delete options.env;
 }
 
-TEST_F(DBFlushTest, FlushError) {
-  Options options;
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env(
-      new FaultInjectionTestEnv(env_));
-  options.write_buffer_size = 100;
-  options.max_write_buffer_number = 4;
-  options.min_write_buffer_number_to_merge = 3;
-  options.disable_auto_compactions = true;
-  options.env = fault_injection_env.get();
-  Reopen(options);
-
-  ASSERT_OK(Put("key1", "value1"));
-  ASSERT_OK(Put("key2", "value2"));
-  fault_injection_env->SetFilesystemActive(false);
-  Status s = dbfull()->TEST_SwitchMemtable();
-  fault_injection_env->SetFilesystemActive(true);
-  Destroy(options);
-  ASSERT_NE(s, Status::OK());
-}
-
 INSTANTIATE_TEST_CASE_P(DBFlushDirectIOTest, DBFlushDirectIOTest,
                         testing::Bool());
 

db/db_impl.cc

@@ -258,7 +258,7 @@ void DBImpl::CancelAllBackgroundWork(bool wait) {
       if (!cfd->IsDropped() && cfd->initialized() && !cfd->mem()->IsEmpty()) {
         cfd->Ref();
         mutex_.Unlock();
-        FlushMemTable(cfd, FlushOptions(), FlushReason::kShutDown);
+        FlushMemTable(cfd, FlushOptions());
         mutex_.Lock();
         cfd->Unref();
       }
@@ -278,7 +278,7 @@ void DBImpl::CancelAllBackgroundWork(bool wait) {
   }
 }
 
-Status DBImpl::CloseHelper() {
+Status DBImpl::CloseImpl() {
   // CancelAllBackgroundWork called with false means we just set the shutdown
   // marker. After this we do a variant of the waiting and unschedule work
   // (to consider: moving all the waiting into CancelAllBackgroundWork(true))
@@ -287,7 +287,6 @@ Status DBImpl::CloseHelper() {
       env_->UnSchedule(this, Env::Priority::BOTTOM);
   int compactions_unscheduled = env_->UnSchedule(this, Env::Priority::LOW);
   int flushes_unscheduled = env_->UnSchedule(this, Env::Priority::HIGH);
-  Status ret;
   mutex_.Lock();
   bg_bottom_compaction_scheduled_ -= bottom_compactions_unscheduled;
   bg_compaction_scheduled_ -= compactions_unscheduled;
@@ -350,18 +349,7 @@ Status DBImpl::CloseHelper() {
     delete l;
   }
   for (auto& log : logs_) {
-    uint64_t log_number = log.writer->get_log_number();
-    Status s = log.ClearWriter();
-    if (!s.ok()) {
-      ROCKS_LOG_WARN(immutable_db_options_.info_log,
-                     "Unable to Sync WAL file %s with error -- %s",
-                     LogFileName(immutable_db_options_.wal_dir, log_number).c_str(),
-                     s.ToString().c_str());
-      // Retain the first error
-      if (ret.ok()) {
-        ret = s;
-      }
-    }
+    log.ClearWriter();
   }
   logs_.clear();
 
@@ -395,25 +383,14 @@ Status DBImpl::CloseHelper() {
   ROCKS_LOG_INFO(immutable_db_options_.info_log, "Shutdown complete");
   LogFlush(immutable_db_options_.info_log);
 
+  Status s = Status::OK();
   if (immutable_db_options_.info_log && own_info_log_) {
-    Status s = immutable_db_options_.info_log->Close();
-    if (ret.ok()) {
-      ret = s;
-    }
+    s = immutable_db_options_.info_log->Close();
   }
-  return ret;
+  return s;
 }
 
-Status DBImpl::CloseImpl() {
-  return CloseHelper();
-}
-
-DBImpl::~DBImpl() {
-  if (!closed_) {
-    closed_ = true;
-    CloseHelper();
-  }
-}
+DBImpl::~DBImpl() { Close(); }
 
 void DBImpl::MaybeIgnoreError(Status* s) const {
   if (s->ok() || immutable_db_options_.paranoid_checks) {
@@ -558,7 +535,6 @@ Status DBImpl::SetOptions(ColumnFamilyHandle* column_family,
 
       persist_options_status = WriteOptionsFile(
           false /*need_mutex_lock*/, true /*need_enter_write_thread*/);
-      bg_cv_.SignalAll();
     }
   }
   sv_context.Clean();
@@ -675,9 +651,8 @@ Status DBImpl::SetDBOptions(
 }
 
 // return the same level if it cannot be moved
-int DBImpl::FindMinimumEmptyLevelFitting(
-    ColumnFamilyData* cfd, const MutableCFOptions& /*mutable_cf_options*/,
-    int level) {
+int DBImpl::FindMinimumEmptyLevelFitting(ColumnFamilyData* cfd,
+    const MutableCFOptions& mutable_cf_options, int level) {
   mutex_.AssertHeld();
   const auto* vstorage = cfd->current()->storage_info();
   int minimum_level = level;
@@ -898,7 +873,7 @@ struct IterState {
   bool background_purge;
 };
 
-static void CleanupIteratorState(void* arg1, void* /*arg2*/) {
+static void CleanupIteratorState(void* arg1, void* arg2) {
   IterState* state = reinterpret_cast<IterState*>(arg1);
 
   if (state->super_version->Unref()) {
@@ -1444,7 +1419,6 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
       }
       is_snapshot_supported_ = new_is_snapshot_supported;
     }
-    bg_cv_.SignalAll();
   }
 
   if (s.ok()) {
@@ -2164,63 +2138,52 @@ Status DBImpl::DeleteFile(std::string name) {
   return status;
 }
 
-Status DBImpl::DeleteFilesInRanges(ColumnFamilyHandle* column_family,
-                                   const RangePtr* ranges, size_t n,
-                                   bool include_end) {
+Status DBImpl::DeleteFilesInRange(ColumnFamilyHandle* column_family,
+                                  const Slice* begin, const Slice* end) {
   Status status;
   auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
   ColumnFamilyData* cfd = cfh->cfd();
   VersionEdit edit;
-  std::set<FileMetaData*> deleted_files;
+  std::vector<FileMetaData*> deleted_files;
   JobContext job_context(next_job_id_.fetch_add(1), true);
   {
     InstrumentedMutexLock l(&mutex_);
     Version* input_version = cfd->current();
 
     auto* vstorage = input_version->storage_info();
-    for (size_t r = 0; r < n; r++) {
-      auto begin = ranges[r].start, end = ranges[r].limit;
-      for (int i = 1; i < cfd->NumberLevels(); i++) {
-        if (vstorage->LevelFiles(i).empty() ||
-            !vstorage->OverlapInLevel(i, begin, end)) {
+    for (int i = 1; i < cfd->NumberLevels(); i++) {
+      if (vstorage->LevelFiles(i).empty() ||
+          !vstorage->OverlapInLevel(i, begin, end)) {
+        continue;
+      }
+      std::vector<FileMetaData*> level_files;
+      InternalKey begin_storage, end_storage, *begin_key, *end_key;
+      if (begin == nullptr) {
+        begin_key = nullptr;
+      } else {
+        begin_storage.SetMinPossibleForUserKey(*begin);
+        begin_key = &begin_storage;
+      }
+      if (end == nullptr) {
+        end_key = nullptr;
+      } else {
+        end_storage.SetMaxPossibleForUserKey(*end);
+        end_key = &end_storage;
+      }
+
+      vstorage->GetCleanInputsWithinInterval(i, begin_key, end_key,
+                                             &level_files, -1 /* hint_index */,
+                                             nullptr /* file_index */);
+      FileMetaData* level_file;
+      for (uint32_t j = 0; j < level_files.size(); j++) {
+        level_file = level_files[j];
+        if (level_file->being_compacted) {
           continue;
         }
-        std::vector<FileMetaData*> level_files;
-        InternalKey begin_storage, end_storage, *begin_key, *end_key;
-        if (begin == nullptr) {
-          begin_key = nullptr;
-        } else {
-          begin_storage.SetMinPossibleForUserKey(*begin);
-          begin_key = &begin_storage;
-        }
-        if (end == nullptr) {
-          end_key = nullptr;
-        } else {
-          end_storage.SetMaxPossibleForUserKey(*end);
-          end_key = &end_storage;
-        }
-
-        vstorage->GetCleanInputsWithinInterval(i, begin_key, end_key,
-                                               &level_files, -1 /* hint_index */,
-                                               nullptr /* file_index */);
-        FileMetaData* level_file;
-        for (uint32_t j = 0; j < level_files.size(); j++) {
-          level_file = level_files[j];
-          if (level_file->being_compacted) {
-            continue;
-          }
-          if (deleted_files.find(level_file) != deleted_files.end()) {
-            continue;
-          }
-          if (!include_end && end != nullptr &&
-              cfd->user_comparator()->Compare(level_file->largest.user_key(), *end) == 0) {
-            continue;
-          }
-          edit.SetColumnFamily(cfd->GetID());
-          edit.DeleteFile(i, level_file->fd.GetNumber());
-          deleted_files.insert(level_file);
-          level_file->being_compacted = true;
-        }
+        edit.SetColumnFamily(cfd->GetID());
+        edit.DeleteFile(i, level_file->fd.GetNumber());
+        deleted_files.push_back(level_file);
+        level_file->being_compacted = true;
       }
     }
     if (edit.GetDeletedFiles().empty()) {
@@ -2336,31 +2299,31 @@ Status DBImpl::GetDbIdentity(std::string& identity) const {
 }
 
 // Default implementation -- returns not supported status
-Status DB::CreateColumnFamily(const ColumnFamilyOptions& /*cf_options*/,
-                              const std::string& /*column_family_name*/,
-                              ColumnFamilyHandle** /*handle*/) {
+Status DB::CreateColumnFamily(const ColumnFamilyOptions& cf_options,
+                              const std::string& column_family_name,
+                              ColumnFamilyHandle** handle) {
   return Status::NotSupported("");
 }
 
 Status DB::CreateColumnFamilies(
-    const ColumnFamilyOptions& /*cf_options*/,
-    const std::vector<std::string>& /*column_family_names*/,
-    std::vector<ColumnFamilyHandle*>* /*handles*/) {
+    const ColumnFamilyOptions& cf_options,
+    const std::vector<std::string>& column_family_names,
+    std::vector<ColumnFamilyHandle*>* handles) {
   return Status::NotSupported("");
 }
 
 Status DB::CreateColumnFamilies(
-    const std::vector<ColumnFamilyDescriptor>& /*column_families*/,
-    std::vector<ColumnFamilyHandle*>* /*handles*/) {
+    const std::vector<ColumnFamilyDescriptor>& column_families,
+    std::vector<ColumnFamilyHandle*>* handles) {
   return Status::NotSupported("");
 }
 
-Status DB::DropColumnFamily(ColumnFamilyHandle* /*column_family*/) {
+Status DB::DropColumnFamily(ColumnFamilyHandle* column_family) {
   return Status::NotSupported("");
 }
 
 Status DB::DropColumnFamilies(
-    const std::vector<ColumnFamilyHandle*>& /*column_families*/) {
+    const std::vector<ColumnFamilyHandle*>& column_families) {
   return Status::NotSupported("");
 }
 
@@ -2833,14 +2796,12 @@ Status DBImpl::IngestExternalFile(
     // Figure out if we need to flush the memtable first
     if (status.ok()) {
       bool need_flush = false;
-      status = ingestion_job.NeedsFlush(&need_flush, cfd->GetSuperVersion());
+      status = ingestion_job.NeedsFlush(&need_flush);
       TEST_SYNC_POINT_CALLBACK("DBImpl::IngestExternalFile:NeedFlush",
                                &need_flush);
       if (status.ok() && need_flush) {
         mutex_.Unlock();
-        status = FlushMemTable(cfd, FlushOptions(),
-                               FlushReason::kExternalFileIngestion,
-                               true /* writes_stopped */);
+        status = FlushMemTable(cfd, FlushOptions(), true /* writes_stopped */);
         mutex_.Lock();
       }
     }

db/db_impl.h

@@ -14,6 +14,7 @@
 #include <limits>
 #include <list>
 #include <map>
+#include <queue>
 #include <set>
 #include <string>
 #include <utility>
@@ -246,9 +247,8 @@ class DBImpl : public DB {
       const TransactionLogIterator::ReadOptions&
           read_options = TransactionLogIterator::ReadOptions()) override;
   virtual Status DeleteFile(std::string name) override;
-  Status DeleteFilesInRanges(ColumnFamilyHandle* column_family,
-                             const RangePtr* ranges, size_t n,
-                             bool include_end = true);
+  Status DeleteFilesInRange(ColumnFamilyHandle* column_family,
+                            const Slice* begin, const Slice* end);
 
   virtual void GetLiveFilesMetaData(
       std::vector<LiveFileMetaData>* metadata) override;
@@ -432,8 +432,6 @@ class DBImpl : public DB {
 
   uint64_t TEST_FindMinLogContainingOutstandingPrep();
   uint64_t TEST_FindMinPrepLogReferencedByMemTable();
-  size_t TEST_PreparedSectionCompletedSize();
-  size_t TEST_LogsWithPrepSize();
 
   int TEST_BGCompactionsAllowed() const;
   int TEST_BGFlushesAllowed() const;
@@ -674,14 +672,10 @@ class DBImpl : public DB {
   // batch which will be written to memtable later during the commit, and in
   // WritePrepared it is guaranteed since it will be used only for WAL markers
   // which will never be written to memtable.
-  // batch_cnt is expected to be non-zero in seq_per_batch mode and indicates
-  // the number of sub-patches. A sub-patch is a subset of the write batch that
-  // does not have duplicate keys.
   Status WriteImpl(const WriteOptions& options, WriteBatch* updates,
                    WriteCallback* callback = nullptr,
                    uint64_t* log_used = nullptr, uint64_t log_ref = 0,
                    bool disable_memtable = false, uint64_t* seq_used = nullptr,
-                   size_t batch_cnt = 0,
                    PreReleaseCallback* pre_release_callback = nullptr);
 
   Status PipelinedWriteImpl(const WriteOptions& options, WriteBatch* updates,
@@ -690,13 +684,10 @@ class DBImpl : public DB {
                             bool disable_memtable = false,
                             uint64_t* seq_used = nullptr);
 
-  // batch_cnt is expected to be non-zero in seq_per_batch mode and indicates
-  // the number of sub-patches. A sub-patch is a subset of the write batch that
-  // does not have duplicate keys.
   Status WriteImplWALOnly(const WriteOptions& options, WriteBatch* updates,
                           WriteCallback* callback = nullptr,
                           uint64_t* log_used = nullptr, uint64_t log_ref = 0,
-                          uint64_t* seq_used = nullptr, size_t batch_cnt = 0,
+                          uint64_t* seq_used = nullptr,
                           PreReleaseCallback* pre_release_callback = nullptr);
 
   uint64_t FindMinLogContainingOutstandingPrep();
@@ -705,9 +696,6 @@ class DBImpl : public DB {
   // The writer must be the leader in write_thread_ and holding mutex_
   Status WriteRecoverableState();
 
-  // Actual implementation of Close()
-  Status CloseImpl();
-
  private:
   friend class DB;
   friend class InternalStats;
@@ -823,7 +811,7 @@ class DBImpl : public DB {
 
   // Force current memtable contents to be flushed.
   Status FlushMemTable(ColumnFamilyData* cfd, const FlushOptions& options,
-                       FlushReason flush_reason, bool writes_stopped = false);
+                       bool writes_stopped = false);
 
   // Wait for memtable flushed.
   // If flush_memtable_id is non-null, wait until the memtable with the ID
@@ -885,7 +873,7 @@ class DBImpl : public DB {
   ColumnFamilyData* GetColumnFamilyDataByName(const std::string& cf_name);
 
   void MaybeScheduleFlushOrCompaction();
-  void SchedulePendingFlush(ColumnFamilyData* cfd, FlushReason flush_reason);
+  void SchedulePendingFlush(ColumnFamilyData* cfd);
   void SchedulePendingCompaction(ColumnFamilyData* cfd);
   void SchedulePendingPurge(std::string fname, FileType type, uint64_t number,
                             uint32_t path_id, int job_id);
@@ -924,7 +912,7 @@ class DBImpl : public DB {
   // helper functions for adding and removing from flush & compaction queues
   void AddToCompactionQueue(ColumnFamilyData* cfd);
   ColumnFamilyData* PopFirstFromCompactionQueue();
-  void AddToFlushQueue(ColumnFamilyData* cfd, FlushReason flush_reason);
+  void AddToFlushQueue(ColumnFamilyData* cfd);
   ColumnFamilyData* PopFirstFromFlushQueue();
 
   // helper function to call after some of the logs_ were synced
@@ -934,7 +922,8 @@ class DBImpl : public DB {
 
   uint64_t GetMaxTotalWalSize() const;
 
-  Status CloseHelper();
+  // Actual implementation of Close()
+  virtual Status CloseImpl();
 
   // table_cache_ provides its own synchronization
   std::shared_ptr<Cache> table_cache_;
@@ -966,8 +955,6 @@ class DBImpl : public DB {
   // * whenever num_running_ingest_file_ goes to 0.
   // * whenever pending_purge_obsolete_files_ goes to 0.
   // * whenever disable_delete_obsolete_files_ goes to 0.
-  // * whenever SetOptions successfully updates options.
-  // * whenever a column family is dropped.
   InstrumentedCondVar bg_cv_;
   // Writes are protected by locking both mutex_ and log_write_mutex_, and reads
   // must be under either mutex_ or log_write_mutex_. Since after ::Open,
@@ -1005,11 +992,9 @@ class DBImpl : public DB {
       writer = nullptr;
       return w;
     }
-    Status ClearWriter() {
-      Status s = writer->WriteBuffer();
+    void ClearWriter() {
       delete writer;
       writer = nullptr;
-      return s;
     }
 
     uint64_t number;
@@ -1299,33 +1284,27 @@ class DBImpl : public DB {
   // Indicate DB was opened successfully
   bool opened_successfully_;
 
-  // REQUIRES: logs_with_prep_mutex_ held
-  //
-  // sorted list of log numbers still containing prepared data.
+  // minimum log number still containing prepared data.
   // this is used by FindObsoleteFiles to determine which
   // flushed logs we must keep around because they still
-  // contain prepared data which has not been committed or rolled back
-  struct LogCnt {
-    uint64_t log;  // the log number
-    uint64_t cnt;  // number of prepared sections in the log
-  };
-  std::vector<LogCnt> logs_with_prep_;
-  std::mutex logs_with_prep_mutex_;
+  // contain prepared data which has not been flushed or rolled back
+  std::priority_queue<uint64_t, std::vector<uint64_t>, std::greater<uint64_t>>
+      min_log_with_prep_;
 
-  // REQUIRES: prepared_section_completed_mutex_ held
-  //
-  // to be used in conjunction with logs_with_prep_.
+  // to be used in conjunction with min_log_with_prep_.
   // once a transaction with data in log L is committed or rolled back
-  // rather than updating logs_with_prep_ directly we keep track of that
-  // in prepared_section_completed_ which maps LOG -> instance_count. This helps
-  // avoiding contention between a commit thread and the prepare threads.
+  // rather than removing the value from the heap we add that value
+  // to prepared_section_completed_ which maps LOG -> instance_count
+  // since a log could contain multiple prepared sections
   //
   // when trying to determine the minimum log still active we first
-  // consult logs_with_prep_. while that root value maps to
-  // an equal value in prepared_section_completed_ we erase the log from
-  // both logs_with_prep_ and prepared_section_completed_.
+  // consult min_log_with_prep_. while that root value maps to
+  // a value > 0 in prepared_section_completed_ we decrement the
+  // instance_count for that log and pop the root value in
+  // min_log_with_prep_. This will work the same as a min_heap
+  // where we are deleteing arbitrary elements and the up heaping.
   std::unordered_map<uint64_t, uint64_t> prepared_section_completed_;
-  std::mutex prepared_section_completed_mutex_;
+  std::mutex prep_heap_mutex_;
 
   // Callback for compaction to check if a key is visible to a snapshot.
   // REQUIRES: mutex held
@@ -1374,8 +1353,8 @@ class DBImpl : public DB {
     return Env::WLTH_SHORT;
   }
 
-  // When set, we use a separate queue for writes that dont write to memtable.
-  // In 2PC these are the writes at Prepare phase.
+  // When set, we use a seprate queue for writes that dont write to memtable. In
+  // 2PC these are the writes at Prepare phase.
   const bool two_write_queues_;
   const bool manual_wal_flush_;
   // Increase the sequence number after writing each batch, whether memtable is

db/db_impl_compaction_flush.cc

@@ -23,7 +23,6 @@
 #include "util/sync_point.h"
 
 namespace rocksdb {
-
 Status DBImpl::SyncClosedLogs(JobContext* job_context) {
   TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Start");
   mutex_.AssertHeld();
@@ -135,6 +134,7 @@ Status DBImpl::FlushMemTableToOutputFile(
   }
 
   if (s.ok()) {
+    TEST_SYNC_POINT("DBImpl::FlushMemTableToOutputFile:BeforeInstallSV");
     InstallSuperVersionAndScheduleWork(cfd, &job_context->superversion_context,
                                        mutable_cf_options);
     if (made_progress) {
@@ -223,7 +223,6 @@ void DBImpl::NotifyOnFlushBegin(ColumnFamilyData* cfd, FileMetaData* file_meta,
     info.smallest_seqno = file_meta->smallest_seqno;
     info.largest_seqno = file_meta->largest_seqno;
     info.table_properties = prop;
-    info.flush_reason = cfd->GetFlushReason();
     for (auto listener : immutable_db_options_.listeners) {
       listener->OnFlushBegin(this, info);
     }
@@ -268,7 +267,6 @@ void DBImpl::NotifyOnFlushCompleted(ColumnFamilyData* cfd,
     info.smallest_seqno = file_meta->smallest_seqno;
     info.largest_seqno = file_meta->largest_seqno;
     info.table_properties = prop;
-    info.flush_reason = cfd->GetFlushReason();
     for (auto listener : immutable_db_options_.listeners) {
       listener->OnFlushCompleted(this, info);
     }
@@ -290,75 +288,10 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
   auto cfd = cfh->cfd();
   bool exclusive = options.exclusive_manual_compaction;
 
-  bool flush_needed = true;
-  if (begin != nullptr && end != nullptr) {
-    // TODO(ajkr): We could also optimize away the flush in certain cases where
-    // one/both sides of the interval are unbounded. But it requires more
-    // changes to RangesOverlapWithMemtables.
-    Range range(*begin, *end);
-    SuperVersion* super_version = cfd->GetReferencedSuperVersion(&mutex_);
-    cfd->RangesOverlapWithMemtables({range}, super_version, &flush_needed);
-    CleanupSuperVersion(super_version);
-  }
-
-  if (!options.allow_write_stall && flush_needed) {
-    InstrumentedMutexLock l(&mutex_);
-    uint64_t orig_active_memtable_id = cfd->mem()->GetID();
-    WriteStallCondition write_stall_condition = WriteStallCondition::kNormal;
-    do {
-      if (write_stall_condition != WriteStallCondition::kNormal) {
-        TEST_SYNC_POINT("DBImpl::CompactRange:StallWait");
-        ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                       "[%s] CompactRange waiting on stall conditions to clear",
-                       cfd->GetName().c_str());
-        bg_cv_.Wait();
-      }
-      if (cfd->IsDropped() || shutting_down_.load(std::memory_order_acquire)) {
-        return Status::ShutdownInProgress();
-      }
-
-      uint64_t earliest_memtable_id =
-          std::min(cfd->mem()->GetID(), cfd->imm()->GetEarliestMemTableID());
-      if (earliest_memtable_id > orig_active_memtable_id) {
-        // We waited so long that the memtable we were originally waiting on was
-        // flushed.
-        flush_needed = false;
-        break;
-      }
-
-      const auto& mutable_cf_options = *cfd->GetLatestMutableCFOptions();
-      const auto* vstorage = cfd->current()->storage_info();
-
-      // Skip stalling check if we're below auto-flush and auto-compaction
-      // triggers. If it stalled in these conditions, that'd mean the stall
-      // triggers are so low that stalling is needed for any background work. In
-      // that case we shouldn't wait since background work won't be scheduled.
-      if (cfd->imm()->NumNotFlushed() <
-              cfd->ioptions()->min_write_buffer_number_to_merge &&
-          vstorage->l0_delay_trigger_count() <
-              mutable_cf_options.level0_file_num_compaction_trigger) {
-        break;
-      }
-
-      // check whether one extra immutable memtable or an extra L0 file would
-      // cause write stalling mode to be entered. It could still enter stall
-      // mode due to pending compaction bytes, but that's less common
-      write_stall_condition =
-          ColumnFamilyData::GetWriteStallConditionAndCause(
-              cfd->imm()->NumNotFlushed() + 1,
-              vstorage->l0_delay_trigger_count() + 1,
-              vstorage->estimated_compaction_needed_bytes(), mutable_cf_options)
-              .first;
-    } while (write_stall_condition != WriteStallCondition::kNormal);
-  }
-  TEST_SYNC_POINT("DBImpl::CompactRange:StallWaitDone");
-  Status s;
-  if (flush_needed) {
-    s = FlushMemTable(cfd, FlushOptions(), FlushReason::kManualCompaction);
-    if (!s.ok()) {
-      LogFlush(immutable_db_options_.info_log);
-      return s;
-    }
+  Status s = FlushMemTable(cfd, FlushOptions());
+  if (!s.ok()) {
+    LogFlush(immutable_db_options_.info_log);
+    return s;
   }
 
   int max_level_with_files = 0;
@@ -864,7 +797,7 @@ int DBImpl::NumberLevels(ColumnFamilyHandle* column_family) {
   return cfh->cfd()->NumberLevels();
 }
 
-int DBImpl::MaxMemCompactionLevel(ColumnFamilyHandle* /*column_family*/) {
+int DBImpl::MaxMemCompactionLevel(ColumnFamilyHandle* column_family) {
   return 0;
 }
 
@@ -880,8 +813,7 @@ Status DBImpl::Flush(const FlushOptions& flush_options,
   auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
   ROCKS_LOG_INFO(immutable_db_options_.info_log, "[%s] Manual flush start.",
                  cfh->GetName().c_str());
-  Status s =
-      FlushMemTable(cfh->cfd(), flush_options, FlushReason::kManualCompaction);
+  Status s = FlushMemTable(cfh->cfd(), flush_options);
   ROCKS_LOG_INFO(immutable_db_options_.info_log,
                  "[%s] Manual flush finished, status: %s\n",
                  cfh->GetName().c_str(), s.ToString().c_str());
@@ -1018,7 +950,7 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
 
 Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
                              const FlushOptions& flush_options,
-                             FlushReason flush_reason, bool writes_stopped) {
+                             bool writes_stopped) {
   Status s;
   uint64_t flush_memtable_id = 0;
   {
@@ -1047,7 +979,7 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
     cfd->imm()->FlushRequested();
 
     // schedule flush
-    SchedulePendingFlush(cfd, flush_reason);
+    SchedulePendingFlush(cfd);
     MaybeScheduleFlushOrCompaction();
   }
 
@@ -1203,12 +1135,11 @@ ColumnFamilyData* DBImpl::PopFirstFromCompactionQueue() {
   return cfd;
 }
 
-void DBImpl::AddToFlushQueue(ColumnFamilyData* cfd, FlushReason flush_reason) {
+void DBImpl::AddToFlushQueue(ColumnFamilyData* cfd) {
   assert(!cfd->pending_flush());
   cfd->Ref();
   flush_queue_.push_back(cfd);
   cfd->set_pending_flush(true);
-  cfd->SetFlushReason(flush_reason);
 }
 
 ColumnFamilyData* DBImpl::PopFirstFromFlushQueue() {
@@ -1217,14 +1148,12 @@ ColumnFamilyData* DBImpl::PopFirstFromFlushQueue() {
   flush_queue_.pop_front();
   assert(cfd->pending_flush());
   cfd->set_pending_flush(false);
-  // TODO: need to unset flush reason?
   return cfd;
 }
 
-void DBImpl::SchedulePendingFlush(ColumnFamilyData* cfd,
-                                  FlushReason flush_reason) {
+void DBImpl::SchedulePendingFlush(ColumnFamilyData* cfd) {
   if (!cfd->pending_flush() && cfd->imm()->IsFlushPending()) {
-    AddToFlushQueue(cfd, flush_reason);
+    AddToFlushQueue(cfd);
     ++unscheduled_flushes_;
   }
 }
@@ -1767,7 +1696,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
     env_->Schedule(&DBImpl::BGWorkBottomCompaction, ca, Env::Priority::BOTTOM,
                    this, &DBImpl::UnscheduleCallback);
   } else {
-    int output_level  __attribute__((__unused__));
+    int output_level  __attribute__((unused));
     output_level = c->output_level();
     TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:NonTrivial",
                              &output_level);
@@ -2001,7 +1930,7 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
 
   // Whenever we install new SuperVersion, we might need to issue new flushes or
   // compactions.
-  SchedulePendingFlush(cfd, FlushReason::kSuperVersionChange);
+  SchedulePendingFlush(cfd);
   SchedulePendingCompaction(cfd);
   MaybeScheduleFlushOrCompaction();
 

db/db_impl_debug.cc

@@ -103,7 +103,7 @@ Status DBImpl::TEST_FlushMemTable(bool wait, ColumnFamilyHandle* cfh) {
     auto cfhi = reinterpret_cast<ColumnFamilyHandleImpl*>(cfh);
     cfd = cfhi->cfd();
   }
-  return FlushMemTable(cfd, fo, FlushReason::kTest);
+  return FlushMemTable(cfd, fo);
 }
 
 Status DBImpl::TEST_WaitForFlushMemTable(ColumnFamilyHandle* column_family) {
@@ -186,12 +186,6 @@ uint64_t DBImpl::TEST_FindMinLogContainingOutstandingPrep() {
   return FindMinLogContainingOutstandingPrep();
 }
 
-size_t DBImpl::TEST_PreparedSectionCompletedSize() {
-  return prepared_section_completed_.size();
-}
-
-size_t DBImpl::TEST_LogsWithPrepSize() { return logs_with_prep_.size(); }
-
 uint64_t DBImpl::TEST_FindMinPrepLogReferencedByMemTable() {
   return FindMinPrepLogReferencedByMemTable();
 }

db/db_impl_files.cc

@@ -48,61 +48,58 @@ uint64_t DBImpl::FindMinPrepLogReferencedByMemTable() {
   return min_log;
 }
 
+// TODO(myabandeh): Avoid using locks
 void DBImpl::MarkLogAsHavingPrepSectionFlushed(uint64_t log) {
   assert(log != 0);
-  std::lock_guard<std::mutex> lock(prepared_section_completed_mutex_);
+  std::lock_guard<std::mutex> lock(prep_heap_mutex_);
   auto it = prepared_section_completed_.find(log);
-  if (UNLIKELY(it == prepared_section_completed_.end())) {
-    prepared_section_completed_[log] = 1;
-  } else {
-    it->second += 1;
-  }
+  assert(it != prepared_section_completed_.end());
+  it->second += 1;
 }
 
+// TODO(myabandeh): Avoid using locks
 void DBImpl::MarkLogAsContainingPrepSection(uint64_t log) {
   assert(log != 0);
-  std::lock_guard<std::mutex> lock(logs_with_prep_mutex_);
-
-  auto rit = logs_with_prep_.rbegin();
-  bool updated = false;
-  // Most probabely the last log is the one that is being marked for
-  // having a prepare section; so search from the end.
-  for (; rit != logs_with_prep_.rend() && rit->log >= log; ++rit) {
-    if (rit->log == log) {
-      rit->cnt++;
-      updated = true;
-      break;
-    }
-  }
-  if (!updated) {
-    // We are either at the start, or at a position with rit->log < log
-    logs_with_prep_.insert(rit.base(), {log, 1});
+  std::lock_guard<std::mutex> lock(prep_heap_mutex_);
+  min_log_with_prep_.push(log);
+  auto it = prepared_section_completed_.find(log);
+  if (it == prepared_section_completed_.end()) {
+    prepared_section_completed_[log] = 0;
   }
 }
 
 uint64_t DBImpl::FindMinLogContainingOutstandingPrep() {
-  std::lock_guard<std::mutex> lock(logs_with_prep_mutex_);
-  auto it = logs_with_prep_.begin();
-  // start with the smallest log
-  for (; it != logs_with_prep_.end();) {
-    auto min_log = it->log;
-    {
-      std::lock_guard<std::mutex> lock2(prepared_section_completed_mutex_);
-      auto completed_it = prepared_section_completed_.find(min_log);
-      if (completed_it == prepared_section_completed_.end() ||
-          completed_it->second < it->cnt) {
-        return min_log;
-      }
-      assert(completed_it != prepared_section_completed_.end() &&
-             completed_it->second == it->cnt);
-      prepared_section_completed_.erase(completed_it);
-    }
-    // erase from beigning in vector is not efficient but this function is not
-    // on the fast path.
-    it = logs_with_prep_.erase(it);
+
+  if (!allow_2pc()) {
+    return 0;
   }
-  // no such log found
-  return 0;
+
+  std::lock_guard<std::mutex> lock(prep_heap_mutex_);
+  uint64_t min_log = 0;
+
+  // first we look in the prepared heap where we keep
+  // track of transactions that have been prepared (written to WAL)
+  // but not yet committed.
+  while (!min_log_with_prep_.empty()) {
+    min_log = min_log_with_prep_.top();
+
+    auto it = prepared_section_completed_.find(min_log);
+
+    // value was marked as 'deleted' from heap
+    if (it != prepared_section_completed_.end() && it->second > 0) {
+      it->second -= 1;
+      min_log_with_prep_.pop();
+
+      // back to squere one...
+      min_log = 0;
+      continue;
+    } else {
+      // found a valid value
+      break;
+    }
+  }
+
+  return min_log;
 }
 
 uint64_t DBImpl::MinLogNumberToKeep() {

db/db_impl_open.cc

@@ -356,29 +356,6 @@ Status DBImpl::Recover(
       assert(s.IsIOError());
       return s;
     }
-    // Verify compatibility of env_options_ and filesystem
-    {
-      unique_ptr<RandomAccessFile> idfile;
-      EnvOptions customized_env(env_options_);
-      customized_env.use_direct_reads |=
-          immutable_db_options_.use_direct_io_for_flush_and_compaction;
-      s = env_->NewRandomAccessFile(IdentityFileName(dbname_), &idfile,
-                                    customized_env);
-      if (!s.ok()) {
-        const char* error_msg = s.ToString().c_str();
-        // Check if unsupported Direct I/O is the root cause
-        customized_env.use_direct_reads = false;
-        s = env_->NewRandomAccessFile(IdentityFileName(dbname_), &idfile,
-                                      customized_env);
-        if (s.ok()) {
-          return Status::InvalidArgument(
-              "Direct I/O is not supported by the specified DB.");
-        } else {
-          return Status::InvalidArgument(
-              "Found options incompatible with filesystem", error_msg);
-        }
-      }
-    }
   }
 
   Status s = versions_->Recover(column_families, read_only);

db/db_impl_readonly.cc

@@ -107,7 +107,7 @@ Status DBImplReadOnly::NewIterators(
 }
 
 Status DB::OpenForReadOnly(const Options& options, const std::string& dbname,
-                           DB** dbptr, bool /*error_if_log_file_exist*/) {
+                           DB** dbptr, bool error_if_log_file_exist) {
   *dbptr = nullptr;
 
   // Try to first open DB as fully compacted DB

db/db_impl_readonly.h

@@ -36,47 +36,46 @@ class DBImplReadOnly : public DBImpl {
       std::vector<Iterator*>* iterators) override;
 
   using DBImpl::Put;
-  virtual Status Put(const WriteOptions& /*options*/,
-                     ColumnFamilyHandle* /*column_family*/,
-                     const Slice& /*key*/, const Slice& /*value*/) override {
+  virtual Status Put(const WriteOptions& options,
+                     ColumnFamilyHandle* column_family, const Slice& key,
+                     const Slice& value) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
   using DBImpl::Merge;
-  virtual Status Merge(const WriteOptions& /*options*/,
-                       ColumnFamilyHandle* /*column_family*/,
-                       const Slice& /*key*/, const Slice& /*value*/) override {
+  virtual Status Merge(const WriteOptions& options,
+                       ColumnFamilyHandle* column_family, const Slice& key,
+                       const Slice& value) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
   using DBImpl::Delete;
-  virtual Status Delete(const WriteOptions& /*options*/,
-                        ColumnFamilyHandle* /*column_family*/,
-                        const Slice& /*key*/) override {
+  virtual Status Delete(const WriteOptions& options,
+                        ColumnFamilyHandle* column_family,
+                        const Slice& key) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
   using DBImpl::SingleDelete;
-  virtual Status SingleDelete(const WriteOptions& /*options*/,
-                              ColumnFamilyHandle* /*column_family*/,
-                              const Slice& /*key*/) override {
+  virtual Status SingleDelete(const WriteOptions& options,
+                              ColumnFamilyHandle* column_family,
+                              const Slice& key) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
-  virtual Status Write(const WriteOptions& /*options*/,
-                       WriteBatch* /*updates*/) override {
+  virtual Status Write(const WriteOptions& options,
+                       WriteBatch* updates) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
   using DBImpl::CompactRange;
-  virtual Status CompactRange(const CompactRangeOptions& /*options*/,
-                              ColumnFamilyHandle* /*column_family*/,
-                              const Slice* /*begin*/,
-                              const Slice* /*end*/) override {
+  virtual Status CompactRange(const CompactRangeOptions& options,
+                              ColumnFamilyHandle* column_family,
+                              const Slice* begin, const Slice* end) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 
   using DBImpl::CompactFiles;
   virtual Status CompactFiles(
-      const CompactionOptions& /*compact_options*/,
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*input_file_names*/,
-      const int /*output_level*/, const int /*output_path_id*/ = -1) override {
+      const CompactionOptions& compact_options,
+      ColumnFamilyHandle* column_family,
+      const std::vector<std::string>& input_file_names,
+      const int output_level, const int output_path_id = -1) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 
@@ -84,18 +83,18 @@ class DBImplReadOnly : public DBImpl {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 
-  virtual Status EnableFileDeletions(bool /*force*/) override {
+  virtual Status EnableFileDeletions(bool force) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
   virtual Status GetLiveFiles(std::vector<std::string>&,
-                              uint64_t* /*manifest_file_size*/,
-                              bool /*flush_memtable*/ = true) override {
+                              uint64_t* manifest_file_size,
+                              bool flush_memtable = true) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 
   using DBImpl::Flush;
-  virtual Status Flush(const FlushOptions& /*options*/,
-                       ColumnFamilyHandle* /*column_family*/) override {
+  virtual Status Flush(const FlushOptions& options,
+                       ColumnFamilyHandle* column_family) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 
@@ -106,9 +105,9 @@ class DBImplReadOnly : public DBImpl {
 
   using DB::IngestExternalFile;
   virtual Status IngestExternalFile(
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*external_files*/,
-      const IngestExternalFileOptions& /*ingestion_options*/) override {
+      ColumnFamilyHandle* column_family,
+      const std::vector<std::string>& external_files,
+      const IngestExternalFileOptions& ingestion_options) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 

db/db_impl_write.cc

@@ -64,9 +64,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
                          WriteBatch* my_batch, WriteCallback* callback,
                          uint64_t* log_used, uint64_t log_ref,
                          bool disable_memtable, uint64_t* seq_used,
-                         size_t batch_cnt,
                          PreReleaseCallback* pre_release_callback) {
-  assert(!seq_per_batch_ || batch_cnt != 0);
   if (my_batch == nullptr) {
     return Status::Corruption("Batch is nullptr!");
   }
@@ -78,7 +76,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
         "pipelined_writes is not compatible with concurrent prepares");
   }
   if (seq_per_batch_ && immutable_db_options_.enable_pipelined_write) {
-    // TODO(yiwu): update pipeline write with seq_per_batch and batch_cnt
     return Status::NotSupported(
         "pipelined_writes is not compatible with seq_per_batch");
   }
@@ -96,7 +93,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
 
   if (two_write_queues_ && disable_memtable) {
     return WriteImplWALOnly(write_options, my_batch, callback, log_used,
-                            log_ref, seq_used, batch_cnt, pre_release_callback);
+                            log_ref, seq_used, pre_release_callback);
   }
 
   if (immutable_db_options_.enable_pipelined_write) {
@@ -106,7 +103,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
 
   PERF_TIMER_GUARD(write_pre_and_post_process_time);
   WriteThread::Writer w(write_options, my_batch, callback, log_ref,
-                        disable_memtable, batch_cnt, pre_release_callback);
+                        disable_memtable, pre_release_callback);
 
   if (!write_options.disableWAL) {
     RecordTick(stats_, WRITE_WITH_WAL);
@@ -125,7 +122,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
       w.status = WriteBatchInternal::InsertInto(
           &w, w.sequence, &column_family_memtables, &flush_scheduler_,
           write_options.ignore_missing_column_families, 0 /*log_number*/, this,
-          true /*concurrent_memtable_writes*/, seq_per_batch_, w.batch_cnt);
+          true /*concurrent_memtable_writes*/, seq_per_batch_);
     }
 
     if (write_thread_.CompleteParallelMemTableWriter(&w)) {
@@ -217,7 +214,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     uint64_t total_byte_size = 0;
     for (auto* writer : write_group) {
       if (writer->CheckCallback(this)) {
-        valid_batches += writer->batch_cnt;
+        valid_batches++;
         if (writer->ShouldWriteToMemtable()) {
           total_count += WriteBatchInternal::Count(writer->batch);
           parallel = parallel && !writer->batch->HasMerge();
@@ -306,8 +303,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
           }
           writer->sequence = next_sequence;
           if (seq_per_batch_) {
-            assert(writer->batch_cnt);
-            next_sequence += writer->batch_cnt;
+            next_sequence++;
           } else if (writer->ShouldWriteToMemtable()) {
             next_sequence += WriteBatchInternal::Count(writer->batch);
           }
@@ -327,8 +323,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
           w.status = WriteBatchInternal::InsertInto(
               &w, w.sequence, &column_family_memtables, &flush_scheduler_,
               write_options.ignore_missing_column_families, 0 /*log_number*/,
-              this, true /*concurrent_memtable_writes*/, seq_per_batch_,
-              w.batch_cnt);
+              this, true /*concurrent_memtable_writes*/, seq_per_batch_);
         }
       }
       if (seq_used != nullptr) {
@@ -520,13 +515,12 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
 Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
                                 WriteBatch* my_batch, WriteCallback* callback,
                                 uint64_t* log_used, uint64_t log_ref,
-                                uint64_t* seq_used, size_t batch_cnt,
+                                uint64_t* seq_used,
                                 PreReleaseCallback* pre_release_callback) {
   Status status;
   PERF_TIMER_GUARD(write_pre_and_post_process_time);
   WriteThread::Writer w(write_options, my_batch, callback, log_ref,
-                        true /* disable_memtable */, batch_cnt,
-                        pre_release_callback);
+                        true /* disable_memtable */, pre_release_callback);
   RecordTick(stats_, WRITE_WITH_WAL);
   StopWatch write_sw(env_, immutable_db_options_.statistics.get(), DB_WRITE);
 
@@ -582,15 +576,7 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
   PERF_TIMER_GUARD(write_wal_time);
   // LastAllocatedSequence is increased inside WriteToWAL under
   // wal_write_mutex_ to ensure ordered events in WAL
-  size_t seq_inc = 0 /* total_count */;
-  if (seq_per_batch_) {
-    size_t total_batch_cnt = 0;
-    for (auto* writer : write_group) {
-      assert(writer->batch_cnt);
-      total_batch_cnt += writer->batch_cnt;
-    }
-    seq_inc = total_batch_cnt;
-  }
+  size_t seq_inc = seq_per_batch_ ? write_group.size : 0 /*total_count*/;
   if (!write_options.disableWAL) {
     status =
         ConcurrentWriteToWAL(write_group, log_used, &last_sequence, seq_inc);
@@ -605,8 +591,7 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
     }
     writer->sequence = curr_seq;
     if (seq_per_batch_) {
-      assert(writer->batch_cnt);
-      curr_seq += writer->batch_cnt;
+      curr_seq++;
     }
     // else seq advances only by memtable writes
   }
@@ -1019,7 +1004,7 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
         break;
       }
       cfd->imm()->FlushRequested();
-      SchedulePendingFlush(cfd, FlushReason::kWriteBufferManager);
+      SchedulePendingFlush(cfd);
     }
   }
   MaybeScheduleFlushOrCompaction();
@@ -1065,7 +1050,7 @@ Status DBImpl::HandleWriteBufferFull(WriteContext* write_context) {
     status = SwitchMemtable(cfd_picked, write_context);
     if (status.ok()) {
       cfd_picked->imm()->FlushRequested();
-      SchedulePendingFlush(cfd_picked, FlushReason::kWriteBufferFull);
+      SchedulePendingFlush(cfd_picked);
       MaybeScheduleFlushOrCompaction();
     }
   }
@@ -1175,7 +1160,7 @@ Status DBImpl::ScheduleFlushes(WriteContext* context) {
 }
 
 #ifndef ROCKSDB_LITE
-void DBImpl::NotifyOnMemTableSealed(ColumnFamilyData* /*cfd*/,
+void DBImpl::NotifyOnMemTableSealed(ColumnFamilyData* cfd,
                                     const MemTableInfo& mem_table_info) {
   if (immutable_db_options_.listeners.size() == 0U) {
     return;
@@ -1307,29 +1292,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
                  ". Immutable memtables: %d.\n",
                  cfd->GetName().c_str(), new_log_number, num_imm_unflushed);
   mutex_.Lock();
-  if (s.ok() && creating_new_log) {
-    log_write_mutex_.Lock();
-    logfile_number_ = new_log_number;
-    assert(new_log != nullptr);
-    log_empty_ = true;
-    log_dir_synced_ = false;
-    if (!logs_.empty()) {
-      // Alway flush the buffer of the last log before switching to a new one
-      log::Writer* cur_log_writer = logs_.back().writer;
-      s = cur_log_writer->WriteBuffer();
-      if (!s.ok()) {
-        ROCKS_LOG_WARN(immutable_db_options_.info_log,
-                       "[%s] Failed to switch from #%" PRIu64 " to #%" PRIu64
-                       "  WAL file -- %s\n",
-                       cfd->GetName().c_str(), cur_log_writer->get_log_number(),
-                       new_log_number);
-      }
-    }
-    logs_.emplace_back(logfile_number_, new_log);
-    alive_log_files_.push_back(LogFileNumberSize(logfile_number_));
-    log_write_mutex_.Unlock();
-  }
-
   if (!s.ok()) {
     // how do we fail if we're not creating new log?
     assert(creating_new_log);
@@ -1340,7 +1302,21 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
     }
     return s;
   }
-
+  if (creating_new_log) {
+    log_write_mutex_.Lock();
+    logfile_number_ = new_log_number;
+    assert(new_log != nullptr);
+    log_empty_ = true;
+    log_dir_synced_ = false;
+    if (!logs_.empty()) {
+      // Alway flush the buffer of the last log before switching to a new one
+      log::Writer* cur_log_writer = logs_.back().writer;
+      cur_log_writer->WriteBuffer();
+    }
+    logs_.emplace_back(logfile_number_, new_log);
+    alive_log_files_.push_back(LogFileNumberSize(logfile_number_));
+    log_write_mutex_.Unlock();
+  }
   for (auto loop_cfd : *versions_->GetColumnFamilySet()) {
     // all this is just optimization to delete logs that
     // are no longer needed -- if CF is empty, that means it
@@ -1395,10 +1371,7 @@ Status DB::Put(const WriteOptions& opt, ColumnFamilyHandle* column_family,
   // 8 bytes are taken by header, 4 bytes for count, 1 byte for type,
   // and we allocate 11 extra bytes for key length, as well as value length.
   WriteBatch batch(key.size() + value.size() + 24);
-  Status s = batch.Put(column_family, key, value);
-  if (!s.ok()) {
-    return s;
-  }
+  batch.Put(column_family, key, value);
   return Write(opt, &batch);
 }
 
@@ -1427,10 +1400,7 @@ Status DB::DeleteRange(const WriteOptions& opt,
 Status DB::Merge(const WriteOptions& opt, ColumnFamilyHandle* column_family,
                  const Slice& key, const Slice& value) {
   WriteBatch batch;
-  Status s = batch.Merge(column_family, key, value);
-  if (!s.ok()) {
-    return s;
-  }
+  batch.Merge(column_family, key, value);
   return Write(opt, &batch);
 }
 }  // namespace rocksdb

db/db_iter.cc

@@ -217,9 +217,6 @@ class DBIter final: public Iterator {
         *prop = "Iterator is not valid.";
       }
       return Status::OK();
-    } else if (prop_name == "rocksdb.iterator.internal-key") {
-      *prop = saved_key_.GetUserKey().ToString();
-      return Status::OK();
     }
     return Status::InvalidArgument("Undentified property.");
   }
@@ -614,12 +611,10 @@ void DBIter::MergeValuesNewToOld() {
   // Start the merge process by pushing the first operand
   merge_context_.PushOperand(iter_->value(),
                              iter_->IsValuePinned() /* operand_pinned */);
-  TEST_SYNC_POINT("DBIter::MergeValuesNewToOld:PushedFirstOperand");
 
   ParsedInternalKey ikey;
   Status s;
   for (iter_->Next(); iter_->Valid(); iter_->Next()) {
-    TEST_SYNC_POINT("DBIter::MergeValuesNewToOld:SteppedToNextOperand");
     if (!ParseKey(&ikey)) {
       // skip corrupted key
       continue;

db/db_iterator_test.cc

@@ -18,39 +18,14 @@
 
 namespace rocksdb {
 
-// A dumb ReadCallback which saying every key is committed.
-class DummyReadCallback : public ReadCallback {
-  bool IsCommitted(SequenceNumber /*seq*/) { return true; }
-};
-
-// Test param:
-//   bool: whether to pass read_callback to NewIterator().
-class DBIteratorTest : public DBTestBase,
-                       public testing::WithParamInterface<bool> {
+class DBIteratorTest : public DBTestBase {
  public:
   DBIteratorTest() : DBTestBase("/db_iterator_test") {}
-
-  Iterator* NewIterator(const ReadOptions& read_options,
-                        ColumnFamilyHandle* column_family = nullptr) {
-    if (column_family == nullptr) {
-      column_family = db_->DefaultColumnFamily();
-    }
-    auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family)->cfd();
-    SequenceNumber seq = read_options.snapshot != nullptr
-                             ? read_options.snapshot->GetSequenceNumber()
-                             : db_->GetLatestSequenceNumber();
-    bool use_read_callback = GetParam();
-    ReadCallback* read_callback = use_read_callback ? &read_callback_ : nullptr;
-    return dbfull()->NewIteratorImpl(read_options, cfd, seq, read_callback);
-  }
-
- private:
-  DummyReadCallback read_callback_;
 };
 
 class FlushBlockEveryKeyPolicy : public FlushBlockPolicy {
  public:
-  virtual bool Update(const Slice& /*key*/, const Slice& /*value*/) override {
+  virtual bool Update(const Slice& key, const Slice& value) override {
     if (!start_) {
       start_ = true;
       return false;
@@ -70,41 +45,34 @@ class FlushBlockEveryKeyPolicyFactory : public FlushBlockPolicyFactory {
   }
 
   FlushBlockPolicy* NewFlushBlockPolicy(
-      const BlockBasedTableOptions& /*table_options*/,
-      const BlockBuilder& /*data_block_builder*/) const override {
+    const BlockBasedTableOptions& table_options,
+    const BlockBuilder& data_block_builder) const override {
     return new FlushBlockEveryKeyPolicy;
   }
 };
 
-TEST_P(DBIteratorTest, IteratorProperty) {
+TEST_F(DBIteratorTest, IteratorProperty) {
   // The test needs to be changed if kPersistedTier is supported in iterator.
   Options options = CurrentOptions();
   CreateAndReopenWithCF({"pikachu"}, options);
   Put(1, "1", "2");
-  Delete(1, "2");
   ReadOptions ropt;
   ropt.pin_data = false;
   {
-    unique_ptr<Iterator> iter(NewIterator(ropt, handles_[1]));
+    unique_ptr<Iterator> iter(db_->NewIterator(ropt, handles_[1]));
     iter->SeekToFirst();
     std::string prop_value;
     ASSERT_NOK(iter->GetProperty("non_existing.value", &prop_value));
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.is-key-pinned", &prop_value));
     ASSERT_EQ("0", prop_value);
-    ASSERT_OK(iter->GetProperty("rocksdb.iterator.internal-key", &prop_value));
-    ASSERT_EQ("1", prop_value);
     iter->Next();
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.is-key-pinned", &prop_value));
     ASSERT_EQ("Iterator is not valid.", prop_value);
-
-    // Get internal key at which the iteration stopped (tombstone in this case).
-    ASSERT_OK(iter->GetProperty("rocksdb.iterator.internal-key", &prop_value));
-    ASSERT_EQ("2", prop_value);
   }
   Close();
 }
 
-TEST_P(DBIteratorTest, PersistedTierOnIterator) {
+TEST_F(DBIteratorTest, PersistedTierOnIterator) {
   // The test needs to be changed if kPersistedTier is supported in iterator.
   Options options = CurrentOptions();
   CreateAndReopenWithCF({"pikachu"}, options);
@@ -120,7 +88,7 @@ TEST_P(DBIteratorTest, PersistedTierOnIterator) {
   Close();
 }
 
-TEST_P(DBIteratorTest, NonBlockingIteration) {
+TEST_F(DBIteratorTest, NonBlockingIteration) {
   do {
     ReadOptions non_blocking_opts, regular_opts;
     Options options = CurrentOptions();
@@ -132,7 +100,7 @@ TEST_P(DBIteratorTest, NonBlockingIteration) {
 
     // scan using non-blocking iterator. We should find it because
     // it is in memtable.
-    Iterator* iter = NewIterator(non_blocking_opts, handles_[1]);
+    Iterator* iter = db_->NewIterator(non_blocking_opts, handles_[1]);
     int count = 0;
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
       ASSERT_OK(iter->status());
@@ -149,7 +117,7 @@ TEST_P(DBIteratorTest, NonBlockingIteration) {
     // kvs. Neither does it do any IOs to storage.
     uint64_t numopen = TestGetTickerCount(options, NO_FILE_OPENS);
     uint64_t cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
-    iter = NewIterator(non_blocking_opts, handles_[1]);
+    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
     count = 0;
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
       count++;
@@ -166,7 +134,7 @@ TEST_P(DBIteratorTest, NonBlockingIteration) {
     // verify that we can find it via a non-blocking scan
     numopen = TestGetTickerCount(options, NO_FILE_OPENS);
     cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
-    iter = NewIterator(non_blocking_opts, handles_[1]);
+    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
     count = 0;
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
       ASSERT_OK(iter->status());
@@ -185,7 +153,7 @@ TEST_P(DBIteratorTest, NonBlockingIteration) {
 }
 
 #ifndef ROCKSDB_LITE
-TEST_P(DBIteratorTest, ManagedNonBlockingIteration) {
+TEST_F(DBIteratorTest, ManagedNonBlockingIteration) {
   do {
     ReadOptions non_blocking_opts, regular_opts;
     Options options = CurrentOptions();
@@ -198,7 +166,7 @@ TEST_P(DBIteratorTest, ManagedNonBlockingIteration) {
 
     // scan using non-blocking iterator. We should find it because
     // it is in memtable.
-    Iterator* iter = NewIterator(non_blocking_opts, handles_[1]);
+    Iterator* iter = db_->NewIterator(non_blocking_opts, handles_[1]);
     int count = 0;
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
       ASSERT_OK(iter->status());
@@ -215,7 +183,7 @@ TEST_P(DBIteratorTest, ManagedNonBlockingIteration) {
     // kvs. Neither does it do any IOs to storage.
     int64_t numopen = TestGetTickerCount(options, NO_FILE_OPENS);
     int64_t cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
-    iter = NewIterator(non_blocking_opts, handles_[1]);
+    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
     count = 0;
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
       count++;
@@ -232,7 +200,7 @@ TEST_P(DBIteratorTest, ManagedNonBlockingIteration) {
     // verify that we can find it via a non-blocking scan
     numopen = TestGetTickerCount(options, NO_FILE_OPENS);
     cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
-    iter = NewIterator(non_blocking_opts, handles_[1]);
+    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
     count = 0;
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
       ASSERT_OK(iter->status());
@@ -251,7 +219,7 @@ TEST_P(DBIteratorTest, ManagedNonBlockingIteration) {
 }
 #endif  // ROCKSDB_LITE
 
-TEST_P(DBIteratorTest, IterSeekBeforePrev) {
+TEST_F(DBIteratorTest, IterSeekBeforePrev) {
   ASSERT_OK(Put("a", "b"));
   ASSERT_OK(Put("c", "d"));
   dbfull()->Flush(FlushOptions());
@@ -259,7 +227,7 @@ TEST_P(DBIteratorTest, IterSeekBeforePrev) {
   ASSERT_OK(Put("1", "h"));
   dbfull()->Flush(FlushOptions());
   ASSERT_OK(Put("2", "j"));
-  auto iter = NewIterator(ReadOptions());
+  auto iter = db_->NewIterator(ReadOptions());
   iter->Seek(Slice("c"));
   iter->Prev();
   iter->Seek(Slice("a"));
@@ -267,7 +235,7 @@ TEST_P(DBIteratorTest, IterSeekBeforePrev) {
   delete iter;
 }
 
-TEST_P(DBIteratorTest, IterSeekForPrevBeforeNext) {
+TEST_F(DBIteratorTest, IterSeekForPrevBeforeNext) {
   ASSERT_OK(Put("a", "b"));
   ASSERT_OK(Put("c", "d"));
   dbfull()->Flush(FlushOptions());
@@ -275,7 +243,7 @@ TEST_P(DBIteratorTest, IterSeekForPrevBeforeNext) {
   ASSERT_OK(Put("1", "h"));
   dbfull()->Flush(FlushOptions());
   ASSERT_OK(Put("2", "j"));
-  auto iter = NewIterator(ReadOptions());
+  auto iter = db_->NewIterator(ReadOptions());
   iter->SeekForPrev(Slice("0"));
   iter->Next();
   iter->SeekForPrev(Slice("1"));
@@ -289,7 +257,7 @@ std::string MakeLongKey(size_t length, char c) {
 }
 }  // namespace
 
-TEST_P(DBIteratorTest, IterLongKeys) {
+TEST_F(DBIteratorTest, IterLongKeys) {
   ASSERT_OK(Put(MakeLongKey(20, 0), "0"));
   ASSERT_OK(Put(MakeLongKey(32, 2), "2"));
   ASSERT_OK(Put("a", "b"));
@@ -297,7 +265,7 @@ TEST_P(DBIteratorTest, IterLongKeys) {
   ASSERT_OK(Put(MakeLongKey(50, 1), "1"));
   ASSERT_OK(Put(MakeLongKey(127, 3), "3"));
   ASSERT_OK(Put(MakeLongKey(64, 4), "4"));
-  auto iter = NewIterator(ReadOptions());
+  auto iter = db_->NewIterator(ReadOptions());
 
   // Create a key that needs to be skipped for Seq too new
   iter->Seek(MakeLongKey(20, 0));
@@ -319,7 +287,7 @@ TEST_P(DBIteratorTest, IterLongKeys) {
   ASSERT_EQ(IterStatus(iter), MakeLongKey(50, 1) + "->1");
   delete iter;
 
-  iter = NewIterator(ReadOptions());
+  iter = db_->NewIterator(ReadOptions());
   iter->Seek(MakeLongKey(50, 1));
   ASSERT_EQ(IterStatus(iter), MakeLongKey(50, 1) + "->1");
   iter->Next();
@@ -329,13 +297,13 @@ TEST_P(DBIteratorTest, IterLongKeys) {
   delete iter;
 }
 
-TEST_P(DBIteratorTest, IterNextWithNewerSeq) {
+TEST_F(DBIteratorTest, IterNextWithNewerSeq) {
   ASSERT_OK(Put("0", "0"));
   dbfull()->Flush(FlushOptions());
   ASSERT_OK(Put("a", "b"));
   ASSERT_OK(Put("c", "d"));
   ASSERT_OK(Put("d", "e"));
-  auto iter = NewIterator(ReadOptions());
+  auto iter = db_->NewIterator(ReadOptions());
 
   // Create a key that needs to be skipped for Seq too new
   for (uint64_t i = 0; i < last_options_.max_sequential_skip_in_iterations + 1;
@@ -355,13 +323,13 @@ TEST_P(DBIteratorTest, IterNextWithNewerSeq) {
   delete iter;
 }
 
-TEST_P(DBIteratorTest, IterPrevWithNewerSeq) {
+TEST_F(DBIteratorTest, IterPrevWithNewerSeq) {
   ASSERT_OK(Put("0", "0"));
   dbfull()->Flush(FlushOptions());
   ASSERT_OK(Put("a", "b"));
   ASSERT_OK(Put("c", "d"));
   ASSERT_OK(Put("d", "e"));
-  auto iter = NewIterator(ReadOptions());
+  auto iter = db_->NewIterator(ReadOptions());
 
   // Create a key that needs to be skipped for Seq too new
   for (uint64_t i = 0; i < last_options_.max_sequential_skip_in_iterations + 1;
@@ -386,14 +354,14 @@ TEST_P(DBIteratorTest, IterPrevWithNewerSeq) {
   delete iter;
 }
 
-TEST_P(DBIteratorTest, IterPrevWithNewerSeq2) {
+TEST_F(DBIteratorTest, IterPrevWithNewerSeq2) {
   ASSERT_OK(Put("0", "0"));
   dbfull()->Flush(FlushOptions());
   ASSERT_OK(Put("a", "b"));
   ASSERT_OK(Put("c", "d"));
   ASSERT_OK(Put("e", "f"));
-  auto iter = NewIterator(ReadOptions());
-  auto iter2 = NewIterator(ReadOptions());
+  auto iter = db_->NewIterator(ReadOptions());
+  auto iter2 = db_->NewIterator(ReadOptions());
   iter->Seek(Slice("c"));
   iter2->SeekForPrev(Slice("d"));
   ASSERT_EQ(IterStatus(iter), "c->d");
@@ -415,10 +383,10 @@ TEST_P(DBIteratorTest, IterPrevWithNewerSeq2) {
   delete iter2;
 }
 
-TEST_P(DBIteratorTest, IterEmpty) {
+TEST_F(DBIteratorTest, IterEmpty) {
   do {
     CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
-    Iterator* iter = NewIterator(ReadOptions(), handles_[1]);
+    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
 
     iter->SeekToFirst();
     ASSERT_EQ(IterStatus(iter), "(invalid)");
@@ -436,11 +404,11 @@ TEST_P(DBIteratorTest, IterEmpty) {
   } while (ChangeCompactOptions());
 }
 
-TEST_P(DBIteratorTest, IterSingle) {
+TEST_F(DBIteratorTest, IterSingle) {
   do {
     CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
     ASSERT_OK(Put(1, "a", "va"));
-    Iterator* iter = NewIterator(ReadOptions(), handles_[1]);
+    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
 
     iter->SeekToFirst();
     ASSERT_EQ(IterStatus(iter), "a->va");
@@ -487,13 +455,13 @@ TEST_P(DBIteratorTest, IterSingle) {
   } while (ChangeCompactOptions());
 }
 
-TEST_P(DBIteratorTest, IterMulti) {
+TEST_F(DBIteratorTest, IterMulti) {
   do {
     CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
     ASSERT_OK(Put(1, "a", "va"));
     ASSERT_OK(Put(1, "b", "vb"));
     ASSERT_OK(Put(1, "c", "vc"));
-    Iterator* iter = NewIterator(ReadOptions(), handles_[1]);
+    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
 
     iter->SeekToFirst();
     ASSERT_EQ(IterStatus(iter), "a->va");
@@ -586,7 +554,7 @@ TEST_P(DBIteratorTest, IterMulti) {
 
 // Check that we can skip over a run of user keys
 // by using reseek rather than sequential scan
-TEST_P(DBIteratorTest, IterReseek) {
+TEST_F(DBIteratorTest, IterReseek) {
   anon::OptionsOverride options_override;
   options_override.skip_policy = kSkipNoSnapshot;
   Options options = CurrentOptions(options_override);
@@ -603,7 +571,7 @@ TEST_P(DBIteratorTest, IterReseek) {
   ASSERT_OK(Put(1, "a", "one"));
   ASSERT_OK(Put(1, "a", "two"));
   ASSERT_OK(Put(1, "b", "bone"));
-  Iterator* iter = NewIterator(ReadOptions(), handles_[1]);
+  Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
   iter->SeekToFirst();
   ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
   ASSERT_EQ(IterStatus(iter), "a->two");
@@ -615,7 +583,7 @@ TEST_P(DBIteratorTest, IterReseek) {
   // insert a total of three keys with same userkey and verify
   // that reseek is still not invoked.
   ASSERT_OK(Put(1, "a", "three"));
-  iter = NewIterator(ReadOptions(), handles_[1]);
+  iter = db_->NewIterator(ReadOptions(), handles_[1]);
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "a->three");
   iter->Next();
@@ -626,7 +594,7 @@ TEST_P(DBIteratorTest, IterReseek) {
   // insert a total of four keys with same userkey and verify
   // that reseek is invoked.
   ASSERT_OK(Put(1, "a", "four"));
-  iter = NewIterator(ReadOptions(), handles_[1]);
+  iter = db_->NewIterator(ReadOptions(), handles_[1]);
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "a->four");
   ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
@@ -643,7 +611,7 @@ TEST_P(DBIteratorTest, IterReseek) {
 
   // Insert another version of b and assert that reseek is not invoked
   ASSERT_OK(Put(1, "b", "btwo"));
-  iter = NewIterator(ReadOptions(), handles_[1]);
+  iter = db_->NewIterator(ReadOptions(), handles_[1]);
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "b->btwo");
   ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
@@ -658,7 +626,7 @@ TEST_P(DBIteratorTest, IterReseek) {
   // of b and 4 versions of a.
   ASSERT_OK(Put(1, "b", "bthree"));
   ASSERT_OK(Put(1, "b", "bfour"));
-  iter = NewIterator(ReadOptions(), handles_[1]);
+  iter = db_->NewIterator(ReadOptions(), handles_[1]);
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "b->bfour");
   ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
@@ -672,7 +640,7 @@ TEST_P(DBIteratorTest, IterReseek) {
   delete iter;
 }
 
-TEST_P(DBIteratorTest, IterSmallAndLargeMix) {
+TEST_F(DBIteratorTest, IterSmallAndLargeMix) {
   do {
     CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
     ASSERT_OK(Put(1, "a", "va"));
@@ -681,7 +649,7 @@ TEST_P(DBIteratorTest, IterSmallAndLargeMix) {
     ASSERT_OK(Put(1, "d", std::string(100000, 'd')));
     ASSERT_OK(Put(1, "e", std::string(100000, 'e')));
 
-    Iterator* iter = NewIterator(ReadOptions(), handles_[1]);
+    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
 
     iter->SeekToFirst();
     ASSERT_EQ(IterStatus(iter), "a->va");
@@ -713,7 +681,7 @@ TEST_P(DBIteratorTest, IterSmallAndLargeMix) {
   } while (ChangeCompactOptions());
 }
 
-TEST_P(DBIteratorTest, IterMultiWithDelete) {
+TEST_F(DBIteratorTest, IterMultiWithDelete) {
   do {
     CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
     ASSERT_OK(Put(1, "ka", "va"));
@@ -722,7 +690,7 @@ TEST_P(DBIteratorTest, IterMultiWithDelete) {
     ASSERT_OK(Delete(1, "kb"));
     ASSERT_EQ("NOT_FOUND", Get(1, "kb"));
 
-    Iterator* iter = NewIterator(ReadOptions(), handles_[1]);
+    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
     iter->Seek("kc");
     ASSERT_EQ(IterStatus(iter), "kc->vc");
     if (!CurrentOptions().merge_operator) {
@@ -739,7 +707,7 @@ TEST_P(DBIteratorTest, IterMultiWithDelete) {
   } while (ChangeOptions());
 }
 
-TEST_P(DBIteratorTest, IterPrevMaxSkip) {
+TEST_F(DBIteratorTest, IterPrevMaxSkip) {
   do {
     CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
     for (int i = 0; i < 2; i++) {
@@ -769,7 +737,7 @@ TEST_P(DBIteratorTest, IterPrevMaxSkip) {
   } while (ChangeOptions(kSkipMergePut | kSkipNoSeekToLast));
 }
 
-TEST_P(DBIteratorTest, IterWithSnapshot) {
+TEST_F(DBIteratorTest, IterWithSnapshot) {
   anon::OptionsOverride options_override;
   options_override.skip_policy = kSkipNoSnapshot;
   do {
@@ -783,7 +751,7 @@ TEST_P(DBIteratorTest, IterWithSnapshot) {
     const Snapshot* snapshot = db_->GetSnapshot();
     ReadOptions options;
     options.snapshot = snapshot;
-    Iterator* iter = NewIterator(options, handles_[1]);
+    Iterator* iter = db_->NewIterator(options, handles_[1]);
 
     ASSERT_OK(Put(1, "key0", "val0"));
     // Put more values after the snapshot
@@ -836,13 +804,13 @@ TEST_P(DBIteratorTest, IterWithSnapshot) {
   } while (ChangeOptions(kSkipHashCuckoo));
 }
 
-TEST_P(DBIteratorTest, IteratorPinsRef) {
+TEST_F(DBIteratorTest, IteratorPinsRef) {
   do {
     CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
     Put(1, "foo", "hello");
 
     // Get iterator that will yield the current contents of the DB.
-    Iterator* iter = NewIterator(ReadOptions(), handles_[1]);
+    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
 
     // Write to force compactions
     Put(1, "foo", "newvalue1");
@@ -862,7 +830,7 @@ TEST_P(DBIteratorTest, IteratorPinsRef) {
   } while (ChangeCompactOptions());
 }
 
-TEST_P(DBIteratorTest, DBIteratorBoundTest) {
+TEST_F(DBIteratorTest, DBIteratorBoundTest) {
   Options options = CurrentOptions();
   options.env = env_;
   options.create_if_missing = true;
@@ -879,7 +847,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundTest) {
     ReadOptions ro;
     ro.iterate_upper_bound = nullptr;
 
-    std::unique_ptr<Iterator> iter(NewIterator(ro));
+    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
 
     iter->Seek("foo");
 
@@ -916,7 +884,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundTest) {
     Slice prefix("foo2");
     ro.iterate_upper_bound = &prefix;
 
-    std::unique_ptr<Iterator> iter(NewIterator(ro));
+    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
 
     iter->Seek("foo");
 
@@ -938,7 +906,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundTest) {
     Slice prefix("foo");
     ro.iterate_upper_bound = &prefix;
 
-    std::unique_ptr<Iterator> iter(NewIterator(ro));
+    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
 
     iter->SeekToLast();
     ASSERT_TRUE(iter->Valid());
@@ -962,7 +930,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundTest) {
     Slice upper_bound("g");
     ro.iterate_upper_bound = &upper_bound;
 
-    std::unique_ptr<Iterator> iter(NewIterator(ro));
+    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
 
     iter->Seek("foo");
 
@@ -995,7 +963,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundTest) {
     ReadOptions ro;
     ro.iterate_upper_bound = nullptr;
 
-    std::unique_ptr<Iterator> iter(NewIterator(ro));
+    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
 
     iter->Seek("b");
     ASSERT_TRUE(iter->Valid());
@@ -1015,7 +983,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundTest) {
     Slice prefix("c");
     ro.iterate_upper_bound = &prefix;
 
-    iter.reset(NewIterator(ro));
+    iter.reset(db_->NewIterator(ro));
 
     get_perf_context()->Reset();
 
@@ -1036,7 +1004,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundTest) {
   }
 }
 
-TEST_P(DBIteratorTest, DBIteratorBoundOptimizationTest) {
+TEST_F(DBIteratorTest, DBIteratorBoundOptimizationTest) {
   int upper_bound_hits = 0;
   Options options = CurrentOptions();
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
@@ -1064,7 +1032,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundOptimizationTest) {
   ReadOptions ro;
   ro.iterate_upper_bound = &ub;
 
-  std::unique_ptr<Iterator> iter(NewIterator(ro));
+  std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
 
   iter->Seek("foo");
   ASSERT_TRUE(iter->Valid());
@@ -1082,7 +1050,7 @@ TEST_P(DBIteratorTest, DBIteratorBoundOptimizationTest) {
 }
 // TODO(3.13): fix the issue of Seek() + Prev() which might not necessary
 //             return the biggest key which is smaller than the seek key.
-TEST_P(DBIteratorTest, PrevAfterAndNextAfterMerge) {
+TEST_F(DBIteratorTest, PrevAfterAndNextAfterMerge) {
   Options options;
   options.create_if_missing = true;
   options.merge_operator = MergeOperators::CreatePutOperator();
@@ -1095,7 +1063,7 @@ TEST_P(DBIteratorTest, PrevAfterAndNextAfterMerge) {
   db_->Merge(wopts, "2", "data2");
   db_->Merge(wopts, "3", "data3");
 
-  std::unique_ptr<Iterator> it(NewIterator(ReadOptions()));
+  std::unique_ptr<Iterator> it(db_->NewIterator(ReadOptions()));
 
   it->Seek("2");
   ASSERT_TRUE(it->Valid());
@@ -1191,7 +1159,7 @@ class DBIteratorTestForPinnedData : public DBIteratorTest {
 
     ReadOptions ro;
     ro.pin_data = true;
-    auto iter = NewIterator(ro);
+    auto iter = db_->NewIterator(ro);
 
     {
       // Test Seek to random keys
@@ -1283,25 +1251,25 @@ class DBIteratorTestForPinnedData : public DBIteratorTest {
 }
 };
 
-TEST_P(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedNormal) {
+TEST_F(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedNormal) {
   PinnedDataIteratorRandomized(TestConfig::NORMAL);
 }
 
-TEST_P(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedCLoseAndOpen) {
+TEST_F(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedCLoseAndOpen) {
   PinnedDataIteratorRandomized(TestConfig::CLOSE_AND_OPEN);
 }
 
-TEST_P(DBIteratorTestForPinnedData,
+TEST_F(DBIteratorTestForPinnedData,
        PinnedDataIteratorRandomizedCompactBeforeRead) {
   PinnedDataIteratorRandomized(TestConfig::COMPACT_BEFORE_READ);
 }
 
-TEST_P(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedFlush) {
+TEST_F(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedFlush) {
   PinnedDataIteratorRandomized(TestConfig::FLUSH_EVERY_1000);
 }
 
 #ifndef ROCKSDB_LITE
-TEST_P(DBIteratorTest, PinnedDataIteratorMultipleFiles) {
+TEST_F(DBIteratorTest, PinnedDataIteratorMultipleFiles) {
   Options options = CurrentOptions();
   BlockBasedTableOptions table_options;
   table_options.use_delta_encoding = false;
@@ -1350,7 +1318,7 @@ TEST_P(DBIteratorTest, PinnedDataIteratorMultipleFiles) {
 
   ReadOptions ro;
   ro.pin_data = true;
-  auto iter = NewIterator(ro);
+  auto iter = db_->NewIterator(ro);
 
   std::vector<std::pair<Slice, std::string>> results;
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
@@ -1372,7 +1340,7 @@ TEST_P(DBIteratorTest, PinnedDataIteratorMultipleFiles) {
 }
 #endif
 
-TEST_P(DBIteratorTest, PinnedDataIteratorMergeOperator) {
+TEST_F(DBIteratorTest, PinnedDataIteratorMergeOperator) {
   Options options = CurrentOptions();
   BlockBasedTableOptions table_options;
   table_options.use_delta_encoding = false;
@@ -1405,7 +1373,7 @@ TEST_P(DBIteratorTest, PinnedDataIteratorMergeOperator) {
 
   ReadOptions ro;
   ro.pin_data = true;
-  auto iter = NewIterator(ro);
+  auto iter = db_->NewIterator(ro);
 
   std::vector<std::pair<Slice, std::string>> results;
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
@@ -1432,7 +1400,7 @@ TEST_P(DBIteratorTest, PinnedDataIteratorMergeOperator) {
   delete iter;
 }
 
-TEST_P(DBIteratorTest, PinnedDataIteratorReadAfterUpdate) {
+TEST_F(DBIteratorTest, PinnedDataIteratorReadAfterUpdate) {
   Options options = CurrentOptions();
   BlockBasedTableOptions table_options;
   table_options.use_delta_encoding = false;
@@ -1452,7 +1420,7 @@ TEST_P(DBIteratorTest, PinnedDataIteratorReadAfterUpdate) {
 
   ReadOptions ro;
   ro.pin_data = true;
-  auto iter = NewIterator(ro);
+  auto iter = db_->NewIterator(ro);
 
   // Delete 50% of the keys and update the other 50%
   for (auto& kv : true_data) {
@@ -1482,7 +1450,7 @@ TEST_P(DBIteratorTest, PinnedDataIteratorReadAfterUpdate) {
   delete iter;
 }
 
-TEST_P(DBIteratorTest, IterSeekForPrevCrossingFiles) {
+TEST_F(DBIteratorTest, IterSeekForPrevCrossingFiles) {
   Options options = CurrentOptions();
   options.prefix_extractor.reset(NewFixedPrefixTransform(1));
   options.disable_auto_compactions = true;
@@ -1511,7 +1479,7 @@ TEST_P(DBIteratorTest, IterSeekForPrevCrossingFiles) {
   MoveFilesToLevel(1);
   {
     ReadOptions ro;
-    Iterator* iter = NewIterator(ro);
+    Iterator* iter = db_->NewIterator(ro);
 
     iter->SeekForPrev("a4");
     ASSERT_EQ(iter->key().ToString(), "a3");
@@ -1529,14 +1497,14 @@ TEST_P(DBIteratorTest, IterSeekForPrevCrossingFiles) {
   {
     ReadOptions ro;
     ro.prefix_same_as_start = true;
-    Iterator* iter = NewIterator(ro);
+    Iterator* iter = db_->NewIterator(ro);
     iter->SeekForPrev("c2");
     ASSERT_TRUE(!iter->Valid());
     delete iter;
   }
 }
 
-TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocks) {
+TEST_F(DBIteratorTest, IterPrevKeyCrossingBlocks) {
   Options options = CurrentOptions();
   BlockBasedTableOptions table_options;
   table_options.block_size = 1;  // every block will contain one entry
@@ -1578,7 +1546,7 @@ TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocks) {
   {
     ReadOptions ro;
     ro.fill_cache = false;
-    Iterator* iter = NewIterator(ro);
+    Iterator* iter = db_->NewIterator(ro);
 
     iter->SeekToLast();
     ASSERT_EQ(iter->key().ToString(), "key5");
@@ -1604,7 +1572,7 @@ TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocks) {
   }
 }
 
-TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocksRandomized) {
+TEST_F(DBIteratorTest, IterPrevKeyCrossingBlocksRandomized) {
   Options options = CurrentOptions();
   options.merge_operator = MergeOperators::CreateStringAppendTESTOperator();
   options.disable_auto_compactions = true;
@@ -1680,7 +1648,7 @@ TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocksRandomized) {
   {
     ReadOptions ro;
     ro.fill_cache = false;
-    Iterator* iter = NewIterator(ro);
+    Iterator* iter = db_->NewIterator(ro);
     auto data_iter = true_data.rbegin();
 
     for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
@@ -1696,7 +1664,7 @@ TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocksRandomized) {
   {
     ReadOptions ro;
     ro.fill_cache = false;
-    Iterator* iter = NewIterator(ro);
+    Iterator* iter = db_->NewIterator(ro);
     auto data_iter = true_data.rbegin();
 
     int entries_right = 0;
@@ -1751,7 +1719,7 @@ TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocksRandomized) {
   }
 }
 
-TEST_P(DBIteratorTest, IteratorWithLocalStatistics) {
+TEST_F(DBIteratorTest, IteratorWithLocalStatistics) {
   Options options = CurrentOptions();
   options.statistics = rocksdb::CreateDBStatistics();
   DestroyAndReopen(options);
@@ -1772,7 +1740,7 @@ TEST_P(DBIteratorTest, IteratorWithLocalStatistics) {
   std::function<void()> reader_func_next = [&]() {
     SetPerfLevel(kEnableCount);
     get_perf_context()->Reset();
-    Iterator* iter = NewIterator(ReadOptions());
+    Iterator* iter = db_->NewIterator(ReadOptions());
 
     iter->SeekToFirst();
     // Seek will bump ITER_BYTES_READ
@@ -1799,7 +1767,7 @@ TEST_P(DBIteratorTest, IteratorWithLocalStatistics) {
 
   std::function<void()> reader_func_prev = [&]() {
     SetPerfLevel(kEnableCount);
-    Iterator* iter = NewIterator(ReadOptions());
+    Iterator* iter = db_->NewIterator(ReadOptions());
 
     iter->SeekToLast();
     // Seek will bump ITER_BYTES_READ
@@ -1845,7 +1813,7 @@ TEST_P(DBIteratorTest, IteratorWithLocalStatistics) {
 
 }
 
-TEST_P(DBIteratorTest, ReadAhead) {
+TEST_F(DBIteratorTest, ReadAhead) {
   Options options;
   env_->count_random_reads_ = true;
   options.env = env_;
@@ -1882,7 +1850,7 @@ TEST_P(DBIteratorTest, ReadAhead) {
   env_->random_read_bytes_counter_ = 0;
   options.statistics->setTickerCount(NO_FILE_OPENS, 0);
   ReadOptions read_options;
-  auto* iter = NewIterator(read_options);
+  auto* iter = db_->NewIterator(read_options);
   iter->SeekToFirst();
   int64_t num_file_opens = TestGetTickerCount(options, NO_FILE_OPENS);
   size_t bytes_read = env_->random_read_bytes_counter_;
@@ -1891,7 +1859,7 @@ TEST_P(DBIteratorTest, ReadAhead) {
   env_->random_read_bytes_counter_ = 0;
   options.statistics->setTickerCount(NO_FILE_OPENS, 0);
   read_options.readahead_size = 1024 * 10;
-  iter = NewIterator(read_options);
+  iter = db_->NewIterator(read_options);
   iter->SeekToFirst();
   int64_t num_file_opens_readahead = TestGetTickerCount(options, NO_FILE_OPENS);
   size_t bytes_read_readahead = env_->random_read_bytes_counter_;
@@ -1901,7 +1869,7 @@ TEST_P(DBIteratorTest, ReadAhead) {
   ASSERT_GT(bytes_read_readahead, read_options.readahead_size * 3);
 
   // Verify correctness.
-  iter = NewIterator(read_options);
+  iter = db_->NewIterator(read_options);
   int count = 0;
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
     ASSERT_EQ(value, iter->value());
@@ -1918,7 +1886,7 @@ TEST_P(DBIteratorTest, ReadAhead) {
 // Insert a key, create a snapshot iterator, overwrite key lots of times,
 // seek to a smaller key. Expect DBIter to fall back to a seek instead of
 // going through all the overwrites linearly.
-TEST_P(DBIteratorTest, DBIteratorSkipRecentDuplicatesTest) {
+TEST_F(DBIteratorTest, DBIteratorSkipRecentDuplicatesTest) {
   Options options = CurrentOptions();
   options.env = env_;
   options.create_if_missing = true;
@@ -1933,7 +1901,7 @@ TEST_P(DBIteratorTest, DBIteratorSkipRecentDuplicatesTest) {
 
   // Create iterator.
   ReadOptions ro;
-  std::unique_ptr<Iterator> iter(NewIterator(ro));
+  std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
 
   // Insert a lot.
   for (int i = 0; i < 100; ++i) {
@@ -1971,10 +1939,10 @@ TEST_P(DBIteratorTest, DBIteratorSkipRecentDuplicatesTest) {
                  NUMBER_OF_RESEEKS_IN_ITERATION));
 }
 
-TEST_P(DBIteratorTest, Refresh) {
+TEST_F(DBIteratorTest, Refresh) {
   ASSERT_OK(Put("x", "y"));
 
-  std::unique_ptr<Iterator> iter(NewIterator(ReadOptions()));
+  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
   iter->Seek(Slice("a"));
   ASSERT_TRUE(iter->Valid());
   ASSERT_EQ(iter->key().compare(Slice("x")), 0);
@@ -2030,20 +1998,20 @@ TEST_P(DBIteratorTest, Refresh) {
   iter.reset();
 }
 
-TEST_P(DBIteratorTest, CreationFailure) {
+TEST_F(DBIteratorTest, CreationFailure) {
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::NewInternalIterator:StatusCallback", [](void* arg) {
         *(reinterpret_cast<Status*>(arg)) = Status::Corruption("test status");
       });
   SyncPoint::GetInstance()->EnableProcessing();
 
-  Iterator* iter = NewIterator(ReadOptions());
+  Iterator* iter = db_->NewIterator(ReadOptions());
   ASSERT_FALSE(iter->Valid());
   ASSERT_TRUE(iter->status().IsCorruption());
   delete iter;
 }
 
-TEST_P(DBIteratorTest, TableFilter) {
+TEST_F(DBIteratorTest, TableFilter) {
   ASSERT_OK(Put("a", "1"));
   dbfull()->Flush(FlushOptions());
   ASSERT_OK(Put("b", "2"));
@@ -2068,7 +2036,7 @@ TEST_P(DBIteratorTest, TableFilter) {
       }
       return true;
     };
-    auto iter = NewIterator(opts);
+    auto iter = db_->NewIterator(opts);
     iter->SeekToFirst();
     ASSERT_EQ(IterStatus(iter), "a->1");
     iter->Next();
@@ -2094,7 +2062,7 @@ TEST_P(DBIteratorTest, TableFilter) {
     opts.table_filter = [](const TableProperties& props) {
       return props.num_entries != 2;
     };
-    auto iter = NewIterator(opts);
+    auto iter = db_->NewIterator(opts);
     iter->SeekToFirst();
     ASSERT_EQ(IterStatus(iter), "a->1");
     iter->Next();
@@ -2109,7 +2077,7 @@ TEST_P(DBIteratorTest, TableFilter) {
   }
 }
 
-TEST_P(DBIteratorTest, SkipStatistics) {
+TEST_F(DBIteratorTest, SkipStatistics) {
   Options options = CurrentOptions();
   options.statistics = rocksdb::CreateDBStatistics();
   DestroyAndReopen(options);
@@ -2131,7 +2099,7 @@ TEST_P(DBIteratorTest, SkipStatistics) {
   ASSERT_OK(Delete("e"));
   ASSERT_OK(Delete("f"));
 
-  Iterator* iter = NewIterator(ReadOptions());
+  Iterator* iter = db_->NewIterator(ReadOptions());
   int count = 0;
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
     ASSERT_OK(iter->status());
@@ -2142,7 +2110,7 @@ TEST_P(DBIteratorTest, SkipStatistics) {
   skip_count += 8; // 3 deletes + 3 original keys + 2 lower in sequence
   ASSERT_EQ(skip_count, TestGetTickerCount(options, NUMBER_ITER_SKIP));
 
-  iter = NewIterator(ReadOptions());
+  iter = db_->NewIterator(ReadOptions());
   count = 0;
   for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
     ASSERT_OK(iter->status());
@@ -2166,7 +2134,7 @@ TEST_P(DBIteratorTest, SkipStatistics) {
   Slice prefix("b");
   ro.iterate_upper_bound = &prefix;
 
-  iter = NewIterator(ro);
+  iter = db_->NewIterator(ro);
   count = 0;
   for(iter->Seek("aa"); iter->Valid(); iter->Next()) {
     ASSERT_OK(iter->status());
@@ -2177,7 +2145,7 @@ TEST_P(DBIteratorTest, SkipStatistics) {
   skip_count += 6; // 3 deletes + 3 original keys
   ASSERT_EQ(skip_count, TestGetTickerCount(options, NUMBER_ITER_SKIP));
 
-  iter = NewIterator(ro);
+  iter = db_->NewIterator(ro);
   count = 0;
   for(iter->SeekToLast(); iter->Valid(); iter->Prev()) {
     ASSERT_OK(iter->status());
@@ -2190,55 +2158,7 @@ TEST_P(DBIteratorTest, SkipStatistics) {
   ASSERT_EQ(skip_count, TestGetTickerCount(options, NUMBER_ITER_SKIP));
 }
 
-TEST_P(DBIteratorTest, SeekAfterHittingManyInternalKeys) {
-  Options options = CurrentOptions();
-  DestroyAndReopen(options);
-  ReadOptions ropts;
-  ropts.max_skippable_internal_keys = 2;
-
-  Put("1", "val_1");
-  // Add more tombstones than max_skippable_internal_keys so that Next() fails.
-  Delete("2");
-  Delete("3");
-  Delete("4");
-  Delete("5");
-  Put("6", "val_6");
-
-  unique_ptr<Iterator> iter(NewIterator(ropts));
-  iter->SeekToFirst();
-
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(iter->key().ToString(), "1");
-  ASSERT_EQ(iter->value().ToString(), "val_1");
-
-  // This should fail as incomplete due to too many non-visible internal keys on
-  // the way to the next valid user key.
-  iter->Next();
-  ASSERT_TRUE(!iter->Valid());
-  ASSERT_TRUE(iter->status().IsIncomplete());
-
-  // Get the internal key at which Next() failed.
-  std::string prop_value;
-  ASSERT_OK(iter->GetProperty("rocksdb.iterator.internal-key", &prop_value));
-  ASSERT_EQ("4", prop_value);
-
-  // Create a new iterator to seek to the internal key.
-  unique_ptr<Iterator> iter2(NewIterator(ropts));
-  iter2->Seek(prop_value);
-  ASSERT_TRUE(iter2->Valid());
-  ASSERT_OK(iter2->status());
-
-  ASSERT_EQ(iter2->key().ToString(), "6");
-  ASSERT_EQ(iter2->value().ToString(), "val_6");
-}
-
-INSTANTIATE_TEST_CASE_P(DBIteratorTestInstance, DBIteratorTest,
-                        testing::Values(true, false));
-
-// Tests how DBIter work with ReadCallback
-class DBIteratorWithReadCallbackTest : public DBIteratorTest {};
-
-TEST_F(DBIteratorWithReadCallbackTest, ReadCallback) {
+TEST_F(DBIteratorTest, ReadCallback) {
   class TestReadCallback : public ReadCallback {
    public:
     explicit TestReadCallback(SequenceNumber last_visible_seq)

db/db_memtable_test.cc

@@ -28,11 +28,13 @@ class MockMemTableRep : public MemTableRep {
     return rep_->Allocate(len, buf);
   }
 
-  virtual void Insert(KeyHandle handle) override { rep_->Insert(handle); }
+  virtual void Insert(KeyHandle handle) override {
+    return rep_->Insert(handle);
+  }
 
   virtual void InsertWithHint(KeyHandle handle, void** hint) override {
     num_insert_with_hint_++;
-    EXPECT_NE(nullptr, hint);
+    ASSERT_NE(nullptr, hint);
     last_hint_in_ = *hint;
     rep_->InsertWithHint(handle, hint);
     last_hint_out_ = *hint;
@@ -119,7 +121,7 @@ class TestPrefixExtractor : public SliceTransform {
     return separator(key) != nullptr;
   }
 
-  virtual bool InRange(const Slice& /*key*/) const override { return false; }
+  virtual bool InRange(const Slice& key) const override { return false; }
 
  private:
   const char* separator(const Slice& key) const {
@@ -127,84 +129,6 @@ class TestPrefixExtractor : public SliceTransform {
   }
 };
 
-// Test that ::Add properly returns false when inserting duplicate keys
-TEST_F(DBMemTableTest, DuplicateSeq) {
-  SequenceNumber seq = 123;
-  std::string value;
-  Status s;
-  MergeContext merge_context;
-  Options options;
-  InternalKeyComparator ikey_cmp(options.comparator);
-  RangeDelAggregator range_del_agg(ikey_cmp, {} /* snapshots */);
-
-  // Create a MemTable
-  InternalKeyComparator cmp(BytewiseComparator());
-  auto factory = std::make_shared<SkipListFactory>();
-  options.memtable_factory = factory;
-  ImmutableCFOptions ioptions(options);
-  WriteBufferManager wb(options.db_write_buffer_size);
-  MemTable* mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb,
-                               kMaxSequenceNumber, 0 /* column_family_id */);
-
-  // Write some keys and make sure it returns false on duplicates
-  bool res;
-  res = mem->Add(seq, kTypeValue, "key", "value2");
-  ASSERT_TRUE(res);
-  res = mem->Add(seq, kTypeValue, "key", "value2");
-  ASSERT_FALSE(res);
-  // Changing the type should still cause the duplicatae key
-  res = mem->Add(seq, kTypeMerge, "key", "value2");
-  ASSERT_FALSE(res);
-  // Changing the seq number will make the key fresh
-  res = mem->Add(seq + 1, kTypeMerge, "key", "value2");
-  ASSERT_TRUE(res);
-  // Test with different types for duplicate keys
-  res = mem->Add(seq, kTypeDeletion, "key", "");
-  ASSERT_FALSE(res);
-  res = mem->Add(seq, kTypeSingleDeletion, "key", "");
-  ASSERT_FALSE(res);
-
-  // Test the duplicate keys under stress
-  for (int i = 0; i < 10000; i++) {
-    bool insert_dup = i % 10 == 1;
-    if (!insert_dup) {
-      seq++;
-    }
-    res = mem->Add(seq, kTypeValue, "foo", "value" + ToString(seq));
-    if (insert_dup) {
-      ASSERT_FALSE(res);
-    } else {
-      ASSERT_TRUE(res);
-    }
-  }
-  delete mem;
-
-  // Test with InsertWithHint
-  options.memtable_insert_with_hint_prefix_extractor.reset(
-      new TestPrefixExtractor());  // which uses _ to extract the prefix
-  ioptions = ImmutableCFOptions(options);
-  mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb,
-                     kMaxSequenceNumber, 0 /* column_family_id */);
-  // Insert a duplicate key with _ in it
-  res = mem->Add(seq, kTypeValue, "key_1", "value");
-  ASSERT_TRUE(res);
-  res = mem->Add(seq, kTypeValue, "key_1", "value");
-  ASSERT_FALSE(res);
-  delete mem;
-
-  // Test when InsertConcurrently will be invoked
-  options.allow_concurrent_memtable_write = true;
-  ioptions = ImmutableCFOptions(options);
-  mem = new MemTable(cmp, ioptions, MutableCFOptions(options), &wb,
-                     kMaxSequenceNumber, 0 /* column_family_id */);
-  MemTablePostProcessInfo post_process_info;
-  res = mem->Add(seq, kTypeValue, "key", "value", true, &post_process_info);
-  ASSERT_TRUE(res);
-  res = mem->Add(seq, kTypeValue, "key", "value", true, &post_process_info);
-  ASSERT_FALSE(res);
-  delete mem;
-}
-
 TEST_F(DBMemTableTest, InsertWithHint) {
   Options options;
   options.allow_concurrent_memtable_write = false;

db/db_merge_operator_test.cc

@@ -14,43 +14,10 @@
 
 namespace rocksdb {
 
-class TestReadCallback : public ReadCallback {
- public:
-  TestReadCallback(SnapshotChecker* snapshot_checker,
-                   SequenceNumber snapshot_seq)
-      : snapshot_checker_(snapshot_checker), snapshot_seq_(snapshot_seq) {}
-
-  bool IsCommitted(SequenceNumber seq) override {
-    return snapshot_checker_->IsInSnapshot(seq, snapshot_seq_);
-  }
-
- private:
-  SnapshotChecker* snapshot_checker_;
-  SequenceNumber snapshot_seq_;
-};
-
 // Test merge operator functionality.
 class DBMergeOperatorTest : public DBTestBase {
  public:
   DBMergeOperatorTest() : DBTestBase("/db_merge_operator_test") {}
-
-  std::string GetWithReadCallback(SnapshotChecker* snapshot_checker,
-                                  const Slice& key,
-                                  const Snapshot* snapshot = nullptr) {
-    SequenceNumber seq = snapshot == nullptr ? db_->GetLatestSequenceNumber()
-                                             : snapshot->GetSequenceNumber();
-    TestReadCallback read_callback(snapshot_checker, seq);
-    ReadOptions read_opt;
-    read_opt.snapshot = snapshot;
-    PinnableSlice value;
-    Status s =
-        dbfull()->GetImpl(read_opt, db_->DefaultColumnFamily(), key, &value,
-                          nullptr /*value_found*/, &read_callback);
-    if (!s.ok()) {
-      return s.ToString();
-    }
-    return value.ToString();
-  }
 };
 
 TEST_F(DBMergeOperatorTest, LimitMergeOperands) {
@@ -482,152 +449,8 @@ TEST_P(MergeOperatorPinningTest, TailingIterator) {
   writer_thread.join();
   reader_thread.join();
 }
-
-TEST_F(DBMergeOperatorTest, TailingIteratorMemtableUnrefedBySomeoneElse) {
-  Options options = CurrentOptions();
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  DestroyAndReopen(options);
-
-  // Overview of the test:
-  //  * There are two merge operands for the same key: one in an sst file,
-  //    another in a memtable.
-  //  * Seek a tailing iterator to this key.
-  //  * As part of the seek, the iterator will:
-  //      (a) first visit the operand in the memtable and tell ForwardIterator
-  //          to pin this operand, then
-  //      (b) move on to the operand in the sst file, then pass both operands
-  //          to merge operator.
-  //  * The memtable may get flushed and unreferenced by another thread between
-  //    (a) and (b). The test simulates it by flushing the memtable inside a
-  //    SyncPoint callback located between (a) and (b).
-  //  * In this case it's ForwardIterator's responsibility to keep the memtable
-  //    pinned until (b) is complete. There used to be a bug causing
-  //    ForwardIterator to not pin it in some circumstances. This test
-  //    reproduces it.
-
-  db_->Merge(WriteOptions(), "key", "sst");
-  db_->Flush(FlushOptions()); // Switch to SuperVersion A
-  db_->Merge(WriteOptions(), "key", "memtable");
-
-  // Pin SuperVersion A
-  std::unique_ptr<Iterator> someone_else(db_->NewIterator(ReadOptions()));
-
-  bool pushed_first_operand = false;
-  bool stepped_to_next_operand = false;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBIter::MergeValuesNewToOld:PushedFirstOperand", [&](void*) {
-        EXPECT_FALSE(pushed_first_operand);
-        pushed_first_operand = true;
-        db_->Flush(FlushOptions()); // Switch to SuperVersion B
-      });
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBIter::MergeValuesNewToOld:SteppedToNextOperand", [&](void*) {
-        EXPECT_FALSE(stepped_to_next_operand);
-        stepped_to_next_operand = true;
-        someone_else.reset(); // Unpin SuperVersion A
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  ReadOptions ro;
-  ro.tailing = true;
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
-  iter->Seek("key");
-
-  ASSERT_TRUE(iter->status().ok());
-  ASSERT_TRUE(iter->Valid());
-  EXPECT_EQ(std::string("sst,memtable"), iter->value().ToString());
-  EXPECT_TRUE(pushed_first_operand);
-  EXPECT_TRUE(stepped_to_next_operand);
-}
 #endif  // ROCKSDB_LITE
 
-TEST_F(DBMergeOperatorTest, SnapshotCheckerAndReadCallback) {
-  Options options = CurrentOptions();
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  DestroyAndReopen(options);
-
-  class TestSnapshotChecker : public SnapshotChecker {
-    bool IsInSnapshot(SequenceNumber seq,
-                      SequenceNumber snapshot_seq) const override {
-      switch (snapshot_seq) {
-        case 0:
-          return seq == 0;
-        case 1:
-          return seq <= 1;
-        case 2:
-          // seq = 2 not visible to snapshot with seq = 2
-          return seq <= 1;
-        case 3:
-          return seq <= 3;
-        case 4:
-          // seq = 4 not visible to snpahost with seq = 4
-          return seq <= 3;
-        default:
-          // seq >=4 is uncommitted
-          return seq <= 4;
-      };
-    }
-  };
-  TestSnapshotChecker* snapshot_checker = new TestSnapshotChecker();
-  dbfull()->SetSnapshotChecker(snapshot_checker);
-
-  std::string value;
-  ASSERT_OK(Merge("foo", "v1"));
-  ASSERT_EQ(1, db_->GetLatestSequenceNumber());
-  ASSERT_EQ("v1", GetWithReadCallback(snapshot_checker, "foo"));
-  ASSERT_OK(Merge("foo", "v2"));
-  ASSERT_EQ(2, db_->GetLatestSequenceNumber());
-  // v2 is not visible to latest snapshot, which has seq = 2.
-  ASSERT_EQ("v1", GetWithReadCallback(snapshot_checker, "foo"));
-  // Take a snapshot with seq = 2.
-  const Snapshot* snapshot1 = db_->GetSnapshot();
-  ASSERT_EQ(2, snapshot1->GetSequenceNumber());
-  // v2 is not visible to snapshot1, which has seq = 2
-  ASSERT_EQ("v1", GetWithReadCallback(snapshot_checker, "foo", snapshot1));
-
-  // Verify flush doesn't alter the result.
-  ASSERT_OK(Flush());
-  ASSERT_EQ("v1", GetWithReadCallback(snapshot_checker, "foo", snapshot1));
-  ASSERT_EQ("v1", GetWithReadCallback(snapshot_checker, "foo"));
-
-  ASSERT_OK(Merge("foo", "v3"));
-  ASSERT_EQ(3, db_->GetLatestSequenceNumber());
-  ASSERT_EQ("v1,v2,v3", GetWithReadCallback(snapshot_checker, "foo"));
-  ASSERT_OK(Merge("foo", "v4"));
-  ASSERT_EQ(4, db_->GetLatestSequenceNumber());
-  // v4 is not visible to latest snapshot, which has seq = 4.
-  ASSERT_EQ("v1,v2,v3", GetWithReadCallback(snapshot_checker, "foo"));
-  const Snapshot* snapshot2 = db_->GetSnapshot();
-  ASSERT_EQ(4, snapshot2->GetSequenceNumber());
-  // v4 is not visible to snapshot2, which has seq = 4.
-  ASSERT_EQ("v1,v2,v3",
-            GetWithReadCallback(snapshot_checker, "foo", snapshot2));
-
-  // Verify flush doesn't alter the result.
-  ASSERT_OK(Flush());
-  ASSERT_EQ("v1", GetWithReadCallback(snapshot_checker, "foo", snapshot1));
-  ASSERT_EQ("v1,v2,v3",
-            GetWithReadCallback(snapshot_checker, "foo", snapshot2));
-  ASSERT_EQ("v1,v2,v3", GetWithReadCallback(snapshot_checker, "foo"));
-
-  ASSERT_OK(Merge("foo", "v5"));
-  ASSERT_EQ(5, db_->GetLatestSequenceNumber());
-  // v5 is uncommitted
-  ASSERT_EQ("v1,v2,v3,v4", GetWithReadCallback(snapshot_checker, "foo"));
-
-  // full manual compaction.
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-
-  // Verify compaction doesn't alter the result.
-  ASSERT_EQ("v1", GetWithReadCallback(snapshot_checker, "foo", snapshot1));
-  ASSERT_EQ("v1,v2,v3",
-            GetWithReadCallback(snapshot_checker, "foo", snapshot2));
-  ASSERT_EQ("v1,v2,v3,v4", GetWithReadCallback(snapshot_checker, "foo"));
-
-  db_->ReleaseSnapshot(snapshot1);
-  db_->ReleaseSnapshot(snapshot2);
-}
-
 }  // namespace rocksdb
 
 int main(int argc, char** argv) {

db/db_properties_test.cc

@@ -14,7 +14,6 @@
 
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "rocksdb/listener.h"
 #include "rocksdb/options.h"
 #include "rocksdb/perf_context.h"
 #include "rocksdb/perf_level.h"
@@ -986,9 +985,8 @@ class CountingUserTblPropCollector : public TablePropertiesCollector {
     return Status::OK();
   }
 
-  Status AddUserKey(const Slice& /*user_key*/, const Slice& /*value*/,
-                    EntryType /*type*/, SequenceNumber /*seq*/,
-                    uint64_t /*file_size*/) override {
+  Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type,
+                    SequenceNumber seq, uint64_t file_size) override {
     ++count_;
     return Status::OK();
   }
@@ -1029,9 +1027,8 @@ class CountingDeleteTabPropCollector : public TablePropertiesCollector {
  public:
   const char* Name() const override { return "CountingDeleteTabPropCollector"; }
 
-  Status AddUserKey(const Slice& /*user_key*/, const Slice& /*value*/,
-                    EntryType type, SequenceNumber /*seq*/,
-                    uint64_t /*file_size*/) override {
+  Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type,
+                    SequenceNumber seq, uint64_t file_size) override {
     if (type == kEntryDelete) {
       num_deletes_++;
     }
@@ -1058,7 +1055,7 @@ class CountingDeleteTabPropCollectorFactory
     : public TablePropertiesCollectorFactory {
  public:
   virtual TablePropertiesCollector* CreateTablePropertiesCollector(
-      TablePropertiesCollectorFactory::Context /*context*/) override {
+      TablePropertiesCollectorFactory::Context context) override {
     return new CountingDeleteTabPropCollector();
   }
   const char* Name() const override {
@@ -1386,56 +1383,6 @@ TEST_F(DBPropertiesTest, EstimateOldestKeyTime) {
   Close();
 }
 
-TEST_F(DBPropertiesTest, SstFilesSize) {
-  struct TestListener : public EventListener {
-    void OnCompactionCompleted(DB* db,
-                               const CompactionJobInfo& /*info*/) override {
-      assert(callback_triggered == false);
-      assert(size_before_compaction > 0);
-      callback_triggered = true;
-      uint64_t total_sst_size = 0;
-      uint64_t live_sst_size = 0;
-      bool ok = db->GetIntProperty(DB::Properties::kTotalSstFilesSize,
-                                   &total_sst_size);
-      ASSERT_TRUE(ok);
-      // total_sst_size include files before and after compaction.
-      ASSERT_GT(total_sst_size, size_before_compaction);
-      ok =
-          db->GetIntProperty(DB::Properties::kLiveSstFilesSize, &live_sst_size);
-      ASSERT_TRUE(ok);
-      // live_sst_size only include files after compaction.
-      ASSERT_GT(live_sst_size, 0);
-      ASSERT_LT(live_sst_size, size_before_compaction);
-    }
-
-    uint64_t size_before_compaction = 0;
-    bool callback_triggered = false;
-  };
-  std::shared_ptr<TestListener> listener = std::make_shared<TestListener>();
-
-  Options options;
-  options.disable_auto_compactions = true;
-  options.listeners.push_back(listener);
-  Reopen(options);
-
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put("key" + ToString(i), std::string(1000, 'v')));
-  }
-  ASSERT_OK(Flush());
-  for (int i = 0; i < 5; i++) {
-    ASSERT_OK(Delete("key" + ToString(i)));
-  }
-  ASSERT_OK(Flush());
-  uint64_t sst_size;
-  bool ok = db_->GetIntProperty(DB::Properties::kTotalSstFilesSize, &sst_size);
-  ASSERT_TRUE(ok);
-  ASSERT_GT(sst_size, 0);
-  listener->size_before_compaction = sst_size;
-  // Compact to clean all keys and trigger listener.
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_TRUE(listener->callback_triggered);
-}
-
 #endif  // ROCKSDB_LITE
 }  // namespace rocksdb
 

db/db_test.cc

@@ -480,36 +480,6 @@ TEST_F(DBTest, SingleDeletePutFlush) {
                          kSkipUniversalCompaction | kSkipMergePut));
 }
 
-// Disable because not all platform can run it.
-// It requires more than 9GB memory to run it, With single allocation
-// of more than 3GB.
-TEST_F(DBTest, DISABLED_SanitizeVeryVeryLargeValue) {
-  const size_t kValueSize = 4 * size_t{1024 * 1024 * 1024};  // 4GB value
-  std::string raw(kValueSize, 'v');
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.merge_operator = MergeOperators::CreatePutOperator();
-  options.write_buffer_size = 100000;  // Small write buffer
-  options.paranoid_checks = true;
-  DestroyAndReopen(options);
-
-  ASSERT_OK(Put("boo", "v1"));
-  ASSERT_TRUE(Put("foo", raw).IsInvalidArgument());
-  ASSERT_TRUE(Merge("foo", raw).IsInvalidArgument());
-
-  WriteBatch wb;
-  ASSERT_TRUE(wb.Put("foo", raw).IsInvalidArgument());
-  ASSERT_TRUE(wb.Merge("foo", raw).IsInvalidArgument());
-
-  Slice value_slice = raw;
-  Slice key_slice = "foo";
-  SliceParts sp_key(&key_slice, 1);
-  SliceParts sp_value(&value_slice, 1);
-
-  ASSERT_TRUE(wb.Put(sp_key, sp_value).IsInvalidArgument());
-  ASSERT_TRUE(wb.Merge(sp_key, sp_value).IsInvalidArgument());
-}
-
 // Disable because not all platform can run it.
 // It requires more than 9GB memory to run it, With single allocation
 // of more than 3GB.
@@ -750,9 +720,9 @@ TEST_F(DBTest, FlushSchedule) {
 namespace {
 class KeepFilter : public CompactionFilter {
  public:
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& /*value*/, std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
     return false;
   }
 
@@ -782,9 +752,9 @@ class KeepFilterFactory : public CompactionFilterFactory {
 class DelayFilter : public CompactionFilter {
  public:
   explicit DelayFilter(DBTestBase* d) : db_test(d) {}
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& /*value*/, std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
     db_test->env_->addon_time_.fetch_add(1000);
     return true;
   }
@@ -799,7 +769,7 @@ class DelayFilterFactory : public CompactionFilterFactory {
  public:
   explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {}
   virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
-      const CompactionFilter::Context& /*context*/) override {
+      const CompactionFilter::Context& context) override {
     return std::unique_ptr<CompactionFilter>(new DelayFilter(db_test));
   }
 
@@ -2247,17 +2217,17 @@ class ModelDB : public DB {
     return Write(o, &batch);
   }
   using DB::Get;
-  virtual Status Get(const ReadOptions& /*options*/, ColumnFamilyHandle* /*cf*/,
-                     const Slice& key, PinnableSlice* /*value*/) override {
+  virtual Status Get(const ReadOptions& options, ColumnFamilyHandle* cf,
+                     const Slice& key, PinnableSlice* value) override {
     return Status::NotSupported(key);
   }
 
   using DB::MultiGet;
   virtual std::vector<Status> MultiGet(
-      const ReadOptions& /*options*/,
-      const std::vector<ColumnFamilyHandle*>& /*column_family*/,
+      const ReadOptions& options,
+      const std::vector<ColumnFamilyHandle*>& column_family,
       const std::vector<Slice>& keys,
-      std::vector<std::string>* /*values*/) override {
+      std::vector<std::string>* values) override {
     std::vector<Status> s(keys.size(),
                           Status::NotSupported("Not implemented."));
     return s;
@@ -2266,9 +2236,9 @@ class ModelDB : public DB {
 #ifndef ROCKSDB_LITE
   using DB::IngestExternalFile;
   virtual Status IngestExternalFile(
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*external_files*/,
-      const IngestExternalFileOptions& /*options*/) override {
+      ColumnFamilyHandle* column_family,
+      const std::vector<std::string>& external_files,
+      const IngestExternalFileOptions& options) override {
     return Status::NotSupported("Not implemented.");
   }
 
@@ -2278,22 +2248,22 @@ class ModelDB : public DB {
 
   using DB::GetPropertiesOfAllTables;
   virtual Status GetPropertiesOfAllTables(
-      ColumnFamilyHandle* /*column_family*/,
-      TablePropertiesCollection* /*props*/) override {
+      ColumnFamilyHandle* column_family,
+      TablePropertiesCollection* props) override {
     return Status();
   }
 
   virtual Status GetPropertiesOfTablesInRange(
-      ColumnFamilyHandle* /*column_family*/, const Range* /*range*/,
-      std::size_t /*n*/, TablePropertiesCollection* /*props*/) override {
+      ColumnFamilyHandle* column_family, const Range* range, std::size_t n,
+      TablePropertiesCollection* props) override {
     return Status();
   }
 #endif  // ROCKSDB_LITE
 
   using DB::KeyMayExist;
-  virtual bool KeyMayExist(const ReadOptions& /*options*/,
-                           ColumnFamilyHandle* /*column_family*/,
-                           const Slice& /*key*/, std::string* /*value*/,
+  virtual bool KeyMayExist(const ReadOptions& options,
+                           ColumnFamilyHandle* column_family, const Slice& key,
+                           std::string* value,
                            bool* value_found = nullptr) override {
     if (value_found != nullptr) {
       *value_found = false;
@@ -2301,9 +2271,8 @@ class ModelDB : public DB {
     return true;  // Not Supported directly
   }
   using DB::NewIterator;
-  virtual Iterator* NewIterator(
-      const ReadOptions& options,
-      ColumnFamilyHandle* /*column_family*/) override {
+  virtual Iterator* NewIterator(const ReadOptions& options,
+                                ColumnFamilyHandle* column_family) override {
     if (options.snapshot == nullptr) {
       KVMap* saved = new KVMap;
       *saved = map_;
@@ -2315,9 +2284,9 @@ class ModelDB : public DB {
     }
   }
   virtual Status NewIterators(
-      const ReadOptions& /*options*/,
-      const std::vector<ColumnFamilyHandle*>& /*column_family*/,
-      std::vector<Iterator*>* /*iterators*/) override {
+      const ReadOptions& options,
+      const std::vector<ColumnFamilyHandle*>& column_family,
+      std::vector<Iterator*>* iterators) override {
     return Status::NotSupported("Not supported yet");
   }
   virtual const Snapshot* GetSnapshot() override {
@@ -2330,7 +2299,7 @@ class ModelDB : public DB {
     delete reinterpret_cast<const ModelSnapshot*>(snapshot);
   }
 
-  virtual Status Write(const WriteOptions& /*options*/,
+  virtual Status Write(const WriteOptions& options,
                        WriteBatch* batch) override {
     class Handler : public WriteBatch::Handler {
      public:
@@ -2338,8 +2307,7 @@ class ModelDB : public DB {
       virtual void Put(const Slice& key, const Slice& value) override {
         (*map_)[key.ToString()] = value.ToString();
       }
-      virtual void Merge(const Slice& /*key*/,
-                         const Slice& /*value*/) override {
+      virtual void Merge(const Slice& key, const Slice& value) override {
         // ignore merge for now
         // (*map_)[key.ToString()] = value.ToString();
       }
@@ -2353,65 +2321,62 @@ class ModelDB : public DB {
   }
 
   using DB::GetProperty;
-  virtual bool GetProperty(ColumnFamilyHandle* /*column_family*/,
-                           const Slice& /*property*/,
-                           std::string* /*value*/) override {
+  virtual bool GetProperty(ColumnFamilyHandle* column_family,
+                           const Slice& property, std::string* value) override {
     return false;
   }
   using DB::GetIntProperty;
-  virtual bool GetIntProperty(ColumnFamilyHandle* /*column_family*/,
-                              const Slice& /*property*/,
-                              uint64_t* /*value*/) override {
+  virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
+                              const Slice& property, uint64_t* value) override {
     return false;
   }
   using DB::GetMapProperty;
   virtual bool GetMapProperty(
-      ColumnFamilyHandle* /*column_family*/, const Slice& /*property*/,
-      std::map<std::string, std::string>* /*value*/) override {
+      ColumnFamilyHandle* column_family, const Slice& property,
+      std::map<std::string, std::string>* value) override {
     return false;
   }
   using DB::GetAggregatedIntProperty;
-  virtual bool GetAggregatedIntProperty(const Slice& /*property*/,
-                                        uint64_t* /*value*/) override {
+  virtual bool GetAggregatedIntProperty(const Slice& property,
+                                        uint64_t* value) override {
     return false;
   }
   using DB::GetApproximateSizes;
-  virtual void GetApproximateSizes(ColumnFamilyHandle* /*column_family*/,
-                                   const Range* /*range*/, int n,
-                                   uint64_t* sizes,
-                                   uint8_t /*include_flags*/
+  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
+                                   const Range* range, int n, uint64_t* sizes,
+                                   uint8_t include_flags
                                    = INCLUDE_FILES) override {
     for (int i = 0; i < n; i++) {
       sizes[i] = 0;
     }
   }
   using DB::GetApproximateMemTableStats;
-  virtual void GetApproximateMemTableStats(
-      ColumnFamilyHandle* /*column_family*/, const Range& /*range*/,
-      uint64_t* const count, uint64_t* const size) override {
+  virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
+                                           const Range& range,
+                                           uint64_t* const count,
+                                           uint64_t* const size) override {
     *count = 0;
     *size = 0;
   }
   using DB::CompactRange;
-  virtual Status CompactRange(const CompactRangeOptions& /*options*/,
-                              ColumnFamilyHandle* /*column_family*/,
-                              const Slice* /*start*/,
-                              const Slice* /*end*/) override {
+  virtual Status CompactRange(const CompactRangeOptions& options,
+                              ColumnFamilyHandle* column_family,
+                              const Slice* start, const Slice* end) override {
     return Status::NotSupported("Not supported operation.");
   }
 
   virtual Status SetDBOptions(
-      const std::unordered_map<std::string, std::string>& /*new_options*/)
+      const std::unordered_map<std::string, std::string>& new_options)
       override {
     return Status::NotSupported("Not supported operation.");
   }
 
   using DB::CompactFiles;
-  virtual Status CompactFiles(
-      const CompactionOptions& /*compact_options*/,
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*input_file_names*/,
-      const int /*output_level*/, const int /*output_path_id*/ = -1) override {
+  virtual Status CompactFiles(const CompactionOptions& compact_options,
+                              ColumnFamilyHandle* column_family,
+                              const std::vector<std::string>& input_file_names,
+                              const int output_level,
+                              const int output_path_id = -1) override {
     return Status::NotSupported("Not supported operation.");
   }
 
@@ -2424,25 +2389,24 @@ class ModelDB : public DB {
   }
 
   Status EnableAutoCompaction(
-      const std::vector<ColumnFamilyHandle*>& /*column_family_handles*/)
-      override {
+      const std::vector<ColumnFamilyHandle*>& column_family_handles) override {
     return Status::NotSupported("Not supported operation.");
   }
 
   using DB::NumberLevels;
-  virtual int NumberLevels(ColumnFamilyHandle* /*column_family*/) override {
+  virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
     return 1;
   }
 
   using DB::MaxMemCompactionLevel;
   virtual int MaxMemCompactionLevel(
-      ColumnFamilyHandle* /*column_family*/) override {
+      ColumnFamilyHandle* column_family) override {
     return 1;
   }
 
   using DB::Level0StopWriteTrigger;
   virtual int Level0StopWriteTrigger(
-      ColumnFamilyHandle* /*column_family*/) override {
+      ColumnFamilyHandle* column_family) override {
     return -1;
   }
 
@@ -2451,8 +2415,7 @@ class ModelDB : public DB {
   virtual Env* GetEnv() const override { return nullptr; }
 
   using DB::GetOptions;
-  virtual Options GetOptions(
-      ColumnFamilyHandle* /*column_family*/) const override {
+  virtual Options GetOptions(ColumnFamilyHandle* column_family) const override {
     return options_;
   }
 
@@ -2460,8 +2423,8 @@ class ModelDB : public DB {
   virtual DBOptions GetDBOptions() const override { return options_; }
 
   using DB::Flush;
-  virtual Status Flush(const rocksdb::FlushOptions& /*options*/,
-                       ColumnFamilyHandle* /*column_family*/) override {
+  virtual Status Flush(const rocksdb::FlushOptions& options,
+                       ColumnFamilyHandle* column_family) override {
     Status ret;
     return ret;
   }
@@ -2471,42 +2434,39 @@ class ModelDB : public DB {
 #ifndef ROCKSDB_LITE
   virtual Status DisableFileDeletions() override { return Status::OK(); }
 
-  virtual Status EnableFileDeletions(bool /*force*/) override {
+  virtual Status EnableFileDeletions(bool force) override {
     return Status::OK();
   }
-  virtual Status GetLiveFiles(std::vector<std::string>&, uint64_t* /*size*/,
-                              bool /*flush_memtable*/ = true) override {
+  virtual Status GetLiveFiles(std::vector<std::string>&, uint64_t* size,
+                              bool flush_memtable = true) override {
     return Status::OK();
   }
 
-  virtual Status GetSortedWalFiles(VectorLogPtr& /*files*/) override {
+  virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
     return Status::OK();
   }
 
-  virtual Status DeleteFile(std::string /*name*/) override {
-    return Status::OK();
-  }
+  virtual Status DeleteFile(std::string name) override { return Status::OK(); }
 
   virtual Status GetUpdatesSince(
       rocksdb::SequenceNumber, unique_ptr<rocksdb::TransactionLogIterator>*,
-      const TransactionLogIterator::ReadOptions& /*read_options*/ =
+      const TransactionLogIterator::ReadOptions& read_options =
           TransactionLogIterator::ReadOptions()) override {
     return Status::NotSupported("Not supported in Model DB");
   }
 
   virtual void GetColumnFamilyMetaData(
-      ColumnFamilyHandle* /*column_family*/,
-      ColumnFamilyMetaData* /*metadata*/) override {}
+      ColumnFamilyHandle* column_family,
+      ColumnFamilyMetaData* metadata) override {}
 #endif  // ROCKSDB_LITE
 
-  virtual Status GetDbIdentity(std::string& /*identity*/) const override {
+  virtual Status GetDbIdentity(std::string& identity) const override {
     return Status::OK();
   }
 
   virtual SequenceNumber GetLatestSequenceNumber() const override { return 0; }
 
-  virtual bool SetPreserveDeletesSequenceNumber(
-      SequenceNumber /*seqnum*/) override {
+  virtual bool SetPreserveDeletesSequenceNumber(SequenceNumber seqnum) override {
     return true;
   }
 
@@ -4786,7 +4746,7 @@ class DelayedMergeOperator : public MergeOperator {
  public:
   explicit DelayedMergeOperator(DBTest* d) : db_test_(d) {}
 
-  virtual bool FullMergeV2(const MergeOperationInput& /*merge_in*/,
+  virtual bool FullMergeV2(const MergeOperationInput& merge_in,
                            MergeOperationOutput* merge_out) const override {
     db_test_->env_->addon_time_.fetch_add(1000);
     merge_out->new_value = "";
@@ -5154,10 +5114,10 @@ TEST_F(DBTest, AutomaticConflictsWithManualCompaction) {
     ASSERT_OK(Flush());
   }
   std::thread manual_compaction_thread([this]() {
-    CompactRangeOptions croptions;
-    croptions.exclusive_manual_compaction = true;
-    ASSERT_OK(db_->CompactRange(croptions, nullptr, nullptr));
-  });
+      CompactRangeOptions croptions;
+      croptions.exclusive_manual_compaction = true;
+      ASSERT_OK(db_->CompactRange(croptions, nullptr, nullptr));
+    });
 
   TEST_SYNC_POINT("DBTest::AutomaticConflictsWithManualCompaction:PrePuts");
   for (int i = 0; i < kNumL0Files; ++i) {
@@ -5732,50 +5692,6 @@ TEST_F(DBTest, PauseBackgroundWorkTest) {
   // now it's done
   ASSERT_TRUE(done.load());
 }
-
-// Keep spawning short-living threads that create an iterator and quit.
-// Meanwhile in another thread keep flushing memtables.
-// This used to cause a deadlock.
-TEST_F(DBTest, ThreadLocalPtrDeadlock) {
-  std::atomic<int> flushes_done{0};
-  std::atomic<int> threads_destroyed{0};
-  auto done = [&] {
-    return flushes_done.load() > 10;
-  };
-
-  std::thread flushing_thread([&] {
-    for (int i = 0; !done(); ++i) {
-      ASSERT_OK(db_->Put(WriteOptions(), Slice("hi"),
-                         Slice(std::to_string(i).c_str())));
-      ASSERT_OK(db_->Flush(FlushOptions()));
-      int cnt = ++flushes_done;
-      fprintf(stderr, "Flushed %d times\n", cnt);
-    }
-  });
-
-  std::vector<std::thread> thread_spawning_threads(10);
-  for (auto& t: thread_spawning_threads) {
-    t = std::thread([&] {
-      while (!done()) {
-        {
-          std::thread tmp_thread([&] {
-            auto it = db_->NewIterator(ReadOptions());
-            delete it;
-          });
-          tmp_thread.join();
-        }
-        ++threads_destroyed;
-      }
-    });
-  }
-
-  for (auto& t: thread_spawning_threads) {
-    t.join();
-  }
-  flushing_thread.join();
-  fprintf(stderr, "Done. Flushed %d times, destroyed %d threads\n",
-          flushes_done.load(), threads_destroyed.load());
-}
 }  // namespace rocksdb
 
 int main(int argc, char** argv) {

db/db_test2.cc

@@ -498,9 +498,9 @@ TEST_F(DBTest2, WalFilterTest) {
       apply_option_at_record_index_(apply_option_for_record_index),
       current_record_index_(0) {}
 
-    virtual WalProcessingOption LogRecord(
-        const WriteBatch& /*batch*/, WriteBatch* /*new_batch*/,
-        bool* /*batch_changed*/) const override {
+    virtual WalProcessingOption LogRecord(const WriteBatch& batch,
+      WriteBatch* new_batch,
+      bool* batch_changed) const override {
       WalFilter::WalProcessingOption option_to_return;
 
       if (current_record_index_ == apply_option_at_record_index_) {
@@ -874,10 +874,11 @@ TEST_F(DBTest2, WalFilterTestWithColumnFamilies) {
       cf_name_id_map_ = cf_name_id_map;
     }
 
-    virtual WalProcessingOption LogRecordFound(
-        unsigned long long log_number, const std::string& /*log_file_name*/,
-        const WriteBatch& batch, WriteBatch* /*new_batch*/,
-        bool* /*batch_changed*/) override {
+    virtual WalProcessingOption LogRecordFound(unsigned long long log_number,
+      const std::string& log_file_name,
+      const WriteBatch& batch,
+      WriteBatch* new_batch,
+      bool* batch_changed) override {
       class LogRecordBatchHandler : public WriteBatch::Handler {
       private:
         const std::map<uint32_t, uint64_t> & cf_log_number_map_;
@@ -1230,7 +1231,7 @@ class CompactionStallTestListener : public EventListener {
  public:
   CompactionStallTestListener() : compacted_files_cnt_(0) {}
 
-  void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) override {
+  void OnCompactionCompleted(DB* db, const CompactionJobInfo& ci) override {
     ASSERT_EQ(ci.cf_name, "default");
     ASSERT_EQ(ci.base_input_level, 0);
     ASSERT_EQ(ci.compaction_reason, CompactionReason::kLevelL0FilesNum);
@@ -1819,17 +1820,11 @@ TEST_F(DBTest2, ReadAmpBitmap) {
 
 #ifndef OS_SOLARIS // GetUniqueIdFromFile is not implemented
 TEST_F(DBTest2, ReadAmpBitmapLiveInCacheAfterDBClose) {
-  {
-    const int kIdBufLen = 100;
-    char id_buf[kIdBufLen];
-    std::unique_ptr<RandomAccessFile> file;
-    env_->NewRandomAccessFile(dbname_, &file, EnvOptions());
-    if (file->GetUniqueId(id_buf, kIdBufLen) == 0) {
-      // fs holding db directory doesn't support getting a unique file id,
-      // this means that running this test will fail because lru_cache will load
-      // the blocks again regardless of them being already in the cache
-      return;
-    }
+  if (dbname_.find("dev/shm") != std::string::npos) {
+    // /dev/shm dont support getting a unique file id, this mean that
+    // running this test on /dev/shm will fail because lru_cache will load
+    // the blocks again regardless of them being already in the cache
+    return;
   }
   uint32_t bytes_per_bit[2] = {1, 16};
   for (size_t k = 0; k < 2; k++) {

db/db_test_util.cc

@@ -1143,18 +1143,17 @@ UpdateStatus DBTestBase::updateInPlaceSmallerVarintSize(char* prevValue,
   }
 }
 
-UpdateStatus DBTestBase::updateInPlaceLargerSize(char* /*prevValue*/,
-                                                 uint32_t* /*prevSize*/,
+UpdateStatus DBTestBase::updateInPlaceLargerSize(char* prevValue,
+                                                 uint32_t* prevSize,
                                                  Slice delta,
                                                  std::string* newValue) {
   *newValue = std::string(delta.size(), 'c');
   return UpdateStatus::UPDATED;
 }
 
-UpdateStatus DBTestBase::updateInPlaceNoAction(char* /*prevValue*/,
-                                               uint32_t* /*prevSize*/,
-                                               Slice /*delta*/,
-                                               std::string* /*newValue*/) {
+UpdateStatus DBTestBase::updateInPlaceNoAction(char* prevValue,
+                                               uint32_t* prevSize, Slice delta,
+                                               std::string* newValue) {
   return UpdateStatus::UPDATE_FAILED;
 }
 

db/db_test_util.h

@@ -137,8 +137,8 @@ class SpecialMemTableRep : public MemTableRep {
   // Insert key into the list.
   // REQUIRES: nothing that compares equal to key is currently in the list.
   virtual void Insert(KeyHandle handle) override {
-    num_entries_++;
     memtable_->Insert(handle);
+    num_entries_++;
   }
 
   // Returns true iff an entry that compares equal to key is in the list.
@@ -187,7 +187,7 @@ class SpecialSkipListFactory : public MemTableRepFactory {
   using MemTableRepFactory::CreateMemTableRep;
   virtual MemTableRep* CreateMemTableRep(
       const MemTableRep::KeyComparator& compare, Allocator* allocator,
-      const SliceTransform* transform, Logger* /*logger*/) override {
+      const SliceTransform* transform, Logger* logger) override {
     return new SpecialMemTableRep(
         allocator, factory_.CreateMemTableRep(compare, allocator, transform, 0),
         num_entries_flush_);

db/db_universal_compaction_test.cc

@@ -56,9 +56,9 @@ void VerifyCompactionResult(
 
 class KeepFilter : public CompactionFilter {
  public:
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& /*value*/, std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value, bool* value_changed) const
+      override {
     return false;
   }
 
@@ -88,9 +88,9 @@ class KeepFilterFactory : public CompactionFilterFactory {
 class DelayFilter : public CompactionFilter {
  public:
   explicit DelayFilter(DBTestBase* d) : db_test(d) {}
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& /*value*/, std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
     db_test->env_->addon_time_.fetch_add(1000);
     return true;
   }
@@ -105,7 +105,7 @@ class DelayFilterFactory : public CompactionFilterFactory {
  public:
   explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {}
   virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
-      const CompactionFilter::Context& /*context*/) override {
+      const CompactionFilter::Context& context) override {
     return std::unique_ptr<CompactionFilter>(new DelayFilter(db_test));
   }
 
@@ -388,16 +388,10 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionSizeAmplification) {
   DestroyAndReopen(options);
 
   int total_picked_compactions = 0;
-  int total_size_amp_compactions = 0;
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "UniversalCompactionPicker::PickCompaction:Return", [&](void* arg) {
         if (arg) {
           total_picked_compactions++;
-          Compaction* c = static_cast<Compaction*>(arg);
-          if (c->compaction_reason() ==
-              CompactionReason::kUniversalSizeAmplification) {
-            total_size_amp_compactions++;
-          }
         }
       });
   rocksdb::SyncPoint::GetInstance()->EnableProcessing();
@@ -451,102 +445,6 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionSizeAmplification) {
   // Verify that size amplification did happen
   ASSERT_EQ(NumSortedRuns(1), 1);
   ASSERT_EQ(total_picked_compactions, 1);
-  ASSERT_EQ(total_size_amp_compactions, 1);
-}
-
-TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionReadAmplification) {
-  Options options = CurrentOptions();
-  options.compaction_style = kCompactionStyleUniversal;
-  options.num_levels = 1;
-  options.write_buffer_size = 100 << 10;     // 100KB
-  options.target_file_size_base = 32 << 10;  // 32KB
-  options.level0_file_num_compaction_trigger = 3;
-  // Initial setup of compaction_options_universal will prevent universal
-  // compaction from happening
-  options.compaction_options_universal.max_size_amplification_percent = 2000;
-  options.compaction_options_universal.size_ratio = 0;
-  options.compaction_options_universal.min_merge_width = 100;
-  DestroyAndReopen(options);
-
-  int total_picked_compactions = 0;
-  int total_size_ratio_compactions = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "UniversalCompactionPicker::PickCompaction:Return", [&](void* arg) {
-        if (arg) {
-          total_picked_compactions++;
-          Compaction* c = static_cast<Compaction*>(arg);
-          if (c->compaction_reason() == CompactionReason::kUniversalSizeRatio) {
-            total_size_ratio_compactions++;
-          }
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  MutableCFOptions mutable_cf_options;
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  Random rnd(301);
-  int key_idx = 0;
-
-  // Generate three files in Level 0. All files are approx the same size.
-  for (int num = 0; num < options.level0_file_num_compaction_trigger; num++) {
-    // Write 110KB (11 values, each 10K)
-    for (int i = 0; i < 11; i++) {
-      ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
-      key_idx++;
-    }
-    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
-    ASSERT_EQ(NumSortedRuns(1), num + 1);
-  }
-  ASSERT_EQ(NumSortedRuns(1), options.level0_file_num_compaction_trigger);
-
-  // Flush whatever is remaining in memtable. This is typically small, about
-  // 30KB.
-  ASSERT_OK(Flush(1));
-  dbfull()->TEST_WaitForCompact();
-  // Verify compaction did not happen
-  ASSERT_EQ(NumSortedRuns(1), options.level0_file_num_compaction_trigger + 1);
-  ASSERT_EQ(total_picked_compactions, 0);
-
-  ASSERT_OK(dbfull()->SetOptions(
-      handles_[1],
-      {{"compaction_options_universal",
-        "{min_merge_width=2;max_merge_width=2;size_ratio=100;}"}}));
-  ASSERT_EQ(dbfull()
-                ->GetOptions(handles_[1])
-                .compaction_options_universal.min_merge_width,
-            2);
-  ASSERT_EQ(dbfull()
-                ->GetOptions(handles_[1])
-                .compaction_options_universal.max_merge_width,
-            2);
-  ASSERT_EQ(
-      dbfull()->GetOptions(handles_[1]).compaction_options_universal.size_ratio,
-      100);
-
-  ASSERT_OK(dbfull()->TEST_GetLatestMutableCFOptions(handles_[1],
-                                                     &mutable_cf_options));
-  ASSERT_EQ(mutable_cf_options.compaction_options_universal.size_ratio, 100);
-  ASSERT_EQ(mutable_cf_options.compaction_options_universal.min_merge_width, 2);
-  ASSERT_EQ(mutable_cf_options.compaction_options_universal.max_merge_width, 2);
-
-  dbfull()->TEST_WaitForCompact();
-
-  // Files in L0 are approx: 0.3 (30KB), 1, 1, 1.
-  // On compaction: the files are below the size amp threshold, so we
-  // fallthrough to checking read amp conditions. The configured size ratio is
-  // not big enough to take 0.3 into consideration. So the next files 1 and 1
-  // are compacted together first as they satisfy size ratio condition and
-  // (min_merge_width, max_merge_width) condition, to give out a file size of 2.
-  // Next, the newly generated 2 and the last file 1 are compacted together. So
-  // at the end: #sortedRuns = 2, #picked_compactions = 2, and all the picked
-  // ones are size ratio based compactions.
-  ASSERT_EQ(NumSortedRuns(1), 2);
-  // If max_merge_width had not been changed dynamically above, and if it
-  // continued to be the default value of UINIT_MAX, total_picked_compactions
-  // would have been 1.
-  ASSERT_EQ(total_picked_compactions, 2);
-  ASSERT_EQ(total_size_ratio_compactions, 2);
 }
 
 TEST_P(DBTestUniversalCompaction, CompactFilesOnUniversalCompaction) {

db/dbformat.cc

@@ -125,26 +125,6 @@ int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
   return r;
 }
 
-int InternalKeyComparator::CompareKeySeq(const Slice& akey,
-                                         const Slice& bkey) const {
-  // Order by:
-  //    increasing user key (according to user-supplied comparator)
-  //    decreasing sequence number
-  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
-  PERF_COUNTER_ADD(user_key_comparison_count, 1);
-  if (r == 0) {
-    // Shift the number to exclude the last byte which contains the value type
-    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8) >> 8;
-    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8) >> 8;
-    if (anum > bnum) {
-      r = -1;
-    } else if (anum < bnum) {
-      r = +1;
-    }
-  }
-  return r;
-}
-
 int InternalKeyComparator::Compare(const ParsedInternalKey& a,
                                    const ParsedInternalKey& b) const {
   // Order by:

db/dbformat.h

@@ -162,8 +162,6 @@ class InternalKeyComparator
 
   virtual const char* Name() const override;
   virtual int Compare(const Slice& a, const Slice& b) const override;
-  // Same as Compare except that it excludes the value type from comparison
-  virtual int CompareKeySeq(const Slice& a, const Slice& b) const;
   virtual void FindShortestSeparator(std::string* start,
                                      const Slice& limit) const override;
   virtual void FindShortSuccessor(std::string* key) const override;

db/deletefile_test.cc

@@ -159,7 +159,7 @@ class DeleteFileTest : public testing::Test {
   }
 
   // An empty job to guard all jobs are processed
-  static void GuardFinish(void* /*arg*/) {
+  static void GuardFinish(void* arg) {
     TEST_SYNC_POINT("DeleteFileTest::GuardFinish");
   }
 };

db/external_sst_file_ingestion_job.cc

@@ -132,15 +132,11 @@ Status ExternalSstFileIngestionJob::Prepare(
   return status;
 }
 
-Status ExternalSstFileIngestionJob::NeedsFlush(bool* flush_needed,
-                                               SuperVersion* super_version) {
-  autovector<Range> ranges;
-  for (const IngestedFileInfo& file_to_ingest : files_to_ingest_) {
-    ranges.emplace_back(file_to_ingest.smallest_user_key,
-                        file_to_ingest.largest_user_key);
-  }
+Status ExternalSstFileIngestionJob::NeedsFlush(bool* flush_needed) {
+  SuperVersion* super_version = cfd_->GetSuperVersion();
   Status status =
-      cfd_->RangesOverlapWithMemtables(ranges, super_version, flush_needed);
+      IngestedFilesOverlapWithMemtables(super_version, flush_needed);
+
   if (status.ok() && *flush_needed &&
       !ingestion_options_.allow_blocking_flush) {
     status = Status::InvalidArgument("External file requires flush");
@@ -152,12 +148,11 @@ Status ExternalSstFileIngestionJob::NeedsFlush(bool* flush_needed,
 // nonmem_write_thread_
 Status ExternalSstFileIngestionJob::Run() {
   Status status;
-  SuperVersion* super_version = cfd_->GetSuperVersion();
 #ifndef NDEBUG
   // We should never run the job with a memtable that is overlapping
   // with the files we are ingesting
   bool need_flush = false;
-  status = NeedsFlush(&need_flush, super_version);
+  status = NeedsFlush(&need_flush);
   assert(status.ok() && need_flush == false);
 #endif
 
@@ -172,6 +167,7 @@ Status ExternalSstFileIngestionJob::Run() {
   // It is safe to use this instead of LastAllocatedSequence since we are
   // the only active writer, and hence they are equal
   const SequenceNumber last_seqno = versions_->LastSequence();
+  SuperVersion* super_version = cfd_->GetSuperVersion();
   edit_.SetColumnFamily(cfd_->GetID());
   // The levels that the files will be ingested into
 
@@ -379,6 +375,54 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
   return status;
 }
 
+Status ExternalSstFileIngestionJob::IngestedFilesOverlapWithMemtables(
+    SuperVersion* sv, bool* overlap) {
+  *overlap = false;
+  // Create an InternalIterator over all memtables
+  Arena arena;
+  ReadOptions ro;
+  ro.total_order_seek = true;
+  MergeIteratorBuilder merge_iter_builder(&cfd_->internal_comparator(), &arena);
+  merge_iter_builder.AddIterator(sv->mem->NewIterator(ro, &arena));
+  sv->imm->AddIterators(ro, &merge_iter_builder);
+  ScopedArenaIterator memtable_iter(merge_iter_builder.Finish());
+
+  std::vector<InternalIterator*> memtable_range_del_iters;
+  auto* active_range_del_iter = sv->mem->NewRangeTombstoneIterator(ro);
+  if (active_range_del_iter != nullptr) {
+    memtable_range_del_iters.push_back(active_range_del_iter);
+  }
+  sv->imm->AddRangeTombstoneIterators(ro, &memtable_range_del_iters);
+  RangeDelAggregator range_del_agg(cfd_->internal_comparator(),
+                                   {} /* snapshots */,
+                                   false /* collapse_deletions */);
+  Status status;
+  {
+    std::unique_ptr<InternalIterator> memtable_range_del_iter(
+        NewMergingIterator(&cfd_->internal_comparator(),
+                           memtable_range_del_iters.empty()
+                               ? nullptr
+                               : &memtable_range_del_iters[0],
+                           static_cast<int>(memtable_range_del_iters.size())));
+    status = range_del_agg.AddTombstones(std::move(memtable_range_del_iter));
+  }
+  if (status.ok()) {
+    for (IngestedFileInfo& f : files_to_ingest_) {
+      status = IngestedFileOverlapWithIteratorRange(&f, memtable_iter.get(),
+                                                    overlap);
+      if (!status.ok() || *overlap == true) {
+        break;
+      }
+      if (range_del_agg.IsRangeOverlapped(f.smallest_user_key,
+                                          f.largest_user_key)) {
+        *overlap = true;
+        break;
+      }
+    }
+  }
+  return status;
+}
+
 Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(
     SuperVersion* sv, bool force_global_seqno, CompactionStyle compaction_style,
     IngestedFileInfo* file_to_ingest, SequenceNumber* assigned_seqno) {
@@ -429,10 +473,7 @@ Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(
                             return f1->largest_seqno < f2->largest_seqno;
                           }))
                 ->largest_seqno;
-        // should only assign seqno to current level's largest seqno when
-        // the file fits
-        if (level_largest_seqno != 0 &&
-            IngestedFileFitInLevel(file_to_ingest, lvl)) {
+        if (level_largest_seqno != 0) {
           *assigned_seqno = level_largest_seqno;
         } else {
           continue;

db/external_sst_file_ingestion_job.h

@@ -84,12 +84,8 @@ class ExternalSstFileIngestionJob {
   // Check if we need to flush the memtable before running the ingestion job
   // This will be true if the files we are ingesting are overlapping with any
   // key range in the memtable.
-  //
-  // @param super_version A referenced SuperVersion that will be held for the
-  //    duration of this function.
-  //
-  // Thread-safe
-  Status NeedsFlush(bool* flush_needed, SuperVersion* super_version);
+  // REQUIRES: Mutex held
+  Status NeedsFlush(bool* flush_needed);
 
   // Will execute the ingestion job and prepare edit() to be applied.
   // REQUIRES: Mutex held
@@ -114,6 +110,10 @@ class ExternalSstFileIngestionJob {
   Status GetIngestedFileInfo(const std::string& external_file,
                              IngestedFileInfo* file_to_ingest);
 
+  // Check if the files we are ingesting overlap with any memtable.
+  // REQUIRES: Mutex held
+  Status IngestedFilesOverlapWithMemtables(SuperVersion* sv, bool* overlap);
+
   // Assign `file_to_ingest` the appropriate sequence number and  the lowest
   // possible level that it can be ingested to according to compaction_style.
   // REQUIRES: Mutex held

db/external_sst_file_test.cc

@@ -388,17 +388,15 @@ class SstFileWriterCollector : public TablePropertiesCollector {
   const char* Name() const override { return name_.c_str(); }
 
   Status Finish(UserCollectedProperties* properties) override {
-    std::string count = std::to_string(count_);
     *properties = UserCollectedProperties{
         {prefix_ + "_SstFileWriterCollector", "YES"},
-        {prefix_ + "_Count", count},
+        {prefix_ + "_Count", std::to_string(count_)},
     };
     return Status::OK();
   }
 
-  Status AddUserKey(const Slice& /*user_key*/, const Slice& /*value*/,
-                    EntryType /*type*/, SequenceNumber /*seq*/,
-                    uint64_t /*file_size*/) override {
+  Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type,
+                    SequenceNumber seq, uint64_t file_size) override {
     ++count_;
     return Status::OK();
   }
@@ -418,7 +416,7 @@ class SstFileWriterCollectorFactory : public TablePropertiesCollectorFactory {
   explicit SstFileWriterCollectorFactory(std::string prefix)
       : prefix_(prefix), num_created_(0) {}
   virtual TablePropertiesCollector* CreateTablePropertiesCollector(
-      TablePropertiesCollectorFactory::Context /*context*/) override {
+      TablePropertiesCollectorFactory::Context context) override {
     num_created_++;
     return new SstFileWriterCollector(prefix_);
   }
@@ -1799,7 +1797,7 @@ TEST_F(ExternalSSTFileTest, FileWithCFInfo) {
 
 class TestIngestExternalFileListener : public EventListener {
  public:
-  void OnExternalFileIngested(DB* /*db*/,
+  void OnExternalFileIngested(DB* db,
                               const ExternalFileIngestionInfo& info) override {
     ingested_files.push_back(info);
   }

db/fault_injection_test.cc

@@ -228,9 +228,16 @@ class FaultInjectionTest : public testing::Test,
     return Status::OK();
   }
 
+#ifdef ROCKSDB_UBSAN_RUN
+#if defined(__clang__)
+__attribute__((__no_sanitize__("shift"), no_sanitize("signed-integer-overflow")))
+#elif defined(__GNUC__)
+__attribute__((__no_sanitize_undefined__))
+#endif
+#endif
   // Return the ith key
   Slice Key(int i, std::string* storage) const {
-    unsigned long long num = i;
+    int num = i;
     if (!sequential_order_) {
       // random transfer
       const int m = 0x5bd1e995;
@@ -238,7 +245,7 @@ class FaultInjectionTest : public testing::Test,
       num ^= num << 24;
     }
     char buf[100];
-    snprintf(buf, sizeof(buf), "%016d", static_cast<int>(num));
+    snprintf(buf, sizeof(buf), "%016d", num);
     storage->assign(buf, strlen(buf));
     return Slice(*storage);
   }

db/file_indexer_test.cc

@@ -36,10 +36,10 @@ class IntComparator : public Comparator {
 
   const char* Name() const override { return "IntComparator"; }
 
-  void FindShortestSeparator(std::string* /*start*/,
-                             const Slice& /*limit*/) const override {}
+  void FindShortestSeparator(std::string* start,
+                             const Slice& limit) const override {}
 
-  void FindShortSuccessor(std::string* /*key*/) const override {}
+  void FindShortSuccessor(std::string* key) const override {}
 };
 
 class FileIndexerTest : public testing::Test {

db/flush_job.cc

@@ -54,32 +54,6 @@
 
 namespace rocksdb {
 
-const char* GetFlushReasonString (FlushReason flush_reason) {
-  switch (flush_reason) {
-    case FlushReason::kUnknown:
-      return "Unknown";
-    case FlushReason::kGetLiveFiles:
-      return "Get Live Files";
-    case FlushReason::kShutDown:
-      return "Shut down";
-    case FlushReason::kExternalFileIngestion:
-      return "External File Ingestion";
-    case FlushReason::kManualCompaction:
-      return "Manual Compaction";
-    case FlushReason::kWriteBufferManager:
-      return "Write Buffer Manager";
-    case FlushReason::kWriteBufferFull:
-      return "Write Buffer Full";
-    case FlushReason::kTest:
-      return "Test";
-    case FlushReason::kSuperVersionChange:
-      return "SuperVersion Change";
-    default:
-      return "Invalid";
-  }
-}
-
-
 FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
                    const ImmutableDBOptions& db_options,
                    const MutableCFOptions& mutable_cf_options,
@@ -304,13 +278,12 @@ Status FlushJob::WriteLevel0Table() {
       total_memory_usage += m->ApproximateMemoryUsage();
     }
 
-    event_logger_->Log()
-        << "job" << job_context_->job_id << "event"
-        << "flush_started"
-        << "num_memtables" << mems_.size() << "num_entries" << total_num_entries
-        << "num_deletes" << total_num_deletes << "memory_usage"
-        << total_memory_usage << "flush_reason"
-        << GetFlushReasonString(cfd_->GetFlushReason());
+    event_logger_->Log() << "job" << job_context_->job_id << "event"
+                         << "flush_started"
+                         << "num_memtables" << mems_.size() << "num_entries"
+                         << total_num_entries << "num_deletes"
+                         << total_num_deletes << "memory_usage"
+                         << total_memory_usage;
 
     {
       ScopedArenaIterator iter(

db/forward_iterator.cc

@@ -25,15 +25,15 @@
 namespace rocksdb {
 
 // Usage:
-//     ForwardLevelIterator iter;
+//     LevelIterator iter;
 //     iter.SetFileIndex(file_index);
 //     iter.Seek(target);
 //     iter.Next()
-class ForwardLevelIterator : public InternalIterator {
+class LevelIterator : public InternalIterator {
  public:
-  ForwardLevelIterator(const ColumnFamilyData* const cfd,
-                       const ReadOptions& read_options,
-                       const std::vector<FileMetaData*>& files)
+  LevelIterator(const ColumnFamilyData* const cfd,
+                const ReadOptions& read_options,
+                const std::vector<FileMetaData*>& files)
       : cfd_(cfd),
         read_options_(read_options),
         files_(files),
@@ -42,7 +42,7 @@ class ForwardLevelIterator : public InternalIterator {
         file_iter_(nullptr),
         pinned_iters_mgr_(nullptr) {}
 
-  ~ForwardLevelIterator() {
+  ~LevelIterator() {
     // Reset current pointer
     if (pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled()) {
       pinned_iters_mgr_->PinIterator(file_iter_);
@@ -84,11 +84,11 @@ class ForwardLevelIterator : public InternalIterator {
     }
   }
   void SeekToLast() override {
-    status_ = Status::NotSupported("ForwardLevelIterator::SeekToLast()");
+    status_ = Status::NotSupported("LevelIterator::SeekToLast()");
     valid_ = false;
   }
   void Prev() override {
-    status_ = Status::NotSupported("ForwardLevelIterator::Prev()");
+    status_ = Status::NotSupported("LevelIterator::Prev()");
     valid_ = false;
   }
   bool Valid() const override {
@@ -104,8 +104,8 @@ class ForwardLevelIterator : public InternalIterator {
     file_iter_->Seek(internal_key);
     valid_ = file_iter_->Valid();
   }
-  void SeekForPrev(const Slice& /*internal_key*/) override {
-    status_ = Status::NotSupported("ForwardLevelIterator::SeekForPrev()");
+  void SeekForPrev(const Slice& internal_key) override {
+    status_ = Status::NotSupported("LevelIterator::SeekForPrev()");
     valid_ = false;
   }
   void Next() override {
@@ -196,60 +196,38 @@ ForwardIterator::~ForwardIterator() {
   Cleanup(true);
 }
 
-void ForwardIterator::SVCleanup(DBImpl* db, SuperVersion* sv,
-                                bool background_purge_on_iterator_cleanup) {
-  if (sv->Unref()) {
+namespace {
+// Used in PinnedIteratorsManager to release pinned SuperVersion
+static void ReleaseSuperVersionFunc(void* sv) {
+  delete reinterpret_cast<SuperVersion*>(sv);
+}
+}  // namespace
+
+void ForwardIterator::SVCleanup() {
+  if (sv_ != nullptr && sv_->Unref()) {
     // Job id == 0 means that this is not our background process, but rather
     // user thread
     JobContext job_context(0);
-    db->mutex_.Lock();
-    sv->Cleanup();
-    db->FindObsoleteFiles(&job_context, false, true);
-    if (background_purge_on_iterator_cleanup) {
-      db->ScheduleBgLogWriterClose(&job_context);
+    db_->mutex_.Lock();
+    sv_->Cleanup();
+    db_->FindObsoleteFiles(&job_context, false, true);
+    if (read_options_.background_purge_on_iterator_cleanup) {
+      db_->ScheduleBgLogWriterClose(&job_context);
+    }
+    db_->mutex_.Unlock();
+    if (pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled()) {
+      pinned_iters_mgr_->PinPtr(sv_, &ReleaseSuperVersionFunc);
+    } else {
+      delete sv_;
     }
-    db->mutex_.Unlock();
-    delete sv;
     if (job_context.HaveSomethingToDelete()) {
-      db->PurgeObsoleteFiles(job_context, background_purge_on_iterator_cleanup);
+      db_->PurgeObsoleteFiles(
+          job_context, read_options_.background_purge_on_iterator_cleanup);
     }
     job_context.Clean();
   }
 }
 
-namespace {
-struct SVCleanupParams {
-  DBImpl* db;
-  SuperVersion* sv;
-  bool background_purge_on_iterator_cleanup;
-};
-}
-
-// Used in PinnedIteratorsManager to release pinned SuperVersion
-void ForwardIterator::DeferredSVCleanup(void* arg) {
-  auto d = reinterpret_cast<SVCleanupParams*>(arg);
-  ForwardIterator::SVCleanup(
-    d->db, d->sv, d->background_purge_on_iterator_cleanup);
-  delete d;
-}
-
-void ForwardIterator::SVCleanup() {
-  if (sv_ == nullptr) {
-    return;
-  }
-  if (pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled()) {
-    // pinned_iters_mgr_ tells us to make sure that all visited key-value slices
-    // are alive until pinned_iters_mgr_->ReleasePinnedData() is called.
-    // The slices may point into some memtables owned by sv_, so we need to keep
-    // sv_ referenced until pinned_iters_mgr_ unpins everything.
-    auto p = new SVCleanupParams{
-      db_, sv_, read_options_.background_purge_on_iterator_cleanup};
-    pinned_iters_mgr_->PinPtr(p, &ForwardIterator::DeferredSVCleanup);
-  } else {
-    SVCleanup(db_, sv_, read_options_.background_purge_on_iterator_cleanup);
-  }
-}
-
 void ForwardIterator::Cleanup(bool release_sv) {
   if (mutable_iter_ != nullptr) {
     DeleteIterator(mutable_iter_, true /* is_arena */);
@@ -383,13 +361,14 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
 
       if (!l0_iters_[i]->status().ok()) {
         immutable_status_ = l0_iters_[i]->status();
-      } else if (l0_iters_[i]->Valid() &&
-                 !IsOverUpperBound(l0_iters_[i]->key())) {
-        immutable_min_heap_.push(l0_iters_[i]);
-      } else {
-        has_iter_trimmed_for_upper_bound_ = true;
-        DeleteIterator(l0_iters_[i]);
-        l0_iters_[i] = nullptr;
+      } else if (l0_iters_[i]->Valid()) {
+        if (!IsOverUpperBound(l0_iters_[i]->key())) {
+          immutable_min_heap_.push(l0_iters_[i]);
+        } else {
+          has_iter_trimmed_for_upper_bound_ = true;
+          DeleteIterator(l0_iters_[i]);
+          l0_iters_[i] = nullptr;
+        }
       }
     }
 
@@ -416,14 +395,15 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
 
         if (!level_iters_[level - 1]->status().ok()) {
           immutable_status_ = level_iters_[level - 1]->status();
-        } else if (level_iters_[level - 1]->Valid() &&
-                   !IsOverUpperBound(level_iters_[level - 1]->key())) {
-          immutable_min_heap_.push(level_iters_[level - 1]);
-        } else {
-          // Nothing in this level is interesting. Remove.
-          has_iter_trimmed_for_upper_bound_ = true;
-          DeleteIterator(level_iters_[level - 1]);
-          level_iters_[level - 1] = nullptr;
+        } else if (level_iters_[level - 1]->Valid()) {
+          if (!IsOverUpperBound(level_iters_[level - 1]->key())) {
+            immutable_min_heap_.push(level_iters_[level - 1]);
+          } else {
+            // Nothing in this level is interesting. Remove.
+            has_iter_trimmed_for_upper_bound_ = true;
+            DeleteIterator(level_iters_[level - 1]);
+            level_iters_[level - 1] = nullptr;
+          }
         }
       }
     }
@@ -561,7 +541,7 @@ void ForwardIterator::UpdateChildrenPinnedItersMgr() {
   }
 
   // Set PinnedIteratorsManager for L1+ levels iterators.
-  for (ForwardLevelIterator* child_iter : level_iters_) {
+  for (LevelIterator* child_iter : level_iters_) {
     if (child_iter) {
       child_iter->SetPinnedItersMgr(pinned_iters_mgr_);
     }
@@ -723,7 +703,7 @@ void ForwardIterator::BuildLevelIterators(const VersionStorageInfo* vstorage) {
       }
     } else {
       level_iters_.push_back(
-          new ForwardLevelIterator(cfd_, read_options_, level_files));
+          new LevelIterator(cfd_, read_options_, level_files));
     }
   }
 }

db/forward_iterator.h

@@ -23,7 +23,7 @@ class DBImpl;
 class Env;
 struct SuperVersion;
 class ColumnFamilyData;
-class ForwardLevelIterator;
+class LevelIterator;
 class VersionStorageInfo;
 struct FileMetaData;
 
@@ -55,7 +55,7 @@ class ForwardIterator : public InternalIterator {
                   ColumnFamilyData* cfd, SuperVersion* current_sv = nullptr);
   virtual ~ForwardIterator();
 
-  void SeekForPrev(const Slice& /*target*/) override {
+  void SeekForPrev(const Slice& target) override {
     status_ = Status::NotSupported("ForwardIterator::SeekForPrev()");
     valid_ = false;
   }
@@ -85,14 +85,7 @@ class ForwardIterator : public InternalIterator {
 
  private:
   void Cleanup(bool release_sv);
-  // Unreference and, if needed, clean up the current SuperVersion. This is
-  // either done immediately or deferred until this iterator is unpinned by
-  // PinnedIteratorsManager.
   void SVCleanup();
-  static void SVCleanup(
-    DBImpl* db, SuperVersion* sv, bool background_purge_on_iterator_cleanup);
-  static void DeferredSVCleanup(void* arg);
-
   void RebuildIterators(bool refresh_sv);
   void RenewIterators();
   void BuildLevelIterators(const VersionStorageInfo* vstorage);
@@ -126,7 +119,7 @@ class ForwardIterator : public InternalIterator {
   InternalIterator* mutable_iter_;
   std::vector<InternalIterator*> imm_iters_;
   std::vector<InternalIterator*> l0_iters_;
-  std::vector<ForwardLevelIterator*> level_iters_;
+  std::vector<LevelIterator*> level_iters_;
   InternalIterator* current_;
   bool valid_;
 

db/internal_stats.cc

@@ -233,7 +233,6 @@ static const std::string estimate_live_data_size = "estimate-live-data-size";
 static const std::string min_log_number_to_keep = "min-log-number-to-keep";
 static const std::string base_level = "base-level";
 static const std::string total_sst_files_size = "total-sst-files-size";
-static const std::string live_sst_files_size = "live-sst-files-size";
 static const std::string estimate_pending_comp_bytes =
     "estimate-pending-compaction-bytes";
 static const std::string aggregated_table_properties =
@@ -308,8 +307,6 @@ const std::string DB::Properties::kMinLogNumberToKeep =
     rocksdb_prefix + min_log_number_to_keep;
 const std::string DB::Properties::kTotalSstFilesSize =
                       rocksdb_prefix + total_sst_files_size;
-const std::string DB::Properties::kLiveSstFilesSize =
-    rocksdb_prefix + live_sst_files_size;
 const std::string DB::Properties::kBaseLevel = rocksdb_prefix + base_level;
 const std::string DB::Properties::kEstimatePendingCompactionBytes =
     rocksdb_prefix + estimate_pending_comp_bytes;
@@ -408,8 +405,6 @@ const std::unordered_map<std::string, DBPropertyInfo>
          {false, nullptr, &InternalStats::HandleBaseLevel, nullptr}},
         {DB::Properties::kTotalSstFilesSize,
          {false, nullptr, &InternalStats::HandleTotalSstFilesSize, nullptr}},
-        {DB::Properties::kLiveSstFilesSize,
-         {false, nullptr, &InternalStats::HandleLiveSstFilesSize, nullptr}},
         {DB::Properties::kEstimatePendingCompactionBytes,
          {false, nullptr, &InternalStats::HandleEstimatePendingCompactionBytes,
           nullptr}},
@@ -447,7 +442,7 @@ bool InternalStats::GetStringProperty(const DBPropertyInfo& property_info,
 }
 
 bool InternalStats::GetMapProperty(const DBPropertyInfo& property_info,
-                                   const Slice& /*property*/,
+                                   const Slice& property,
                                    std::map<std::string, std::string>* value) {
   assert(value != nullptr);
   assert(property_info.handle_map != nullptr);
@@ -499,7 +494,7 @@ bool InternalStats::HandleCompressionRatioAtLevelPrefix(std::string* value,
   return true;
 }
 
-bool InternalStats::HandleLevelStats(std::string* value, Slice /*suffix*/) {
+bool InternalStats::HandleLevelStats(std::string* value, Slice suffix) {
   char buf[1000];
   const auto* vstorage = cfd_->current()->storage_info();
   snprintf(buf, sizeof(buf),
@@ -532,36 +527,35 @@ bool InternalStats::HandleCFMapStats(
   return true;
 }
 
-bool InternalStats::HandleCFStats(std::string* value, Slice /*suffix*/) {
+bool InternalStats::HandleCFStats(std::string* value, Slice suffix) {
   DumpCFStats(value);
   return true;
 }
 
 bool InternalStats::HandleCFStatsNoFileHistogram(std::string* value,
-                                                 Slice /*suffix*/) {
+                                                 Slice suffix) {
   DumpCFStatsNoFileHistogram(value);
   return true;
 }
 
-bool InternalStats::HandleCFFileHistogram(std::string* value,
-                                          Slice /*suffix*/) {
+bool InternalStats::HandleCFFileHistogram(std::string* value, Slice suffix) {
   DumpCFFileHistogram(value);
   return true;
 }
 
-bool InternalStats::HandleDBStats(std::string* value, Slice /*suffix*/) {
+bool InternalStats::HandleDBStats(std::string* value, Slice suffix) {
   DumpDBStats(value);
   return true;
 }
 
-bool InternalStats::HandleSsTables(std::string* value, Slice /*suffix*/) {
+bool InternalStats::HandleSsTables(std::string* value, Slice suffix) {
   auto* current = cfd_->current();
   *value = current->DebugString(true, true);
   return true;
 }
 
 bool InternalStats::HandleAggregatedTableProperties(std::string* value,
-                                                    Slice /*suffix*/) {
+                                                    Slice suffix) {
   std::shared_ptr<const TableProperties> tp;
   auto s = cfd_->current()->GetAggregatedTableProperties(&tp);
   if (!s.ok()) {
@@ -588,34 +582,34 @@ bool InternalStats::HandleAggregatedTablePropertiesAtLevel(std::string* value,
   return true;
 }
 
-bool InternalStats::HandleNumImmutableMemTable(uint64_t* value, DBImpl* /*db*/,
-                                               Version* /*version*/) {
+bool InternalStats::HandleNumImmutableMemTable(uint64_t* value, DBImpl* db,
+                                               Version* version) {
   *value = cfd_->imm()->NumNotFlushed();
   return true;
 }
 
 bool InternalStats::HandleNumImmutableMemTableFlushed(uint64_t* value,
-                                                      DBImpl* /*db*/,
-                                                      Version* /*version*/) {
+                                                      DBImpl* db,
+                                                      Version* version) {
   *value = cfd_->imm()->NumFlushed();
   return true;
 }
 
-bool InternalStats::HandleMemTableFlushPending(uint64_t* value, DBImpl* /*db*/,
-                                               Version* /*version*/) {
+bool InternalStats::HandleMemTableFlushPending(uint64_t* value, DBImpl* db,
+                                               Version* version) {
   // Return number of mem tables that are ready to flush (made immutable)
   *value = (cfd_->imm()->IsFlushPending() ? 1 : 0);
   return true;
 }
 
 bool InternalStats::HandleNumRunningFlushes(uint64_t* value, DBImpl* db,
-                                            Version* /*version*/) {
+                                            Version* version) {
   *value = db->num_running_flushes();
   return true;
 }
 
-bool InternalStats::HandleCompactionPending(uint64_t* value, DBImpl* /*db*/,
-                                            Version* /*version*/) {
+bool InternalStats::HandleCompactionPending(uint64_t* value, DBImpl* db,
+                                            Version* version) {
   // 1 if the system already determines at least one compaction is needed.
   // 0 otherwise,
   const auto* vstorage = cfd_->current()->storage_info();
@@ -624,74 +618,70 @@ bool InternalStats::HandleCompactionPending(uint64_t* value, DBImpl* /*db*/,
 }
 
 bool InternalStats::HandleNumRunningCompactions(uint64_t* value, DBImpl* db,
-                                                Version* /*version*/) {
+                                                Version* version) {
   *value = db->num_running_compactions_;
   return true;
 }
 
-bool InternalStats::HandleBackgroundErrors(uint64_t* value, DBImpl* /*db*/,
-                                           Version* /*version*/) {
+bool InternalStats::HandleBackgroundErrors(uint64_t* value, DBImpl* db,
+                                           Version* version) {
   // Accumulated number of  errors in background flushes or compactions.
   *value = GetBackgroundErrorCount();
   return true;
 }
 
-bool InternalStats::HandleCurSizeActiveMemTable(uint64_t* value, DBImpl* /*db*/,
-                                                Version* /*version*/) {
+bool InternalStats::HandleCurSizeActiveMemTable(uint64_t* value, DBImpl* db,
+                                                Version* version) {
   // Current size of the active memtable
   *value = cfd_->mem()->ApproximateMemoryUsage();
   return true;
 }
 
-bool InternalStats::HandleCurSizeAllMemTables(uint64_t* value, DBImpl* /*db*/,
-                                              Version* /*version*/) {
+bool InternalStats::HandleCurSizeAllMemTables(uint64_t* value, DBImpl* db,
+                                              Version* version) {
   // Current size of the active memtable + immutable memtables
   *value = cfd_->mem()->ApproximateMemoryUsage() +
            cfd_->imm()->ApproximateUnflushedMemTablesMemoryUsage();
   return true;
 }
 
-bool InternalStats::HandleSizeAllMemTables(uint64_t* value, DBImpl* /*db*/,
-                                           Version* /*version*/) {
+bool InternalStats::HandleSizeAllMemTables(uint64_t* value, DBImpl* db,
+                                           Version* version) {
   *value = cfd_->mem()->ApproximateMemoryUsage() +
            cfd_->imm()->ApproximateMemoryUsage();
   return true;
 }
 
-bool InternalStats::HandleNumEntriesActiveMemTable(uint64_t* value,
-                                                   DBImpl* /*db*/,
-                                                   Version* /*version*/) {
+bool InternalStats::HandleNumEntriesActiveMemTable(uint64_t* value, DBImpl* db,
+                                                   Version* version) {
   // Current number of entires in the active memtable
   *value = cfd_->mem()->num_entries();
   return true;
 }
 
-bool InternalStats::HandleNumEntriesImmMemTables(uint64_t* value,
-                                                 DBImpl* /*db*/,
-                                                 Version* /*version*/) {
+bool InternalStats::HandleNumEntriesImmMemTables(uint64_t* value, DBImpl* db,
+                                                 Version* version) {
   // Current number of entries in the immutable memtables
   *value = cfd_->imm()->current()->GetTotalNumEntries();
   return true;
 }
 
-bool InternalStats::HandleNumDeletesActiveMemTable(uint64_t* value,
-                                                   DBImpl* /*db*/,
-                                                   Version* /*version*/) {
+bool InternalStats::HandleNumDeletesActiveMemTable(uint64_t* value, DBImpl* db,
+                                                   Version* version) {
   // Current number of entires in the active memtable
   *value = cfd_->mem()->num_deletes();
   return true;
 }
 
-bool InternalStats::HandleNumDeletesImmMemTables(uint64_t* value,
-                                                 DBImpl* /*db*/,
-                                                 Version* /*version*/) {
+bool InternalStats::HandleNumDeletesImmMemTables(uint64_t* value, DBImpl* db,
+                                                 Version* version) {
   // Current number of entries in the immutable memtables
   *value = cfd_->imm()->current()->GetTotalNumDeletes();
   return true;
 }
 
-bool InternalStats::HandleEstimateNumKeys(uint64_t* value, DBImpl* /*db*/,
-                                          Version* /*version*/) {
+bool InternalStats::HandleEstimateNumKeys(uint64_t* value, DBImpl* db,
+                                          Version* version) {
   // Estimate number of entries in the column family:
   // Use estimated entries in tables + total entries in memtables.
   const auto* vstorage = cfd_->current()->storage_info();
@@ -707,85 +697,77 @@ bool InternalStats::HandleEstimateNumKeys(uint64_t* value, DBImpl* /*db*/,
 }
 
 bool InternalStats::HandleNumSnapshots(uint64_t* value, DBImpl* db,
-                                       Version* /*version*/) {
+                                       Version* version) {
   *value = db->snapshots().count();
   return true;
 }
 
 bool InternalStats::HandleOldestSnapshotTime(uint64_t* value, DBImpl* db,
-                                             Version* /*version*/) {
+                                             Version* version) {
   *value = static_cast<uint64_t>(db->snapshots().GetOldestSnapshotTime());
   return true;
 }
 
-bool InternalStats::HandleNumLiveVersions(uint64_t* value, DBImpl* /*db*/,
-                                          Version* /*version*/) {
+bool InternalStats::HandleNumLiveVersions(uint64_t* value, DBImpl* db,
+                                          Version* version) {
   *value = cfd_->GetNumLiveVersions();
   return true;
 }
 
-bool InternalStats::HandleCurrentSuperVersionNumber(uint64_t* value,
-                                                    DBImpl* /*db*/,
-                                                    Version* /*version*/) {
+bool InternalStats::HandleCurrentSuperVersionNumber(uint64_t* value, DBImpl* db,
+                                                    Version* version) {
   *value = cfd_->GetSuperVersionNumber();
   return true;
 }
 
 bool InternalStats::HandleIsFileDeletionsEnabled(uint64_t* value, DBImpl* db,
-                                                 Version* /*version*/) {
+                                                 Version* version) {
   *value = db->IsFileDeletionsEnabled();
   return true;
 }
 
-bool InternalStats::HandleBaseLevel(uint64_t* value, DBImpl* /*db*/,
-                                    Version* /*version*/) {
+bool InternalStats::HandleBaseLevel(uint64_t* value, DBImpl* db,
+                                    Version* version) {
   const auto* vstorage = cfd_->current()->storage_info();
   *value = vstorage->base_level();
   return true;
 }
 
-bool InternalStats::HandleTotalSstFilesSize(uint64_t* value, DBImpl* /*db*/,
-                                            Version* /*version*/) {
+bool InternalStats::HandleTotalSstFilesSize(uint64_t* value, DBImpl* db,
+                                            Version* version) {
   *value = cfd_->GetTotalSstFilesSize();
   return true;
 }
 
-bool InternalStats::HandleLiveSstFilesSize(uint64_t* value, DBImpl* /*db*/,
-                                           Version* /*version*/) {
-  *value = cfd_->GetLiveSstFilesSize();
-  return true;
-}
-
 bool InternalStats::HandleEstimatePendingCompactionBytes(uint64_t* value,
-                                                         DBImpl* /*db*/,
-                                                         Version* /*version*/) {
+                                                         DBImpl* db,
+                                                         Version* version) {
   const auto* vstorage = cfd_->current()->storage_info();
   *value = vstorage->estimated_compaction_needed_bytes();
   return true;
 }
 
-bool InternalStats::HandleEstimateTableReadersMem(uint64_t* value,
-                                                  DBImpl* /*db*/,
+bool InternalStats::HandleEstimateTableReadersMem(uint64_t* value, DBImpl* db,
                                                   Version* version) {
   *value = (version == nullptr) ? 0 : version->GetMemoryUsageByTableReaders();
   return true;
 }
 
-bool InternalStats::HandleEstimateLiveDataSize(uint64_t* value, DBImpl* /*db*/,
-                                               Version* /*version*/) {
+bool InternalStats::HandleEstimateLiveDataSize(uint64_t* value, DBImpl* db,
+                                               Version* version) {
   const auto* vstorage = cfd_->current()->storage_info();
   *value = vstorage->EstimateLiveDataSize();
   return true;
 }
 
 bool InternalStats::HandleMinLogNumberToKeep(uint64_t* value, DBImpl* db,
-                                             Version* /*version*/) {
+                                             Version* version) {
   *value = db->MinLogNumberToKeep();
   return true;
 }
 
 bool InternalStats::HandleActualDelayedWriteRate(uint64_t* value, DBImpl* db,
-                                                 Version* /*version*/) {
+                                                 Version* version) {
   const WriteController& wc = db->write_controller();
   if (!wc.NeedsDelay()) {
     *value = 0;
@@ -796,7 +778,7 @@ bool InternalStats::HandleActualDelayedWriteRate(uint64_t* value, DBImpl* db,
 }
 
 bool InternalStats::HandleIsWriteStopped(uint64_t* value, DBImpl* db,
-                                         Version* /*version*/) {
+                                         Version* version) {
   *value = db->write_controller().IsStopped() ? 1 : 0;
   return true;
 }

db/internal_stats.h

@@ -467,7 +467,6 @@ class InternalStats {
                                     Version* version);
   bool HandleBaseLevel(uint64_t* value, DBImpl* db, Version* version);
   bool HandleTotalSstFilesSize(uint64_t* value, DBImpl* db, Version* version);
-  bool HandleLiveSstFilesSize(uint64_t* value, DBImpl* db, Version* version);
   bool HandleEstimatePendingCompactionBytes(uint64_t* value, DBImpl* db,
                                             Version* version);
   bool HandleEstimateTableReadersMem(uint64_t* value, DBImpl* db,

db/listener_test.cc

@@ -46,11 +46,11 @@ class EventListenerTest : public DBTestBase {
 };
 
 struct TestPropertiesCollector : public rocksdb::TablePropertiesCollector {
-  virtual rocksdb::Status AddUserKey(const rocksdb::Slice& /*key*/,
-                                     const rocksdb::Slice& /*value*/,
-                                     rocksdb::EntryType /*type*/,
-                                     rocksdb::SequenceNumber /*seq*/,
-                                     uint64_t /*file_size*/) override {
+  virtual rocksdb::Status AddUserKey(const rocksdb::Slice& key,
+                                     const rocksdb::Slice& value,
+                                     rocksdb::EntryType type,
+                                     rocksdb::SequenceNumber seq,
+                                     uint64_t file_size) override {
     return Status::OK();
   }
   virtual rocksdb::Status Finish(
@@ -73,7 +73,7 @@ struct TestPropertiesCollector : public rocksdb::TablePropertiesCollector {
 class TestPropertiesCollectorFactory : public TablePropertiesCollectorFactory {
  public:
   virtual TablePropertiesCollector* CreateTablePropertiesCollector(
-      TablePropertiesCollectorFactory::Context /*context*/) override {
+      TablePropertiesCollectorFactory::Context context) override {
     return new TestPropertiesCollector;
   }
   const char* Name() const override { return "TestTablePropertiesCollector"; }
@@ -425,7 +425,7 @@ TEST_F(EventListenerTest, DisableBGCompaction) {
 
 class TestCompactionReasonListener : public EventListener {
  public:
-  void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) override {
+  void OnCompactionCompleted(DB* db, const CompactionJobInfo& ci) override {
     std::lock_guard<std::mutex> lock(mutex_);
     compaction_reasons_.push_back(ci.compaction_reason);
   }
@@ -528,7 +528,7 @@ TEST_F(EventListenerTest, CompactionReasonUniversal) {
 
   ASSERT_GT(listener->compaction_reasons_.size(), 0);
   for (auto compaction_reason : listener->compaction_reasons_) {
-    ASSERT_EQ(compaction_reason, CompactionReason::kUniversalSizeRatio);
+    ASSERT_EQ(compaction_reason, CompactionReason::kUniversalSortedRunNum);
   }
 
   options.level0_file_num_compaction_trigger = 8;
@@ -807,8 +807,7 @@ class BackgroundErrorListener : public EventListener {
  public:
   BackgroundErrorListener(SpecialEnv* env) : env_(env), counter_(0) {}
 
-  void OnBackgroundError(BackgroundErrorReason /*reason*/,
-                         Status* bg_error) override {
+  void OnBackgroundError(BackgroundErrorReason reason, Status* bg_error) override {
     if (counter_ == 0) {
       // suppress the first error and disable write-dropping such that a retry
       // can succeed.

db/log_reader.h

@@ -54,7 +54,6 @@ class Reader {
   // The Reader will start reading at the first record located at physical
   // position >= initial_offset within the file.
   Reader(std::shared_ptr<Logger> info_log,
-  // @lint-ignore TXT2 T25377293 Grandfathered in
 	 unique_ptr<SequentialFileReader>&& file,
          Reporter* reporter, bool checksum, uint64_t initial_offset,
          uint64_t log_num);

db/malloc_stats.cc

@@ -41,8 +41,8 @@ static void GetJemallocStatus(void* mstat_arg, const char* status) {
 }
 #endif  // ROCKSDB_JEMALLOC
 
-#ifdef ROCKSDB_JEMALLOC
 void DumpMallocStats(std::string* stats) {
+#ifdef ROCKSDB_JEMALLOC
   MallocStatus mstat;
   const unsigned int kMallocStatusLen = 1000000;
   std::unique_ptr<char[]> buf{new char[kMallocStatusLen + 1]};
@@ -50,10 +50,8 @@ void DumpMallocStats(std::string* stats) {
   mstat.end = buf.get() + kMallocStatusLen;
   je_malloc_stats_print(GetJemallocStatus, &mstat, "");
   stats->append(buf.get());
-}
-#else
-void DumpMallocStats(std::string*) {}
 #endif  // ROCKSDB_JEMALLOC
+}
 
 }
 #endif  // !ROCKSDB_LITE

db/manual_compaction_test.cc

@@ -46,9 +46,9 @@ class DestroyAllCompactionFilter : public CompactionFilter {
  public:
   DestroyAllCompactionFilter() {}
 
-  virtual bool Filter(int /*level*/, const Slice& /*key*/,
-                      const Slice& existing_value, std::string* /*new_value*/,
-                      bool* /*value_changed*/) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& existing_value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
     return existing_value.ToString() == "destroy";
   }
 

db/memtable.cc

@@ -225,7 +225,7 @@ int MemTable::KeyComparator::operator()(const char* prefix_len_key1,
   // Internal keys are encoded as length-prefixed strings.
   Slice k1 = GetLengthPrefixedSlice(prefix_len_key1);
   Slice k2 = GetLengthPrefixedSlice(prefix_len_key2);
-  return comparator.CompareKeySeq(k1, k2);
+  return comparator.Compare(k1, k2);
 }
 
 int MemTable::KeyComparator::operator()(const char* prefix_len_key,
@@ -233,16 +233,16 @@ int MemTable::KeyComparator::operator()(const char* prefix_len_key,
     const {
   // Internal keys are encoded as length-prefixed strings.
   Slice a = GetLengthPrefixedSlice(prefix_len_key);
-  return comparator.CompareKeySeq(a, key);
+  return comparator.Compare(a, key);
 }
 
-void MemTableRep::InsertConcurrently(KeyHandle /*handle*/) {
+void MemTableRep::InsertConcurrently(KeyHandle handle) {
 #ifndef ROCKSDB_LITE
-  throw std::runtime_error("concurrent insert not supported");
+    throw std::runtime_error("concurrent insert not supported");
 #else
-  abort();
+    abort();
 #endif
-}
+  }
 
 Slice MemTableRep::UserKey(const char* key) const {
   Slice slice = GetLengthPrefixedSlice(key);
@@ -289,7 +289,8 @@ class MemTableIterator : public InternalIterator {
 #ifndef NDEBUG
     // Assert that the MemTableIterator is never deleted while
     // Pinning is Enabled.
-    assert(!pinned_iters_mgr_ || !pinned_iters_mgr_->PinningEnabled());
+    assert(!pinned_iters_mgr_ ||
+           (pinned_iters_mgr_ && !pinned_iters_mgr_->PinningEnabled()));
 #endif
     if (arena_mode_) {
       iter_->~Iterator();
@@ -443,7 +444,7 @@ MemTable::MemTableStats MemTable::ApproximateStats(const Slice& start_ikey,
   return {entry_count * (data_size / n), entry_count};
 }
 
-bool MemTable::Add(SequenceNumber s, ValueType type,
+void MemTable::Add(SequenceNumber s, ValueType type,
                    const Slice& key, /* user key */
                    const Slice& value, bool allow_concurrent,
                    MemTablePostProcessInfo* post_process_info) {
@@ -478,15 +479,9 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
     if (insert_with_hint_prefix_extractor_ != nullptr &&
         insert_with_hint_prefix_extractor_->InDomain(key_slice)) {
       Slice prefix = insert_with_hint_prefix_extractor_->Transform(key_slice);
-      bool res = table->InsertKeyWithHint(handle, &insert_hints_[prefix]);
-      if (!res) {
-        return res;
-      }
+      table->InsertWithHint(handle, &insert_hints_[prefix]);
     } else {
-      bool res = table->InsertKey(handle);
-      if (!res) {
-        return res;
-      }
+      table->Insert(handle);
     }
 
     // this is a bit ugly, but is the way to avoid locked instructions
@@ -519,10 +514,7 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
     assert(post_process_info == nullptr);
     UpdateFlushState();
   } else {
-    bool res = table->InsertKeyConcurrently(handle);
-    if (!res) {
-      return res;
-    }
+    table->InsertConcurrently(handle);
 
     assert(post_process_info != nullptr);
     post_process_info->num_entries++;
@@ -552,7 +544,6 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
     is_range_del_table_empty_ = false;
   }
   UpdateOldestKeyTime();
-  return true;
 }
 
 // Callback from MemTable::Get()
@@ -588,12 +579,11 @@ struct Saver {
 
 static bool SaveValue(void* arg, const char* entry) {
   Saver* s = reinterpret_cast<Saver*>(arg);
-  assert(s != nullptr);
   MergeContext* merge_context = s->merge_context;
   RangeDelAggregator* range_del_agg = s->range_del_agg;
   const MergeOperator* merge_operator = s->merge_operator;
 
-  assert(merge_context != nullptr && range_del_agg != nullptr);
+  assert(s != nullptr && merge_context != nullptr && range_del_agg != nullptr);
 
   // entry format is:
   //    klength  varint32
@@ -809,9 +799,8 @@ void MemTable::Update(SequenceNumber seq,
       // Correct user key
       const uint64_t tag = DecodeFixed64(key_ptr + key_length - 8);
       ValueType type;
-      SequenceNumber existing_seq;
-      UnPackSequenceAndType(tag, &existing_seq, &type);
-      assert(existing_seq != seq);
+      SequenceNumber unused;
+      UnPackSequenceAndType(tag, &unused, &type);
       if (type == kTypeValue) {
         Slice prev_value = GetLengthPrefixedSlice(key_ptr + key_length);
         uint32_t prev_size = static_cast<uint32_t>(prev_value.size());
@@ -834,10 +823,7 @@ void MemTable::Update(SequenceNumber seq,
   }
 
   // key doesn't exist
-  bool add_res __attribute__((__unused__));
-  add_res = Add(seq, kTypeValue, key, value);
-  // We already checked unused != seq above. In that case, Add should not fail.
-  assert(add_res);
+  Add(seq, kTypeValue, key, value);
 }
 
 bool MemTable::UpdateCallback(SequenceNumber seq,

db/memtable.h

@@ -167,10 +167,7 @@ class MemTable {
   //
   // REQUIRES: if allow_concurrent = false, external synchronization to prevent
   // simultaneous operations on the same MemTable.
-  //
-  // Returns false if MemTableRepFactory::CanHandleDuplicatedKey() is true and
-  // the <key, seq> already exists.
-  bool Add(SequenceNumber seq, ValueType type, const Slice& key,
+  void Add(SequenceNumber seq, ValueType type, const Slice& key,
            const Slice& value, bool allow_concurrent = false,
            MemTablePostProcessInfo* post_process_info = nullptr);
 

db/memtable_list.cc

@@ -154,7 +154,7 @@ bool MemTableListVersion::GetFromList(
 }
 
 Status MemTableListVersion::AddRangeTombstoneIterators(
-    const ReadOptions& read_opts, Arena* /*arena*/,
+    const ReadOptions& read_opts, Arena* arena,
     RangeDelAggregator* range_del_agg) {
   assert(range_del_agg != nullptr);
   for (auto& m : memlist_) {
@@ -300,7 +300,7 @@ void MemTableList::PickMemtablesToFlush(autovector<MemTable*>* ret) {
 }
 
 void MemTableList::RollbackMemtableFlush(const autovector<MemTable*>& mems,
-                                         uint64_t /*file_number*/) {
+                                         uint64_t file_number) {
   AutoThreadOperationStageUpdater stage_updater(
       ThreadStatus::STAGE_MEMTABLE_ROLLBACK);
   assert(!mems.empty());

db/merge_helper.cc

@@ -5,12 +5,12 @@
 
 #include "db/merge_helper.h"
 
+#include <stdio.h>
 #include <string>
 
 #include "db/dbformat.h"
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/statistics.h"
-#include "port/likely.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/db.h"
 #include "rocksdb/merge_operator.h"
@@ -22,8 +22,7 @@ MergeHelper::MergeHelper(Env* env, const Comparator* user_comparator,
                          const MergeOperator* user_merge_operator,
                          const CompactionFilter* compaction_filter,
                          Logger* logger, bool assert_valid_internal_key,
-                         SequenceNumber latest_snapshot,
-                         const SnapshotChecker* snapshot_checker, int level,
+                         SequenceNumber latest_snapshot, int level,
                          Statistics* stats,
                          const std::atomic<bool>* shutting_down)
     : env_(env),
@@ -35,7 +34,6 @@ MergeHelper::MergeHelper(Env* env, const Comparator* user_comparator,
       assert_valid_internal_key_(assert_valid_internal_key),
       allow_single_operand_(false),
       latest_snapshot_(latest_snapshot),
-      snapshot_checker_(snapshot_checker),
       level_(level),
       keys_(),
       filter_timer_(env_),
@@ -160,10 +158,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
       // hit a different user key, stop right here
       hit_the_next_user_key = true;
       break;
-    } else if (stop_before > 0 && ikey.sequence <= stop_before &&
-               LIKELY(snapshot_checker_ == nullptr ||
-                      snapshot_checker_->IsInSnapshot(ikey.sequence,
-                                                      stop_before))) {
+    } else if (stop_before && ikey.sequence <= stop_before) {
       // hit an entry that's visible by the previous snapshot, can't touch that
       break;
     }

db/merge_helper.h

@@ -13,7 +13,6 @@
 #include "db/dbformat.h"
 #include "db/merge_context.h"
 #include "db/range_del_aggregator.h"
-#include "db/snapshot_checker.h"
 #include "rocksdb/compaction_filter.h"
 #include "rocksdb/env.h"
 #include "rocksdb/slice.h"
@@ -34,8 +33,7 @@ class MergeHelper {
               const MergeOperator* user_merge_operator,
               const CompactionFilter* compaction_filter, Logger* logger,
               bool assert_valid_internal_key, SequenceNumber latest_snapshot,
-              const SnapshotChecker* snapshot_checker = nullptr, int level = 0,
-              Statistics* stats = nullptr,
+              int level = 0, Statistics* stats = nullptr,
               const std::atomic<bool>* shutting_down = nullptr);
 
   // Wrapper around MergeOperator::FullMergeV2() that records perf statistics.
@@ -147,7 +145,6 @@ class MergeHelper {
   bool assert_valid_internal_key_; // enforce no internal key corruption?
   bool allow_single_operand_;
   SequenceNumber latest_snapshot_;
-  const SnapshotChecker* const snapshot_checker_;
   int level_;
 
   // the scratch area that holds the result of MergeUntil

db/merge_test.cc

@@ -504,7 +504,7 @@ void runTest(int argc, const std::string& dbname, const bool use_ttl = false) {
 }
 }  // namespace
 
-int main(int argc, char* /*argv*/ []) {
+int main(int argc, char *argv[]) {
   //TODO: Make this test like a general rocksdb unit-test
   rocksdb::port::InstallStackTraceHandler();
   runTest(argc, test::TmpDir() + "/merge_testdb");

db/plain_table_db_test.cc

@@ -327,7 +327,7 @@ class TestPlainTableFactory : public PlainTableFactory {
       const TableReaderOptions& table_reader_options,
       unique_ptr<RandomAccessFileReader>&& file, uint64_t file_size,
       unique_ptr<TableReader>* table,
-      bool /*prefetch_index_and_filter_in_cache*/) const override {
+      bool prefetch_index_and_filter_in_cache) const override {
     TableProperties* props = nullptr;
     auto s =
         ReadTableProperties(file.get(), file_size, kPlainTableMagicNumber,

db/prefix_test.cc

@@ -126,10 +126,10 @@ class TestKeyComparator : public Comparator {
     return "TestKeyComparator";
   }
 
-  virtual void FindShortestSeparator(std::string* /*start*/,
-                                     const Slice& /*limit*/) const override {}
+  virtual void FindShortestSeparator(std::string* start,
+                                     const Slice& limit) const override {}
 
-  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortSuccessor(std::string* key) const override {}
 };
 
 namespace {

db/snapshot_checker.h

@@ -19,8 +19,8 @@ class SnapshotChecker {
 class DisableGCSnapshotChecker : public SnapshotChecker {
  public:
   virtual ~DisableGCSnapshotChecker() {}
-  virtual bool IsInSnapshot(SequenceNumber /*sequence*/,
-                            SequenceNumber /*snapshot_sequence*/) const {
+  virtual bool IsInSnapshot(SequenceNumber sequence,
+                            SequenceNumber snapshot_sequence) const {
     // By returning false, we prevent all the values from being GCed
     return false;
   }

db/snapshot_impl.h

@@ -45,10 +45,6 @@ class SnapshotList {
     list_.prev_ = &list_;
     list_.next_ = &list_;
     list_.number_ = 0xFFFFFFFFL;      // placeholder marker, for debugging
-    // Set all the variables to make UBSAN happy.
-    list_.list_ = nullptr;
-    list_.unix_time_ = 0;
-    list_.is_write_conflict_boundary_ = false;
     count_ = 0;
   }
 

db/table_cache.cc

@@ -30,7 +30,7 @@ namespace rocksdb {
 namespace {
 
 template <class T>
-static void DeleteEntry(const Slice& /*key*/, void* value) {
+static void DeleteEntry(const Slice& key, void* value) {
   T* typed_value = reinterpret_cast<T*>(value);
   delete typed_value;
 }
@@ -41,7 +41,7 @@ static void UnrefEntry(void* arg1, void* arg2) {
   cache->Release(h);
 }
 
-static void DeleteTableReader(void* arg1, void* /*arg2*/) {
+static void DeleteTableReader(void* arg1, void* arg2) {
   TableReader* table_reader = reinterpret_cast<TableReader*>(arg1);
   delete table_reader;
 }
@@ -272,8 +272,9 @@ InternalIterator* TableCache::NewRangeTombstoneIterator(
     const InternalKeyComparator& icomparator, const FileDescriptor& fd,
     HistogramImpl* file_read_hist, bool skip_filters, int level) {
   Status s;
+  TableReader* table_reader = nullptr;
   Cache::Handle* handle = nullptr;
-  TableReader* table_reader = fd.table_reader;
+  table_reader = fd.table_reader;
   if (table_reader == nullptr) {
     s = FindTable(env_options, icomparator, fd, &handle,
                   options.read_tier == kBlockCacheTier /* no_io */,

db/table_properties_collector.cc

@@ -12,8 +12,8 @@
 namespace rocksdb {
 
 Status InternalKeyPropertiesCollector::InternalAdd(const Slice& key,
-                                                   const Slice& /*value*/,
-                                                   uint64_t /*file_size*/) {
+                                                   const Slice& value,
+                                                   uint64_t file_size) {
   ParsedInternalKey ikey;
   if (!ParseInternalKey(key, &ikey)) {
     return Status::InvalidArgument("Invalid internal key");
@@ -60,7 +60,7 @@ InternalKeyPropertiesCollector::GetReadableProperties() const {
 namespace {
 
 uint64_t GetUint64Property(const UserCollectedProperties& props,
-                           const std::string& property_name,
+                           const std::string property_name,
                            bool* property_present) {
   auto pos = props.find(property_name);
   if (pos == props.end()) {

db/table_properties_collector.h

@@ -73,7 +73,7 @@ class InternalKeyPropertiesCollectorFactory
     : public IntTblPropCollectorFactory {
  public:
   virtual IntTblPropCollector* CreateIntTblPropCollector(
-      uint32_t /*column_family_id*/) override {
+      uint32_t column_family_id) override {
     return new InternalKeyPropertiesCollector();
   }
 

db/table_properties_collector_test.cc

@@ -82,9 +82,8 @@ class RegularKeysStartWithA: public TablePropertiesCollector {
      return Status::OK();
   }
 
-  Status AddUserKey(const Slice& user_key, const Slice& /*value*/,
-                    EntryType type, SequenceNumber /*seq*/,
-                    uint64_t file_size) override {
+  Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type,
+                    SequenceNumber seq, uint64_t file_size) override {
     // simply asssume all user keys are not empty.
     if (user_key.data()[0] == 'A') {
       ++count_;
@@ -134,7 +133,7 @@ class RegularKeysStartWithABackwardCompatible
     return Status::OK();
   }
 
-  Status Add(const Slice& user_key, const Slice& /*value*/) override {
+  Status Add(const Slice& user_key, const Slice& value) override {
     // simply asssume all user keys are not empty.
     if (user_key.data()[0] == 'A') {
       ++count_;
@@ -162,8 +161,8 @@ class RegularKeysStartWithAInternal : public IntTblPropCollector {
     return Status::OK();
   }
 
-  Status InternalAdd(const Slice& user_key, const Slice& /*value*/,
-                     uint64_t /*file_size*/) override {
+  Status InternalAdd(const Slice& user_key, const Slice& value,
+                     uint64_t file_size) override {
     // simply asssume all user keys are not empty.
     if (user_key.data()[0] == 'A') {
       ++count_;
@@ -194,7 +193,7 @@ class RegularKeysStartWithAFactory : public IntTblPropCollectorFactory,
     }
   }
   virtual IntTblPropCollector* CreateIntTblPropCollector(
-      uint32_t /*column_family_id*/) override {
+      uint32_t column_family_id) override {
     return new RegularKeysStartWithAInternal();
   }
   const char* Name() const override { return "RegularKeysStartWithA"; }
@@ -204,7 +203,7 @@ class RegularKeysStartWithAFactory : public IntTblPropCollectorFactory,
 
 class FlushBlockEveryThreePolicy : public FlushBlockPolicy {
  public:
-  virtual bool Update(const Slice& /*key*/, const Slice& /*value*/) override {
+  virtual bool Update(const Slice& key, const Slice& value) override {
     return (++count_ % 3U == 0);
   }
 
@@ -221,8 +220,8 @@ class FlushBlockEveryThreePolicyFactory : public FlushBlockPolicyFactory {
   }
 
   FlushBlockPolicy* NewFlushBlockPolicy(
-      const BlockBasedTableOptions& /*table_options*/,
-      const BlockBuilder& /*data_block_builder*/) const override {
+      const BlockBasedTableOptions& table_options,
+      const BlockBuilder& data_block_builder) const override {
     return new FlushBlockEveryThreePolicy;
   }
 };

db/transaction_log_impl.cc

@@ -269,18 +269,16 @@ void TransactionLogIteratorImpl::UpdateCurrentWriteBatch(const Slice& record) {
       return Status::OK();
     }
 
-    Status PutCF(uint32_t /*cf*/, const Slice& /*key*/,
-                 const Slice& /*val*/) override {
+    Status PutCF(uint32_t cf, const Slice& key, const Slice& val) override {
       return Status::OK();
     }
-    Status DeleteCF(uint32_t /*cf*/, const Slice& /*key*/) override {
+    Status DeleteCF(uint32_t cf, const Slice& key) override {
       return Status::OK();
     }
-    Status SingleDeleteCF(uint32_t /*cf*/, const Slice& /*key*/) override {
+    Status SingleDeleteCF(uint32_t cf, const Slice& key) override {
       return Status::OK();
     }
-    Status MergeCF(uint32_t /*cf*/, const Slice& /*key*/,
-                   const Slice& /*val*/) override {
+    Status MergeCF(uint32_t cf, const Slice& key, const Slice& val) override {
       return Status::OK();
     }
     Status MarkBeginPrepare() override { return Status::OK(); }

db/version_builder.cc

@@ -199,7 +199,7 @@ class VersionBuilder::Rep {
     }
   }
 
-  void CheckConsistencyForDeletes(VersionEdit* /*edit*/, uint64_t number,
+  void CheckConsistencyForDeletes(VersionEdit* edit, uint64_t number,
                                   int level) {
 #ifdef NDEBUG
     if (!base_vstorage_->force_consistency_checks()) {

db/version_edit.cc

@@ -198,7 +198,7 @@ static bool GetInternalKey(Slice* input, InternalKey* dst) {
   }
 }
 
-bool VersionEdit::GetLevel(Slice* input, int* level, const char** /*msg*/) {
+bool VersionEdit::GetLevel(Slice* input, int* level, const char** msg) {
   uint32_t v;
   if (GetVarint32(input, &v)) {
     *level = v;

db/version_set.cc

@@ -424,261 +424,129 @@ bool SomeFileOverlapsRange(
 }
 
 namespace {
-class LevelIterator final : public InternalIterator {
+
+// An internal iterator.  For a given version/level pair, yields
+// information about the files in the level.  For a given entry, key()
+// is the largest key that occurs in the file, and value() is an
+// 16-byte value containing the file number and file size, both
+// encoded using EncodeFixed64.
+class LevelFileNumIterator : public InternalIterator {
  public:
-  LevelIterator(TableCache* table_cache, const ReadOptions& read_options,
-                const EnvOptions& env_options,
-                const InternalKeyComparator& icomparator,
-                const LevelFilesBrief* flevel, bool should_sample,
-                HistogramImpl* file_read_hist, bool for_compaction,
-                bool skip_filters, int level, RangeDelAggregator* range_del_agg)
-      : table_cache_(table_cache),
+  LevelFileNumIterator(const InternalKeyComparator& icmp,
+                       const LevelFilesBrief* flevel, bool should_sample)
+      : icmp_(icmp),
+        flevel_(flevel),
+        index_(static_cast<uint32_t>(flevel->num_files)),
+        current_value_(0, 0, 0),  // Marks as invalid
+        should_sample_(should_sample) {}
+  virtual bool Valid() const override { return index_ < flevel_->num_files; }
+  virtual void Seek(const Slice& target) override {
+    index_ = FindFile(icmp_, *flevel_, target);
+  }
+  virtual void SeekForPrev(const Slice& target) override {
+    SeekForPrevImpl(target, &icmp_);
+  }
+
+  virtual void SeekToFirst() override { index_ = 0; }
+  virtual void SeekToLast() override {
+    index_ = (flevel_->num_files == 0)
+                 ? 0
+                 : static_cast<uint32_t>(flevel_->num_files) - 1;
+  }
+  virtual void Next() override {
+    assert(Valid());
+    index_++;
+  }
+  virtual void Prev() override {
+    assert(Valid());
+    if (index_ == 0) {
+      index_ = static_cast<uint32_t>(flevel_->num_files);  // Marks as invalid
+    } else {
+      index_--;
+    }
+  }
+  Slice key() const override {
+    assert(Valid());
+    return flevel_->files[index_].largest_key;
+  }
+  Slice value() const override {
+    assert(Valid());
+
+    auto file_meta = flevel_->files[index_];
+    if (should_sample_) {
+      sample_file_read_inc(file_meta.file_metadata);
+    }
+    current_value_ = file_meta.fd;
+    return Slice(reinterpret_cast<const char*>(&current_value_),
+                 sizeof(FileDescriptor));
+  }
+  virtual Status status() const override { return Status::OK(); }
+
+ private:
+  const InternalKeyComparator icmp_;
+  const LevelFilesBrief* flevel_;
+  uint32_t index_;
+  mutable FileDescriptor current_value_;
+  bool should_sample_;
+};
+
+class LevelFileIteratorState : public TwoLevelIteratorState {
+ public:
+  // @param skip_filters Disables loading/accessing the filter block
+  LevelFileIteratorState(TableCache* table_cache,
+                         const ReadOptions& read_options,
+                         const EnvOptions& env_options,
+                         const InternalKeyComparator& icomparator,
+                         HistogramImpl* file_read_hist, bool for_compaction,
+                         bool prefix_enabled, bool skip_filters, int level,
+                         RangeDelAggregator* range_del_agg)
+      : TwoLevelIteratorState(prefix_enabled),
+        table_cache_(table_cache),
         read_options_(read_options),
         env_options_(env_options),
         icomparator_(icomparator),
-        flevel_(flevel),
         file_read_hist_(file_read_hist),
-        should_sample_(should_sample),
         for_compaction_(for_compaction),
         skip_filters_(skip_filters),
-        file_index_(flevel_->num_files),
         level_(level),
-        range_del_agg_(range_del_agg),
-        pinned_iters_mgr_(nullptr) {
-    // Empty level is not supported.
-    assert(flevel_ != nullptr && flevel_->num_files > 0);
-  }
+        range_del_agg_(range_del_agg) {}
 
-  virtual ~LevelIterator() { delete file_iter_.Set(nullptr); }
-
-  virtual void Seek(const Slice& target) override;
-  virtual void SeekForPrev(const Slice& target) override;
-  virtual void SeekToFirst() override;
-  virtual void SeekToLast() override;
-  virtual void Next() override;
-  virtual void Prev() override;
-
-  virtual bool Valid() const override { return file_iter_.Valid(); }
-  virtual Slice key() const override {
-    assert(Valid());
-    return file_iter_.key();
-  }
-  virtual Slice value() const override {
-    assert(Valid());
-    return file_iter_.value();
-  }
-  virtual Status status() const override {
-    // It'd be nice if status() returned a const Status& instead of a Status
-    if (!status_.ok()) {
-      return status_;
-    } else if (file_iter_.iter() != nullptr) {
-      return file_iter_.status();
+  InternalIterator* NewSecondaryIterator(const Slice& meta_handle) override {
+    if (meta_handle.size() != sizeof(FileDescriptor)) {
+      return NewErrorInternalIterator(
+          Status::Corruption("FileReader invoked with unexpected value"));
     }
-    return Status::OK();
-  }
-  virtual void SetPinnedItersMgr(
-      PinnedIteratorsManager* pinned_iters_mgr) override {
-    pinned_iters_mgr_ = pinned_iters_mgr;
-    if (file_iter_.iter()) {
-      file_iter_.SetPinnedItersMgr(pinned_iters_mgr);
-    }
-  }
-  virtual bool IsKeyPinned() const override {
-    return pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled() &&
-           file_iter_.iter() && file_iter_.IsKeyPinned();
-  }
-  virtual bool IsValuePinned() const override {
-    return pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled() &&
-           file_iter_.iter() && file_iter_.IsValuePinned();
+    const FileDescriptor* fd =
+        reinterpret_cast<const FileDescriptor*>(meta_handle.data());
+    return table_cache_->NewIterator(
+        read_options_, env_options_, icomparator_, *fd, range_del_agg_,
+        nullptr /* don't need reference to table */, file_read_hist_,
+        for_compaction_, nullptr /* arena */, skip_filters_, level_);
   }
 
- private:
-  void SkipEmptyFileForward();
-  void SkipEmptyFileBackward();
-  void SetFileIterator(InternalIterator* iter);
-  void InitFileIterator(size_t new_file_index);
-
-  const Slice& file_smallest_key(size_t file_index) {
-    assert(file_index < flevel_->num_files);
-    return flevel_->files[file_index].smallest_key;
+  bool PrefixMayMatch(const Slice& internal_key) override {
+    return true;
   }
 
-  bool KeyReachedUpperBound(const Slice& internal_key) {
+  bool KeyReachedUpperBound(const Slice& internal_key) override {
     return read_options_.iterate_upper_bound != nullptr &&
            icomparator_.user_comparator()->Compare(
                ExtractUserKey(internal_key),
                *read_options_.iterate_upper_bound) >= 0;
   }
 
-  InternalIterator* NewFileIterator() {
-    assert(file_index_ < flevel_->num_files);
-    auto file_meta = flevel_->files[file_index_];
-    if (should_sample_) {
-      sample_file_read_inc(file_meta.file_metadata);
-    }
-
-    return table_cache_->NewIterator(
-        read_options_, env_options_, icomparator_, file_meta.fd, range_del_agg_,
-        nullptr /* don't need reference to table */, file_read_hist_,
-        for_compaction_, nullptr /* arena */, skip_filters_, level_);
-  }
-
+ private:
   TableCache* table_cache_;
   const ReadOptions read_options_;
   const EnvOptions& env_options_;
   const InternalKeyComparator& icomparator_;
-  const LevelFilesBrief* flevel_;
-  mutable FileDescriptor current_value_;
-
   HistogramImpl* file_read_hist_;
-  bool should_sample_;
   bool for_compaction_;
   bool skip_filters_;
-  size_t file_index_;
   int level_;
   RangeDelAggregator* range_del_agg_;
-  IteratorWrapper file_iter_;  // May be nullptr
-  PinnedIteratorsManager* pinned_iters_mgr_;
-  Status status_;
 };
 
-void LevelIterator::Seek(const Slice& target) {
-  size_t new_file_index = FindFile(icomparator_, *flevel_, target);
-
-  InitFileIterator(new_file_index);
-  if (file_iter_.iter() != nullptr) {
-    file_iter_.Seek(target);
-  }
-  SkipEmptyFileForward();
-}
-
-void LevelIterator::SeekForPrev(const Slice& target) {
-  size_t new_file_index = FindFile(icomparator_, *flevel_, target);
-  if (new_file_index >= flevel_->num_files) {
-    new_file_index = flevel_->num_files - 1;
-  }
-
-  InitFileIterator(new_file_index);
-  if (file_iter_.iter() != nullptr) {
-    file_iter_.SeekForPrev(target);
-    SkipEmptyFileBackward();
-  }
-}
-
-void LevelIterator::SeekToFirst() {
-  InitFileIterator(0);
-  if (file_iter_.iter() != nullptr) {
-    file_iter_.SeekToFirst();
-  }
-  SkipEmptyFileForward();
-}
-
-void LevelIterator::SeekToLast() {
-  InitFileIterator(flevel_->num_files - 1);
-  if (file_iter_.iter() != nullptr) {
-    file_iter_.SeekToLast();
-  }
-  SkipEmptyFileBackward();
-}
-
-void LevelIterator::Next() {
-  assert(Valid());
-  file_iter_.Next();
-  SkipEmptyFileForward();
-}
-
-void LevelIterator::Prev() {
-  assert(Valid());
-  file_iter_.Prev();
-  SkipEmptyFileBackward();
-}
-
-void LevelIterator::SkipEmptyFileForward() {
-  // For an error (IO error, checksum mismatch, etc), we skip the file
-  // and move to the next one and continue reading data.
-  // TODO this behavior is from LevelDB. We should revisit it.
-  while (file_iter_.iter() == nullptr ||
-         (!file_iter_.Valid() && !file_iter_.status().IsIncomplete())) {
-    if (file_iter_.iter() != nullptr && !file_iter_.Valid() &&
-        file_iter_.iter()->IsOutOfBound()) {
-      return;
-    }
-
-    // Move to next file
-    if (file_index_ >= flevel_->num_files - 1) {
-      // Already at the last file
-      SetFileIterator(nullptr);
-      return;
-    }
-    if (KeyReachedUpperBound(file_smallest_key(file_index_ + 1))) {
-      SetFileIterator(nullptr);
-      return;
-    }
-    InitFileIterator(file_index_ + 1);
-    if (file_iter_.iter() != nullptr) {
-      file_iter_.SeekToFirst();
-    }
-  }
-}
-
-void LevelIterator::SkipEmptyFileBackward() {
-  while (file_iter_.iter() == nullptr ||
-         (!file_iter_.Valid() && !file_iter_.status().IsIncomplete())) {
-    // Move to previous file
-    if (file_index_ == 0) {
-      // Already the first file
-      SetFileIterator(nullptr);
-      return;
-    }
-    InitFileIterator(file_index_ - 1);
-    if (file_iter_.iter() != nullptr) {
-      file_iter_.SeekToLast();
-    }
-  }
-}
-
-void LevelIterator::SetFileIterator(InternalIterator* iter) {
-  if (file_iter_.iter() != nullptr && status_.ok()) {
-    // TODO right now we don't invalidate the iterator even if the status is
-    // not OK. We should consider to do that so that it is harder for users to
-    // skip errors.
-    status_ = file_iter_.status();
-  }
-
-  if (pinned_iters_mgr_ && iter) {
-    iter->SetPinnedItersMgr(pinned_iters_mgr_);
-  }
-
-  InternalIterator* old_iter = file_iter_.Set(iter);
-  if (pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled()) {
-    pinned_iters_mgr_->PinIterator(old_iter);
-  } else {
-    delete old_iter;
-  }
-}
-
-void LevelIterator::InitFileIterator(size_t new_file_index) {
-  if (new_file_index >= flevel_->num_files) {
-    file_index_ = new_file_index;
-    SetFileIterator(nullptr);
-    return;
-  } else {
-    // If the file iterator shows incomplete, we try it again if users seek
-    // to the same file, as this time we may go to a different data block
-    // which is cached in block cache.
-    //
-    if (file_iter_.iter() != nullptr && !file_iter_.status().IsIncomplete() &&
-        new_file_index == file_index_) {
-      // file_iter_ is already constructed with this iterator, so
-      // no need to change anything
-    } else {
-      file_index_ = new_file_index;
-      InternalIterator* iter = NewFileIterator();
-      SetFileIterator(iter);
-    }
-  }
-}
-
 // A wrapper of version builder which references the current version in
 // constructor and unref it in the destructor.
 // Both of the constructor and destructor need to be called inside DB Mutex.
@@ -891,15 +759,6 @@ void Version::GetColumnFamilyMetaData(ColumnFamilyMetaData* cf_meta) {
   }
 }
 
-uint64_t Version::GetSstFilesSize() {
-  uint64_t sst_files_size = 0;
-  for (int level = 0; level < storage_info_.num_levels_; level++) {
-    for (const auto& file_meta : storage_info_.LevelFiles(level)) {
-      sst_files_size += file_meta->fd.GetFileSize();
-    }
-  }
-  return sst_files_size;
-}
 
 uint64_t VersionStorageInfo::GetEstimatedActiveKeys() const {
   // Estimation will be inaccurate when:
@@ -995,18 +854,24 @@ void Version::AddIteratorsForLevel(const ReadOptions& read_options,
         sample_file_read_inc(meta);
       }
     }
-  } else if (storage_info_.LevelFilesBrief(level).num_files > 0) {
+  } else {
     // For levels > 0, we can use a concatenating iterator that sequentially
     // walks through the non-overlapping files in the level, opening them
     // lazily.
-    auto* mem = arena->AllocateAligned(sizeof(LevelIterator));
-    merge_iter_builder->AddIterator(new (mem) LevelIterator(
-        cfd_->table_cache(), read_options, soptions,
+    auto* mem = arena->AllocateAligned(sizeof(LevelFileIteratorState));
+    auto* state = new (mem)
+        LevelFileIteratorState(cfd_->table_cache(), read_options, soptions,
+                               cfd_->internal_comparator(),
+                               cfd_->internal_stats()->GetFileReadHist(level),
+                               false /* for_compaction */,
+                               cfd_->ioptions()->prefix_extractor != nullptr,
+                               IsFilterSkipped(level), level, range_del_agg);
+    mem = arena->AllocateAligned(sizeof(LevelFileNumIterator));
+    auto* first_level_iter = new (mem) LevelFileNumIterator(
         cfd_->internal_comparator(), &storage_info_.LevelFilesBrief(level),
-        should_sample_file_read(),
-        cfd_->internal_stats()->GetFileReadHist(level),
-        false /* for_compaction */, IsFilterSkipped(level), level,
-        range_del_agg));
+        should_sample_file_read());
+    merge_iter_builder->AddIterator(
+        NewTwoLevelIterator(state, first_level_iter, arena, false));
   }
 }
 
@@ -2111,7 +1976,7 @@ void VersionStorageInfo::ExtendFileRangeOverlappingInterval(
 #endif
   *start_index = mid_index + 1;
   *end_index = mid_index;
-  int count __attribute__((__unused__));
+  int count __attribute__((unused));
   count = 0;
 
   // check backwards from 'mid' to lower indices
@@ -2907,7 +2772,7 @@ void VersionSet::LogAndApplyCFHelper(VersionEdit* edit) {
 }
 
 void VersionSet::LogAndApplyHelper(ColumnFamilyData* cfd,
-                                   VersionBuilder* builder, Version* /*v*/,
+                                   VersionBuilder* builder, Version* v,
                                    VersionEdit* edit, InstrumentedMutex* mu) {
   mu->AssertHeld();
   assert(!edit->IsColumnFamilyManipulation());
@@ -3867,13 +3732,17 @@ InternalIterator* VersionSet::MakeInputIterator(
         }
       } else {
         // Create concatenating iterator for the files from this level
-        list[num++] = new LevelIterator(
-            cfd->table_cache(), read_options, env_options_compactions,
-            cfd->internal_comparator(), c->input_levels(which),
-            false /* should_sample */,
-            nullptr /* no per level latency histogram */,
-            true /* for_compaction */, false /* skip_filters */,
-            (int)which /* level */, range_del_agg);
+        list[num++] = NewTwoLevelIterator(
+            new LevelFileIteratorState(
+                cfd->table_cache(), read_options, env_options_compactions,
+                cfd->internal_comparator(),
+                nullptr /* no per level latency histogram */,
+                true /* for_compaction */, false /* prefix enabled */,
+                false /* skip_filters */, (int)which /* level */,
+                range_del_agg),
+            new LevelFileNumIterator(cfd->internal_comparator(),
+                                     c->input_levels(which),
+                                     false /* don't sample compaction */));
       }
     }
   }

db/version_set.h

@@ -613,8 +613,6 @@ class Version {
 
   void GetColumnFamilyMetaData(ColumnFamilyMetaData* cf_meta);
 
-  uint64_t GetSstFilesSize();
-
  private:
   Env* env_;
   friend class VersionSet;
@@ -872,7 +870,7 @@ class VersionSet {
 
   struct LogReporter : public log::Reader::Reporter {
     Status* status;
-    virtual void Corruption(size_t /*bytes*/, const Status& s) override {
+    virtual void Corruption(size_t bytes, const Status& s) override {
       if (this->status->ok()) *this->status = s;
     }
   };

db/version_set_test.cc

@@ -76,9 +76,7 @@ class CountingLogger : public Logger {
  public:
   CountingLogger() : log_count(0) {}
   using Logger::Logv;
-  virtual void Logv(const char* /*format*/, va_list /*ap*/) override {
-    log_count++;
-  }
+  virtual void Logv(const char* format, va_list ap) override { log_count++; }
   int log_count;
 };
 

db/wal_manager_test.cc

@@ -73,7 +73,7 @@ class WalManagerTest : public testing::Test {
   }
 
   // NOT thread safe
-  void RollTheLog(bool /*archived*/) {
+  void RollTheLog(bool archived) {
     current_log_number_++;
     std::string fname = ArchivedLogFileName(dbname_, current_log_number_);
     unique_ptr<WritableFile> file;

db/write_batch.cc

@@ -186,7 +186,7 @@ WriteBatch::~WriteBatch() { delete save_points_; }
 
 WriteBatch::Handler::~Handler() { }
 
-void WriteBatch::Handler::LogData(const Slice& /*blob*/) {
+void WriteBatch::Handler::LogData(const Slice& blob) {
   // If the user has not specified something to do with blobs, then we ignore
   // them.
 }
@@ -402,22 +402,14 @@ Status WriteBatch::Iterate(Handler* handler) const {
   bool empty_batch = true;
   int found = 0;
   Status s;
-  char tag = 0;
-  uint32_t column_family = 0;  // default
-  while ((s.ok() || UNLIKELY(s.IsTryAgain())) && !input.empty() &&
-         handler->Continue()) {
-    if (LIKELY(!s.IsTryAgain())) {
-      tag = 0;
-      column_family = 0;  // default
+  while (s.ok() && !input.empty() && handler->Continue()) {
+    char tag = 0;
+    uint32_t column_family = 0;  // default
 
-      s = ReadRecordFromWriteBatch(&input, &tag, &column_family, &key, &value,
-                                   &blob, &xid);
-      if (!s.ok()) {
-        return s;
-      }
-    } else {
-      assert(s.IsTryAgain());
-      s = Status::OK();
+    s = ReadRecordFromWriteBatch(&input, &tag, &column_family, &key, &value,
+                                 &blob, &xid);
+    if (!s.ok()) {
+      return s;
     }
 
     switch (tag) {
@@ -426,59 +418,47 @@ Status WriteBatch::Iterate(Handler* handler) const {
         assert(content_flags_.load(std::memory_order_relaxed) &
                (ContentFlags::DEFERRED | ContentFlags::HAS_PUT));
         s = handler->PutCF(column_family, key, value);
-        if (LIKELY(s.ok())) {
-          empty_batch = false;
-          found++;
-        }
+        empty_batch = false;
+        found++;
         break;
       case kTypeColumnFamilyDeletion:
       case kTypeDeletion:
         assert(content_flags_.load(std::memory_order_relaxed) &
                (ContentFlags::DEFERRED | ContentFlags::HAS_DELETE));
         s = handler->DeleteCF(column_family, key);
-        if (LIKELY(s.ok())) {
-          empty_batch = false;
-          found++;
-        }
+        empty_batch = false;
+        found++;
         break;
       case kTypeColumnFamilySingleDeletion:
       case kTypeSingleDeletion:
         assert(content_flags_.load(std::memory_order_relaxed) &
                (ContentFlags::DEFERRED | ContentFlags::HAS_SINGLE_DELETE));
         s = handler->SingleDeleteCF(column_family, key);
-        if (LIKELY(s.ok())) {
-          empty_batch = false;
-          found++;
-        }
+        empty_batch = false;
+        found++;
         break;
       case kTypeColumnFamilyRangeDeletion:
       case kTypeRangeDeletion:
         assert(content_flags_.load(std::memory_order_relaxed) &
                (ContentFlags::DEFERRED | ContentFlags::HAS_DELETE_RANGE));
         s = handler->DeleteRangeCF(column_family, key, value);
-        if (LIKELY(s.ok())) {
-          empty_batch = false;
-          found++;
-        }
+        empty_batch = false;
+        found++;
         break;
       case kTypeColumnFamilyMerge:
       case kTypeMerge:
         assert(content_flags_.load(std::memory_order_relaxed) &
                (ContentFlags::DEFERRED | ContentFlags::HAS_MERGE));
         s = handler->MergeCF(column_family, key, value);
-        if (LIKELY(s.ok())) {
-          empty_batch = false;
-          found++;
-        }
+        empty_batch = false;
+        found++;
         break;
       case kTypeColumnFamilyBlobIndex:
       case kTypeBlobIndex:
         assert(content_flags_.load(std::memory_order_relaxed) &
                (ContentFlags::DEFERRED | ContentFlags::HAS_BLOB_INDEX));
         s = handler->PutBlobIndexCF(column_family, key, value);
-        if (LIKELY(s.ok())) {
-          found++;
-        }
+        found++;
         break;
       case kTypeLogData:
         handler->LogData(blob);
@@ -569,19 +549,12 @@ void WriteBatchInternal::SetSequence(WriteBatch* b, SequenceNumber seq) {
   EncodeFixed64(&b->rep_[0], seq);
 }
 
-size_t WriteBatchInternal::GetFirstOffset(WriteBatch* /*b*/) {
+size_t WriteBatchInternal::GetFirstOffset(WriteBatch* b) {
   return WriteBatchInternal::kHeader;
 }
 
 Status WriteBatchInternal::Put(WriteBatch* b, uint32_t column_family_id,
                                const Slice& key, const Slice& value) {
-  if (key.size() > size_t{port::kMaxUint32}) {
-    return Status::InvalidArgument("key is too large");
-  }
-  if (value.size() > size_t{port::kMaxUint32}) {
-    return Status::InvalidArgument("value is too large");
-  }
-
   LocalSavePoint save(b);
   WriteBatchInternal::SetCount(b, WriteBatchInternal::Count(b) + 1);
   if (column_family_id == 0) {
@@ -604,33 +577,8 @@ Status WriteBatch::Put(ColumnFamilyHandle* column_family, const Slice& key,
                                  value);
 }
 
-Status WriteBatchInternal::CheckSlicePartsLength(const SliceParts& key,
-                                                 const SliceParts& value) {
-  size_t total_key_bytes = 0;
-  for (int i = 0; i < key.num_parts; ++i) {
-    total_key_bytes += key.parts[i].size();
-  }
-  if (total_key_bytes >= size_t{port::kMaxUint32}) {
-    return Status::InvalidArgument("key is too large");
-  }
-
-  size_t total_value_bytes = 0;
-  for (int i = 0; i < value.num_parts; ++i) {
-    total_value_bytes += value.parts[i].size();
-  }
-  if (total_value_bytes >= size_t{port::kMaxUint32}) {
-    return Status::InvalidArgument("value is too large");
-  }
-  return Status::OK();
-}
-
 Status WriteBatchInternal::Put(WriteBatch* b, uint32_t column_family_id,
                                const SliceParts& key, const SliceParts& value) {
-  Status s = CheckSlicePartsLength(key, value);
-  if (!s.ok()) {
-    return s;
-  }
-
   LocalSavePoint save(b);
   WriteBatchInternal::SetCount(b, WriteBatchInternal::Count(b) + 1);
   if (column_family_id == 0) {
@@ -847,13 +795,6 @@ Status WriteBatch::DeleteRange(ColumnFamilyHandle* column_family,
 
 Status WriteBatchInternal::Merge(WriteBatch* b, uint32_t column_family_id,
                                  const Slice& key, const Slice& value) {
-  if (key.size() > size_t{port::kMaxUint32}) {
-    return Status::InvalidArgument("key is too large");
-  }
-  if (value.size() > size_t{port::kMaxUint32}) {
-    return Status::InvalidArgument("value is too large");
-  }
-
   LocalSavePoint save(b);
   WriteBatchInternal::SetCount(b, WriteBatchInternal::Count(b) + 1);
   if (column_family_id == 0) {
@@ -879,11 +820,6 @@ Status WriteBatch::Merge(ColumnFamilyHandle* column_family, const Slice& key,
 Status WriteBatchInternal::Merge(WriteBatch* b, uint32_t column_family_id,
                                  const SliceParts& key,
                                  const SliceParts& value) {
-  Status s = CheckSlicePartsLength(key, value);
-  if (!s.ok()) {
-    return s;
-  }
-
   LocalSavePoint save(b);
   WriteBatchInternal::SetCount(b, WriteBatchInternal::Count(b) + 1);
   if (column_family_id == 0) {
@@ -1148,23 +1084,12 @@ class MemTableInserter : public WriteBatch::Handler {
       MaybeAdvanceSeq();
       return seek_status;
     }
-    Status ret_status;
 
     MemTable* mem = cf_mems_->GetMemTable();
     auto* moptions = mem->GetImmutableMemTableOptions();
-    // inplace_update_support is inconsistent with snapshots, and therefore with
-    // any kind of transactions including the ones that use seq_per_batch
-    assert(!seq_per_batch_ || !moptions->inplace_update_support);
     if (!moptions->inplace_update_support) {
-      bool mem_res =
-          mem->Add(sequence_, value_type, key, value,
-                   concurrent_memtable_writes_, get_post_process_info(mem));
-      if (UNLIKELY(!mem_res)) {
-        assert(seq_per_batch_);
-        ret_status = Status::TryAgain("key+seq exists");
-        const bool BATCH_BOUNDRY = true;
-        MaybeAdvanceSeq(BATCH_BOUNDRY);
-      }
+      mem->Add(sequence_, value_type, key, value, concurrent_memtable_writes_,
+               get_post_process_info(mem));
     } else if (moptions->inplace_callback == nullptr) {
       assert(!concurrent_memtable_writes_);
       mem->Update(sequence_, key, value);
@@ -1200,17 +1125,11 @@ class MemTableInserter : public WriteBatch::Handler {
                                                  value, &merged_value);
         if (status == UpdateStatus::UPDATED_INPLACE) {
           // prev_value is updated in-place with final value.
-          bool mem_res __attribute__((__unused__));
-          mem_res = mem->Add(
-              sequence_, value_type, key, Slice(prev_buffer, prev_size));
-          assert(mem_res);
+          mem->Add(sequence_, value_type, key, Slice(prev_buffer, prev_size));
           RecordTick(moptions->statistics, NUMBER_KEYS_WRITTEN);
         } else if (status == UpdateStatus::UPDATED) {
           // merged_value contains the final value.
-          bool mem_res __attribute__((__unused__));
-          mem_res =
-              mem->Add(sequence_, value_type, key, Slice(merged_value));
-          assert(mem_res);
+          mem->Add(sequence_, value_type, key, Slice(merged_value));
           RecordTick(moptions->statistics, NUMBER_KEYS_WRITTEN);
         }
       }
@@ -1220,7 +1139,7 @@ class MemTableInserter : public WriteBatch::Handler {
     // in memtable add/update.
     MaybeAdvanceSeq();
     CheckMemtableFull();
-    return ret_status;
+    return Status::OK();
   }
 
   virtual Status PutCF(uint32_t column_family_id, const Slice& key,
@@ -1228,22 +1147,14 @@ class MemTableInserter : public WriteBatch::Handler {
     return PutCFImpl(column_family_id, key, value, kTypeValue);
   }
 
-  Status DeleteImpl(uint32_t /*column_family_id*/, const Slice& key,
+  Status DeleteImpl(uint32_t column_family_id, const Slice& key,
                     const Slice& value, ValueType delete_type) {
-    Status ret_status;
     MemTable* mem = cf_mems_->GetMemTable();
-    bool mem_res =
-        mem->Add(sequence_, delete_type, key, value,
-                 concurrent_memtable_writes_, get_post_process_info(mem));
-    if (UNLIKELY(!mem_res)) {
-      assert(seq_per_batch_);
-      ret_status = Status::TryAgain("key+seq exists");
-      const bool BATCH_BOUNDRY = true;
-      MaybeAdvanceSeq(BATCH_BOUNDRY);
-    }
+    mem->Add(sequence_, delete_type, key, value, concurrent_memtable_writes_,
+             get_post_process_info(mem));
     MaybeAdvanceSeq();
     CheckMemtableFull();
-    return ret_status;
+    return Status::OK();
   }
 
   virtual Status DeleteCF(uint32_t column_family_id,
@@ -1335,7 +1246,6 @@ class MemTableInserter : public WriteBatch::Handler {
       return seek_status;
     }
 
-    Status ret_status;
     MemTable* mem = cf_mems_->GetMemTable();
     auto* moptions = mem->GetImmutableMemTableOptions();
     bool perform_merge = false;
@@ -1391,30 +1301,18 @@ class MemTableInserter : public WriteBatch::Handler {
         perform_merge = false;
       } else {
         // 3) Add value to memtable
-        bool mem_res = mem->Add(sequence_, kTypeValue, key, new_value);
-        if (UNLIKELY(!mem_res)) {
-          assert(seq_per_batch_);
-          ret_status = Status::TryAgain("key+seq exists");
-          const bool BATCH_BOUNDRY = true;
-          MaybeAdvanceSeq(BATCH_BOUNDRY);
-        }
+        mem->Add(sequence_, kTypeValue, key, new_value);
       }
     }
 
     if (!perform_merge) {
       // Add merge operator to memtable
-      bool mem_res = mem->Add(sequence_, kTypeMerge, key, value);
-      if (UNLIKELY(!mem_res)) {
-        assert(seq_per_batch_);
-        ret_status = Status::TryAgain("key+seq exists");
-        const bool BATCH_BOUNDRY = true;
-        MaybeAdvanceSeq(BATCH_BOUNDRY);
-      }
+      mem->Add(sequence_, kTypeMerge, key, value);
     }
 
     MaybeAdvanceSeq();
     CheckMemtableFull();
-    return ret_status;
+    return Status::OK();
   }
 
   virtual Status PutBlobIndexCF(uint32_t column_family_id, const Slice& key,
@@ -1598,8 +1496,6 @@ Status WriteBatchInternal::InsertInto(
     if (!w->status.ok()) {
       return w->status;
     }
-    assert(!seq_per_batch || w->batch_cnt != 0);
-    assert(!seq_per_batch || inserter.sequence() - w->sequence == w->batch_cnt);
   }
   return Status::OK();
 }
@@ -1608,7 +1504,7 @@ Status WriteBatchInternal::InsertInto(
     WriteThread::Writer* writer, SequenceNumber sequence,
     ColumnFamilyMemTables* memtables, FlushScheduler* flush_scheduler,
     bool ignore_missing_column_families, uint64_t log_number, DB* db,
-    bool concurrent_memtable_writes, bool seq_per_batch, size_t batch_cnt) {
+    bool concurrent_memtable_writes, bool seq_per_batch) {
   assert(writer->ShouldWriteToMemtable());
   MemTableInserter inserter(sequence, memtables, flush_scheduler,
                             ignore_missing_column_families, log_number, db,
@@ -1617,8 +1513,6 @@ Status WriteBatchInternal::InsertInto(
   SetSequence(writer->batch, sequence);
   inserter.set_log_number_ref(writer->log_ref);
   Status s = writer->batch->Iterate(&inserter);
-  assert(!seq_per_batch || batch_cnt != 0);
-  assert(!seq_per_batch || inserter.sequence() - sequence == batch_cnt);
   if (concurrent_memtable_writes) {
     inserter.PostProcess();
   }