StackableDB optionally take shared ownership of the underlying DB

2026-07-07 14:47:40 +08:00 · 2018-01-25 15:34:12 -08:00
577 changed files with 10014 additions and 33308 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
@@ -16,7 +16,7 @@
 #    See thirdparty.inc for more information.
 #        sample command: cmake -G "Visual Studio 15 Win64" -DWITH_GFLAGS=1 -DWITH_SNAPPY=1 -DWITH_JEMALLOC=1 -DWITH_JNI=1 ..
 # 4. Then build the project in debug mode (you may want to add /m[:<N>] flag to run msbuild in <N> parallel threads
-#                                          or simply /m to use all avail cores)
+#                                          or simply /m ot use all avail cores)
 #        msbuild rocksdb.sln
 #
 #        rocksdb.sln build features exclusions of test only code in Release. If you build ALL_BUILD then everything
@@ -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()
@@ -64,10 +64,9 @@ else()
      find_package(JeMalloc REQUIRED)
      add_definitions(-DROCKSDB_JEMALLOC -DJEMALLOC_NO_DEMANGLE)
      include_directories(${JEMALLOC_INCLUDE_DIR})
-      list(APPEND THIRDPARTY_LIBS ${JEMALLOC_LIBRARIES})
    endif()
  endif()
-
+  
  # No config file for this
  option(WITH_GFLAGS "build with GFlags" ON)
  if(WITH_GFLAGS)
@@ -133,17 +132,19 @@ endif()

 string(REGEX REPLACE "[^0-9a-f]+" "" GIT_SHA "${GIT_SHA}")

-
-# Read rocksdb version from version.h header file.
-file(READ include/rocksdb/version.h version_header_file)
-string(REGEX MATCH "#define ROCKSDB_MAJOR ([0-9]+)" _ ${version_header_file})
-set(ROCKSDB_VERSION_MAJOR ${CMAKE_MATCH_1})
-string(REGEX MATCH "#define ROCKSDB_MINOR ([0-9]+)" _ ${version_header_file})
-set(ROCKSDB_VERSION_MINOR ${CMAKE_MATCH_1})
-string(REGEX MATCH "#define ROCKSDB_PATCH ([0-9]+)" _ ${version_header_file})
-set(ROCKSDB_VERSION_PATCH ${CMAKE_MATCH_1})
-set(ROCKSDB_VERSION ${ROCKSDB_VERSION_MAJOR}.${ROCKSDB_VERSION_MINOR}.${ROCKSDB_VERSION_PATCH})
-
+set(SH_CMD "sh")
+execute_process(COMMAND
+  ${SH_CMD} -c "build_tools/version.sh full"
+  WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+  OUTPUT_VARIABLE ROCKSDB_VERSION
+)
+string(STRIP "${ROCKSDB_VERSION}" ROCKSDB_VERSION)
+execute_process(COMMAND
+  ${SH_CMD} -c "build_tools/version.sh major"
+  WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+  OUTPUT_VARIABLE ROCKSDB_VERSION_MAJOR
+)
+string(STRIP "${ROCKSDB_VERSION_MAJOR}" ROCKSDB_VERSION_MAJOR)

 option(WITH_MD_LIBRARY "build with MD" ON)
 if(WIN32 AND MSVC)
@@ -228,7 +229,6 @@ int main() {
 unset(CMAKE_REQUIRED_FLAGS)
 if(HAVE_SSE42)
  add_definitions(-DHAVE_SSE42)
-  add_definitions(-DHAVE_PCLMUL)
 elseif(FORCE_SSE42)
  message(FATAL_ERROR "FORCE_SSE42=ON but unable to compile with SSE4.2 enabled")
 endif()
@@ -285,28 +285,20 @@ if(WITH_UBSAN)
  endif()
 endif()

-option(WITH_NUMA "build with NUMA policy support" OFF)
-if(WITH_NUMA)
-  find_package(NUMA REQUIRED)
+find_package(NUMA)
+if(NUMA_FOUND)
  add_definitions(-DNUMA)
  include_directories(${NUMA_INCLUDE_DIR})
  list(APPEND THIRDPARTY_LIBS ${NUMA_LIBRARIES})
 endif()

-option(WITH_TBB "build with Threading Building Blocks (TBB)" OFF)
-if(WITH_TBB)
-  find_package(TBB REQUIRED)
+find_package(TBB)
+if(TBB_FOUND)
  add_definitions(-DTBB)
  include_directories(${TBB_INCLUDE_DIR})
  list(APPEND THIRDPARTY_LIBS ${TBB_LIBRARIES})
 endif()

-# Stall notifications eat some performance from inserts
-option(DISABLE_STALL_NOTIF "Build with stall notifications" OFF)
-if(DISABLE_STALL_NOTIF)
-  add_definitions(-DROCKSDB_DISABLE_STALL_NOTIFICATION)
-endif()
-
 # Used to run CI build and tests so we can run faster
 set(OPTIMIZE_DEBUG_DEFAULT 0)        # Debug build is unoptimized by default use -DOPTDBG=1 to optimize

@@ -316,22 +308,6 @@ else()
   set(OPTIMIZE_DEBUG ${OPTIMIZE_DEBUG_DEFAULT})
 endif()

-if(DEFINED USE_RTTI)
-  if(USE_RTTI)
-    message(STATUS "Enabling RTTI")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DROCKSDB_USE_RTTI")
-  else()
-    message(STATUS "Disabling RTTI")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-rtti")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-rtti")
-  endif()
-else()
-  message(STATUS "Enabling RTTI in Debug builds only (default)")
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
-  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-rtti")
-endif()
-
 if(MSVC)
  if((${OPTIMIZE_DEBUG} EQUAL 1))
    message(STATUS "Debug optimization is enabled")
@@ -479,7 +455,6 @@ set(SOURCES
        db/flush_scheduler.cc
        db/forward_iterator.cc
        db/internal_stats.cc
-        db/logs_with_prep_tracker.cc
        db/log_reader.cc
        db/log_writer.cc
        db/malloc_stats.cc
@@ -594,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
@@ -629,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
@@ -683,12 +655,8 @@ if(WIN32)
    port/win/env_default.cc
    port/win/port_win.cc
    port/win/win_logger.cc
-    port/win/win_thread.cc)
-
-if(WITH_XPRESS)
-  list(APPEND SOURCES
+    port/win/win_thread.cc
    port/win/xpress_win.cc)
-endif()

 if(WITH_JEMALLOC)
  list(APPEND SOURCES
@@ -705,14 +673,6 @@ endif()
 set(ROCKSDB_STATIC_LIB rocksdb${ARTIFACT_SUFFIX})
 set(ROCKSDB_SHARED_LIB rocksdb-shared${ARTIFACT_SUFFIX})
 set(ROCKSDB_IMPORT_LIB ${ROCKSDB_SHARED_LIB})
-
-option(WITH_LIBRADOS "Build with librados" OFF)
-if(WITH_LIBRADOS)
-  list(APPEND SOURCES
-    utilities/env_librados.cc)
-  list(APPEND THIRDPARTY_LIBS rados)
-endif()
-
 if(WIN32)
  set(SYSTEM_LIBS ${SYSTEM_LIBS} Shlwapi.lib Rpcrt4.lib)
  set(LIBS ${ROCKSDB_STATIC_LIB} ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
@@ -731,6 +691,13 @@ else()
                        OUTPUT_NAME "rocksdb")
 endif()

+option(WITH_LIBRADOS "Build with librados" OFF)
+if(WITH_LIBRADOS)
+  list(APPEND SOURCES
+    utilities/env_librados.cc)
+  list(APPEND THIRDPARTY_LIBS rados)
+endif()
+
 add_library(${ROCKSDB_STATIC_LIB} STATIC ${SOURCES})
 target_link_libraries(${ROCKSDB_STATIC_LIB}
  ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
@@ -863,7 +830,6 @@ if(WITH_TESTS)
        db/db_write_test.cc
        db/dbformat_test.cc
        db/deletefile_test.cc
-        db/obsolete_files_test.cc
        db/external_sst_file_basic_test.cc
        db/external_sst_file_test.cc
        db/fault_injection_test.cc
@@ -1,85 +1,9 @@
 # Rocksdb Change Log
 ## Unreleased
 ### Public API Change
-* Add a BlockBasedTableOption to align uncompressed data blocks on the smaller of block size or page size boundary, to reduce flash reads by avoiding reads spanning 4K pages.
-* The background thread naming convention changed (on supporting platforms) to "rocksdb:<thread pool priority><thread number>", e.g., "rocksdb:low0".
-* Add a new ticker stat rocksdb.number.multiget.keys.found to count number of keys successfully read in MultiGet calls
-* Touch-up to write-related counters in PerfContext. New counters added: write_scheduling_flushes_compactions_time, write_thread_wait_nanos. Counters whose behavior was fixed or modified: write_memtable_time, write_pre_and_post_process_time, write_delay_time.
-* Posix Env's NewRandomRWFile() will fail if the file doesn't exist.
-* Now, `DBOptions::use_direct_io_for_flush_and_compaction` only applies to background writes, and `DBOptions::use_direct_reads` applies to both user reads and background reads. This conforms with Linux's `open(2)` manpage, which advises against simultaneously reading a file in buffered and direct modes, due to possibly undefined behavior and degraded performance.
-
-### New Features
-* Introduce TTL for level compaction so that all files older than ttl go through the compaction process to get rid of old data.
-* TransactionDBOptions::write_policy can be configured to enable WritePrepared 2PC transactions. Read more about them in the wiki.
-* Add DB properties "rocksdb.block-cache-capacity", "rocksdb.block-cache-usage", "rocksdb.block-cache-pinned-usage" to show block cache usage.
-* Add `Env::LowerThreadPoolCPUPriority(Priority)` method, which lowers the CPU priority of background (esp. compaction) threads to minimize interference with foreground tasks.
-* Fsync parent directory after deleting a file in delete scheduler.
-* In level-based compaction, if bottom-pri thread pool was setup via `Env::SetBackgroundThreads()`, compactions to the bottom level will be delegated to that thread pool.
-
-### Bug Fixes
-* Fsync after writing global seq number to the ingestion file in ExternalSstFileIngestionJob.
-* Fix WAL corruption caused by race condition between user write thread and FlushWAL when two_write_queue is not set.
-* Fix `BackupableDBOptions::max_valid_backups_to_open` to not delete backup files when refcount cannot be accurately determined.
-* Fix memory leak when pin_l0_filter_and_index_blocks_in_cache is used with partitioned filters
-* Disable rollback of merge operands in WritePrepared transactions to work around an issue in MyRocks. It can be enabled back by setting TransactionDBOptions::rollback_merge_operands to true.
-
-### Java API Changes
-* Add `BlockBasedTableConfig.setBlockCache` to allow sharing a block cache across DB instances.
-* Added SstFileManager to the Java API to allow managing SST files 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)
@@ -102,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
@@ -76,9 +76,7 @@ ifeq ($(MAKECMDGOALS),install)
 endif

 ifeq ($(MAKECMDGOALS),rocksdbjavastatic)
-	ifneq ($(DEBUG_LEVEL),2)
-		DEBUG_LEVEL=0
-	endif
+	DEBUG_LEVEL=0
 endif

 ifeq ($(MAKECMDGOALS),rocksdbjavastaticrelease)
@@ -224,9 +222,6 @@ ifdef COMPILE_WITH_TSAN
 	PROFILING_FLAGS =
 	# LUA is not supported under TSAN
 	LUA_PATH =
-	# Limit keys for crash test under TSAN to avoid error:
-	# "ThreadSanitizer: DenseSlabAllocator overflow. Dying."
-	CRASH_TEST_EXT_ARGS += --max_key=1000000
 endif

 # AIX doesn't work with -pg
@@ -237,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
@@ -281,11 +272,7 @@ endif
 default: all

 WARNING_FLAGS = -W -Wextra -Wall -Wsign-compare -Wshadow \
-  -Wunused-parameter
-
-ifeq ($(PLATFORM), OS_OPENBSD)
-	WARNING_FLAGS += -Wno-unused-lambda-capture
-endif
+  -Wno-unused-parameter

 ifndef DISABLE_WARNING_AS_ERROR
 	WARNING_FLAGS += -Werror
@@ -415,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 \
@@ -479,7 +467,6 @@ TESTS = \
 	write_batch_with_index_test \
 	write_controller_test\
 	deletefile_test \
-	obsolete_files_test \
 	table_test \
 	geodb_test \
 	delete_scheduler_test \
@@ -517,7 +504,6 @@ TESTS = \
 	repair_test \
 	env_timed_test \
 	write_prepared_transaction_test \
-	db_universal_compaction_test \

 PARALLEL_TEST = \
 	backupable_db_test \
@@ -537,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)/')
@@ -648,7 +630,7 @@ ifeq ($(HAVE_POWER8),1)
 shared_all_libobjects = $(shared_libobjects) $(shared-ppc-objects)
 endif
 $(SHARED4): $(shared_all_libobjects)
-	$(CXX) $(PLATFORM_SHARED_LDFLAGS)$(SHARED3) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) $(shared_all_libobjects) $(LDFLAGS) -o $@
+	$(CXX) $(PLATFORM_SHARED_LDFLAGS)$(SHARED3) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) $(shared_libobjects) $(LDFLAGS) -o $@

 endif  # PLATFORM_SHARED_EXT

@@ -684,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),
@@ -801,7 +783,7 @@ check_0:
 	  | grep -E '$(tests-regexp)'					\
 	  | build_tools/gnu_parallel -j$(J) --plain --joblog=LOG $$eta --gnu '{} >& t/log-{/}'

-valgrind-blacklist-regexp = InlineSkipTest.ConcurrentInsert|TransactionTest.DeadlockStress|DBCompactionTest.SuggestCompactRangeNoTwoLevel0Compactions|BackupableDBTest.RateLimiting|DBTest.CloseSpeedup|DBTest.ThreadStatusFlush|DBTest.RateLimitingTest|DBTest.EncodeDecompressedBlockSizeTest|FaultInjectionTest.UninstalledCompaction|HarnessTest.Randomized|ExternalSSTFileTest.CompactDuringAddFileRandom|ExternalSSTFileTest.IngestFileWithGlobalSeqnoRandomized|MySQLStyleTransactionTest.TransactionStressTest
+valgrind-blacklist-regexp = InlineSkipTest.ConcurrentInsert|TransactionTest.DeadlockStress|DBCompactionTest.SuggestCompactRangeNoTwoLevel0Compactions|BackupableDBTest.RateLimiting|DBTest.CloseSpeedup|DBTest.ThreadStatusFlush|DBTest.RateLimitingTest|DBTest.EncodeDecompressedBlockSizeTest|FaultInjectionTest.UninstalledCompaction|HarnessTest.Randomized|ExternalSSTFileTest.CompactDuringAddFileRandom|ExternalSSTFileTest.IngestFileWithGlobalSeqnoRandomized

 .PHONY: valgrind_check_0
 valgrind_check_0:
@@ -831,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.
@@ -996,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:
@@ -1386,9 +1368,6 @@ options_file_test: db/options_file_test.o $(LIBOBJECTS) $(TESTHARNESS)
 deletefile_test: db/deletefile_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-obsolete_files_test: db/obsolete_files_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 geodb_test: utilities/geodb/geodb_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

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

@@ -1553,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
@@ -1589,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
@@ -1618,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)
@@ -1650,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\"; \
@@ -1663,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 \
@@ -1676,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 \
@@ -1724,9 +1691,7 @@ rocksdbjavastatic: $(java_static_all_libobjects)
 	  -o ./java/target/$(ROCKSDBJNILIB) $(JNI_NATIVE_SOURCES) \
 	  $(java_static_all_libobjects) $(COVERAGEFLAGS) \
 	  $(JAVA_COMPRESSIONS) $(JAVA_STATIC_LDFLAGS)
-	cd java/target;if [ "$(DEBUG_LEVEL)" == "0" ]; then \
-		strip $(STRIPFLAGS) $(ROCKSDBJNILIB); \
-	fi
+	cd java/target;strip $(STRIPFLAGS) $(ROCKSDBJNILIB)
 	cd java;jar -cf target/$(ROCKSDB_JAR) HISTORY*.md
 	cd java/target;jar -uf $(ROCKSDB_JAR) $(ROCKSDBJNILIB)
 	cd java/target/classes;jar -uf ../$(ROCKSDB_JAR) org/rocksdb/*.class org/rocksdb/util/*.class
@@ -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
@@ -25,10 +25,6 @@ rocksdb_compiler_flags = [
    "-DTBB",
    # Needed to compile in fbcode
    "-Wno-expansion-to-defined",
-    # Added missing flags from output of build_detect_platform
-    "-DROCKSDB_PTHREAD_ADAPTIVE_MUTEX",
-    "-DROCKSDB_BACKTRACE",
-    "-Wshorten-64-to-32",
 ]

 rocksdb_external_deps = [
@@ -50,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")
@@ -103,7 +96,6 @@ cpp_library(
        "db/internal_stats.cc",
        "db/log_reader.cc",
        "db/log_writer.cc",
-        "db/logs_with_prep_tracker.cc",
        "db/malloc_stats.cc",
        "db/managed_iterator.cc",
        "db/memtable.cc",
@@ -220,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",
@@ -252,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",
@@ -830,11 +819,6 @@ ROCKS_TESTS = [
        "utilities/object_registry_test.cc",
        "serial",
    ],
-    [
-        "obsolete_files_test",
-        "db/obsolete_files_test.cc",
-        "serial",
-    ],
    [
        "optimistic_transaction_test",
        "utilities/transactions/optimistic_transaction_test.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"
@@ -29,10 +29,6 @@ rocksdb_compiler_flags = [
    "-DTBB",
    # Needed to compile in fbcode
    "-Wno-expansion-to-defined",
-    # Added missing flags from output of build_detect_platform
-    "-DROCKSDB_PTHREAD_ADAPTIVE_MUTEX",
-    "-DROCKSDB_BACKTRACE",
-    "-Wshorten-64-to-32",
 ]

 rocksdb_external_deps = [
@@ -54,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,23 +64,11 @@ rm -f "$OUTPUT"
 touch "$OUTPUT"

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

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

 # Detect OS
@@ -99,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}"
@@ -144,8 +122,6 @@ case "$TARGET_OS" in
        COMMON_FLAGS="$COMMON_FLAGS -DOS_LINUX"
        if [ -z "$USE_CLANG" ]; then
            COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp"
-        else
-            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic"
        fi
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt"
        # PORT_FILES=port/linux/linux_specific.cc
@@ -178,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
@@ -198,8 +171,6 @@ case "$TARGET_OS" in
        COMMON_FLAGS="$COMMON_FLAGS -DCYGWIN"
        if [ -z "$USE_CLANG" ]; then
            COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp"
-        else
-            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic"
        fi
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt"
        # PORT_FILES=port/linux/linux_specific.cc
@@ -514,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"
@@ -604,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
@@ -52,7 +52,7 @@ namespace rocksdb {

 class CacheBench;
 namespace {
-void deleter(const Slice& /*key*/, void* value) {
+void deleter(const Slice& key, void* value) {
    delete reinterpret_cast<char *>(value);
 }

@@ -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
@@ -13,8 +13,8 @@

 namespace rocksdb {

-std::shared_ptr<Cache> NewClockCache(size_t /*capacity*/, int /*num_shard_bits*/,
-                                     bool /*strict_capacity_limit*/) {
+std::shared_ptr<Cache> NewClockCache(size_t capacity, int num_shard_bits,
+                                     bool strict_capacity_limit) {
  // Clock cache not supported.
  return nullptr;
 }
@@ -367,9 +367,7 @@ ClockCacheShard::~ClockCacheShard() {
  for (auto& handle : list_) {
    uint32_t flags = handle.flags.load(std::memory_order_relaxed);
    if (InCache(flags) || CountRefs(flags) > 0) {
-      if (handle.deleter != nullptr) {
-        (*handle.deleter)(handle.key, handle.value);
-      }
+      (*handle.deleter)(handle.key, handle.value);
      delete[] handle.key.data();
    }
  }
@@ -588,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);
 }
@@ -5,17 +5,13 @@
 # TBB_LIBRARIES - List of libraries when using TBB.
 # TBB_FOUND - True if TBB found.

-if(NOT DEFINED TBB_ROOT_DIR)
-  set(TBB_ROOT_DIR "$ENV{TBBROOT}")
-endif()
-
 find_path(TBB_INCLUDE_DIR
 NAMES tbb/tbb.h
 HINTS ${TBB_ROOT_DIR}/include)

 find_library(TBB_LIBRARIES
 NAMES tbb
-HINTS ${TBB_ROOT_DIR}/lib ENV LIBRARY_PATH)
+HINTS ${TBB_ROOT_DIR}/lib)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(TBB DEFAULT_MSG TBB_LIBRARIES TBB_INCLUDE_DIR)
@@ -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,
@@ -92,7 +92,7 @@ Status BuildTable(
    return s;
  }

-  std::string fname = TableFileName(ioptions.cf_paths, meta->fd.GetNumber(),
+  std::string fname = TableFileName(ioptions.db_paths, meta->fd.GetNumber(),
                                    meta->fd.GetPathId());
 #ifndef ROCKSDB_LITE
  EventHelpers::NotifyTableFileCreationStarted(
@@ -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,10 +100,6 @@ using rocksdb::OptimisticTransactionDB;
 using rocksdb::OptimisticTransactionOptions;
 using rocksdb::Transaction;
 using rocksdb::Checkpoint;
-using rocksdb::TransactionLogIterator;
-using rocksdb::BatchResult;
-using rocksdb::PerfLevel;
-using rocksdb::PerfContext;

 using std::shared_ptr;

@@ -137,8 +131,6 @@ struct rocksdb_cuckoo_table_options_t  { CuckooTableOptions rep; };
 struct rocksdb_seqfile_t         { SequentialFile*   rep; };
 struct rocksdb_randomfile_t      { RandomAccessFile* rep; };
 struct rocksdb_writablefile_t    { WritableFile*     rep; };
-struct rocksdb_wal_iterator_t { TransactionLogIterator* rep; };
-struct rocksdb_wal_readoptions_t { TransactionLogIterator::ReadOptions rep; };
 struct rocksdb_filelock_t        { FileLock*         rep; };
 struct rocksdb_logger_t          { shared_ptr<Logger>  rep; };
 struct rocksdb_cache_t           { shared_ptr<Cache>   rep; };
@@ -147,8 +139,7 @@ struct rocksdb_column_family_handle_t  { ColumnFamilyHandle* rep; };
 struct rocksdb_envoptions_t      { EnvOptions        rep; };
 struct rocksdb_ingestexternalfileoptions_t  { IngestExternalFileOptions rep; };
 struct rocksdb_sstfilewriter_t   { SstFileWriter*    rep; };
-struct rocksdb_ratelimiter_t     { shared_ptr<RateLimiter>      rep; };
-struct rocksdb_perfcontext_t     { PerfContext*      rep; };
+struct rocksdb_ratelimiter_t     { RateLimiter*      rep; };
 struct rocksdb_pinnableslice_t {
  PinnableSlice rep;
 };
@@ -261,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 {
@@ -376,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);
@@ -486,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,
@@ -934,54 +911,6 @@ rocksdb_iterator_t* rocksdb_create_iterator(
  return result;
 }

-rocksdb_wal_iterator_t* rocksdb_get_updates_since(
-        rocksdb_t* db, uint64_t seq_number,
-        const rocksdb_wal_readoptions_t* options,
-        char** errptr) {
-  std::unique_ptr<TransactionLogIterator> iter;
-  TransactionLogIterator::ReadOptions ro;
-  if (options!=nullptr) {
-      ro = options->rep;
-  }
-  if (SaveError(errptr, db->rep->GetUpdatesSince(seq_number, &iter, ro))) {
-    return nullptr;
-  }
-  rocksdb_wal_iterator_t* result = new rocksdb_wal_iterator_t;
-  result->rep = iter.release();
-  return result;
-}
-
-void rocksdb_wal_iter_next(rocksdb_wal_iterator_t* iter) {
-    iter->rep->Next();
-}
-
-unsigned char rocksdb_wal_iter_valid(const rocksdb_wal_iterator_t* iter) {
-    return iter->rep->Valid();
-}
-
-void rocksdb_wal_iter_status (const rocksdb_wal_iterator_t* iter, char** errptr) {
-    SaveError(errptr, iter->rep->status());
-}
-
-void rocksdb_wal_iter_destroy (const rocksdb_wal_iterator_t* iter) {
-  delete iter->rep;
-  delete iter;
-}
-
-rocksdb_writebatch_t* rocksdb_wal_iter_get_batch (const rocksdb_wal_iterator_t* iter, uint64_t* seq) {
-  rocksdb_writebatch_t* result = rocksdb_writebatch_create();
-  BatchResult wal_batch = iter->rep->GetBatch();
-  result->rep = * wal_batch.writeBatchPtr.release();
-  if (seq != nullptr) {
-    *seq = wal_batch.sequence;
-  }
-  return result;
-}
-
-uint64_t rocksdb_get_latest_sequence_number (rocksdb_t *db) {
-    return db->rep->GetLatestSequenceNumber();
-}
-
 rocksdb_iterator_t* rocksdb_create_iterator_cf(
    rocksdb_t* db,
    const rocksdb_readoptions_t* options,
@@ -1459,24 +1388,23 @@ void rocksdb_writebatch_put_log_data(
  b->rep.PutLogData(Slice(blob, len));
 }

-class H : public WriteBatch::Handler {
- public:
-  void* state_;
-  void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen);
-  void (*deleted_)(void*, const char* k, size_t klen);
-  virtual void Put(const Slice& key, const Slice& value) override {
-    (*put_)(state_, key.data(), key.size(), value.data(), value.size());
-  }
-  virtual void Delete(const Slice& key) override {
-    (*deleted_)(state_, key.data(), key.size());
-  }
-};
-
 void rocksdb_writebatch_iterate(
    rocksdb_writebatch_t* b,
    void* state,
    void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
    void (*deleted)(void*, const char* k, size_t klen)) {
+  class H : public WriteBatch::Handler {
+   public:
+    void* state_;
+    void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen);
+    void (*deleted_)(void*, const char* k, size_t klen);
+    virtual void Put(const Slice& key, const Slice& value) override {
+      (*put_)(state_, key.data(), key.size(), value.data(), value.size());
+    }
+    virtual void Delete(const Slice& key) override {
+      (*deleted_)(state_, key.data(), key.size());
+    }
+  };
  H handler;
  handler.state_ = state;
  handler.put_ = put;
@@ -1721,6 +1649,18 @@ void rocksdb_writebatch_wi_iterate(
    void* state,
    void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
    void (*deleted)(void*, const char* k, size_t klen)) {
+  class H : public WriteBatch::Handler {
+   public:
+    void* state_;
+    void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen);
+    void (*deleted_)(void*, const char* k, size_t klen);
+    virtual void Put(const Slice& key, const Slice& value) override {
+      (*put_)(state_, key.data(), key.size(), value.data(), value.size());
+    }
+    virtual void Delete(const Slice& key) override {
+      (*deleted_)(state_, key.data(), key.size());
+    }
+  };
  H handler;
  handler.state_ = state;
  handler.put_ = put;
@@ -2226,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);
@@ -2291,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) {
@@ -2462,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
 }

@@ -2576,9 +2516,8 @@ char *rocksdb_options_statistics_get_string(rocksdb_options_t *opt) {
 }

 void rocksdb_options_set_ratelimiter(rocksdb_options_t *opt, rocksdb_ratelimiter_t *limiter) {
-  if (limiter) {
-    opt->rep.rate_limiter = limiter->rep;
-  }
+  opt->rep.rate_limiter.reset(limiter->rep);
+  limiter->rep = nullptr;
 }

 rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
@@ -2586,184 +2525,16 @@ rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
    int64_t refill_period_us,
    int32_t fairness) {
  rocksdb_ratelimiter_t* rate_limiter = new rocksdb_ratelimiter_t;
-  rate_limiter->rep.reset(
-               NewGenericRateLimiter(rate_bytes_per_sec,
-                                     refill_period_us, fairness));
+  rate_limiter->rep = NewGenericRateLimiter(rate_bytes_per_sec,
+                                            refill_period_us, fairness);
  return rate_limiter;
 }

 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;
+  if (limiter->rep) {
+    delete limiter->rep;
  }
