StackableDB optionally take shared ownership of the underlying DB

2026-07-07 22:55:23 +08:00 · 2018-01-25 15:34:12 -08:00
451 changed files with 4979 additions and 23105 deletions
@@ -20,9 +20,8 @@ addons:
 env:
  - TEST_GROUP=platform_dependent # 16-18 minutes
  - TEST_GROUP=1 # 33-35 minutes
-  - TEST_GROUP=2 # 18-20 minutes
-  - TEST_GROUP=3 # 20-22 minutes
-  - TEST_GROUP=4 # 12-14 minutes
+  - TEST_GROUP=2 # 30-32 minutes
+  - TEST_GROUP=3 # ? minutes - under development
  # Run java tests
  - JOB_NAME=java_test # 4-11 minutes
  # Build ROCKSDB_LITE
@@ -40,8 +39,6 @@ matrix:
    env: TEST_GROUP=2
  - os: osx
    env: TEST_GROUP=3
-  - os: osx
-    env: TEST_GROUP=4
  - os : osx
    env: JOB_NAME=cmake-mingw
  - os : linux
@@ -68,10 +65,9 @@ script:
  - ${CXX} --version
  - if [ `command -v ccache` ]; then ccache -C; fi
  - if [ "${TEST_GROUP}" == 'platform_dependent' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_END=db_block_cache_test make -j4 all_but_some_tests check_some; fi
-  - if [ "${TEST_GROUP}" == '1' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=db_block_cache_test ROCKSDBTESTS_END=full_filter_block_test make -j4 check_some; fi
-  - if [ "${TEST_GROUP}" == '2' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=full_filter_block_test ROCKSDBTESTS_END=write_batch_with_index_test make -j4 check_some; fi
-  - if [ "${TEST_GROUP}" == '3' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=write_batch_with_index_test ROCKSDBTESTS_END=write_prepared_transaction_test make -j4 check_some; fi
-  - if [ "${TEST_GROUP}" == '4' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=write_prepared_transaction_test make -j4 check_some; fi
+  - if [ "${TEST_GROUP}" == '1' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=db_block_cache_test ROCKSDBTESTS_END=comparator_db_test make -j4 check_some; fi
+  - if [ "${TEST_GROUP}" == '2' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=comparator_db_test ROCKSDBTESTS_END=write_prepared_transaction_test make -j4 check_some; fi
+  - if [ "${TEST_GROUP}" == '3' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=write_prepared_transaction_test make -j4 check_some; fi
  - if [ "${JOB_NAME}" == 'java_test' ]; then OPT=-DTRAVIS V=1 make clean jclean && make rocksdbjava jtest; fi
  - if [ "${JOB_NAME}" == 'lite_build' ]; then OPT="-DTRAVIS -DROCKSDB_LITE" V=1 make -j4 static_lib tools; fi
  - if [ "${JOB_NAME}" == 'examples' ]; then OPT=-DTRAVIS V=1 make -j4 static_lib; cd examples; make -j4; fi
@@ -56,7 +56,7 @@ if(MSVC)
  include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
 else()
  if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
-    # FreeBSD has jemalloc as default malloc
+    # FreeBSD has jemaloc as default malloc
    # but it does not have all the jemalloc files in include/...
    set(WITH_JEMALLOC ON)
  else()
@@ -569,14 +569,12 @@ set(SOURCES
        util/status_message.cc
        util/string_util.cc
        util/sync_point.cc
-        util/sync_point_impl.cc
        util/testutil.cc
        util/thread_local.cc
        util/threadpool_imp.cc
        util/transaction_test_util.cc
        util/xxhash.cc
        utilities/backupable/backupable_db.cc
-        utilities/blob_db/blob_compaction_filter.cc
        utilities/blob_db/blob_db.cc
        utilities/blob_db/blob_db_impl.cc
        utilities/blob_db/blob_dump_tool.cc
@@ -604,7 +602,6 @@ set(SOURCES
        utilities/leveldb_options/leveldb_options.cc
        utilities/lua/rocks_lua_compaction_filter.cc
        utilities/memory/memory_util.cc
-        utilities/merge_operators/bytesxor.cc
        utilities/merge_operators/max.cc
        utilities/merge_operators/put.cc
        utilities/merge_operators/string_append/stringappend.cc
@@ -1,68 +1,9 @@
 # Rocksdb Change Log
 ## Unreleased
 ### Public API Change
-
-### New Features
-
-### Bug Fixes
-* Fsync after writing global seq number to the ingestion file in ExternalSstFileIngestionJob.
-
-### Java API Changes
-* Add `BlockBasedTableConfig.setBlockCache` to allow sharing a block cache across DB instances.
-
-## 5.13.0 (3/20/2018)
-### 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
-* SstFileManager now can cancel compactions if they will result in max space errors. SstFileManager users can also use SetCompactionBufferSize to specify how much space must be leftover during a compaction for auxiliary file functions such as logging and flushing.
-* Avoid unnecessarily flushing in `CompactRange()` when the range specified by the user does not overlap unflushed memtables.
-* If `ColumnFamilyOptions::max_subcompactions` is set greater than one, we now parallelize large manual level-based compactions.
-* Add "rocksdb.live-sst-files-size" DB property to return total bytes of all SST files belong to the latest LSM tree.
-* NewSstFileManager to add an argument bytes_max_delete_chunk with default 64MB. With this argument, a file larger than 64MB will be ftruncated multiple times based on this size.
-
-### Bug Fixes
-* Fix a leak in prepared_section_completed_ where the zeroed entries would not removed from the map.
-* Fix WAL corruption caused by race condition between user write thread and backup/checkpoint thread.
-
-## 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)
@@ -85,7 +26,7 @@
 * `BackupableDBOptions::max_valid_backups_to_open == 0` now means no backups will be opened during BackupEngine initialization. Previously this condition disabled limiting backups opened.
 * `DBOptions::preserve_deletes` is a new option that allows one to specify that DB should not drop tombstones for regular deletes if they have sequence number larger than what was set by the new API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)`. Disabled by default.
 * API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)` was added, users who wish to preserve deletes are expected to periodically call this function to advance the cutoff seqnum (all deletes made before this seqnum can be dropped by DB). It's user responsibility to figure out how to advance the seqnum in the way so the tombstones are kept for the desired period of time, yet are eventually processed in time and don't eat up too much space.
-* `ReadOptions::iter_start_seqnum` was added; if set to something > 0 user will see 2 changes in iterators behavior 1) only keys written with sequence larger than this parameter would be returned and 2) the `Slice` returned by iter->key() now points to the memory that keep User-oriented representation of the internal key, rather than user key. New struct `FullKey` was added to represent internal keys, along with a new helper function `ParseFullKey(const Slice& internal_key, FullKey* result);`.
+* `ReadOptions::iter_start_seqnum` was added; if set to something > 0 user will see 2 changes in iterators behavior 1) only keys written with sequence larger than this parameter would be returned and 2) the `Slice` returned by iter->key() now points to the the memory that keep User-oriented representation of the internal key, rather than user key. New struct `FullKey` was added to represent internal keys, along with a new helper function `ParseFullKey(const Slice& internal_key, FullKey* result);`.
 * Deprecate trash_dir param in NewSstFileManager, right now we will rename deleted files to <name>.trash instead of moving them to trash directory
 * Allow setting a custom trash/DB size ratio limit in the SstFileManager, after which files that are to be scheduled for deletion are deleted immediately, regardless of any delete ratelimit.
 * Return an error on write if write_options.sync = true and write_options.disableWAL = true to warn user of inconsistent options. Previously we will not write to WAL and not respecting the sync options in this case.
@@ -141,27 +141,6 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
        export JAVA_HOME=/usr/local/openjdk7
        gmake rocksdbjava

-* **OpenBSD** (6.3/-current):
-
-    * As RocksDB is not available in the ports yet you have to build it on your own:
-
-    * Install the dependencies for RocksDB:
-
-        pkg_add gmake gflags snappy bzip2 lz4 zstd git jdk bash findutils gnuwatch 
-
-    * Build RocksDB from source:
-
-        cd ~
-        git clone https://github.com/facebook/rocksdb.git
-        cd rocksdb
-        gmake static_lib
-
-    * Build RocksJava from source (optional):
-
-        cd rocksdb
-        export JAVA_HOME=/usr/local/jdk-1.8.0
-        export PATH=$PATH:/usr/local/jdk-1.8.0/bin
-        gmake rocksdbjava

 * **iOS**:
  * Run: `TARGET_OS=IOS make static_lib`. When building the project which uses rocksdb iOS library, make sure to define two important pre-processing macros: `ROCKSDB_LITE` and `IOS_CROSS_COMPILE`.
@@ -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
@@ -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
@@ -278,10 +274,6 @@ default: all
 WARNING_FLAGS = -W -Wextra -Wall -Wsign-compare -Wshadow \
  -Wno-unused-parameter

-ifeq ($(PLATFORM), OS_OPENBSD)
-	WARNING_FLAGS += -Wno-unused-lambda-capture
-endif
-
 ifndef DISABLE_WARNING_AS_ERROR
 	WARNING_FLAGS += -Werror
 endif
@@ -410,6 +402,7 @@ TESTS = \
 	db_range_del_test \
 	db_sst_test \
 	db_tailing_iter_test \
+	db_universal_compaction_test \
 	db_io_failure_test \
 	db_properties_test \
 	db_table_properties_test \
@@ -511,7 +504,6 @@ TESTS = \
 	repair_test \
 	env_timed_test \
 	write_prepared_transaction_test \
-	db_universal_compaction_test \

 PARALLEL_TEST = \
 	backupable_db_test \
@@ -531,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)/')
@@ -678,7 +666,7 @@ coverage:
 	COVERAGEFLAGS="-fprofile-arcs -ftest-coverage" LDFLAGS+="-lgcov" $(MAKE) J=1 all check
 	cd coverage && ./coverage_test.sh
        # Delete intermediate files
-	$(FIND) . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;
+	find . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;

 ifneq (,$(filter check parallel_check,$(MAKECMDGOALS)),)
 # Use /dev/shm if it has the sticky bit set (otherwise, /tmp),
@@ -825,7 +813,7 @@ CLEAN_FILES += t LOG $(TMPD)
 # regardless of their duration. As with any use of "watch", hit ^C to
 # interrupt.
 watch-log:
-	$(WATCH) --interval=0 'sort -k7,7nr -k4,4gr LOG|$(quoted_perl_command)'
+	watch --interval=0 'sort -k7,7nr -k4,4gr LOG|$(quoted_perl_command)'

 # If J != 1 and GNU parallel is installed, run the tests in parallel,
 # via the check_0 rule above.  Otherwise, run them sequentially.
@@ -990,14 +978,14 @@ rocksdb.h rocksdb.cc: build_tools/amalgamate.py Makefile $(LIB_SOURCES) unity.cc
 clean:
 	rm -f $(BENCHMARKS) $(TOOLS) $(TESTS) $(LIBRARY) $(SHARED)
 	rm -rf $(CLEAN_FILES) ios-x86 ios-arm scan_build_report
-	$(FIND) . -name "*.[oda]" -exec rm -f {} \;
-	$(FIND) . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;
+	find . -name "*.[oda]" -exec rm -f {} \;
+	find . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;
 	rm -rf bzip2* snappy* zlib* lz4* zstd*
 	cd java; $(MAKE) clean

 tags:
-	ctags -R .
-	cscope -b `$(FIND) . -name '*.cc'` `$(FIND) . -name '*.h'` `$(FIND) . -name '*.c'`
+	ctags * -R
+	cscope -b `find . -name '*.cc'` `find . -name '*.h'` `find . -name '*.c'`
 	ctags -e -R -o etags *

 format:
@@ -1514,10 +1502,10 @@ uninstall:

 install-headers:
 	install -d $(INSTALL_PATH)/lib
-	for header_dir in `$(FIND) "include/rocksdb" -type d`; do \
+	for header_dir in `find "include/rocksdb" -type d`; do \
 		install -d $(INSTALL_PATH)/$$header_dir; \
 	done
-	for header in `$(FIND) "include/rocksdb" -type f -name *.h`; do \
+	for header in `find "include/rocksdb" -type f -name *.h`; do \
 		install -C -m 644 $$header $(INSTALL_PATH)/$$header; \
 	done

@@ -1544,12 +1532,6 @@ install: install-static
 JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/linux
 ifeq ($(PLATFORM), OS_SOLARIS)
 	ARCH := $(shell isainfo -b)
-else ifeq ($(PLATFORM), OS_OPENBSD)
-	ifneq (,$(filter $(MACHINE), amd64 arm64 sparc64))
-		ARCH := 64
-	else
-		ARCH := 32
-	endif
 else
 	ARCH := $(shell getconf LONG_BIT)
 endif
@@ -1580,7 +1562,6 @@ LZ4_DOWNLOAD_BASE ?= https://github.com/lz4/lz4/archive
 ZSTD_VER ?= 1.3.3
 ZSTD_SHA256 ?= a77c47153ee7de02626c5b2a097005786b71688be61e9fb81806a011f90b297b
 ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive
-CURL_SSL_OPTS ?= --tlsv1

 ifeq ($(PLATFORM), OS_MACOSX)
 	ROCKSDBJNILIB = librocksdbjni-osx.jnilib
@@ -1609,11 +1590,6 @@ ifeq ($(PLATFORM), OS_AIX)
 	EXTRACT_SOURCES = gunzip < TAR_GZ | tar xvf -
 	SNAPPY_MAKE_TARGET = libsnappy.la
 endif
-ifeq ($(PLATFORM), OS_OPENBSD)
-        JAVA_INCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/openbsd
-	ROCKSDBJNILIB = librocksdbjni-openbsd$(ARCH).so
-        ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-openbsd$(ARCH).jar
-endif

 libz.a:
 	-rm -rf zlib-$(ZLIB_VER)
@@ -1641,7 +1617,7 @@ libbz2.a:

 libsnappy.a:
 	-rm -rf snappy-$(SNAPPY_VER)
-	curl -O -L ${CURL_SSL_OPTS} ${SNAPPY_DOWNLOAD_BASE}/$(SNAPPY_VER)/snappy-$(SNAPPY_VER).tar.gz
+	curl -O -L ${SNAPPY_DOWNLOAD_BASE}/$(SNAPPY_VER)/snappy-$(SNAPPY_VER).tar.gz
 	SNAPPY_SHA256_ACTUAL=`$(SHA256_CMD) snappy-$(SNAPPY_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(SNAPPY_SHA256)" != "$$SNAPPY_SHA256_ACTUAL" ]; then \
 		echo snappy-$(SNAPPY_VER).tar.gz checksum mismatch, expected=\"$(SNAPPY_SHA256)\" actual=\"$$SNAPPY_SHA256_ACTUAL\"; \
@@ -1654,7 +1630,7 @@ libsnappy.a:

 liblz4.a:
 	-rm -rf lz4-$(LZ4_VER)
-	curl -O -L ${CURL_SSL_OPTS} ${LZ4_DOWNLOAD_BASE}/v$(LZ4_VER).tar.gz
+	curl -O -L ${LZ4_DOWNLOAD_BASE}/v$(LZ4_VER).tar.gz
 	mv v$(LZ4_VER).tar.gz lz4-$(LZ4_VER).tar.gz
 	LZ4_SHA256_ACTUAL=`$(SHA256_CMD) lz4-$(LZ4_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(LZ4_SHA256)" != "$$LZ4_SHA256_ACTUAL" ]; then \
@@ -1667,7 +1643,7 @@ liblz4.a:

 libzstd.a:
 	-rm -rf zstd-$(ZSTD_VER)
-	curl -O -L ${CURL_SSL_OPTS} ${ZSTD_DOWNLOAD_BASE}/v$(ZSTD_VER).tar.gz
+	curl -O -L ${ZSTD_DOWNLOAD_BASE}/v$(ZSTD_VER).tar.gz
 	mv v$(ZSTD_VER).tar.gz zstd-$(ZSTD_VER).tar.gz
 	ZSTD_SHA256_ACTUAL=`$(SHA256_CMD) zstd-$(ZSTD_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(ZSTD_SHA256)" != "$$ZSTD_SHA256_ACTUAL" ]; then \
@@ -26,7 +26,3 @@ rely on the details of any other header files in this package.  Those
 internal APIs may be changed without warning.

 Design discussions are conducted in https://www.facebook.com/groups/rocksdb.dev/
-
-## License
-
-RocksDB is dual-licensed under both the GPLv2 (found in the COPYING file in the root directory) and Apache 2.0 License (found in the LICENSE.Apache file in the root directory).  You may select, at your option, one of the above-listed licenses.
@@ -5,7 +5,7 @@ RocksDBLite is a project focused on mobile use cases, which don't need a lot of
 Some examples of the features disabled by ROCKSDB_LITE:
 * compiled-in support for LDB tool
 * No backupable DB
-* No support for replication (which we provide in form of TransactionalIterator)
+* No support for replication (which we provide in form of TrasactionalIterator)
 * No advanced monitoring tools
 * No special-purpose memtables that are highly optimized for specific use cases
 * No Transactions
@@ -46,10 +46,7 @@ rocksdb_preprocessor_flags = [
 ]

 rocksdb_arch_preprocessor_flags = {
-    "x86_64": [
-        "-DHAVE_SSE42",
-        "-DHAVE_PCLMUL",
-    ],
+    "x86_64": ["-DHAVE_SSE42"],
 }

 build_mode = read_config("fbcode", "build_mode")
@@ -215,13 +212,11 @@ cpp_library(
        "util/status_message.cc",
        "util/string_util.cc",
        "util/sync_point.cc",
-        "util/sync_point_impl.cc",
        "util/thread_local.cc",
        "util/threadpool_imp.cc",
        "util/transaction_test_util.cc",
        "util/xxhash.cc",
        "utilities/backupable/backupable_db.cc",
-        "utilities/blob_db/blob_compaction_filter.cc",
        "utilities/blob_db/blob_db.cc",
        "utilities/blob_db/blob_db_impl.cc",
        "utilities/blob_db/blob_dump_tool.cc",
@@ -247,7 +242,6 @@ cpp_library(
        "utilities/leveldb_options/leveldb_options.cc",
        "utilities/lua/rocks_lua_compaction_filter.cc",
        "utilities/memory/memory_util.cc",
-        "utilities/merge_operators/bytesxor.cc",
        "utilities/merge_operators/max.cc",
        "utilities/merge_operators/put.cc",
        "utilities/merge_operators/string_append/stringappend.cc",
@@ -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"
@@ -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
@@ -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
@@ -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"
@@ -50,10 +50,7 @@ rocksdb_preprocessor_flags = [
 ]

 rocksdb_arch_preprocessor_flags = {
-    "x86_64": [
-        "-DHAVE_SSE42",
-        "-DHAVE_PCLMUL",
-    ],
+    "x86_64": ["-DHAVE_SSE42"],
 }

 build_mode = read_config("fbcode", "build_mode")
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/sh
 #
 # Detects OS we're compiling on and outputs a file specified by the first
 # argument, which in turn gets read while processing Makefile.
@@ -16,8 +16,6 @@
 #   PLATFORM_CXXFLAGS           C++ compiler flags.  Will contain:
 #   PLATFORM_SHARED_VERSIONED   Set to 'true' if platform supports versioned
 #                               shared libraries, empty otherwise.
-#   FIND			Command for the find utility
-#   WATCH			Command for the watch utility
 #
 # The PLATFORM_CCFLAGS and PLATFORM_CXXFLAGS might include the following:
 #
@@ -66,19 +64,11 @@ rm -f "$OUTPUT"
 touch "$OUTPUT"

 if test -z "$CC"; then
-    if [ -x "$(command -v clang)" ]; then
-        CC=clang
-    else
-        CC=cc
-    fi
+   CC=cc
 fi

 if test -z "$CXX"; then
-    if [ -x "$(command -v clang++)" ]; then
-        CXX=clang++
-    else
-        CXX=g++
-    fi
+    CXX=g++
 fi

 # Detect OS
@@ -95,15 +85,7 @@ if test -z "$CLANG_SCAN_BUILD"; then
 fi

 if test -z "$CLANG_ANALYZER"; then
-    CLANG_ANALYZER=$(command -v clang++ 2> /dev/null)
-fi
-
-if test -z "$FIND"; then
-    FIND=find
-fi
-
-if test -z "$WATCH"; then
-    WATCH=watch
+    CLANG_ANALYZER=$(which clang++ 2> /dev/null)
 fi

 COMMON_FLAGS="$COMMON_FLAGS ${CFLAGS}"
@@ -172,12 +154,9 @@ case "$TARGET_OS" in
        ;;
    OpenBSD)
        PLATFORM=OS_OPENBSD
-	CXX=clang++
        COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_OPENBSD"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread"
        # PORT_FILES=port/openbsd/openbsd_specific.cc
-	FIND=gfind
-	WATCH=gnuwatch
        ;;
    DragonFly)
        PLATFORM=OS_DRAGONFLYBSD
@@ -506,9 +485,7 @@ if test -z "$PORTABLE"; then
  elif test -n "`echo $TARGET_ARCHITECTURE | grep ^arm`"; then
    # TODO: Handle this with approprite options.
    COMMON_FLAGS="$COMMON_FLAGS"
-  elif [ "$TARGET_OS" == "IOS" ]; then
-    COMMON_FLAGS="$COMMON_FLAGS"
-  elif [ "$TARGET_OS" != "AIX" ] && [ "$TARGET_OS" != "SunOS" ]; then
+  elif [ "$TARGET_OS" != AIX ] && [ "$TARGET_OS" != SunOS ]; then
    COMMON_FLAGS="$COMMON_FLAGS -march=native "
  elif test "$USE_SSE"; then
    COMMON_FLAGS="$COMMON_FLAGS -msse4.2 -mpclmul"
@@ -596,8 +573,6 @@ echo "ROCKSDB_PATCH=$ROCKSDB_PATCH" >> "$OUTPUT"
 echo "CLANG_SCAN_BUILD=$CLANG_SCAN_BUILD" >> "$OUTPUT"
 echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT"
 echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
-echo "FIND=$FIND" >> "$OUTPUT"
-echo "WATCH=$WATCH" >> "$OUTPUT"
 # This will enable some related identifiers for the preprocessor
 if test -n "$JEMALLOC"; then
  echo "JEMALLOC=1" >> "$OUTPUT"
@@ -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."
 }

@@ -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
@@ -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
@@ -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 $@
@@ -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
    ;;
@@ -336,7 +336,7 @@ $InvokeTestAsync = {
 # Test limiting factor here
 [int]$count = 0
 # Overall status
-[bool]$script:success = $true;
+[bool]$success = $true;

 function RunJobs($Suites, $TestCmds, [int]$ConcurrencyVal)
 {
@@ -425,7 +425,7 @@ function RunJobs($Suites, $TestCmds, [int]$ConcurrencyVal)
        $log_content = @(Get-Content $log)

        if($completed.State -ne "Completed") {
-            $script:success = $false
+            $success = $false
            Write-Warning $message
            $log_content | Write-Warning
        } else {
@@ -449,7 +449,7 @@ function RunJobs($Suites, $TestCmds, [int]$ConcurrencyVal)
            }

            if(!$pass_found) {
-                $script:success = $false;
+                $success = $false;
                Write-Warning $message
                $log_content | Write-Warning
            } else {
@@ -473,7 +473,7 @@ New-TimeSpan -Start $StartDate -End $EndDate |
  }


-if(!$script:success) {
+if(!$success) {
 # This does not succeed killing off jobs quick
 # So we simply exit
 #    Remove-Job -Job $jobs -Force
@@ -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
@@ -1,4 +1,4 @@
-#/usr/bin/env bash
+#!/bin/sh
 if [ "$#" = "0" ]; then
  echo "Usage: $0 major|minor|patch|full"
  exit 1
@@ -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
@@ -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()];
@@ -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
@@ -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);
 }
@@ -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
@@ -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,
@@ -32,13 +32,11 @@
 #include "rocksdb/universal_compaction.h"
 #include "rocksdb/utilities/backupable_db.h"
 #include "rocksdb/utilities/checkpoint.h"
-#include "rocksdb/utilities/db_ttl.h"
 #include "rocksdb/utilities/optimistic_transaction_db.h"
 #include "rocksdb/utilities/transaction.h"
 #include "rocksdb/utilities/transaction_db.h"
 #include "rocksdb/utilities/write_batch_with_index.h"
 #include "rocksdb/write_batch.h"
-#include "rocksdb/perf_context.h"
 #include "utilities/merge_operators.h"

 using rocksdb::BytewiseComparator;
@@ -102,8 +100,6 @@ using rocksdb::OptimisticTransactionDB;
 using rocksdb::OptimisticTransactionOptions;
 using rocksdb::Transaction;
 using rocksdb::Checkpoint;
-using rocksdb::PerfLevel;
-using rocksdb::PerfContext;

 using std::shared_ptr;

@@ -144,7 +140,6 @@ struct rocksdb_envoptions_t      { EnvOptions        rep; };
 struct rocksdb_ingestexternalfileoptions_t  { IngestExternalFileOptions rep; };
 struct rocksdb_sstfilewriter_t   { SstFileWriter*    rep; };
 struct rocksdb_ratelimiter_t     { RateLimiter*      rep; };
-struct rocksdb_perfcontext_t     { PerfContext*      rep; };
 struct rocksdb_pinnableslice_t {
  PinnableSlice rep;
 };
@@ -257,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 {
@@ -372,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);
@@ -482,20 +477,6 @@ rocksdb_t* rocksdb_open(
  return result;
 }

-rocksdb_t* rocksdb_open_with_ttl(
-    const rocksdb_options_t* options,
-    const char* name,
-    int ttl,
-    char** errptr) {
-  rocksdb::DBWithTTL* db;
-  if (SaveError(errptr, rocksdb::DBWithTTL::Open(options->rep, std::string(name), &db, ttl))) {
-    return nullptr;
-  }
-  rocksdb_t* result = new rocksdb_t;
-  result->rep = db;
-  return result;
-}
-
 rocksdb_t* rocksdb_open_for_read_only(
    const rocksdb_options_t* options,
    const char* name,
@@ -2185,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);
@@ -2250,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) {
@@ -2421,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
 }

@@ -2556,176 +2537,6 @@ void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t *limiter) {
  delete limiter;
 }

-void rocksdb_set_perf_level(int v) {
-  PerfLevel level = static_cast<PerfLevel>(v);
-  SetPerfLevel(level);
-}
-
-rocksdb_perfcontext_t* rocksdb_perfcontext_create() {
-  rocksdb_perfcontext_t* context = new rocksdb_perfcontext_t;
-  context->rep = rocksdb::get_perf_context();
-  return context;
-}
-
-void rocksdb_perfcontext_reset(rocksdb_perfcontext_t* context) {
-  context->rep->Reset();
-}
-
-char* rocksdb_perfcontext_report(rocksdb_perfcontext_t* context,
-    unsigned char exclude_zero_counters) {
-  return strdup(context->rep->ToString(exclude_zero_counters).c_str());
-}
-
-uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context,
-    int metric) {
-  PerfContext* rep = context->rep;
-  switch (metric) {
-    case rocksdb_user_key_comparison_count:
-      return rep->user_key_comparison_count;
-    case rocksdb_block_cache_hit_count:
-      return rep->block_cache_hit_count;
-    case rocksdb_block_read_count:
-      return rep->block_read_count;
-    case rocksdb_block_read_byte:
-      return rep->block_read_byte;
-    case rocksdb_block_read_time:
-      return rep->block_read_time;
-    case rocksdb_block_checksum_time:
-      return rep->block_checksum_time;
-    case rocksdb_block_decompress_time:
-      return rep->block_decompress_time;
-    case rocksdb_get_read_bytes:
-      return rep->get_read_bytes;
-    case rocksdb_multiget_read_bytes:
-      return rep->multiget_read_bytes;
-    case rocksdb_iter_read_bytes:
-      return rep->iter_read_bytes;
-    case rocksdb_internal_key_skipped_count:
-      return rep->internal_key_skipped_count;
-    case rocksdb_internal_delete_skipped_count:
-      return rep->internal_delete_skipped_count;
-    case rocksdb_internal_recent_skipped_count:
-      return rep->internal_recent_skipped_count;
-    case rocksdb_internal_merge_count:
-      return rep->internal_merge_count;
-    case rocksdb_get_snapshot_time:
-      return rep->get_snapshot_time;
-    case rocksdb_get_from_memtable_time:
-      return rep->get_from_memtable_time;
-    case rocksdb_get_from_memtable_count:
-      return rep->get_from_memtable_count;
-    case rocksdb_get_post_process_time:
-      return rep->get_post_process_time;
-    case rocksdb_get_from_output_files_time:
-      return rep->get_from_output_files_time;
-    case rocksdb_seek_on_memtable_time:
-      return rep->seek_on_memtable_time;
-    case rocksdb_seek_on_memtable_count:
-      return rep->seek_on_memtable_count;
-    case rocksdb_next_on_memtable_count:
-      return rep->next_on_memtable_count;
-    case rocksdb_prev_on_memtable_count:
-      return rep->prev_on_memtable_count;
-    case rocksdb_seek_child_seek_time:
-      return rep->seek_child_seek_time;
-    case rocksdb_seek_child_seek_count:
-      return rep->seek_child_seek_count;
-    case rocksdb_seek_min_heap_time:
-      return rep->seek_min_heap_time;
-    case rocksdb_seek_max_heap_time:
-      return rep->seek_max_heap_time;
-    case rocksdb_seek_internal_seek_time:
-      return rep->seek_internal_seek_time;
-    case rocksdb_find_next_user_entry_time:
-      return rep->find_next_user_entry_time;
-    case rocksdb_write_wal_time:
-      return rep->write_wal_time;
-    case rocksdb_write_memtable_time:
-      return rep->write_memtable_time;
-    case rocksdb_write_delay_time:
-      return rep->write_delay_time;
-    case rocksdb_write_pre_and_post_process_time:
-      return rep->write_pre_and_post_process_time;
-    case rocksdb_db_mutex_lock_nanos:
-      return rep->db_mutex_lock_nanos;
-    case rocksdb_db_condition_wait_nanos:
-      return rep->db_condition_wait_nanos;
-    case rocksdb_merge_operator_time_nanos:
-      return rep->merge_operator_time_nanos;
-    case rocksdb_read_index_block_nanos:
-      return rep->read_index_block_nanos;
-    case rocksdb_read_filter_block_nanos:
-      return rep->read_filter_block_nanos;
-    case rocksdb_new_table_block_iter_nanos:
-      return rep->new_table_block_iter_nanos;
-    case rocksdb_new_table_iterator_nanos:
-      return rep->new_table_iterator_nanos;
-    case rocksdb_block_seek_nanos:
-      return rep->block_seek_nanos;
-    case rocksdb_find_table_nanos:
-      return rep->find_table_nanos;
-    case rocksdb_bloom_memtable_hit_count:
-      return rep->bloom_memtable_hit_count;
-    case rocksdb_bloom_memtable_miss_count:
-      return rep->bloom_memtable_miss_count;
-    case rocksdb_bloom_sst_hit_count:
-      return rep->bloom_sst_hit_count;
-    case rocksdb_bloom_sst_miss_count:
-      return rep->bloom_sst_miss_count;
-    case rocksdb_key_lock_wait_time:
-      return rep->key_lock_wait_time;
-    case rocksdb_key_lock_wait_count:
-      return rep->key_lock_wait_count;
-    case rocksdb_env_new_sequential_file_nanos:
-      return rep->env_new_sequential_file_nanos;
-    case rocksdb_env_new_random_access_file_nanos:
-      return rep->env_new_random_access_file_nanos;
-    case rocksdb_env_new_writable_file_nanos:
-      return rep->env_new_writable_file_nanos;
-    case rocksdb_env_reuse_writable_file_nanos:
-      return rep->env_reuse_writable_file_nanos;
-    case rocksdb_env_new_random_rw_file_nanos:
-      return rep->env_new_random_rw_file_nanos;
-    case rocksdb_env_new_directory_nanos:
-      return rep->env_new_directory_nanos;
-    case rocksdb_env_file_exists_nanos:
-      return rep->env_file_exists_nanos;
-    case rocksdb_env_get_children_nanos:
-      return rep->env_get_children_nanos;
-    case rocksdb_env_get_children_file_attributes_nanos:
-      return rep->env_get_children_file_attributes_nanos;
-    case rocksdb_env_delete_file_nanos:
-      return rep->env_delete_file_nanos;
-    case rocksdb_env_create_dir_nanos:
-      return rep->env_create_dir_nanos;
-    case rocksdb_env_create_dir_if_missing_nanos:
-      return rep->env_create_dir_if_missing_nanos;
-    case rocksdb_env_delete_dir_nanos:
-      return rep->env_delete_dir_nanos;
-    case rocksdb_env_get_file_size_nanos:
-      return rep->env_get_file_size_nanos;
-    case rocksdb_env_get_file_modification_time_nanos:
-      return rep->env_get_file_modification_time_nanos;
-    case rocksdb_env_rename_file_nanos:
-      return rep->env_rename_file_nanos;
-    case rocksdb_env_link_file_nanos:
-      return rep->env_link_file_nanos;
-    case rocksdb_env_lock_file_nanos:
-      return rep->env_lock_file_nanos;
-    case rocksdb_env_unlock_file_nanos:
-      return rep->env_unlock_file_nanos;
-    case rocksdb_env_new_logger_nanos:
-      return rep->env_new_logger_nanos;
-    default:
-      break;
-  }
-  return 0;
-}
-
-void rocksdb_perfcontext_destroy(rocksdb_perfcontext_t* context) {
-  delete context;
-}
-
 /*
 TODO:
 DB::OpenForReadOnly
@@ -3162,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;
@@ -3200,7 +3011,7 @@ void rocksdb_sstfilewriter_delete(rocksdb_sstfilewriter_t* writer,

 void rocksdb_sstfilewriter_finish(rocksdb_sstfilewriter_t* writer,
                                  char** errptr) {
-  SaveError(errptr, writer->rep->Finish(nullptr));
+  SaveError(errptr, writer->rep->Finish(NULL));
 }

 void rocksdb_sstfilewriter_destroy(rocksdb_sstfilewriter_t* writer) {
@@ -3982,7 +3793,7 @@ rocksdb_pinnableslice_t* rocksdb_get_pinned(
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
-    return nullptr;
+    return NULL;
  }
  return v;
 }
@@ -3999,7 +3810,7 @@ rocksdb_pinnableslice_t* rocksdb_get_pinned_cf(
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
-    return nullptr;
+    return NULL;
  }
  return v;
 }
@@ -4010,7 +3821,7 @@ const char* rocksdb_pinnableslice_value(const rocksdb_pinnableslice_t* v,
                                        size_t* vlen) {
  if (!v) {
    *vlen = 0;
-    return nullptr;
+    return NULL;
  }

  *vlen = v->rep.size();
@@ -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"

@@ -54,9 +53,6 @@ ColumnFamilyHandleImpl::~ColumnFamilyHandleImpl() {
 #endif  // ROCKSDB_LITE
    // Job id == 0 means that this is not our background process, but rather
    // user thread
-    // Need to hold some shared pointers owned by the initial_cf_options
-    // before final cleaning up finishes.
-    ColumnFamilyOptions initial_cf_options_copy = cfd_->initial_cf_options();
    JobContext job_context(0);
    mutex_->Lock();
    if (cfd_->Unref()) {
@@ -348,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

@@ -386,7 +381,6 @@ ColumnFamilyData::ColumnFamilyData(
      next_(nullptr),
      prev_(nullptr),
      log_number_(0),
-      flush_reason_(FlushReason::kOthers),
      column_family_set_(column_family_set),
      pending_flush_(false),
      pending_compaction_(false),
@@ -475,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();
@@ -486,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);
  }
@@ -637,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;
@@ -681,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);
@@ -711,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 "
@@ -736,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;
@@ -747,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);
@@ -756,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.
@@ -775,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 "
@@ -782,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,
@@ -849,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,
@@ -889,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;

@@ -969,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()
@@ -983,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
@@ -1001,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);
@@ -1065,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);
@@ -1086,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() {
@@ -1097,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;
+    }
  }
 }

@@ -1164,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_;
 }
@@ -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
@@ -370,10 +343,6 @@ class ColumnFamilyData {

  bool initialized() const { return initialized_.load(); }

-  const ColumnFamilyOptions& initial_cf_options() {
-    return initial_cf_options_;
-  }
-
  Env::WriteLifeTimeHint CalculateSSTWriteHint(int level);

 private:
@@ -435,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_;
@@ -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;
@@ -2791,18 +2790,6 @@ TEST_F(ColumnFamilyTest, CompactionSpeedupTwoColumnFamilies) {
  ASSERT_EQ(1, dbfull()->TEST_BGCompactionsAllowed());
 }

-TEST_F(ColumnFamilyTest, CreateAndDestoryOptions) {
-  std::unique_ptr<ColumnFamilyOptions> cfo(new ColumnFamilyOptions());
-  ColumnFamilyHandle* cfh;
-  Open();
-  ASSERT_OK(db_->CreateColumnFamily(*(cfo.get()), "yoyo", &cfh));
-  cfo.reset();
-  ASSERT_OK(db_->Put(WriteOptions(), cfh, "foo", "bar"));
-  ASSERT_OK(db_->Flush(FlushOptions(), cfh));
-  ASSERT_OK(db_->DropColumnFamily(cfh));
-  ASSERT_OK(db_->DestroyColumnFamilyHandle(cfh));
-}
-
 #ifndef ROCKSDB_LITE
 TEST_F(ColumnFamilyTest, FlushCloseWALFiles) {
  SpecialEnv env(Env::Default());
@@ -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;
      }
@@ -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.");
  }

@@ -446,8 +446,7 @@ bool Compaction::ShouldFormSubcompactions() const {
    return false;
  }
  if (cfd_->ioptions()->compaction_style == kCompactionStyleLevel) {
-    return (start_level_ == 0 || is_manual_compaction_) && output_level_ > 0 &&
-           !IsOutputLevelEmpty();
+    return start_level_ == 0 && output_level_ > 0 && !IsOutputLevelEmpty();
  } else if (cfd_->ioptions()->compaction_style == kCompactionStyleUniversal) {
    return number_levels_ > 1 && output_level_ > 0;
  } else {
@@ -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),
@@ -167,13 +199,10 @@ void CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
    CompactionFilter::ValueType value_type =
        ikey_.type == kTypeValue ? CompactionFilter::ValueType::kValue
                                 : CompactionFilter::ValueType::kBlobIndex;
-    // Hack: pass internal key to BlobIndexCompactionFilter since it needs
-    // to get sequence number.
-    Slice& filter_key = ikey_.type == kTypeValue ? ikey_.user_key : key_;
    {
      StopWatchNano timer(env_, true);
      filter = compaction_filter_->FilterV2(
-          compaction_->level(), filter_key, value_type, value_,
+          compaction_->level(), ikey_.user_key, value_type, value_,
          &compaction_filter_value_, compaction_filter_skip_until_.rep());
      iter_stats_.total_filter_time +=
          env_ != nullptr ? timer.ElapsedNanos() : 0;
@@ -264,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
@@ -492,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;
@@ -514,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();
@@ -577,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() &&
@@ -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_;
@@ -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) {
@@ -723,16 +723,14 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  std::set<size_t> sample_begin_offsets;
  if (bottommost_level_ && kSampleBytes > 0) {
    const size_t kMaxSamples = kSampleBytes >> kSampleLenShift;
-    const size_t kOutFileLen = static_cast<size_t>(
-      mutable_cf_options->MaxFileSizeForLevel(
-        compact_->compaction->output_level()));
+    const size_t kOutFileLen = mutable_cf_options->MaxFileSizeForLevel(
+        compact_->compaction->output_level());
    if (kOutFileLen != port::kMaxSizet) {
      const size_t kOutFileNumSamples = kOutFileLen >> kSampleLenShift;
      Random64 generator{versions_->NewFileNumber()};
      for (size_t i = 0; i < kMaxSamples; ++i) {
-        sample_begin_offsets.insert(
-          static_cast<size_t>(generator.Uniform(kOutFileNumSamples))
-            << kSampleLenShift);
+        sample_begin_offsets.insert(generator.Uniform(kOutFileNumSamples)
+                                    << kSampleLenShift);
      }
    }
  }
@@ -749,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");

@@ -764,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() &&
@@ -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);
@@ -41,7 +41,7 @@ bool FindIntraL0Compaction(const std::vector<FileMetaData*>& level_files,
                           size_t min_files_to_compact,
                           uint64_t max_compact_bytes_per_del_file,
                           CompactionInputFiles* comp_inputs) {
-  size_t compact_bytes = static_cast<size_t>(level_files[0]->fd.file_size);
+  size_t compact_bytes = level_files[0]->fd.file_size;
  size_t compact_bytes_per_del_file = port::kMaxSizet;
  // compaction range will be [0, span_len).
  size_t span_len;
@@ -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;
@@ -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;
  }
 };
@@ -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;
 };

@@ -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,
@@ -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

@@ -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,
@@ -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) {
@@ -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();
@@ -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,16 +100,14 @@ 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());
    if (i / 10 % 2 == 0) {
      char key_str[100];
-      snprintf(key_str, sizeof(key_str), "%010d", i / 10 * 10 + 10);
+      snprintf(key_str, sizeof(key), "%010d", i / 10 * 10 + 10);
      *skip_until = key_str;
      ++cfilter_skips;
      return Decision::kRemoveAndSkipUntil;
@@ -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());
  }

@@ -767,7 +765,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilterIgnoreSnapshot) {
      iter->Next();
    }
    ASSERT_EQ(count, 6);
-    read_options.snapshot = nullptr;
+    read_options.snapshot = 0;
    std::unique_ptr<Iterator> iter1(db_->NewIterator(read_options));
    iter1->SeekToFirst();
    count = 0;
@@ -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
@@ -2751,7 +2635,6 @@ TEST_P(DBCompactionTestWithParam, ForceBottommostLevelCompaction) {
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
-  options.target_file_size_base = 100000000;
  options.write_buffer_size = 100000000;
  options.max_subcompactions = max_subcompactions_;
  DestroyAndReopen(options);
@@ -3106,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),
@@ -74,7 +74,7 @@ Status DBImpl::EnableFileDeletions(bool force) {
 }

 int DBImpl::IsFileDeletionsEnabled() const {
-  return !disable_delete_obsolete_files_;
+  return disable_delete_obsolete_files_;
 }

 Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
@@ -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();
@@ -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());

@@ -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,23 +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) {
@@ -556,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();
@@ -673,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;
@@ -896,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()) {
@@ -1442,7 +1419,6 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
      }
      is_snapshot_supported_ = new_is_snapshot_supported;
    }
-    bg_cv_.SignalAll();
  }

  if (s.ok()) {
@@ -2145,9 +2121,9 @@ Status DBImpl::DeleteFile(std::string name) {
    status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                    &edit, &mutex_, directories_.GetDbDir());
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd, &job_context.superversion_context,
-                                         *cfd->GetLatestMutableCFOptions(),
-                                         FlushReason::kDeleteFiles);
+      InstallSuperVersionAndScheduleWork(
+          cfd, &job_context.superversion_context,
+          *cfd->GetLatestMutableCFOptions());
    }
    FindObsoleteFiles(&job_context, false);
  }  // lock released here
@@ -2162,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()) {
@@ -2229,9 +2194,9 @@ Status DBImpl::DeleteFilesInRanges(ColumnFamilyHandle* column_family,
    status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                    &edit, &mutex_, directories_.GetDbDir());
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd, &job_context.superversion_context,
-                                         *cfd->GetLatestMutableCFOptions(),
-                                         FlushReason::kDeleteFiles);
+      InstallSuperVersionAndScheduleWork(
+          cfd, &job_context.superversion_context,
+          *cfd->GetLatestMutableCFOptions());
    }
    for (auto* deleted_file : deleted_files) {
      deleted_file->being_compacted = false;
@@ -2334,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("");
 }

@@ -2387,13 +2352,10 @@ Snapshot::~Snapshot() {
 }

 Status DestroyDB(const std::string& dbname, const Options& options) {
-  ImmutableDBOptions soptions(SanitizeOptions(dbname, options));
+  const ImmutableDBOptions soptions(SanitizeOptions(dbname, options));
  Env* env = soptions.env;
  std::vector<std::string> filenames;

-  // Reset the logger because it holds a handle to the
-  // log file and prevents cleanup and directory removal
-  soptions.info_log.reset();
  // Ignore error in case directory does not exist
  env->GetChildren(dbname, &filenames);

@@ -2834,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();
      }
    }
@@ -2859,8 +2819,8 @@ Status DBImpl::IngestExternalFile(
                                 &mutex_, directories_.GetDbDir());
    }
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd, &sv_context, *mutable_cf_options,
-                                         FlushReason::kExternalFileIngestion);
+      InstallSuperVersionAndScheduleWork(cfd, &sv_context,
+                                         *mutable_cf_options);
    }

    // Resume writes to the DB
@@ -14,6 +14,7 @@
 #include <limits>
 #include <list>
 #include <map>
+#include <queue>
 #include <set>
 #include <string>
 #include <utility>
@@ -185,9 +186,7 @@ class DBImpl : public DB {
                              ColumnFamilyHandle* column_family,
                              const std::vector<std::string>& input_file_names,
                              const int output_level,
-                              const int output_path_id = -1,
-                              std::vector<std::string>* const output_file_names
-                              = nullptr) override;
+                              const int output_path_id = -1) override;

  virtual Status PauseBackgroundWork() override;
  virtual Status ContinueBackgroundWork() override;
@@ -223,8 +222,6 @@ class DBImpl : public DB {
  virtual Status SyncWAL() override;

  virtual SequenceNumber GetLatestSequenceNumber() const override;
-  // REQUIRES: joined the main write queue if two_write_queues is disabled, and
-  // the second write queue otherwise.
  virtual void SetLastPublishedSequence(SequenceNumber seq);
  // Returns LastSequence in last_seq_same_as_publish_seq_
  // mode and LastAllocatedSequence otherwise. This is useful when visiblility
@@ -250,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;
@@ -382,9 +378,7 @@ class DBImpl : public DB {
  Status TEST_WaitForFlushMemTable(ColumnFamilyHandle* column_family = nullptr);

  // Wait for any compaction
-  // We add a bool parameter to wait for unscheduledCompactions_ == 0, but this
-  // is only for the special test of CancelledCompactions
-  Status TEST_WaitForCompact(bool waitUnscheduled = false);
+  Status TEST_WaitForCompact();

  // Return the maximum overlapping data (in bytes) at next level for any
  // file at a level >= 1.
@@ -438,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;
@@ -473,7 +465,7 @@ class DBImpl : public DB {
                         bool no_full_scan = false);

  // Diffs the files listed in filenames and those that do not
-  // belong to live files are possibly removed. Also, removes all the
+  // belong to live files are posibly removed. Also, removes all the
  // files in sst_delete_files and log_delete_files.
  // It is not necessary to hold the mutex when invoking this method.
  // If FindObsoleteFiles() was run, we need to also run
@@ -556,18 +548,9 @@ class DBImpl : public DB {
    WriteBatch* batch_;
    // The seq number of the first key in the batch
    SequenceNumber seq_;
-    // Number of sub-batched. A new sub-batch is created if we txn attempts to
-    // inserts a duplicate key,seq to memtable. This is currently used in
-    // WritePrparedTxn
-    size_t batch_cnt_;
    explicit RecoveredTransaction(const uint64_t log, const std::string& name,
-                                  WriteBatch* batch, SequenceNumber seq,
-                                  size_t batch_cnt)
-        : log_number_(log),
-          name_(name),
-          batch_(batch),
-          seq_(seq),
-          batch_cnt_(batch_cnt) {}
+                                  WriteBatch* batch, SequenceNumber seq)
+        : log_number_(log), name_(name), batch_(batch), seq_(seq) {}

    ~RecoveredTransaction() { delete batch_; }
  };
@@ -589,10 +572,9 @@ class DBImpl : public DB {
  }

  void InsertRecoveredTransaction(const uint64_t log, const std::string& name,
-                                  WriteBatch* batch, SequenceNumber seq,
-                                  size_t batch_cnt) {
+                                  WriteBatch* batch, SequenceNumber seq) {
    recovered_transactions_[name] =
-        new RecoveredTransaction(log, name, batch, seq, batch_cnt);
+        new RecoveredTransaction(log, name, batch, seq);
    MarkLogAsContainingPrepSection(log);
  }

@@ -690,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,
@@ -706,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();
@@ -721,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;
@@ -835,12 +807,11 @@ class DBImpl : public DB {

  Status ScheduleFlushes(WriteContext* context);

-  Status SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
-                        FlushReason flush_reason = FlushReason::kOthers);
+  Status SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context);

  // 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
@@ -876,7 +847,7 @@ class DBImpl : public DB {
                              size_t seq_inc);

  // Used by WriteImpl to update bg_error_ if paranoid check is enabled.
-  void WriteStatusCheck(const Status& status);
+  void WriteCallbackStatusCheck(const Status& status);

  // Used by WriteImpl to update bg_error_ in case of memtable insert error.
  void MemTableInsertStatusCheck(const Status& memtable_insert_status);
@@ -886,7 +857,6 @@ class DBImpl : public DB {
  Status CompactFilesImpl(const CompactionOptions& compact_options,
                          ColumnFamilyData* cfd, Version* version,
                          const std::vector<std::string>& input_file_names,
-                          std::vector<std::string>* const output_file_names,
                          const int output_level, int output_path_id,
                          JobContext* job_context, LogBuffer* log_buffer);

@@ -903,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);
@@ -942,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
@@ -952,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_;
@@ -984,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,
@@ -1023,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;
@@ -1317,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
@@ -1362,8 +1323,7 @@ class DBImpl : public DB {
  // state needs flush or compaction.
  void InstallSuperVersionAndScheduleWork(
      ColumnFamilyData* cfd, SuperVersionContext* sv_context,
-      const MutableCFOptions& mutable_cf_options,
-      FlushReason flush_reason = FlushReason::kOthers);
+      const MutableCFOptions& mutable_cf_options);

 #ifndef ROCKSDB_LITE
  using DB::GetPropertiesOfAllTables;
@@ -1393,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
@@ -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;
@@ -461,8 +394,7 @@ Status DBImpl::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,
-    std::vector<std::string>* const output_file_names) {
+    const int output_level, const int output_path_id) {
 #ifdef ROCKSDB_LITE
    // not supported in lite version
  return Status::NotSupported("Not supported in ROCKSDB LITE");
@@ -489,7 +421,7 @@ Status DBImpl::CompactFiles(
    WaitForIngestFile();

    s = CompactFilesImpl(compact_options, cfd, sv->current,
-                         input_file_names, output_file_names, output_level,
+                         input_file_names, output_level,
                         output_path_id, &job_context, &log_buffer);
  }
  if (sv->Unref()) {
@@ -533,7 +465,6 @@ Status DBImpl::CompactFiles(
 Status DBImpl::CompactFilesImpl(
    const CompactionOptions& compact_options, ColumnFamilyData* cfd,
    Version* version, const std::vector<std::string>& input_file_names,
-    std::vector<std::string>* const output_file_names,
    const int output_level, int output_path_id, JobContext* job_context,
    LogBuffer* log_buffer) {
  mutex_.AssertHeld();
@@ -655,7 +586,7 @@ Status DBImpl::CompactFilesImpl(
  if (status.ok()) {
    InstallSuperVersionAndScheduleWork(
        c->column_family_data(), &job_context->superversion_context,
-        *c->mutable_cf_options(), FlushReason::kManualCompaction);
+       *c->mutable_cf_options());
  }
  c->ReleaseCompactionFiles(s);

@@ -682,14 +613,6 @@ Status DBImpl::CompactFilesImpl(
    }
  }

-  if (output_file_names != nullptr) {
-    for (const auto newf : c->edit()->GetNewFiles()) {
-      (*output_file_names).push_back(TableFileName(
-              immutable_db_options_.db_paths, newf.second.fd.GetNumber(),
-              newf.second.fd.GetPathId()) );
-    }
-  }
-
  c.reset();

  bg_compaction_scheduled_--;
@@ -874,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;
 }

@@ -890,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::kManualFlush);
+  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());
@@ -1028,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;
  {
@@ -1057,7 +979,7 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
    cfd->imm()->FlushRequested();

    // schedule flush
-    SchedulePendingFlush(cfd, flush_reason);
+    SchedulePendingFlush(cfd);
    MaybeScheduleFlushOrCompaction();
  }

@@ -1213,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() {
@@ -1227,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_;
  }
 }
@@ -1513,7 +1432,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
    if (made_progress ||
        (bg_compaction_scheduled_ == 0 &&
         bg_bottom_compaction_scheduled_ == 0) ||
-        HasPendingManualCompaction() || unscheduled_compactions_ == 0) {
+        HasPendingManualCompaction()) {
      // signal if
      // * made_progress -- need to wakeup DelayWrite
      // * bg_{bottom,}_compaction_scheduled_ == 0 -- need to wakeup ~DBImpl
@@ -1576,9 +1495,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,

  // InternalKey manual_end_storage;
  // InternalKey* manual_end = &manual_end_storage;
-#ifndef ROCKSDB_LITE
-  bool sfm_bookkeeping = false;
-#endif  // ROCKSDB_LITE
  if (is_manual) {
    ManualCompactionState* m = manual_compaction;
    assert(m->in_progress);
@@ -1641,66 +1557,27 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
      TEST_SYNC_POINT("DBImpl::BackgroundCompaction():BeforePickCompaction");
      c.reset(cfd->PickCompaction(*mutable_cf_options, log_buffer));
      TEST_SYNC_POINT("DBImpl::BackgroundCompaction():AfterPickCompaction");
-
-      bool enough_room = true;
      if (c != nullptr) {
-#ifndef ROCKSDB_LITE
-        auto sfm = static_cast<SstFileManagerImpl*>(
-            immutable_db_options_.sst_file_manager.get());
-        if (sfm) {
-          enough_room = sfm->EnoughRoomForCompaction(c.get());
-          if (enough_room) {
-            sfm_bookkeeping = true;
-          }
-        }
-#endif  // ROCKSDB_LITE
-        if (!enough_room) {
-          // Just in case tests want to change the value of enough_room
-          TEST_SYNC_POINT_CALLBACK(
-              "DBImpl::BackgroundCompaction():CancelledCompaction",
-              &enough_room);
-        }
-        if (!enough_room) {
-          // Then don't do the compaction
-          c->ReleaseCompactionFiles(status);
-          c->column_family_data()
-              ->current()
-              ->storage_info()
-              ->ComputeCompactionScore(*(c->immutable_cf_options()),
-                                       *(c->mutable_cf_options()));
-
-          ROCKS_LOG_BUFFER(log_buffer,
-                           "Cancelled compaction because not enough room");
+        // update statistics
+        MeasureTime(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
+                    c->inputs(0)->size());
+        // There are three things that can change compaction score:
+        // 1) When flush or compaction finish. This case is covered by
+        // InstallSuperVersionAndScheduleWork
+        // 2) When MutableCFOptions changes. This case is also covered by
+        // InstallSuperVersionAndScheduleWork, because this is when the new
+        // options take effect.
+        // 3) When we Pick a new compaction, we "remove" those files being
+        // compacted from the calculation, which then influences compaction
+        // score. Here we check if we need the new compaction even without the
+        // files that are currently being compacted. If we need another
+        // compaction, we might be able to execute it in parallel, so we add it
+        // to the queue and schedule a new thread.
+        if (cfd->NeedsCompaction()) {
+          // Yes, we need more compactions!
          AddToCompactionQueue(cfd);
          ++unscheduled_compactions_;
-
-          c.reset();
-          // Don't need to sleep here, because BackgroundCallCompaction
-          // will sleep if !s.ok()
-          status = Status::CompactionTooLarge();
-          RecordTick(stats_, COMPACTION_CANCELLED, 1);
-        } else {
-          // update statistics
-          MeasureTime(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
-                      c->inputs(0)->size());
-          // There are three things that can change compaction score:
-          // 1) When flush or compaction finish. This case is covered by
-          // InstallSuperVersionAndScheduleWork
-          // 2) When MutableCFOptions changes. This case is also covered by
-          // InstallSuperVersionAndScheduleWork, because this is when the new
-          // options take effect.
-          // 3) When we Pick a new compaction, we "remove" those files being
-          // compacted from the calculation, which then influences compaction
-          // score. Here we check if we need the new compaction even without the
-          // files that are currently being compacted. If we need another
-          // compaction, we might be able to execute it in parallel, so we add
-          // it to the queue and schedule a new thread.
-          if (cfd->NeedsCompaction()) {
-            // Yes, we need more compactions!
-            AddToCompactionQueue(cfd);
-            ++unscheduled_compactions_;
-            MaybeScheduleFlushOrCompaction();
-          }
+          MaybeScheduleFlushOrCompaction();
        }
      }
    }
@@ -1727,7 +1604,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                                    &mutex_, directories_.GetDbDir());
    InstallSuperVersionAndScheduleWork(
        c->column_family_data(), &job_context->superversion_context,
-        *c->mutable_cf_options(), FlushReason::kAutoCompaction);
+        *c->mutable_cf_options());
    ROCKS_LOG_BUFFER(log_buffer, "[%s] Deleted %d files\n",
                     c->column_family_data()->GetName().c_str(),
                     c->num_input_files(0));
@@ -1774,7 +1651,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    // Use latest MutableCFOptions
    InstallSuperVersionAndScheduleWork(
        c->column_family_data(), &job_context->superversion_context,
-        *c->mutable_cf_options(), FlushReason::kAutoCompaction);
+        *c->mutable_cf_options());

    VersionStorageInfo::LevelSummaryStorage tmp;
    c->column_family_data()->internal_stats()->IncBytesMoved(c->output_level(),
@@ -1819,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);
@@ -1853,23 +1730,13 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    if (status.ok()) {
      InstallSuperVersionAndScheduleWork(
          c->column_family_data(), &job_context->superversion_context,
-          *c->mutable_cf_options(), FlushReason::kAutoCompaction);
+          *c->mutable_cf_options());
    }
    *made_progress = true;
  }
  if (c != nullptr) {
    c->ReleaseCompactionFiles(status);
    *made_progress = true;
-
-#ifndef ROCKSDB_LITE
-    // Need to make sure SstFileManager does its bookkeeping
-    auto sfm = static_cast<SstFileManagerImpl*>(
-        immutable_db_options_.sst_file_manager.get());
-    if (sfm && sfm_bookkeeping) {
-      sfm->OnCompactionCompletion(c.get());
-    }
-#endif  // ROCKSDB_LITE
-
    NotifyOnCompactionCompleted(
        c->column_family_data(), c.get(), status,
        compaction_job_stats, job_context->job_id);
@@ -1877,7 +1744,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
  // this will unref its input_version and column_family_data
  c.reset();

-  if (status.ok() || status.IsCompactionTooLarge()) {
+  if (status.ok()) {
    // Done
  } else if (status.IsShutdownInProgress()) {
    // Ignore compaction errors found during shutting down
@@ -2044,7 +1911,7 @@ bool DBImpl::MCOverlap(ManualCompactionState* m, ManualCompactionState* m1) {

 void DBImpl::InstallSuperVersionAndScheduleWork(
    ColumnFamilyData* cfd, SuperVersionContext* sv_context,
-    const MutableCFOptions& mutable_cf_options, FlushReason flush_reason) {
+    const MutableCFOptions& mutable_cf_options) {
  mutex_.AssertHeld();

  // Update max_total_in_memory_state_
@@ -2063,7 +1930,7 @@ void DBImpl::InstallSuperVersionAndScheduleWork(

  // Whenever we install new SuperVersion, we might need to issue new flushes or
  // compactions.
-  SchedulePendingFlush(cfd, flush_reason);
+  SchedulePendingFlush(cfd);
  SchedulePendingCompaction(cfd);
  MaybeScheduleFlushOrCompaction();

@@ -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) {
@@ -117,7 +117,7 @@ Status DBImpl::TEST_WaitForFlushMemTable(ColumnFamilyHandle* column_family) {
  return WaitForFlushMemTable(cfd);
 }

-Status DBImpl::TEST_WaitForCompact(bool wait_unscheduled) {
+Status DBImpl::TEST_WaitForCompact() {
  // Wait until the compaction completes

  // TODO: a bug here. This function actually does not necessarily
@@ -126,8 +126,7 @@ Status DBImpl::TEST_WaitForCompact(bool wait_unscheduled) {

  InstrumentedMutexLock l(&mutex_);
  while ((bg_bottom_compaction_scheduled_ || bg_compaction_scheduled_ ||
-          bg_flush_scheduled_ ||
-          (wait_unscheduled && unscheduled_compactions_)) &&
+          bg_flush_scheduled_) &&
         bg_error_.ok()) {
    bg_cv_.Wait();
  }
@@ -187,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();
 }
@@ -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 probably 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 beginning 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() {
@@ -113,11 +110,11 @@ uint64_t DBImpl::MinLogNumberToKeep() {
    // sections of outstanding transactions.
    //
    // We must check min logs with outstanding prep before we check
-    // logs references by memtables because a log referenced by the
+    // logs referneces by memtables because a log referenced by the
    // first data structure could transition to the second under us.
    //
    // TODO(horuff): iterating over all column families under db mutex.
-    // should find more optimal solution
+    // should find more optimial solution
    auto min_log_in_prep_heap = FindMinLogContainingOutstandingPrep();

    if (min_log_in_prep_heap != 0 && min_log_in_prep_heap < log_number) {
@@ -153,7 +150,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,

  bool doing_the_full_scan = false;

-  // logic for figuring out if we're doing the full scan
+  // logic for figurint out if we're doing the full scan
  if (no_full_scan) {
    doing_the_full_scan = false;
  } else if (force ||
@@ -173,7 +170,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
  // threads
  // Since job_context->min_pending_output is set, until file scan finishes,
  // mutex_ cannot be released. Otherwise, we might see no min_pending_output
-  // here but later find newer generated unfinalized files while scanning.
+  // here but later find newer generated unfinalized files while scannint.
  if (!pending_outputs_.empty()) {
    job_context->min_pending_output = *pending_outputs_.begin();
  } else {
@@ -344,7 +341,7 @@ void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
 }

 // Diffs the files listed in filenames and those that do not
-// belong to live files are possibly removed. Also, removes all the
+// belong to live files are posibly removed. Also, removes all the
 // files in sst_delete_files and log_delete_files.
 // It is not necessary to hold the mutex when invoking this method.
 void DBImpl::PurgeObsoleteFiles(const JobContext& state, bool schedule_only) {
@@ -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);
@@ -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
@@ -36,49 +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,
-      std::vector<std::string>* const /*output_file_names*/ = nullptr
-      ) 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.");
  }

@@ -86,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.");
  }

@@ -108,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.");
  }

@@ -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)) {
@@ -133,8 +130,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
      for (auto* writer : *(w.write_group)) {
        if (!writer->CallbackFailed() && writer->pre_release_callback) {
          assert(writer->sequence != kMaxSequenceNumber);
-          Status ws = writer->pre_release_callback->Callback(writer->sequence,
-                                                             disable_memtable);
+          Status ws = writer->pre_release_callback->Callback(writer->sequence);
          if (!ws.ok()) {
            status = ws;
            break;
@@ -215,10 +211,10 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
                    write_group.size > 1;
    size_t total_count = 0;
    size_t valid_batches = 0;
-    size_t total_byte_size = 0;
+    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();
@@ -307,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);
          }
@@ -328,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) {
@@ -340,7 +334,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
  PERF_TIMER_START(write_pre_and_post_process_time);

  if (!w.CallbackFailed()) {
-    WriteStatusCheck(status);
+    WriteCallbackStatusCheck(status);
  }

  if (need_log_sync) {
@@ -369,8 +363,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
      for (auto* writer : write_group) {
        if (!writer->CallbackFailed() && writer->pre_release_callback) {
          assert(writer->sequence != kMaxSequenceNumber);
-          Status ws = writer->pre_release_callback->Callback(writer->sequence,
-                                                             disable_memtable);
+          Status ws = writer->pre_release_callback->Callback(writer->sequence);
          if (!ws.ok()) {
            status = ws;
            break;
@@ -464,7 +457,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    }

    if (!w.CallbackFailed()) {
-      WriteStatusCheck(w.status);
+      WriteCallbackStatusCheck(w.status);
    }

    if (need_log_sync) {
@@ -522,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);

@@ -552,7 +544,7 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
  // Note: no need to update last_batch_group_size_ here since the batch writes
  // to WAL only

-  size_t total_byte_size = 0;
+  uint64_t total_byte_size = 0;
  for (auto* writer : write_group) {
    if (writer->CheckCallback(this)) {
      total_byte_size = WriteBatchInternal::AppendedByteSize(
@@ -584,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);
@@ -607,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
  }
@@ -625,15 +608,13 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
  PERF_TIMER_START(write_pre_and_post_process_time);

  if (!w.CallbackFailed()) {
-    WriteStatusCheck(status);
+    WriteCallbackStatusCheck(status);
  }
  if (status.ok()) {
    for (auto* writer : write_group) {
      if (!writer->CallbackFailed() && writer->pre_release_callback) {
        assert(writer->sequence != kMaxSequenceNumber);
-        const bool DISABLE_MEMTABLE = true;
-        Status ws = writer->pre_release_callback->Callback(writer->sequence,
-                                                           DISABLE_MEMTABLE);
+        Status ws = writer->pre_release_callback->Callback(writer->sequence);
        if (!ws.ok()) {
          status = ws;
          break;
@@ -651,7 +632,7 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
  return status;
 }

-void DBImpl::WriteStatusCheck(const Status& status) {
+void DBImpl::WriteCallbackStatusCheck(const Status& status) {
  // Is setting bg_error_ enough here?  This will at least stop
  // compaction and fail any further writes.
  if (immutable_db_options_.paranoid_checks && !status.ok() &&
@@ -1023,7 +1004,7 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
        break;
      }
      cfd->imm()->FlushRequested();
-      SchedulePendingFlush(cfd, FlushReason::kWriteBufferManager);
+      SchedulePendingFlush(cfd);
    }
  }
  MaybeScheduleFlushOrCompaction();
@@ -1066,11 +1047,10 @@ Status DBImpl::HandleWriteBufferFull(WriteContext* write_context) {
    }
  }
  if (cfd_picked != nullptr) {
-    status = SwitchMemtable(cfd_picked, write_context,
-                            FlushReason::kWriteBufferFull);
+    status = SwitchMemtable(cfd_picked, write_context);
    if (status.ok()) {
      cfd_picked->imm()->FlushRequested();
-      SchedulePendingFlush(cfd_picked, FlushReason::kWriteBufferFull);
+      SchedulePendingFlush(cfd_picked);
      MaybeScheduleFlushOrCompaction();
    }
  }
@@ -1168,7 +1148,7 @@ Status DBImpl::ThrottleLowPriWritesIfNeeded(const WriteOptions& write_options,
 Status DBImpl::ScheduleFlushes(WriteContext* context) {
  ColumnFamilyData* cfd;
  while ((cfd = flush_scheduler_.TakeNextColumnFamily()) != nullptr) {
-    auto status = SwitchMemtable(cfd, context, FlushReason::kWriteBufferFull);
+    auto status = SwitchMemtable(cfd, context);
    if (cfd->Unref()) {
      delete cfd;
    }
@@ -1180,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;
@@ -1197,8 +1177,7 @@ void DBImpl::NotifyOnMemTableSealed(ColumnFamilyData* /*cfd*/,

 // REQUIRES: mutex_ is held
 // REQUIRES: this thread is currently at the front of the writer queue
-Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
-                              FlushReason flush_reason) {
+Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  mutex_.AssertHeld();
  WriteThread::Writer nonmem_w;
  if (two_write_queues_) {
@@ -1313,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);
@@ -1346,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
@@ -1366,7 +1336,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
  new_mem->Ref();
  cfd->SetMemtable(new_mem);
  InstallSuperVersionAndScheduleWork(cfd, &context->superversion_context,
-                                     mutable_cf_options, flush_reason);
+                                     mutable_cf_options);
  if (two_write_queues_) {
    nonmem_write_thread_.ExitUnbatched(&nonmem_w);
  }
@@ -1375,13 +1345,11 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,

 size_t DBImpl::GetWalPreallocateBlockSize(uint64_t write_buffer_size) const {
  mutex_.AssertHeld();
-  size_t bsize = static_cast<size_t>(
-    write_buffer_size / 10 + write_buffer_size);
+  size_t bsize = write_buffer_size / 10 + write_buffer_size;
  // Some users might set very high write_buffer_size and rely on
  // max_total_wal_size or other parameters to control the WAL size.
  if (mutable_db_options_.max_total_wal_size > 0) {
-    bsize = std::min<size_t>(bsize, static_cast<size_t>(
-      mutable_db_options_.max_total_wal_size));
+    bsize = std::min<size_t>(bsize, mutable_db_options_.max_total_wal_size);
  }
  if (immutable_db_options_.db_write_buffer_size > 0) {
    bsize = std::min<size_t>(bsize, immutable_db_options_.db_write_buffer_size);
@@ -1403,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);
 }

@@ -1435,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
@@ -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;
@@ -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)
@@ -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;
@@ -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) {
@@ -284,7 +251,7 @@ TEST_P(MergeOperatorPinningTest, Randomized) {
    Random rnd(301);
    std::map<std::string, std::string> true_data;

-    const int kTotalMerges = 5000;
+    const int kTotalMerges = 10000;
    // Every key gets ~10 operands
    const int kKeyRange = kTotalMerges / 10;
    const int kOperandSize = 20;
@@ -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) {
@@ -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"
@@ -69,27 +68,27 @@ TEST_F(DBPropertiesTest, Empty) {
    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("0", num);
+    ASSERT_EQ("1", num);

    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("0", num);
+    ASSERT_EQ("2", num);

    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("0", num);
+    ASSERT_EQ("3", num);

    ASSERT_OK(db_->EnableFileDeletions(false));
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("0", num);
+    ASSERT_EQ("2", num);

    ASSERT_OK(db_->EnableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("1", num);
+    ASSERT_EQ("0", num);
  } while (ChangeOptions());
 }

@@ -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

@@ -409,11 +409,6 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DeleteScheduler::DeleteTrashFile:DeleteFile",
      [&](void* arg) { bg_delete_file++; });
-  // The deletion scheduler sometimes skips marking file as trash according to
-  // a heuristic. In that case the deletion will go through the below SyncPoint.
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DeleteScheduler::DeleteFile",
-      [&](void* arg) { bg_delete_file++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
@@ -466,15 +461,13 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
  sfm->WaitForEmptyTrash();
  ASSERT_EQ(bg_delete_file, 8);

-  // Compaction will delete both files and regenerate a file in L1 in second
-  // db path. The deleted files should still be cleaned up via delete scheduler.
  compact_options.bottommost_level_compaction =
      BottommostLevelCompaction::kForce;
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,1", FilesPerLevel(0));

  sfm->WaitForEmptyTrash();
-  ASSERT_EQ(bg_delete_file, 10);
+  ASSERT_EQ(bg_delete_file, 8);

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
@@ -545,52 +538,6 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowed) {
  ASSERT_NOK(Flush());
 }

-TEST_F(DBSSTTest, CancellingCompactionsWorks) {
-  std::shared_ptr<SstFileManager> sst_file_manager(NewSstFileManager(env_));
-  auto sfm = static_cast<SstFileManagerImpl*>(sst_file_manager.get());
-
-  Options options = CurrentOptions();
-  options.sst_file_manager = sst_file_manager;
-  options.level0_file_num_compaction_trigger = 2;
-  options.statistics = CreateDBStatistics();
-  DestroyAndReopen(options);
-
-  int completed_compactions = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction():CancelledCompaction", [&](void* arg) {
-        sfm->SetMaxAllowedSpaceUsage(0);
-      });
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun",
-      [&](void* arg) { completed_compactions++; });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  Random rnd(301);
-
-  // Generate a file containing 10 keys.
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 50)));
-  }
-  ASSERT_OK(Flush());
-  uint64_t total_file_size = 0;
-  auto files_in_db = GetAllSSTFiles(&total_file_size);
-  // Set the maximum allowed space usage to the current total size
-  sfm->SetMaxAllowedSpaceUsage(2 * total_file_size + 1);
-
-  // Generate another file to trigger compaction.
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 50)));
-  }
-  ASSERT_OK(Flush());
-  dbfull()->TEST_WaitForCompact(true);
-
-  ASSERT_GT(completed_compactions, 0);
-  ASSERT_EQ(sfm->GetCompactionsReservedSize(), 0);
-  // Make sure the stat is bumped
-  ASSERT_GT(dbfull()->immutable_db_options().statistics.get()->getTickerCount(COMPACTION_CANCELLED), 0);
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
 TEST_F(DBSSTTest, DBWithMaxSpaceAllowedRandomized) {
  // This test will set a maximum allowed space for the DB, then it will
  // keep filling the DB until the limit is reached and bg_error_ is set.
@@ -619,12 +566,6 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowedRandomized) {
        estimate_multiplier++;  // used in the main loop assert
      });

-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction():CancelledCompaction", [&](void* arg) {
-        bool* enough_room = static_cast<bool*>(arg);
-        *enough_room = true;
-      });
-
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "CompactionJob::FinishCompactionOutputFile:MaxAllowedSpaceReached",
      [&](void* arg) {
@@ -214,9 +214,9 @@ TEST_F(DBTestTailingIterator, TailingIteratorTrimSeekToNext) {
  }
  ASSERT_TRUE(file_iters_renewed_null);
  ASSERT_TRUE(file_iters_renewed_copy);
-  iter = nullptr;
-  itern = nullptr;
-  iterh = nullptr;
+  iter = 0;
+  itern = 0;
+  iterh = 0;
  BlockBasedTableOptions table_options;
  table_options.no_block_cache = true;
  table_options.block_cache_compressed = nullptr;
@@ -229,7 +229,7 @@ TEST_F(DBTestTailingIterator, TailingIteratorTrimSeekToNext) {
  Slice target1(buf5, 20);
  iteri->Seek(target1);
  ASSERT_TRUE(iteri->status().IsIncomplete());
-  iteri = nullptr;
+  iteri = 0;

  read_options.read_tier = kReadAllTier;
  options.table_factory.reset(NewBlockBasedTableFactory());
@@ -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,67 +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,
-      std::vector<std::string>* const /*output_file_names*/ = nullptr
-      ) 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.");
  }

@@ -2426,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;
  }

@@ -2453,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_;
  }

@@ -2462,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;
  }
@@ -2473,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;
  }

@@ -4788,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 = "";
@@ -5155,11 +5113,11 @@ TEST_F(DBTest, AutomaticConflictsWithManualCompaction) {
    }
    ASSERT_OK(Flush());
  }
-  port::Thread manual_compaction_thread([this]() {
-    CompactRangeOptions croptions;
-    croptions.exclusive_manual_compaction = true;
-    ASSERT_OK(db_->CompactRange(croptions, nullptr, nullptr));
-  });
+  std::thread manual_compaction_thread([this]() {
+      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) {
@@ -5395,42 +5353,18 @@ TEST_F(DBTest, HardLimit) {
 #ifndef ROCKSDB_LITE
 class WriteStallListener : public EventListener {
 public:
-  WriteStallListener() : cond_(&mutex_), 
-    condition_(WriteStallCondition::kNormal),
-    expected_(WriteStallCondition::kNormal),
-    expected_set_(false) 
-  {}
+  WriteStallListener() : condition_(WriteStallCondition::kNormal) {}
  void OnStallConditionsChanged(const WriteStallInfo& info) override {
    MutexLock l(&mutex_);
    condition_ = info.condition.cur;
-    if (expected_set_ && 
-      condition_ == expected_) {
-        cond_.Signal();
-        expected_set_ = false;
-    }
  }
  bool CheckCondition(WriteStallCondition expected) {
    MutexLock l(&mutex_);
-    if (expected != condition_) {
-      expected_ = expected;
-      expected_set_ = true;
-      while (expected != condition_) {
-        // We bail out on timeout 500 milliseconds
-        const uint64_t timeout_us = 500000;
-        if (cond_.TimedWait(timeout_us)) {
-          expected_set_ = false;
-          return false;
-        }
-      }
-    }
-    return true;
+    return expected == condition_;
  }
 private:
-  port::Mutex   mutex_;
-  port::CondVar cond_;
+  port::Mutex mutex_;
  WriteStallCondition condition_;
-  WriteStallCondition expected_;
-  bool                expected_set_;
 };

 TEST_F(DBTest, SoftLimit) {
@@ -5758,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;
-  };
-
-  port::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<port::Thread> thread_spawning_threads(10);
-  for (auto& t: thread_spawning_threads) {
-    t = port::Thread([&] {
-      while (!done()) {
-        {
-          port::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) {
@@ -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,29 +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];
-#ifndef OS_WIN
-    // You can't open a directory on windows using random access file
-    std::unique_ptr<RandomAccessFile> file;
-    ASSERT_OK(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;
-    }
-#else
-    std::unique_ptr<Directory> dir;
-    ASSERT_OK(env_->NewDirectory(dbname_, &dir));
-    if (dir->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;
-    }
-#endif
+  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++) {
@@ -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;
 }

@@ -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_);
@@ -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) {
@@ -80,22 +80,6 @@ TEST_P(DBWriteTest, IOErrorOnWALWritePropagateToWriteThreadFollower) {
  Close();
 }

-TEST_P(DBWriteTest, IOErrorOnWALWriteTriggersReadOnlyMode) {
-  std::unique_ptr<FaultInjectionTestEnv> mock_env(
-      new FaultInjectionTestEnv(Env::Default()));
-  Options options = GetOptions();
-  options.env = mock_env.get();
-  Reopen(options);
-  for (int i = 0; i < 2; i++) {
-    // Forcibly fail WAL write for the first Put only. Subsequent Puts should
-    // fail due to read-only mode
-    mock_env->SetFilesystemActive(i != 0);
-    ASSERT_FALSE(Put("key" + ToString(i), "value").ok());
-  }
-  // Close before mock_env destruct.
-  Close();
-}
-
 INSTANTIATE_TEST_CASE_P(DBWriteTestInstance, DBWriteTest,
                        testing::Values(DBTestBase::kDefault,
                                        DBTestBase::kConcurrentWALWrites,
@@ -106,6 +106,25 @@ const char* InternalKeyComparator::Name() const {
  return name_.c_str();
 }

+int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
+  // Order by:
+  //    increasing user key (according to user-supplied comparator)
+  //    decreasing sequence number
+  //    decreasing type (though sequence# should be enough to disambiguate)
+  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
+  PERF_COUNTER_ADD(user_key_comparison_count, 1);
+  if (r == 0) {
+    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
+    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 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:
@@ -11,7 +11,6 @@
 #include <stdio.h>
 #include <string>
 #include <utility>
-#include "monitoring/perf_context_imp.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/db.h"
 #include "rocksdb/filter_policy.h"
@@ -163,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;
@@ -608,46 +605,4 @@ struct RangeTombstone {
  }
 };

-inline
-int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
-  // Order by:
-  //    increasing user key (according to user-supplied comparator)
-  //    decreasing sequence number
-  //    decreasing type (though sequence# should be enough to disambiguate)
-  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
-  PERF_COUNTER_ADD(user_key_comparison_count, 1);
-  if (r == 0) {
-    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
-    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8);
-    if (anum > bnum) {
-      r = -1;
-    } else if (anum < bnum) {
-      r = +1;
-    }
-  }
-  return r;
-}
-
-inline
-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;
-}
-
-
 }  // namespace rocksdb
@@ -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");
  }
 };
@@ -228,7 +228,7 @@ TEST_F(DeleteFileTest, PurgeObsoleteFilesTest) {

  // this time, we keep an iterator alive
  ReopenDB(true);
-  Iterator *itr = nullptr;
+  Iterator *itr = 0;
  CreateTwoLevels();
  itr = db_->NewIterator(ReadOptions());
  db_->CompactRange(compact_options, &first_slice, &last_slice);
@@ -249,7 +249,7 @@ TEST_F(DeleteFileTest, BackgroundPurgeTest) {
  Slice first_slice(first), last_slice(last);

  // We keep an iterator alive
-  Iterator* itr = nullptr;
+  Iterator* itr = 0;
  CreateTwoLevels();
  ReadOptions options;
  options.background_purge_on_iterator_cleanup = true;
@@ -289,7 +289,7 @@ TEST_F(DeleteFileTest, BackgroundPurgeCopyOptions) {
  Slice first_slice(first), last_slice(last);

  // We keep an iterator alive
-  Iterator* itr = nullptr;
+  Iterator* itr = 0;
  CreateTwoLevels();
  ReadOptions* options = new ReadOptions();
  options->background_purge_on_iterator_cleanup = true;
@@ -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) {
@@ -407,9 +451,8 @@ Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(

    if (vstorage->NumLevelFiles(lvl) > 0) {
      bool overlap_with_level = false;
-      status = sv->current->OverlapWithLevelIterator(ro, env_options_,
-          file_to_ingest->smallest_user_key, file_to_ingest->largest_user_key,
-          lvl, &overlap_with_level);
+      status = IngestedFileOverlapWithLevel(sv, file_to_ingest, lvl,
+        &overlap_with_level);
      if (!status.ok()) {
        return status;
      }
@@ -430,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;
@@ -510,15 +550,40 @@ Status ExternalSstFileIngestionJob::AssignGlobalSeqnoForIngestedFile(
  std::string seqno_val;
  PutFixed64(&seqno_val, seqno);
  status = rwfile->Write(file_to_ingest->global_seqno_offset, seqno_val);
-  if (status.ok()) {
-    status = rwfile->Fsync();
-  }
  if (status.ok()) {
    file_to_ingest->assigned_seqno = seqno;
  }
  return status;
 }

+Status ExternalSstFileIngestionJob::IngestedFileOverlapWithIteratorRange(
+    const IngestedFileInfo* file_to_ingest, InternalIterator* iter,
+    bool* overlap) {
+  auto* vstorage = cfd_->current()->storage_info();
+  auto* ucmp = vstorage->InternalComparator()->user_comparator();
+  InternalKey range_start(file_to_ingest->smallest_user_key, kMaxSequenceNumber,
+                          kValueTypeForSeek);
+  iter->Seek(range_start.Encode());
+  if (!iter->status().ok()) {
+    return iter->status();
+  }
+
+  *overlap = false;
+  if (iter->Valid()) {
+    ParsedInternalKey seek_result;
+    if (!ParseInternalKey(iter->key(), &seek_result)) {
+      return Status::Corruption("DB have corrupted keys");
+    }
+
+    if (ucmp->Compare(seek_result.user_key, file_to_ingest->largest_user_key) <=
+        0) {
+      *overlap = true;
+    }
+  }
+
+  return iter->status();
+}
+
 bool ExternalSstFileIngestionJob::IngestedFileFitInLevel(
    const IngestedFileInfo* file_to_ingest, int level) {
  if (level == 0) {
@@ -547,6 +612,38 @@ bool ExternalSstFileIngestionJob::IngestedFileFitInLevel(
  return true;
 }

+Status ExternalSstFileIngestionJob::IngestedFileOverlapWithLevel(
+    SuperVersion* sv, IngestedFileInfo* file_to_ingest, int lvl,
+    bool* overlap_with_level) {
+  Arena arena;
+  ReadOptions ro;
+  ro.total_order_seek = true;
+  MergeIteratorBuilder merge_iter_builder(&cfd_->internal_comparator(),
+                                          &arena);
+  // Files are opened lazily when the iterator needs them, thus range deletions
+  // are also added lazily to the aggregator. We need to check for range
+  // deletion overlap only in the case where there's no point-key overlap. Then,
+  // we've already opened the file with range containing the ingested file's
+  // begin key, and iterated through all files until the one containing the
+  // ingested file's end key. So any files maybe containing range deletions
+  // overlapping the ingested file must have been opened and had their range
+  // deletions added to the aggregator.
+  RangeDelAggregator range_del_agg(cfd_->internal_comparator(),
+                                   {} /* snapshots */,
+                                   false /* collapse_deletions */);
+  sv->current->AddIteratorsForLevel(ro, env_options_, &merge_iter_builder, lvl,
+                                    &range_del_agg);
+  ScopedArenaIterator level_iter(merge_iter_builder.Finish());
+  Status status = IngestedFileOverlapWithIteratorRange(
+      file_to_ingest, level_iter.get(), overlap_with_level);
+  if (status.ok() && *overlap_with_level == false &&
+      range_del_agg.IsRangeOverlapped(file_to_ingest->smallest_user_key,
+                                      file_to_ingest->largest_user_key)) {
+    *overlap_with_level = true;
+  }
+  return status;
+}
+
 }  // namespace rocksdb

 #endif  // !ROCKSDB_LITE
@@ -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
@@ -133,6 +133,17 @@ class ExternalSstFileIngestionJob {
  Status AssignGlobalSeqnoForIngestedFile(IngestedFileInfo* file_to_ingest,
                                          SequenceNumber seqno);

+  // Check if `file_to_ingest` key range overlap with the range `iter` represent
+  // REQUIRES: Mutex held
+  Status IngestedFileOverlapWithIteratorRange(
+      const IngestedFileInfo* file_to_ingest, InternalIterator* iter,
+      bool* overlap);
+
+  // Check if `file_to_ingest` key range overlap with level
+  // REQUIRES: Mutex held
+  Status IngestedFileOverlapWithLevel(SuperVersion* sv,
+    IngestedFileInfo* file_to_ingest, int lvl, bool* overlap_with_level);
+
  // Check if `file_to_ingest` can fit in level `level`
  // REQUIRES: Mutex held
  bool IngestedFileFitInLevel(const IngestedFileInfo* file_to_ingest,
@@ -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);
  }
@@ -76,8 +76,8 @@ class FaultInjectionTest : public testing::Test,
        sync_use_wal_(false),
        sync_use_compact_(true),
        base_env_(nullptr),
-        env_(nullptr),
-        db_(nullptr) {
+        env_(NULL),
+        db_(NULL) {
  }

  ~FaultInjectionTest() {
@@ -139,9 +139,9 @@ class FaultInjectionTest : public testing::Test,
  }

  Status NewDB() {
-    assert(db_ == nullptr);
+    assert(db_ == NULL);
    assert(tiny_cache_ == nullptr);
-    assert(env_ == nullptr);
+    assert(env_ == NULL);

    env_ =
        new FaultInjectionTestEnv(base_env_ ? base_env_.get() : Env::Default());
@@ -176,7 +176,7 @@ class FaultInjectionTest : public testing::Test,
    Status s = DestroyDB(dbname_, options_);

    delete env_;
-    env_ = nullptr;
+    env_ = NULL;

    tiny_cache_.reset();

@@ -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);
  }
@@ -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 {
@@ -54,36 +54,6 @@

 namespace rocksdb {

-const char* GetFlushReasonString (FlushReason flush_reason) {
-  switch (flush_reason) {
-    case FlushReason::kOthers:
-      return "Other Reasons";
-    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::kDeleteFiles:
-      return "Delete Files";
-    case FlushReason::kAutoCompaction:
-      return "Auto Compaction";
-    case FlushReason::kManualFlush:
-      return "Manual Flush";
-    default:
-      return "Invalid";
-  }
-}
-
-
 FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
                   const ImmutableDBOptions& db_options,
                   const MutableCFOptions& mutable_cf_options,
@@ -308,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(
@@ -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));
    }
  }
 }
@@ -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_;

@@ -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;
 }
@@ -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,
@@ -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.
@@ -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);
@@ -163,7 +163,7 @@ class LogTest : public ::testing::TestWithParam<int> {
        source_holder_(
            test::GetSequentialFileReader(new StringSource(reader_contents_))),
        writer_(std::move(dest_holder_), 123, GetParam()),
-        reader_(nullptr, std::move(source_holder_), &report_, true /*checksum*/,
+        reader_(NULL, std::move(source_holder_), &report_, true /*checksum*/,
                0 /*initial_offset*/, 123) {
    int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
    initial_offset_last_record_offsets_[0] = 0;
@@ -271,7 +271,7 @@ class LogTest : public ::testing::TestWithParam<int> {
    unique_ptr<SequentialFileReader> file_reader(
        test::GetSequentialFileReader(new StringSource(reader_contents_)));
    unique_ptr<Reader> offset_reader(
-        new Reader(nullptr, std::move(file_reader), &report_,
+        new Reader(NULL, std::move(file_reader), &report_,
                   true /*checksum*/, WrittenBytes() + offset_past_end, 123));
    Slice record;
    std::string scratch;
@@ -284,7 +284,7 @@ class LogTest : public ::testing::TestWithParam<int> {
    unique_ptr<SequentialFileReader> file_reader(
        test::GetSequentialFileReader(new StringSource(reader_contents_)));
    unique_ptr<Reader> offset_reader(
-        new Reader(nullptr, std::move(file_reader), &report_,
+        new Reader(NULL, std::move(file_reader), &report_,
                   true /*checksum*/, initial_offset, 123));
    Slice record;
    std::string scratch;
@@ -58,8 +58,7 @@ Status Writer::AddRecord(const Slice& slice) {
        // kRecyclableHeaderSize being <= 11)
        assert(header_size <= 11);
        dest_->Append(
-            Slice("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-                  static_cast<size_t>(leftover)));
+            Slice("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", leftover));
      }
      block_offset_ = 0;
    }
@@ -49,7 +49,7 @@ namespace log {
 * |CRC (4B) | Size (2B) | Type (1B) | Payload   |
 * +---------+-----------+-----------+--- ... ---+
 *
- * CRC = 32bit hash computed over the record type and payload using CRC
+ * CRC = 32bit hash computed over the payload using CRC
 * Size = Length of the payload data
 * Type = Type of record
 *        (kZeroType, kFullType, kFirstType, kLastType, kMiddleType )
@@ -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,9 +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
@@ -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";
  }

@@ -225,24 +225,24 @@ 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,
-                                        const KeyComparator::DecodedType& key)
+                                        const Slice& 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,
@@ -64,7 +64,7 @@ struct MemTablePostProcessInfo {
 };

 // Note:  Many of the methods in this class have comments indicating that
-// external synchronization is required as these methods are not thread-safe.
+// external synchromization is required as these methods are not thread-safe.
 // It is up to higher layers of code to decide how to prevent concurrent
 // invokation of these methods.  This is usually done by acquiring either
 // the db mutex or the single writer thread.
@@ -84,7 +84,7 @@ class MemTable {
    virtual int operator()(const char* prefix_len_key1,
                           const char* prefix_len_key2) const override;
    virtual int operator()(const char* prefix_len_key,
-                           const DecodedType& key) const override;
+                           const Slice& key) const override;
  };

  // MemTables are reference counted.  The initial reference count
@@ -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);

@@ -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());
@@ -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;
    }
@@ -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
--- a/Show More
+++ b/Show More