-  return 0;
-}
-
-void rocksdb_perfcontext_destroy(rocksdb_perfcontext_t* context) {
-  delete context;
+  delete limiter;
 }

 /*
@@ -3202,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;
@@ -3240,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) {
@@ -3338,21 +3109,20 @@ void rocksdb_slicetransform_destroy(rocksdb_slicetransform_t* st) {
  delete st;
 }

-struct Wrapper : public rocksdb_slicetransform_t {
-  const SliceTransform* rep_;
-  ~Wrapper() { delete rep_; }
-  const char* Name() const override { return rep_->Name(); }
-  Slice Transform(const Slice& src) const override {
-    return rep_->Transform(src);
-  }
-  bool InDomain(const Slice& src) const override {
-    return rep_->InDomain(src);
-  }
-  bool InRange(const Slice& src) const override { return rep_->InRange(src); }
-  static void DoNothing(void*) { }
-};
-
 rocksdb_slicetransform_t* rocksdb_slicetransform_create_fixed_prefix(size_t prefixLen) {
+  struct Wrapper : public rocksdb_slicetransform_t {
+    const SliceTransform* rep_;
+    ~Wrapper() { delete rep_; }
+    const char* Name() const override { return rep_->Name(); }
+    Slice Transform(const Slice& src) const override {
+      return rep_->Transform(src);
+    }
+    bool InDomain(const Slice& src) const override {
+      return rep_->InDomain(src);
+    }
+    bool InRange(const Slice& src) const override { return rep_->InRange(src); }
+    static void DoNothing(void*) { }
+  };
  Wrapper* wrapper = new Wrapper;
  wrapper->rep_ = rocksdb::NewFixedPrefixTransform(prefixLen);
  wrapper->state_ = nullptr;
@@ -3361,6 +3131,19 @@ rocksdb_slicetransform_t* rocksdb_slicetransform_create_fixed_prefix(size_t pref
 }

 rocksdb_slicetransform_t* rocksdb_slicetransform_create_noop() {
+  struct Wrapper : public rocksdb_slicetransform_t {
+    const SliceTransform* rep_;
+    ~Wrapper() { delete rep_; }
+    const char* Name() const override { return rep_->Name(); }
+    Slice Transform(const Slice& src) const override {
+      return rep_->Transform(src);
+    }
+    bool InDomain(const Slice& src) const override {
+      return rep_->InDomain(src);
+    }
+    bool InRange(const Slice& src) const override { return rep_->InRange(src); }
+    static void DoNothing(void*) { }
+  };
  Wrapper* wrapper = new Wrapper;
  wrapper->rep_ = rocksdb::NewNoopTransform();
  wrapper->state_ = nullptr;
@@ -4010,7 +3793,7 @@ rocksdb_pinnableslice_t* rocksdb_get_pinned(
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
-    return nullptr;
+    return NULL;
  }
  return v;
 }
@@ -4027,7 +3810,7 @@ rocksdb_pinnableslice_t* rocksdb_get_pinned_cf(
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
-    return nullptr;
+    return NULL;
  }
  return v;
 }
@@ -4038,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();
@@ -192,11 +192,10 @@ static void CheckDel(void* ptr, const char* k, size_t klen) {
  (*state)++;
 }

-static void CmpDestroy(void* arg) { (void)arg; }
+static void CmpDestroy(void* arg) { }

 static int CmpCompare(void* arg, const char* a, size_t alen,
                      const char* b, size_t blen) {
-  (void)arg;
  size_t n = (alen < blen) ? alen : blen;
  int r = memcmp(a, b, n);
  if (r == 0) {
@@ -207,15 +206,13 @@ static int CmpCompare(void* arg, const char* a, size_t alen,
 }

 static const char* CmpName(void* arg) {
-  (void)arg;
  return "foo";
 }

 // Custom filter policy
 static unsigned char fake_filter_result = 1;
-static void FilterDestroy(void* arg) { (void)arg; }
+static void FilterDestroy(void* arg) { }
 static const char* FilterName(void* arg) {
-  (void)arg;
  return "TestFilter";
 }
 static char* FilterCreate(
@@ -223,10 +220,6 @@ static char* FilterCreate(
    const char* const* key_array, const size_t* key_length_array,
    int num_keys,
    size_t* filter_length) {
-  (void)arg;
-  (void)key_array;
-  (void)key_length_array;
-  (void)num_keys;
  *filter_length = 4;
  char* result = malloc(4);
  memcpy(result, "fake", 4);
@@ -236,30 +229,20 @@ static unsigned char FilterKeyMatch(
    void* arg,
    const char* key, size_t length,
    const char* filter, size_t filter_length) {
-  (void)arg;
-  (void)key;
-  (void)length;
  CheckCondition(filter_length == 4);
  CheckCondition(memcmp(filter, "fake", 4) == 0);
  return fake_filter_result;
 }

 // Custom compaction filter
-static void CFilterDestroy(void* arg) { (void)arg; }
-static const char* CFilterName(void* arg) {
-  (void)arg;
-  return "foo";
-}
+static void CFilterDestroy(void* arg) {}
+static const char* CFilterName(void* arg) { return "foo"; }
 static unsigned char CFilterFilter(void* arg, int level, const char* key,
                                   size_t key_length,
                                   const char* existing_value,
                                   size_t value_length, char** new_value,
                                   size_t* new_value_length,
                                   unsigned char* value_changed) {
-  (void)arg;
-  (void)level;
-  (void)existing_value;
-  (void)value_length;
  if (key_length == 3) {
    if (memcmp(key, "bar", key_length) == 0) {
      return 1;
@@ -273,15 +256,10 @@ static unsigned char CFilterFilter(void* arg, int level, const char* key,
  return 0;
 }

-static void CFilterFactoryDestroy(void* arg) { (void)arg; }
-static const char* CFilterFactoryName(void* arg) {
-  (void)arg;
-  return "foo";
-}
+static void CFilterFactoryDestroy(void* arg) {}
+static const char* CFilterFactoryName(void* arg) { return "foo"; }
 static rocksdb_compactionfilter_t* CFilterCreate(
    void* arg, rocksdb_compactionfiltercontext_t* context) {
-  (void)arg;
-  (void)context;
  return rocksdb_compactionfilter_create(NULL, CFilterDestroy, CFilterFilter,
                                         CFilterName);
 }
@@ -312,9 +290,8 @@ static rocksdb_t* CheckCompaction(rocksdb_t* db, rocksdb_options_t* options,
 }

 // Custom merge operator
-static void MergeOperatorDestroy(void* arg) { (void)arg; }
+static void MergeOperatorDestroy(void* arg) { }
 static const char* MergeOperatorName(void* arg) {
-  (void)arg;
  return "TestMergeOperator";
 }
 static char* MergeOperatorFullMerge(
@@ -324,14 +301,6 @@ static char* MergeOperatorFullMerge(
    const char* const* operands_list, const size_t* operands_list_length,
    int num_operands,
    unsigned char* success, size_t* new_value_length) {
-  (void)arg;
-  (void)key;
-  (void)key_length;
-  (void)existing_value;
-  (void)existing_value_length;
-  (void)operands_list;
-  (void)operands_list_length;
-  (void)num_operands;
  *new_value_length = 4;
  *success = 1;
  char* result = malloc(4);
@@ -344,12 +313,6 @@ static char* MergeOperatorPartialMerge(
    const char* const* operands_list, const size_t* operands_list_length,
    int num_operands,
    unsigned char* success, size_t* new_value_length) {
-  (void)arg;
-  (void)key;
-  (void)key_length;
-  (void)operands_list;
-  (void)operands_list_length;
-  (void)num_operands;
  *new_value_length = 4;
  *success = 1;
  char* result = malloc(4);
@@ -414,8 +377,6 @@ static void CheckTxnDBGetCF(rocksdb_transactiondb_t* txn_db,
 }

 int main(int argc, char** argv) {
-  (void)argc;
-  (void)argv;
  rocksdb_t* db;
  rocksdb_comparator_t* cmp;
  rocksdb_cache_t* cache;
@@ -31,10 +31,8 @@
 #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"
-#include "util/sst_file_manager_impl.h"

 namespace rocksdb {

@@ -55,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()) {
@@ -85,7 +80,6 @@ Status ColumnFamilyHandleImpl::GetDescriptor(ColumnFamilyDescriptor* desc) {
  *desc = ColumnFamilyDescriptor(cfd()->GetName(), cfd()->GetLatestCFOptions());
  return Status::OK();
 #else
-  (void)desc;
  return Status::NotSupported();
 #endif  // !ROCKSDB_LITE
 }
@@ -161,28 +155,6 @@ Status CheckConcurrentWritesSupported(const ColumnFamilyOptions& cf_options) {
  return Status::OK();
 }

-Status CheckCFPathsSupported(const DBOptions& db_options,
-                             const ColumnFamilyOptions& cf_options) {
-  // More than one cf_paths are supported only in universal
-  // and level compaction styles. This function also checks the case
-  // in which cf_paths is not specified, which results in db_paths
-  // being used.
-  if ((cf_options.compaction_style != kCompactionStyleUniversal) &&
-      (cf_options.compaction_style != kCompactionStyleLevel)) {
-    if (cf_options.cf_paths.size() > 1) {
-      return Status::NotSupported(
-          "More than one CF paths are only supported in "
-          "universal and level compaction styles. ");
-    } else if (cf_options.cf_paths.empty() &&
-               db_options.db_paths.size() > 1) {
-      return Status::NotSupported(
-          "More than one DB paths are only supported in "
-          "universal and level compaction styles. ");
-    }
-  }
-  return Status::OK();
-}
-
 ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
                                    const ColumnFamilyOptions& src) {
  ColumnFamilyOptions result = src;
@@ -301,24 +273,9 @@ ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
        result.hard_pending_compaction_bytes_limit;
  }

-#ifndef ROCKSDB_LITE
-  // When the DB is stopped, it's possible that there are some .trash files that
-  // were not deleted yet, when we open the DB we will find these .trash files
-  // and schedule them to be deleted (or delete immediately if SstFileManager
-  // was not used)
-  auto sfm = static_cast<SstFileManagerImpl*>(db_options.sst_file_manager.get());
-  for (size_t i = 0; i < result.cf_paths.size(); i++) {
-    DeleteScheduler::CleanupDirectory(db_options.env, sfm, result.cf_paths[i].path);
-  }
-#endif
-
-  if (result.cf_paths.empty()) {
-    result.cf_paths = db_options.db_paths;
-  }
-
  if (result.level_compaction_dynamic_level_bytes) {
    if (result.compaction_style != kCompactionStyleLevel ||
-        result.cf_paths.size() > 1U) {
+        db_options.db_paths.size() > 1U) {
      // 1. level_compaction_dynamic_level_bytes only makes sense for
      //    level-based compaction.
      // 2. we don't yet know how to make both of this feature and multiple
@@ -387,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

@@ -425,10 +381,9 @@ ColumnFamilyData::ColumnFamilyData(
      next_(nullptr),
      prev_(nullptr),
      log_number_(0),
-      flush_reason_(FlushReason::kOthers),
      column_family_set_(column_family_set),
-      queued_for_flush_(false),
-      queued_for_compaction_(false),
+      pending_flush_(false),
+      pending_compaction_(false),
      prev_compaction_needed_bytes_(0),
      allow_2pc_(db_options.allow_2pc),
      last_memtable_id_(0) {
@@ -504,8 +459,8 @@ ColumnFamilyData::~ColumnFamilyData() {

  // It would be wrong if this ColumnFamilyData is in flush_queue_ or
  // compaction_queue_ and we destroyed it
-  assert(!queued_for_flush_);
-  assert(!queued_for_compaction_);
+  assert(!pending_flush_);
+  assert(!pending_compaction_);

  if (super_version_ != nullptr) {
    // Release SuperVersion reference kept in ThreadLocalPtr.
@@ -514,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();
@@ -525,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);
  }
@@ -558,9 +513,7 @@ uint64_t ColumnFamilyData::OldestLogToKeep() {
  auto current_log = GetLogNumber();

  if (allow_2pc_) {
-    autovector<MemTable*> empty_list;
-    auto imm_prep_log =
-        imm()->PrecomputeMinLogContainingPrepSection(empty_list);
+    auto imm_prep_log = imm()->GetMinLogContainingPrepSection();
    auto mem_prep_log = mem()->GetMinLogContainingPrepSection();

    if (imm_prep_log > 0 && imm_prep_log < current_log) {
@@ -678,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;
@@ -722,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);
@@ -752,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 "
@@ -777,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;
@@ -788,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);
@@ -797,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.
@@ -816,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 "
@@ -823,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,
@@ -890,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,
@@ -930,80 +850,16 @@ 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;

 Compaction* ColumnFamilyData::CompactRange(
    const MutableCFOptions& mutable_cf_options, int input_level,
-    int output_level, uint32_t output_path_id, uint32_t max_subcompactions,
-    const InternalKey* begin, const InternalKey* end,
-    InternalKey** compaction_end, bool* conflict) {
+    int output_level, uint32_t output_path_id, const InternalKey* begin,
+    const InternalKey* end, InternalKey** compaction_end, bool* conflict) {
  auto* result = compaction_picker_->CompactRange(
      GetName(), mutable_cf_options, current_->storage_info(), input_level,
-      output_level, output_path_id, max_subcompactions, begin, end,
-      compaction_end, conflict);
+      output_level, output_path_id, begin, end, compaction_end, conflict);
  if (result != nullptr) {
    result->SetInputVersion(current_);
  }
@@ -1012,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()
@@ -1026,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
@@ -1044,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);
@@ -1108,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);
@@ -1129,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() {
@@ -1140,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;
+    }
  }
 }

@@ -1153,9 +1006,8 @@ void ColumnFamilyData::ResetThreadLocalSuperVersions() {
 Status ColumnFamilyData::SetOptions(
      const std::unordered_map<std::string, std::string>& options_map) {
  MutableCFOptions new_mutable_cf_options;
-  Status s =
-      GetMutableOptionsFromStrings(mutable_cf_options_, options_map,
-                                   ioptions_.info_log, &new_mutable_cf_options);
+  Status s = GetMutableOptionsFromStrings(mutable_cf_options_, options_map,
+                                          &new_mutable_cf_options);
  if (s.ok()) {
    mutable_cf_options_ = new_mutable_cf_options;
    mutable_cf_options_.RefreshDerivedOptions(ioptions_);
@@ -1182,31 +1034,6 @@ Env::WriteLifeTimeHint ColumnFamilyData::CalculateSSTWriteHint(int level) {
                            static_cast<int>(Env::WLTH_MEDIUM));
 }

-Status ColumnFamilyData::AddDirectories() {
-  Status s;
-  assert(data_dirs_.empty());
-  for (auto& p : ioptions_.cf_paths) {
-    std::unique_ptr<Directory> path_directory;
-    s = DBImpl::CreateAndNewDirectory(ioptions_.env, p.path, &path_directory);
-    if (!s.ok()) {
-      return s;
-    }
-    assert(path_directory != nullptr);
-    data_dirs_.emplace_back(path_directory.release());
-  }
-  assert(data_dirs_.size() == ioptions_.cf_paths.size());
-  return s;
-}
-
-Directory* ColumnFamilyData::GetDataDir(size_t path_id) const {
-  if (data_dirs_.empty()) {
-    return nullptr;
-  }
-
-  assert(path_id < data_dirs_.size());
-  return data_dirs_[path_id].get();
-}
-
 ColumnFamilySet::ColumnFamilySet(const std::string& dbname,
                                 const ImmutableDBOptions* db_options,
                                 const EnvOptions& env_options,
@@ -1233,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;
@@ -139,9 +138,6 @@ extern Status CheckCompressionSupported(const ColumnFamilyOptions& cf_options);
 extern Status CheckConcurrentWritesSupported(
    const ColumnFamilyOptions& cf_options);

-extern Status CheckCFPathsSupported(const DBOptions& db_options,
-                                    const ColumnFamilyOptions& cf_options);
-
 extern ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
                                           const ColumnFamilyOptions& src);
 // Wrap user defined table proproties collector factories `from cf_options`
@@ -206,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_; }
@@ -247,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);
@@ -278,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;
@@ -296,9 +277,9 @@ class ColumnFamilyData {
  // REQUIRES: DB mutex held
  Compaction* CompactRange(const MutableCFOptions& mutable_cf_options,
                           int input_level, int output_level,
-                           uint32_t output_path_id, uint32_t max_subcompactions,
-                           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);

  CompactionPicker* compaction_picker() { return compaction_picker_.get(); }
  // thread-safe
@@ -345,21 +326,10 @@ class ColumnFamilyData {
  void ResetThreadLocalSuperVersions();

  // Protected by DB mutex
-  void set_queued_for_flush(bool value) { queued_for_flush_ = value; }
-  void set_queued_for_compaction(bool value) { queued_for_compaction_ = value; }
-  bool queued_for_flush() { return queued_for_flush_; }
-  bool queued_for_compaction() { return queued_for_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);
+  void set_pending_flush(bool value) { pending_flush_ = value; }
+  void set_pending_compaction(bool value) { pending_compaction_ = value; }
+  bool pending_flush() { return pending_flush_; }
+  bool pending_compaction() { return pending_compaction_; }

  // Recalculate some small conditions, which are changed only during
  // compaction, adding new memtable and/or
@@ -373,16 +343,8 @@ class ColumnFamilyData {

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

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

-  Status AddDirectories();
-
-  Directory* GetDataDir(size_t path_id) const;
-
 private:
  friend class ColumnFamilySet;
  ColumnFamilyData(uint32_t id, const std::string& name,
@@ -442,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_;
@@ -453,11 +413,11 @@ class ColumnFamilyData {
  std::unique_ptr<WriteControllerToken> write_controller_token_;

  // If true --> this ColumnFamily is currently present in DBImpl::flush_queue_
-  bool queued_for_flush_;
+  bool pending_flush_;

  // If true --> this ColumnFamily is currently present in
  // DBImpl::compaction_queue_
-  bool queued_for_compaction_;
+  bool pending_compaction_;

  uint64_t prev_compaction_needed_bytes_;

@@ -466,9 +426,6 @@ class ColumnFamilyData {

  // Memtable id to track flush.
  std::atomic<uint64_t> last_memtable_id_;
-
-  // Directories corresponding to cf_paths.
-  std::vector<std::unique_ptr<Directory>> data_dirs_;
 };

 // ColumnFamilySet has interesting thread-safety requirements
@@ -69,15 +69,9 @@ class ColumnFamilyTest : public testing::Test {
  }

  ~ColumnFamilyTest() {
-    std::vector<ColumnFamilyDescriptor> column_families;
-    for (auto h : handles_) {
-      ColumnFamilyDescriptor cfdescriptor;
-      h->GetDescriptor(&cfdescriptor);
-      column_families.push_back(cfdescriptor);
-    }
    Close();
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-    Destroy(column_families);
+    Destroy();
    delete env_;
  }

@@ -242,11 +236,9 @@ class ColumnFamilyTest : public testing::Test {
 #endif  // !ROCKSDB_LITE
  }

-  void Destroy(const std::vector<ColumnFamilyDescriptor>& column_families =
-                  std::vector<ColumnFamilyDescriptor>()) {
+  void Destroy() {
    Close();
-    ASSERT_OK(DestroyDB(dbname_, Options(db_options_, column_family_options_),
-                        column_families));
+    ASSERT_OK(DestroyDB(dbname_, Options(db_options_, column_family_options_)));
  }

  void CreateColumnFamilies(
@@ -391,9 +383,6 @@ class ColumnFamilyTest : public testing::Test {
  void AssertFilesPerLevel(const std::string& value, int cf) {
 #ifndef ROCKSDB_LITE
    ASSERT_EQ(value, FilesPerLevel(cf));
-#else
-    (void) value;
-    (void) cf;
 #endif
  }

@@ -408,8 +397,6 @@ class ColumnFamilyTest : public testing::Test {
  void AssertCountLiveFiles(int expected_value) {
 #ifndef ROCKSDB_LITE
    ASSERT_EQ(expected_value, CountLiveFiles());
-#else
-    (void) expected_value;
 #endif
  }

@@ -458,8 +445,6 @@ class ColumnFamilyTest : public testing::Test {
  void AssertCountLiveLogFiles(int value) {
 #ifndef ROCKSDB_LITE  // GetSortedWalFiles is not supported
    ASSERT_EQ(value, CountLiveLogFiles());
-#else
-    (void) value;
 #endif  // !ROCKSDB_LITE
  }

@@ -498,12 +483,6 @@ class ColumnFamilyTest : public testing::Test {
    ASSERT_OK(destfile->Close());
  }

-  int GetSstFileCount(std::string path) {
-    std::vector<std::string> files;
-    DBTestBase::GetSstFiles(env_, path, &files);
-    return static_cast<int>(files.size());
-  }
-
  std::vector<ColumnFamilyHandle*> handles_;
  std::vector<std::string> names_;
  std::set<std::string> keys_;
@@ -1189,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;
@@ -1368,7 +1346,7 @@ TEST_F(ColumnFamilyTest, MultipleManualCompactions) {
       {"ColumnFamilyTest::MultiManual:2", "ColumnFamilyTest::MultiManual:5"},
       {"ColumnFamilyTest::MultiManual:2", "ColumnFamilyTest::MultiManual:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (cf_1_1) {
          TEST_SYNC_POINT("ColumnFamilyTest::MultiManual:4");
          cf_1_1 = false;
@@ -1461,7 +1439,7 @@ TEST_F(ColumnFamilyTest, AutomaticAndManualCompactions) {
       {"ColumnFamilyTest::AutoManual:2", "ColumnFamilyTest::AutoManual:5"},
       {"ColumnFamilyTest::AutoManual:2", "ColumnFamilyTest::AutoManual:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (cf_1_1) {
          cf_1_1 = false;
          TEST_SYNC_POINT("ColumnFamilyTest::AutoManual:4");
@@ -1562,7 +1540,7 @@ TEST_F(ColumnFamilyTest, ManualAndAutomaticCompactions) {
       {"ColumnFamilyTest::ManualAuto:5", "ColumnFamilyTest::ManualAuto:2"},
       {"ColumnFamilyTest::ManualAuto:2", "ColumnFamilyTest::ManualAuto:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (cf_1_1) {
          TEST_SYNC_POINT("ColumnFamilyTest::ManualAuto:4");
          cf_1_1 = false;
@@ -1655,7 +1633,7 @@ TEST_F(ColumnFamilyTest, SameCFManualManualCompactions) {
       {"ColumnFamilyTest::ManualManual:1",
        "ColumnFamilyTest::ManualManual:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (cf_1_1) {
          TEST_SYNC_POINT("ColumnFamilyTest::ManualManual:4");
          cf_1_1 = false;
@@ -1753,7 +1731,7 @@ TEST_F(ColumnFamilyTest, SameCFManualAutomaticCompactions) {
       {"ColumnFamilyTest::ManualAuto:1", "ColumnFamilyTest::ManualAuto:2"},
       {"ColumnFamilyTest::ManualAuto:1", "ColumnFamilyTest::ManualAuto:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (cf_1_1) {
          TEST_SYNC_POINT("ColumnFamilyTest::ManualAuto:4");
          cf_1_1 = false;
@@ -1845,7 +1823,7 @@ TEST_F(ColumnFamilyTest, SameCFManualAutomaticCompactionsLevel) {
        "ColumnFamilyTest::ManualAuto:3"},
       {"ColumnFamilyTest::ManualAuto:1", "ColumnFamilyTest::ManualAuto:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (cf_1_1) {
          TEST_SYNC_POINT("ColumnFamilyTest::ManualAuto:4");
          cf_1_1 = false;
@@ -1932,7 +1910,7 @@ TEST_F(ColumnFamilyTest, SameCFAutomaticManualCompactions) {
       {"CompactionPicker::CompactRange:Conflict",
        "ColumnFamilyTest::AutoManual:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (cf_1_1) {
          TEST_SYNC_POINT("ColumnFamilyTest::AutoManual:4");
          cf_1_1 = false;
@@ -2379,7 +2357,7 @@ TEST_F(ColumnFamilyTest, CreateAndDropRace) {
  auto main_thread_id = std::this_thread::get_id();

  rocksdb::SyncPoint::GetInstance()->SetCallBack("PersistRocksDBOptions:start",
-                                                 [&](void* /*arg*/) {
+                                                 [&](void* arg) {
    auto current_thread_id = std::this_thread::get_id();
    // If it's the main thread hitting this sync-point, then it
    // will be blocked until some other thread update the test_stage.
@@ -2392,7 +2370,7 @@ TEST_F(ColumnFamilyTest, CreateAndDropRace) {
  });

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "WriteThread::EnterUnbatched:Wait", [&](void* /*arg*/) {
+      "WriteThread::EnterUnbatched:Wait", [&](void* arg) {
        // This means a thread doing DropColumnFamily() is waiting for
        // other thread to finish persisting options.
        // In such case, we update the test_stage to unblock the main thread.
@@ -2812,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());
@@ -3150,58 +3116,6 @@ TEST_F(ColumnFamilyTest, DISABLED_LogTruncationTest) {
  // cleanup
  env_->DeleteDir(backup_logs);
 }
-
-TEST_F(ColumnFamilyTest, DefaultCfPathsTest) {
-  Open();
-  // Leave cf_paths for one column families to be empty.
-  // Files should be generated according to db_paths for that
-  // column family.
-  ColumnFamilyOptions cf_opt1, cf_opt2;
-  cf_opt1.cf_paths.emplace_back(dbname_ + "_one_1",
-                                std::numeric_limits<uint64_t>::max());
-  CreateColumnFamilies({"one", "two"}, {cf_opt1, cf_opt2});
-  Reopen({ColumnFamilyOptions(), cf_opt1, cf_opt2});
-
-  // Fill Column family 1.
-  PutRandomData(1, 100, 100);
-  Flush(1);
-
-  ASSERT_EQ(1, GetSstFileCount(cf_opt1.cf_paths[0].path));
-  ASSERT_EQ(0, GetSstFileCount(dbname_));
-
-  // Fill column family 2
-  PutRandomData(2, 100, 100);
-  Flush(2);
-
-  // SST from Column family 2 should be generated in
-  // db_paths which is dbname_ in this case.
-  ASSERT_EQ(1, GetSstFileCount(dbname_));
-}
-
-TEST_F(ColumnFamilyTest, MultipleCFPathsTest) {
-  Open();
-  // Configure Column family specific paths.
-  ColumnFamilyOptions cf_opt1, cf_opt2;
-  cf_opt1.cf_paths.emplace_back(dbname_ + "_one_1",
-                                std::numeric_limits<uint64_t>::max());
-  cf_opt2.cf_paths.emplace_back(dbname_ + "_two_1",
-                                std::numeric_limits<uint64_t>::max());
-  CreateColumnFamilies({"one", "two"}, {cf_opt1, cf_opt2});
-  Reopen({ColumnFamilyOptions(), cf_opt1, cf_opt2});
-
-  PutRandomData(1, 100, 100);
-  Flush(1);
-
-  // Check that files are generated in appropriate paths.
-  ASSERT_EQ(1, GetSstFileCount(cf_opt1.cf_paths[0].path));
-  ASSERT_EQ(0, GetSstFileCount(dbname_));
-
-  PutRandomData(2, 100, 100);
-  Flush(2);
-
-  ASSERT_EQ(1, GetSstFileCount(cf_opt2.cf_paths[0].path));
-  ASSERT_EQ(0, GetSstFileCount(dbname_));
-}
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -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;
      }
@@ -318,7 +319,7 @@ int main(int argc, char** argv) {
 #else
 #include <stdio.h>

-int main(int /*argc*/, char** /*argv*/) {
+int main(int argc, char** argv) {
  fprintf(stderr,
          "SKIPPED as DBImpl::CompactFiles is not supported in ROCKSDB_LITE\n");
  return 0;
@@ -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.");
  }

@@ -134,7 +134,6 @@ Compaction::Compaction(VersionStorageInfo* vstorage,
                       int _output_level, uint64_t _target_file_size,
                       uint64_t _max_compaction_bytes, uint32_t _output_path_id,
                       CompressionType _compression,
-                       uint32_t _max_subcompactions,
                       std::vector<FileMetaData*> _grandparents,
                       bool _manual_compaction, double _score,
                       bool _deletion_compaction,
@@ -144,7 +143,6 @@ Compaction::Compaction(VersionStorageInfo* vstorage,
      output_level_(_output_level),
      max_output_file_size_(_target_file_size),
      max_compaction_bytes_(_max_compaction_bytes),
-      max_subcompactions_(_max_subcompactions),
      immutable_cf_options_(_immutable_cf_options),
      mutable_cf_options_(_mutable_cf_options),
      input_version_(nullptr),
@@ -165,9 +163,6 @@ Compaction::Compaction(VersionStorageInfo* vstorage,
  if (is_manual_compaction_) {
    compaction_reason_ = CompactionReason::kManualCompaction;
  }
-  if (max_subcompactions_ == 0) {
-    max_subcompactions_ = immutable_cf_options_.max_subcompactions;
-  }

 #ifndef NDEBUG
  for (size_t i = 1; i < inputs_.size(); ++i) {
@@ -447,12 +442,11 @@ bool Compaction::IsOutputLevelEmpty() const {
 }

 bool Compaction::ShouldFormSubcompactions() const {
-  if (max_subcompactions_ <= 1 || cfd_ == nullptr) {
+  if (immutable_cf_options_.max_subcompactions <= 1 || cfd_ == nullptr) {
    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 {
@@ -473,8 +467,4 @@ uint64_t Compaction::MaxInputFileCreationTime() const {
  return max_creation_time;
 }

-int Compaction::GetInputBaseLevel() const {
-  return input_vstorage_->base_level();
-}
-
 }  // namespace rocksdb
@@ -40,7 +40,6 @@ class Compaction {
             std::vector<CompactionInputFiles> inputs, int output_level,
             uint64_t target_file_size, uint64_t max_compaction_bytes,
             uint32_t output_path_id, CompressionType compression,
-             uint32_t max_subcompactions,
             std::vector<FileMetaData*> grandparents,
             bool manual_compaction = false, double score = -1,
             bool deletion_compaction = false,
@@ -234,8 +233,6 @@ class Compaction {

  Slice GetLargestUserKey() const { return largest_user_key_; }

-  int GetInputBaseLevel() const;
-
  CompactionReason compaction_reason() { return compaction_reason_; }

  const std::vector<FileMetaData*>& grandparents() const {
@@ -244,8 +241,6 @@ class Compaction {

  uint64_t max_compaction_bytes() const { return max_compaction_bytes_; }

-  uint32_t max_subcompactions() const { return max_subcompactions_; }
-
  uint64_t MaxInputFileCreationTime() const;

 private:
@@ -272,7 +267,6 @@ class Compaction {
  const int output_level_;  // levels to which output files are stored
  uint64_t max_output_file_size_;
  uint64_t max_compaction_bytes_;
-  uint32_t max_subcompactions_;
  const ImmutableCFOptions immutable_cf_options_;
  const MutableCFOptions mutable_cf_options_;
  Version* input_version_;
@@ -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) {
@@ -62,46 +62,6 @@

 namespace rocksdb {

-const char* GetCompactionReasonString(CompactionReason compaction_reason) {
-  switch (compaction_reason) {
-    case CompactionReason::kUnknown:
-      return "Unknown";
-    case CompactionReason::kLevelL0FilesNum:
-      return "LevelL0FilesNum";
-    case CompactionReason::kLevelMaxLevelSize:
-      return "LevelMaxLevelSize";
-    case CompactionReason::kUniversalSizeAmplification:
-      return "UniversalSizeAmplification";
-    case CompactionReason::kUniversalSizeRatio:
-      return "UniversalSizeRatio";
-    case CompactionReason::kUniversalSortedRunNum:
-      return "UniversalSortedRunNum";
-    case CompactionReason::kFIFOMaxSize:
-      return "FIFOMaxSize";
-    case CompactionReason::kFIFOReduceNumFiles:
-      return "FIFOReduceNumFiles";
-    case CompactionReason::kFIFOTtl:
-      return "FIFOTtl";
-    case CompactionReason::kManualCompaction:
-      return "ManualCompaction";
-    case CompactionReason::kFilesMarkedForCompaction:
-      return "FilesMarkedForCompaction";
-    case CompactionReason::kBottommostFiles:
-      return "BottommostFiles";
-    case CompactionReason::kTtl:
-      return "Ttl";
-    case CompactionReason::kFlush:
-      return "Flush";
-    case CompactionReason::kExternalSstIngestion:
-      return "ExternalSstIngestion";
-    case CompactionReason::kNumOfReasons:
-      // fall through
-    default:
-      assert(false);
-      return "Invalid";
-  }
-}
-
 // Maintains state for each sub-compaction
 struct CompactionJob::SubcompactionState {
  const Compaction* compaction;
@@ -316,7 +276,7 @@ CompactionJob::CompactionJob(
    : job_id_(job_id),
      compact_(new CompactionState(compaction)),
      compaction_job_stats_(compaction_job_stats),
-      compaction_stats_(compaction->compaction_reason(), 1),
+      compaction_stats_(1),
      dbname_(dbname),
      db_options_(db_options),
      env_options_(env_options),
@@ -354,13 +314,15 @@ CompactionJob::~CompactionJob() {
  ThreadStatusUtil::ResetThreadStatus();
 }

-void CompactionJob::ReportStartedCompaction(Compaction* compaction) {
+void CompactionJob::ReportStartedCompaction(
+    Compaction* compaction) {
  const auto* cfd = compact_->compaction->column_family_data();
  ThreadStatusUtil::SetColumnFamily(cfd, cfd->ioptions()->env,
                                    db_options_.enable_thread_tracking);

-  ThreadStatusUtil::SetThreadOperationProperty(ThreadStatus::COMPACTION_JOB_ID,
-                                               job_id_);
+  ThreadStatusUtil::SetThreadOperationProperty(
+      ThreadStatus::COMPACTION_JOB_ID,
+      job_id_);

  ThreadStatusUtil::SetThreadOperationProperty(
      ThreadStatus::COMPACTION_INPUT_OUTPUT_LEVEL,
@@ -390,7 +352,8 @@ void CompactionJob::ReportStartedCompaction(Compaction* compaction) {

  // Set the thread operation after operation properties
  // to ensure GetThreadList() can always show them all together.
-  ThreadStatusUtil::SetThreadOperation(ThreadStatus::OP_COMPACTION);
+  ThreadStatusUtil::SetThreadOperation(
+      ThreadStatus::OP_COMPACTION);

  if (compaction_job_stats_) {
    compaction_job_stats_->is_manual_compaction =
@@ -405,11 +368,11 @@ void CompactionJob::Prepare() {
  // Generate file_levels_ for compaction berfore making Iterator
  auto* c = compact_->compaction;
  assert(c->column_family_data() != nullptr);
-  assert(c->column_family_data()->current()->storage_info()->NumLevelFiles(
-             compact_->compaction->level()) > 0);
+  assert(c->column_family_data()->current()->storage_info()
+      ->NumLevelFiles(compact_->compaction->level()) > 0);

-  write_hint_ =
-      c->column_family_data()->CalculateSSTWriteHint(c->output_level());
+  write_hint_ = c->column_family_data()->CalculateSSTWriteHint(
+    c->output_level());
  // Is this compaction producing files at the bottommost level?
  bottommost_level_ = c->bottommost_level();

@@ -492,18 +455,14 @@ void CompactionJob::GenSubcompactionBoundaries() {
  }

  std::sort(bounds.begin(), bounds.end(),
-            [cfd_comparator](const Slice& a, const Slice& b) -> bool {
-              return cfd_comparator->Compare(ExtractUserKey(a),
-                                             ExtractUserKey(b)) < 0;
-            });
+    [cfd_comparator] (const Slice& a, const Slice& b) -> bool {
+      return cfd_comparator->Compare(ExtractUserKey(a), ExtractUserKey(b)) < 0;
+    });
  // Remove duplicated entries from bounds
-  bounds.erase(
-      std::unique(bounds.begin(), bounds.end(),
-                  [cfd_comparator](const Slice& a, const Slice& b) -> bool {
-                    return cfd_comparator->Compare(ExtractUserKey(a),
-                                                   ExtractUserKey(b)) == 0;
-                  }),
-      bounds.end());
+  bounds.erase(std::unique(bounds.begin(), bounds.end(),
+    [cfd_comparator] (const Slice& a, const Slice& b) -> bool {
+      return cfd_comparator->Compare(ExtractUserKey(a), ExtractUserKey(b)) == 0;
+    }), bounds.end());

  // Combine consecutive pairs of boundaries into ranges with an approximate
  // size of data covered by keys in that range
@@ -526,15 +485,12 @@ void CompactionJob::GenSubcompactionBoundaries() {

  // Group the ranges into subcompactions
  const double min_file_fill_percent = 4.0 / 5;
-  int base_level = v->storage_info()->base_level();
-  uint64_t max_output_files = static_cast<uint64_t>(std::ceil(
-      sum / min_file_fill_percent /
-      MaxFileSizeForLevel(*(c->mutable_cf_options()), out_lvl,
-          c->immutable_cf_options()->compaction_style, base_level,
-          c->immutable_cf_options()->level_compaction_dynamic_level_bytes)));
+  uint64_t max_output_files = static_cast<uint64_t>(
+      std::ceil(sum / min_file_fill_percent /
+                c->mutable_cf_options()->MaxFileSizeForLevel(out_lvl)));
  uint64_t subcompactions =
      std::min({static_cast<uint64_t>(ranges.size()),
-                static_cast<uint64_t>(c->max_subcompactions()),
+                static_cast<uint64_t>(db_options_.max_subcompactions),
                max_output_files});

  if (subcompactions > 1) {
@@ -610,9 +566,8 @@ Status CompactionJob::Run() {
  TablePropertiesCollection tp;
  for (const auto& state : compact_->sub_compact_states) {
    for (const auto& output : state.outputs) {
-      auto fn =
-          TableFileName(state.compaction->immutable_cf_options()->cf_paths,
-                        output.meta.fd.GetNumber(), output.meta.fd.GetPathId());
+      auto fn = TableFileName(db_options_.db_paths, output.meta.fd.GetNumber(),
+                              output.meta.fd.GetPathId());
      tp[fn] = output.table_properties;
    }
  }
@@ -768,19 +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>(MaxFileSizeForLevel(*mutable_cf_options,
-            compact_->compaction->output_level(),
-            cfd->ioptions()->compaction_style,
-            compact_->compaction->GetInputBaseLevel(),
-            cfd->ioptions()->level_compaction_dynamic_level_bytes));
+    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);
      }
    }
  }
@@ -797,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");

@@ -812,21 +762,33 @@ 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() && sub_compact->compaction->output_level() != 0) {
+  if (c_iter->Valid() &&
+      sub_compact->compaction->output_level() != 0) {
    // ShouldStopBefore() maintains state based on keys processed so far. The
    // compaction loop always calls it on the "next" key, thus won't tell it the
    // first key. So we do that here.
-    sub_compact->ShouldStopBefore(c_iter->key(),
-                                  sub_compact->current_output_file_size);
+    sub_compact->ShouldStopBefore(
+      c_iter->key(), sub_compact->current_output_file_size);
  }
  const auto& c_iter_stats = c_iter->iter_stats();
  auto sample_begin_offset_iter = sample_begin_offsets.cbegin();
@@ -940,8 +902,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    c_iter->Next();
    if (!output_file_ended && c_iter->Valid() &&
        sub_compact->compaction->output_level() != 0 &&
-        sub_compact->ShouldStopBefore(c_iter->key(),
-                                      sub_compact->current_output_file_size) &&
+        sub_compact->ShouldStopBefore(
+          c_iter->key(), sub_compact->current_output_file_size) &&
        sub_compact->builder != nullptr) {
      // (2) this key belongs to the next file. For historical reasons, the
      // iterator status after advancing will be given to
@@ -993,8 +955,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  RecordDroppedKeys(c_iter_stats, &sub_compact->compaction_job_stats);
  RecordCompactionIOStats();

-  if (status.ok() &&
-      (shutting_down_->load(std::memory_order_relaxed) || cfd->IsDropped())) {
+  if (status.ok() && (shutting_down_->load(std::memory_order_relaxed) ||
+                      cfd->IsDropped())) {
    status = Status::ShutdownInProgress(
        "Database shutdown or Column family drop during compaction");
  }
@@ -1158,9 +1120,8 @@ Status CompactionJob::FinishCompactionOutputFile(
    // If there is nothing to output, no necessary to generate a sst file.
    // This happens when the output level is bottom level, at the same time
    // the sub_compact output nothing.
-    std::string fname =
-        TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
-                      meta->fd.GetNumber(), meta->fd.GetPathId());
+    std::string fname = TableFileName(
+        db_options_.db_paths, meta->fd.GetNumber(), meta->fd.GetPathId());
    env_->DeleteFile(fname);

    // Also need to remove the file from outputs, or it will be added to the
@@ -1179,7 +1140,7 @@ Status CompactionJob::FinishCompactionOutputFile(
    // We set for_compaction to false and don't OptimizeForCompactionTableRead
    // here because this is a special case after we finish the table building
    // No matter whether use_direct_io_for_flush_and_compaction is true,
-    // we will regard this verification as user reads since the goal is
+    // we will regrad this verification as user reads since the goal is
    // to cache it here for further user reads
    InternalIterator* iter = cfd->table_cache()->NewIterator(
        ReadOptions(), env_options_, cfd->internal_comparator(), meta->fd,
@@ -1191,8 +1152,7 @@ Status CompactionJob::FinishCompactionOutputFile(
    s = iter->status();

    if (s.ok() && paranoid_file_checks_) {
-      for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-      }
+      for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {}
      s = iter->status();
    }

@@ -1214,9 +1174,8 @@ Status CompactionJob::FinishCompactionOutputFile(
  std::string fname;
  FileDescriptor output_fd;
  if (meta != nullptr) {
-    fname =
-        TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
-                      meta->fd.GetNumber(), meta->fd.GetPathId());
+    fname = TableFileName(db_options_.db_paths, meta->fd.GetNumber(),
+                          meta->fd.GetPathId());
    output_fd = meta->fd;
  } else {
    fname = "(nil)";
@@ -1230,14 +1189,13 @@ Status CompactionJob::FinishCompactionOutputFile(
  auto sfm =
      static_cast<SstFileManagerImpl*>(db_options_.sst_file_manager.get());
  if (sfm && meta != nullptr && meta->fd.GetPathId() == 0) {
-    auto fn =
-        TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
-                      meta->fd.GetNumber(), meta->fd.GetPathId());
+    auto fn = TableFileName(cfd->ioptions()->db_paths, meta->fd.GetNumber(),
+                            meta->fd.GetPathId());
    sfm->OnAddFile(fn);
    if (sfm->IsMaxAllowedSpaceReached()) {
      // TODO(ajkr): should we return OK() if max space was reached by the final
      // compaction output file (similarly to how flush works when full)?
-      s = Status::NoSpace("Max allowed space was reached");
+      s = Status::IOError("Max allowed space was reached");
      TEST_SYNC_POINT(
          "CompactionJob::FinishCompactionOutputFile:"
          "MaxAllowedSpaceReached");
@@ -1287,7 +1245,7 @@ Status CompactionJob::InstallCompactionResults(
        compaction->InputLevelSummary(&inputs_summary), compact_->total_bytes);
  }

-  // Add compaction inputs
+  // Add compaction outputs
  compaction->AddInputDeletions(compact_->compaction->edit());

  for (const auto& sub_compact : compact_->sub_compact_states) {
@@ -1317,9 +1275,8 @@ Status CompactionJob::OpenCompactionOutputFile(
  assert(sub_compact->builder == nullptr);
  // no need to lock because VersionSet::next_file_number_ is atomic
  uint64_t file_number = versions_->NewFileNumber();
-  std::string fname =
-      TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
-                    file_number, sub_compact->compaction->output_path_id());
+  std::string fname = TableFileName(db_options_.db_paths, file_number,
+                                    sub_compact->compaction->output_path_id());
  // Fire events.
  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
 #ifndef ROCKSDB_LITE
@@ -1421,7 +1378,8 @@ void CompactionJob::CleanupCompaction() {

 #ifndef ROCKSDB_LITE
 namespace {
-void CopyPrefix(const Slice& src, size_t prefix_length, std::string* dst) {
+void CopyPrefix(
+    const Slice& src, size_t prefix_length, std::string* dst) {
  assert(prefix_length > 0);
  size_t length = src.size() > prefix_length ? prefix_length : src.size();
  dst->assign(src.data(), length);
@@ -1440,11 +1398,13 @@ void CompactionJob::UpdateCompactionStats() {
    if (compaction->level(input_level) != compaction->output_level()) {
      UpdateCompactionInputStatsHelper(
          &compaction_stats_.num_input_files_in_non_output_levels,
-          &compaction_stats_.bytes_read_non_output_levels, input_level);
+          &compaction_stats_.bytes_read_non_output_levels,
+          input_level);
    } else {
      UpdateCompactionInputStatsHelper(
          &compaction_stats_.num_input_files_in_output_level,
-          &compaction_stats_.bytes_read_output_level, input_level);
+          &compaction_stats_.bytes_read_output_level,
+          input_level);
    }
  }

@@ -1467,9 +1427,8 @@ void CompactionJob::UpdateCompactionStats() {
  }
 }

-void CompactionJob::UpdateCompactionInputStatsHelper(int* num_files,
-                                                     uint64_t* bytes_read,
-                                                     int input_level) {
+void CompactionJob::UpdateCompactionInputStatsHelper(
+    int* num_files, uint64_t* bytes_read, int input_level) {
  const Compaction* compaction = compact_->compaction;
  auto num_input_files = compaction->num_input_files(input_level);
  *num_files += static_cast<int>(num_input_files);
@@ -1490,8 +1449,10 @@ void CompactionJob::UpdateCompactionJobStats(

    // input information
    compaction_job_stats_->total_input_bytes =
-        stats.bytes_read_non_output_levels + stats.bytes_read_output_level;
-    compaction_job_stats_->num_input_records = compact_->num_input_records;
+        stats.bytes_read_non_output_levels +
+        stats.bytes_read_output_level;
+    compaction_job_stats_->num_input_records =
+        compact_->num_input_records;
    compaction_job_stats_->num_input_files =
        stats.num_input_files_in_non_output_levels +
        stats.num_input_files_in_output_level;
@@ -1500,20 +1461,21 @@ void CompactionJob::UpdateCompactionJobStats(

    // output information
    compaction_job_stats_->total_output_bytes = stats.bytes_written;
-    compaction_job_stats_->num_output_records = compact_->num_output_records;
+    compaction_job_stats_->num_output_records =
+        compact_->num_output_records;
    compaction_job_stats_->num_output_files = stats.num_output_files;

    if (compact_->NumOutputFiles() > 0U) {
-      CopyPrefix(compact_->SmallestUserKey(),
-                 CompactionJobStats::kMaxPrefixLength,
-                 &compaction_job_stats_->smallest_output_key_prefix);
-      CopyPrefix(compact_->LargestUserKey(),
-                 CompactionJobStats::kMaxPrefixLength,
-                 &compaction_job_stats_->largest_output_key_prefix);
+      CopyPrefix(
+          compact_->SmallestUserKey(),
+          CompactionJobStats::kMaxPrefixLength,
+          &compaction_job_stats_->smallest_output_key_prefix);
+      CopyPrefix(
+          compact_->LargestUserKey(),
+          CompactionJobStats::kMaxPrefixLength,
+          &compaction_job_stats_->largest_output_key_prefix);
    }
  }
-#else
-  (void)stats;
 #endif  // !ROCKSDB_LITE
 }

@@ -1536,9 +1498,7 @@ void CompactionJob::LogCompaction() {
    // build event logger report
    auto stream = event_logger_->Log();
    stream << "job" << job_id_ << "event"
-           << "compaction_started"
-           << "compaction_reason"
-           << GetCompactionReasonString(compaction->compaction_reason());
+           << "compaction_started";
    for (size_t i = 0; i < compaction->num_input_levels(); ++i) {
      stream << ("files_L" + ToString(compaction->level(i)));
      stream.StartArray();
@@ -30,7 +30,6 @@
 #include "db/write_controller.h"
 #include "db/write_thread.h"
 #include "options/db_options.h"
-#include "options/cf_options.h"
 #include "port/port.h"
 #include "rocksdb/compaction_filter.h"
 #include "rocksdb/compaction_job_stats.h"
@@ -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);
@@ -806,7 +806,7 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {
    stats_checker->set_verify_next_comp_io_stats(true);
    std::atomic<bool> first_prepare_write(true);
    rocksdb::SyncPoint::GetInstance()->SetCallBack(
-        "WritableFileWriter::Append:BeforePrepareWrite", [&](void* /*arg*/) {
+        "WritableFileWriter::Append:BeforePrepareWrite", [&](void* arg) {
          if (first_prepare_write.load()) {
            options.env->SleepForMicroseconds(3);
            first_prepare_write.store(false);
@@ -815,7 +815,7 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {

    std::atomic<bool> first_flush(true);
    rocksdb::SyncPoint::GetInstance()->SetCallBack(
-        "WritableFileWriter::Flush:BeforeAppend", [&](void* /*arg*/) {
+        "WritableFileWriter::Flush:BeforeAppend", [&](void* arg) {
          if (first_flush.load()) {
            options.env->SleepForMicroseconds(3);
            first_flush.store(false);
@@ -824,7 +824,7 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {

    std::atomic<bool> first_sync(true);
    rocksdb::SyncPoint::GetInstance()->SetCallBack(
-        "WritableFileWriter::SyncInternal:0", [&](void* /*arg*/) {
+        "WritableFileWriter::SyncInternal:0", [&](void* arg) {
          if (first_sync.load()) {
            options.env->SleepForMicroseconds(3);
            first_sync.store(false);
@@ -833,7 +833,7 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {

    std::atomic<bool> first_range_sync(true);
    rocksdb::SyncPoint::GetInstance()->SetCallBack(
-        "WritableFileWriter::RangeSync:0", [&](void* /*arg*/) {
+        "WritableFileWriter::RangeSync:0", [&](void* arg) {
          if (first_range_sync.load()) {
            options.env->SleepForMicroseconds(3);
            first_range_sync.store(false);
@@ -1034,7 +1034,7 @@ int main(int argc, char** argv) {
 #else
 #include <stdio.h>

-int main(int /*argc*/, char** /*argv*/) {
+int main(int argc, char** argv) {
  fprintf(stderr, "SKIPPED, not supported in ROCKSDB_LITE\n");
  return 0;
 }
@@ -1043,5 +1043,5 @@ int main(int /*argc*/, char** /*argv*/) {

 #else

-int main(int /*argc*/, char** /*argv*/) { return 0; }
+int main(int argc, char** argv) { return 0; }
 #endif  // !defined(IOS_CROSS_COMPILE)
@@ -246,7 +246,7 @@ class CompactionJobTest : public testing::Test {
    Compaction compaction(cfd->current()->storage_info(), *cfd->ioptions(),
                          *cfd->GetLatestMutableCFOptions(),
                          compaction_input_files, 1, 1024 * 1024,
-                          10 * 1024 * 1024, 0, kNoCompression, 0, {}, true);
+                          10 * 1024 * 1024, 0, kNoCompression, {}, true);
    compaction.SetInputVersion(cfd->current());

    LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, db_options_.info_log.get());
@@ -946,7 +946,7 @@ int main(int argc, char** argv) {
 #else
 #include <stdio.h>

-int main(int /*argc*/, char** /*argv*/) {
+int main(int argc, char** argv) {
  fprintf(stderr,
          "SKIPPED as CompactionJobStats is not supported in ROCKSDB_LITE\n");
  return 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;
@@ -59,7 +59,7 @@ bool FindIntraL0Compaction(const std::vector<FileMetaData*>& level_files,
  }

  if (span_len >= min_files_to_compact &&
-      compact_bytes_per_del_file < max_compact_bytes_per_del_file) {
+      new_compact_bytes_per_del_file < max_compact_bytes_per_del_file) {
    assert(comp_inputs != nullptr);
    comp_inputs->level = 0;
    for (size_t i = 0; i < span_len; ++i) {
@@ -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
@@ -301,9 +301,7 @@ Compaction* CompactionPicker::CompactFiles(
      new Compaction(vstorage, ioptions_, mutable_cf_options, input_files,
                     output_level, compact_options.output_file_size_limit,
                     mutable_cf_options.max_compaction_bytes, output_path_id,
-                     compact_options.compression,
-                     compact_options.max_subcompactions,
-                     /* grandparents */ {}, true);
+                     compact_options.compression, /* grandparents */ {}, true);
  RegisterCompaction(c);
  return c;
 }
@@ -311,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.");
@@ -506,8 +504,7 @@ void CompactionPicker::GetGrandparents(
 Compaction* CompactionPicker::CompactRange(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
    VersionStorageInfo* vstorage, int input_level, int output_level,
-    uint32_t output_path_id, uint32_t max_subcompactions,
-    const InternalKey* begin, const InternalKey* end,
+    uint32_t output_path_id, const InternalKey* begin, const InternalKey* end,
    InternalKey** compaction_end, bool* manual_conflict) {
  // CompactionPickerFIFO has its own implementation of compact range
  assert(ioptions_.compaction_style != kCompactionStyleFIFO);
@@ -569,12 +566,11 @@ Compaction* CompactionPicker::CompactRange(

    Compaction* c = new Compaction(
        vstorage, ioptions_, mutable_cf_options, std::move(inputs),
-        output_level, MaxFileSizeForLevel(mutable_cf_options, output_level,
-            ioptions_.compaction_style),
+        output_level, mutable_cf_options.MaxFileSizeForLevel(output_level),
        /* max_compaction_bytes */ LLONG_MAX, output_path_id,
        GetCompressionType(ioptions_, vstorage, mutable_cf_options,
                           output_level, 1),
-        max_subcompactions, /* grandparents */ {}, /* is manual */ true);
+        /* grandparents */ {}, /* is manual */ true);
    RegisterCompaction(c);
    return c;
  }
@@ -620,7 +616,7 @@ Compaction* CompactionPicker::CompactRange(
      }
    }
  }
-  assert(output_path_id < static_cast<uint32_t>(ioptions_.cf_paths.size()));
+  assert(output_path_id < static_cast<uint32_t>(ioptions_.db_paths.size()));

  if (ExpandInputsToCleanCut(cf_name, vstorage, &inputs) == false) {
    // manual compaction is now multi-threaded, so it can
@@ -677,15 +673,11 @@ Compaction* CompactionPicker::CompactRange(
  GetGrandparents(vstorage, inputs, output_level_inputs, &grandparents);
  Compaction* compaction = new Compaction(
      vstorage, ioptions_, mutable_cf_options, std::move(compaction_inputs),
-      output_level,
-      MaxFileSizeForLevel(mutable_cf_options, output_level,
-          ioptions_.compaction_style, vstorage->base_level(),
-          ioptions_.level_compaction_dynamic_level_bytes),
+      output_level, mutable_cf_options.MaxFileSizeForLevel(output_level),
      mutable_cf_options.max_compaction_bytes, output_path_id,
      GetCompressionType(ioptions_, vstorage, mutable_cf_options, output_level,
                         vstorage->base_level()),
-      /* max_subcompactions */ 0, std::move(grandparents),
-      /* is manual compaction */ true);
+      std::move(grandparents), /* is manual compaction */ true);

  TEST_SYNC_POINT_CALLBACK("CompactionPicker::CompactRange:Return", compaction);
  RegisterCompaction(compaction);
@@ -949,9 +941,6 @@ void CompactionPicker::UnregisterCompaction(Compaction* c) {

 bool LevelCompactionPicker::NeedsCompaction(
    const VersionStorageInfo* vstorage) const {
-  if (!vstorage->ExpiredTtlFiles().empty()) {
-    return true;
-  }
  if (!vstorage->BottommostFilesMarkedForCompaction().empty()) {
    return true;
  }
@@ -1021,8 +1010,6 @@ class LevelCompactionBuilder {
  // If there is any file marked for compaction, put put it into inputs.
  void PickFilesMarkedForCompaction();

-  void PickExpiredTtlFiles();
-
  const std::string& cf_name_;
  VersionStorageInfo* vstorage_;
  CompactionPicker* compaction_picker_;
@@ -1093,42 +1080,6 @@ void LevelCompactionBuilder::PickFilesMarkedForCompaction() {
  start_level_inputs_.files.clear();
 }

-void LevelCompactionBuilder::PickExpiredTtlFiles() {
-  if (vstorage_->ExpiredTtlFiles().empty()) {
-    return;
-  }
-
-  auto continuation = [&](std::pair<int, FileMetaData*> level_file) {
-    // If it's being compacted it has nothing to do here.
-    // If this assert() fails that means that some function marked some
-    // files as being_compacted, but didn't call ComputeCompactionScore()
-    assert(!level_file.second->being_compacted);
-    start_level_ = level_file.first;
-    output_level_ =
-        (start_level_ == 0) ? vstorage_->base_level() : start_level_ + 1;
-
-    if ((start_level_ == vstorage_->num_non_empty_levels() - 1) ||
-        (start_level_ == 0 &&
-         !compaction_picker_->level0_compactions_in_progress()->empty())) {
-      return false;
-    }
-
-    start_level_inputs_.files = {level_file.second};
-    start_level_inputs_.level = start_level_;
-    return compaction_picker_->ExpandInputsToCleanCut(cf_name_, vstorage_,
-                                                      &start_level_inputs_);
-  };
-
-  for (auto& level_file : vstorage_->ExpiredTtlFiles()) {
-    if (continuation(level_file)) {
-      // found the compaction!
-      return;
-    }
-  }
-
-  start_level_inputs_.files.clear();
-}
-
 void LevelCompactionBuilder::SetupInitialFiles() {
  // Find the compactions by size on all levels.
  bool skipped_l0_to_base = false;
@@ -1180,40 +1131,32 @@ void LevelCompactionBuilder::SetupInitialFiles() {
  // if we didn't find a compaction, check if there are any files marked for
  // compaction
  if (start_level_inputs_.empty()) {
+    is_manual_ = true;
    parent_index_ = base_index_ = -1;
-
    PickFilesMarkedForCompaction();
-    if (!start_level_inputs_.empty()) {
-      is_manual_ = true;
-      compaction_reason_ = CompactionReason::kFilesMarkedForCompaction;
-      return;
-    }
-
-    size_t i;
-    for (i = 0; i < vstorage_->BottommostFilesMarkedForCompaction().size();
-         ++i) {
-      auto& level_and_file = vstorage_->BottommostFilesMarkedForCompaction()[i];
-      assert(!level_and_file.second->being_compacted);
-      start_level_inputs_.level = output_level_ = start_level_ =
-          level_and_file.first;
-      start_level_inputs_.files = {level_and_file.second};
-      if (compaction_picker_->ExpandInputsToCleanCut(cf_name_, vstorage_,
-                                                     &start_level_inputs_)) {
-        break;
+    if (start_level_inputs_.empty()) {
+      size_t i;
+      for (i = 0; i < vstorage_->BottommostFilesMarkedForCompaction().size();
+           ++i) {
+        auto& level_and_file =
+            vstorage_->BottommostFilesMarkedForCompaction()[i];
+        assert(!level_and_file.second->being_compacted);
+        start_level_inputs_.level = output_level_ = start_level_ =
+            level_and_file.first;
+        start_level_inputs_.files = {level_and_file.second};
+        if (compaction_picker_->ExpandInputsToCleanCut(cf_name_, vstorage_,
+                                                       &start_level_inputs_)) {
+          break;
+        }
+      }
+      if (i == vstorage_->BottommostFilesMarkedForCompaction().size()) {
+        start_level_inputs_.clear();
+      } else {
+        assert(!start_level_inputs_.empty());
+        compaction_reason_ = CompactionReason::kBottommostFiles;
      }
-    }
-    if (i == vstorage_->BottommostFilesMarkedForCompaction().size()) {
-      start_level_inputs_.clear();
    } else {
-      assert(!start_level_inputs_.empty());
-      compaction_reason_ = CompactionReason::kBottommostFiles;
-      return;
-    }
-
-    assert(start_level_inputs_.empty());
-    PickExpiredTtlFiles();
-    if (!start_level_inputs_.empty()) {
-      compaction_reason_ = CompactionReason::kTtl;
+      compaction_reason_ = CompactionReason::kFilesMarkedForCompaction;
    }
  }
 }
@@ -1315,16 +1258,13 @@ Compaction* LevelCompactionBuilder::PickCompaction() {
 Compaction* LevelCompactionBuilder::GetCompaction() {
  auto c = new Compaction(
      vstorage_, ioptions_, mutable_cf_options_, std::move(compaction_inputs_),
-      output_level_,
-      MaxFileSizeForLevel(mutable_cf_options_, output_level_,
-          ioptions_.compaction_style, vstorage_->base_level(),
-          ioptions_.level_compaction_dynamic_level_bytes),
+      output_level_, mutable_cf_options_.MaxFileSizeForLevel(output_level_),
      mutable_cf_options_.max_compaction_bytes,
      GetPathId(ioptions_, mutable_cf_options_, output_level_),
      GetCompressionType(ioptions_, vstorage_, mutable_cf_options_,
                         output_level_, vstorage_->base_level()),
-      /* max_subcompactions */ 0, std::move(grandparents_), is_manual_,
-      start_level_score_, false /* deletion_compaction */, compaction_reason_);
+      std::move(grandparents_), is_manual_, start_level_score_,
+      false /* deletion_compaction */, compaction_reason_);

  // If it's level 0 compaction, make sure we don't execute any other level 0
  // compactions in parallel
@@ -1347,10 +1287,10 @@ uint32_t LevelCompactionBuilder::GetPathId(
    const ImmutableCFOptions& ioptions,
    const MutableCFOptions& mutable_cf_options, int level) {
  uint32_t p = 0;
-  assert(!ioptions.cf_paths.empty());
+  assert(!ioptions.db_paths.empty());

  // size remaining in the most recent path
-  uint64_t current_path_size = ioptions.cf_paths[0].target_size;
+  uint64_t current_path_size = ioptions.db_paths[0].target_size;

  uint64_t level_size;
  int cur_level = 0;
@@ -1360,7 +1300,7 @@ uint32_t LevelCompactionBuilder::GetPathId(
  level_size = mutable_cf_options.max_bytes_for_level_base;

  // Last path is the fallback
-  while (p < ioptions.cf_paths.size() - 1) {
+  while (p < ioptions.db_paths.size() - 1) {
    if (level_size <= current_path_size) {
      if (cur_level == level) {
        // Does desired level fit in this path?
@@ -1387,7 +1327,7 @@ uint32_t LevelCompactionBuilder::GetPathId(
      }
    }
    p++;
-    current_path_size = ioptions.cf_paths[p].target_size;
+    current_path_size = ioptions.db_paths[p].target_size;
  }
  return p;
 }
@@ -1572,9 +1512,8 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(

  Compaction* c = new Compaction(
      vstorage, ioptions_, mutable_cf_options, std::move(inputs), 0, 0, 0, 0,
-      kNoCompression, /* max_subcompactions */ 0, {}, /* is manual */ false,
-      vstorage->CompactionScore(0), /* is deletion compaction */ true,
-      CompactionReason::kFIFOTtl);
+      kNoCompression, {}, /* is manual */ false, vstorage->CompactionScore(0),
+      /* is deletion compaction */ true, CompactionReason::kFIFOTtl);
  return c;
 }

@@ -1592,28 +1531,18 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
    if (mutable_cf_options.compaction_options_fifo.allow_compaction &&
        level_files.size() > 0) {
      CompactionInputFiles comp_inputs;
-      // try to prevent same files from being compacted multiple times, which
-      // could produce large files that may never TTL-expire. Achieve this by
-      // disallowing compactions with files larger than memtable (inflate its
-      // size by 10% to account for uncompressed L0 files that may have size
-      // slightly greater than memtable size limit).
-      size_t max_compact_bytes_per_del_file =
-          static_cast<size_t>(MultiplyCheckOverflow(
-              static_cast<uint64_t>(mutable_cf_options.write_buffer_size),
-              1.1));
      if (FindIntraL0Compaction(
              level_files,
              mutable_cf_options
-                  .level0_file_num_compaction_trigger /* min_files_to_compact */
-              ,
-              max_compact_bytes_per_del_file, &comp_inputs)) {
+                  .level0_file_num_compaction_trigger /* min_files_to_compact */,
+              mutable_cf_options.write_buffer_size, &comp_inputs)) {
        Compaction* c = new Compaction(
            vstorage, ioptions_, mutable_cf_options, {comp_inputs}, 0,
            16 * 1024 * 1024 /* output file size limit */,
            0 /* max compaction bytes, not applicable */,
-            0 /* output path ID */, mutable_cf_options.compression,
-            0 /* max_subcompactions */, {}, /* is manual */ false,
-            vstorage->CompactionScore(0), /* is deletion compaction */ false,
+            0 /* output path ID */, mutable_cf_options.compression, {},
+            /* is manual */ false, vstorage->CompactionScore(0),
+            /* is deletion compaction */ false,
            CompactionReason::kFIFOReduceNumFiles);
        return c;
      }
@@ -1659,9 +1588,8 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(

  Compaction* c = new Compaction(
      vstorage, ioptions_, mutable_cf_options, std::move(inputs), 0, 0, 0, 0,
-      kNoCompression, /* max_subcompactions */ 0, {}, /* is manual */ false,
-      vstorage->CompactionScore(0), /* is deletion compaction */ true,
-      CompactionReason::kFIFOMaxSize);
+      kNoCompression, {}, /* is manual */ false, vstorage->CompactionScore(0),
+      /* is deletion compaction */ true, CompactionReason::kFIFOMaxSize);
  return c;
 }

@@ -1684,13 +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*/, uint32_t /*max_subcompactions*/,
-    const InternalKey* /*begin*/, const InternalKey* /*end*/,
-    InternalKey** compaction_end, bool* /*manual_conflict*/) {
-#ifdef NDEBUG
-  (void)input_level;
-  (void)output_level;
-#endif
+    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;
@@ -58,8 +58,7 @@ class CompactionPicker {
  virtual 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, uint32_t max_subcompactions,
-      const InternalKey* begin, const InternalKey* end,
+      uint32_t output_path_id, const InternalKey* begin, const InternalKey* end,
      InternalKey** compaction_end, bool* manual_conflict);

  // The maximum allowed output level.  Default value is NumberLevels() - 1.
@@ -239,8 +238,7 @@ class FIFOCompactionPicker : public CompactionPicker {
  virtual 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, uint32_t max_subcompactions,
-      const InternalKey* begin, const InternalKey* end,
+      uint32_t output_path_id, const InternalKey* begin, const InternalKey* end,
      InternalKey** compaction_end, bool* manual_conflict) override;

  // The maximum allowed output level.  Always returns 0.
@@ -269,30 +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*/,
-                           uint32_t /*max_subcompactions*/,
-                           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;
 };

@@ -59,7 +57,7 @@ class CompactionPickerTest : public testing::Test {
        vstorage_(nullptr) {
    fifo_options_.max_table_files_size = 1;
    mutable_cf_options_.RefreshDerivedOptions(ioptions_);
-    ioptions_.cf_paths.emplace_back("dummy",
+    ioptions_.db_paths.emplace_back("dummy",
                                    std::numeric_limits<uint64_t>::max());
  }

@@ -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)) {
@@ -406,9 +406,9 @@ uint32_t UniversalCompactionPicker::GetPathId(
      file_size *
      (100 - mutable_cf_options.compaction_options_universal.size_ratio) / 100;
  uint32_t p = 0;
-  assert(!ioptions.cf_paths.empty());
-  for (; p < ioptions.cf_paths.size() - 1; p++) {
-    uint64_t target_size = ioptions.cf_paths[p].target_size;
+  assert(!ioptions.db_paths.empty());
+  for (; p < ioptions.db_paths.size() - 1; p++) {
+    uint64_t target_size = ioptions.db_paths[p].target_size;
    if (target_size > file_size &&
        accumulated_size + (target_size - file_size) > future_size) {
      return p;
@@ -603,19 +603,17 @@ 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,
-      MaxFileSizeForLevel(mutable_cf_options, output_level,
-                          kCompactionStyleUniversal),
-      LLONG_MAX, path_id,
+      mutable_cf_options.MaxFileSizeForLevel(output_level), LLONG_MAX, path_id,
      GetCompressionType(ioptions_, vstorage, mutable_cf_options, start_level,
                         1, enable_compression),
-      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
-      score, false /* deletion_compaction */, compaction_reason);
+      /* grandparents */ {}, /* is manual */ false, score,
+      false /* deletion_compaction */, compaction_reason);
 }

 // Look at overall size amplification. If size amplification
@@ -744,13 +742,12 @@ Compaction* UniversalCompactionPicker::PickCompactionToReduceSizeAmp(

  return new Compaction(
      vstorage, ioptions_, mutable_cf_options, std::move(inputs),
-      output_level, MaxFileSizeForLevel(mutable_cf_options, output_level,
-          kCompactionStyleUniversal),
+      output_level, mutable_cf_options.MaxFileSizeForLevel(output_level),
      /* max_grandparent_overlap_bytes */ LLONG_MAX, path_id,
      GetCompressionType(ioptions_, vstorage, mutable_cf_options,
                         output_level, 1),
-      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
-      score, false /* deletion_compaction */,
+      /* grandparents */ {}, /* is manual */ false, score,
+      false /* deletion_compaction */,
      CompactionReason::kUniversalSizeAmplification);
 }
 }  // namespace rocksdb
@@ -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,
@@ -510,7 +510,7 @@ int main(int argc, char** argv) {
 #else
 #include <stdio.h>

-int main(int /*argc*/, char** /*argv*/) {
+int main(int argc, char** argv) {
  fprintf(stderr, "SKIPPED as RepairDB() is not supported in ROCKSDB_LITE\n");
  return 0;
 }
@@ -333,7 +333,7 @@ int main(int argc, char** argv) {
 #else
 #include <stdio.h>

-int main(int /*argc*/, char** /*argv*/) {
+int main(int argc, char** argv) {
  fprintf(stderr, "SKIPPED as Cuckoo table is not supported in ROCKSDB_LITE\n");
  return 0;
 }
@@ -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();
@@ -305,41 +280,6 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksOfNewTableAddedToCache) {
            TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
 }

-// With fill_cache = false, fills up the cache, then iterates over the entire
-// db, verify dummy entries inserted in `BlockBasedTable::NewDataBlockIterator`
-// does not cause heap-use-after-free errors in COMPILE_WITH_ASAN=1 runs
-TEST_F(DBBlockCacheTest, FillCacheAndIterateDB) {
-  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(10, 0, true);
-  table_options.block_cache = cache;
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  Reopen(options);
-  ASSERT_OK(Put("key1", "val1"));
-  ASSERT_OK(Put("key2", "val2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("key3", "val3"));
-  ASSERT_OK(Put("key4", "val4"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("key5", "val5"));
-  ASSERT_OK(Put("key6", "val6"));
-  ASSERT_OK(Flush());
-
-  Iterator* iter = nullptr;
-
-  iter = db_->NewIterator(read_options);
-  iter->Seek(ToString(0));
-  while (iter->Valid()) {
-    iter->Next();
-  }
-  delete iter;
-  iter = nullptr;
-}
-
 TEST_F(DBBlockCacheTest, IndexAndFilterBlocksStats) {
  Options options = CurrentOptions();
  options.create_if_missing = true;
@@ -1057,10 +1057,10 @@ TEST_F(DBBloomFilterTest, OptimizeFiltersForHits) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial_move++; });
+      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  CompactRangeOptions compact_options;
@@ -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);
  }
@@ -74,48 +74,6 @@ class FlushedFileCollector : public EventListener {
  std::mutex mutex_;
 };

-class CompactionStatsCollector : public EventListener {
-public:
-  CompactionStatsCollector()
-      : compaction_completed_(static_cast<int>(CompactionReason::kNumOfReasons)) {
-    for (auto& v : compaction_completed_) {
-      v.store(0);
-    }
-  }
-
-  ~CompactionStatsCollector() {}
-
-  virtual void OnCompactionCompleted(DB* /* db */,
-      const CompactionJobInfo& info) override {
-    int k = static_cast<int>(info.compaction_reason);
-    int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-    assert(k >= 0 && k < num_of_reasons);
-    compaction_completed_[k]++;
-  }
-
-  virtual void OnExternalFileIngested(DB* /* db */,
-      const ExternalFileIngestionInfo& /* info */) override {
-    int k = static_cast<int>(CompactionReason::kExternalSstIngestion);
-    compaction_completed_[k]++;
-  }
-
-  virtual void OnFlushCompleted(DB* /* db */,
-      const FlushJobInfo& /* info */) override {
-    int k = static_cast<int>(CompactionReason::kFlush);
-    compaction_completed_[k]++;
-  }
-
-  int NumberOfCompactions(CompactionReason reason) const {
-    int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-    int k = static_cast<int>(reason);
-    assert(k >= 0 && k < num_of_reasons);
-    return compaction_completed_.at(k).load();
-  }
-
-private:
-  std::vector<std::atomic<int>> compaction_completed_;
-};
-
 static const int kCDTValueSize = 1000;
 static const int kCDTKeysPerBuffer = 4;
 static const int kCDTNumLevels = 8;
@@ -196,40 +154,6 @@ void VerifyCompactionResult(
 #endif
 }

-/*
- * Verifies compaction stats of cfd are valid.
- *
- * For each level of cfd, its compaction stats are valid if
- * 1) sum(stat.counts) == stat.count, and
- * 2) stat.counts[i] == collector.NumberOfCompactions(i)
- */
-void VerifyCompactionStats(ColumnFamilyData& cfd,
-    const CompactionStatsCollector& collector) {
-#ifndef NDEBUG
-  InternalStats* internal_stats_ptr = cfd.internal_stats();
-  ASSERT_TRUE(internal_stats_ptr != nullptr);
-  const std::vector<InternalStats::CompactionStats>& comp_stats =
-      internal_stats_ptr->TEST_GetCompactionStats();
-  const int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-  std::vector<int> counts(num_of_reasons, 0);
-  // Count the number of compactions caused by each CompactionReason across
-  // all levels.
-  for (const auto& stat : comp_stats) {
-    int sum = 0;
-    for (int i = 0; i < num_of_reasons; i++) {
-      counts[i] += stat.counts[i];
-      sum += stat.counts[i];
-    }
-    ASSERT_EQ(sum, stat.count);
-  }
-  // Verify InternalStats bookkeeping matches that of CompactionStatsCollector,
-  // assuming that all compactions complete.
-  for (int i = 0; i < num_of_reasons; i++) {
-    ASSERT_EQ(collector.NumberOfCompactions(static_cast<CompactionReason>(i)), counts[i]);
-  }
-#endif /* NDEBUG */
-}
-
 const SstFileMetaData* PickFileRandomly(
    const ColumnFamilyMetaData& cf_meta,
    Random* rand,
@@ -436,7 +360,7 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
      });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "TableCache::GetTableReader:0",
-      [&](void* /*arg*/) { num_new_table_reader++; });
+      [&](void* arg) { num_new_table_reader++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  for (int k = 0; k < options.level0_file_num_compaction_trigger; ++k) {
@@ -992,7 +916,7 @@ TEST_P(DBCompactionTestWithParam, TrivialMoveOneFile) {
  int32_t trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
@@ -1049,10 +973,10 @@ TEST_P(DBCompactionTestWithParam, TrivialMoveNonOverlappingFiles) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial_move++; });
+      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
@@ -1148,10 +1072,10 @@ TEST_P(DBCompactionTestWithParam, TrivialMoveTargetLevel) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial_move++; });
+      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
@@ -1207,10 +1131,10 @@ TEST_P(DBCompactionTestWithParam, ManualCompactionPartial) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial_move++; });
+      [&](void* arg) { non_trivial_move++; });
  bool first = true;
  // Purpose of dependencies:
  // 4 -> 1: ensure the order of two non-trivial compactions
@@ -1221,7 +1145,7 @@ TEST_P(DBCompactionTestWithParam, ManualCompactionPartial) {
       {"DBCompaction::ManualPartial:5", "DBCompaction::ManualPartial:2"},
       {"DBCompaction::ManualPartial:5", "DBCompaction::ManualPartial:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (first) {
          first = false;
          TEST_SYNC_POINT("DBCompaction::ManualPartial:4");
@@ -1352,17 +1276,17 @@ TEST_F(DBCompactionTest, DISABLED_ManualPartialFill) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial_move++; });
+      [&](void* arg) { non_trivial_move++; });
  bool first = true;
  bool second = true;
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      {{"DBCompaction::PartialFill:4", "DBCompaction::PartialFill:1"},
       {"DBCompaction::PartialFill:2", "DBCompaction::PartialFill:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (first) {
          TEST_SYNC_POINT("DBCompaction::PartialFill:4");
          first = false;
@@ -1593,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
@@ -1768,10 +1576,10 @@ TEST_P(DBCompactionTestWithParam, TrivialMoveToLastLevelWithFiles) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial_move++; });
+      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
@@ -2059,125 +1867,6 @@ TEST_P(DBCompactionTestWithParam, LevelCompactionPathUse) {
  Destroy(options);
 }

-TEST_P(DBCompactionTestWithParam, LevelCompactionCFPathUse) {
-  Options options = CurrentOptions();
-  options.db_paths.emplace_back(dbname_, 500 * 1024);
-  options.db_paths.emplace_back(dbname_ + "_2", 4 * 1024 * 1024);
-  options.db_paths.emplace_back(dbname_ + "_3", 1024 * 1024 * 1024);
-  options.memtable_factory.reset(
-    new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
-  options.compaction_style = kCompactionStyleLevel;
-  options.write_buffer_size = 110 << 10;  // 110KB
-  options.arena_block_size = 4 << 10;
-  options.level0_file_num_compaction_trigger = 2;
-  options.num_levels = 4;
-  options.max_bytes_for_level_base = 400 * 1024;
-  options.max_subcompactions = max_subcompactions_;
-
-  std::vector<Options> option_vector;
-  option_vector.emplace_back(options);
-  ColumnFamilyOptions cf_opt1(options), cf_opt2(options);
-  // Configure CF1 specific paths.
-  cf_opt1.cf_paths.emplace_back(dbname_ + "cf1", 500 * 1024);
-  cf_opt1.cf_paths.emplace_back(dbname_ + "cf1_2", 4 * 1024 * 1024);
-  cf_opt1.cf_paths.emplace_back(dbname_ + "cf1_3", 1024 * 1024 * 1024);
-  option_vector.emplace_back(DBOptions(options), cf_opt1);
-  CreateColumnFamilies({"one"},option_vector[1]);
-
-  // Configura CF2 specific paths.
-  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2", 500 * 1024);
-  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2_2", 4 * 1024 * 1024);
-  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2_3", 1024 * 1024 * 1024);
-  option_vector.emplace_back(DBOptions(options), cf_opt2);
-  CreateColumnFamilies({"two"},option_vector[2]);
-
-  ReopenWithColumnFamilies({"default", "one", "two"}, option_vector);
-
-  Random rnd(301);
-  int key_idx = 0;
-  int key_idx1 = 0;
-  int key_idx2 = 0;
-
-  auto generate_file = [&]() {
-    GenerateNewFile(0, &rnd, &key_idx);
-    GenerateNewFile(1, &rnd, &key_idx1);
-    GenerateNewFile(2, &rnd, &key_idx2);
-  };
-
-  auto check_sstfilecount = [&](int path_id, int expected) {
-    ASSERT_EQ(expected, GetSstFileCount(options.db_paths[path_id].path));
-    ASSERT_EQ(expected, GetSstFileCount(cf_opt1.cf_paths[path_id].path));
-    ASSERT_EQ(expected, GetSstFileCount(cf_opt2.cf_paths[path_id].path));
-  };
-
-  auto check_filesperlevel = [&](const std::string& expected) {
-    ASSERT_EQ(expected, FilesPerLevel(0));
-    ASSERT_EQ(expected, FilesPerLevel(1));
-    ASSERT_EQ(expected, FilesPerLevel(2));
-  };
-
-  auto check_getvalues = [&]() {
-    for (int i = 0; i < key_idx; i++) {
-      auto v = Get(0, Key(i));
-      ASSERT_NE(v, "NOT_FOUND");
-      ASSERT_TRUE(v.size() == 1 || v.size() == 990);
-    }
-
-    for (int i = 0; i < key_idx1; i++) {
-      auto v = Get(1, Key(i));
-      ASSERT_NE(v, "NOT_FOUND");
-      ASSERT_TRUE(v.size() == 1 || v.size() == 990);
-    }
-
-    for (int i = 0; i < key_idx2; i++) {
-      auto v = Get(2, Key(i));
-      ASSERT_NE(v, "NOT_FOUND");
-      ASSERT_TRUE(v.size() == 1 || v.size() == 990);
-    }
-  };
-
-  // Check that default column family uses db_paths.
-  // And Column family "one" uses cf_paths.
-
-  // First three 110KB files are not going to second path.
-  // After that, (100K, 200K)
-  for (int num = 0; num < 3; num++) {
-    generate_file();
-  }
-
-  // Another 110KB triggers a compaction to 400K file to fill up first path
-  generate_file();
-  check_sstfilecount(1, 3);
-
-  // (1, 4)
-  generate_file();
-  check_filesperlevel("1,4");
-  check_sstfilecount(1, 4);
-  check_sstfilecount(0, 1);
-
-  // (1, 4, 1)
-  generate_file();
-  check_filesperlevel("1,4,1");
-  check_sstfilecount(2, 1);
-  check_sstfilecount(1, 4);
-  check_sstfilecount(0, 1);
-
-  // (1, 4, 2)
-  generate_file();
-  check_filesperlevel("1,4,2");
-  check_sstfilecount(2, 2);
-  check_sstfilecount(1, 4);
-  check_sstfilecount(0, 1);
-
-  check_getvalues();
-
-  ReopenWithColumnFamilies({"default", "one", "two"}, option_vector);
-
-  check_getvalues();
-
-  Destroy(options, true);
-}
-
 TEST_P(DBCompactionTestWithParam, ConvertCompactionStyle) {
  Random rnd(301);
  int max_key_level_insert = 200;
@@ -2768,16 +2457,16 @@ TEST_P(DBCompactionTestWithParam, CompressLevelCompaction) {

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "Compaction::InputCompressionMatchesOutput:Matches",
-      [&](void* /*arg*/) { matches++; });
+      [&](void* arg) { matches++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "Compaction::InputCompressionMatchesOutput:DidntMatch",
-      [&](void* /*arg*/) { didnt_match++; });
+      [&](void* arg) { didnt_match++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial++; });
+      [&](void* arg) { non_trivial++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Reopen(options);
@@ -2939,14 +2628,13 @@ TEST_P(DBCompactionTestWithParam, ForceBottommostLevelCompaction) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial_move++; });
+      [&](void* arg) { non_trivial_move++; });
  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);
@@ -3286,13 +2974,6 @@ TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
  // compactions should be triggered, which reduce the size of each bottom-level
  // file without changing file count.
  db_->ReleaseSnapshot(snapshot);
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
-        Compaction* compaction = reinterpret_cast<Compaction*>(arg);
-        ASSERT_TRUE(compaction->compaction_reason() ==
-                    CompactionReason::kBottommostFiles);
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  dbfull()->TEST_WaitForCompact();
  db_->GetLiveFilesMetaData(&post_release_metadata);
  ASSERT_EQ(pre_release_metadata.size(), post_release_metadata.size());
@@ -3306,358 +2987,6 @@ TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
    // deletion markers/deleted keys.
    ASSERT_LT(post_file.size, pre_file.size);
  }
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_F(DBCompactionTest, LevelCompactExpiredTtlFiles) {
-  const int kNumKeysPerFile = 32;
-  const int kNumLevelFiles = 2;
-  const int kValueSize = 1024;
-
-  Options options = CurrentOptions();
-  options.compression = kNoCompression;
-  options.ttl = 24 * 60 * 60;  // 24 hours
-  options.max_open_files = -1;
-  env_->time_elapse_only_sleep_ = false;
-  options.env = env_;
-
-  env_->addon_time_.store(0);
-  DestroyAndReopen(options);
-
-  Random rnd(301);
-  for (int i = 0; i < kNumLevelFiles; ++i) {
-    for (int j = 0; j < kNumKeysPerFile; ++j) {
-      ASSERT_OK(
-          Put(Key(i * kNumKeysPerFile + j), RandomString(&rnd, kValueSize)));
-    }
-    Flush();
-  }
-  Flush();
-  dbfull()->TEST_WaitForCompact();
-  MoveFilesToLevel(3);
-  ASSERT_EQ("0,0,0,2", FilesPerLevel());
-
-  for (int i = 0; i < kNumLevelFiles; ++i) {
-    for (int j = 0; j < kNumKeysPerFile; ++j) {
-      // Overwrite previous keys with smaller, but predictable, values.
-      ASSERT_OK(Delete(Key(i * kNumKeysPerFile + j)));
-    }
-    Flush();
-  }
-  dbfull()->TEST_WaitForCompact();
-  ASSERT_EQ("2,0,0,2", FilesPerLevel());
-  MoveFilesToLevel(1);
-  ASSERT_EQ("0,2,0,2", FilesPerLevel());
-
-  env_->addon_time_.fetch_add(36 * 60 * 60);  // 36 hours
-  ASSERT_EQ("0,2,0,2", FilesPerLevel());
-
-  // Just do a siimple write + flush so that the Ttl expired files get
-  // compacted.
-  ASSERT_OK(Put("a", "1"));
-  Flush();
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
-        Compaction* compaction = reinterpret_cast<Compaction*>(arg);
-        ASSERT_TRUE(compaction->compaction_reason() == CompactionReason::kTtl);
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  dbfull()->TEST_WaitForCompact();
-  // All non-L0 files are deleted, as they contained only deleted data.
-  ASSERT_EQ("1", FilesPerLevel());
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-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());
-      }
-    }
-  }
-}
-
-TEST_F(DBCompactionTest, CompactionStatsTest) {
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = 2;
-  CompactionStatsCollector* collector = new CompactionStatsCollector();
-  options.listeners.emplace_back(collector);
-  DestroyAndReopen(options);
-
-  for (int i = 0; i < 32; i++) {
-    for (int j = 0; j < 5000; j++) {
-      Put(std::to_string(j), std::string(1, 'A'));
-    }
-    ASSERT_OK(Flush());
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-  }
-  dbfull()->TEST_WaitForCompact();
-  ColumnFamilyHandleImpl* cfh =
-      static_cast<ColumnFamilyHandleImpl*>(dbfull()->DefaultColumnFamily());
-  ColumnFamilyData* cfd = cfh->cfd();
-
-  VerifyCompactionStats(*cfd, *collector);
 }

 INSTANTIATE_TEST_CASE_P(DBCompactionTestWithParam, DBCompactionTestWithParam,
@@ -3679,7 +3008,7 @@ TEST_P(DBCompactionDirectIOTest, DirectIO) {
      "TableCache::NewIterator:for_compaction", [&](void* arg) {
        bool* use_direct_reads = static_cast<bool*>(arg);
        ASSERT_EQ(*use_direct_reads,
-                  options.use_direct_reads);
+                  options.use_direct_io_for_flush_and_compaction);
      });
  SyncPoint::GetInstance()->SetCallBack(
      "CompactionJob::OpenCompactionOutputFile", [&](void* arg) {
@@ -3689,7 +3018,7 @@ TEST_P(DBCompactionDirectIOTest, DirectIO) {
      });
  if (options.use_direct_io_for_flush_and_compaction) {
    SyncPoint::GetInstance()->SetCallBack(
-        "SanitizeOptions:direct_io", [&](void* /*arg*/) {
+        "SanitizeOptions:direct_io", [&](void* arg) {
          readahead = true;
        });
  }
@@ -3698,7 +3027,7 @@ TEST_P(DBCompactionDirectIOTest, DirectIO) {
  MakeTables(3, "p", "q", 1);
  ASSERT_EQ("1,1,1", FilesPerLevel(1));
  Compact(1, "p1", "p9");
-  ASSERT_EQ(readahead, options.use_direct_reads);
+  ASSERT_FALSE(readahead ^ options.use_direct_io_for_flush_and_compaction);
  ASSERT_EQ("0,0,1", FilesPerLevel(1));
  Destroy(options);
  delete options.env;
@@ -3766,8 +3095,6 @@ int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
 #else
-  (void) argc;
-  (void) argv;
  return 0;
 #endif
 }
@@ -194,7 +194,7 @@ TEST_F(DBTestDynamicLevel, DynamicLevelMaxBytesBase2) {
  // Hold compaction jobs to make sure
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "CompactionJob::Run():Start",
-      [&](void* /*arg*/) { env_->SleepForMicroseconds(100000); });
+      [&](void* arg) { env_->SleepForMicroseconds(100000); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "true"},
@@ -378,7 +378,7 @@ TEST_F(DBTestDynamicLevel, DynamicLevelMaxBytesBaseInc) {
  int non_trivial = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
-      [&](void* /*arg*/) { non_trivial++; });
+      [&](void* arg) { non_trivial++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Random rnd(301);
@@ -501,8 +501,6 @@ int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
 #else
-  (void) argc;
-  (void) argv;
  return 0;
 #endif
 }
@@ -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();
@@ -72,23 +72,19 @@ TEST_F(DBFlushTest, SyncFail) {
  auto* cfd =
      reinterpret_cast<ColumnFamilyHandleImpl*>(db_->DefaultColumnFamily())
          ->cfd();
+  int refs_before = cfd->current()->TEST_refs();
  FlushOptions flush_options;
  flush_options.wait = false;
  ASSERT_OK(dbfull()->Flush(flush_options));
-  // Flush installs a new super-version. Get the ref count after that.
-  auto current_before = cfd->current();
-  int refs_before = cfd->current()->TEST_refs();
  fault_injection_env->SetFilesystemActive(false);
  TEST_SYNC_POINT("DBFlushTest::SyncFail:1");
  TEST_SYNC_POINT("DBFlushTest::SyncFail:2");
  fault_injection_env->SetFilesystemActive(true);
-  // Now the background job will do the flush; wait for it.
  dbfull()->TEST_WaitForFlushMemTable();
 #ifndef ROCKSDB_LITE
  ASSERT_EQ("", FilesPerLevel());  // flush failed.
 #endif                             // ROCKSDB_LITE
-  // Backgroun flush job should release ref count to current version.
-  ASSERT_EQ(current_before, cfd->current());
+  // Flush job should release ref count to current version.
  ASSERT_EQ(refs_before, cfd->current()->TEST_refs());
  Destroy(options);
 }
@@ -105,7 +101,7 @@ TEST_F(DBFlushTest, FlushInLowPriThreadPool) {
  std::thread::id tid;
  int num_flushes = 0, num_compactions = 0;
  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BGWorkFlush", [&](void* /*arg*/) {
+      "DBImpl::BGWorkFlush", [&](void* arg) {
        if (tid == std::thread::id()) {
          tid = std::this_thread::get_id();
        } else {
@@ -114,7 +110,7 @@ TEST_F(DBFlushTest, FlushInLowPriThreadPool) {
        ++num_flushes;
      });
  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BGWorkCompaction", [&](void* /*arg*/) {
+      "DBImpl::BGWorkCompaction", [&](void* arg) {
        ASSERT_EQ(tid, std::this_thread::get_id());
        ++num_compactions;
      });
@@ -141,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"));
@@ -189,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());

@@ -97,7 +97,7 @@

 namespace rocksdb {
 const std::string kDefaultColumnFamilyName("default");
-void DumpRocksDBBuildVersion(Logger* log);
+void DumpRocksDBBuildVersion(Logger * log);

 CompressionType GetCompressionFlush(
    const ImmutableCFOptions& ioptions,
@@ -135,7 +135,7 @@ void DumpSupportInfo(Logger* logger) {
 }

 int64_t kDefaultLowPriThrottledRate = 2 * 1024 * 1024;
-}  // namespace
+} // namespace

 DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
               const bool seq_per_batch)
@@ -183,7 +183,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      last_stats_dump_time_microsec_(0),
      next_job_id_(1),
      has_unpersisted_data_(false),
-      unable_to_release_oldest_log_(false),
+      unable_to_flush_oldest_log_(false),
      env_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
      env_options_for_compaction_(env_->OptimizeForCompactionTableWrite(
          env_options_, immutable_db_options_)),
@@ -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;
@@ -300,8 +299,6 @@ Status DBImpl::CloseHelper() {
    TEST_SYNC_POINT("DBImpl::~DBImpl:WaitJob");
    bg_cv_.Wait();
  }
-  TEST_SYNC_POINT_CALLBACK("DBImpl::CloseHelper:PendingPurgeFinished",
-                           &files_grabbed_for_purge_);
  EraseThreadStatusDbInfo();
  flush_scheduler_.Clear();

@@ -352,19 +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();

@@ -398,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) {
@@ -515,16 +491,7 @@ void DBImpl::ScheduleBgLogWriterClose(JobContext* job_context) {
  }
 }

-Directory* DBImpl::GetDataDir(ColumnFamilyData* cfd, size_t path_id) const {
-  assert(cfd);
-  Directory* ret_dir = cfd->GetDataDir(path_id);
-  if (ret_dir == nullptr) {
-    return directories_.GetDataDir(path_id);
-  }
-  return ret_dir;
-}
-
-Directory* DBImpl::Directories::GetDataDir(size_t path_id) const {
+Directory* DBImpl::Directories::GetDataDir(size_t path_id) {
  assert(path_id < data_dirs_.size());
  Directory* ret_dir = data_dirs_[path_id].get();
  if (ret_dir == nullptr) {
@@ -534,12 +501,9 @@ Directory* DBImpl::Directories::GetDataDir(size_t path_id) const {
  return ret_dir;
 }

-Status DBImpl::SetOptions(
-    ColumnFamilyHandle* column_family,
+Status DBImpl::SetOptions(ColumnFamilyHandle* column_family,
    const std::unordered_map<std::string, std::string>& options_map) {
 #ifdef ROCKSDB_LITE
-  (void)column_family;
-  (void)options_map;
  return Status::NotSupported("Not supported in ROCKSDB LITE");
 #else
  auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family)->cfd();
@@ -571,14 +535,13 @@ Status DBImpl::SetOptions(

      persist_options_status = WriteOptionsFile(
          false /*need_mutex_lock*/, true /*need_enter_write_thread*/);
-      bg_cv_.SignalAll();
    }
  }
  sv_context.Clean();

-  ROCKS_LOG_INFO(
-      immutable_db_options_.info_log,
-      "SetOptions() on column family [%s], inputs:", cfd->GetName().c_str());
+  ROCKS_LOG_INFO(immutable_db_options_.info_log,
+                 "SetOptions() on column family [%s], inputs:",
+                 cfd->GetName().c_str());
  for (const auto& o : options_map) {
    ROCKS_LOG_INFO(immutable_db_options_.info_log, "%s: %s\n", o.first.c_str(),
                   o.second.c_str());
@@ -602,7 +565,6 @@ Status DBImpl::SetOptions(
 Status DBImpl::SetDBOptions(
    const std::unordered_map<std::string, std::string>& options_map) {
 #ifdef ROCKSDB_LITE
-  (void)options_map;
  return Status::NotSupported("Not supported in ROCKSDB LITE");
 #else
  if (options_map.empty()) {
@@ -629,8 +591,7 @@ Status DBImpl::SetDBOptions(
        MaybeScheduleFlushOrCompaction();
      }

-      write_controller_.set_max_delayed_write_rate(
-          new_options.delayed_write_rate);
+      write_controller_.set_max_delayed_write_rate(new_options.delayed_write_rate);
      table_cache_.get()->SetCapacity(new_options.max_open_files == -1
                                          ? TableCache::kInfiniteCapacity
                                          : new_options.max_open_files - 10);
@@ -690,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;
@@ -710,7 +670,7 @@ int DBImpl::FindMinimumEmptyLevelFitting(
 }

 Status DBImpl::FlushWAL(bool sync) {
-  if (manual_wal_flush_) {
+  {
    // We need to lock log_write_mutex_ since logs_ might change concurrently
    InstrumentedMutexLock wl(&log_write_mutex_);
    log::Writer* cur_log_writer = logs_.back().writer;
@@ -724,9 +684,6 @@ Status DBImpl::FlushWAL(bool sync) {
      return s;
    }
  }
-  if (!sync) {
-    return Status::OK();
-  }
  // sync = true
  ROCKS_LOG_DEBUG(immutable_db_options_.info_log, "FlushWAL sync=true");
  return SyncWAL();
@@ -794,10 +751,12 @@ Status DBImpl::SyncWAL() {
  return status;
 }

-void DBImpl::MarkLogsSynced(uint64_t up_to, bool synced_dir,
-                            const Status& status) {
+void DBImpl::MarkLogsSynced(
+    uint64_t up_to, bool synced_dir, const Status& status) {
  mutex_.AssertHeld();
-  if (synced_dir && logfile_number_ == up_to && status.ok()) {
+  if (synced_dir &&
+      logfile_number_ == up_to &&
+      status.ok()) {
    log_dir_synced_ = true;
  }
  for (auto it = logs_.begin(); it != logs_.end() && it->number <= up_to;) {
@@ -871,14 +830,14 @@ void DBImpl::BackgroundCallPurge() {
    if (!purge_queue_.empty()) {
      auto purge_file = purge_queue_.begin();
      auto fname = purge_file->fname;
-      auto dir_to_sync = purge_file->dir_to_sync;
      auto type = purge_file->type;
      auto number = purge_file->number;
+      auto path_id = purge_file->path_id;
      auto job_id = purge_file->job_id;
      purge_queue_.pop_front();

      mutex_.Unlock();
-      DeleteObsoleteFileImpl(job_id, fname, dir_to_sync, type, number);
+      DeleteObsoleteFileImpl(job_id, fname, type, number, path_id);
      mutex_.Lock();
    } else {
      assert(!logs_to_free_queue_.empty());
@@ -914,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()) {
@@ -1034,8 +993,8 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
    // Because prep_seq > snapshot => commit_seq > snapshot so if a snapshot is
    // specified we should be fine with skipping seq numbers that are greater
    // than that.
-    snapshot =
-        reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)->number_;
+    snapshot = reinterpret_cast<const SnapshotImpl*>(
+        read_options.snapshot)->number_;
  } else {
    // Since we get and reference the super version before getting
    // the snapshot number, without a mutex protection, it is possible
@@ -1113,6 +1072,7 @@ std::vector<Status> DBImpl::MultiGet(
    const ReadOptions& read_options,
    const std::vector<ColumnFamilyHandle*>& column_family,
    const std::vector<Slice>& keys, std::vector<std::string>* values) {
+
  StopWatch sw(env_, stats_, DB_MULTIGET);
  PERF_TIMER_GUARD(get_snapshot_time);

@@ -1136,8 +1096,8 @@ std::vector<Status> DBImpl::MultiGet(

  mutex_.Lock();
  if (read_options.snapshot != nullptr) {
-    snapshot =
-        reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)->number_;
+    snapshot = reinterpret_cast<const SnapshotImpl*>(
+        read_options.snapshot)->number_;
  } else {
    snapshot = last_seq_same_as_publish_seq_
                   ? versions_->LastSequence()
@@ -1165,7 +1125,6 @@ std::vector<Status> DBImpl::MultiGet(
  // First look in the memtable, then in the immutable memtable (if any).
  // s is both in/out. When in, s could either be OK or MergeInProgress.
  // merge_operands will contain the sequence of merges in the latter case.
-  size_t num_found = 0;
  for (size_t i = 0; i < num_keys; ++i) {
    merge_context.Clear();
    Status& s = stat_list[i];
@@ -1187,11 +1146,11 @@ std::vector<Status> DBImpl::MultiGet(
      if (super_version->mem->Get(lkey, value, &s, &merge_context,
                                  &range_del_agg, read_options)) {
        done = true;
-        RecordTick(stats_, MEMTABLE_HIT);
+        // TODO(?): RecordTick(stats_, MEMTABLE_HIT)?
      } else if (super_version->imm->Get(lkey, value, &s, &merge_context,
                                         &range_del_agg, read_options)) {
        done = true;
-        RecordTick(stats_, MEMTABLE_HIT);
+        // TODO(?): RecordTick(stats_, MEMTABLE_HIT)?
      }
    }
    if (!done) {
@@ -1200,12 +1159,11 @@ std::vector<Status> DBImpl::MultiGet(
      super_version->current->Get(read_options, lkey, &pinnable_val, &s,
                                  &merge_context, &range_del_agg);
      value->assign(pinnable_val.data(), pinnable_val.size());
-      RecordTick(stats_, MEMTABLE_MISS);
+      // TODO(?): RecordTick(stats_, MEMTABLE_MISS)?
    }

    if (s.ok()) {
      bytes_read += value->size();
-      num_found++;
    }
  }

@@ -1233,7 +1191,6 @@ std::vector<Status> DBImpl::MultiGet(

  RecordTick(stats_, NUMBER_MULTIGET_CALLS);
  RecordTick(stats_, NUMBER_MULTIGET_KEYS_READ, num_keys);
-  RecordTick(stats_, NUMBER_MULTIGET_KEYS_FOUND, num_found);
  RecordTick(stats_, NUMBER_MULTIGET_BYTES_READ, bytes_read);
  MeasureTime(stats_, BYTES_PER_MULTIGET, bytes_read);
  PERF_COUNTER_ADD(multiget_read_bytes, bytes_read);
@@ -1321,17 +1278,6 @@ Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
  if (s.ok() && immutable_db_options_.allow_concurrent_memtable_write) {
    s = CheckConcurrentWritesSupported(cf_options);
  }
-  if (s.ok()) {
-    s = CheckCFPathsSupported(initial_db_options_, cf_options);
-  }
-  if (s.ok()) {
-    for (auto& cf_path : cf_options.cf_paths) {
-      s = env_->CreateDirIfMissing(cf_path.path);
-      if (!s.ok()) {
-        break;
-      }
-    }
-  }
  if (!s.ok()) {
    return s;
  }
@@ -1363,19 +1309,13 @@ Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
                                 &cf_options);
      write_thread_.ExitUnbatched(&w);
    }
-    if (s.ok()) {
-      auto* cfd =
-          versions_->GetColumnFamilySet()->GetColumnFamily(column_family_name);
-      assert(cfd != nullptr);
-      s = cfd->AddDirectories();
-    }
    if (s.ok()) {
      single_column_family_mode_ = false;
      auto* cfd =
          versions_->GetColumnFamilySet()->GetColumnFamily(column_family_name);
      assert(cfd != nullptr);
-      InstallSuperVersionAndScheduleWork(cfd, &sv_context,
-                                         *cfd->GetLatestMutableCFOptions());
+      InstallSuperVersionAndScheduleWork(
+              cfd, &sv_context, *cfd->GetLatestMutableCFOptions());

      if (!cfd->mem()->IsSnapshotSupported()) {
        is_snapshot_supported_ = false;
@@ -1457,8 +1397,8 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
      // we drop column family from a single write thread
      WriteThread::Writer w;
      write_thread_.EnterUnbatched(&w, &mutex_);
-      s = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(), &edit,
-                                 &mutex_);
+      s = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
+                                 &edit, &mutex_);
      write_thread_.ExitUnbatched(&w);
    }
    if (s.ok()) {
@@ -1479,7 +1419,6 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
      }
      is_snapshot_supported_ = new_is_snapshot_supported;
    }
-    bg_cv_.SignalAll();
  }

  if (s.ok()) {
@@ -1508,7 +1447,7 @@ bool DBImpl::KeyMayExist(const ReadOptions& read_options,
    *value_found = true;
  }
  ReadOptions roptions = read_options;
-  roptions.read_tier = kBlockCacheTier;  // read from block cache only
+  roptions.read_tier = kBlockCacheTier; // read from block cache only
  PinnableSlice pinnable_val;
  auto s = GetImpl(roptions, column_family, key, &pinnable_val, value_found);
  value->assign(pinnable_val.data(), pinnable_val.size());
@@ -1531,17 +1470,17 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
  if (immutable_db_options_.preserve_deletes &&
      read_options.iter_start_seqnum > 0 &&
      read_options.iter_start_seqnum < preserve_deletes_seqnum_.load()) {
-    return NewErrorIterator(Status::InvalidArgument(
-        "Iterator requested internal keys which are too old and are not"
-        " guaranteed to be preserved, try larger iter_start_seqnum opt."));
-  }
+        return NewErrorIterator(Status::InvalidArgument(
+          "Iterator requested internal keys which are too old and are not"
+          " guaranteed to be preserved, try larger iter_start_seqnum opt."));
+      }
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
  auto cfd = cfh->cfd();
  ReadCallback* read_callback = nullptr;  // No read callback provided.
  if (read_options.managed) {
 #ifdef ROCKSDB_LITE
    // not supported in lite version
-    result = NewErrorIterator(Status::InvalidArgument(
+    result =  NewErrorIterator(Status::InvalidArgument(
        "Managed Iterators not supported in RocksDBLite."));
 #else
    if ((read_options.tailing) || (read_options.snapshot != nullptr) ||
@@ -1550,7 +1489,7 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
    } else {
      // Managed iter not supported
      result = NewErrorIterator(Status::InvalidArgument(
-          "Managed Iterators not supported without snapshots."));
+        "Managed Iterators not supported without snapshots."));
    }
 #endif
  } else if (read_options.tailing) {
@@ -1561,11 +1500,11 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
 #else
    SuperVersion* sv = cfd->GetReferencedSuperVersion(&mutex_);
    auto iter = new ForwardIterator(this, read_options, cfd, sv);
-    result =
-        NewDBIterator(env_, read_options, *cfd->ioptions(),
-                      cfd->user_comparator(), iter, kMaxSequenceNumber,
-                      sv->mutable_cf_options.max_sequential_skip_in_iterations,
-                      read_callback);
+    result = NewDBIterator(
+        env_, read_options, *cfd->ioptions(), cfd->user_comparator(), iter,
+        kMaxSequenceNumber,
+        sv->mutable_cf_options.max_sequential_skip_in_iterations,
+        read_callback);
 #endif
  } else {
    // Note: no need to consider the special case of
@@ -1695,8 +1634,8 @@ Status DBImpl::NewIterators(
                        ? read_options.snapshot->GetSequenceNumber()
                        : versions_->LastSequence();
    for (size_t i = 0; i < column_families.size(); ++i) {
-      auto* cfd =
-          reinterpret_cast<ColumnFamilyHandleImpl*>(column_families[i])->cfd();
+      auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(
+          column_families[i])->cfd();
      iterators->push_back(
          NewIteratorImpl(read_options, cfd, snapshot, read_callback));
    }
@@ -1713,7 +1652,7 @@ const Snapshot* DBImpl::GetSnapshotForWriteConflictBoundary() {
 }
 #endif  // ROCKSDB_LITE

-SnapshotImpl* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary) {
+const Snapshot* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary) {
  int64_t unix_time = 0;
  env_->GetCurrentTime(&unix_time);  // Ignore error
  SnapshotImpl* s = new SnapshotImpl;
@@ -1803,9 +1742,13 @@ Status DBImpl::GetPropertiesOfTablesInRange(ColumnFamilyHandle* column_family,

 #endif  // ROCKSDB_LITE

-const std::string& DBImpl::GetName() const { return dbname_; }
+const std::string& DBImpl::GetName() const {
+  return dbname_;
+}

-Env* DBImpl::GetEnv() const { return env_; }
+Env* DBImpl::GetEnv() const {
+  return env_;
+}

 Options DBImpl::GetOptions(ColumnFamilyHandle* column_family) const {
  InstrumentedMutexLock l(&mutex_);
@@ -2178,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
@@ -2195,64 +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()) {
@@ -2263,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;
@@ -2289,8 +2220,9 @@ void DBImpl::GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata) {
  versions_->GetLiveFilesMetaData(metadata);
 }

-void DBImpl::GetColumnFamilyMetaData(ColumnFamilyHandle* column_family,
-                                     ColumnFamilyMetaData* cf_meta) {
+void DBImpl::GetColumnFamilyMetaData(
+    ColumnFamilyHandle* column_family,
+    ColumnFamilyMetaData* cf_meta) {
  assert(column_family);
  auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family)->cfd();
  auto* sv = GetAndRefSuperVersion(cfd);
@@ -2367,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("");
 }

@@ -2416,17 +2348,14 @@ Status DB::ListColumnFamilies(const DBOptions& db_options,
  return VersionSet::ListColumnFamilies(column_families, name, db_options.env);
 }

-Snapshot::~Snapshot() {}
+Snapshot::~Snapshot() {
+}

-Status DestroyDB(const std::string& dbname, const Options& options,
-                 const std::vector<ColumnFamilyDescriptor>& column_families) {
-  ImmutableDBOptions soptions(SanitizeOptions(dbname, options));
+Status DestroyDB(const std::string& dbname, const Options& 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);

@@ -2437,15 +2366,15 @@ Status DestroyDB(const std::string& dbname, const Options& options,
    uint64_t number;
    FileType type;
    InfoLogPrefix info_log_prefix(!soptions.db_log_dir.empty(), dbname);
-    for (const auto& fname : filenames) {
-      if (ParseFileName(fname, &number, info_log_prefix.prefix, &type) &&
-        type != kDBLockFile) {  // Lock file will be deleted at end
+    for (size_t i = 0; i < filenames.size(); i++) {
+      if (ParseFileName(filenames[i], &number, info_log_prefix.prefix, &type) &&
+          type != kDBLockFile) {  // Lock file will be deleted at end
        Status del;
-        std::string path_to_delete = dbname + "/" + fname;
+        std::string path_to_delete = dbname + "/" + filenames[i];
        if (type == kMetaDatabase) {
          del = DestroyDB(path_to_delete, options);
        } else if (type == kTableFile) {
-          del = DeleteSSTFile(&soptions, path_to_delete, dbname);
+          del = DeleteSSTFile(&soptions, path_to_delete, 0);
        } else {
          del = env->DeleteFile(path_to_delete);
        }
@@ -2455,82 +2384,59 @@ Status DestroyDB(const std::string& dbname, const Options& options,
      }
    }

-    std::vector<std::string> paths;
-
-    for (const auto& path : options.db_paths) {
-      paths.emplace_back(path.path);
-    }
-    for (const auto& cf : column_families) {
-      for (const auto& path : cf.options.cf_paths) {
-        paths.emplace_back(path.path);
-      }
-    }
-
-    // Remove duplicate paths.
-    // Note that we compare only the actual paths but not path ids.
-    // This reason is that same path can appear at different path_ids
-    // for different column families.
-    std::sort(paths.begin(), paths.end());
-    paths.erase(std::unique(paths.begin(), paths.end()), paths.end());
-
-    for (const auto& path : paths) {
-      if (env->GetChildren(path, &filenames).ok()) {
-        for (const auto& fname : filenames) {
-          if (ParseFileName(fname, &number, &type) &&
+    for (size_t path_id = 0; path_id < options.db_paths.size(); path_id++) {
+      const auto& db_path = options.db_paths[path_id];
+      env->GetChildren(db_path.path, &filenames);
+      for (size_t i = 0; i < filenames.size(); i++) {
+        if (ParseFileName(filenames[i], &number, &type) &&
            type == kTableFile) {  // Lock file will be deleted at end
-            std::string table_path = path + "/" + fname;
-            Status del = DeleteSSTFile(&soptions, table_path, dbname);
-            if (result.ok() && !del.ok()) {
-              result = del;
-            }
+          std::string table_path = db_path.path + "/" + filenames[i];
+          Status del = DeleteSSTFile(&soptions, table_path,
+                                     static_cast<uint32_t>(path_id));
+          if (result.ok() && !del.ok()) {
+            result = del;
          }
        }
-        env->DeleteDir(path);
      }
    }

    std::vector<std::string> walDirFiles;
    std::string archivedir = ArchivalDirectory(dbname);
-    bool wal_dir_exists = false;
    if (dbname != soptions.wal_dir) {
-      wal_dir_exists = env->GetChildren(soptions.wal_dir, &walDirFiles).ok();
+      env->GetChildren(soptions.wal_dir, &walDirFiles);
      archivedir = ArchivalDirectory(soptions.wal_dir);
    }

-    // Archive dir may be inside wal dir or dbname and should be
-    // processed and removed before those otherwise we have issues
-    // removing them
-    std::vector<std::string> archiveFiles;
-    if (env->GetChildren(archivedir, &archiveFiles).ok()) {
-      // Delete archival files.
-      for (const auto& file : archiveFiles) {
-        if (ParseFileName(file, &number, &type) &&
-          type == kLogFile) {
-          Status del = env->DeleteFile(archivedir + "/" + file);
-          if (result.ok() && !del.ok()) {
-            result = del;
-          }
+    // Delete log files in the WAL dir
+    for (const auto& file : walDirFiles) {
+      if (ParseFileName(file, &number, &type) && type == kLogFile) {
+        Status del = env->DeleteFile(LogFileName(soptions.wal_dir, number));
+        if (result.ok() && !del.ok()) {
+          result = del;
        }
      }
-      env->DeleteDir(archivedir);
    }

-    // Delete log files in the WAL dir
-    if (wal_dir_exists) {
-      for (const auto& file : walDirFiles) {
-        if (ParseFileName(file, &number, &type) && type == kLogFile) {
-          Status del = env->DeleteFile(LogFileName(soptions.wal_dir, number));
-          if (result.ok() && !del.ok()) {
-            result = del;
-          }
+    std::vector<std::string> archiveFiles;
+    env->GetChildren(archivedir, &archiveFiles);
+    // Delete archival files.
+    for (size_t i = 0; i < archiveFiles.size(); ++i) {
+      if (ParseFileName(archiveFiles[i], &number, &type) &&
+          type == kLogFile) {
+        Status del = env->DeleteFile(archivedir + "/" + archiveFiles[i]);
+        if (result.ok() && !del.ok()) {
+          result = del;
        }
      }
-      env->DeleteDir(soptions.wal_dir);
    }

+    // ignore case where no archival directory is present
+    env->DeleteDir(archivedir);
+
    env->UnlockFile(lock);  // Ignore error since state is already gone
    env->DeleteFile(lockname);
    env->DeleteDir(dbname);  // Ignore error in case dir contains other files
+    env->DeleteDir(soptions.wal_dir);
  }
  return result;
 }
@@ -2592,9 +2498,6 @@ Status DBImpl::WriteOptionsFile(bool need_mutex_lock,
                             s.ToString().c_str());
    }
  }
-#else
-  (void)need_mutex_lock;
-  (void)need_enter_write_thread;
 #endif  // !ROCKSDB_LITE
  return Status::OK();
 }
@@ -2663,21 +2566,22 @@ Status DBImpl::RenameTempFileToOptionsFile(const std::string& file_name) {
  DeleteObsoleteOptionsFiles();
  return s;
 #else
-  (void)file_name;
  return Status::OK();
 #endif  // !ROCKSDB_LITE
 }

 #ifdef ROCKSDB_USING_THREAD_STATUS

-void DBImpl::NewThreadStatusCfInfo(ColumnFamilyData* cfd) const {
+void DBImpl::NewThreadStatusCfInfo(
+    ColumnFamilyData* cfd) const {
  if (immutable_db_options_.enable_thread_tracking) {
    ThreadStatusUtil::NewColumnFamilyInfo(this, cfd, cfd->GetName(),
                                          cfd->ioptions()->env);
  }
 }

-void DBImpl::EraseThreadStatusCfInfo(ColumnFamilyData* cfd) const {
+void DBImpl::EraseThreadStatusCfInfo(
+    ColumnFamilyData* cfd) const {
  if (immutable_db_options_.enable_thread_tracking) {
    ThreadStatusUtil::EraseColumnFamilyInfo(cfd);
  }
@@ -2690,16 +2594,21 @@ void DBImpl::EraseThreadStatusDbInfo() const {
 }

 #else
-void DBImpl::NewThreadStatusCfInfo(ColumnFamilyData* /*cfd*/) const {}
+void DBImpl::NewThreadStatusCfInfo(
+    ColumnFamilyData* cfd) const {
+}

-void DBImpl::EraseThreadStatusCfInfo(ColumnFamilyData* /*cfd*/) const {}
+void DBImpl::EraseThreadStatusCfInfo(
+    ColumnFamilyData* cfd) const {
+}

-void DBImpl::EraseThreadStatusDbInfo() const {}
+void DBImpl::EraseThreadStatusDbInfo() const {
+}
 #endif  // ROCKSDB_USING_THREAD_STATUS

 //
 // A global method that can dump out the build version
-void DumpRocksDBBuildVersion(Logger* log) {
+void DumpRocksDBBuildVersion(Logger * log) {
 #if !defined(IOS_CROSS_COMPILE)
  // if we compile with Xcode, we don't run build_detect_version, so we don't
  // generate util/build_version.cc
@@ -2836,7 +2745,7 @@ Status DBImpl::IngestExternalFile(
  if (ingestion_options.ingest_behind) {
    if (!immutable_db_options_.allow_ingest_behind) {
      return Status::InvalidArgument(
-          "Can't ingest_behind file in DB with allow_ingest_behind=false");
+        "Can't ingest_behind file in DB with allow_ingest_behind=false");
    }
  }

@@ -2887,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();
      }
    }
@@ -2912,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
@@ -2969,12 +2876,11 @@ Status DBImpl::VerifyChecksum() {
  }
  for (auto& sv : sv_list) {
    VersionStorageInfo* vstorage = sv->current->storage_info();
-    ColumnFamilyData* cfd = sv->current->cfd();
    for (int i = 0; i < vstorage->num_non_empty_levels() && s.ok(); i++) {
      for (size_t j = 0; j < vstorage->LevelFilesBrief(i).num_files && s.ok();
           j++) {
        const auto& fd = vstorage->LevelFilesBrief(i).files[j].fd;
-        std::string fname = TableFileName(cfd->ioptions()->cf_paths,
+        std::string fname = TableFileName(immutable_db_options_.db_paths,
                                          fd.GetNumber(), fd.GetPathId());
        s = rocksdb::VerifySstFileChecksum(options, env_options, fname);
      }
@@ -2992,7 +2898,7 @@ Status DBImpl::VerifyChecksum() {
      }
    }
    for (auto cfd : cfd_list) {
-      cfd->Unref();
+        cfd->Unref();
    }
  }
  return s;
@@ -3028,4 +2934,5 @@ void DBImpl::WaitForIngestFile() {
 }

 #endif  // ROCKSDB_LITE
+
 }  // namespace rocksdb
@@ -14,6 +14,7 @@
 #include <limits>
 #include <list>
 #include <map>
+#include <queue>
 #include <set>
 #include <string>
 #include <utility>
@@ -27,7 +28,6 @@
 #include "db/flush_scheduler.h"
 #include "db/internal_stats.h"
 #include "db/log_writer.h"
-#include "db/logs_with_prep_tracker.h"
 #include "db/pre_release_callback.h"
 #include "db/read_callback.h"
 #include "db/snapshot_checker.h"
@@ -186,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;
@@ -224,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
@@ -251,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;
@@ -343,7 +338,6 @@ class DBImpl : public DB {

  Status RunManualCompaction(ColumnFamilyData* cfd, int input_level,
                             int output_level, uint32_t output_path_id,
-                             uint32_t max_subcompactions,
                             const Slice* begin, const Slice* end,
                             bool exclusive,
                             bool disallow_trivial_move = false);
@@ -355,10 +349,6 @@ class DBImpl : public DB {
      Arena* arena, RangeDelAggregator* range_del_agg,
      ColumnFamilyHandle* column_family = nullptr);

-  LogsWithPrepTracker* logs_with_prep_tracker() {
-    return &logs_with_prep_tracker_;
-  }
-
 #ifndef NDEBUG
  // Extra methods (for testing) that are not in the public DB interface
  // Implemented in db_impl_debug.cc
@@ -370,7 +360,9 @@ class DBImpl : public DB {

  void TEST_SwitchWAL();

-  bool TEST_UnableToReleaseOldestLog() { return unable_to_release_oldest_log_; }
+  bool TEST_UnableToFlushOldestLog() {
+    return unable_to_flush_oldest_log_;
+  }

  bool TEST_IsLogGettingFlushed() {
    return alive_log_files_.begin()->getting_flushed;
@@ -386,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.
@@ -442,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;
@@ -477,12 +465,12 @@ 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
  // PurgeObsoleteFiles(), even if disable_delete_obsolete_files_ is true
-  void PurgeObsoleteFiles(JobContext& background_contet,
+  void PurgeObsoleteFiles(const JobContext& background_contet,
                          bool schedule_only = false);

  void SchedulePurge();
@@ -560,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_; }
  };
@@ -593,11 +572,10 @@ 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);
-    logs_with_prep_tracker_.MarkLogAsContainingPrepSection(log);
+        new RecoveredTransaction(log, name, batch, seq);
+    MarkLogAsContainingPrepSection(log);
  }

  void DeleteRecoveredTransaction(const std::string& name) {
@@ -605,7 +583,7 @@ class DBImpl : public DB {
    assert(it != recovered_transactions_.end());
    auto* trx = it->second;
    recovered_transactions_.erase(it);
-    logs_with_prep_tracker_.MarkLogAsHavingPrepSectionFlushed(trx->log_number_);
+    MarkLogAsHavingPrepSectionFlushed(trx->log_number_);
    delete trx;
  }

@@ -617,15 +595,14 @@ class DBImpl : public DB {
    recovered_transactions_.clear();
  }

+  void MarkLogAsHavingPrepSectionFlushed(uint64_t log);
+  void MarkLogAsContainingPrepSection(uint64_t log);
  void AddToLogsToFreeQueue(log::Writer* log_writer) {
    logs_to_free_queue_.push_back(log_writer);
  }

  void SetSnapshotChecker(SnapshotChecker* snapshot_checker);

-  // Not thread-safe.
-  void SetRecoverableStatePreReleaseCallback(PreReleaseCallback* callback);
-
  InstrumentedMutex* mutex() { return &mutex_; }

  Status NewDB();
@@ -638,9 +615,6 @@ class DBImpl : public DB {

  virtual Status Close() override;

-  static Status CreateAndNewDirectory(Env* env, const std::string& dirname,
-                                      std::unique_ptr<Directory>* directory);
-
 protected:
  Env* const env_;
  const std::string dbname_;
@@ -693,25 +667,15 @@ class DBImpl : public DB {
  void EraseThreadStatusDbInfo() const;

  // If disable_memtable is set the application logic must guarantee that the
-  // batch will still be skipped from memtable during the recovery. An excption
-  // to this is seq_per_batch_ mode, in which since each batch already takes one
-  // seq, it is ok for the batch to write to memtable during recovery as long as
-  // it only takes one sequence number: i.e., no duplicate keys.
-  // In WriteCommitted it is guarnateed since disable_memtable is used for
-  // prepare 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. If the commit marker is
-  // accompanied with CommitTimeWriteBatch that is not written to memtable as
-  // long as it has no duplicate keys, it does not violate the one-seq-per-batch
-  // policy.
-  // 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.
+  // batch will still be skipped from memtable during the recovery. In
+  // WriteCommitted it is guarnateed since disable_memtable is used for prepare
+  // 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.
  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,
@@ -720,27 +684,22 @@ 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();
+  uint64_t FindMinPrepLogReferencedByMemTable();
  // write cached_recoverable_state_ to memtable if it is not empty
  // 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;
  friend class PessimisticTransaction;
-  friend class TransactionBaseImpl;
  friend class WriteCommittedTxn;
  friend class WritePreparedTxn;
  friend class WritePreparedTxnDB;
@@ -750,7 +709,6 @@ class DBImpl : public DB {
 #endif
  friend struct SuperVersion;
  friend class CompactedDBImpl;
-  friend class DBTest_ConcurrentFlushWAL_Test;
 #ifndef NDEBUG
  friend class DBTest2_ReadCallbackTest_Test;
  friend class WriteCallbackTest_WriteWithCallbackTest_Test;
@@ -798,8 +756,7 @@ class DBImpl : public DB {
  void DeleteObsoleteFiles();
  // Delete obsolete files and log status and information of file deletion
  void DeleteObsoleteFileImpl(int job_id, const std::string& fname,
-                              const std::string& path_to_sync, FileType type,
-                              uint64_t number);
+                              FileType type, uint64_t number, uint32_t path_id);

  // Background process needs to call
  //     auto x = CaptureCurrentFileNumberInPendingOutputs()
@@ -850,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
@@ -891,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);
@@ -901,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);

@@ -918,10 +873,10 @@ 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, std::string dir_to_sync,
-                            FileType type, uint64_t number, int job_id);
+  void SchedulePendingPurge(std::string fname, FileType type, uint64_t number,
+                            uint32_t path_id, int job_id);
  static void BGWorkCompaction(void* arg);
  // Runs a pre-chosen universal compaction involving bottom level in a
  // separate, bottom-pri thread pool.
@@ -939,9 +894,6 @@ class DBImpl : public DB {
  Status BackgroundFlush(bool* madeProgress, JobContext* job_context,
                         LogBuffer* log_buffer);

-  bool EnoughRoomForCompaction(const std::vector<CompactionInputFiles>& inputs,
-                               bool* sfm_bookkeeping, LogBuffer* log_buffer);
-
  void PrintStatistics();

  // dump rocksdb.stats to LOG
@@ -960,19 +912,18 @@ 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
  void MarkLogsSynced(uint64_t up_to, bool synced_dir, const Status& status);

-  SnapshotImpl* GetSnapshotImpl(bool is_write_conflict_boundary);
+  const Snapshot* GetSnapshotImpl(bool is_write_conflict_boundary);

  uint64_t GetMaxTotalWalSize() const;

-  Directory* GetDataDir(ColumnFamilyData* cfd, size_t path_id) const;
-
-  Status CloseHelper();
+  // Actual implementation of Close()
+  virtual Status CloseImpl();

  // table_cache_ provides its own synchronization
  std::shared_ptr<Cache> table_cache_;
@@ -1004,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,
@@ -1043,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;
@@ -1109,7 +1056,7 @@ class DBImpl : public DB {
                          const std::string& wal_dir,
                          const std::vector<DbPath>& data_paths);

-    Directory* GetDataDir(size_t path_id) const;
+    Directory* GetDataDir(size_t path_id);

    Directory* GetWalDir() {
      if (wal_dir_) {
@@ -1124,6 +1071,9 @@ class DBImpl : public DB {
    std::unique_ptr<Directory> db_dir_;
    std::vector<std::unique_ptr<Directory>> data_dirs_;
    std::unique_ptr<Directory> wal_dir_;
+
+    Status CreateAndNewDirectory(Env* env, const std::string& dirname,
+                                 std::unique_ptr<Directory>* directory) const;
  };

  Directories directories_;
@@ -1165,13 +1115,13 @@ class DBImpl : public DB {
  // purge_queue_
  struct PurgeFileInfo {
    std::string fname;
-    std::string dir_to_sync;
    FileType type;
    uint64_t number;
+    uint32_t path_id;
    int job_id;
-    PurgeFileInfo(std::string fn, std::string d, FileType t, uint64_t num,
+    PurgeFileInfo(std::string fn, FileType t, uint64_t num, uint32_t pid,
                  int jid)
-        : fname(fn), dir_to_sync(d), type(t), number(num), job_id(jid) {}
+        : fname(fn), type(t), number(num), path_id(pid), job_id(jid) {}
  };

  // flush_queue_ and compaction_queue_ hold column families that we need to
@@ -1202,10 +1152,6 @@ class DBImpl : public DB {
  // A queue to store filenames of the files to be purged
  std::deque<PurgeFileInfo> purge_queue_;

-  // A vector to store the file numbers that have been assigned to certain
-  // JobContext. Current implementation tracks ssts only.
-  std::vector<uint64_t> files_grabbed_for_purge_;
-
  // A queue to store log writers to close
  std::deque<log::Writer*> logs_to_free_queue_;
  int unscheduled_flushes_;
@@ -1301,7 +1247,7 @@ class DBImpl : public DB {
  // We must attempt to free the dependent memtables again
  // at a later time after the transaction in the oldest
  // log is fully commited.
-  bool unable_to_release_oldest_log_;
+  bool unable_to_flush_oldest_log_;

  static const int KEEP_LOG_FILE_NUM = 1000;
  // MSVC version 1800 still does not have constexpr for ::max()
@@ -1338,16 +1284,32 @@ class DBImpl : public DB {
  // Indicate DB was opened successfully
  bool opened_successfully_;

-  LogsWithPrepTracker logs_with_prep_tracker_;
+  // 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 flushed or rolled back
+  std::priority_queue<uint64_t, std::vector<uint64_t>, std::greater<uint64_t>>
+      min_log_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 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 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 prep_heap_mutex_;

  // Callback for compaction to check if a key is visible to a snapshot.
  // REQUIRES: mutex held
  std::unique_ptr<SnapshotChecker> snapshot_checker_;

-  // Callback for when the cached_recoverable_state_ is written to memtable
-  // Only to be set during initialization
-  std::unique_ptr<PreReleaseCallback> recoverable_state_pre_release_callback_;
-
  // No copying allowed
  DBImpl(const DBImpl&);
  void operator=(const DBImpl&);
@@ -1361,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;
@@ -1387,16 +1348,13 @@ class DBImpl : public DB {
  bool HaveManualCompaction(ColumnFamilyData* cfd);
  bool MCOverlap(ManualCompactionState* m, ManualCompactionState* m1);

-  bool ShouldPurge(uint64_t file_number) const;
-  void MarkAsGrabbedForPurge(uint64_t file_number);
-
  size_t GetWalPreallocateBlockSize(uint64_t write_buffer_size) const;
  Env::WriteLifeTimeHint CalculateWALWriteHint() {
    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
@@ -1434,25 +1392,6 @@ extern CompressionType GetCompressionFlush(
    const ImmutableCFOptions& ioptions,
    const MutableCFOptions& mutable_cf_options);

-// Return the earliest log file to keep after the memtable flush is
-// finalized.
-// `cfd_to_flush` is the column family whose memtable (specified in
-// `memtables_to_flush`) will be flushed and thus will not depend on any WAL
-// file.
-// The function is only applicable to 2pc mode.
-extern uint64_t PrecomputeMinLogNumberToKeep(
-    VersionSet* vset, const ColumnFamilyData& cfd_to_flush,
-    autovector<VersionEdit*> edit_list,
-    const autovector<MemTable*>& memtables_to_flush,
-    LogsWithPrepTracker* prep_tracker);
-
-// `cfd_to_flush` is the column family whose memtable will be flushed and thus
-// will not depend on any WAL file. nullptr means no memtable is being flushed.
-// The function is only applicable to 2pc mode.
-extern uint64_t FindMinPrepLogReferencedByMemTable(
-    VersionSet* vset, const ColumnFamilyData* cfd_to_flush,
-    const autovector<MemTable*>& memtables_to_flush);
-
 // Fix user-supplied options to be reasonable
 template <class T, class V>
 static void ClipToRange(T* ptr, V minvalue, V maxvalue) {
@@ -23,36 +23,6 @@
 #include "util/sync_point.h"

 namespace rocksdb {
-
-bool DBImpl::EnoughRoomForCompaction(
-    const std::vector<CompactionInputFiles>& inputs,
-    bool* sfm_reserved_compact_space, LogBuffer* log_buffer) {
-  // Check if we have enough room to do the compaction
-  bool enough_room = true;
-#ifndef ROCKSDB_LITE
-  auto sfm = static_cast<SstFileManagerImpl*>(
-      immutable_db_options_.sst_file_manager.get());
-  if (sfm) {
-    enough_room = sfm->EnoughRoomForCompaction(inputs);
-    if (enough_room) {
-      *sfm_reserved_compact_space = true;
-    }
-  }
-#else
-  (void)inputs;
-  (void)sfm_reserved_compact_space;
-#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);
-    ROCKS_LOG_BUFFER(log_buffer,
-                     "Cancelled compaction because not enough room");
-    RecordTick(stats_, COMPACTION_CANCELLED, 1);
-  }
-  return enough_room;
-}
-
 Status DBImpl::SyncClosedLogs(JobContext* job_context) {
  TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Start");
  mutex_.AssertHeld();
@@ -79,9 +49,6 @@ Status DBImpl::SyncClosedLogs(JobContext* job_context) {
                     "[JOB %d] Syncing log #%" PRIu64, job_context->job_id,
                     log->get_log_number());
      s = log->file()->Sync(immutable_db_options_.use_fsync);
-      if (!s.ok()) {
-        break;
-      }
    }
    if (s.ok()) {
      s = directories_.GetWalDir()->Fsync();
@@ -127,7 +94,8 @@ Status DBImpl::FlushMemTableToOutputFile(
      dbname_, cfd, immutable_db_options_, mutable_cf_options,
      env_options_for_compaction_, versions_.get(), &mutex_, &shutting_down_,
      snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
-      job_context, log_buffer, directories_.GetDbDir(), GetDataDir(cfd, 0U),
+      job_context, log_buffer, directories_.GetDbDir(),
+      directories_.GetDataDir(0U),
      GetCompressionFlush(*cfd->ioptions(), mutable_cf_options), stats_,
      &event_logger_, mutable_cf_options.report_bg_io_stats);

@@ -160,12 +128,13 @@ Status DBImpl::FlushMemTableToOutputFile(
  // and EventListener callback will be called when the db_mutex
  // is unlocked by the current thread.
  if (s.ok()) {
-    s = flush_job.Run(&logs_with_prep_tracker_, &file_meta);
+    s = flush_job.Run(&file_meta);
  } else {
    flush_job.Cancel();
  }

  if (s.ok()) {
+    TEST_SYNC_POINT("DBImpl::FlushMemTableToOutputFile:BeforeInstallSV");
    InstallSuperVersionAndScheduleWork(cfd, &job_context->superversion_context,
                                       mutable_cf_options);
    if (made_progress) {
@@ -200,10 +169,10 @@ Status DBImpl::FlushMemTableToOutputFile(
    if (sfm) {
      // Notify sst_file_manager that a new file was added
      std::string file_path = MakeTableFileName(
-          cfd->ioptions()->cf_paths[0].path, file_meta.fd.GetNumber());
+          immutable_db_options_.db_paths[0].path, file_meta.fd.GetNumber());
      sfm->OnAddFile(file_path);
      if (sfm->IsMaxAllowedSpaceReached() && bg_error_.ok()) {
-        Status new_bg_error = Status::NoSpace("Max allowed space was reached");
+        Status new_bg_error = Status::IOError("Max allowed space was reached");
        TEST_SYNC_POINT_CALLBACK(
            "DBImpl::FlushMemTableToOutputFile:MaxAllowedSpaceReached",
            &new_bg_error);
@@ -245,7 +214,7 @@ void DBImpl::NotifyOnFlushBegin(ColumnFamilyData* cfd, FileMetaData* file_meta,
    info.cf_name = cfd->GetName();
    // TODO(yhchiang): make db_paths dynamic in case flush does not
    //                 go to L0 in the future.
-    info.file_path = MakeTableFileName(cfd->ioptions()->cf_paths[0].path,
+    info.file_path = MakeTableFileName(immutable_db_options_.db_paths[0].path,
                                       file_meta->fd.GetNumber());
    info.thread_id = env_->GetThreadID();
    info.job_id = job_id;
@@ -254,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);
    }
@@ -262,12 +230,6 @@ void DBImpl::NotifyOnFlushBegin(ColumnFamilyData* cfd, FileMetaData* file_meta,
  mutex_.Lock();
 // no need to signal bg_cv_ as it will be signaled at the end of the
 // flush process.
-#else
-  (void)cfd;
-  (void)file_meta;
-  (void)mutable_cf_options;
-  (void)job_id;
-  (void)prop;
 #endif  // ROCKSDB_LITE
 }

@@ -296,7 +258,7 @@ void DBImpl::NotifyOnFlushCompleted(ColumnFamilyData* cfd,
    info.cf_name = cfd->GetName();
    // TODO(yhchiang): make db_paths dynamic in case flush does not
    //                 go to L0 in the future.
-    info.file_path = MakeTableFileName(cfd->ioptions()->cf_paths[0].path,
+    info.file_path = MakeTableFileName(immutable_db_options_.db_paths[0].path,
                                       file_meta->fd.GetNumber());
    info.thread_id = env_->GetThreadID();
    info.job_id = job_id;
@@ -305,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);
    }
@@ -313,96 +274,24 @@ void DBImpl::NotifyOnFlushCompleted(ColumnFamilyData* cfd,
  mutex_.Lock();
  // no need to signal bg_cv_ as it will be signaled at the end of the
  // flush process.
-#else
-  (void)cfd;
-  (void)file_meta;
-  (void)mutable_cf_options;
-  (void)job_id;
-  (void)prop;
 #endif  // ROCKSDB_LITE
 }

 Status DBImpl::CompactRange(const CompactRangeOptions& options,
                            ColumnFamilyHandle* column_family,
                            const Slice* begin, const Slice* end) {
-  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
-  auto cfd = cfh->cfd();
-
-  if (options.target_path_id >= cfd->ioptions()->cf_paths.size()) {
+  if (options.target_path_id >= immutable_db_options_.db_paths.size()) {
    return Status::InvalidArgument("Invalid target path ID");
  }

+  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
+  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;
@@ -428,7 +317,7 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
    }
    s = RunManualCompaction(cfd, ColumnFamilyData::kCompactAllLevels,
                            final_output_level, options.target_path_id,
-                            options.max_subcompactions, begin, end, exclusive);
+                            begin, end, exclusive);
  } else {
    for (int level = 0; level <= max_level_with_files; level++) {
      int output_level;
@@ -462,7 +351,7 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
        }
      }
      s = RunManualCompaction(cfd, level, output_level, options.target_path_id,
-                              options.max_subcompactions, begin, end, exclusive);
+                              begin, end, exclusive);
      if (!s.ok()) {
        break;
      }
@@ -501,19 +390,13 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
  return s;
 }

-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) {
+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) {
 #ifdef ROCKSDB_LITE
-  (void)compact_options;
-  (void)column_family;
-  (void)input_file_names;
-  (void)output_level;
-  (void)output_path_id;
-  (void)output_file_names;
-  // not supported in lite version
+    // not supported in lite version
  return Status::NotSupported("Not supported in ROCKSDB LITE");
 #else
  if (column_family == nullptr) {
@@ -537,9 +420,9 @@ Status DBImpl::CompactFiles(const CompactionOptions& compact_options,
    // IngestExternalFile() calls to finish.
    WaitForIngestFile();

-    s = CompactFilesImpl(compact_options, cfd, sv->current, input_file_names,
-                         output_file_names, output_level, output_path_id,
-                         &job_context, &log_buffer);
+    s = CompactFilesImpl(compact_options, cfd, sv->current,
+                         input_file_names, output_level,
+                         output_path_id, &job_context, &log_buffer);
  }
  if (sv->Unref()) {
    mutex_.Lock();
@@ -582,8 +465,8 @@ Status DBImpl::CompactFiles(const CompactionOptions& compact_options,
 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) {
+    const int output_level, int output_path_id, JobContext* job_context,
+    LogBuffer* log_buffer) {
  mutex_.AssertHeld();

  if (shutting_down_.load(std::memory_order_acquire)) {
@@ -601,7 +484,7 @@ Status DBImpl::CompactFilesImpl(
  version->GetColumnFamilyMetaData(&cf_meta);

  if (output_path_id < 0) {
-    if (cfd->ioptions()->cf_paths.size() == 1U) {
+    if (immutable_db_options_.db_paths.size() == 1U) {
      output_path_id = 0;
    } else {
      return Status::NotSupported(
@@ -630,16 +513,6 @@ Status DBImpl::CompactFilesImpl(
          "files are already being compacted");
    }
  }
-  bool sfm_reserved_compact_space = false;
-  // First check if we have enough room to do the compaction
-  bool enough_room = EnoughRoomForCompaction(
-      input_files, &sfm_reserved_compact_space, log_buffer);
-
-  if (!enough_room) {
-    // m's vars will get set properly at the end of this function,
-    // as long as status == CompactionTooLarge
-    return Status::CompactionTooLarge();
-  }

  // At this point, CompactFiles will be run.
  bg_compaction_scheduled_++;
@@ -673,9 +546,9 @@ Status DBImpl::CompactFilesImpl(
      job_context->job_id, c.get(), immutable_db_options_,
      env_options_for_compaction_, versions_.get(), &shutting_down_,
      preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
-      GetDataDir(c->column_family_data(), c->output_path_id()), stats_, &mutex_,
-      &bg_error_, snapshot_seqs, earliest_write_conflict_snapshot,
-      snapshot_checker, table_cache_, &event_logger_,
+      directories_.GetDataDir(c->output_path_id()), stats_, &mutex_, &bg_error_,
+      snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
+      table_cache_, &event_logger_,
      c->mutable_cf_options()->paranoid_file_checks,
      c->mutable_cf_options()->report_bg_io_stats, dbname_,
      nullptr);  // Here we pass a nullptr for CompactionJobStats because
@@ -713,17 +586,9 @@ 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);
-#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_reserved_compact_space) {
-    sfm->OnCompactionCompletion(c.get());
-  }
-#endif  // ROCKSDB_LITE

  ReleaseFileNumberFromPendingOutputs(pending_outputs_inserted_elem);

@@ -748,22 +613,12 @@ Status DBImpl::CompactFilesImpl(
    }
  }

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

  bg_compaction_scheduled_--;
  if (bg_compaction_scheduled_ == 0) {
    bg_cv_.SignalAll();
  }
-  TEST_SYNC_POINT("CompactFilesImpl:End");

  return status;
 }
@@ -798,8 +653,9 @@ Status DBImpl::ContinueBackgroundWork() {
 }

 void DBImpl::NotifyOnCompactionCompleted(
-    ColumnFamilyData* cfd, Compaction* c, const Status& st,
-    const CompactionJobStats& compaction_job_stats, const int job_id) {
+    ColumnFamilyData* cfd, Compaction *c, const Status &st,
+    const CompactionJobStats& compaction_job_stats,
+    const int job_id) {
 #ifndef ROCKSDB_LITE
  if (immutable_db_options_.listeners.size() == 0U) {
    return;
@@ -827,7 +683,7 @@ void DBImpl::NotifyOnCompactionCompleted(
    info.compression = c->output_compression();
    for (size_t i = 0; i < c->num_input_levels(); ++i) {
      for (const auto fmd : *c->inputs(i)) {
-        auto fn = TableFileName(c->immutable_cf_options()->cf_paths,
+        auto fn = TableFileName(immutable_db_options_.db_paths,
                                fmd->fd.GetNumber(), fmd->fd.GetPathId());
        info.input_files.push_back(fn);
        if (info.table_properties.count(fn) == 0) {
@@ -840,9 +696,9 @@ void DBImpl::NotifyOnCompactionCompleted(
      }
    }
    for (const auto newf : c->edit()->GetNewFiles()) {
-      info.output_files.push_back(TableFileName(
-          c->immutable_cf_options()->cf_paths, newf.second.fd.GetNumber(),
-          newf.second.fd.GetPathId()));
+      info.output_files.push_back(TableFileName(immutable_db_options_.db_paths,
+                                                newf.second.fd.GetNumber(),
+                                                newf.second.fd.GetPathId()));
    }
    for (auto listener : immutable_db_options_.listeners) {
      listener->OnCompactionCompleted(this, info);
@@ -852,12 +708,6 @@ void DBImpl::NotifyOnCompactionCompleted(
  current->Unref();
  // no need to signal bg_cv_ as it will be signaled at the end of the
  // flush process.
-#else
-  (void)cfd;
-  (void)c;
-  (void)st;
-  (void)compaction_job_stats;
-  (void)job_id;
 #endif  // ROCKSDB_LITE
 }

@@ -947,16 +797,15 @@ int DBImpl::NumberLevels(ColumnFamilyHandle* column_family) {
  return cfh->cfd()->NumberLevels();
 }

-int DBImpl::MaxMemCompactionLevel(ColumnFamilyHandle* /*column_family*/) {
+int DBImpl::MaxMemCompactionLevel(ColumnFamilyHandle* column_family) {
  return 0;
 }

 int DBImpl::Level0StopWriteTrigger(ColumnFamilyHandle* column_family) {
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
  InstrumentedMutexLock l(&mutex_);
-  return cfh->cfd()
-      ->GetSuperVersion()
-      ->mutable_cf_options.level0_stop_writes_trigger;
+  return cfh->cfd()->GetSuperVersion()->
+      mutable_cf_options.level0_stop_writes_trigger;
 }

 Status DBImpl::Flush(const FlushOptions& flush_options,
@@ -964,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());
@@ -974,7 +822,6 @@ Status DBImpl::Flush(const FlushOptions& flush_options,

 Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
                                   int output_level, uint32_t output_path_id,
-                                   uint32_t max_subcompactions,
                                   const Slice* begin, const Slice* end,
                                   bool exclusive, bool disallow_trivial_move) {
  assert(input_level == ColumnFamilyData::kCompactAllLevels ||
@@ -1060,12 +907,11 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
    if (ShouldntRunManualCompaction(&manual) || (manual.in_progress == true) ||
        scheduled ||
        (((manual.manual_end = &manual.tmp_storage1) != nullptr) &&
-         ((compaction = manual.cfd->CompactRange(
-               *manual.cfd->GetLatestMutableCFOptions(), manual.input_level,
-               manual.output_level, manual.output_path_id, max_subcompactions,
-               manual.begin, manual.end, &manual.manual_end,
-               &manual_conflict)) == nullptr &&
-          manual_conflict))) {
+             ((compaction = manual.cfd->CompactRange(
+                  *manual.cfd->GetLatestMutableCFOptions(), manual.input_level,
+                  manual.output_level, manual.output_path_id, manual.begin,
+                  manual.end, &manual.manual_end, &manual_conflict)) == nullptr &&
+         manual_conflict))) {
      // exclusive manual compactions should not see a conflict during
      // CompactRange
      assert(!exclusive || !manual_conflict);
@@ -1104,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;
  {
@@ -1133,7 +979,7 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
    cfd->imm()->FlushRequested();

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

@@ -1198,7 +1044,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
  }
  auto bg_job_limits = GetBGJobLimits();
  bool is_flush_pool_empty =
-      env_->GetBackgroundThreads(Env::Priority::HIGH) == 0;
+    env_->GetBackgroundThreads(Env::Priority::HIGH) == 0;
  while (!is_flush_pool_empty && unscheduled_flushes_ > 0 &&
         bg_flush_scheduled_ < bg_job_limits.max_flushes) {
    unscheduled_flushes_--;
@@ -1274,58 +1120,56 @@ DBImpl::BGJobLimits DBImpl::GetBGJobLimits(int max_background_flushes,
 }

 void DBImpl::AddToCompactionQueue(ColumnFamilyData* cfd) {
-  assert(!cfd->queued_for_compaction());
+  assert(!cfd->pending_compaction());
  cfd->Ref();
  compaction_queue_.push_back(cfd);
-  cfd->set_queued_for_compaction(true);
+  cfd->set_pending_compaction(true);
 }

 ColumnFamilyData* DBImpl::PopFirstFromCompactionQueue() {
  assert(!compaction_queue_.empty());
  auto cfd = *compaction_queue_.begin();
  compaction_queue_.pop_front();
-  assert(cfd->queued_for_compaction());
-  cfd->set_queued_for_compaction(false);
+  assert(cfd->pending_compaction());
+  cfd->set_pending_compaction(false);
  return cfd;
 }

-void DBImpl::AddToFlushQueue(ColumnFamilyData* cfd, FlushReason flush_reason) {
-  assert(!cfd->queued_for_flush());
+void DBImpl::AddToFlushQueue(ColumnFamilyData* cfd) {
+  assert(!cfd->pending_flush());
  cfd->Ref();
  flush_queue_.push_back(cfd);
-  cfd->set_queued_for_flush(true);
-  cfd->SetFlushReason(flush_reason);
+  cfd->set_pending_flush(true);
 }

 ColumnFamilyData* DBImpl::PopFirstFromFlushQueue() {
  assert(!flush_queue_.empty());
  auto cfd = *flush_queue_.begin();
  flush_queue_.pop_front();
-  assert(cfd->queued_for_flush());
-  cfd->set_queued_for_flush(false);
-  // TODO: need to unset flush reason?
+  assert(cfd->pending_flush());
+  cfd->set_pending_flush(false);
  return cfd;
 }

-void DBImpl::SchedulePendingFlush(ColumnFamilyData* cfd,
-                                  FlushReason flush_reason) {
-  if (!cfd->queued_for_flush() && cfd->imm()->IsFlushPending()) {
-    AddToFlushQueue(cfd, flush_reason);
+void DBImpl::SchedulePendingFlush(ColumnFamilyData* cfd) {
+  if (!cfd->pending_flush() && cfd->imm()->IsFlushPending()) {
+    AddToFlushQueue(cfd);
    ++unscheduled_flushes_;
  }
 }

 void DBImpl::SchedulePendingCompaction(ColumnFamilyData* cfd) {
-  if (!cfd->queued_for_compaction() && cfd->NeedsCompaction()) {
+  if (!cfd->pending_compaction() && cfd->NeedsCompaction()) {
    AddToCompactionQueue(cfd);
    ++unscheduled_compactions_;
  }
 }

-void DBImpl::SchedulePendingPurge(std::string fname, std::string dir_to_sync,
-                                  FileType type, uint64_t number, int job_id) {
+void DBImpl::SchedulePendingPurge(std::string fname, FileType type,
+                                  uint64_t number, uint32_t path_id,
+                                  int job_id) {
  mutex_.AssertHeld();
-  PurgeFileInfo file_info(fname, dir_to_sync, type, number, job_id);
+  PurgeFileInfo file_info(fname, type, number, path_id, job_id);
  purge_queue_.push_back(std::move(file_info));
 }

@@ -1454,7 +1298,7 @@ void DBImpl::BackgroundCallFlush() {
      // chew up resources for failed flushes for the duration of
      // the problem.
      uint64_t error_cnt =
-          default_cf_internal_stats_->BumpAndGetBackgroundErrorCount();
+        default_cf_internal_stats_->BumpAndGetBackgroundErrorCount();
      bg_cv_.SignalAll();  // In case a waiter can proceed despite the error
      mutex_.Unlock();
      ROCKS_LOG_ERROR(immutable_db_options_.info_log,
@@ -1554,7 +1398,6 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
    // have created (they might not be all recorded in job_context in case of a
    // failure). Thus, we force full scan in FindObsoleteFiles()
    FindObsoleteFiles(&job_context, !s.ok() && !s.IsShutdownInProgress());
-    TEST_SYNC_POINT("DBImpl::BackgroundCallCompaction:FoundObsoleteFiles");

    // delete unnecessary files if any, this is done outside the mutex
    if (job_context.HaveSomethingToClean() ||
@@ -1568,7 +1411,6 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
      log_buffer.FlushBufferToLog();
      if (job_context.HaveSomethingToDelete()) {
        PurgeObsoleteFiles(job_context);
-        TEST_SYNC_POINT("DBImpl::BackgroundCallCompaction:PurgedObsoleteFiles");
      }
      job_context.Clean();
      mutex_.Lock();
@@ -1590,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
@@ -1653,7 +1495,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,

  // InternalKey manual_end_storage;
  // InternalKey* manual_end = &manual_end_storage;
-  bool sfm_reserved_compact_space = false;
  if (is_manual) {
    ManualCompactionState* m = manual_compaction;
    assert(m->in_progress);
@@ -1667,29 +1508,16 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                       (m->begin ? m->begin->DebugString().c_str() : "(begin)"),
                       (m->end ? m->end->DebugString().c_str() : "(end)"));
    } else {
-      // First check if we have enough room to do the compaction
-      bool enough_room = EnoughRoomForCompaction(
-          *(c->inputs()), &sfm_reserved_compact_space, log_buffer);
-
-      if (!enough_room) {
-        // Then don't do the compaction
-        c->ReleaseCompactionFiles(status);
-        c.reset();
-        // m's vars will get set properly at the end of this function,
-        // as long as status == CompactionTooLarge
-        status = Status::CompactionTooLarge();
-      } else {
-        ROCKS_LOG_BUFFER(
-            log_buffer,
-            "[%s] Manual compaction from level-%d to level-%d from %s .. "
-            "%s; will stop at %s\n",
-            m->cfd->GetName().c_str(), m->input_level, c->output_level(),
-            (m->begin ? m->begin->DebugString().c_str() : "(begin)"),
-            (m->end ? m->end->DebugString().c_str() : "(end)"),
-            ((m->done || m->manual_end == nullptr)
-                 ? "(end)"
-                 : m->manual_end->DebugString().c_str()));
-      }
+      ROCKS_LOG_BUFFER(
+          log_buffer,
+          "[%s] Manual compaction from level-%d to level-%d from %s .. "
+          "%s; will stop at %s\n",
+          m->cfd->GetName().c_str(), m->input_level, c->output_level(),
+          (m->begin ? m->begin->DebugString().c_str() : "(begin)"),
+          (m->end ? m->end->DebugString().c_str() : "(end)"),
+          ((m->done || m->manual_end == nullptr)
+               ? "(end)"
+               : m->manual_end->DebugString().c_str()));
    }
  } else if (!is_prepicked && !compaction_queue_.empty()) {
    if (HasExclusiveManualCompaction()) {
@@ -1729,48 +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");
-
      if (c != nullptr) {
-        bool enough_room = EnoughRoomForCompaction(
-            *(c->inputs()), &sfm_reserved_compact_space, log_buffer);
-
-        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()));
+        // 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();
-        } 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();
        }
      }
    }
@@ -1797,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));
@@ -1828,11 +1635,11 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                           f->largest, f->smallest_seqno, f->largest_seqno,
                           f->marked_for_compaction);

-        ROCKS_LOG_BUFFER(
-            log_buffer,
-            "[%s] Moving #%" PRIu64 " to level-%d %" PRIu64 " bytes\n",
-            c->column_family_data()->GetName().c_str(), f->fd.GetNumber(),
-            c->output_level(), f->fd.GetFileSize());
+        ROCKS_LOG_BUFFER(log_buffer, "[%s] Moving #%" PRIu64
+                                     " to level-%d %" PRIu64 " bytes\n",
+                         c->column_family_data()->GetName().c_str(),
+                         f->fd.GetNumber(), c->output_level(),
+                         f->fd.GetFileSize());
        ++moved_files;
        moved_bytes += f->fd.GetFileSize();
      }
@@ -1844,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(),
@@ -1866,7 +1673,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,

    // Clear Instrument
    ThreadStatusUtil::ResetThreadStatus();
-  } else if (!is_prepicked && c->output_level() > 0 &&
+  } else if (c->column_family_data()->ioptions()->compaction_style ==
+                 kCompactionStyleUniversal &&
+             !is_prepicked && c->output_level() > 0 &&
             c->output_level() ==
                 c->column_family_data()
                     ->current()
@@ -1874,9 +1683,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                     ->MaxOutputLevel(
                         immutable_db_options_.allow_ingest_behind) &&
             env_->GetBackgroundThreads(Env::Priority::BOTTOM) > 0) {
-    // Forward compactions involving last level to the bottom pool if it exists,
-    // such that compactions unlikely to contribute to write stalls can be
-    // delayed or deprioritized.
+    // Forward universal compactions involving last level to the bottom pool
+    // if it exists, such that long-running compactions can't block short-
+    // lived ones, like L0->L0s.
    TEST_SYNC_POINT("DBImpl::BackgroundCompaction:ForwardToBottomPriPool");
    CompactionArg* ca = new CompactionArg;
    ca->db = this;
@@ -1887,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);
@@ -1904,8 +1713,8 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
        job_context->job_id, c.get(), immutable_db_options_,
        env_options_for_compaction_, versions_.get(), &shutting_down_,
        preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
-        GetDataDir(c->column_family_data(), c->output_path_id()), stats_,
-        &mutex_, &bg_error_, snapshot_seqs, earliest_write_conflict_snapshot,
+        directories_.GetDataDir(c->output_path_id()), stats_, &mutex_,
+        &bg_error_, snapshot_seqs, earliest_write_conflict_snapshot,
        snapshot_checker, table_cache_, &event_logger_,
        c->mutable_cf_options()->paranoid_file_checks,
        c->mutable_cf_options()->report_bg_io_stats, dbname_,
@@ -1921,30 +1730,21 @@ 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_reserved_compact_space) {
-      sfm->OnCompactionCompletion(c.get());
-    }
-#endif  // ROCKSDB_LITE
-
-    NotifyOnCompactionCompleted(c->column_family_data(), c.get(), status,
-                                compaction_job_stats, job_context->job_id);
+    NotifyOnCompactionCompleted(
+        c->column_family_data(), c.get(), status,
+        compaction_job_stats, job_context->job_id);
  }
  // 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
@@ -1997,7 +1797,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
      m->begin = &m->tmp_storage;
      m->incomplete = true;
    }
-    m->in_progress = false;  // not being processed anymore
+    m->in_progress = false; // not being processed anymore
  }
  TEST_SYNC_POINT("DBImpl::BackgroundCompaction:Finish");
  return status;
@@ -2097,7 +1897,8 @@ bool DBImpl::MCOverlap(ManualCompactionState* m, ManualCompactionState* m1) {
 }

 // SuperVersionContext gets created and destructed outside of the lock --
-// we use this conveniently to:
+// we
+// use this convinently to:
 // * malloc one SuperVersion() outside of the lock -- new_superversion
 // * delete SuperVersion()s outside of the lock -- superversions_to_free
 //
@@ -2110,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_
@@ -2124,49 +1925,20 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
  if (sv_context->new_superversion == nullptr) {
    sv_context->NewSuperVersion();
  }
-  cfd->InstallSuperVersion(sv_context, &mutex_, mutable_cf_options);
+  cfd->InstallSuperVersion(sv_context, &mutex_,
+                           mutable_cf_options);

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

  // Update max_total_in_memory_state_
-  max_total_in_memory_state_ = max_total_in_memory_state_ - old_memtable_size +
-                               mutable_cf_options.write_buffer_size *
-                                   mutable_cf_options.max_write_buffer_number;
-}
-
-// ShouldPurge is called by FindObsoleteFiles when doing a full scan,
-// and db mutex (mutex_) should already be held. This function performs a
-// linear scan of an vector (files_grabbed_for_purge_) in search of a
-// certain element. We expect FindObsoleteFiles with full scan to occur once
-// every 10 hours by default, and the size of the vector is small.
-// Therefore, the cost is affordable even if the mutex is held.
-// Actually, the current implementation of FindObsoleteFiles with
-// full_scan=true can issue I/O requests to obtain list of files in
-// directories, e.g. env_->getChildren while holding db mutex.
-// In the future, if we want to reduce the cost of search, we may try to keep
-// the vector sorted.
-bool DBImpl::ShouldPurge(uint64_t file_number) const {
-  for (auto fn : files_grabbed_for_purge_) {
-    if (file_number == fn) {
-      return false;
-    }
-  }
-  for (const auto& purge_file_info : purge_queue_) {
-    if (purge_file_info.number == file_number) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// MarkAsGrabbedForPurge is called by FindObsoleteFiles, and db mutex
-// (mutex_) should already be held.
-void DBImpl::MarkAsGrabbedForPurge(uint64_t file_number) {
-  files_grabbed_for_purge_.emplace_back(file_number);
+  max_total_in_memory_state_ =
+      max_total_in_memory_state_ - old_memtable_size +
+      mutable_cf_options.write_buffer_size *
+      mutable_cf_options.max_write_buffer_number;
 }

 void DBImpl::SetSnapshotChecker(SnapshotChecker* snapshot_checker) {
@@ -80,7 +80,7 @@ Status DBImpl::TEST_CompactRange(int level, const Slice* begin,
       cfd->ioptions()->compaction_style == kCompactionStyleFIFO)
          ? level
          : level + 1;
-  return RunManualCompaction(cfd, level, output_level, 0, 0, begin, end, true,
+  return RunManualCompaction(cfd, level, output_level, 0, begin, end, true,
                             disallow_trivial_move);
 }

@@ -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();
  }
@@ -184,21 +183,11 @@ Status DBImpl::TEST_GetAllImmutableCFOptions(
 }

 uint64_t DBImpl::TEST_FindMinLogContainingOutstandingPrep() {
-  return logs_with_prep_tracker_.FindMinLogContainingOutstandingPrep();
-}
-
-size_t DBImpl::TEST_PreparedSectionCompletedSize() {
-  return logs_with_prep_tracker_.TEST_PreparedSectionCompletedSize();
-}
-
-size_t DBImpl::TEST_LogsWithPrepSize() {
-  return logs_with_prep_tracker_.TEST_LogsWithPrepSize();
+  return FindMinLogContainingOutstandingPrep();
 }

 uint64_t DBImpl::TEST_FindMinPrepLogReferencedByMemTable() {
-  autovector<MemTable*> empty_list;
-  return FindMinPrepLogReferencedByMemTable(versions_.get(), nullptr,
-                                            empty_list);
+  return FindMinPrepLogReferencedByMemTable();
 }

 Status DBImpl::TEST_GetLatestMutableCFOptions(
@@ -12,19 +12,122 @@
 #define __STDC_FORMAT_MACROS
 #endif
 #include <inttypes.h>
-#include <unordered_set>
 #include "db/event_helpers.h"
-#include "db/memtable_list.h"
 #include "util/file_util.h"
 #include "util/sst_file_manager_impl.h"

+
 namespace rocksdb {
-uint64_t DBImpl::MinLogNumberToKeep() {
-  if (allow_2pc()) {
-    return versions_->min_log_number_to_keep_2pc();
-  } else {
-    return versions_->MinLogNumberWithUnflushedData();
+uint64_t DBImpl::FindMinPrepLogReferencedByMemTable() {
+  if (!allow_2pc()) {
+    return 0;
  }
+
+  uint64_t min_log = 0;
+
+  // we must look through the memtables for two phase transactions
+  // that have been committed but not yet flushed
+  for (auto loop_cfd : *versions_->GetColumnFamilySet()) {
+    if (loop_cfd->IsDropped()) {
+      continue;
+    }
+
+    auto log = loop_cfd->imm()->GetMinLogContainingPrepSection();
+
+    if (log > 0 && (min_log == 0 || log < min_log)) {
+      min_log = log;
+    }
+
+    log = loop_cfd->mem()->GetMinLogContainingPrepSection();
+
+    if (log > 0 && (min_log == 0 || log < min_log)) {
+      min_log = log;
+    }
+  }
+
+  return min_log;
+}
+
+// TODO(myabandeh): Avoid using locks
+void DBImpl::MarkLogAsHavingPrepSectionFlushed(uint64_t log) {
+  assert(log != 0);
+  std::lock_guard<std::mutex> lock(prep_heap_mutex_);
+  auto it = prepared_section_completed_.find(log);
+  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(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() {
+
+  if (!allow_2pc()) {
+    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() {
+  uint64_t log_number = versions_->MinLogNumber();
+
+  if (allow_2pc()) {
+    // if are 2pc we must consider logs containing prepared
+    // sections of outstanding transactions.
+    //
+    // We must check min logs with outstanding prep before we check
+    // 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 optimial solution
+    auto min_log_in_prep_heap = FindMinLogContainingOutstandingPrep();
+
+    if (min_log_in_prep_heap != 0 && min_log_in_prep_heap < log_number) {
+      log_number = min_log_in_prep_heap;
+    }
+
+    auto min_log_refed_by_mem = FindMinPrepLogReferencedByMemTable();
+
+    if (min_log_refed_by_mem != 0 && min_log_refed_by_mem < log_number) {
+      log_number = min_log_refed_by_mem;
+    }
+  }
+  return log_number;
 }

 // * Returns the list of live files in 'sst_live'
@@ -47,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 ||
@@ -67,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 {
@@ -81,65 +184,27 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
                              &job_context->manifest_delete_files,
                              job_context->min_pending_output);

-  // Mark the elements in job_context->sst_delete_files as grabbedForPurge
-  // so that other threads calling FindObsoleteFiles with full_scan=true
-  // will not add these files to candidate list for purge.
-  for (const auto& sst_to_del : job_context->sst_delete_files) {
-    MarkAsGrabbedForPurge(sst_to_del.metadata->fd.GetNumber());
-  }
-
  // store the current filenum, lognum, etc
  job_context->manifest_file_number = versions_->manifest_file_number();
  job_context->pending_manifest_file_number =
      versions_->pending_manifest_file_number();
  job_context->log_number = MinLogNumberToKeep();
+
  job_context->prev_log_number = versions_->prev_log_number();

  versions_->AddLiveFiles(&job_context->sst_live);
  if (doing_the_full_scan) {
-    InfoLogPrefix info_log_prefix(!immutable_db_options_.db_log_dir.empty(),
-        dbname_);
-    std::vector<std::string> paths;
    for (size_t path_id = 0; path_id < immutable_db_options_.db_paths.size();
         path_id++) {
-      paths.emplace_back(immutable_db_options_.db_paths[path_id].path);
-    }
-
-    // Note that if cf_paths is not specified in the ColumnFamilyOptions
-    // of a particular column family, we use db_paths as the cf_paths
-    // setting. Hence, there can be multiple duplicates of files from db_paths
-    // in the following code. The duplicate are removed while identifying
-    // unique files in PurgeObsoleteFiles.
-    for (auto cfd : *versions_->GetColumnFamilySet()) {
-      for (size_t path_id = 0; path_id < cfd->ioptions()->cf_paths.size();
-           path_id++) {
-        paths.emplace_back(cfd->ioptions()->cf_paths[path_id].path);
-      }
-    }
-
-    for (auto& path : paths) {
      // set of all files in the directory. We'll exclude files that are still
      // alive in the subsequent processings.
      std::vector<std::string> files;
-      env_->GetChildren(path, &files);  // Ignore errors
-      for (const std::string& file : files) {
-        uint64_t number;
-        FileType type;
-        // 1. If we cannot parse the file name, we skip;
-        // 2. If the file with file_number equals number has already been
-        // grabbed for purge by another compaction job, or it has already been
-        // schedule for purge, we also skip it if we
-        // are doing full scan in order to avoid double deletion of the same
-        // file under race conditions. See
-        // https://github.com/facebook/rocksdb/issues/3573
-        if (!ParseFileName(file, &number, info_log_prefix.prefix, &type) ||
-            !ShouldPurge(number)) {
-          continue;
-        }
-
+      env_->GetChildren(immutable_db_options_.db_paths[path_id].path,
+                        &files);  // Ignore errors
+      for (std::string file : files) {
        // TODO(icanadi) clean up this mess to avoid having one-off "/" prefixes
        job_context->full_scan_candidate_files.emplace_back(
-            "/" + file, path);
+            "/" + file, static_cast<uint32_t>(path_id));
      }
    }

@@ -148,9 +213,8 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
      std::vector<std::string> log_files;
      env_->GetChildren(immutable_db_options_.wal_dir,
                        &log_files);  // Ignore errors
-      for (const std::string& log_file : log_files) {
-        job_context->full_scan_candidate_files.emplace_back(log_file,
-            immutable_db_options_.wal_dir);
+      for (std::string log_file : log_files) {
+        job_context->full_scan_candidate_files.emplace_back(log_file, 0);
      }
    }
    // Add info log files in db_log_dir
@@ -159,9 +223,8 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
      std::vector<std::string> info_log_files;
      // Ignore errors
      env_->GetChildren(immutable_db_options_.db_log_dir, &info_log_files);
-      for (std::string& log_file : info_log_files) {
-        job_context->full_scan_candidate_files.emplace_back(log_file,
-            immutable_db_options_.db_log_dir);
+      for (std::string log_file : info_log_files) {
+        job_context->full_scan_candidate_files.emplace_back(log_file, 0);
      }
    }
  }
@@ -236,24 +299,22 @@ bool CompareCandidateFile(const JobContext::CandidateFileInfo& first,
  } else if (first.file_name < second.file_name) {
    return false;
  } else {
-    return (first.file_path > second.file_path);
+    return (first.path_id > second.path_id);
  }
 }
 };  // namespace

 // Delete obsolete files and log status and information of file deletion
 void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
-                                    const std::string& path_to_sync,
-                                    FileType type, uint64_t number) {
+                                    FileType type, uint64_t number,
+                                    uint32_t path_id) {
  Status file_deletion_status;
  if (type == kTableFile) {
    file_deletion_status =
-        DeleteSSTFile(&immutable_db_options_, fname, path_to_sync);
+        DeleteSSTFile(&immutable_db_options_, fname, path_id);
  } else {
    file_deletion_status = env_->DeleteFile(fname);
  }
-  TEST_SYNC_POINT_CALLBACK("DBImpl::DeleteObsoleteFileImpl:AfterDeletion",
-      &file_deletion_status);
  if (file_deletion_status.ok()) {
    ROCKS_LOG_DEBUG(immutable_db_options_.info_log,
                    "[JOB %d] Delete %s type=%d #%" PRIu64 " -- %s\n", job_id,
@@ -280,10 +341,10 @@ 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(JobContext& state, bool schedule_only) {
+void DBImpl::PurgeObsoleteFiles(const JobContext& state, bool schedule_only) {
  TEST_SYNC_POINT("DBImpl::PurgeObsoleteFiles:Begin");
  // we'd better have sth to delete
  assert(state.HaveSomethingToDelete());
@@ -306,23 +367,23 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
      state.log_delete_files.size() + state.manifest_delete_files.size());
  // We may ignore the dbname when generating the file names.
  const char* kDumbDbName = "";
-  for (auto& file : state.sst_delete_files) {
+  for (auto file : state.sst_delete_files) {
    candidate_files.emplace_back(
-        MakeTableFileName(kDumbDbName, file.metadata->fd.GetNumber()), file.path);
-    if (file.metadata->table_reader_handle) {
-      table_cache_->Release(file.metadata->table_reader_handle);
+        MakeTableFileName(kDumbDbName, file->fd.GetNumber()),
+        file->fd.GetPathId());
+    if (file->table_reader_handle) {
+      table_cache_->Release(file->table_reader_handle);
    }
-    file.DeleteMetadata();
+    delete file;
  }

  for (auto file_num : state.log_delete_files) {
    if (file_num > 0) {
-      candidate_files.emplace_back(LogFileName(kDumbDbName, file_num),
-          immutable_db_options_.wal_dir);
+      candidate_files.emplace_back(LogFileName(kDumbDbName, file_num), 0);
    }
  }
  for (const auto& filename : state.manifest_delete_files) {
-    candidate_files.emplace_back(filename, dbname_);
+    candidate_files.emplace_back(filename, 0);
  }

  // dedup state.candidate_files so we don't try to delete the same
@@ -345,9 +406,9 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
  std::vector<std::string> old_info_log_files;
  InfoLogPrefix info_log_prefix(!immutable_db_options_.db_log_dir.empty(),
                                dbname_);
-  std::unordered_set<uint64_t> files_to_del;
  for (const auto& candidate_file : candidate_files) {
    std::string to_delete = candidate_file.file_name;
+    uint32_t path_id = candidate_file.path_id;
    uint64_t number;
    FileType type;
    // Ignore file if we cannot recognize it.
@@ -373,9 +434,6 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
        // DontDeletePendingOutputs fail
        keep = (sst_live_map.find(number) != sst_live_map.end()) ||
               number >= state.min_pending_output;
-        if (!keep) {
-          files_to_del.insert(number);
-        }
        break;
      case kTempFile:
        // Any temp files that are currently being written to must
@@ -411,16 +469,13 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
    }

    std::string fname;
-    std::string dir_to_sync;
    if (type == kTableFile) {
      // evict from cache
      TableCache::Evict(table_cache_.get(), number);
-      fname = MakeTableFileName(candidate_file.file_path, number);
-      dir_to_sync = candidate_file.file_path;
+      fname = TableFileName(immutable_db_options_.db_paths, number, path_id);
    } else {
-      dir_to_sync =
-          (type == kLogFile) ? immutable_db_options_.wal_dir : dbname_;
-      fname = dir_to_sync + "/" + to_delete;
+      fname = ((type == kLogFile) ? immutable_db_options_.wal_dir : dbname_) +
+              "/" + to_delete;
    }

 #ifndef ROCKSDB_LITE
@@ -434,25 +489,12 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
    Status file_deletion_status;
    if (schedule_only) {
      InstrumentedMutexLock guard_lock(&mutex_);
-      SchedulePendingPurge(fname, dir_to_sync, type, number, state.job_id);
+      SchedulePendingPurge(fname, type, number, path_id, state.job_id);
    } else {
-      DeleteObsoleteFileImpl(state.job_id, fname, dir_to_sync, type, number);
+      DeleteObsoleteFileImpl(state.job_id, fname, type, number, path_id);
    }
  }

-  {
-    // After purging obsolete files, remove them from files_grabbed_for_purge_.
-    // Use a temporary vector to perform bulk deletion via swap.
-    InstrumentedMutexLock guard_lock(&mutex_);
-    std::vector<uint64_t> tmp;
-    for (auto fn : files_grabbed_for_purge_) {
-      if (files_to_del.count(fn) == 0) {
-        tmp.emplace_back(fn);
-      }
-    }
-    files_grabbed_for_purge_.swap(tmp);
-  }
-
  // Delete old info log files.
  size_t old_info_log_file_count = old_info_log_files.size();
  if (old_info_log_file_count != 0 &&
@@ -512,95 +554,4 @@ void DBImpl::DeleteObsoleteFiles() {
  job_context.Clean();
  mutex_.Lock();
 }
-
-uint64_t FindMinPrepLogReferencedByMemTable(
-    VersionSet* vset, const ColumnFamilyData* cfd_to_flush,
-    const autovector<MemTable*>& memtables_to_flush) {
-  uint64_t min_log = 0;
-
-  // we must look through the memtables for two phase transactions
-  // that have been committed but not yet flushed
-  for (auto loop_cfd : *vset->GetColumnFamilySet()) {
-    if (loop_cfd->IsDropped() || loop_cfd == cfd_to_flush) {
-      continue;
-    }
-
-    auto log = loop_cfd->imm()->PrecomputeMinLogContainingPrepSection(
-        memtables_to_flush);
-
-    if (log > 0 && (min_log == 0 || log < min_log)) {
-      min_log = log;
-    }
-
-    log = loop_cfd->mem()->GetMinLogContainingPrepSection();
-
-    if (log > 0 && (min_log == 0 || log < min_log)) {
-      min_log = log;
-    }
-  }
-
-  return min_log;
-}
-
-uint64_t PrecomputeMinLogNumberToKeep(
-    VersionSet* vset, const ColumnFamilyData& cfd_to_flush,
-    autovector<VersionEdit*> edit_list,
-    const autovector<MemTable*>& memtables_to_flush,
-    LogsWithPrepTracker* prep_tracker) {
-  assert(vset != nullptr);
-  assert(prep_tracker != nullptr);
-  // Calculate updated min_log_number_to_keep
-  // Since the function should only be called in 2pc mode, log number in
-  // the version edit should be sufficient.
-
-  // Precompute the min log number containing unflushed data for the column
-  // family being flushed (`cfd_to_flush`).
-  uint64_t cf_min_log_number_to_keep = 0;
-  for (auto& e : edit_list) {
-    if (e->has_log_number()) {
-      cf_min_log_number_to_keep =
-          std::max(cf_min_log_number_to_keep, e->log_number());
-    }
-  }
-  if (cf_min_log_number_to_keep == 0) {
-    // No version edit contains information on log number. The log number
-    // for this column family should stay the same as it is.
-    cf_min_log_number_to_keep = cfd_to_flush.GetLogNumber();
-  }
-
-  // Get min log number containing unflushed data for other column families.
-  uint64_t min_log_number_to_keep =
-      vset->PreComputeMinLogNumberWithUnflushedData(&cfd_to_flush);
-  if (cf_min_log_number_to_keep != 0) {
-    min_log_number_to_keep =
-        std::min(cf_min_log_number_to_keep, min_log_number_to_keep);
-  }
-
-  // if are 2pc we must consider logs containing prepared
-  // 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
-  // first data structure could transition to the second under us.
-  //
-  // TODO: iterating over all column families under db mutex.
-  // should find more optimal solution
-  auto min_log_in_prep_heap =
-      prep_tracker->FindMinLogContainingOutstandingPrep();
-
-  if (min_log_in_prep_heap != 0 &&
-      min_log_in_prep_heap < min_log_number_to_keep) {
-    min_log_number_to_keep = min_log_in_prep_heap;
-  }
-
-  uint64_t min_log_refed_by_mem = FindMinPrepLogReferencedByMemTable(
-      vset, &cfd_to_flush, memtables_to_flush);
-
-  if (min_log_refed_by_mem != 0 &&
-      min_log_refed_by_mem < min_log_number_to_keep) {
-    min_log_number_to_keep = min_log_refed_by_mem;
-  }
-  return min_log_number_to_keep;
-}
-
 }  // namespace rocksdb
@@ -106,14 +106,14 @@ DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src) {
    result.db_paths.emplace_back(dbname, std::numeric_limits<uint64_t>::max());
  }

-  if (result.use_direct_reads &&
+  if (result.use_direct_io_for_flush_and_compaction &&
      result.compaction_readahead_size == 0) {
    TEST_SYNC_POINT_CALLBACK("SanitizeOptions:direct_io", nullptr);
    result.compaction_readahead_size = 1024 * 1024 * 2;
  }

  if (result.compaction_readahead_size > 0 ||
-      result.use_direct_reads) {
+      result.use_direct_io_for_flush_and_compaction) {
    result.new_table_reader_for_compaction_inputs = true;
  }

@@ -163,23 +163,28 @@ static Status ValidateOptions(
    if (s.ok() && db_options.allow_concurrent_memtable_write) {
      s = CheckConcurrentWritesSupported(cfd.options);
    }
-    if (s.ok()) {
-      s = CheckCFPathsSupported(db_options, cfd.options);
-    }
    if (!s.ok()) {
      return s;
    }
-
-    if (cfd.options.ttl > 0 || cfd.options.compaction_options_fifo.ttl > 0) {
+    if (db_options.db_paths.size() > 1) {
+      if ((cfd.options.compaction_style != kCompactionStyleUniversal) &&
+          (cfd.options.compaction_style != kCompactionStyleLevel)) {
+        return Status::NotSupported(
+            "More than one DB paths are only supported in "
+            "universal and level compaction styles. ");
+      }
+    }
+    if (cfd.options.compaction_options_fifo.ttl > 0) {
      if (db_options.max_open_files != -1) {
        return Status::NotSupported(
-            "TTL is only supported when files are always "
+            "FIFO Compaction with TTL is only supported when files are always "
            "kept open (set max_open_files = -1). ");
      }
      if (cfd.options.table_factory->Name() !=
          BlockBasedTableFactory().Name()) {
        return Status::NotSupported(
-            "TTL is only supported in Block-Based Table format. ");
+            "FIFO Compaction with TTL is only supported in "
+            "Block-Based Table format. ");
      }
    }
  }
@@ -249,9 +254,9 @@ Status DBImpl::NewDB() {
  return s;
 }

-Status DBImpl::CreateAndNewDirectory(
+Status DBImpl::Directories::CreateAndNewDirectory(
    Env* env, const std::string& dirname,
-    std::unique_ptr<Directory>* directory) {
+    std::unique_ptr<Directory>* directory) const {
  // We call CreateDirIfMissing() as the directory may already exist (if we
  // are reopening a DB), when this happens we don't want creating the
  // directory to cause an error. However, we need to check if creating the
@@ -269,12 +274,12 @@ Status DBImpl::CreateAndNewDirectory(
 Status DBImpl::Directories::SetDirectories(
    Env* env, const std::string& dbname, const std::string& wal_dir,
    const std::vector<DbPath>& data_paths) {
-  Status s = DBImpl::CreateAndNewDirectory(env, dbname, &db_dir_);
+  Status s = CreateAndNewDirectory(env, dbname, &db_dir_);
  if (!s.ok()) {
    return s;
  }
  if (!wal_dir.empty() && dbname != wal_dir) {
-    s = DBImpl::CreateAndNewDirectory(env, wal_dir, &wal_dir_);
+    s = CreateAndNewDirectory(env, wal_dir, &wal_dir_);
    if (!s.ok()) {
      return s;
    }
@@ -287,7 +292,7 @@ Status DBImpl::Directories::SetDirectories(
      data_dirs_.emplace_back(nullptr);
    } else {
      std::unique_ptr<Directory> path_directory;
-      s = DBImpl::CreateAndNewDirectory(env, db_path, &path_directory);
+      s = CreateAndNewDirectory(env, db_path, &path_directory);
      if (!s.ok()) {
        return s;
      }
@@ -351,43 +356,12 @@ 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);
  if (immutable_db_options_.paranoid_checks && s.ok()) {
    s = CheckConsistency();
  }
-  if (s.ok() && !read_only) {
-    for (auto cfd : *versions_->GetColumnFamilySet()) {
-      s = cfd->AddDirectories();
-      if (!s.ok()) {
-        return s;
-      }
-    }
-  }
  if (s.ok()) {
    SequenceNumber next_sequence(kMaxSequenceNumber);
    default_cf_handle_ = new ColumnFamilyHandleImpl(
@@ -532,13 +506,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
  bool flushed = false;
  uint64_t corrupted_log_number = kMaxSequenceNumber;
  for (auto log_number : log_numbers) {
-    if (log_number < versions_->min_log_number_to_keep_2pc()) {
-      ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                     "Skipping log #%" PRIu64
-                     " since it is older than min log to keep #%" PRIu64,
-                     log_number, versions_->min_log_number_to_keep_2pc());
-      continue;
-    }
    // The previous incarnation may not have written any MANIFEST
    // records after allocating this log number.  So we manually
    // update the file number allocation counter in VersionSet.
@@ -972,7 +939,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
                  meta.marked_for_compaction);
  }

-  InternalStats::CompactionStats stats(CompactionReason::kFlush, 1);
+  InternalStats::CompactionStats stats(1);
  stats.micros = env_->NowMicros() - start_micros;
  stats.bytes_written = meta.fd.GetFileSize();
  stats.num_output_files = 1;
@@ -1034,17 +1001,8 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
  DBImpl* impl = new DBImpl(db_options, dbname, seq_per_batch);
  s = impl->env_->CreateDirIfMissing(impl->immutable_db_options_.wal_dir);
  if (s.ok()) {
-    std::vector<std::string> paths;
-    for (auto& db_path : impl->immutable_db_options_.db_paths) {
-      paths.emplace_back(db_path.path);
-    }
-    for (auto& cf : column_families) {
-      for (auto& cf_path : cf.options.cf_paths) {
-        paths.emplace_back(cf_path.path);
-      }
-    }
-    for (auto& path : paths) {
-      s = impl->env_->CreateDirIfMissing(path);
+    for (auto db_path : impl->immutable_db_options_.db_paths) {
+      s = impl->env_->CreateDirIfMissing(db_path.path);
      if (!s.ok()) {
        break;
      }
@@ -1187,28 +1145,17 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
      impl->immutable_db_options_.sst_file_manager.get());
  if (s.ok() && sfm) {
    // Notify SstFileManager about all sst files that already exist in
-    // db_paths[0] and cf_paths[0] when the DB is opened.
-    std::vector<std::string> paths;
-    paths.emplace_back(impl->immutable_db_options_.db_paths[0].path);
-    for (auto& cf : column_families) {
-      if (!cf.options.cf_paths.empty()) {
-        paths.emplace_back(cf.options.cf_paths[0].path);
-      }
-    }
-    // Remove duplicate paths.
-    std::sort(paths.begin(), paths.end());
-    paths.erase(std::unique(paths.begin(), paths.end()), paths.end());
-    for (auto& path : paths) {
-      std::vector<std::string> existing_files;
-      impl->immutable_db_options_.env->GetChildren(path, &existing_files);
-      for (auto& file_name : existing_files) {
-        uint64_t file_number;
-        FileType file_type;
-        std::string file_path = path + "/" + file_name;
-        if (ParseFileName(file_name, &file_number, &file_type) &&
-            file_type == kTableFile) {
-          sfm->OnAddFile(file_path);
-        }
+    // db_paths[0] when the DB is opened.
+    auto& db_path = impl->immutable_db_options_.db_paths[0];
+    std::vector<std::string> existing_files;
+    impl->immutable_db_options_.env->GetChildren(db_path.path, &existing_files);
+    for (auto& file_name : existing_files) {
+      uint64_t file_number;
+      FileType file_type;
+      std::string file_path = db_path.path + "/" + file_name;
+      if (ParseFileName(file_name, &file_number, &file_type) &&
+          file_type == kTableFile) {
+        sfm->OnAddFile(file_path);
      }
    }
  }
@@ -24,7 +24,8 @@ DBImplReadOnly::DBImplReadOnly(const DBOptions& db_options,
  LogFlush(immutable_db_options_.info_log);
 }

-DBImplReadOnly::~DBImplReadOnly() {}
+DBImplReadOnly::~DBImplReadOnly() {
+}

 // Implementations of the DB interface
 Status DBImplReadOnly::Get(const ReadOptions& read_options,
@@ -106,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
@@ -182,21 +183,20 @@ Status DB::OpenForReadOnly(
  return s;
 }

-#else   // !ROCKSDB_LITE
+#else  // !ROCKSDB_LITE

-Status DB::OpenForReadOnly(const Options& /*options*/,
-                           const std::string& /*dbname*/, DB** /*dbptr*/,
-                           bool /*error_if_log_file_exist*/) {
+Status DB::OpenForReadOnly(const Options& options, const std::string& dbname,
+                           DB** dbptr, bool error_if_log_file_exist) {
  return Status::NotSupported("Not supported in ROCKSDB_LITE.");
 }

 Status DB::OpenForReadOnly(
-    const DBOptions& /*db_options*/, const std::string& /*dbname*/,
-    const std::vector<ColumnFamilyDescriptor>& /*column_families*/,
-    std::vector<ColumnFamilyHandle*>* /*handles*/, DB** /*dbptr*/,
-    bool /*error_if_log_file_exist*/) {
+    const DBOptions& db_options, const std::string& dbname,
+    const std::vector<ColumnFamilyDescriptor>& column_families,
+    std::vector<ColumnFamilyHandle*>* handles, DB** dbptr,
+    bool error_if_log_file_exist) {
  return Status::NotSupported("Not supported in ROCKSDB_LITE.");
 }
 #endif  // !ROCKSDB_LITE

-}  // namespace rocksdb
+}   // namespace rocksdb
@@ -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.");
  }

@@ -45,11 +45,6 @@ Status DBImpl::SingleDelete(const WriteOptions& write_options,
  return DB::SingleDelete(write_options, column_family, key);
 }

-void DBImpl::SetRecoverableStatePreReleaseCallback(
-    PreReleaseCallback* callback) {
-  recoverable_state_pre_release_callback_.reset(callback);
-}
-
 Status DBImpl::Write(const WriteOptions& write_options, WriteBatch* my_batch) {
  return WriteImpl(write_options, my_batch, nullptr, nullptr);
 }
@@ -69,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!");
  }
@@ -83,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");
  }
@@ -101,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) {
@@ -111,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);
@@ -122,19 +114,15 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
  write_thread_.JoinBatchGroup(&w);
  if (w.state == WriteThread::STATE_PARALLEL_MEMTABLE_WRITER) {
    // we are a non-leader in a parallel group
+    PERF_TIMER_GUARD(write_memtable_time);

    if (w.ShouldWriteToMemtable()) {
-      PERF_TIMER_STOP(write_pre_and_post_process_time);
-      PERF_TIMER_GUARD(write_memtable_time);
-
      ColumnFamilyMemTablesImpl column_family_memtables(
          versions_->GetColumnFamilySet());
      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);
-
-      PERF_TIMER_START(write_pre_and_post_process_time);
+          true /*concurrent_memtable_writes*/, seq_per_batch_);
    }

    if (write_thread_.CompleteParallelMemTableWriter(&w)) {
@@ -142,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;
@@ -194,13 +181,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // With concurrent writes we do preprocess only in the write thread that
    // also does write to memtable to avoid sync issue on shared data structure
    // with the other thread
-
-    // PreprocessWrite does its own perf timing.
-    PERF_TIMER_STOP(write_pre_and_post_process_time);
-
    status = PreprocessWrite(write_options, &need_log_sync, &write_context);
-
-    PERF_TIMER_START(write_pre_and_post_process_time);
  }
  log::Writer* log_writer = logs_.back().writer;

@@ -230,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();
@@ -322,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);
          }
@@ -343,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) {
@@ -355,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) {
@@ -363,7 +342,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    MarkLogsSynced(logfile_number_, need_log_dir_sync, status);
    mutex_.Unlock();
    // Requesting sync with two_write_queues_ is expected to be very rare. We
-    // hence provide a simple implementation that is not necessarily efficient.
+    // hance provide a simple implementation that is not necessarily efficient.
    if (two_write_queues_) {
      if (manual_wal_flush_) {
        status = FlushWAL(true);
@@ -384,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;
@@ -424,10 +402,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    mutex_.Lock();
    bool need_log_sync = !write_options.disableWAL && write_options.sync;
    bool need_log_dir_sync = need_log_sync && !log_dir_synced_;
-    // PreprocessWrite does its own perf timing.
-    PERF_TIMER_STOP(write_pre_and_post_process_time);
    w.status = PreprocessWrite(write_options, &need_log_sync, &write_context);
-    PERF_TIMER_START(write_pre_and_post_process_time);
    log::Writer* log_writer = logs_.back().writer;
    mutex_.Unlock();

@@ -482,7 +457,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    }

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

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

@@ -570,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(
@@ -602,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);
@@ -625,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
  }
@@ -643,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;
@@ -669,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() &&
@@ -717,8 +680,6 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
  assert(write_context != nullptr && need_log_sync != nullptr);
  Status status;

-  PERF_TIMER_GUARD(write_scheduling_flushes_compactions_time);
-
  assert(!single_column_family_mode_ ||
         versions_->GetColumnFamilySet()->NumberOfColumnFamilies() == 1);
  if (UNLIKELY(status.ok() && !single_column_family_mode_ &&
@@ -743,19 +704,14 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
    status = ScheduleFlushes(write_context);
  }

-  PERF_TIMER_STOP(write_scheduling_flushes_compactions_time);
-  PERF_TIMER_GUARD(write_pre_and_post_process_time);
-
  if (UNLIKELY(status.ok() && (write_controller_.IsStopped() ||
                               write_controller_.NeedsDelay()))) {
-    PERF_TIMER_STOP(write_pre_and_post_process_time);
    PERF_TIMER_GUARD(write_delay_time);
    // We don't know size of curent batch so that we always use the size
    // for previous one. It might create a fairness issue that expiration
    // might happen for smaller writes but larger writes can go through.
    // Can optimize it if it is an issue.
    status = DelayWrite(last_batch_group_size_, write_options);
-    PERF_TIMER_START(write_pre_and_post_process_time);
  }

  if (status.ok() && *need_log_sync) {
@@ -833,21 +789,7 @@ Status DBImpl::WriteToWAL(const WriteBatch& merged_batch,
  assert(log_size != nullptr);
  Slice log_entry = WriteBatchInternal::Contents(&merged_batch);
  *log_size = log_entry.size();
-  // When two_write_queues_ WriteToWAL has to be protected from concurretn calls
-  // from the two queues anyway and log_write_mutex_ is already held. Otherwise
-  // if manual_wal_flush_ is enabled we need to protect log_writer->AddRecord
-  // from possible concurrent calls via the FlushWAL by the application.
-  const bool needs_locking = manual_wal_flush_ && !two_write_queues_;
-  // Due to performance cocerns of missed branch prediction penalize the new
-  // manual_wal_flush_ feature (by UNLIKELY) instead of the more common case
-  // when we do not need any locking.
-  if (UNLIKELY(needs_locking)) {
-    log_write_mutex_.Lock();
-  }
  Status status = log_writer->AddRecord(log_entry);
-  if (UNLIKELY(needs_locking)) {
-    log_write_mutex_.Unlock();
-  }
  if (log_used != nullptr) {
    *log_used = logfile_number_;
  }
@@ -985,12 +927,7 @@ Status DBImpl::WriteRecoverableState() {
    if (two_write_queues_) {
      log_write_mutex_.Lock();
    }
-    SequenceNumber seq;
-    if (two_write_queues_) {
-      seq = versions_->FetchAddLastAllocatedSequence(0);
-    } else {
-      seq = versions_->LastSequence();
-    }
+    SequenceNumber seq = versions_->LastSequence();
    WriteBatchInternal::SetSequence(&cached_recoverable_state_, seq + 1);
    auto status = WriteBatchInternal::InsertInto(
        &cached_recoverable_state_, column_family_memtables_.get(),
@@ -1000,20 +937,12 @@ Status DBImpl::WriteRecoverableState() {
    auto last_seq = next_seq - 1;
    if (two_write_queues_) {
      versions_->FetchAddLastAllocatedSequence(last_seq - seq);
-      versions_->SetLastPublishedSequence(last_seq);
    }
    versions_->SetLastSequence(last_seq);
+    versions_->SetLastPublishedSequence(last_seq);
    if (two_write_queues_) {
      log_write_mutex_.Unlock();
    }
-    if (status.ok() && recoverable_state_pre_release_callback_) {
-      const bool DISABLE_MEMTABLE = true;
-      for (uint64_t sub_batch_seq = seq + 1;
-           sub_batch_seq < next_seq && status.ok(); sub_batch_seq++) {
-        status = recoverable_state_pre_release_callback_->Callback(
-            sub_batch_seq, !DISABLE_MEMTABLE);
-      }
-    }
    if (status.ok()) {
      cached_recoverable_state_.Clear();
      cached_recoverable_state_empty_ = true;
@@ -1033,34 +962,28 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
  }

  auto oldest_alive_log = alive_log_files_.begin()->number;
-  bool flush_wont_release_oldest_log = false;
-  if (allow_2pc()) {
-    auto oldest_log_with_uncommited_prep =
-        logs_with_prep_tracker_.FindMinLogContainingOutstandingPrep();
+  auto oldest_log_with_uncommited_prep = FindMinLogContainingOutstandingPrep();

-    assert(oldest_log_with_uncommited_prep == 0 ||
-           oldest_log_with_uncommited_prep >= oldest_alive_log);
-    if (oldest_log_with_uncommited_prep > 0 &&
-        oldest_log_with_uncommited_prep == oldest_alive_log) {
-      if (unable_to_release_oldest_log_) {
+  if (allow_2pc() &&
+      oldest_log_with_uncommited_prep > 0 &&
+      oldest_log_with_uncommited_prep <= oldest_alive_log) {
+    if (unable_to_flush_oldest_log_) {
        // we already attempted to flush all column families dependent on
-        // the oldest alive log but the log still contained uncommited
-        // transactions so there is still nothing that we can do.
+        // the oldest alive log but the log still contained uncommited transactions.
+        // the oldest alive log STILL contains uncommited transaction so there
+        // is still nothing that we can do.
        return status;
-      } else {
-        ROCKS_LOG_WARN(
-            immutable_db_options_.info_log,
-            "Unable to release oldest log due to uncommited transaction");
-        unable_to_release_oldest_log_ = true;
-        flush_wont_release_oldest_log = true;
-      }
+    } else {
+      ROCKS_LOG_WARN(
+          immutable_db_options_.info_log,
+          "Unable to release oldest log due to uncommited transaction");
+      unable_to_flush_oldest_log_ = true;
    }
-  }
-  if (!flush_wont_release_oldest_log) {
+  } else {
    // we only mark this log as getting flushed if we have successfully
    // flushed all data in this log. If this log contains outstanding prepared
    // transactions then we cannot flush this log until those transactions are commited.
-    unable_to_release_oldest_log_ = false;
+    unable_to_flush_oldest_log_ = false;
    alive_log_files_.begin()->getting_flushed = true;
  }

@@ -1081,7 +1004,7 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
        break;
      }
      cfd->imm()->FlushRequested();
-      SchedulePendingFlush(cfd, FlushReason::kWriteBufferManager);
+      SchedulePendingFlush(cfd);
    }
  }
  MaybeScheduleFlushOrCompaction();
@@ -1124,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();
    }
  }
@@ -1215,7 +1137,6 @@ Status DBImpl::ThrottleLowPriWritesIfNeeded(const WriteOptions& write_options,
      // is that in case the write is heavy, low pri writes may never have
      // a chance to run. Now we guarantee we are still slowly making
      // progress.
-      PERF_TIMER_GUARD(write_delay_time);
      write_controller_.low_pri_rate_limiter()->Request(
          my_batch->GetDataSize(), Env::IO_HIGH, nullptr /* stats */,
          RateLimiter::OpType::kWrite);
@@ -1227,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;
    }
@@ -1239,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;
@@ -1256,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_) {
@@ -1372,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);
@@ -1405,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
@@ -1425,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);
  }
@@ -1434,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);
@@ -1462,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);
 }

@@ -1494,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;
@@ -2550,7 +2550,7 @@ TEST_F(DBIterWithMergeIterTest, InnerMergeIteratorDataRace1) {
  // and before an SeekToLast() is called.
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "MergeIterator::Prev:BeforeSeekToLast",
-      [&](void* /*arg*/) { internal_iter2_->Add("z", kTypeValue, "7", 12u); });
+      [&](void* arg) { internal_iter2_->Add("z", kTypeValue, "7", 12u); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  db_iter_->Prev();
@@ -2585,7 +2585,7 @@ TEST_F(DBIterWithMergeIterTest, InnerMergeIteratorDataRace2) {
  // mem table after MergeIterator::Prev() realized the mem tableiterator is at
  // its end and before an SeekToLast() is called.
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "MergeIterator::Prev:BeforeSeekToLast", [&](void* /*arg*/) {
+      "MergeIterator::Prev:BeforeSeekToLast", [&](void* arg) {
        internal_iter2_->Add("z", kTypeValue, "7", 12u);
        internal_iter2_->Add("z", kTypeValue, "7", 11u);
      });
@@ -2623,7 +2623,7 @@ TEST_F(DBIterWithMergeIterTest, InnerMergeIteratorDataRace3) {
  // mem table after MergeIterator::Prev() realized the mem table iterator is at
  // its end and before an SeekToLast() is called.
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "MergeIterator::Prev:BeforeSeekToLast", [&](void* /*arg*/) {
+      "MergeIterator::Prev:BeforeSeekToLast", [&](void* arg) {
        internal_iter2_->Add("z", kTypeValue, "7", 16u, true);
        internal_iter2_->Add("z", kTypeValue, "7", 15u, true);
        internal_iter2_->Add("z", kTypeValue, "7", 14u, true);
@@ -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)
@@ -289,8 +289,6 @@ int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
 #else
-  (void) argc;
-  (void) argv;
  return 0;
 #endif
 }
@@ -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) {
@@ -134,7 +134,7 @@ TEST_F(DBOptionsTest, SetBytesPerSync) {
  const std::string kValue(kValueSize, 'v');
  ASSERT_EQ(options.bytes_per_sync, dbfull()->GetDBOptions().bytes_per_sync);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "WritableFileWriter::RangeSync:0", [&](void* /*arg*/) {
+      "WritableFileWriter::RangeSync:0", [&](void* arg) {
        counter++;
      });

@@ -183,7 +183,7 @@ TEST_F(DBOptionsTest, SetWalBytesPerSync) {
  int counter = 0;
  int low_bytes_per_sync = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "WritableFileWriter::RangeSync:0", [&](void* /*arg*/) {
+      "WritableFileWriter::RangeSync:0", [&](void* arg) {
        counter++;
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
@@ -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,157 +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);
-}
-
-TEST_F(DBPropertiesTest, BlockCacheProperties) {
-  Options options;
-  uint64_t value;
-
-  // Block cache properties are not available for tables other than
-  // block-based table.
-  options.table_factory.reset(NewPlainTableFactory());
-  Reopen(options);
-  ASSERT_FALSE(
-      db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
-  ASSERT_FALSE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  ASSERT_FALSE(
-      db_->GetIntProperty(DB::Properties::kBlockCachePinnedUsage, &value));
-
-  options.table_factory.reset(NewCuckooTableFactory());
-  Reopen(options);
-  ASSERT_FALSE(
-      db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
-  ASSERT_FALSE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  ASSERT_FALSE(
-      db_->GetIntProperty(DB::Properties::kBlockCachePinnedUsage, &value));
-
-  // Block cache properties are not available if block cache is not used.
-  BlockBasedTableOptions table_options;
-  table_options.no_block_cache = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  Reopen(options);
-  ASSERT_FALSE(
-      db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
-  ASSERT_FALSE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  ASSERT_FALSE(
-      db_->GetIntProperty(DB::Properties::kBlockCachePinnedUsage, &value));
-
-  // Test with empty block cache.
-  constexpr size_t kCapacity = 100;
-  auto block_cache = NewLRUCache(kCapacity, 0 /*num_shard_bits*/);
-  table_options.block_cache = block_cache;
-  table_options.no_block_cache = false;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  Reopen(options);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
-  ASSERT_EQ(kCapacity, value);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  ASSERT_EQ(0, value);
-  ASSERT_TRUE(
-      db_->GetIntProperty(DB::Properties::kBlockCachePinnedUsage, &value));
-  ASSERT_EQ(0, value);
-
-  // Insert unpinned item to the cache and check size.
-  constexpr size_t kSize1 = 50;
-  block_cache->Insert("item1", nullptr /*value*/, kSize1, nullptr /*deleter*/);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
-  ASSERT_EQ(kCapacity, value);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  ASSERT_EQ(kSize1, value);
-  ASSERT_TRUE(
-      db_->GetIntProperty(DB::Properties::kBlockCachePinnedUsage, &value));
-  ASSERT_EQ(0, value);
-
-  // Insert pinned item to the cache and check size.
-  constexpr size_t kSize2 = 30;
-  Cache::Handle* item2 = nullptr;
-  block_cache->Insert("item2", nullptr /*value*/, kSize2, nullptr /*deleter*/,
-                      &item2);
-  ASSERT_NE(nullptr, item2);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
-  ASSERT_EQ(kCapacity, value);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  ASSERT_EQ(kSize1 + kSize2, value);
-  ASSERT_TRUE(
-      db_->GetIntProperty(DB::Properties::kBlockCachePinnedUsage, &value));
-  ASSERT_EQ(kSize2, value);
-
-  // Insert another pinned item to make the cache over-sized.
-  constexpr size_t kSize3 = 80;
-  Cache::Handle* item3 = nullptr;
-  block_cache->Insert("item3", nullptr /*value*/, kSize3, nullptr /*deleter*/,
-                      &item3);
-  ASSERT_NE(nullptr, item2);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
-  ASSERT_EQ(kCapacity, value);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  // Item 1 is evicted.
-  ASSERT_EQ(kSize2 + kSize3, value);
-  ASSERT_TRUE(
-      db_->GetIntProperty(DB::Properties::kBlockCachePinnedUsage, &value));
-  ASSERT_EQ(kSize2 + kSize3, value);
-
-  // Check size after release.
-  block_cache->Release(item2);
-  block_cache->Release(item3);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
-  ASSERT_EQ(kCapacity, value);
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  // item2 will be evicted, while item3 remain in cache after release.
-  ASSERT_EQ(kSize3, value);
-  ASSERT_TRUE(
-      db_->GetIntProperty(DB::Properties::kBlockCachePinnedUsage, &value));
-  ASSERT_EQ(0, value);
-}
-
 #endif  // ROCKSDB_LITE
 }  // namespace rocksdb

@@ -433,8 +433,8 @@ TEST_F(DBRangeDelTest, ValidUniversalSubcompactionBoundaries) {
      reinterpret_cast<ColumnFamilyHandleImpl*>(db_->DefaultColumnFamily())
          ->cfd(),
      1 /* input_level */, 2 /* output_level */, 0 /* output_path_id */,
-      0 /* max_subcompactions */, nullptr /* begin */, nullptr /* end */,
-      true /* exclusive */, true /* disallow_trivial_move */));
+      nullptr /* begin */, nullptr /* end */, true /* exclusive */,
+      true /* disallow_trivial_move */));
 }
 #endif  // ROCKSDB_LITE

@@ -20,37 +20,6 @@ class DBSSTTest : public DBTestBase {
  DBSSTTest() : DBTestBase("/db_sst_test") {}
 };

-#ifndef ROCKSDB_LITE
-// A class which remembers the name of each flushed file.
-class FlushedFileCollector : public EventListener {
- public:
-  FlushedFileCollector() {}
-  ~FlushedFileCollector() {}
-
-  virtual void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
-    std::lock_guard<std::mutex> lock(mutex_);
-    flushed_files_.push_back(info.file_path);
-  }
-
-  std::vector<std::string> GetFlushedFiles() {
-    std::lock_guard<std::mutex> lock(mutex_);
-    std::vector<std::string> result;
-    for (auto fname : flushed_files_) {
-      result.push_back(fname);
-    }
-    return result;
-  }
-  void ClearFlushedFiles() {
-    std::lock_guard<std::mutex> lock(mutex_);
-    flushed_files_.clear();
-  }
-
- private:
-  std::vector<std::string> flushed_files_;
-  std::mutex mutex_;
-};
-#endif  // ROCKSDB_LITE
-
 TEST_F(DBSSTTest, DontDeletePendingOutputs) {
  Options options;
  options.env = env_;
@@ -103,7 +72,7 @@ TEST_F(DBSSTTest, SSTsWithLdbSuffixHandling) {
  ASSERT_GT(num_files, 0);

  std::vector<std::string> filenames;
-  GetSstFiles(env_, dbname_, &filenames);
+  GetSstFiles(dbname_, &filenames);
  int num_ldb_files = 0;
  for (size_t i = 0; i < filenames.size(); ++i) {
    if (i & 1) {
@@ -262,11 +231,11 @@ TEST_F(DBSSTTest, DBWithSstFileManager) {
  int files_deleted = 0;
  int files_moved = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::OnAddFile", [&](void* /*arg*/) { files_added++; });
+      "SstFileManagerImpl::OnAddFile", [&](void* arg) { files_added++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::OnDeleteFile", [&](void* /*arg*/) { files_deleted++; });
+      "SstFileManagerImpl::OnDeleteFile", [&](void* arg) { files_deleted++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::OnMoveFile", [&](void* /*arg*/) { files_moved++; });
+      "SstFileManagerImpl::OnMoveFile", [&](void* arg) { files_moved++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
@@ -439,12 +408,7 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
  int bg_delete_file = 0;
  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++; });
+      [&](void* arg) { bg_delete_file++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
@@ -497,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();
 }
@@ -514,7 +476,7 @@ TEST_F(DBSSTTest, DestroyDBWithRateLimitedDelete) {
  int bg_delete_file = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DeleteScheduler::DeleteTrashFile:DeleteFile",
-      [&](void* /*arg*/) { bg_delete_file++; });
+      [&](void* arg) { bg_delete_file++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Status s;
@@ -576,127 +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);
-        ASSERT_EQ(sfm->GetCompactionsReservedSize(), 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);
-
-  // Because we set a callback in CancelledCompaction, we actually
-  // let the compaction run
-  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, CancellingManualCompactionsWorks) {
-  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.statistics = CreateDBStatistics();
-
-  FlushedFileCollector* collector = new FlushedFileCollector();
-  options.listeners.emplace_back(collector);
-
-  DestroyAndReopen(options);
-
-  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());
-
-  // OK, now trigger a manual compaction
-  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-
-  // Wait for manual compaction to get scheduled and finish
-  dbfull()->TEST_WaitForCompact(true);
-
-  ASSERT_EQ(sfm->GetCompactionsReservedSize(), 0);
-  // Make sure the stat is bumped
-  ASSERT_EQ(dbfull()->immutable_db_options().statistics.get()->getTickerCount(
-                COMPACTION_CANCELLED),
-            1);
-
-  // Now make sure CompactFiles also gets cancelled
-  auto l0_files = collector->GetFlushedFiles();
-  dbfull()->CompactFiles(rocksdb::CompactionOptions(), l0_files, 0);
-
-  // Wait for manual compaction to get scheduled and finish
-  dbfull()->TEST_WaitForCompact(true);
-
-  ASSERT_EQ(dbfull()->immutable_db_options().statistics.get()->getTickerCount(
-                COMPACTION_CANCELLED),
-            2);
-  ASSERT_EQ(sfm->GetCompactionsReservedSize(), 0);
-
-  // Now let the flush through and make sure GetCompactionsReservedSize
-  // returns to normal
-  sfm->SetMaxAllowedSpaceUsage(0);
-  int completed_compactions = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "CompactFilesImpl:End", [&](void* /*arg*/) { completed_compactions++; });
-
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  dbfull()->CompactFiles(rocksdb::CompactionOptions(), l0_files, 0);
-  dbfull()->TEST_WaitForCompact(true);
-
-  ASSERT_EQ(sfm->GetCompactionsReservedSize(), 0);
-  ASSERT_GT(completed_compactions, 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.
@@ -725,15 +566,9 @@ 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*/) {
+      [&](void* arg) {
        bg_error_set = true;
        GetAllSSTFiles(&total_sst_files_size);
        reached_max_space_on_compaction++;
@@ -157,10 +157,10 @@ TEST_F(DBTestTailingIterator, TailingIteratorTrimSeekToNext) {
      });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "ForwardIterator::RenewIterators:Null",
-      [&](void* /*arg*/) { file_iters_renewed_null = true; });
+      [&](void* arg) { file_iters_renewed_null = true; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "ForwardIterator::RenewIterators:Copy",
-      [&](void* /*arg*/) { file_iters_renewed_copy = true; });
+      [&](void* arg) { file_iters_renewed_copy = true; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  const int num_records = 1000;
  for (int i = 1; i < num_records; ++i) {
@@ -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());
@@ -415,7 +415,7 @@ TEST_F(DBTestTailingIterator, TailingIteratorUpperBound) {
  int immutable_seeks = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "ForwardIterator::SeekInternal:Immutable",
-      [&](void* /*arg*/) { ++immutable_seeks; });
+      [&](void* arg) { ++immutable_seeks; });

  // Seek to 13. This should not require any immutable seeks.
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
@@ -809,8 +809,6 @@ int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
 #else
-  (void) argc;
-  (void) argv;
  return 0;
 #endif
 }
@@ -234,11 +234,11 @@ TEST_F(DBTest, SkipDelay) {
      std::atomic<int> sleep_count(0);
      rocksdb::SyncPoint::GetInstance()->SetCallBack(
          "DBImpl::DelayWrite:Sleep",
-          [&](void* /*arg*/) { sleep_count.fetch_add(1); });
+          [&](void* arg) { sleep_count.fetch_add(1); });
      std::atomic<int> wait_count(0);
      rocksdb::SyncPoint::GetInstance()->SetCallBack(
          "DBImpl::DelayWrite:Wait",
-          [&](void* /*arg*/) { wait_count.fetch_add(1); });
+          [&](void* arg) { wait_count.fetch_add(1); });
      rocksdb::SyncPoint::GetInstance()->EnableProcessing();

      WriteOptions wo;
@@ -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;
  }

@@ -3348,56 +3306,6 @@ TEST_F(DBTest, WriteSingleThreadEntry) {
  }
 }

-TEST_F(DBTest, ConcurrentFlushWAL) {
-  const size_t cnt = 100;
-  Options options;
-  WriteOptions wopt;
-  ReadOptions ropt;
-  for (bool two_write_queues : {false, true}) {
-    for (bool manual_wal_flush : {false, true}) {
-      options.two_write_queues = two_write_queues;
-      options.manual_wal_flush = manual_wal_flush;
-      options.create_if_missing = true;
-      DestroyAndReopen(options);
-      std::vector<port::Thread> threads;
-      threads.emplace_back([&] {
-        for (size_t i = 0; i < cnt; i++) {
-          auto istr = ToString(i);
-          db_->Put(wopt, db_->DefaultColumnFamily(), "a" + istr, "b" + istr);
-        }
-      });
-      if (two_write_queues) {
-        threads.emplace_back([&] {
-          for (size_t i = cnt; i < 2 * cnt; i++) {
-            auto istr = ToString(i);
-            WriteBatch batch;
-            batch.Put("a" + istr, "b" + istr);
-            dbfull()->WriteImpl(wopt, &batch, nullptr, nullptr, 0, true);
-          }
-        });
-      }
-      threads.emplace_back([&] {
-        for (size_t i = 0; i < cnt * 100; i++) {  // FlushWAL is faster than Put
-          db_->FlushWAL(false);
-        }
-      });
-      for (auto& t : threads) {
-        t.join();
-      }
-      options.create_if_missing = false;
-      // Recover from the wal and make sure that it is not corrupted
-      Reopen(options);
-      for (size_t i = 0; i < cnt; i++) {
-        PinnableSlice pval;
-        auto istr = ToString(i);
-        ASSERT_OK(
-            db_->Get(ropt, db_->DefaultColumnFamily(), "a" + istr, &pval));
-        ASSERT_TRUE(pval == ("b" + istr));
-      }
-    }
-  }
-}
-
 #ifndef ROCKSDB_LITE
 TEST_F(DBTest, DynamicMemtableOptions) {
  const uint64_t k64KB = 1 << 16;
@@ -3491,7 +3399,7 @@ TEST_F(DBTest, DynamicMemtableOptions) {

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::DelayWrite:Wait",
-      [&](void* /*arg*/) { sleeping_task_low.WakeUp(); });
+      [&](void* arg) { sleeping_task_low.WakeUp(); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  while (!sleeping_task_low.WokenUp() && count < 256) {
@@ -4838,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 = "";
@@ -5194,7 +5102,7 @@ TEST_F(DBTest, AutomaticConflictsWithManualCompaction) {
  std::atomic<int> callback_count(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::MaybeScheduleFlushOrCompaction:Conflict",
-      [&](void* /*arg*/) { callback_count.fetch_add(1); });
+      [&](void* arg) { callback_count.fetch_add(1); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Random rnd(301);
@@ -5205,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) {
@@ -5417,7 +5325,7 @@ TEST_F(DBTest, HardLimit) {

  std::atomic<int> callback_count(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack("DBImpl::DelayWrite:Wait",
-                                                 [&](void* /*arg*/) {
+                                                 [&](void* arg) {
                                                   callback_count.fetch_add(1);
                                                   sleeping_task_low.WakeUp();
                                                 });
@@ -5442,45 +5350,21 @@ TEST_F(DBTest, HardLimit) {
  sleeping_task_low.WaitUntilDone();
 }

-#if !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION)
+#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) {
@@ -5554,7 +5438,7 @@ TEST_F(DBTest, SoftLimit) {

  // Only allow one compactin going through.
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "BackgroundCallCompaction:0", [&](void* /*arg*/) {
+      "BackgroundCallCompaction:0", [&](void* arg) {
        // Schedule a sleeping task.
        sleeping_task_low.Reset();
        env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask,
@@ -5664,7 +5548,7 @@ TEST_F(DBTest, LastWriteBufferDelay) {
  sleeping_task.WakeUp();
  sleeping_task.WaitUntilDone();
 }
-#endif  // !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION)
+#endif  // ROCKSDB_LITE

 TEST_F(DBTest, FailWhenCompressionNotSupportedTest) {
  CompressionType compressions[] = {kZlibCompression, kBZip2Compression,
@@ -5808,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_;
@@ -1112,7 +1113,7 @@ TEST_F(DBTest2, PresetCompressionDict) {

      size_t out_bytes = 0;
      std::vector<std::string> files;
-      GetSstFiles(env_, dbname_, &files);
+      GetSstFiles(dbname_, &files);
      for (const auto& file : files) {
        uint64_t curr_bytes;
        env_->GetFileSize(dbname_ + "/" + file, &curr_bytes);
@@ -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);
@@ -1691,7 +1692,7 @@ TEST_F(DBTest2, SyncPointMarker) {
  std::atomic<int> sync_point_called(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBTest2::MarkedPoint",
-      [&](void* /*arg*/) { sync_point_called.fetch_add(1); });
+      [&](void* arg) { sync_point_called.fetch_add(1); });

  // The first dependency enforces Marker can be loaded before MarkedPoint.
  // The second checks that thread 1's MarkedPoint should be disabled here.
@@ -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++) {
@@ -1978,7 +1961,7 @@ TEST_F(DBTest2, AutomaticCompactionOverlapManualCompaction) {
  // can fit in L2, these 2 files will be moved to L2 and overlap with
  // the running compaction and break the LSM consistency.
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::Run():Start", [&](void* /*arg*/) {
+      "CompactionJob::Run():Start", [&](void* arg) {
        ASSERT_OK(
            dbfull()->SetOptions({{"level0_file_num_compaction_trigger", "2"},
                                  {"max_bytes_for_level_base", "1"}}));
@@ -2044,7 +2027,7 @@ TEST_F(DBTest2, ManualCompactionOverlapManualCompaction) {
  // the running compaction and break the LSM consistency.
  std::atomic<bool> flag(false);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::Run():Start", [&](void* /*arg*/) {
+      "CompactionJob::Run():Start", [&](void* arg) {
        if (flag.exchange(true)) {
          // We want to make sure to call this callback only once
          return;
@@ -2296,8 +2279,7 @@ TEST_F(DBTest2, RateLimitedCompactionReads) {
                             kBytesPerKey) /* rate_bytes_per_sec */,
        10 * 1000 /* refill_period_us */, 10 /* fairness */,
        RateLimiter::Mode::kReadsOnly));
-    options.use_direct_reads = options.use_direct_io_for_flush_and_compaction =
-        use_direct_io;
+    options.use_direct_io_for_flush_and_compaction = use_direct_io;
    BlockBasedTableOptions bbto;
    bbto.block_size = 16384;
    bbto.no_block_cache = true;
@@ -2319,7 +2301,7 @@ TEST_F(DBTest2, RateLimitedCompactionReads) {
    // chose 1MB as the upper bound on the total bytes read.
    size_t rate_limited_bytes =
        options.rate_limiter->GetTotalBytesThrough(Env::IO_LOW);
-    // Include the explicit prefetch of the footer in direct I/O case.
+    // Include the explict prefetch of the footer in direct I/O case.
    size_t direct_io_extra = use_direct_io ? 512 * 1024 : 0;
    ASSERT_GE(rate_limited_bytes,
              static_cast<size_t>(kNumKeysPerFile * kBytesPerKey * kNumL0Files +
@@ -2479,7 +2461,7 @@ TEST_F(DBTest2, LiveFilesOmitObsoleteFiles) {
  });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::PurgeObsoleteFiles:Begin",
-      [&](void* /*arg*/) { env_->SleepForMicroseconds(1000000); });
+      [&](void* arg) { env_->SleepForMicroseconds(1000000); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Put("key", "val");
@@ -575,17 +575,9 @@ void DBTestBase::DestroyAndReopen(const Options& options) {
  ASSERT_OK(TryReopen(options));
 }

-void DBTestBase::Destroy(const Options& options, bool delete_cf_paths) {
-  std::vector<ColumnFamilyDescriptor> column_families;
-  if (delete_cf_paths) {
-    for (size_t i = 0; i < handles_.size(); ++i) {
-      ColumnFamilyDescriptor cfdescriptor;
-      handles_[i]->GetDescriptor(&cfdescriptor);
-      column_families.push_back(cfdescriptor);
-    }
-  }
+void DBTestBase::Destroy(const Options& options) {
  Close();
-  ASSERT_OK(DestroyDB(dbname_, options, column_families));
+  ASSERT_OK(DestroyDB(dbname_, options));
 }

 Status DBTestBase::ReadOnlyReopen(const Options& options) {
@@ -1025,9 +1017,9 @@ std::string DBTestBase::DumpSSTableList() {
  return property;
 }

-void DBTestBase::GetSstFiles(Env* env, std::string path,
+void DBTestBase::GetSstFiles(std::string path,
                             std::vector<std::string>* files) {
-  env->GetChildren(path, files);
+  env_->GetChildren(path, files);

  files->erase(
      std::remove_if(files->begin(), files->end(), [](std::string name) {
@@ -1039,7 +1031,7 @@ void DBTestBase::GetSstFiles(Env* env, std::string path,

 int DBTestBase::GetSstFileCount(std::string path) {
  std::vector<std::string> files;
-  DBTestBase::GetSstFiles(env_, path, &files);
+  GetSstFiles(path, &files);
  return static_cast<int>(files.size());
 }

@@ -1151,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_);
@@ -451,9 +451,8 @@ class SpecialEnv : public EnvWrapper {
    return s;
  }

-  virtual Status NewSequentialFile(const std::string& f,
-                                   unique_ptr<SequentialFile>* r,
-                                   const EnvOptions& soptions) override {
+  Status NewSequentialFile(const std::string& f, unique_ptr<SequentialFile>* r,
+                           const EnvOptions& soptions) override {
    class CountingFile : public SequentialFile {
     public:
      CountingFile(unique_ptr<SequentialFile>&& target,
@@ -606,7 +605,7 @@ class MockTimeEnv : public EnvWrapper {
  }

 private:
-  std::atomic<uint64_t> current_time_{0};
+  uint64_t current_time_ = 0;
 };

 #ifndef ROCKSDB_LITE
@@ -804,7 +803,7 @@ class DBTestBase : public testing::Test {

  void DestroyAndReopen(const Options& options);

-  void Destroy(const Options& options, bool delete_cf_paths = false);
+  void Destroy(const Options& options);

  Status ReadOnlyReopen(const Options& options);

@@ -904,8 +903,7 @@ class DBTestBase : public testing::Test {

  std::string DumpSSTableList();

-  static void GetSstFiles(Env* env, std::string path,
-                          std::vector<std::string>* files);
+  void GetSstFiles(std::string path, std::vector<std::string>* files);

  int GetSstFileCount(std::string path);

@@ -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) {
@@ -697,7 +595,7 @@ TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionTrivialMove) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial", [&](void* arg) {
        non_trivial_move++;
@@ -769,7 +667,7 @@ TEST_P(DBTestUniversalCompactionParallel, UniversalCompactionParallel) {
  std::atomic<int> num_compactions_running(0);
  std::atomic<bool> has_parallel(false);
  rocksdb::SyncPoint::GetInstance()->SetCallBack("CompactionJob::Run():Start",
-                                                 [&](void* /*arg*/) {
+                                                 [&](void* arg) {
    if (num_compactions_running.fetch_add(1) > 0) {
      has_parallel.store(true);
      return;
@@ -784,7 +682,7 @@ TEST_P(DBTestUniversalCompactionParallel, UniversalCompactionParallel) {
  });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "CompactionJob::Run():End",
-      [&](void* /*arg*/) { num_compactions_running.fetch_add(-1); });
+      [&](void* arg) { num_compactions_running.fetch_add(-1); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  options = CurrentOptions(options);
@@ -1154,7 +1052,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest1) {
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial", [&](void* arg) {
        non_trivial_move++;
@@ -1200,7 +1098,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest2) {
  int32_t trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
-      [&](void* /*arg*/) { trivial_move++; });
+      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial", [&](void* arg) {
        ASSERT_TRUE(arg != nullptr);
@@ -1343,146 +1241,6 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionFourPaths) {
  Destroy(options);
 }

-TEST_P(DBTestUniversalCompaction, UniversalCompactionCFPathUse) {
-  Options options = CurrentOptions();
-  options.db_paths.emplace_back(dbname_, 300 * 1024);
-  options.db_paths.emplace_back(dbname_ + "_2", 300 * 1024);
-  options.db_paths.emplace_back(dbname_ + "_3", 500 * 1024);
-  options.db_paths.emplace_back(dbname_ + "_4", 1024 * 1024 * 1024);
-  options.memtable_factory.reset(
-      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
-  options.compaction_style = kCompactionStyleUniversal;
-  options.compaction_options_universal.size_ratio = 5;
-  options.write_buffer_size = 111 << 10;  // 114KB
-  options.arena_block_size = 4 << 10;
-  options.level0_file_num_compaction_trigger = 2;
-  options.num_levels = 1;
-
-  std::vector<Options> option_vector;
-  option_vector.emplace_back(options);
-  ColumnFamilyOptions cf_opt1(options), cf_opt2(options);
-  // Configure CF1 specific paths.
-  cf_opt1.cf_paths.emplace_back(dbname_ + "cf1", 300 * 1024);
-  cf_opt1.cf_paths.emplace_back(dbname_ + "cf1_2", 300 * 1024);
-  cf_opt1.cf_paths.emplace_back(dbname_ + "cf1_3", 500 * 1024);
-  cf_opt1.cf_paths.emplace_back(dbname_ + "cf1_4", 1024 * 1024 * 1024);
-  option_vector.emplace_back(DBOptions(options), cf_opt1);
-  CreateColumnFamilies({"one"},option_vector[1]);
-
-  // Configura CF2 specific paths.
-  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2", 300 * 1024);
-  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2_2", 300 * 1024);
-  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2_3", 500 * 1024);
-  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2_4", 1024 * 1024 * 1024);
-  option_vector.emplace_back(DBOptions(options), cf_opt2);
-  CreateColumnFamilies({"two"},option_vector[2]);
-
-  ReopenWithColumnFamilies({"default", "one", "two"}, option_vector);
-
-  Random rnd(301);
-  int key_idx = 0;
-  int key_idx1 = 0;
-  int key_idx2 = 0;
-
-  auto generate_file = [&]() {
-    GenerateNewFile(0, &rnd, &key_idx);
-    GenerateNewFile(1, &rnd, &key_idx1);
-    GenerateNewFile(2, &rnd, &key_idx2);
-  };
-
-  auto check_sstfilecount = [&](int path_id, int expected) {
-    ASSERT_EQ(expected, GetSstFileCount(options.db_paths[path_id].path));
-    ASSERT_EQ(expected, GetSstFileCount(cf_opt1.cf_paths[path_id].path));
-    ASSERT_EQ(expected, GetSstFileCount(cf_opt2.cf_paths[path_id].path));
-  };
-
-  auto check_getvalues = [&]() {
-    for (int i = 0; i < key_idx; i++) {
-      auto v = Get(0, Key(i));
-      ASSERT_NE(v, "NOT_FOUND");
-      ASSERT_TRUE(v.size() == 1 || v.size() == 990);
-    }
-
-    for (int i = 0; i < key_idx1; i++) {
-      auto v = Get(1, Key(i));
-      ASSERT_NE(v, "NOT_FOUND");
-      ASSERT_TRUE(v.size() == 1 || v.size() == 990);
-    }
-
-    for (int i = 0; i < key_idx2; i++) {
-      auto v = Get(2, Key(i));
-      ASSERT_NE(v, "NOT_FOUND");
-      ASSERT_TRUE(v.size() == 1 || v.size() == 990);
-    }
-  };
-
-  // First three 110KB files are not going to second path.
-  // After that, (100K, 200K)
-  for (int num = 0; num < 3; num++) {
-    generate_file();
-  }
-
-  // Another 110KB triggers a compaction to 400K file to second path
-  generate_file();
-  check_sstfilecount(2, 1);
-
-  // (1, 4)
-  generate_file();
-  check_sstfilecount(2, 1);
-  check_sstfilecount(0, 1);
-
-  // (1,1,4) -> (2, 4)
-  generate_file();
-  check_sstfilecount(2, 1);
-  check_sstfilecount(1, 1);
-  check_sstfilecount(0, 0);
-
-  // (1, 2, 4) -> (3, 4)
-  generate_file();
-  check_sstfilecount(2, 1);
-  check_sstfilecount(1, 1);
-  check_sstfilecount(0, 0);
-
-  // (1, 3, 4) -> (8)
-  generate_file();
-  check_sstfilecount(3, 1);
-
-  // (1, 8)
-  generate_file();
-  check_sstfilecount(3, 1);
-  check_sstfilecount(0, 1);
-
-  // (1, 1, 8) -> (2, 8)
-  generate_file();
-  check_sstfilecount(3, 1);
-  check_sstfilecount(1, 1);
-
-  // (1, 2, 8) -> (3, 8)
-  generate_file();
-  check_sstfilecount(3, 1);
-  check_sstfilecount(1, 1);
-  check_sstfilecount(0, 0);
-
-  // (1, 3, 8) -> (4, 8)
-  generate_file();
-  check_sstfilecount(2, 1);
-  check_sstfilecount(3, 1);
-
-  // (1, 4, 8) -> (5, 8)
-  generate_file();
-  check_sstfilecount(3, 1);
-  check_sstfilecount(2, 1);
-  check_sstfilecount(0, 0);
-
-  check_getvalues();
-
-  ReopenWithColumnFamilies({"default", "one", "two"}, option_vector);
-
-  check_getvalues();
-
-  Destroy(options, true);
-}
-
 TEST_P(DBTestUniversalCompaction, IncreaseUniversalCompactionNumLevels) {
  std::function<void(int)> verify_func = [&](int num_keys_in_db) {
    std::string keys_in_db;
@@ -1698,7 +1456,7 @@ TEST_P(DBTestUniversalCompaction, FullCompactionInBottomPriThreadPool) {
    int num_bottom_pri_compactions = 0;
    SyncPoint::GetInstance()->SetCallBack(
        "DBImpl::BGWorkBottomCompaction",
-        [&](void* /*arg*/) { ++num_bottom_pri_compactions; });
+        [&](void* arg) { ++num_bottom_pri_compactions; });
    SyncPoint::GetInstance()->EnableProcessing();

    Random rnd(301);
@@ -1796,7 +1554,7 @@ TEST_P(DBTestUniversalCompaction, RecalculateScoreAfterPicking) {

  std::atomic<int> num_compactions_attempted(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:Start", [&](void* /*arg*/) {
+      "DBImpl::BackgroundCompaction:Start", [&](void* arg) {
        ++num_compactions_attempted;
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
@@ -1899,8 +1657,6 @@ int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
 #else
-  (void) argc;
-  (void) argv;
  return 0;
 #endif
 }
@@ -20,106 +20,6 @@ class DBWALTest : public DBTestBase {
  DBWALTest() : DBTestBase("/db_wal_test") {}
 };

-// A SpecialEnv enriched to give more insight about deleted files
-class EnrichedSpecialEnv : public SpecialEnv {
- public:
-  explicit EnrichedSpecialEnv(Env* base) : SpecialEnv(base) {}
-  Status NewSequentialFile(const std::string& f, unique_ptr<SequentialFile>* r,
-                           const EnvOptions& soptions) override {
-    InstrumentedMutexLock l(&env_mutex_);
-    if (f == skipped_wal) {
-      deleted_wal_reopened = true;
-      if (IsWAL(f) && largetest_deleted_wal.size() != 0 &&
-          f.compare(largetest_deleted_wal) <= 0) {
-        gap_in_wals = true;
-      }
-    }
-    return SpecialEnv::NewSequentialFile(f, r, soptions);
-  }
-  Status DeleteFile(const std::string& fname) override {
-    if (IsWAL(fname)) {
-      deleted_wal_cnt++;
-      InstrumentedMutexLock l(&env_mutex_);
-      // If this is the first WAL, remember its name and skip deleting it. We
-      // remember its name partly because the application might attempt to
-      // delete the file again.
-      if (skipped_wal.size() != 0 && skipped_wal != fname) {
-        if (largetest_deleted_wal.size() == 0 ||
-            largetest_deleted_wal.compare(fname) < 0) {
-          largetest_deleted_wal = fname;
-        }
-      } else {
-        skipped_wal = fname;
-        return Status::OK();
-      }
-    }
-    return SpecialEnv::DeleteFile(fname);
-  }
-  bool IsWAL(const std::string& fname) {
-    // printf("iswal %s\n", fname.c_str());
-    return fname.compare(fname.size() - 3, 3, "log") == 0;
-  }
-
-  InstrumentedMutex env_mutex_;
-  // the wal whose actual delete was skipped by the env
-  std::string skipped_wal = "";
-  // the largest WAL that was requested to be deleted
-  std::string largetest_deleted_wal = "";
-  // number of WALs that were successfully deleted
-  std::atomic<size_t> deleted_wal_cnt = {0};
-  // the WAL whose delete from fs was skipped is reopened during recovery
-  std::atomic<bool> deleted_wal_reopened = {false};
-  // whether a gap in the WALs was detected during recovery
-  std::atomic<bool> gap_in_wals = {false};
-};
-
-class DBWALTestWithEnrichedEnv : public DBTestBase {
- public:
-  DBWALTestWithEnrichedEnv() : DBTestBase("/db_wal_test") {
-    enriched_env_ = new EnrichedSpecialEnv(env_->target());
-    auto options = CurrentOptions();
-    options.env = enriched_env_;
-    Reopen(options);
-    delete env_;
-    // to be deleted by the parent class
-    env_ = enriched_env_;
-  }
-
- protected:
-  EnrichedSpecialEnv* enriched_env_;
-};
-
-// Test that the recovery would successfully avoid the gaps between the logs.
-// One known scenario that could cause this is that the application issue the
-// WAL deletion out of order. For the sake of simplicity in the test, here we
-// create the gap by manipulating the env to skip deletion of the first WAL but
-// not the ones after it.
-TEST_F(DBWALTestWithEnrichedEnv, SkipDeletedWALs) {
-  auto options = last_options_;
-  // To cause frequent WAL deletion
-  options.write_buffer_size = 128;
-  Reopen(options);
-
-  WriteOptions writeOpt = WriteOptions();
-  for (int i = 0; i < 128 * 5; i++) {
-    ASSERT_OK(dbfull()->Put(writeOpt, "foo", "v1"));
-  }
-  FlushOptions fo;
-  fo.wait = true;
-  ASSERT_OK(db_->Flush(fo));
-
-  // some wals are deleted
-  ASSERT_NE(0, enriched_env_->deleted_wal_cnt);
-  // but not the first one
-  ASSERT_NE(0, enriched_env_->skipped_wal.size());
-
-  // Test that the WAL that was not deleted will be skipped during recovery
-  options = last_options_;
-  Reopen(options);
-  ASSERT_FALSE(enriched_env_->deleted_wal_reopened);
-  ASSERT_FALSE(enriched_env_->gap_in_wals);
-}
-
 TEST_F(DBWALTest, WAL) {
  do {
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
@@ -991,7 +891,7 @@ TEST_F(DBWALTest, kPointInTimeRecoveryCFConsistency) {

  // Record the offset at this point
  Env* env = options.env;
-  uint64_t wal_file_id = dbfull()->TEST_LogfileNumber();
+  int wal_file_id = RecoveryTestHelper::kWALFileOffset + 1;
  std::string fname = LogFileName(dbname_, wal_file_id);
  uint64_t offset_to_corrupt;
  ASSERT_OK(env->GetFileSize(fname, &offset_to_corrupt));
@@ -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,
@@ -46,8 +46,6 @@ EntryType GetEntryType(ValueType value_type) {
      return kEntrySingleDelete;
    case kTypeMerge:
      return kEntryMerge;
-    case kTypeRangeDeletion:
-      return kEntryRangeDeletion;
    default:
      return kEntryOther;
  }
@@ -108,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;
@@ -500,7 +500,7 @@ int main(int argc, char** argv) {
 #else
 #include <stdio.h>

-int main(int /*argc*/, char** /*argv*/) {
+int main(int argc, char** argv) {
  fprintf(stderr,
          "SKIPPED as DBImpl::DeleteFile is not supported in ROCKSDB_LITE\n");
  return 0;
@@ -8,7 +8,7 @@
 namespace rocksdb {

 namespace {
-template <class T>
+template<class T>
 inline T SafeDivide(T a, T b) {
  return b == 0 ? 0 : a / b;
 }
@@ -17,8 +17,7 @@ inline T SafeDivide(T a, T b) {
 void EventHelpers::AppendCurrentTime(JSONWriter* jwriter) {
  *jwriter << "time_micros"
           << std::chrono::duration_cast<std::chrono::microseconds>(
-                  std::chrono::system_clock::now().time_since_epoch())
-                  .count();
+                  std::chrono::system_clock::now().time_since_epoch()).count();
 }

 #ifndef ROCKSDB_LITE
@@ -53,11 +52,6 @@ void EventHelpers::NotifyOnBackgroundError(
    listener->OnBackgroundError(reason, bg_error);
  }
  db_mutex->Lock();
-#else
-  (void)listeners;
-  (void)reason;
-  (void)bg_error;
-  (void)db_mutex;
 #endif  // ROCKSDB_LITE
 }

@@ -123,25 +117,20 @@ void EventHelpers::LogAndNotifyTableFileCreationFinished(
  for (auto& listener : listeners) {
    listener->OnTableFileCreated(info);
  }
-#else
-  (void)listeners;
-  (void)db_name;
-  (void)cf_name;
-  (void)file_path;
-  (void)reason;
 #endif  // !ROCKSDB_LITE
 }

 void EventHelpers::LogAndNotifyTableFileDeletion(
-    EventLogger* event_logger, int job_id, uint64_t file_number,
-    const std::string& file_path, const Status& status,
-    const std::string& dbname,
+    EventLogger* event_logger, int job_id,
+    uint64_t file_number, const std::string& file_path,
+    const Status& status, const std::string& dbname,
    const std::vector<std::shared_ptr<EventListener>>& listeners) {
+
  JSONWriter jwriter;
  AppendCurrentTime(&jwriter);

-  jwriter << "job" << job_id << "event"
-          << "table_file_deletion"
+  jwriter << "job" << job_id
+          << "event" << "table_file_deletion"
          << "file_number" << file_number;
  if (!status.ok()) {
    jwriter << "status" << status.ToString();
@@ -160,10 +149,6 @@ void EventHelpers::LogAndNotifyTableFileDeletion(
  for (auto& listener : listeners) {
    listener->OnTableFileDeleted(info);
  }
-#else
-  (void)file_path;
-  (void)dbname;
-  (void)listeners;
 #endif  // !ROCKSDB_LITE
 }

@@ -30,13 +30,12 @@ Status PromoteL0(DB* db, ColumnFamilyHandle* column_family, int target_level) {

 #else  // ROCKSDB_LITE

-Status SuggestCompactRange(DB* /*db*/, ColumnFamilyHandle* /*column_family*/,
-                           const Slice* /*begin*/, const Slice* /*end*/) {
+Status SuggestCompactRange(DB* db, ColumnFamilyHandle* column_family,
+                           const Slice* begin, const Slice* end) {
  return Status::NotSupported("Not supported in RocksDB LITE");
 }

-Status PromoteL0(DB* /*db*/, ColumnFamilyHandle* /*column_family*/,
-                 int /*target_level*/) {
+Status PromoteL0(DB* db, ColumnFamilyHandle* column_family, int target_level) {
  return Status::NotSupported("Not supported in RocksDB LITE");
 }

@@ -94,8 +94,7 @@ Status ExternalSstFileIngestionJob::Prepare(

    const std::string path_outside_db = f.external_file_path;
    const std::string path_inside_db =
-        TableFileName(cfd_->ioptions()->cf_paths, f.fd.GetNumber(),
-                      f.fd.GetPathId());
+        TableFileName(db_options_.db_paths, f.fd.GetNumber(), f.fd.GetPathId());

    if (ingestion_options_.move_files) {
      status = env_->LinkFile(path_outside_db, path_inside_db);
@@ -103,16 +102,12 @@ Status ExternalSstFileIngestionJob::Prepare(
        // Original file is on a different FS, use copy instead of hard linking
        status = CopyFile(env_, path_outside_db, path_inside_db, 0,
                          db_options_.use_fsync);
-        f.copy_file = true;
-      } else {
-        f.copy_file = false;
      }
    } else {
      status = CopyFile(env_, path_outside_db, path_inside_db, 0,
                        db_options_.use_fsync);
-      f.copy_file = true;
    }
-    TEST_SYNC_POINT("ExternalSstFileIngestionJob::Prepare:FileAdded");
+    TEST_SYNC_POINT("DBImpl::AddFile:FileCopied");
    if (!status.ok()) {
      break;
    }
@@ -122,7 +117,7 @@ Status ExternalSstFileIngestionJob::Prepare(
  if (!status.ok()) {
    // We failed, remove all files that we copied into the db
    for (IngestedFileInfo& f : files_to_ingest_) {
-      if (f.internal_file_path.empty()) {
+      if (f.internal_file_path == "") {
        break;
      }
      Status s = env_->DeleteFile(f.internal_file_path);
@@ -137,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");
@@ -157,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

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

@@ -222,17 +213,9 @@ void ExternalSstFileIngestionJob::UpdateStats() {
  uint64_t total_l0_files = 0;
  uint64_t total_time = env_->NowMicros() - job_start_time_;
  for (IngestedFileInfo& f : files_to_ingest_) {
-    InternalStats::CompactionStats stats(CompactionReason::kExternalSstIngestion, 1);
+    InternalStats::CompactionStats stats(1);
    stats.micros = total_time;
-    // If actual copy occured for this file, then we need to count the file
-    // size as the actual bytes written. If the file was linked, then we ignore
-    // the bytes written for file metadata.
-    // TODO (yanqin) maybe account for file metadata bytes for exact accuracy?
-    if (f.copy_file) {
-      stats.bytes_written = f.fd.GetFileSize();
-    } else {
-      stats.bytes_moved = f.fd.GetFileSize();
-    }
+    stats.bytes_written = f.fd.GetFileSize();
    stats.num_output_files = 1;
    cfd_->internal_stats()->AddCompactionStats(f.picked_level, stats);
    cfd_->internal_stats()->AddCFStats(InternalStats::BYTES_INGESTED_ADD_FILE,
@@ -392,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) {
@@ -420,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;
      }
@@ -443,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;
@@ -523,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) {
@@ -560,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
@@ -46,18 +46,11 @@ struct IngestedFileInfo {
  // FileDescriptor for the file inside the DB
  FileDescriptor fd;
  // file path that we picked for file inside the DB
-  std::string internal_file_path;
+  std::string internal_file_path = "";
  // Global sequence number that we picked for the file inside the DB
  SequenceNumber assigned_seqno = 0;
  // Level inside the DB we picked for the external file.
  int picked_level = 0;
-  // Whether to copy or link the external sst file. copy_file will be set to
-  // false if ingestion_options.move_files is true and underlying FS
-  // supports link operation. Need to provide a default value to make the
-  // undefined-behavior sanity check of llvm happy. Since
-  // ingestion_options.move_files is false by default, thus copy_file is true
-  // by default.
-  bool copy_file = true;

  InternalKey smallest_internal_key() const {
    return InternalKey(smallest_user_key, assigned_seqno,
@@ -91,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
@@ -121,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
@@ -140,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_);
  }
@@ -689,7 +687,7 @@ TEST_F(ExternalSSTFileTest, PurgeObsoleteFilesBug) {
  DestroyAndReopen(options);

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "ExternalSstFileIngestionJob::Prepare:FileAdded", [&](void* /* arg */) {
+      "DBImpl::AddFile:FileCopied", [&](void* arg) {
        ASSERT_OK(Put("aaa", "bbb"));
        ASSERT_OK(Flush());
        ASSERT_OK(Put("aaa", "xxx"));
@@ -1128,7 +1126,7 @@ TEST_F(ExternalSSTFileTest, PickedLevelBug) {
  std::atomic<bool> bg_compact_started(false);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:Start",
-      [&](void* /*arg*/) { bg_compact_started.store(true); });
+      [&](void* arg) { bg_compact_started.store(true); });

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

@@ -1409,16 +1407,12 @@ TEST_F(ExternalSSTFileTest, AddFileTrivialMoveBug) {
  ASSERT_OK(GenerateAndAddExternalFile(options, {22, 23}, 6));  // L2

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::Run():Start", [&](void* /*arg*/) {
+      "CompactionJob::Run():Start", [&](void* arg) {
        // fit in L3 but will overlap with compaction so will be added
        // to L2 but a compaction will trivially move it to L3
        // and break LSM consistency
-        static std::atomic<bool> called = {false};
-        if (!called) {
-          called = true;
-          ASSERT_OK(dbfull()->SetOptions({{"max_bytes_for_level_base", "1"}}));
-          ASSERT_OK(GenerateAndAddExternalFile(options, {15, 16}, 7));
-        }
+        ASSERT_OK(dbfull()->SetOptions({{"max_bytes_for_level_base", "1"}}));
+        ASSERT_OK(GenerateAndAddExternalFile(options, {15, 16}, 7));
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

@@ -1801,59 +1795,9 @@ TEST_F(ExternalSSTFileTest, FileWithCFInfo) {
  ASSERT_OK(db_->IngestExternalFile(handles_[2], {unknown_sst}, ifo));
 }

-/*
- * Test and verify the functionality of ingestion_options.move_files.
- */
-TEST_F(ExternalSSTFileTest, LinkExternalSst) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  DestroyAndReopen(options);
-  const int kNumKeys = 10000;
-
-  std::string file_path = sst_files_dir_ + "file1.sst";
-  // Create SstFileWriter for default column family
-  SstFileWriter sst_file_writer(EnvOptions(), options);
-  ASSERT_OK(sst_file_writer.Open(file_path));
-  for (int i = 0; i < kNumKeys; i++) {
-    ASSERT_OK(sst_file_writer.Put(Key(i), Key(i) + "_value"));
-  }
-  ASSERT_OK(sst_file_writer.Finish());
-  uint64_t file_size = 0;
-  ASSERT_OK(env_->GetFileSize(file_path, &file_size));
-
-  IngestExternalFileOptions ifo;
-  ifo.move_files = true;
-  ASSERT_OK(db_->IngestExternalFile({file_path}, ifo));
-
-  ColumnFamilyHandleImpl* cfh =
-      static_cast<ColumnFamilyHandleImpl*>(dbfull()->DefaultColumnFamily());
-  ColumnFamilyData* cfd = cfh->cfd();
-  const InternalStats* internal_stats_ptr = cfd->internal_stats();
-  const std::vector<InternalStats::CompactionStats>& comp_stats =
-      internal_stats_ptr->TEST_GetCompactionStats();
-  uint64_t bytes_copied = 0;
-  uint64_t bytes_moved = 0;
-  for (const auto& stats : comp_stats) {
-    bytes_copied += stats.bytes_written;
-    bytes_moved += stats.bytes_moved;
-  }
-  // If bytes_moved > 0, it means external sst resides on the same FS
-  // supporting hard link operation. Therefore,
-  // 0 bytes should be copied, and the bytes_moved == file_size.
-  // Otherwise, FS does not support hard link, or external sst file resides on
-  // a different file system, then the bytes_copied should be equal to
-  // file_size.
-  if (bytes_moved > 0) {
-    ASSERT_EQ(0, bytes_copied);
-    ASSERT_EQ(file_size, bytes_moved);
-  } else {
-    ASSERT_EQ(file_size, bytes_copied);
-  }
-}
-
 class TestIngestExternalFileListener : public EventListener {
 public:
-  void OnExternalFileIngested(DB* /*db*/,
+  void OnExternalFileIngested(DB* db,
                              const ExternalFileIngestionInfo& info) override {
    ingested_files.push_back(info);
  }
@@ -2056,7 +2000,7 @@ int main(int argc, char** argv) {
 #else
 #include <stdio.h>

-int main(int /*argc*/, char** /*argv*/) {
+int main(int argc, char** argv) {
  fprintf(stderr,
          "SKIPPED as External SST File Writer and Ingestion are not supported "
          "in ROCKSDB_LITE\n");
@@ -34,22 +34,19 @@ static const int kValueSize = 1000;
 static const int kMaxNumValues = 2000;
 static const size_t kNumIterations = 3;

-enum FaultInjectionOptionConfig {
-  kDefault,
-  kDifferentDataDir,
-  kWalDir,
-  kSyncWal,
-  kWalDirSyncWal,
-  kMultiLevels,
-  kEnd,
-};
-class FaultInjectionTest
-    : public testing::Test,
-      public testing::WithParamInterface<std::tuple<
-          bool, FaultInjectionOptionConfig, FaultInjectionOptionConfig>> {
+class FaultInjectionTest : public testing::Test,
+                           public testing::WithParamInterface<bool> {
 protected:
+  enum OptionConfig {
+    kDefault,
+    kDifferentDataDir,
+    kWalDir,
+    kSyncWal,
+    kWalDirSyncWal,
+    kMultiLevels,
+    kEnd,
+  };
  int option_config_;
-  int non_inclusive_end_range_;  // kEnd or equivalent to that
  // When need to make sure data is persistent, sync WAL
  bool sync_use_wal_;
  // When need to make sure data is persistent, call DB::CompactRange()
@@ -75,13 +72,13 @@ class FaultInjectionTest
  DB* db_;

  FaultInjectionTest()
-      : option_config_(std::get<1>(GetParam())),
-        non_inclusive_end_range_(std::get<2>(GetParam())),
+      : option_config_(kDefault),
        sync_use_wal_(false),
        sync_use_compact_(true),
        base_env_(nullptr),
-        env_(nullptr),
-        db_(nullptr) {}
+        env_(NULL),
+        db_(NULL) {
+  }

  ~FaultInjectionTest() {
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
@@ -90,7 +87,7 @@ class FaultInjectionTest

  bool ChangeOptions() {
    option_config_++;
-    if (option_config_ >= non_inclusive_end_range_) {
+    if (option_config_ >= kEnd) {
      return false;
    } else {
      if (option_config_ == kMultiLevels) {
@@ -142,9 +139,9 @@ class FaultInjectionTest
  }

  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());
@@ -169,7 +166,7 @@ class FaultInjectionTest
  }

  void SetUp() override {
-    sequential_order_ = std::get<0>(GetParam());
+    sequential_order_ = GetParam();
    ASSERT_OK(NewDB());
  }

@@ -179,7 +176,7 @@ class FaultInjectionTest
    Status s = DestroyDB(dbname_, options_);

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

    tiny_cache_.reset();

@@ -231,9 +228,16 @@ class FaultInjectionTest
    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;
@@ -241,7 +245,7 @@ class FaultInjectionTest
      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);
  }
@@ -346,9 +350,7 @@ class FaultInjectionTest
  }
 };

-class FaultInjectionTestSplitted : public FaultInjectionTest {};
-
-TEST_P(FaultInjectionTestSplitted, FaultTest) {
+TEST_P(FaultInjectionTest, FaultTest) {
  do {
    Random rnd(301);

@@ -461,10 +463,10 @@ TEST_P(FaultInjectionTest, UninstalledCompaction) {

  std::atomic<bool> opened(false);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::Open:Opened", [&](void* /*arg*/) { opened.store(true); });
+      "DBImpl::Open:Opened", [&](void* arg) { opened.store(true); });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BGWorkCompaction",
-      [&](void* /*arg*/) { ASSERT_TRUE(opened.load()); });
+      [&](void* arg) { ASSERT_TRUE(opened.load()); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  ASSERT_OK(OpenDB());
  ASSERT_OK(Verify(0, kNumKeys, FaultInjectionTest::kValExpectFound));
@@ -535,17 +537,7 @@ TEST_P(FaultInjectionTest, WriteBatchWalTerminationTest) {
  ASSERT_EQ(db_->Get(ro, "boys", &val), Status::NotFound());
 }

-INSTANTIATE_TEST_CASE_P(
-    FaultTest, FaultInjectionTest,
-    ::testing::Values(std::make_tuple(false, kDefault, kEnd),
-                      std::make_tuple(true, kDefault, kEnd)));
-
-INSTANTIATE_TEST_CASE_P(
-    FaultTest, FaultInjectionTestSplitted,
-    ::testing::Values(std::make_tuple(false, kDefault, kSyncWal),
-                      std::make_tuple(true, kDefault, kSyncWal),
-                      std::make_tuple(false, kSyncWal, kEnd),
-                      std::make_tuple(true, kSyncWal, kEnd)));
+INSTANTIATE_TEST_CASE_P(FaultTest, FaultInjectionTest, ::testing::Bool());

 }  // namespace rocksdb

@@ -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 {
--- a/Show More
+++ b/Show More