Fix GitHub issue #3716 : gcc-8 warnings

Summary: Fix the following gcc-8 warnings: - conflicting C language linkage declaration [-Werror] - writing to an object with no trivial copy-assignment [-Werror=class-memaccess] - array subscript -1 is below array bounds [-Werror=array-bounds] Solves https://github.com/facebook/rocksdb/issues/3716 Closes https://github.com/facebook/rocksdb/pull/3736 Differential Revision: D7684161 Pulled By: yiwu-arbug fbshipit-source-id: 47c0423d26b74add251f1d3595211eee1e41e54a
Making platform 007 (gcc 7) default in build_detect_platform.sh (#5947 )
2026-11-06 11:02:36 -05:00 · 2019-10-30 13:04:22 -07:00 · 2019-10-30 12:56:31 -07:00 · 2019-10-30 12:56:17 -07:00 · 2018-07-20 16:02:11 -07:00 · 2018-07-20 15:55:48 -07:00
302 changed files with 6737 additions and 12192 deletions
@@ -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
@@ -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,7 +569,6 @@ 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
@@ -683,12 +657,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 +675,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 +693,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 +832,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,31 +1,24 @@
 # 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.
+## 5.13.4 (6/12/2018)
+### Bug Fixes
+* Fix regression bug of Prev() with ReadOptions.iterate_upper_bound.

-### 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.
+## 5.13.3 (6/6/2018)
+### Bug Fixes
+* Fix assertion when reading bloom filter of SST files containing range deletions but no data
+
+## 5.13.2 (5/25/2018)
+### Public API Change
+* Introduced `CompressionOptions::kDefaultCompressionLevel`, which is a generic way to tell RocksDB to use the compression library's default level. It is now the default value for `CompressionOptions::level`. Previously the level defaulted to -1, which gave poor compression ratios in ZSTD.

 ### 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.
+* Fix segfault caused by object premature destruction (PR #3898)
+* Fix an issue with unnecessary capture in lambda expressions (PR #3904)

-### 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.1 (4/30/2018)
+### New Features
+* Add `Env::LowerThreadPoolCPUPriority(Priority)` method, which lowers the CPU priority of background (esp. compaction) threads to minimize interference with foreground tasks.
+* Eliminate use of temporary directories in BackupEngine to improve reliability on distributed file systems.

 ## 5.13.0 (3/20/2018)
 ### Public API Change
@@ -37,11 +30,15 @@
 * 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.
+* Fsync after writing global seq number to the ingestion file in ExternalSstFileIngestionJob.
+* Fix memory leak when pin_l0_filter_and_index_blocks_in_cache is used with partitioned filters
+
+### Java API Changes
+* Add `BlockBasedTableConfig.setBlockCache` to allow sharing a block cache across DB instances.

 ## 5.12.0 (2/14/2018)
 ### Public API Change
@@ -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
@@ -281,7 +276,7 @@ endif
 default: all

 WARNING_FLAGS = -W -Wextra -Wall -Wsign-compare -Wshadow \
-  -Wunused-parameter
+  -Wno-unused-parameter

 ifeq ($(PLATFORM), OS_OPENBSD)
 	WARNING_FLAGS += -Wno-unused-lambda-capture
@@ -479,7 +474,6 @@ TESTS = \
 	write_batch_with_index_test \
 	write_controller_test\
 	deletefile_test \
-	obsolete_files_test \
 	table_test \
 	geodb_test \
 	delete_scheduler_test \
@@ -648,7 +642,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

@@ -801,7 +795,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:
@@ -1386,9 +1380,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)

@@ -1724,9 +1715,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
@@ -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 = [
@@ -103,7 +99,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,7 +215,6 @@ 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",
@@ -830,11 +824,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",
@@ -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 = [
@@ -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.
@@ -53,11 +53,13 @@ if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then
    FBCODE_BUILD="true"
    # If we're compiling with TSAN we need pic build
    PIC_BUILD=$COMPILE_WITH_TSAN
-    if [ -z "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then
-      source "$PWD/build_tools/fbcode_config.sh"
-    else
+    if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then
      # we need this to build with MySQL. Don't use for other purposes.
      source "$PWD/build_tools/fbcode_config4.8.1.sh"
+    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_5xx" ]; then
+      source "$PWD/build_tools/fbcode_config.sh"
+    else
+      source "$PWD/build_tools/fbcode_config_platform007.sh"
    fi
 fi

@@ -66,23 +68,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,7 +89,7 @@ if test -z "$CLANG_SCAN_BUILD"; then
 fi

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

 if test -z "$FIND"; then
@@ -144,8 +134,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
@@ -198,8 +186,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 +500,9 @@ 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
+  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"
@@ -0,0 +1,18 @@
+GCC_BASE=/mnt/gvfs/third-party2/gcc/6e8e715624fd15256a7970073387793dfcf79b46/7.x/centos7-native/b2ef2b6
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/ef37e1faa1c29782abfac1ae65a291b9b7966f6d/stable/centos7-native/c9f9104
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/c67031f0f739ac61575a061518d6ef5038f99f90/7.x/platform007/5620abc
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/60d6f124a78798b73944f5ba87c2306ae3460153/2.26/platform007/f259413
+SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/7f9bdaada18f59bc27ec2b0871eb8a6144343aef/1.1.3/platform007/ca4da3d
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/22c2d65676fb7c23cfa797c4f6937f38b026f3cf/1.2.8/platform007/ca4da3d
+BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/dc49a21c5fceec6456a7a28a94dcd16690af1337/1.0.6/platform007/ca4da3d
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/907b498203d297947f3bb70b9466f47e100f1873/r131/platform007/ca4da3d
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/3ee276cbacfad3074e3f07bf826ac47f06970f4e/1.3.5/platform007/15a3614
+GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/0b9929d2588991c65a57168bf88aff2db87c5d48/2.2.0/platform007/ca4da3d
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/9c910d36d6235cc40e8ff559358f1833452300ca/master/platform007/5b0f53e
+NUMA_BASE=/mnt/gvfs/third-party2/numa/9cbf2460284c669ed19c3ccb200a71f7dd7e53c7/2.0.11/platform007/ca4da3d
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/bf3d7497fe4e6d007354f0adffa16ce3003f8338/1.3/platform007/6f3e0a9
+TBB_BASE=/mnt/gvfs/third-party2/tbb/ff4e0b093534704d8abab678a4fd7f5ea7b094c7/2018_U5/platform007/ca4da3d
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/b5c4a61a5c483ba24722005ae07895971a2ac707/fb/platform007/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/92ff90349e2f43ea0a8246d8b1cf17b6869013e3/2.29.1/centos7-native/da39a3e
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/f3f697a28122e6bcd513273dd9c1ff23852fc59f/3.13.0/platform007/ca4da3d
+LUA_BASE=/mnt/gvfs/third-party2/lua/f0cd714433206d5139df61659eb7b28b1dea6683/5.3.4/platform007/5007832
@@ -0,0 +1,157 @@
+#!/bin/sh
+#
+# Set environment variables so that we can compile rocksdb using
+# fbcode settings.  It uses the latest g++ and clang compilers and also
+# uses jemalloc
+# Environment variables that change the behavior of this script:
+# PIC_BUILD -- if true, it will only take pic versions of libraries from fbcode. libraries that don't have pic variant will not be included
+
+
+BASEDIR=`dirname $BASH_SOURCE`
+source "$BASEDIR/dependencies_platform007.sh"
+
+CFLAGS=""
+
+# libgcc
+LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/7.3.0"
+LIBGCC_LIBS=" -L $LIBGCC_BASE/lib"
+
+# glibc
+GLIBC_INCLUDE="$GLIBC_BASE/include"
+GLIBC_LIBS=" -L $GLIBC_BASE/lib"
+
+# snappy
+SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/"
+if test -z $PIC_BUILD; then
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy.a"
+else
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy_pic.a"
+fi
+CFLAGS+=" -DSNAPPY"
+
+if test -z $PIC_BUILD; then
+  # location of zlib headers and libraries
+  ZLIB_INCLUDE=" -I $ZLIB_BASE/include/"
+  ZLIB_LIBS=" $ZLIB_BASE/lib/libz.a"
+  CFLAGS+=" -DZLIB"
+
+  # location of bzip headers and libraries
+  BZIP_INCLUDE=" -I $BZIP2_BASE/include/"
+  BZIP_LIBS=" $BZIP2_BASE/lib/libbz2.a"
+  CFLAGS+=" -DBZIP2"
+
+  LZ4_INCLUDE=" -I $LZ4_BASE/include/"
+  LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
+  CFLAGS+=" -DLZ4"
+fi
+
+ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
+if test -z $PIC_BUILD; then
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
+else
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd_pic.a"
+fi
+CFLAGS+=" -DZSTD"
+
+# location of gflags headers and libraries
+GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
+if test -z $PIC_BUILD; then
+  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags.a"
+else
+  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags_pic.a"
+fi
+CFLAGS+=" -DGFLAGS=gflags"
+
+# location of jemalloc
+JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/"
+JEMALLOC_LIB=" $JEMALLOC_BASE/lib/libjemalloc.a"
+
+if test -z $PIC_BUILD; then
+  # location of numa
+  NUMA_INCLUDE=" -I $NUMA_BASE/include/"
+  NUMA_LIB=" $NUMA_BASE/lib/libnuma.a"
+  CFLAGS+=" -DNUMA"
+
+  # location of libunwind
+  LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a"
+fi
+
+# location of TBB
+TBB_INCLUDE=" -isystem $TBB_BASE/include/"
+if test -z $PIC_BUILD; then
+  TBB_LIBS="$TBB_BASE/lib/libtbb.a"
+else
+  TBB_LIBS="$TBB_BASE/lib/libtbb_pic.a"
+fi
+CFLAGS+=" -DTBB"
+
+# use Intel SSE support for checksum calculations
+export USE_SSE=1
+export PORTABLE=1
+
+BINUTILS="$BINUTILS_BASE/bin"
+AR="$BINUTILS/ar"
+
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE"
+
+STDLIBS="-L $GCC_BASE/lib64"
+
+CLANG_BIN="$CLANG_BASE/bin"
+CLANG_LIB="$CLANG_BASE/lib"
+CLANG_SRC="$CLANG_BASE/../../src"
+
+CLANG_ANALYZER="$CLANG_BIN/clang++"
+CLANG_SCAN_BUILD="$CLANG_SRC/llvm/tools/clang/tools/scan-build/bin/scan-build"
+
+if [ -z "$USE_CLANG" ]; then
+  # gcc
+  CC="$GCC_BASE/bin/gcc"
+  CXX="$GCC_BASE/bin/g++"
+
+  CFLAGS+=" -B$BINUTILS/gold"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  JEMALLOC=1
+else
+  # clang
+  CLANG_INCLUDE="$CLANG_LIB/clang/stable/include"
+  CC="$CLANG_BIN/clang"
+  CXX="$CLANG_BIN/clang++"
+
+  KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include"
+
+  CFLAGS+=" -B$BINUTILS/gold -nostdinc -nostdlib"
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x/x86_64-facebook-linux "
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  CFLAGS+=" -isystem $CLANG_INCLUDE"
+  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE/linux "
+  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE "
+  CFLAGS+=" -Wno-expansion-to-defined "
+  CXXFLAGS="-nostdinc++"
+fi
+
+CFLAGS+=" $DEPS_INCLUDE"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42"
+CXXFLAGS+=" $CFLAGS"
+
+EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS"
+EXEC_LDFLAGS+=" -B$BINUTILS/gold"
+EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform007/lib/ld.so"
+EXEC_LDFLAGS+=" $LIBUNWIND"
+EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform007/lib"
+# required by libtbb
+EXEC_LDFLAGS+=" -ldl"
+
+PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"
+
+EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS"
+
+VALGRIND_VER="$VALGRIND_BASE/bin/"
+
+# lua not supported because it's on track for deprecation, I think
+LUA_PATH=
+LUA_LIB=
+
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB
@@ -85,8 +85,9 @@ NON_SHM="TMPD=/tmp/rocksdb_test_tmp"
 GCC_481="ROCKSDB_FBCODE_BUILD_WITH_481=1"
 ASAN="COMPILE_WITH_ASAN=1"
 CLANG="USE_CLANG=1"
-LITE="OPT=\"-DROCKSDB_LITE -g\""
-TSAN="COMPILE_WITH_TSAN=1"
+# in gcc-5 there are known problems with TSAN like https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71090.
+# using platform007 gives us gcc-8 or higher which has that bug fixed.
+TSAN="ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007=1 COMPILE_WITH_TSAN=1"
 UBSAN="COMPILE_WITH_UBSAN=1"
 DISABLE_JEMALLOC="DISABLE_JEMALLOC=1"
 HTTP_PROXY="https_proxy=http://fwdproxy.29.prn1:8080 http_proxy=http://fwdproxy.29.prn1:8080 ftp_proxy=http://fwdproxy.29.prn1:8080"
@@ -53,6 +53,45 @@ function get_lib_base()
  log_variable $__res_var
 }

+###########################################################
+#                platform007 dependencies                 #
+###########################################################
+
+OUTPUT="$BASEDIR/dependencies_platform007.sh"
+
+rm -f "$OUTPUT"
+touch "$OUTPUT"
+
+echo "Writing dependencies to $OUTPUT"
+
+# Compilers locations
+GCC_BASE=`readlink -f $TP2_LATEST/gcc/7.x/centos7-native/*/`
+CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/stable/centos7-native/*/`
+
+log_variable GCC_BASE
+log_variable CLANG_BASE
+
+# Libraries locations
+get_lib_base libgcc     7.x     platform007
+get_lib_base glibc      2.26    platform007
+get_lib_base snappy     LATEST  platform007
+get_lib_base zlib       LATEST  platform007
+get_lib_base bzip2      LATEST  platform007
+get_lib_base lz4        LATEST  platform007
+get_lib_base zstd       LATEST  platform007
+get_lib_base gflags     LATEST  platform007
+get_lib_base jemalloc   LATEST  platform007
+get_lib_base numa       LATEST  platform007
+get_lib_base libunwind  LATEST  platform007
+get_lib_base tbb        LATEST  platform007
+
+get_lib_base kernel-headers fb platform007
+get_lib_base binutils   LATEST centos7-native
+get_lib_base valgrind   LATEST platform007
+get_lib_base lua        5.3.4  platform007
+
+git diff $OUTPUT
+
 ###########################################################
 #                   5.x dependencies                      #
 ###########################################################
@@ -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);
 }

@@ -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();
    }
  }
@@ -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)
@@ -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(
@@ -38,7 +38,6 @@
 #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 +101,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 +132,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 +140,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;
 };
@@ -934,54 +926,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,
@@ -2576,9 +2520,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 +2529,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;
 }

 /*
@@ -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;
@@ -34,7 +34,6 @@
 #include "table/merging_iterator.h"
 #include "util/autovector.h"
 #include "util/compression.h"
-#include "util/sst_file_manager_impl.h"

 namespace rocksdb {

@@ -55,9 +54,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 +81,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 +156,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 +274,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
@@ -425,10 +383,10 @@ ColumnFamilyData::ColumnFamilyData(
      next_(nullptr),
      prev_(nullptr),
      log_number_(0),
-      flush_reason_(FlushReason::kOthers),
+      flush_reason_(FlushReason::kUnknown),
      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 +462,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.
@@ -558,9 +516,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) {
@@ -997,13 +953,11 @@ 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_);
  }
@@ -1153,9 +1107,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 +1135,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,
@@ -139,9 +139,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`
@@ -296,9 +293,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,10 +342,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_; }
+  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_; }

  enum class WriteStallCause {
    kNone,
@@ -373,16 +370,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,
@@ -453,11 +442,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 +455,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(
@@ -498,12 +490,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_;
@@ -1368,7 +1354,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 +1447,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 +1548,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 +1641,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 +1739,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 +1831,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 +1918,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 +2365,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 +2378,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.
@@ -2824,6 +2810,27 @@ TEST_F(ColumnFamilyTest, CreateAndDestoryOptions) {
  ASSERT_OK(db_->DestroyColumnFamilyHandle(cfh));
 }

+TEST_F(ColumnFamilyTest, CreateDropAndDestroy) {
+  ColumnFamilyHandle* cfh;
+  Open();
+  ASSERT_OK(db_->CreateColumnFamily(ColumnFamilyOptions(), "yoyo", &cfh));
+  ASSERT_OK(db_->Put(WriteOptions(), cfh, "foo", "bar"));
+  ASSERT_OK(db_->Flush(FlushOptions(), cfh));
+  ASSERT_OK(db_->DropColumnFamily(cfh));
+  ASSERT_OK(db_->DestroyColumnFamilyHandle(cfh));
+}
+
+TEST_F(ColumnFamilyTest, CreateDropAndDestroyWithoutFileDeletion) {
+  ColumnFamilyHandle* cfh;
+  Open();
+  ASSERT_OK(db_->CreateColumnFamily(ColumnFamilyOptions(), "yoyo", &cfh));
+  ASSERT_OK(db_->Put(WriteOptions(), cfh, "foo", "bar"));
+  ASSERT_OK(db_->Flush(FlushOptions(), cfh));
+  ASSERT_OK(db_->DisableFileDeletions());
+  ASSERT_OK(db_->DropColumnFamily(cfh));
+  ASSERT_OK(db_->DestroyColumnFamilyHandle(cfh));
+}
+
 #ifndef ROCKSDB_LITE
 TEST_F(ColumnFamilyTest, FlushCloseWALFiles) {
  SpecialEnv env(Env::Default());
@@ -3150,58 +3157,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) {
@@ -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,7 +442,7 @@ 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) {
@@ -473,8 +468,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_;
@@ -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,18 +723,15 @@ 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 = static_cast<size_t>(
+      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))
+          static_cast<size_t>(generator.Uniform(kOutFileNumSamples))
            << kSampleLenShift);
      }
    }
@@ -821,12 +773,13 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      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 +893,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 +946,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 +1111,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 +1131,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 +1143,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 +1165,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 +1180,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 +1236,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 +1266,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 +1369,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 +1389,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 +1418,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 +1440,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 +1452,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 +1489,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"
@@ -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);
@@ -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());
@@ -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) {
@@ -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;
 }
@@ -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,9 @@ 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.
@@ -282,7 +280,6 @@ class NullCompactionPicker : public CompactionPicker {
                           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*/,
@@ -59,7 +59,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());
  }

@@ -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;
@@ -609,13 +609,11 @@ Compaction* UniversalCompactionPicker::PickCompactionToReduceSortedRuns(
  }
  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
@@ -305,41 +305,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;
@@ -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;
@@ -1768,10 +1692,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 +1983,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 +2573,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,10 +2744,10 @@ 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();
@@ -3286,13 +3091,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,66 +3104,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) {
@@ -3638,28 +3376,6 @@ TEST_F(DBCompactionTest, CompactRangeFlushOverlappingMemtable) {
  }
 }

-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,
                        ::testing::Values(std::make_tuple(1, true),
                                          std::make_tuple(1, false),
@@ -3679,7 +3395,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 +3405,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 +3414,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;
@@ -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);
@@ -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,
@@ -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;
      });
@@ -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_)),
@@ -300,8 +300,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();

@@ -355,11 +353,10 @@ Status DBImpl::CloseHelper() {
    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());
+      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;
@@ -515,16 +512,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 +522,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();
@@ -576,9 +561,9 @@ Status DBImpl::SetOptions(
  }
  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 +587,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 +613,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);
@@ -710,7 +693,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 +707,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 +774,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 +853,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());
@@ -1034,8 +1016,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 +1095,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 +1119,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 +1148,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 +1169,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 +1182,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 +1214,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 +1301,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 +1332,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 +1420,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()) {
@@ -1508,7 +1471,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 +1494,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 +1513,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 +1524,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 +1658,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 +1676,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 +1766,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 +2145,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
@@ -2231,9 +2198,9 @@ Status DBImpl::DeleteFilesInRanges(ColumnFamilyHandle* column_family,
          end_key = &end_storage;
        }

-        vstorage->GetCleanInputsWithinInterval(
-            i, begin_key, end_key, &level_files, -1 /* hint_index */,
-            nullptr /* file_index */);
+        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];
@@ -2244,8 +2211,7 @@ Status DBImpl::DeleteFilesInRanges(ColumnFamilyHandle* column_family,
            continue;
          }
          if (!include_end && end != nullptr &&
-              cfd->user_comparator()->Compare(level_file->largest.user_key(),
-                                              *end) == 0) {
+              cfd->user_comparator()->Compare(level_file->largest.user_key(), *end) == 0) {
            continue;
          }
          edit.SetColumnFamily(cfd->GetID());
@@ -2263,9 +2229,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 +2255,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);
@@ -2416,10 +2383,10 @@ 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) {
+Status DestroyDB(const std::string& dbname, const Options& options) {
  ImmutableDBOptions soptions(SanitizeOptions(dbname, options));
  Env* env = soptions.env;
  std::vector<std::string> filenames;
@@ -2437,15 +2404,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 +2422,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 +2536,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 +2604,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 +2632,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 +2783,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");
    }
  }

@@ -2912,8 +2859,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 +2916,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 +2938,7 @@ Status DBImpl::VerifyChecksum() {
      }
    }
    for (auto cfd : cfd_list) {
-      cfd->Unref();
+        cfd->Unref();
    }
  }
  return s;
@@ -3028,4 +2974,5 @@ void DBImpl::WaitForIngestFile() {
 }

 #endif  // ROCKSDB_LITE
+
 }  // namespace rocksdb
@@ -27,7 +27,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"
@@ -224,8 +223,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
@@ -343,7 +340,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 +351,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 +362,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;
@@ -482,7 +476,7 @@ class DBImpl : public DB {
  // 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();
@@ -597,7 +591,7 @@ class DBImpl : public DB {
                                  size_t batch_cnt) {
    recovered_transactions_[name] =
        new RecoveredTransaction(log, name, batch, seq, batch_cnt);
-    logs_with_prep_tracker_.MarkLogAsContainingPrepSection(log);
+    MarkLogAsContainingPrepSection(log);
  }

  void DeleteRecoveredTransaction(const std::string& name) {
@@ -605,7 +599,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 +611,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 +631,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,20 +683,14 @@ 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.
+  // batch_cnt is expected to be non-zero in seq_per_batch mode and indicates
+  // the number of sub-patches. A sub-patch is a subset of the write batch that
+  // does not have duplicate keys.
  Status WriteImpl(const WriteOptions& options, WriteBatch* updates,
                   WriteCallback* callback = nullptr,
                   uint64_t* log_used = nullptr, uint64_t log_ref = 0,
@@ -729,6 +713,8 @@ class DBImpl : public DB {
                          uint64_t* seq_used = nullptr, size_t batch_cnt = 0,
                          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();
@@ -740,7 +726,6 @@ class DBImpl : public DB {
  friend class DB;
  friend class InternalStats;
  friend class PessimisticTransaction;
-  friend class TransactionBaseImpl;
  friend class WriteCommittedTxn;
  friend class WritePreparedTxn;
  friend class WritePreparedTxnDB;
@@ -750,7 +735,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 +782,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,8 +833,7 @@ 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,
@@ -891,7 +873,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);
@@ -920,8 +902,8 @@ class DBImpl : public DB {
  void MaybeScheduleFlushOrCompaction();
  void SchedulePendingFlush(ColumnFamilyData* cfd, FlushReason flush_reason);
  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 +921,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
@@ -966,12 +945,10 @@ class DBImpl : public DB {
  // 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();

  // table_cache_ provides its own synchronization
@@ -1109,7 +1086,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 +1101,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 +1145,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 +1182,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 +1277,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 +1314,38 @@ class DBImpl : public DB {
  // Indicate DB was opened successfully
  bool opened_successfully_;

-  LogsWithPrepTracker logs_with_prep_tracker_;
+  // REQUIRES: logs_with_prep_mutex_ held
+  //
+  // sorted list of log numbers still containing prepared data.
+  // this is used by FindObsoleteFiles to determine which
+  // flushed logs we must keep around because they still
+  // contain prepared data which has not been committed or rolled back
+  struct LogCnt {
+    uint64_t log;  // the log number
+    uint64_t cnt;  // number of prepared sections in the log
+  };
+  std::vector<LogCnt> logs_with_prep_;
+  std::mutex logs_with_prep_mutex_;
+
+  // REQUIRES: prepared_section_completed_mutex_ held
+  //
+  // to be used in conjunction with logs_with_prep_.
+  // once a transaction with data in log L is committed or rolled back
+  // rather than updating logs_with_prep_ directly we keep track of that
+  // in prepared_section_completed_ which maps LOG -> instance_count. This helps
+  // avoiding contention between a commit thread and the prepare threads.
+  //
+  // when trying to determine the minimum log still active we first
+  // consult logs_with_prep_. while that root value maps to
+  // an equal value in prepared_section_completed_ we erase the log from
+  // both logs_with_prep_ and prepared_section_completed_.
+  std::unordered_map<uint64_t, uint64_t> prepared_section_completed_;
+  std::mutex prepared_section_completed_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 +1359,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,9 +1384,6 @@ 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;
@@ -1434,25 +1428,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) {
@@ -24,35 +24,6 @@

 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 +50,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 +95,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,7 +129,7 @@ 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();
  }
@@ -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;
@@ -262,12 +231,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 +259,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;
@@ -313,25 +276,18 @@ 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;
@@ -428,7 +384,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 +418,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 +457,14 @@ 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,
+    std::vector<std::string>* const output_file_names) {
 #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 +488,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_file_names, output_level,
+                         output_path_id, &job_context, &log_buffer);
  }
  if (sv->Unref()) {
    mutex_.Lock();
@@ -582,8 +533,9 @@ 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) {
+    std::vector<std::string>* const output_file_names,
+    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 +553,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 +582,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 +615,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 +655,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);

@@ -750,10 +684,9 @@ 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()));
+      (*output_file_names).push_back(TableFileName(
+              immutable_db_options_.db_paths, newf.second.fd.GetNumber(),
+              newf.second.fd.GetPathId()) );
    }
  }

@@ -763,7 +696,6 @@ Status DBImpl::CompactFilesImpl(
  if (bg_compaction_scheduled_ == 0) {
    bg_cv_.SignalAll();
  }
-  TEST_SYNC_POINT("CompactFilesImpl:End");

  return status;
 }
@@ -798,8 +730,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 +760,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 +773,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 +785,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
 }

@@ -954,9 +881,8 @@ int DBImpl::MaxMemCompactionLevel(ColumnFamilyHandle* /*column_family*/) {
 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,
@@ -965,7 +891,7 @@ Status DBImpl::Flush(const FlushOptions& flush_options,
  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);
+      FlushMemTable(cfh->cfd(), flush_options, FlushReason::kManualCompaction);
  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 +900,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 +985,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);
@@ -1198,7 +1122,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,26 +1198,26 @@ 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());
+  assert(!cfd->pending_flush());
  cfd->Ref();
  flush_queue_.push_back(cfd);
-  cfd->set_queued_for_flush(true);
+  cfd->set_pending_flush(true);
  cfd->SetFlushReason(flush_reason);
 }

@@ -1301,31 +1225,32 @@ 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);
+  assert(cfd->pending_flush());
+  cfd->set_pending_flush(false);
  // TODO: need to unset flush reason?
  return cfd;
 }

 void DBImpl::SchedulePendingFlush(ColumnFamilyData* cfd,
                                  FlushReason flush_reason) {
-  if (!cfd->queued_for_flush() && cfd->imm()->IsFlushPending()) {
+  if (!cfd->pending_flush() && cfd->imm()->IsFlushPending()) {
    AddToFlushQueue(cfd, flush_reason);
    ++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 +1379,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 +1479,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 +1492,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();
@@ -1653,7 +1576,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,

  // InternalKey manual_end_storage;
  // InternalKey* manual_end = &manual_end_storage;
-  bool sfm_reserved_compact_space = false;
+#ifndef ROCKSDB_LITE
+  bool sfm_bookkeeping = false;
+#endif  // ROCKSDB_LITE
  if (is_manual) {
    ManualCompactionState* m = manual_compaction;
    assert(m->in_progress);
@@ -1667,29 +1592,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()) {
@@ -1730,10 +1642,24 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
      c.reset(cfd->PickCompaction(*mutable_cf_options, log_buffer));
      TEST_SYNC_POINT("DBImpl::BackgroundCompaction():AfterPickCompaction");

+      bool enough_room = true;
      if (c != nullptr) {
-        bool enough_room = EnoughRoomForCompaction(
-            *(c->inputs()), &sfm_reserved_compact_space, log_buffer);
-
+#ifndef ROCKSDB_LITE
+        auto sfm = static_cast<SstFileManagerImpl*>(
+            immutable_db_options_.sst_file_manager.get());
+        if (sfm) {
+          enough_room = sfm->EnoughRoomForCompaction(c.get());
+          if (enough_room) {
+            sfm_bookkeeping = true;
+          }
+        }
+#endif  // ROCKSDB_LITE
+        if (!enough_room) {
+          // Just in case tests want to change the value of enough_room
+          TEST_SYNC_POINT_CALLBACK(
+              "DBImpl::BackgroundCompaction():CancelledCompaction",
+              &enough_room);
+        }
        if (!enough_room) {
          // Then don't do the compaction
          c->ReleaseCompactionFiles(status);
@@ -1742,6 +1668,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
              ->storage_info()
              ->ComputeCompactionScore(*(c->immutable_cf_options()),
                                       *(c->mutable_cf_options()));
+
+          ROCKS_LOG_BUFFER(log_buffer,
+                           "Cancelled compaction because not enough room");
          AddToCompactionQueue(cfd);
          ++unscheduled_compactions_;

@@ -1749,6 +1678,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
          // Don't need to sleep here, because BackgroundCallCompaction
          // will sleep if !s.ok()
          status = Status::CompactionTooLarge();
+          RecordTick(stats_, COMPACTION_CANCELLED, 1);
        } else {
          // update statistics
          MeasureTime(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
@@ -1797,7 +1727,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 +1758,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 +1774,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 +1796,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 +1806,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 +1819,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 +1836,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,7 +1853,7 @@ 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;
  }
@@ -1933,13 +1865,14 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    // 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) {
+    if (sfm && sfm_bookkeeping) {
      sfm->OnCompactionCompletion(c.get());
    }
 #endif  // ROCKSDB_LITE

-    NotifyOnCompactionCompleted(c->column_family_data(), c.get(), status,
-                                compaction_job_stats, job_context->job_id);
+    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();
@@ -1997,7 +1930,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 +2030,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 +2044,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 +2058,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, FlushReason::kSuperVersionChange);
  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);
 }

@@ -184,21 +184,17 @@ Status DBImpl::TEST_GetAllImmutableCFOptions(
 }

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

 size_t DBImpl::TEST_PreparedSectionCompletedSize() {
-  return logs_with_prep_tracker_.TEST_PreparedSectionCompletedSize();
+  return prepared_section_completed_.size();
 }

-size_t DBImpl::TEST_LogsWithPrepSize() {
-  return logs_with_prep_tracker_.TEST_LogsWithPrepSize();
-}
+size_t DBImpl::TEST_LogsWithPrepSize() { return logs_with_prep_.size(); }

 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,125 @@
 #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;
+}
+
+void DBImpl::MarkLogAsHavingPrepSectionFlushed(uint64_t log) {
+  assert(log != 0);
+  std::lock_guard<std::mutex> lock(prepared_section_completed_mutex_);
+  auto it = prepared_section_completed_.find(log);
+  if (UNLIKELY(it == prepared_section_completed_.end())) {
+    prepared_section_completed_[log] = 1;
+  } else {
+    it->second += 1;
+  }
+}
+
+void DBImpl::MarkLogAsContainingPrepSection(uint64_t log) {
+  assert(log != 0);
+  std::lock_guard<std::mutex> lock(logs_with_prep_mutex_);
+
+  auto rit = logs_with_prep_.rbegin();
+  bool updated = false;
+  // Most probably the last log is the one that is being marked for
+  // having a prepare section; so search from the end.
+  for (; rit != logs_with_prep_.rend() && rit->log >= log; ++rit) {
+    if (rit->log == log) {
+      rit->cnt++;
+      updated = true;
+      break;
+    }
+  }
+  if (!updated) {
+    // We are either at the start, or at a position with rit->log < log
+    logs_with_prep_.insert(rit.base(), {log, 1});
+  }
+}
+
+uint64_t DBImpl::FindMinLogContainingOutstandingPrep() {
+  std::lock_guard<std::mutex> lock(logs_with_prep_mutex_);
+  auto it = logs_with_prep_.begin();
+  // start with the smallest log
+  for (; it != logs_with_prep_.end();) {
+    auto min_log = it->log;
+    {
+      std::lock_guard<std::mutex> lock2(prepared_section_completed_mutex_);
+      auto completed_it = prepared_section_completed_.find(min_log);
+      if (completed_it == prepared_section_completed_.end() ||
+          completed_it->second < it->cnt) {
+        return min_log;
+      }
+      assert(completed_it != prepared_section_completed_.end() &&
+             completed_it->second == it->cnt);
+      prepared_section_completed_.erase(completed_it);
+    }
+    // erase from beginning in vector is not efficient but this function is not
+    // on the fast path.
+    it = logs_with_prep_.erase(it);
+  }
+  // no such log found
+  return 0;
+}
+
+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 references by memtables because a log referenced by the
+    // first data structure could transition to the second under us.
+    //
+    // TODO(horuff): iterating over all column families under db mutex.
+    // should find more optimal solution
+    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'
@@ -81,65 +187,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 +216,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 +226,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 +302,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,
@@ -283,7 +347,7 @@ void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
 // belong to live files are possibly 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 +370,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 +409,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 +437,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 +472,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 +492,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 +557,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;
      }
@@ -380,14 +385,6 @@ Status DBImpl::Recover(
  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 +529,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 +962,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 +1024,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 +1168,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,
@@ -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
@@ -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);
 }
@@ -122,19 +117,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);
    }

    if (write_thread_.CompleteParallelMemTableWriter(&w)) {
@@ -142,8 +133,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 +184,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;

@@ -355,7 +339,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 +347,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 +368,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 +407,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 +462,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    }

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

    if (need_log_sync) {
@@ -643,15 +623,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 +647,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 +695,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 +719,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 +804,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 +942,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 +952,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 +977,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;
  }

@@ -1124,8 +1062,7 @@ 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);
@@ -1215,7 +1152,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 +1163,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;
    }
@@ -1256,8 +1192,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_) {
@@ -1425,7 +1360,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);
  }
@@ -36,7 +36,9 @@ class TestIterator : public InternalIterator {
        valid_(false),
        sequence_number_(0),
        iter_(0),
-        cmp(comparator) {}
+        cmp(comparator) {
+    data_.reserve(16);
+  }

  void AddPut(std::string argkey, std::string argvalue) {
    Add(argkey, kTypeValue, argvalue);
@@ -2549,8 +2551,8 @@ TEST_F(DBIterWithMergeIterTest, InnerMergeIteratorDataRace1) {
  // 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*/) { internal_iter2_->Add("z", kTypeValue, "7", 12u); });
+      "MergeIterator::Prev:BeforePrev",
+      [&](void* arg) { internal_iter2_->Add("z", kTypeValue, "7", 12u); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  db_iter_->Prev();
@@ -2585,7 +2587,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:BeforePrev", [&](void* arg) {
        internal_iter2_->Add("z", kTypeValue, "7", 12u);
        internal_iter2_->Add("z", kTypeValue, "7", 11u);
      });
@@ -2623,7 +2625,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:BeforePrev", [&](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);
@@ -2043,6 +2043,43 @@ TEST_P(DBIteratorTest, CreationFailure) {
  delete iter;
 }

+TEST_P(DBIteratorTest, UpperBoundWithChangeDirection) {
+  Options options = CurrentOptions();
+  options.max_sequential_skip_in_iterations = 3;
+  DestroyAndReopen(options);
+
+  // write a bunch of kvs to the database.
+  ASSERT_OK(Put("a", "1"));
+  ASSERT_OK(Put("y", "1"));
+  ASSERT_OK(Put("y1", "1"));
+  ASSERT_OK(Put("y2", "1"));
+  ASSERT_OK(Put("y3", "1"));
+  ASSERT_OK(Put("z", "1"));
+  ASSERT_OK(Flush());
+  ASSERT_OK(Put("a", "1"));
+  ASSERT_OK(Put("z", "1"));
+  ASSERT_OK(Put("bar", "1"));
+  ASSERT_OK(Put("foo", "1"));
+
+  std::string upper_bound = "x";
+  Slice ub_slice(upper_bound);
+  ReadOptions ro;
+  ro.iterate_upper_bound = &ub_slice;
+  ro.max_skippable_internal_keys = 1000;
+
+  Iterator* iter = NewIterator(ro);
+  iter->Seek("foo");
+  ASSERT_TRUE(iter->Valid());
+  ASSERT_EQ("foo", iter->key().ToString());
+
+  iter->Prev();
+  ASSERT_TRUE(iter->Valid());
+  ASSERT_OK(iter->status());
+  ASSERT_EQ("bar", iter->key().ToString());
+
+  delete iter;
+}
+
 TEST_P(DBIteratorTest, TableFilter) {
  ASSERT_OK(Put("a", "1"));
  dbfull()->Flush(FlushOptions());
@@ -2109,6 +2146,47 @@ TEST_P(DBIteratorTest, TableFilter) {
  }
 }

+TEST_P(DBIteratorTest, UpperBoundWithPrevReseek) {
+  Options options = CurrentOptions();
+  options.max_sequential_skip_in_iterations = 3;
+  DestroyAndReopen(options);
+
+  // write a bunch of kvs to the database.
+  ASSERT_OK(Put("a", "1"));
+  ASSERT_OK(Put("y", "1"));
+  ASSERT_OK(Put("z", "1"));
+  ASSERT_OK(Flush());
+  ASSERT_OK(Put("a", "1"));
+  ASSERT_OK(Put("z", "1"));
+  ASSERT_OK(Put("bar", "1"));
+  ASSERT_OK(Put("foo", "1"));
+  ASSERT_OK(Put("foo", "2"));
+
+  ASSERT_OK(Put("foo", "3"));
+  ASSERT_OK(Put("foo", "4"));
+  ASSERT_OK(Put("foo", "5"));
+  const Snapshot* snapshot = db_->GetSnapshot();
+  ASSERT_OK(Put("foo", "6"));
+
+  std::string upper_bound = "x";
+  Slice ub_slice(upper_bound);
+  ReadOptions ro;
+  ro.snapshot = snapshot;
+  ro.iterate_upper_bound = &ub_slice;
+
+  Iterator* iter = NewIterator(ro);
+  iter->SeekForPrev("goo");
+  ASSERT_TRUE(iter->Valid());
+  ASSERT_EQ("foo", iter->key().ToString());
+  iter->Prev();
+
+  ASSERT_TRUE(iter->Valid());
+  ASSERT_EQ("bar", iter->key().ToString());
+
+  delete iter;
+  db_->ReleaseSnapshot(snapshot);
+}
+
 TEST_P(DBIteratorTest, SkipStatistics) {
  Options options = CurrentOptions();
  options.statistics = rocksdb::CreateDBStatistics();
@@ -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();
@@ -69,27 +69,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());
 }

@@ -1436,107 +1436,6 @@ TEST_F(DBPropertiesTest, SstFilesSize) {
  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,12 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
  int bg_delete_file = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DeleteScheduler::DeleteTrashFile:DeleteFile",
-      [&](void* /*arg*/) { bg_delete_file++; });
+      [&](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();
@@ -514,7 +483,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;
@@ -588,13 +557,12 @@ TEST_F(DBSSTTest, CancellingCompactionsWorks) {

  int completed_compactions = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction():CancelledCompaction", [&](void* /*arg*/) {
+      "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++; });
+      [&](void* arg) { completed_compactions++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Random rnd(301);
@@ -616,8 +584,6 @@ TEST_F(DBSSTTest, CancellingCompactionsWorks) {
  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
@@ -625,78 +591,6 @@ TEST_F(DBSSTTest, CancellingCompactionsWorks) {
  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.
@@ -733,7 +627,7 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowedRandomized) {

  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) {
@@ -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();
@@ -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;
@@ -3348,56 +3348,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 +3441,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) {
@@ -5194,7 +5144,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);
@@ -5417,7 +5367,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,7 +5392,7 @@ 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_), 
@@ -5554,7 +5504,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 +5614,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,
@@ -1112,7 +1112,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);
@@ -1691,7 +1691,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.
@@ -1978,7 +1978,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 +2044,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 +2296,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 +2318,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 +2478,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());
 }

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

@@ -697,7 +697,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 +769,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 +784,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 +1154,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 +1200,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 +1343,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 +1558,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 +1656,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();
@@ -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,45 @@ 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::CompareKeySeq(const Slice& akey,
+                                         const Slice& bkey) const {
+  // Order by:
+  //    increasing user key (according to user-supplied comparator)
+  //    decreasing sequence number
+  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
+  PERF_COUNTER_ADD(user_key_comparison_count, 1);
+  if (r == 0) {
+    // Shift the number to exclude the last byte which contains the value type
+    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8) >> 8;
+    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8) >> 8;
+    if (anum > bnum) {
+      r = -1;
+    } else if (anum < bnum) {
+      r = +1;
+    }
+  }
+  return r;
+}
+
 int InternalKeyComparator::Compare(const ParsedInternalKey& a,
                                   const ParsedInternalKey& b) const {
  // Order by:
@@ -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"
@@ -608,46 +607,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
@@ -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);
@@ -222,17 +217,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,
@@ -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,
@@ -689,7 +689,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 +1128,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 +1409,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,56 +1797,6 @@ 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*/,
@@ -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) {}
+        db_(nullptr) {
+  }

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

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

@@ -346,9 +343,7 @@ class FaultInjectionTest
  }
 };

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

@@ -461,10 +456,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 +530,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

@@ -56,8 +56,8 @@ namespace rocksdb {

 const char* GetFlushReasonString (FlushReason flush_reason) {
  switch (flush_reason) {
-    case FlushReason::kOthers:
-      return "Other Reasons";
+    case FlushReason::kUnknown:
+      return "Unknown";
    case FlushReason::kGetLiveFiles:
      return "Get Live Files";
    case FlushReason::kShutDown:
@@ -72,12 +72,8 @@ const char* GetFlushReasonString (FlushReason flush_reason) {
      return "Write Buffer Full";
    case FlushReason::kTest:
      return "Test";
-    case FlushReason::kDeleteFiles:
-      return "Delete Files";
-    case FlushReason::kAutoCompaction:
-      return "Auto Compaction";
-    case FlushReason::kManualFlush:
-      return "Manual Flush";
+    case FlushReason::kSuperVersionChange:
+      return "SuperVersion Change";
    default:
      return "Invalid";
  }
@@ -185,8 +181,7 @@ void FlushJob::PickMemTable() {
  base_->Ref();  // it is likely that we do not need this reference
 }

-Status FlushJob::Run(LogsWithPrepTracker* prep_tracker,
-                     FileMetaData* file_meta) {
+Status FlushJob::Run(FileMetaData* file_meta) {
  db_mutex_->AssertHeld();
  assert(pick_memtable_called);
  AutoThreadOperationStageUpdater stage_run(
@@ -227,7 +222,7 @@ Status FlushJob::Run(LogsWithPrepTracker* prep_tracker,
    TEST_SYNC_POINT("FlushJob::InstallResults");
    // Replace immutable memtable with the generated Table
    s = cfd_->imm()->InstallMemtableFlushResults(
-        cfd_, mutable_cf_options_, mems_, prep_tracker, versions_, db_mutex_,
+        cfd_, mutable_cf_options_, mems_, versions_, db_mutex_,
        meta_.fd.GetNumber(), &job_context_->memtables_to_free, db_directory_,
        log_buffer_);
  }
@@ -393,7 +388,7 @@ Status FlushJob::WriteLevel0Table() {
  }

  // Note that here we treat flush as level 0 compaction in internal stats
-  InternalStats::CompactionStats stats(CompactionReason::kFlush, 1);
+  InternalStats::CompactionStats stats(1);
  stats.micros = db_options_.env->NowMicros() - start_micros;
  stats.bytes_written = meta_.fd.GetFileSize();
  MeasureTime(stats_, FLUSH_TIME, stats.micros);
@@ -22,7 +22,6 @@
 #include "db/internal_stats.h"
 #include "db/job_context.h"
 #include "db/log_writer.h"
-#include "db/logs_with_prep_tracker.h"
 #include "db/memtable_list.h"
 #include "db/snapshot_impl.h"
 #include "db/version_edit.h"
@@ -43,7 +42,6 @@

 namespace rocksdb {

-class DBImpl;
 class MemTable;
 class SnapshotChecker;
 class TableCache;
@@ -73,8 +71,7 @@ class FlushJob {
  // Require db_mutex held.
  // Once PickMemTable() is called, either Run() or Cancel() has to be called.
  void PickMemTable();
-  Status Run(LogsWithPrepTracker* prep_tracker = nullptr,
-             FileMetaData* file_meta = nullptr);
+  Status Run(FileMetaData* file_meta = nullptr);
  void Cancel();
  TableProperties GetTableProperties() const { return table_properties_; }

@@ -150,7 +150,7 @@ TEST_F(FlushJobTest, NonEmpty) {
  FileMetaData fd;
  mutex_.Lock();
  flush_job.PickMemTable();
-  ASSERT_OK(flush_job.Run(nullptr, &fd));
+  ASSERT_OK(flush_job.Run(&fd));
  mutex_.Unlock();
  db_options_.statistics->histogramData(FLUSH_TIME, &hist);
  ASSERT_GT(hist.average, 0.0);
@@ -18,10 +18,9 @@
 #include <string>
 #include <utility>
 #include <vector>
-
 #include "db/column_family.h"
+
 #include "db/db_impl.h"
-#include "table/block_based_table_factory.h"
 #include "util/string_util.h"

 namespace rocksdb {
@@ -87,7 +86,8 @@ void PrepareLevelStats(std::map<LevelStatType, double>* level_stats,
                       const InternalStats::CompactionStats& stats) {
  uint64_t bytes_read =
      stats.bytes_read_non_output_levels + stats.bytes_read_output_level;
-  int64_t bytes_new = stats.bytes_written - stats.bytes_read_output_level;
+  int64_t bytes_new =
+      stats.bytes_written - stats.bytes_read_output_level;
  double elapsed = (stats.micros + 1) / kMicrosInSec;

  (*level_stats)[LevelStatType::NUM_FILES] = num_files;
@@ -117,50 +117,50 @@ void PrepareLevelStats(std::map<LevelStatType, double>* level_stats,

 void PrintLevelStats(char* buf, size_t len, const std::string& name,
                     const std::map<LevelStatType, double>& stat_value) {
-  snprintf(
-      buf, len,
-      "%4s "      /*  Level */
-      "%6d/%-3d " /*  Files */
-      "%8s "      /*  Size */
-      "%5.1f "    /*  Score */
-      "%8.1f "    /*  Read(GB) */
-      "%7.1f "    /*  Rn(GB) */
-      "%8.1f "    /*  Rnp1(GB) */
-      "%9.1f "    /*  Write(GB) */
-      "%8.1f "    /*  Wnew(GB) */
-      "%9.1f "    /*  Moved(GB) */
-      "%5.1f "    /*  W-Amp */
-      "%8.1f "    /*  Rd(MB/s) */
-      "%8.1f "    /*  Wr(MB/s) */
-      "%9.0f "    /*  Comp(sec) */
-      "%9d "      /*  Comp(cnt) */
-      "%8.3f "    /*  Avg(sec) */
-      "%7s "      /*  KeyIn */
-      "%6s\n",    /*  KeyDrop */
-      name.c_str(), static_cast<int>(stat_value.at(LevelStatType::NUM_FILES)),
-      static_cast<int>(stat_value.at(LevelStatType::COMPACTED_FILES)),
-      BytesToHumanString(
-          static_cast<uint64_t>(stat_value.at(LevelStatType::SIZE_BYTES)))
-          .c_str(),
-      stat_value.at(LevelStatType::SCORE),
-      stat_value.at(LevelStatType::READ_GB),
-      stat_value.at(LevelStatType::RN_GB),
-      stat_value.at(LevelStatType::RNP1_GB),
-      stat_value.at(LevelStatType::WRITE_GB),
-      stat_value.at(LevelStatType::W_NEW_GB),
-      stat_value.at(LevelStatType::MOVED_GB),
-      stat_value.at(LevelStatType::WRITE_AMP),
-      stat_value.at(LevelStatType::READ_MBPS),
-      stat_value.at(LevelStatType::WRITE_MBPS),
-      stat_value.at(LevelStatType::COMP_SEC),
-      static_cast<int>(stat_value.at(LevelStatType::COMP_COUNT)),
-      stat_value.at(LevelStatType::AVG_SEC),
-      NumberToHumanString(
-          static_cast<std::int64_t>(stat_value.at(LevelStatType::KEY_IN)))
-          .c_str(),
-      NumberToHumanString(
-          static_cast<std::int64_t>(stat_value.at(LevelStatType::KEY_DROP)))
-          .c_str());
+  snprintf(buf, len,
+           "%4s "      /*  Level */
+           "%6d/%-3d " /*  Files */
+           "%8s "      /*  Size */
+           "%5.1f "    /*  Score */
+           "%8.1f "    /*  Read(GB) */
+           "%7.1f "    /*  Rn(GB) */
+           "%8.1f "    /*  Rnp1(GB) */
+           "%9.1f "    /*  Write(GB) */
+           "%8.1f "    /*  Wnew(GB) */
+           "%9.1f "    /*  Moved(GB) */
+           "%5.1f "    /*  W-Amp */
+           "%8.1f "    /*  Rd(MB/s) */
+           "%8.1f "    /*  Wr(MB/s) */
+           "%9.0f "    /*  Comp(sec) */
+           "%9d "      /*  Comp(cnt) */
+           "%8.3f "    /*  Avg(sec) */
+           "%7s "      /*  KeyIn */
+           "%6s\n",    /*  KeyDrop */
+           name.c_str(),
+           static_cast<int>(stat_value.at(LevelStatType::NUM_FILES)),
+           static_cast<int>(stat_value.at(LevelStatType::COMPACTED_FILES)),
+           BytesToHumanString(
+               static_cast<uint64_t>(stat_value.at(LevelStatType::SIZE_BYTES)))
+               .c_str(),
+           stat_value.at(LevelStatType::SCORE),
+           stat_value.at(LevelStatType::READ_GB),
+           stat_value.at(LevelStatType::RN_GB),
+           stat_value.at(LevelStatType::RNP1_GB),
+           stat_value.at(LevelStatType::WRITE_GB),
+           stat_value.at(LevelStatType::W_NEW_GB),
+           stat_value.at(LevelStatType::MOVED_GB),
+           stat_value.at(LevelStatType::WRITE_AMP),
+           stat_value.at(LevelStatType::READ_MBPS),
+           stat_value.at(LevelStatType::WRITE_MBPS),
+           stat_value.at(LevelStatType::COMP_SEC),
+           static_cast<int>(stat_value.at(LevelStatType::COMP_COUNT)),
+           stat_value.at(LevelStatType::AVG_SEC),
+           NumberToHumanString(
+               static_cast<std::int64_t>(stat_value.at(LevelStatType::KEY_IN)))
+               .c_str(),
+           NumberToHumanString(static_cast<std::int64_t>(
+                                   stat_value.at(LevelStatType::KEY_DROP)))
+               .c_str());
 }

 void PrintLevelStats(char* buf, size_t len, const std::string& name,
@@ -208,30 +208,30 @@ static const std::string mem_table_flush_pending = "mem-table-flush-pending";
 static const std::string compaction_pending = "compaction-pending";
 static const std::string background_errors = "background-errors";
 static const std::string cur_size_active_mem_table =
-    "cur-size-active-mem-table";
+                          "cur-size-active-mem-table";
 static const std::string cur_size_all_mem_tables = "cur-size-all-mem-tables";
 static const std::string size_all_mem_tables = "size-all-mem-tables";
 static const std::string num_entries_active_mem_table =
-    "num-entries-active-mem-table";
+                          "num-entries-active-mem-table";
 static const std::string num_entries_imm_mem_tables =
-    "num-entries-imm-mem-tables";
+                          "num-entries-imm-mem-tables";
 static const std::string num_deletes_active_mem_table =
-    "num-deletes-active-mem-table";
+                          "num-deletes-active-mem-table";
 static const std::string num_deletes_imm_mem_tables =
-    "num-deletes-imm-mem-tables";
+                          "num-deletes-imm-mem-tables";
 static const std::string estimate_num_keys = "estimate-num-keys";
 static const std::string estimate_table_readers_mem =
-    "estimate-table-readers-mem";
+                          "estimate-table-readers-mem";
 static const std::string is_file_deletions_enabled =
-    "is-file-deletions-enabled";
+                          "is-file-deletions-enabled";
 static const std::string num_snapshots = "num-snapshots";
 static const std::string oldest_snapshot_time = "oldest-snapshot-time";
 static const std::string num_live_versions = "num-live-versions";
 static const std::string current_version_number =
    "current-super-version-number";
 static const std::string estimate_live_data_size = "estimate-live-data-size";
-static const std::string min_log_number_to_keep_str = "min-log-number-to-keep";
-static const std::string base_level_str = "base-level";
+static const std::string min_log_number_to_keep = "min-log-number-to-keep";
+static const std::string base_level = "base-level";
 static const std::string total_sst_files_size = "total-sst-files-size";
 static const std::string live_sst_files_size = "live-sst-files-size";
 static const std::string estimate_pending_comp_bytes =
@@ -246,14 +246,11 @@ static const std::string actual_delayed_write_rate =
    "actual-delayed-write-rate";
 static const std::string is_write_stopped = "is-write-stopped";
 static const std::string estimate_oldest_key_time = "estimate-oldest-key-time";
-static const std::string block_cache_capacity = "block-cache-capacity";
-static const std::string block_cache_usage = "block-cache-usage";
-static const std::string block_cache_pinned_usage = "block-cache-pinned-usage";

 const std::string DB::Properties::kNumFilesAtLevelPrefix =
-    rocksdb_prefix + num_files_at_level_prefix;
+                      rocksdb_prefix + num_files_at_level_prefix;
 const std::string DB::Properties::kCompressionRatioAtLevelPrefix =
-    rocksdb_prefix + compression_ratio_at_level_prefix;
+                      rocksdb_prefix + compression_ratio_at_level_prefix;
 const std::string DB::Properties::kStats = rocksdb_prefix + allstats;
 const std::string DB::Properties::kSSTables = rocksdb_prefix + sstables;
 const std::string DB::Properties::kCFStats = rocksdb_prefix + cfstats;
@@ -264,56 +261,56 @@ const std::string DB::Properties::kCFFileHistogram =
 const std::string DB::Properties::kDBStats = rocksdb_prefix + dbstats;
 const std::string DB::Properties::kLevelStats = rocksdb_prefix + levelstats;
 const std::string DB::Properties::kNumImmutableMemTable =
-    rocksdb_prefix + num_immutable_mem_table;
+                      rocksdb_prefix + num_immutable_mem_table;
 const std::string DB::Properties::kNumImmutableMemTableFlushed =
    rocksdb_prefix + num_immutable_mem_table_flushed;
 const std::string DB::Properties::kMemTableFlushPending =
-    rocksdb_prefix + mem_table_flush_pending;
+                      rocksdb_prefix + mem_table_flush_pending;
 const std::string DB::Properties::kCompactionPending =
-    rocksdb_prefix + compaction_pending;
+                      rocksdb_prefix + compaction_pending;
 const std::string DB::Properties::kNumRunningCompactions =
    rocksdb_prefix + num_running_compactions;
 const std::string DB::Properties::kNumRunningFlushes =
    rocksdb_prefix + num_running_flushes;
 const std::string DB::Properties::kBackgroundErrors =
-    rocksdb_prefix + background_errors;
+                      rocksdb_prefix + background_errors;
 const std::string DB::Properties::kCurSizeActiveMemTable =
-    rocksdb_prefix + cur_size_active_mem_table;
+                      rocksdb_prefix + cur_size_active_mem_table;
 const std::string DB::Properties::kCurSizeAllMemTables =
    rocksdb_prefix + cur_size_all_mem_tables;
 const std::string DB::Properties::kSizeAllMemTables =
    rocksdb_prefix + size_all_mem_tables;
 const std::string DB::Properties::kNumEntriesActiveMemTable =
-    rocksdb_prefix + num_entries_active_mem_table;
+                      rocksdb_prefix + num_entries_active_mem_table;
 const std::string DB::Properties::kNumEntriesImmMemTables =
-    rocksdb_prefix + num_entries_imm_mem_tables;
+                      rocksdb_prefix + num_entries_imm_mem_tables;
 const std::string DB::Properties::kNumDeletesActiveMemTable =
-    rocksdb_prefix + num_deletes_active_mem_table;
+                      rocksdb_prefix + num_deletes_active_mem_table;
 const std::string DB::Properties::kNumDeletesImmMemTables =
-    rocksdb_prefix + num_deletes_imm_mem_tables;
+                      rocksdb_prefix + num_deletes_imm_mem_tables;
 const std::string DB::Properties::kEstimateNumKeys =
-    rocksdb_prefix + estimate_num_keys;
+                      rocksdb_prefix + estimate_num_keys;
 const std::string DB::Properties::kEstimateTableReadersMem =
-    rocksdb_prefix + estimate_table_readers_mem;
+                      rocksdb_prefix + estimate_table_readers_mem;
 const std::string DB::Properties::kIsFileDeletionsEnabled =
-    rocksdb_prefix + is_file_deletions_enabled;
+                      rocksdb_prefix + is_file_deletions_enabled;
 const std::string DB::Properties::kNumSnapshots =
-    rocksdb_prefix + num_snapshots;
+                      rocksdb_prefix + num_snapshots;
 const std::string DB::Properties::kOldestSnapshotTime =
-    rocksdb_prefix + oldest_snapshot_time;
+                      rocksdb_prefix + oldest_snapshot_time;
 const std::string DB::Properties::kNumLiveVersions =
-    rocksdb_prefix + num_live_versions;
+                      rocksdb_prefix + num_live_versions;
 const std::string DB::Properties::kCurrentSuperVersionNumber =
    rocksdb_prefix + current_version_number;
 const std::string DB::Properties::kEstimateLiveDataSize =
-    rocksdb_prefix + estimate_live_data_size;
+                      rocksdb_prefix + estimate_live_data_size;
 const std::string DB::Properties::kMinLogNumberToKeep =
-    rocksdb_prefix + min_log_number_to_keep_str;
+    rocksdb_prefix + min_log_number_to_keep;
 const std::string DB::Properties::kTotalSstFilesSize =
-    rocksdb_prefix + total_sst_files_size;
+                      rocksdb_prefix + total_sst_files_size;
 const std::string DB::Properties::kLiveSstFilesSize =
    rocksdb_prefix + live_sst_files_size;
-const std::string DB::Properties::kBaseLevel = rocksdb_prefix + base_level_str;
+const std::string DB::Properties::kBaseLevel = rocksdb_prefix + base_level;
 const std::string DB::Properties::kEstimatePendingCompactionBytes =
    rocksdb_prefix + estimate_pending_comp_bytes;
 const std::string DB::Properties::kAggregatedTableProperties =
@@ -326,12 +323,6 @@ const std::string DB::Properties::kIsWriteStopped =
    rocksdb_prefix + is_write_stopped;
 const std::string DB::Properties::kEstimateOldestKeyTime =
    rocksdb_prefix + estimate_oldest_key_time;
-const std::string DB::Properties::kBlockCacheCapacity =
-    rocksdb_prefix + block_cache_capacity;
-const std::string DB::Properties::kBlockCacheUsage =
-    rocksdb_prefix + block_cache_usage;
-const std::string DB::Properties::kBlockCachePinnedUsage =
-    rocksdb_prefix + block_cache_pinned_usage;

 const std::unordered_map<std::string, DBPropertyInfo>
    InternalStats::ppt_name_to_info = {
@@ -435,13 +426,6 @@ const std::unordered_map<std::string, DBPropertyInfo>
        {DB::Properties::kEstimateOldestKeyTime,
         {false, nullptr, &InternalStats::HandleEstimateOldestKeyTime,
          nullptr}},
-        {DB::Properties::kBlockCacheCapacity,
-         {false, nullptr, &InternalStats::HandleBlockCacheCapacity, nullptr}},
-        {DB::Properties::kBlockCacheUsage,
-         {false, nullptr, &InternalStats::HandleBlockCacheUsage, nullptr}},
-        {DB::Properties::kBlockCachePinnedUsage,
-         {false, nullptr, &InternalStats::HandleBlockCachePinnedUsage,
-          nullptr}},
 };

 const DBPropertyInfo* GetPropertyInfo(const Slice& property) {
@@ -847,58 +831,6 @@ bool InternalStats::HandleEstimateOldestKeyTime(uint64_t* value, DBImpl* /*db*/,
  return *value > 0 && *value < std::numeric_limits<uint64_t>::max();
 }

-bool InternalStats::HandleBlockCacheStat(Cache** block_cache) {
-  assert(block_cache != nullptr);
-  auto* table_factory = cfd_->ioptions()->table_factory;
-  assert(table_factory != nullptr);
-  if (BlockBasedTableFactory::kName != table_factory->Name()) {
-    return false;
-  }
-  auto* table_options =
-      reinterpret_cast<BlockBasedTableOptions*>(table_factory->GetOptions());
-  if (table_options == nullptr) {
-    return false;
-  }
-  *block_cache = table_options->block_cache.get();
-  if (table_options->no_block_cache || *block_cache == nullptr) {
-    return false;
-  }
-  return true;
-}
-
-bool InternalStats::HandleBlockCacheCapacity(uint64_t* value, DBImpl* /*db*/,
-                                             Version* /*version*/) {
-  Cache* block_cache;
-  bool ok = HandleBlockCacheStat(&block_cache);
-  if (!ok) {
-    return false;
-  }
-  *value = static_cast<uint64_t>(block_cache->GetCapacity());
-  return true;
-}
-
-bool InternalStats::HandleBlockCacheUsage(uint64_t* value, DBImpl* /*db*/,
-                                          Version* /*version*/) {
-  Cache* block_cache;
-  bool ok = HandleBlockCacheStat(&block_cache);
-  if (!ok) {
-    return false;
-  }
-  *value = static_cast<uint64_t>(block_cache->GetUsage());
-  return true;
-}
-
-bool InternalStats::HandleBlockCachePinnedUsage(uint64_t* value, DBImpl* /*db*/,
-                                                Version* /*version*/) {
-  Cache* block_cache;
-  bool ok = HandleBlockCacheStat(&block_cache);
-  if (!ok) {
-    return false;
-  }
-  *value = static_cast<uint64_t>(block_cache->GetPinnedUsage());
-  return true;
-}
-
 void InternalStats::DumpDBStats(std::string* value) {
  char buf[1000];
  // DB-level stats, only available from default column family
@@ -950,7 +882,8 @@ void InternalStats::DumpDBStats(std::string* value) {
  value->append(buf);
  // Stall
  AppendHumanMicros(write_stall_micros, human_micros, kHumanMicrosLen, true);
-  snprintf(buf, sizeof(buf), "Cumulative stall: %s, %.1f percent\n",
+  snprintf(buf, sizeof(buf),
+           "Cumulative stall: %s, %.1f percent\n",
           human_micros,
           // 10000 = divide by 1M to get secs, then multiply by 100 for pct
           write_stall_micros / 10000.0 / std::max(seconds_up, 0.001));
@@ -961,40 +894,43 @@ void InternalStats::DumpDBStats(std::string* value) {
  uint64_t interval_write_self = write_self - db_stats_snapshot_.write_self;
  uint64_t interval_num_keys_written =
      num_keys_written - db_stats_snapshot_.num_keys_written;
-  snprintf(
-      buf, sizeof(buf),
-      "Interval writes: %s writes, %s keys, %s commit groups, "
-      "%.1f writes per commit group, ingest: %.2f MB, %.2f MB/s\n",
-      NumberToHumanString(interval_write_other + interval_write_self).c_str(),
-      NumberToHumanString(interval_num_keys_written).c_str(),
-      NumberToHumanString(interval_write_self).c_str(),
-      static_cast<double>(interval_write_other + interval_write_self) /
-          (interval_write_self + 1),
-      (user_bytes_written - db_stats_snapshot_.ingest_bytes) / kMB,
-      (user_bytes_written - db_stats_snapshot_.ingest_bytes) / kMB /
-          std::max(interval_seconds_up, 0.001)),
-      value->append(buf);
+  snprintf(buf, sizeof(buf),
+           "Interval writes: %s writes, %s keys, %s commit groups, "
+           "%.1f writes per commit group, ingest: %.2f MB, %.2f MB/s\n",
+           NumberToHumanString(
+               interval_write_other + interval_write_self).c_str(),
+           NumberToHumanString(interval_num_keys_written).c_str(),
+           NumberToHumanString(interval_write_self).c_str(),
+           static_cast<double>(interval_write_other + interval_write_self) /
+               (interval_write_self + 1),
+           (user_bytes_written - db_stats_snapshot_.ingest_bytes) / kMB,
+           (user_bytes_written - db_stats_snapshot_.ingest_bytes) / kMB /
+               std::max(interval_seconds_up, 0.001)),
+  value->append(buf);

  uint64_t interval_write_with_wal =
      write_with_wal - db_stats_snapshot_.write_with_wal;
  uint64_t interval_wal_synced = wal_synced - db_stats_snapshot_.wal_synced;
  uint64_t interval_wal_bytes = wal_bytes - db_stats_snapshot_.wal_bytes;

-  snprintf(
-      buf, sizeof(buf),
-      "Interval WAL: %s writes, %s syncs, "
-      "%.2f writes per sync, written: %.2f MB, %.2f MB/s\n",
-      NumberToHumanString(interval_write_with_wal).c_str(),
-      NumberToHumanString(interval_wal_synced).c_str(),
-      interval_write_with_wal / static_cast<double>(interval_wal_synced + 1),
-      interval_wal_bytes / kGB,
-      interval_wal_bytes / kMB / std::max(interval_seconds_up, 0.001));
+  snprintf(buf, sizeof(buf),
+           "Interval WAL: %s writes, %s syncs, "
+           "%.2f writes per sync, written: %.2f MB, %.2f MB/s\n",
+           NumberToHumanString(interval_write_with_wal).c_str(),
+           NumberToHumanString(interval_wal_synced).c_str(),
+           interval_write_with_wal /
+              static_cast<double>(interval_wal_synced + 1),
+           interval_wal_bytes / kGB,
+           interval_wal_bytes / kMB / std::max(interval_seconds_up, 0.001));
  value->append(buf);

  // Stall
-  AppendHumanMicros(write_stall_micros - db_stats_snapshot_.write_stall_micros,
-                    human_micros, kHumanMicrosLen, true);
-  snprintf(buf, sizeof(buf), "Interval stall: %s, %.1f percent\n", human_micros,
+  AppendHumanMicros(
+      write_stall_micros - db_stats_snapshot_.write_stall_micros,
+      human_micros, kHumanMicrosLen, true);
+  snprintf(buf, sizeof(buf),
+           "Interval stall: %s, %.1f percent\n",
+           human_micros,
           // 10000 = divide by 1M to get secs, then multiply by 100 for pct
           (write_stall_micros - db_stats_snapshot_.write_stall_micros) /
               10000.0 / std::max(interval_seconds_up, 0.001));
@@ -1020,8 +956,8 @@ void InternalStats::DumpDBStats(std::string* value) {
 * and values represent uint64 encoded as strings.
 */
 void InternalStats::DumpCFMapStats(
-    std::map<std::string, std::string>* cf_stats) {
-  CompactionStats compaction_stats_sum;
+        std::map<std::string, std::string>* cf_stats) {
+  CompactionStats compaction_stats_sum(0);
  std::map<int, std::map<LevelStatType, double>> levels_stats;
  DumpCFMapStats(&levels_stats, &compaction_stats_sum);
  for (auto const& level_ent : levels_stats) {
@@ -1152,7 +1088,7 @@ void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {

  // Print stats for each level
  std::map<int, std::map<LevelStatType, double>> levels_stats;
-  CompactionStats compaction_stats_sum;
+  CompactionStats compaction_stats_sum(0);
  DumpCFMapStats(&levels_stats, &compaction_stats_sum);
  for (int l = 0; l < number_levels_; ++l) {
    if (levels_stats.find(l) != levels_stats.end()) {
@@ -1207,9 +1143,8 @@ void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {

  uint64_t interval_ingest_files_addfile =
      ingest_files_addfile - cf_stats_snapshot_.ingest_files_addfile;
-  snprintf(buf, sizeof(buf),
-           "AddFile(Total Files): cumulative %" PRIu64 ", interval %" PRIu64
-           "\n",
+  snprintf(buf, sizeof(buf), "AddFile(Total Files): cumulative %" PRIu64
+                             ", interval %" PRIu64 "\n",
           ingest_files_addfile, interval_ingest_files_addfile);
  value->append(buf);

@@ -1327,9 +1262,7 @@ void InternalStats::DumpCFFileHistogram(std::string* value) {

 #else

-const DBPropertyInfo* GetPropertyInfo(const Slice& /*property*/) {
-  return nullptr;
-}
+const DBPropertyInfo* GetPropertyInfo(const Slice& property) { return nullptr; }

 #endif  // !ROCKSDB_LITE

@@ -19,8 +19,8 @@ class ColumnFamilyData;

 namespace rocksdb {

-class DBImpl;
 class MemTableList;
+class DBImpl;

 // Config for retrieving a property's value.
 struct DBPropertyInfo {
@@ -163,10 +163,7 @@ class InternalStats {
    // Number of compactions done
    int count;

-    // Number of compactions done per CompactionReason
-    int counts[static_cast<int>(CompactionReason::kNumOfReasons)];
-
-    explicit CompactionStats()
+    explicit CompactionStats(int _count = 0)
        : micros(0),
          bytes_read_non_output_levels(0),
          bytes_read_output_level(0),
@@ -177,36 +174,7 @@ class InternalStats {
          num_output_files(0),
          num_input_records(0),
          num_dropped_records(0),
-          count(0) {
-      int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-      for (int i = 0; i < num_of_reasons; i++) {
-        counts[i] = 0;
-      }
-    }
-
-    explicit CompactionStats(CompactionReason reason, int c)
-        : micros(0),
-          bytes_read_non_output_levels(0),
-          bytes_read_output_level(0),
-          bytes_written(0),
-          bytes_moved(0),
-          num_input_files_in_non_output_levels(0),
-          num_input_files_in_output_level(0),
-          num_output_files(0),
-          num_input_records(0),
-          num_dropped_records(0),
-          count(c) {
-      int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-      for (int i = 0; i < num_of_reasons; i++) {
-        counts[i] = 0;
-      }
-      int r = static_cast<int>(reason);
-      if (r >= 0 && r < num_of_reasons) {
-        counts[r] = c;
-      } else {
-        count = 0;
-      }
-    }
+          count(_count) {}

    explicit CompactionStats(const CompactionStats& c)
        : micros(c.micros),
@@ -221,12 +189,7 @@ class InternalStats {
          num_output_files(c.num_output_files),
          num_input_records(c.num_input_records),
          num_dropped_records(c.num_dropped_records),
-          count(c.count) {
-      int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-      for (int i = 0; i < num_of_reasons; i++) {
-        counts[i] = c.counts[i];
-      }
-    }
+          count(c.count) {}

    void Clear() {
      this->micros = 0;
@@ -240,10 +203,6 @@ class InternalStats {
      this->num_input_records = 0;
      this->num_dropped_records = 0;
      this->count = 0;
-      int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-      for (int i = 0; i < num_of_reasons; i++) {
-        counts[i] = 0;
-      }
    }

    void Add(const CompactionStats& c) {
@@ -260,10 +219,6 @@ class InternalStats {
      this->num_input_records += c.num_input_records;
      this->num_dropped_records += c.num_dropped_records;
      this->count += c.count;
-      int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-      for (int i = 0; i< num_of_reasons; i++) {
-        counts[i] += c.counts[i];
-      }
    }

    void Subtract(const CompactionStats& c) {
@@ -280,10 +235,6 @@ class InternalStats {
      this->num_input_records -= c.num_input_records;
      this->num_dropped_records -= c.num_dropped_records;
      this->count -= c.count;
-      int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-      for (int i = 0; i < num_of_reasons; i++) {
-        counts[i] -= c.counts[i];
-      }
    }
  };

@@ -356,10 +307,6 @@ class InternalStats {
  bool GetIntPropertyOutOfMutex(const DBPropertyInfo& property_info,
                                Version* version, uint64_t* value);

-  const std::vector<CompactionStats>& TEST_GetCompactionStats() const {
-    return comp_stats_;
-  }
-
  // Store a mapping from the user-facing DB::Properties string to our
  // DBPropertyInfo struct used internally for retrieving properties.
  static const std::unordered_map<std::string, DBPropertyInfo> ppt_name_to_info;
@@ -375,8 +322,6 @@ class InternalStats {
  void DumpCFStatsNoFileHistogram(std::string* value);
  void DumpCFFileHistogram(std::string* value);

-  bool HandleBlockCacheStat(Cache** block_cache);
-
  // Per-DB stats
  std::atomic<uint64_t> db_stats_[INTERNAL_DB_STATS_ENUM_MAX];
  // Per-ColumnFamily stats
@@ -405,7 +350,8 @@ class InternalStats {
    uint64_t ingest_keys_addfile;      // Total number of keys ingested

    CFStatsSnapshot()
-        : ingest_bytes_flush(0),
+        : comp_stats(0),
+          ingest_bytes_flush(0),
          stall_count(0),
          compact_bytes_write(0),
          compact_bytes_read(0),
@@ -534,10 +480,6 @@ class InternalStats {
  bool HandleIsWriteStopped(uint64_t* value, DBImpl* db, Version* version);
  bool HandleEstimateOldestKeyTime(uint64_t* value, DBImpl* db,
                                   Version* version);
-  bool HandleBlockCacheCapacity(uint64_t* value, DBImpl* db, Version* version);
-  bool HandleBlockCacheUsage(uint64_t* value, DBImpl* db, Version* version);
-  bool HandleBlockCachePinnedUsage(uint64_t* value, DBImpl* db,
-                                   Version* version);

  // Total number of background errors encountered. Every time a flush task
  // or compaction task fails, this counter is incremented. The failure can
@@ -586,7 +528,7 @@ class InternalStats {
    INTERNAL_DB_STATS_ENUM_MAX,
  };

-  InternalStats(int /*num_levels*/, Env* /*env*/, ColumnFamilyData* /*cfd*/) {}
+  InternalStats(int num_levels, Env* env, ColumnFamilyData* cfd) {}

  struct CompactionStats {
    uint64_t micros;
@@ -601,50 +543,48 @@ class InternalStats {
    uint64_t num_dropped_records;
    int count;

-    explicit CompactionStats() {}
+    explicit CompactionStats(int _count = 0) {}

-    explicit CompactionStats(CompactionReason /*reason*/, int /*c*/) {}
+    explicit CompactionStats(const CompactionStats& c) {}

-    explicit CompactionStats(const CompactionStats& /*c*/) {}
+    void Add(const CompactionStats& c) {}

-    void Add(const CompactionStats& /*c*/) {}
-
-    void Subtract(const CompactionStats& /*c*/) {}
+    void Subtract(const CompactionStats& c) {}
  };

-  void AddCompactionStats(int /*level*/, const CompactionStats& /*stats*/) {}
+  void AddCompactionStats(int level, const CompactionStats& stats) {}

-  void IncBytesMoved(int /*level*/, uint64_t /*amount*/) {}
+  void IncBytesMoved(int level, uint64_t amount) {}

-  void AddCFStats(InternalCFStatsType /*type*/, uint64_t /*value*/) {}
+  void AddCFStats(InternalCFStatsType type, uint64_t value) {}

-  void AddDBStats(InternalDBStatsType /*type*/, uint64_t /*value*/,
-                  bool /*concurrent */ = false) {}
+  void AddDBStats(InternalDBStatsType type, uint64_t value,
+                  bool concurrent = false) {}

-  HistogramImpl* GetFileReadHist(int /*level*/) { return nullptr; }
+  HistogramImpl* GetFileReadHist(int level) { return nullptr; }

  uint64_t GetBackgroundErrorCount() const { return 0; }

  uint64_t BumpAndGetBackgroundErrorCount() { return 0; }

-  bool GetStringProperty(const DBPropertyInfo& /*property_info*/,
-                         const Slice& /*property*/, std::string* /*value*/) {
+  bool GetStringProperty(const DBPropertyInfo& property_info,
+                         const Slice& property, std::string* value) {
    return false;
  }

-  bool GetMapProperty(const DBPropertyInfo& /*property_info*/,
-                      const Slice& /*property*/,
-                      std::map<std::string, std::string>* /*value*/) {
+  bool GetMapProperty(const DBPropertyInfo& property_info,
+                      const Slice& property,
+                      std::map<std::string, std::string>* value) {
    return false;
  }

-  bool GetIntProperty(const DBPropertyInfo& /*property_info*/, uint64_t* /*value*/,
-                      DBImpl* /*db*/) const {
+  bool GetIntProperty(const DBPropertyInfo& property_info, uint64_t* value,
+                      DBImpl* db) const {
    return false;
  }

-  bool GetIntPropertyOutOfMutex(const DBPropertyInfo& /*property_info*/,
-                                Version* /*version*/, uint64_t* /*value*/) const {
+  bool GetIntPropertyOutOfMutex(const DBPropertyInfo& property_info,
+                                Version* version, uint64_t* value) const {
    return false;
  }
 };
@@ -27,9 +27,7 @@ struct SuperVersionContext {
  };

  autovector<SuperVersion*> superversions_to_free;
-#ifndef ROCKSDB_DISABLE_STALL_NOTIFICATION
  autovector<WriteStallNotification> write_stall_notifications;
-#endif
  unique_ptr<SuperVersion> new_superversion;  // if nullptr no new superversion

  explicit SuperVersionContext(bool create_superversion = false)
@@ -40,37 +38,28 @@ struct SuperVersionContext {
  }

  inline bool HaveSomethingToDelete() const {
-#ifndef ROCKSDB_DISABLE_STALL_NOTIFICATION
-    return !superversions_to_free.empty() ||
-           !write_stall_notifications.empty();
-#else
-    return !superversions_to_free.empty();
-#endif
+    return superversions_to_free.size() > 0 ||
+           write_stall_notifications.size() > 0;
  }

  void PushWriteStallNotification(
      WriteStallCondition old_cond, WriteStallCondition new_cond,
      const std::string& name, const ImmutableCFOptions* ioptions) {
-#if !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION)
+#ifndef ROCKSDB_LITE
    WriteStallNotification notif;
    notif.write_stall_info.cf_name = name;
    notif.write_stall_info.condition.prev = old_cond;
    notif.write_stall_info.condition.cur = new_cond;
    notif.immutable_cf_options = ioptions;
    write_stall_notifications.push_back(notif);
-#else
-    (void)old_cond;
-    (void)new_cond;
-    (void)name;
-    (void)ioptions;
-#endif  // !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION)
+#endif  // !ROCKSDB_LITE
  }

  void Clean() {
-#if !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION)
+#ifndef ROCKSDB_LITE
    // notify listeners on changed write stall conditions
    for (auto& notif : write_stall_notifications) {
-      for (auto& listener : notif.immutable_cf_options->listeners) {
+      for (auto listener : notif.immutable_cf_options->listeners) {
        listener->OnStallConditionsChanged(notif.write_stall_info);
      }
    }
@@ -84,10 +73,8 @@ struct SuperVersionContext {
  }

  ~SuperVersionContext() {
-#ifndef ROCKSDB_DISABLE_STALL_NOTIFICATION
-    assert(write_stall_notifications.empty());
-#endif
-    assert(superversions_to_free.empty());
+    assert(write_stall_notifications.size() == 0);
+    assert(superversions_to_free.size() == 0);
  }
 };

@@ -105,12 +92,11 @@ struct JobContext {
  // Structure to store information for candidate files to delete.
  struct CandidateFileInfo {
    std::string file_name;
-    std::string file_path;
-    CandidateFileInfo(std::string name, std::string path)
-        : file_name(std::move(name)), file_path(std::move(path)) {}
+    uint32_t path_id;
+    CandidateFileInfo(std::string name, uint32_t path)
+        : file_name(std::move(name)), path_id(path) {}
    bool operator==(const CandidateFileInfo& other) const {
-      return file_name == other.file_name &&
-             file_path == other.file_path;
+      return file_name == other.file_name && path_id == other.path_id;
    }
  };

@@ -127,7 +113,7 @@ struct JobContext {
  std::vector<FileDescriptor> sst_live;

  // a list of sst files that we need to delete
-  std::vector<ObsoleteFileInfo> sst_delete_files;
+  std::vector<FileMetaData*> sst_delete_files;

  // a list of log files that we need to delete
  std::vector<uint64_t> log_delete_files;
@@ -260,7 +260,7 @@ TEST_F(EventListenerTest, OnSingleDBFlushTest) {
    ASSERT_EQ(listener->flushed_column_family_names_.size(), i);
  }

-  // make sure callback functions are called in the right order
+  // make sure call-back functions are called in the right order
  for (size_t i = 0; i < cf_names.size(); ++i) {
    ASSERT_EQ(listener->flushed_dbs_[i], db_);
    ASSERT_EQ(listener->flushed_column_family_names_[i], cf_names[i]);
@@ -296,7 +296,7 @@ TEST_F(EventListenerTest, MultiCF) {
    ASSERT_EQ(listener->flushed_column_family_names_.size(), i);
  }

-  // make sure callback functions are called in the right order
+  // make sure call-back functions are called in the right order
  for (size_t i = 0; i < cf_names.size(); i++) {
    ASSERT_EQ(listener->flushed_dbs_[i], db_);
    ASSERT_EQ(listener->flushed_column_family_names_[i], cf_names[i]);
@@ -57,11 +57,9 @@ Status Writer::AddRecord(const Slice& slice) {
        // Fill the trailer (literal below relies on kHeaderSize and
        // kRecyclableHeaderSize being <= 11)
        assert(header_size <= 11);
-        s = dest_->Append(Slice("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-                                static_cast<size_t>(leftover)));
-        if (!s.ok()) {
-          break;
-        }
+        dest_->Append(
+            Slice("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+                  static_cast<size_t>(leftover)));
      }
      block_offset_ = 0;
    }
@@ -1,67 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is 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).
-//
-#include "db/logs_with_prep_tracker.h"
-
-#include "port/likely.h"
-
-namespace rocksdb {
-void LogsWithPrepTracker::MarkLogAsHavingPrepSectionFlushed(uint64_t log) {
-  assert(log != 0);
-  std::lock_guard<std::mutex> lock(prepared_section_completed_mutex_);
-  auto it = prepared_section_completed_.find(log);
-  if (UNLIKELY(it == prepared_section_completed_.end())) {
-    prepared_section_completed_[log] = 1;
-  } else {
-    it->second += 1;
-  }
-}
-
-void LogsWithPrepTracker::MarkLogAsContainingPrepSection(uint64_t log) {
-  assert(log != 0);
-  std::lock_guard<std::mutex> lock(logs_with_prep_mutex_);
-
-  auto rit = logs_with_prep_.rbegin();
-  bool updated = false;
-  // Most probably the last log is the one that is being marked for
-  // having a prepare section; so search from the end.
-  for (; rit != logs_with_prep_.rend() && rit->log >= log; ++rit) {
-    if (rit->log == log) {
-      rit->cnt++;
-      updated = true;
-      break;
-    }
-  }
-  if (!updated) {
-    // We are either at the start, or at a position with rit->log < log
-    logs_with_prep_.insert(rit.base(), {log, 1});
-  }
-}
-
-uint64_t LogsWithPrepTracker::FindMinLogContainingOutstandingPrep() {
-  std::lock_guard<std::mutex> lock(logs_with_prep_mutex_);
-  auto it = logs_with_prep_.begin();
-  // start with the smallest log
-  for (; it != logs_with_prep_.end();) {
-    auto min_log = it->log;
-    {
-      std::lock_guard<std::mutex> lock2(prepared_section_completed_mutex_);
-      auto completed_it = prepared_section_completed_.find(min_log);
-      if (completed_it == prepared_section_completed_.end() ||
-          completed_it->second < it->cnt) {
-        return min_log;
-      }
-      assert(completed_it != prepared_section_completed_.end() &&
-             completed_it->second == it->cnt);
-      prepared_section_completed_.erase(completed_it);
-    }
-    // erase from beginning in vector is not efficient but this function is not
-    // on the fast path.
-    it = logs_with_prep_.erase(it);
-  }
-  // no such log found
-  return 0;
-}
-}  // namespace rocksdb
@@ -1,61 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is 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).
-//
-#pragma once
-
-#include <stdint.h>
-#include <cassert>
-#include <cstdlib>
-#include <mutex>
-#include <unordered_map>
-#include <vector>
-
-namespace rocksdb {
-
-// This class is used to track the log files with outstanding prepare entries.
-class LogsWithPrepTracker {
- public:
-  // Called when a transaction prepared in `log` has been committed or aborted.
-  void MarkLogAsHavingPrepSectionFlushed(uint64_t log);
-  // Called when a transaction is prepared in `log`.
-  void MarkLogAsContainingPrepSection(uint64_t log);
-  // Return the earliest log file with outstanding prepare entries.
-  uint64_t FindMinLogContainingOutstandingPrep();
-  size_t TEST_PreparedSectionCompletedSize() {
-    return prepared_section_completed_.size();
-  }
-  size_t TEST_LogsWithPrepSize() { return logs_with_prep_.size(); }
-
- private:
-  // REQUIRES: logs_with_prep_mutex_ held
-  //
-  // sorted list of log numbers still containing prepared data.
-  // this is used by FindObsoleteFiles to determine which
-  // flushed logs we must keep around because they still
-  // contain prepared data which has not been committed or rolled back
-  struct LogCnt {
-    uint64_t log;  // the log number
-    uint64_t cnt;  // number of prepared sections in the log
-  };
-  std::vector<LogCnt> logs_with_prep_;
-  std::mutex logs_with_prep_mutex_;
-
-  // REQUIRES: prepared_section_completed_mutex_ held
-  //
-  // to be used in conjunction with logs_with_prep_.
-  // once a transaction with data in log L is committed or rolled back
-  // rather than updating logs_with_prep_ directly we keep track of that
-  // in prepared_section_completed_ which maps LOG -> instance_count. This helps
-  // avoiding contention between a commit thread and the prepare threads.
-  //
-  // when trying to determine the minimum log still active we first
-  // consult logs_with_prep_. while that root value maps to
-  // an equal value in prepared_section_completed_ we erase the log from
-  // both logs_with_prep_ and prepared_section_completed_.
-  std::unordered_map<uint64_t, uint64_t> prepared_section_completed_;
-  std::mutex prepared_section_completed_mutex_;
-
-};
-}  // namespace rocksdb
@@ -19,12 +19,7 @@ using namespace rocksdb;

 namespace {

-// Reasoning: previously the number was 1100000. Since the keys are written to
-// the batch in one write each write will result into one SST file. each write
-// will result into one SST file. We reduced the write_buffer_size to 1K to
-// basically have the same effect with however less number of keys, which
-// results into less test runtime.
-const int kNumKeys = 1100;
+const int kNumKeys = 1100000;

 std::string Key1(int i) {
  char buf[100];
@@ -104,7 +99,6 @@ TEST_F(ManualCompactionTest, Test) {
  // specific scenario.
  rocksdb::DB* db;
  rocksdb::Options db_options;
-  db_options.write_buffer_size = 1024;
  db_options.create_if_missing = true;
  db_options.compression = rocksdb::kNoCompression;
  ASSERT_OK(rocksdb::DB::Open(db_options, dbname_, &db));
@@ -229,7 +229,7 @@ int MemTable::KeyComparator::operator()(const char* prefix_len_key1,
 }

 int MemTable::KeyComparator::operator()(const char* prefix_len_key,
-                                        const KeyComparator::DecodedType& key)
+                                        const Slice& key)
    const {
  // Internal keys are encoded as length-prefixed strings.
  Slice a = GetLengthPrefixedSlice(prefix_len_key);
@@ -479,12 +479,12 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
        insert_with_hint_prefix_extractor_->InDomain(key_slice)) {
      Slice prefix = insert_with_hint_prefix_extractor_->Transform(key_slice);
      bool res = table->InsertKeyWithHint(handle, &insert_hints_[prefix]);
-      if (UNLIKELY(!res)) {
+      if (!res) {
        return res;
      }
    } else {
      bool res = table->InsertKey(handle);
-      if (UNLIKELY(!res)) {
+      if (!res) {
        return res;
      }
    }
@@ -520,7 +520,7 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
    UpdateFlushState();
  } else {
    bool res = table->InsertKeyConcurrently(handle);
-    if (UNLIKELY(!res)) {
+    if (!res) {
      return res;
    }

@@ -64,7 +64,7 @@ struct MemTablePostProcessInfo {
 };

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

  // MemTables are reference counted.  The initial reference count
@@ -12,7 +12,6 @@
 #include <inttypes.h>
 #include <limits>
 #include <string>
-#include "db/db_impl.h"
 #include "db/memtable.h"
 #include "db/version_set.h"
 #include "monitoring/thread_status_util.h"
@@ -323,10 +322,9 @@ void MemTableList::RollbackMemtableFlush(const autovector<MemTable*>& mems,
 // Record a successful flush in the manifest file
 Status MemTableList::InstallMemtableFlushResults(
    ColumnFamilyData* cfd, const MutableCFOptions& mutable_cf_options,
-    const autovector<MemTable*>& mems, LogsWithPrepTracker* prep_tracker,
-    VersionSet* vset, InstrumentedMutex* mu, uint64_t file_number,
-    autovector<MemTable*>* to_delete, Directory* db_directory,
-    LogBuffer* log_buffer) {
+    const autovector<MemTable*>& mems, VersionSet* vset, InstrumentedMutex* mu,
+    uint64_t file_number, autovector<MemTable*>* to_delete,
+    Directory* db_directory, LogBuffer* log_buffer) {
  AutoThreadOperationStageUpdater stage_updater(
      ThreadStatus::STAGE_MEMTABLE_INSTALL_FLUSH_RESULTS);
  mu->AssertHeld();
@@ -363,7 +361,6 @@ Status MemTableList::InstallMemtableFlushResults(
    uint64_t batch_file_number = 0;
    size_t batch_count = 0;
    autovector<VersionEdit*> edit_list;
-    autovector<MemTable*> memtables_to_flush;
    // enumerate from the last (earliest) element to see how many batch finished
    for (auto it = memlist.rbegin(); it != memlist.rend(); ++it) {
      MemTable* m = *it;
@@ -376,20 +373,11 @@ Status MemTableList::InstallMemtableFlushResults(
                         "[%s] Level-0 commit table #%" PRIu64 " started",
                         cfd->GetName().c_str(), m->file_number_);
        edit_list.push_back(&m->edit_);
-        memtables_to_flush.push_back(m);
      }
      batch_count++;
    }

    if (batch_count > 0) {
-      if (vset->db_options()->allow_2pc) {
-        assert(edit_list.size() > 0);
-        // We piggyback the information of  earliest log file to keep in the
-        // manifest entry for the last file flushed.
-        edit_list.back()->SetMinLogNumberToKeep(PrecomputeMinLogNumberToKeep(
-            vset, *cfd, edit_list, memtables_to_flush, prep_tracker));
-      }
-
      // this can release and reacquire the mutex.
      s = vset->LogAndApply(cfd, mutable_cf_options, edit_list, mu,
                            db_directory);
@@ -480,21 +468,13 @@ void MemTableList::InstallNewVersion() {
  }
 }

-uint64_t MemTableList::PrecomputeMinLogContainingPrepSection(
-    const autovector<MemTable*>& memtables_to_flush) {
+uint64_t MemTableList::GetMinLogContainingPrepSection() {
  uint64_t min_log = 0;

  for (auto& m : current_->memlist_) {
-    // Assume the list is very short, we can live with O(m*n). We can optimize
-    // if the performance has some problem.
-    bool should_skip = false;
-    for (MemTable* m_to_flush : memtables_to_flush) {
-      if (m == m_to_flush) {
-        should_skip = true;
-        break;
-      }
-    }
-    if (should_skip) {
+    // this mem has been flushed it no longer
+    // needs to hold on the its prep section
+    if (m->flush_completed_) {
      continue;
    }

@@ -13,7 +13,6 @@
 #include <vector>

 #include "db/dbformat.h"
-#include "db/logs_with_prep_tracker.h"
 #include "db/memtable.h"
 #include "db/range_del_aggregator.h"
 #include "monitoring/instrumented_mutex.h"
@@ -211,10 +210,9 @@ class MemTableList {
  // Commit a successful flush in the manifest file
  Status InstallMemtableFlushResults(
      ColumnFamilyData* cfd, const MutableCFOptions& mutable_cf_options,
-      const autovector<MemTable*>& m, LogsWithPrepTracker* prep_tracker,
-      VersionSet* vset, InstrumentedMutex* mu, uint64_t file_number,
-      autovector<MemTable*>* to_delete, Directory* db_directory,
-      LogBuffer* log_buffer);
+      const autovector<MemTable*>& m, VersionSet* vset, InstrumentedMutex* mu,
+      uint64_t file_number, autovector<MemTable*>* to_delete,
+      Directory* db_directory, LogBuffer* log_buffer);

  // New memtables are inserted at the front of the list.
  // Takes ownership of the referenced held on *m by the caller of Add().
@@ -245,10 +243,7 @@ class MemTableList {

  size_t* current_memory_usage() { return &current_memory_usage_; }

-  // Returns the min log containing the prep section after memtables listsed in
-  // `memtables_to_flush` are flushed and their status is persisted in manifest.
-  uint64_t PrecomputeMinLogContainingPrepSection(
-      const autovector<MemTable*>& memtables_to_flush);
+  uint64_t GetMinLogContainingPrepSection();

  uint64_t GetEarliestMemTableID() const {
    auto& memlist = current_->memlist_;
@@ -82,10 +82,10 @@ class MemTableListTest : public testing::Test {
    // Create dummy mutex.
    InstrumentedMutex mutex;
    InstrumentedMutexLock l(&mutex);
-    LogsWithPrepTracker dummy_prep_tracker;
-    return list->InstallMemtableFlushResults(
-        cfd, mutable_cf_options, m, &dummy_prep_tracker, &versions, &mutex, 1,
-        to_delete, nullptr, &log_buffer);
+
+    return list->InstallMemtableFlushResults(cfd, mutable_cf_options, m,
+                                             &versions, &mutex, 1, to_delete,
+                                             nullptr, &log_buffer);
  }
 };

@@ -1,217 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is 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).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef ROCKSDB_LITE
-
-#include <stdlib.h>
-#include <map>
-#include <string>
-#include <vector>
-#include "db/db_impl.h"
-#include "db/version_set.h"
-#include "db/write_batch_internal.h"
-#include "rocksdb/db.h"
-#include "rocksdb/env.h"
-#include "rocksdb/transaction_log.h"
-#include "util/filename.h"
-#include "util/string_util.h"
-#include "util/sync_point.h"
-#include "util/testharness.h"
-#include "util/testutil.h"
-
-using std::cerr;
-using std::cout;
-using std::endl;
-using std::flush;
-
-namespace rocksdb {
-
-class ObsoleteFilesTest : public testing::Test {
- public:
-  std::string dbname_;
-  Options options_;
-  DB* db_;
-  Env* env_;
-  int numlevels_;
-
-  ObsoleteFilesTest() {
-    db_ = nullptr;
-    env_ = Env::Default();
-    // Trigger compaction when the number of level 0 files reaches 2.
-    options_.level0_file_num_compaction_trigger = 2;
-    options_.disable_auto_compactions = false;
-    options_.delete_obsolete_files_period_micros = 0;  // always do full purge
-    options_.enable_thread_tracking = true;
-    options_.write_buffer_size = 1024*1024*1000;
-    options_.target_file_size_base = 1024*1024*1000;
-    options_.max_bytes_for_level_base = 1024*1024*1000;
-    options_.WAL_ttl_seconds = 300; // Used to test log files
-    options_.WAL_size_limit_MB = 1024; // Used to test log files
-    dbname_ = test::TmpDir() + "/obsolete_files_test";
-    options_.wal_dir = dbname_ + "/wal_files";
-
-    // clean up all the files that might have been there before
-    std::vector<std::string> old_files;
-    env_->GetChildren(dbname_, &old_files);
-    for (auto file : old_files) {
-      env_->DeleteFile(dbname_ + "/" + file);
-    }
-    env_->GetChildren(options_.wal_dir, &old_files);
-    for (auto file : old_files) {
-      env_->DeleteFile(options_.wal_dir + "/" + file);
-    }
-
-    DestroyDB(dbname_, options_);
-    numlevels_ = 7;
-    EXPECT_OK(ReopenDB(true));
-  }
-
-  Status ReopenDB(bool create) {
-    delete db_;
-    if (create) {
-      DestroyDB(dbname_, options_);
-    }
-    db_ = nullptr;
-    options_.create_if_missing = create;
-    return DB::Open(options_, dbname_, &db_);
-  }
-
-  void CloseDB() {
-    delete db_;
-    db_ = nullptr;
-  }
-
-  void AddKeys(int numkeys, int startkey) {
-    WriteOptions options;
-    options.sync = false;
-    for (int i = startkey; i < (numkeys + startkey) ; i++) {
-      std::string temp = ToString(i);
-      Slice key(temp);
-      Slice value(temp);
-      ASSERT_OK(db_->Put(options, key, value));
-    }
-  }
-
-  int numKeysInLevels(
-    std::vector<LiveFileMetaData> &metadata,
-    std::vector<int> *keysperlevel = nullptr) {
-
-    if (keysperlevel != nullptr) {
-      keysperlevel->resize(numlevels_);
-    }
-
-    int numKeys = 0;
-    for (size_t i = 0; i < metadata.size(); i++) {
-      int startkey = atoi(metadata[i].smallestkey.c_str());
-      int endkey = atoi(metadata[i].largestkey.c_str());
-      int numkeysinfile = (endkey - startkey + 1);
-      numKeys += numkeysinfile;
-      if (keysperlevel != nullptr) {
-        (*keysperlevel)[(int)metadata[i].level] += numkeysinfile;
-      }
-      fprintf(stderr, "level %d name %s smallest %s largest %s\n",
-              metadata[i].level, metadata[i].name.c_str(),
-              metadata[i].smallestkey.c_str(),
-              metadata[i].largestkey.c_str());
-    }
-    return numKeys;
-  }
-
-  void createLevel0Files(int numFiles, int numKeysPerFile) {
-    int startKey = 0;
-    DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
-    for (int i = 0; i < numFiles; i++) {
-      AddKeys(numKeysPerFile, startKey);
-      startKey += numKeysPerFile;
-      ASSERT_OK(dbi->TEST_FlushMemTable());
-      ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
-    }
-  }
-
-  void CheckFileTypeCounts(std::string& dir,
-                            int required_log,
-                            int required_sst,
-                            int required_manifest) {
-    std::vector<std::string> filenames;
-    env_->GetChildren(dir, &filenames);
-
-    int log_cnt = 0, sst_cnt = 0, manifest_cnt = 0;
-    for (auto file : filenames) {
-      uint64_t number;
-      FileType type;
-      if (ParseFileName(file, &number, &type)) {
-        log_cnt += (type == kLogFile);
-        sst_cnt += (type == kTableFile);
-        manifest_cnt += (type == kDescriptorFile);
-      }
-    }
-    ASSERT_EQ(required_log, log_cnt);
-    ASSERT_EQ(required_sst, sst_cnt);
-    ASSERT_EQ(required_manifest, manifest_cnt);
-  }
-};
-
-TEST_F(ObsoleteFilesTest, RaceForObsoleteFileDeletion) {
-  createLevel0Files(2, 50000);
-  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);
-
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImpl::BackgroundCallCompaction:FoundObsoleteFiles",
-       "ObsoleteFilesTest::RaceForObsoleteFileDeletion:1"},
-      {"DBImpl::BackgroundCallCompaction:PurgedObsoleteFiles",
-       "ObsoleteFilesTest::RaceForObsoleteFileDeletion:2"},
-      });
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::DeleteObsoleteFileImpl:AfterDeletion", [&](void* arg) {
-        Status* p_status = reinterpret_cast<Status*>(arg);
-        ASSERT_TRUE(p_status->ok());
-      });
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::CloseHelper:PendingPurgeFinished", [&](void* arg) {
-        std::vector<uint64_t>* files_grabbed_for_purge_ptr =
-            reinterpret_cast<std::vector<uint64_t>*>(arg);
-        ASSERT_TRUE(files_grabbed_for_purge_ptr->empty());
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
-  port::Thread user_thread([&]() {
-    JobContext jobCxt(0);
-    TEST_SYNC_POINT("ObsoleteFilesTest::RaceForObsoleteFileDeletion:1");
-    dbi->TEST_LockMutex();
-    dbi->FindObsoleteFiles(&jobCxt,
-      true /* force=true */, false /* no_full_scan=false */);
-    dbi->TEST_UnlockMutex();
-    TEST_SYNC_POINT("ObsoleteFilesTest::RaceForObsoleteFileDeletion:2");
-    dbi->PurgeObsoleteFiles(jobCxt);
-    jobCxt.Clean();
-  });
-
-  user_thread.join();
-
-  CloseDB();
-}
-
-} //namespace rocksdb
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-
-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr,
-          "SKIPPED as DBImpl::DeleteFile is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // !ROCKSDB_LITE
@@ -227,9 +227,6 @@ void ProfileQueries(bool enabled_time = false) {
  HistogramImpl hist_write_pre_post;
  HistogramImpl hist_write_wal_time;
  HistogramImpl hist_write_memtable_time;
-  HistogramImpl hist_write_delay_time;
-  HistogramImpl hist_write_thread_wait_nanos;
-  HistogramImpl hist_write_scheduling_time;

  uint64_t total_db_mutex_nanos = 0;

@@ -273,15 +270,9 @@ void ProfileQueries(bool enabled_time = false) {
      ThreadStatusUtil::TEST_SetStateDelay(ThreadStatus::STATE_MUTEX_WAIT, 0U);
 #endif
    }
-    hist_write_pre_post.Add(
-        get_perf_context()->write_pre_and_post_process_time);
+    hist_write_pre_post.Add(get_perf_context()->write_pre_and_post_process_time);
    hist_write_wal_time.Add(get_perf_context()->write_wal_time);
    hist_write_memtable_time.Add(get_perf_context()->write_memtable_time);
-    hist_write_delay_time.Add(get_perf_context()->write_delay_time);
-    hist_write_thread_wait_nanos.Add(
-        get_perf_context()->write_thread_wait_nanos);
-    hist_write_scheduling_time.Add(
-        get_perf_context()->write_scheduling_flushes_compactions_time);
    hist_put.Add(get_perf_context()->user_key_comparison_count);
    total_db_mutex_nanos += get_perf_context()->db_mutex_lock_nanos;
  }
@@ -329,11 +320,6 @@ void ProfileQueries(bool enabled_time = false) {
              << hist_write_wal_time.ToString() << "\n"
              << " Writing Mem Table time: \n"
              << hist_write_memtable_time.ToString() << "\n"
-              << " Write Delay: \n" << hist_write_delay_time.ToString() << "\n"
-              << " Waiting for Batch time: \n"
-              << hist_write_thread_wait_nanos.ToString() << "\n"
-              << " Scheduling Flushes and Compactions Time: \n"
-              << hist_write_scheduling_time.ToString() << "\n"
              << " Total DB mutex nanos: \n" << total_db_mutex_nanos << "\n";

    std::cout << "Get(): Time to get snapshot: \n"
@@ -373,14 +359,6 @@ void ProfileQueries(bool enabled_time = false) {
    ASSERT_GT(hist_mget_files.Average(), 0);
    ASSERT_GT(hist_mget_post_process.Average(), 0);
    ASSERT_GT(hist_mget_num_memtable_checked.Average(), 0);
-
-    EXPECT_GT(hist_write_pre_post.Average(), 0);
-    EXPECT_GT(hist_write_wal_time.Average(), 0);
-    EXPECT_GT(hist_write_memtable_time.Average(), 0);
-    EXPECT_EQ(hist_write_delay_time.Average(), 0);
-    EXPECT_EQ(hist_write_thread_wait_nanos.Average(), 0);
-    EXPECT_GT(hist_write_scheduling_time.Average(), 0);
-
 #ifndef NDEBUG
    ASSERT_GT(total_db_mutex_nanos, 2000U);
 #endif
@@ -24,9 +24,7 @@ class PreReleaseCallback {
  // propagated to all the writers in the write group.
  // seq is the sequence number that is used for this write and will be
  // released.
-  // is_mem_disabled is currently used for debugging purposes to assert that
-  // the callback is done from the right write queue.
-  virtual Status Callback(SequenceNumber seq, bool is_mem_disabled) = 0;
+  virtual Status Callback(SequenceNumber seq) = 0;
 };

 }  //  namespace rocksdb
@@ -536,11 +536,4 @@ bool RangeDelAggregator::IsEmpty() {
  return true;
 }

-bool RangeDelAggregator::AddFile(uint64_t file_number) {
-  if (rep_ == nullptr) {
-    return true;
-  }
-  return rep_->added_files_.emplace(file_number).second;
-}
-
 }  // namespace rocksdb
@@ -6,7 +6,6 @@
 #pragma once

 #include <map>
-#include <set>
 #include <string>
 #include <vector>

@@ -141,7 +140,6 @@ class RangeDelAggregator {
                    CompactionIterationStats* range_del_out_stats = nullptr,
                    bool bottommost_level = false);
  bool IsEmpty();
-  bool AddFile(uint64_t file_number);

 private:
  // Maps tombstone user start key -> tombstone object
@@ -168,7 +166,6 @@ class RangeDelAggregator {
  struct Rep {
    StripeMap stripe_map_;
    PinnedIteratorsManager pinned_iters_mgr_;
-    std::set<uint64_t> added_files_;
  };
  // Initializes rep_ lazily. This aggregator object is constructed for every
  // read, so expensive members should only be created when necessary, i.e.,
@@ -101,12 +101,10 @@ class Repairer {
        db_options_(SanitizeOptions(dbname_, db_options)),
        immutable_db_options_(ImmutableDBOptions(db_options_)),
        icmp_(default_cf_opts.comparator),
-        default_cf_opts_(
-            SanitizeOptions(immutable_db_options_, default_cf_opts)),
+        default_cf_opts_(default_cf_opts),
        default_cf_iopts_(
-            ImmutableCFOptions(immutable_db_options_, default_cf_opts_)),
-        unknown_cf_opts_(
-            SanitizeOptions(immutable_db_options_, unknown_cf_opts)),
+            ImmutableCFOptions(immutable_db_options_, default_cf_opts)),
+        unknown_cf_opts_(unknown_cf_opts),
        create_unknown_cfs_(create_unknown_cfs),
        raw_table_cache_(
            // TableCache can be small since we expect each table to be opened
@@ -21,10 +21,6 @@ class SnapshotList;
 class SnapshotImpl : public Snapshot {
 public:
  SequenceNumber number_;  // const after creation
-  // It indicates the smallest uncommitted data at the time the snapshot was
-  // taken. This is currently used by WritePrepared transactions to limit the
-  // scope of queries to IsInSnpashot.
-  SequenceNumber min_uncommitted_ = 0;

  virtual SequenceNumber GetSequenceNumber() const override { return number_; }

@@ -60,8 +56,8 @@ class SnapshotList {
  SnapshotImpl* oldest() const { assert(!empty()); return list_.next_; }
  SnapshotImpl* newest() const { assert(!empty()); return list_.prev_; }

-  SnapshotImpl* New(SnapshotImpl* s, SequenceNumber seq, uint64_t unix_time,
-                    bool is_write_conflict_boundary) {
+  const SnapshotImpl* New(SnapshotImpl* s, SequenceNumber seq,
+                          uint64_t unix_time, bool is_write_conflict_boundary) {
    s->number_ = seq;
    s->unix_time_ = unix_time;
    s->is_write_conflict_boundary_ = is_write_conflict_boundary;
@@ -92,17 +92,13 @@ Status TableCache::GetTableReader(
    bool skip_filters, int level, bool prefetch_index_and_filter_in_cache,
    bool for_compaction) {
  std::string fname =
-      TableFileName(ioptions_.cf_paths, fd.GetNumber(), fd.GetPathId());
+      TableFileName(ioptions_.db_paths, fd.GetNumber(), fd.GetPathId());
  unique_ptr<RandomAccessFile> file;
  Status s = ioptions_.env->NewRandomAccessFile(fname, &file, env_options);

  RecordTick(ioptions_.statistics, NO_FILE_OPENS);
  if (s.ok()) {
-    if (readahead > 0 && !env_options.use_mmap_reads) {
-      // Not compatible with mmap files since ReadaheadRandomAccessFile requires
-      // its wrapped file's Read() to copy data into the provided scratch
-      // buffer, which mmap files don't use.
-      // TODO(ajkr): try madvise for mmap files in place of buffered readahead.
+    if (readahead > 0) {
      file = NewReadaheadRandomAccessFile(std::move(file), readahead);
    }
    if (!sequential_mode && ioptions_.advise_random_on_open) {
@@ -251,15 +247,13 @@ InternalIterator* TableCache::NewIterator(
    }
  }
  if (s.ok() && range_del_agg != nullptr && !options.ignore_range_deletions) {
-    if (range_del_agg->AddFile(fd.GetNumber())) {
-      std::unique_ptr<InternalIterator> range_del_iter(
-          table_reader->NewRangeTombstoneIterator(options));
-      if (range_del_iter != nullptr) {
-        s = range_del_iter->status();
-      }
-      if (s.ok()) {
-        s = range_del_agg->AddTombstones(std::move(range_del_iter));
-      }
+    std::unique_ptr<InternalIterator> range_del_iter(
+        table_reader->NewRangeTombstoneIterator(options));
+    if (range_del_iter != nullptr) {
+      s = range_del_iter->status();
+    }
+    if (s.ok()) {
+      s = range_del_agg->AddTombstones(std::move(range_del_iter));
    }
  }

@@ -30,7 +30,6 @@ enum Tag {
  kNewFile = 7,
  // 8 was used for large value refs
  kPrevLogNumber = 9,
-  kMinLogNumberToKeep = 10,

  // these are new formats divergent from open source leveldb
  kNewFile2 = 100,
@@ -45,11 +44,6 @@ enum Tag {
 enum CustomTag {
  kTerminate = 1,  // The end of customized fields
  kNeedCompaction = 2,
-  // Since Manifest is not entirely currently forward-compatible, and the only
-  // forward-compatbile part is the CutsomtTag of kNewFile, we currently encode
-  // kMinLogNumberToKeep as part of a CustomTag as a hack. This should be
-  // removed when manifest becomes forward-comptabile.
-  kMinLogNumberToKeepHack = 3,
  kPathId = 65,
 };
 // If this bit for the custom tag is set, opening DB should fail if
@@ -69,14 +63,12 @@ void VersionEdit::Clear() {
  last_sequence_ = 0;
  next_file_number_ = 0;
  max_column_family_ = 0;
-  min_log_number_to_keep_ = 0;
  has_comparator_ = false;
  has_log_number_ = false;
  has_prev_log_number_ = false;
  has_next_file_number_ = false;
  has_last_sequence_ = false;
  has_max_column_family_ = false;
-  has_min_log_number_to_keep_ = false;
  deleted_files_.clear();
  new_files_.clear();
  column_family_ = 0;
@@ -105,19 +97,19 @@ bool VersionEdit::EncodeTo(std::string* dst) const {
  if (has_max_column_family_) {
    PutVarint32Varint32(dst, kMaxColumnFamily, max_column_family_);
  }
+
  for (const auto& deleted : deleted_files_) {
    PutVarint32Varint32Varint64(dst, kDeletedFile, deleted.first /* level */,
                                deleted.second /* file number */);
  }

-  bool min_log_num_written = false;
  for (size_t i = 0; i < new_files_.size(); i++) {
    const FileMetaData& f = new_files_[i].second;
    if (!f.smallest.Valid() || !f.largest.Valid()) {
      return false;
    }
    bool has_customized_fields = false;
-    if (f.marked_for_compaction || has_min_log_number_to_keep_) {
+    if (f.marked_for_compaction) {
      PutVarint32(dst, kNewFile4);
      has_customized_fields = true;
    } else if (f.fd.GetPathId() == 0) {
@@ -173,13 +165,6 @@ bool VersionEdit::EncodeTo(std::string* dst) const {
        char p = static_cast<char>(1);
        PutLengthPrefixedSlice(dst, Slice(&p, 1));
      }
-      if (has_min_log_number_to_keep_ && !min_log_num_written) {
-        PutVarint32(dst, CustomTag::kMinLogNumberToKeepHack);
-        std::string varint_log_number;
-        PutFixed64(&varint_log_number, min_log_number_to_keep_);
-        PutLengthPrefixedSlice(dst, Slice(varint_log_number));
-        min_log_num_written = true;
-      }
      TEST_SYNC_POINT_CALLBACK("VersionEdit::EncodeTo:NewFile4:CustomizeFields",
                               dst);

@@ -233,9 +218,6 @@ const char* VersionEdit::DecodeNewFile4From(Slice* input) {
  uint64_t number;
  uint32_t path_id = 0;
  uint64_t file_size;
-  // Since this is the only forward-compatible part of the code, we hack new
-  // extension into this record. When we do, we set this boolean to distinguish
-  // the record from the normal NewFile records.
  if (GetLevel(input, &level, &msg) && GetVarint64(input, &number) &&
      GetVarint64(input, &file_size) && GetInternalKey(input, &f.smallest) &&
      GetInternalKey(input, &f.largest) &&
@@ -270,14 +252,6 @@ const char* VersionEdit::DecodeNewFile4From(Slice* input) {
          }
          f.marked_for_compaction = (field[0] == 1);
          break;
-        case kMinLogNumberToKeepHack:
-          // This is a hack to encode kMinLogNumberToKeep in a
-          // forward-compatbile fashion.
-          if (!GetFixed64(&field, &min_log_number_to_keep_)) {
-            return "deleted log number malformatted";
-          }
-          has_min_log_number_to_keep_ = true;
-          break;
        default:
          if ((custom_tag & kCustomTagNonSafeIgnoreMask) != 0) {
            // Should not proceed if cannot understand it
@@ -357,14 +331,6 @@ Status VersionEdit::DecodeFrom(const Slice& src) {
        }
        break;

-      case kMinLogNumberToKeep:
-        if (GetVarint64(&input, &min_log_number_to_keep_)) {
-          has_min_log_number_to_keep_ = true;
-        } else {
-          msg = "min log number to kee";
-        }
-        break;
-
      case kCompactPointer:
        if (GetLevel(&input, &level, &msg) &&
            GetInternalKey(&input, &key)) {
@@ -509,10 +475,6 @@ std::string VersionEdit::DebugString(bool hex_key) const {
    r.append("\n  NextFileNumber: ");
    AppendNumberTo(&r, next_file_number_);
  }
-  if (has_min_log_number_to_keep_) {
-    r.append("\n  MinLogNumberToKeep: ");
-    AppendNumberTo(&r, min_log_number_to_keep_);
-  }
  if (has_last_sequence_) {
    r.append("\n  LastSeq: ");
    AppendNumberTo(&r, last_sequence_);
@@ -620,9 +582,6 @@ std::string VersionEdit::DebugJSON(int edit_num, bool hex_key) const {
  if (has_max_column_family_) {
    jw << "MaxColumnFamily" << max_column_family_;
  }
-  if (has_min_log_number_to_keep_) {
-    jw << "MinLogNumberToKeep" << min_log_number_to_keep_;
-  }

  jw.EndObject();

@@ -199,14 +199,6 @@ class VersionEdit {
    has_max_column_family_ = true;
    max_column_family_ = max_column_family;
  }
-  void SetMinLogNumberToKeep(uint64_t num) {
-    has_min_log_number_to_keep_ = true;
-    min_log_number_to_keep_ = num;
-  }
-
-  bool has_log_number() { return has_log_number_; }
-
-  uint64_t log_number() { return log_number_; }

  // Add the specified file at the specified number.
  // REQUIRES: This version has not been saved (see VersionSet::SaveTo)
@@ -293,8 +285,6 @@ class VersionEdit {
  uint64_t prev_log_number_;
  uint64_t next_file_number_;
  uint32_t max_column_family_;
-  // The most recent WAL log number that is deleted
-  uint64_t min_log_number_to_keep_;
  SequenceNumber last_sequence_;
  bool has_comparator_;
  bool has_log_number_;
@@ -302,7 +292,6 @@ class VersionEdit {
  bool has_next_file_number_;
  bool has_last_sequence_;
  bool has_max_column_family_;
-  bool has_min_log_number_to_keep_;

  DeletedFileSet deleted_files_;
  std::vector<std::pair<int, FileMetaData>> new_files_;
@@ -181,16 +181,6 @@ TEST_F(VersionEditTest, ColumnFamilyTest) {
  TestEncodeDecode(edit);
 }

-TEST_F(VersionEditTest, MinLogNumberToKeep) {
-  VersionEdit edit;
-  edit.SetMinLogNumberToKeep(13);
-  TestEncodeDecode(edit);
-
-  edit.Clear();
-  edit.SetMinLogNumberToKeep(23);
-  TestEncodeDecode(edit);
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -135,9 +135,6 @@ class FilePicker {
        file_indexer_(file_indexer),
        user_comparator_(user_comparator),
        internal_comparator_(internal_comparator) {
-#ifdef NDEBUG
-    (void)files;
-#endif
    // Setup member variables to search first level.
    search_ended_ = !PrepareNextLevel();
    if (!search_ended_) {
@@ -358,11 +355,7 @@ Version::~Version() {
      assert(f->refs > 0);
      f->refs--;
      if (f->refs <= 0) {
-        assert(cfd_ != nullptr);
-        uint32_t path_id = f->fd.GetPathId();
-        assert(path_id < cfd_->ioptions()->cf_paths.size());
-        vset_->obsolete_files_.push_back(
-            ObsoleteFileInfo(f, cfd_->ioptions()->cf_paths[path_id].path));
+        vset_->obsolete_files_.push_back(f);
      }
    }
  }
@@ -763,7 +756,7 @@ Status Version::GetTableProperties(std::shared_ptr<const TableProperties>* tp,
    file_name = *fname;
  } else {
    file_name =
-      TableFileName(ioptions->cf_paths, file_meta->fd.GetNumber(),
+      TableFileName(vset_->db_options_->db_paths, file_meta->fd.GetNumber(),
                    file_meta->fd.GetPathId());
  }
  s = ioptions->env->NewRandomAccessFile(file_name, &file, env_options_);
@@ -804,7 +797,7 @@ Status Version::GetPropertiesOfAllTables(TablePropertiesCollection* props,
                                         int level) {
  for (const auto& file_meta : storage_info_.files_[level]) {
    auto fname =
-        TableFileName(cfd_->ioptions()->cf_paths, file_meta->fd.GetNumber(),
+        TableFileName(vset_->db_options_->db_paths, file_meta->fd.GetNumber(),
                      file_meta->fd.GetPathId());
    // 1. If the table is already present in table cache, load table
    // properties from there.
@@ -832,7 +825,7 @@ Status Version::GetPropertiesOfTablesInRange(
                                         false);
      for (const auto& file_meta : files) {
        auto fname =
-            TableFileName(cfd_->ioptions()->cf_paths,
+            TableFileName(vset_->db_options_->db_paths,
                          file_meta->fd.GetNumber(), file_meta->fd.GetPathId());
        if (props->count(fname) == 0) {
          // 1. If the table is already present in table cache, load table
@@ -904,11 +897,11 @@ void Version::GetColumnFamilyMetaData(ColumnFamilyMetaData* cf_meta) {
    for (const auto& file : vstorage->LevelFiles(level)) {
      uint32_t path_id = file->fd.GetPathId();
      std::string file_path;
-      if (path_id < ioptions->cf_paths.size()) {
-        file_path = ioptions->cf_paths[path_id].path;
+      if (path_id < ioptions->db_paths.size()) {
+        file_path = ioptions->db_paths[path_id].path;
      } else {
-        assert(!ioptions->cf_paths.empty());
-        file_path = ioptions->cf_paths.back().path;
+        assert(!ioptions->db_paths.empty());
+        file_path = ioptions->db_paths.back().path;
      }
      files.emplace_back(
          MakeTableFileName("", file->fd.GetNumber()), file_path,
@@ -1674,9 +1667,6 @@ void VersionStorageInfo::ComputeCompactionScore(
  }
  ComputeFilesMarkedForCompaction();
  ComputeBottommostFilesMarkedForCompaction();
-  if (immutable_cf_options.ttl > 0) {
-    ComputeExpiredTtlFiles(immutable_cf_options);
-  }
  EstimateCompactionBytesNeeded(mutable_cf_options);
 }

@@ -1703,34 +1693,6 @@ void VersionStorageInfo::ComputeFilesMarkedForCompaction() {
  }
 }

-void VersionStorageInfo::ComputeExpiredTtlFiles(
-    const ImmutableCFOptions& ioptions) {
-  assert(ioptions.ttl > 0);
-
-  expired_ttl_files_.clear();
-
-  int64_t _current_time;
-  auto status = ioptions.env->GetCurrentTime(&_current_time);
-  if (!status.ok()) {
-    return;
-  }
-  const uint64_t current_time = static_cast<uint64_t>(_current_time);
-
-  for (int level = 0; level < num_levels() - 1; level++) {
-    for (auto f : files_[level]) {
-      if (!f->being_compacted && f->fd.table_reader != nullptr &&
-          f->fd.table_reader->GetTableProperties() != nullptr) {
-        auto creation_time =
-            f->fd.table_reader->GetTableProperties()->creation_time;
-        if (creation_time > 0 &&
-            creation_time < (current_time - ioptions.ttl)) {
-          expired_ttl_files_.emplace_back(level, f);
-        }
-      }
-    }
-  }
-}
-
 namespace {

 // used to sort files by size
@@ -1767,8 +1729,6 @@ void VersionStorageInfo::AddFile(int level, FileMetaData* f, Logger* info_log) {
    }
    assert(false);
  }
-#else
-  (void)info_log;
 #endif
  f->refs++;
  level_files->push_back(f);
@@ -2663,16 +2623,16 @@ struct VersionSet::ManifestWriter {
 };

 VersionSet::VersionSet(const std::string& dbname,
-                       const ImmutableDBOptions* _db_options,
+                       const ImmutableDBOptions* db_options,
                       const EnvOptions& storage_options, Cache* table_cache,
                       WriteBufferManager* write_buffer_manager,
                       WriteController* write_controller)
    : column_family_set_(
-          new ColumnFamilySet(dbname, _db_options, storage_options, table_cache,
+          new ColumnFamilySet(dbname, db_options, storage_options, table_cache,
                              write_buffer_manager, write_controller)),
-      env_(_db_options->env),
+      env_(db_options->env),
      dbname_(dbname),
-      db_options_(_db_options),
+      db_options_(db_options),
      next_file_number_(2),
      manifest_file_number_(0),  // Filled by Recover()
      options_file_number_(0),
@@ -2696,12 +2656,12 @@ VersionSet::~VersionSet() {
  Cache* table_cache = column_family_set_->get_table_cache();
  table_cache->ApplyToAllCacheEntries(&CloseTables, false /* thread_safe */);
  column_family_set_.reset();
-  for (auto& file : obsolete_files_) {
-    if (file.metadata->table_reader_handle) {
-      table_cache->Release(file.metadata->table_reader_handle);
-      TableCache::Evict(table_cache, file.metadata->fd.GetNumber());
+  for (auto file : obsolete_files_) {
+    if (file->table_reader_handle) {
+      table_cache->Release(file->table_reader_handle);
+      TableCache::Evict(table_cache, file->fd.GetNumber());
    }
-    file.DeleteMetadata();
+    delete file;
  }
  obsolete_files_.clear();
 }
@@ -2843,9 +2803,6 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
  // because &w is ensuring that all new writes get queued.
  {
    EnvOptions opt_env_opts = env_->OptimizeForManifestWrite(env_options_);
-    // Before releasing mutex, make a copy of mutable_cf_options and pass to
-    // `PrepareApply` to avoided a potential data race with backgroundflush
-    MutableCFOptions mutable_cf_options_copy(mutable_cf_options);
    mu->Unlock();

    TEST_SYNC_POINT("VersionSet::LogAndApply:WriteManifest");
@@ -2884,7 +2841,7 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,

    if (!w.edit_list.front()->IsColumnFamilyManipulation()) {
      // This is cpu-heavy operations, which should be called outside mutex.
-      v->PrepareApply(mutable_cf_options_copy, true);
+      v->PrepareApply(mutable_cf_options, true);
    }

    // Write new record to MANIFEST log
@@ -2957,26 +2914,16 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
      }
    } else {
      uint64_t max_log_number_in_batch  = 0;
-      uint64_t last_min_log_number_to_keep = 0;
      for (auto& e : batch_edits) {
        if (e->has_log_number_) {
          max_log_number_in_batch =
              std::max(max_log_number_in_batch, e->log_number_);
        }
-        if (e->has_min_log_number_to_keep_) {
-          last_min_log_number_to_keep =
-              std::max(last_min_log_number_to_keep, e->min_log_number_to_keep_);
-        }
      }
      if (max_log_number_in_batch != 0) {
        assert(column_family_data->GetLogNumber() <= max_log_number_in_batch);
        column_family_data->SetLogNumber(max_log_number_in_batch);
      }
-      if (last_min_log_number_to_keep != 0) {
-        // Should only be set in 2PC mode.
-        MarkMinLogNumberToKeep2PC(last_min_log_number_to_keep);
-      }
-
      AppendVersion(column_family_data, v);
    }

@@ -3043,9 +2990,6 @@ void VersionSet::LogAndApplyCFHelper(VersionEdit* edit) {
 void VersionSet::LogAndApplyHelper(ColumnFamilyData* cfd,
                                   VersionBuilder* builder, Version* /*v*/,
                                   VersionEdit* edit, InstrumentedMutex* mu) {
-#ifdef NDEBUG
-  (void)cfd;
-#endif
  mu->AssertHeld();
  assert(!edit->IsColumnFamilyManipulation());

@@ -3132,7 +3076,6 @@ Status VersionSet::Recover(
  uint64_t log_number = 0;
  uint64_t previous_log_number = 0;
  uint32_t max_column_family = 0;
-  uint64_t min_log_number_to_keep = 0;
  std::unordered_map<uint32_t, BaseReferencedVersionBuilder*> builders;

  // add default column family
@@ -3273,11 +3216,6 @@ Status VersionSet::Recover(
        max_column_family = edit.max_column_family_;
      }

-      if (edit.has_min_log_number_to_keep_) {
-        min_log_number_to_keep =
-            std::max(min_log_number_to_keep, edit.min_log_number_to_keep_);
-      }
-
      if (edit.has_last_sequence_) {
        last_sequence = edit.last_sequence_;
        have_last_sequence = true;
@@ -3300,9 +3238,6 @@ Status VersionSet::Recover(

    column_family_set_->UpdateMaxColumnFamily(max_column_family);

-    // When reading DB generated using old release, min_log_number_to_keep=0.
-    // All log files will be scanned for potential prepare entries.
-    MarkMinLogNumberToKeep2PC(min_log_number_to_keep);
    MarkFileNumberUsed(previous_log_number);
    MarkFileNumberUsed(log_number);
  }
@@ -3374,12 +3309,11 @@ Status VersionSet::Recover(
        "manifest_file_number is %lu, next_file_number is %lu, "
        "last_sequence is %lu, log_number is %lu,"
        "prev_log_number is %lu,"
-        "max_column_family is %u,"
-        "min_log_number_to_keep is %lu\n",
+        "max_column_family is %u\n",
        manifest_filename.c_str(), (unsigned long)manifest_file_number_,
        (unsigned long)next_file_number_.load(), (unsigned long)last_sequence_,
        (unsigned long)log_number, (unsigned long)prev_log_number_,
-        column_family_set_->GetMaxColumnFamily(), min_log_number_to_keep_2pc());
+        column_family_set_->GetMaxColumnFamily());

    for (auto cfd : *column_family_set_) {
      if (cfd->IsDropped()) {
@@ -3667,7 +3601,6 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
        cfd->SetLogNumber(edit.log_number_);
      }

-
      if (edit.has_prev_log_number_) {
        previous_log_number = edit.prev_log_number_;
        have_prev_log_number = true;
@@ -3686,10 +3619,6 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
      if (edit.has_max_column_family_) {
        column_family_set_->UpdateMaxColumnFamily(edit.max_column_family_);
      }
-
-      if (edit.has_min_log_number_to_keep_) {
-        MarkMinLogNumberToKeep2PC(edit.min_log_number_to_keep_);
-      }
    }
  }
  file_reader.reset();
@@ -3748,11 +3677,10 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,

    printf(
        "next_file_number %lu last_sequence "
-        "%lu  prev_log_number %lu max_column_family %u min_log_number_to_keep "
-        "%" PRIu64 "\n",
+        "%lu  prev_log_number %lu max_column_family %u\n",
        (unsigned long)next_file_number_.load(), (unsigned long)last_sequence,
        (unsigned long)previous_log_number,
-        column_family_set_->GetMaxColumnFamily(), min_log_number_to_keep_2pc());
+        column_family_set_->GetMaxColumnFamily());
  }

  return s;
@@ -3767,14 +3695,6 @@ void VersionSet::MarkFileNumberUsed(uint64_t number) {
  }
 }

-// Called only either from ::LogAndApply which is protected by mutex or during
-// recovery which is single-threaded.
-void VersionSet::MarkMinLogNumberToKeep2PC(uint64_t number) {
-  if (min_log_number_to_keep_2pc_.load(std::memory_order_relaxed) < number) {
-    min_log_number_to_keep_2pc_.store(number, std::memory_order_relaxed);
-  }
-}
-
 Status VersionSet::WriteSnapshot(log::Writer* log) {
  // TODO: Break up into multiple records to reduce memory usage on recovery?

@@ -4091,8 +4011,6 @@ bool VersionSet::VerifyCompactionFileConsistency(Compaction* c) {
      }
    }
  }
-#else
-  (void)c;
 #endif
  return true;     // everything good
 }
@@ -4131,11 +4049,11 @@ void VersionSet::GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata) {
        LiveFileMetaData filemetadata;
        filemetadata.column_family_name = cfd->GetName();
        uint32_t path_id = file->fd.GetPathId();
-        if (path_id < cfd->ioptions()->cf_paths.size()) {
-          filemetadata.db_path = cfd->ioptions()->cf_paths[path_id].path;
+        if (path_id < db_options_->db_paths.size()) {
+          filemetadata.db_path = db_options_->db_paths[path_id].path;
        } else {
-          assert(!cfd->ioptions()->cf_paths.empty());
-          filemetadata.db_path = cfd->ioptions()->cf_paths.back().path;
+          assert(!db_options_->db_paths.empty());
+          filemetadata.db_path = db_options_->db_paths.back().path;
        }
        filemetadata.name = MakeTableFileName("", file->fd.GetNumber());
        filemetadata.level = level;
@@ -4150,17 +4068,17 @@ void VersionSet::GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata) {
  }
 }

-void VersionSet::GetObsoleteFiles(std::vector<ObsoleteFileInfo>* files,
+void VersionSet::GetObsoleteFiles(std::vector<FileMetaData*>* files,
                                  std::vector<std::string>* manifest_filenames,
                                  uint64_t min_pending_output) {
  assert(manifest_filenames->empty());
  obsolete_manifests_.swap(*manifest_filenames);
-  std::vector<ObsoleteFileInfo> pending_files;
-  for (auto& f : obsolete_files_) {
-    if (f.metadata->fd.GetNumber() < min_pending_output) {
-      files->push_back(std::move(f));
+  std::vector<FileMetaData*> pending_files;
+  for (auto f : obsolete_files_) {
+    if (f->fd.GetNumber() < min_pending_output) {
+      files->push_back(f);
    } else {
-      pending_files.push_back(std::move(f));
+      pending_files.push_back(f);
    }
  }
  obsolete_files_.swap(pending_files);
@@ -135,10 +135,6 @@ class VersionStorageInfo {
  // ComputeCompactionScore()
  void ComputeFilesMarkedForCompaction();

-  // This computes ttl_expired_files_ and is called by
-  // ComputeCompactionScore()
-  void ComputeExpiredTtlFiles(const ImmutableCFOptions& ioptions);
-
  // This computes bottommost_files_marked_for_compaction_ and is called by
  // ComputeCompactionScore() or UpdateOldestSnapshot().
  //
@@ -290,13 +286,6 @@ class VersionStorageInfo {
    return files_marked_for_compaction_;
  }

-  // REQUIRES: This version has been saved (see VersionSet::SaveTo)
-  // REQUIRES: DB mutex held during access
-  const autovector<std::pair<int, FileMetaData*>>& ExpiredTtlFiles() const {
-    assert(finalized_);
-    return expired_ttl_files_;
-  }
-
  // REQUIRES: This version has been saved (see VersionSet::SaveTo)
  // REQUIRES: DB mutex held during access
  const autovector<std::pair<int, FileMetaData*>>&
@@ -457,8 +446,6 @@ class VersionStorageInfo {
  // ComputeCompactionScore()
  autovector<std::pair<int, FileMetaData*>> files_marked_for_compaction_;

-  autovector<std::pair<int, FileMetaData*>> expired_ttl_files_;
-
  // These files are considered bottommost because none of their keys can exist
  // at lower levels. They are not necessarily all in the same level. The marked
  // ones are eligible for compaction because they contain duplicate key
@@ -695,36 +682,6 @@ class Version {
  void operator=(const Version&);
 };

-struct ObsoleteFileInfo {
-  FileMetaData* metadata;
-  std::string   path;
-
-  ObsoleteFileInfo() noexcept : metadata(nullptr) {}
-  ObsoleteFileInfo(FileMetaData* f, const std::string& file_path)
-      : metadata(f), path(file_path) {}
-
-  ObsoleteFileInfo(const ObsoleteFileInfo&) = delete;
-  ObsoleteFileInfo& operator=(const ObsoleteFileInfo&) = delete;
-
-  ObsoleteFileInfo(ObsoleteFileInfo&& rhs) noexcept :
-    ObsoleteFileInfo() {
-      *this = std::move(rhs);
-  }
-
-  ObsoleteFileInfo& operator=(ObsoleteFileInfo&& rhs) noexcept {
-    path = std::move(rhs.path);
-    metadata = rhs.metadata;
-    rhs.metadata = nullptr;
-
-    return *this;
-  }
-
-  void DeleteMetadata() {
-    delete metadata;
-    metadata = nullptr;
-  }
-};
-
 class VersionSet {
 public:
  VersionSet(const std::string& dbname, const ImmutableDBOptions* db_options,
@@ -802,10 +759,6 @@ class VersionSet {

  uint64_t current_next_file_number() const { return next_file_number_.load(); }

-  uint64_t min_log_number_to_keep_2pc() const {
-    return min_log_number_to_keep_2pc_.load();
-  }
-
  // Allocate and return a new file number
  uint64_t NewFileNumber() { return next_file_number_.fetch_add(1); }

@@ -853,31 +806,15 @@ class VersionSet {
  // REQUIRED: this is only called during single-threaded recovery or repair.
  void MarkFileNumberUsed(uint64_t number);

-  // Mark the specified log number as deleted
-  // REQUIRED: this is only called during single-threaded recovery or repair, or
-  // from ::LogAndApply where the global mutex is held.
-  void MarkMinLogNumberToKeep2PC(uint64_t number);
-
  // Return the log file number for the log file that is currently
  // being compacted, or zero if there is no such log file.
  uint64_t prev_log_number() const { return prev_log_number_; }

-  // Returns the minimum log number which still has data not flushed to any SST
-  // file.
-  // In non-2PC mode, all the log numbers smaller than this number can be safely
-  // deleted.
-  uint64_t MinLogNumberWithUnflushedData() const {
-    return PreComputeMinLogNumberWithUnflushedData(nullptr);
-  }
-  // Returns the minimum log number which still has data not flushed to any SST
-  // file, except data from `cfd_to_skip`.
-  uint64_t PreComputeMinLogNumberWithUnflushedData(
-      const ColumnFamilyData* cfd_to_skip) const {
+  // Returns the minimum log number such that all
+  // log numbers less than or equal to it can be deleted
+  uint64_t MinLogNumber() const {
    uint64_t min_log_num = std::numeric_limits<uint64_t>::max();
    for (auto cfd : *column_family_set_) {
-      if (cfd == cfd_to_skip) {
-        continue;
-      }
      // It's safe to ignore dropped column families here:
      // cfd->IsDropped() becomes true after the drop is persisted in MANIFEST.
      if (min_log_num > cfd->GetLogNumber() && !cfd->IsDropped()) {
@@ -917,7 +854,7 @@ class VersionSet {
  // This function doesn't support leveldb SST filenames
  void GetLiveFilesMetaData(std::vector<LiveFileMetaData> *metadata);

-  void GetObsoleteFiles(std::vector<ObsoleteFileInfo>* files,
+  void GetObsoleteFiles(std::vector<FileMetaData*>* files,
                        std::vector<std::string>* manifest_filenames,
                        uint64_t min_pending_output);

@@ -928,8 +865,6 @@ class VersionSet {
        new_options.writable_file_max_buffer_size;
  }

-  const ImmutableDBOptions* db_options() const { return db_options_; }
-
  static uint64_t GetNumLiveVersions(Version* dummy_versions);

  static uint64_t GetTotalSstFilesSize(Version* dummy_versions);
@@ -968,10 +903,6 @@ class VersionSet {
  const std::string dbname_;
  const ImmutableDBOptions* const db_options_;
  std::atomic<uint64_t> next_file_number_;
-  // Any log number equal or lower than this should be ignored during recovery,
-  // and is qualified for being deleted in 2PC mode. In non-2PC mode, this
-  // number is ignored.
-  std::atomic<uint64_t> min_log_number_to_keep_2pc_ = {0};
  uint64_t manifest_file_number_;
  uint64_t options_file_number_;
  uint64_t pending_manifest_file_number_;
@@ -1004,7 +935,7 @@ class VersionSet {
  // Current size of manifest file
  uint64_t manifest_file_size_;

-  std::vector<ObsoleteFileInfo> obsolete_files_;
+  std::vector<FileMetaData*> obsolete_files_;
  std::vector<std::string> obsolete_manifests_;

  // env options for all reads and writes except compactions
@@ -405,11 +405,9 @@ Status WriteBatch::Iterate(Handler* handler) const {
  Status s;
  char tag = 0;
  uint32_t column_family = 0;  // default
-  bool last_was_try_again = false;
-  while (((s.ok() && !input.empty()) || UNLIKELY(s.IsTryAgain())) &&
+  while ((s.ok() || UNLIKELY(s.IsTryAgain())) && !input.empty() &&
         handler->Continue()) {
    if (LIKELY(!s.IsTryAgain())) {
-      last_was_try_again = false;
      tag = 0;
      column_family = 0;  // default

@@ -420,13 +418,6 @@ Status WriteBatch::Iterate(Handler* handler) const {
      }
    } else {
      assert(s.IsTryAgain());
-      assert(!last_was_try_again); // to detect infinite loop bugs
-      if (UNLIKELY(last_was_try_again)) {
-        return Status::Corruption(
-            "two consecutive TryAgain in WriteBatch handler; this is either a "
-            "software bug or data corruption.");
-      }
-      last_was_try_again = true;
      s = Status::OK();
    }

@@ -1725,9 +1716,6 @@ Status WriteBatchInternal::InsertInto(
    ColumnFamilyMemTables* memtables, FlushScheduler* flush_scheduler,
    bool ignore_missing_column_families, uint64_t log_number, DB* db,
    bool concurrent_memtable_writes, bool seq_per_batch, size_t batch_cnt) {
-#ifdef NDEBUG
-  (void)batch_cnt;
-#endif
  assert(writer->ShouldWriteToMemtable());
  MemTableInserter inserter(sequence, memtables, flush_scheduler,
                            ignore_missing_column_families, log_number, db,
@@ -294,8 +294,7 @@ TEST_F(WriteCallbackTest, WriteWithCallbackTest) {
                   public:
                    PublishSeqCallback(DBImpl* db_impl_in)
                        : db_impl_(db_impl_in) {}
-                    virtual Status Callback(SequenceNumber last_seq,
-                                            bool /*not used*/) override {
+                    virtual Status Callback(SequenceNumber last_seq) {
                      db_impl_->SetLastPublishedSequence(last_seq);
                      return Status::OK();
                    }
@@ -7,7 +7,6 @@
 #include <chrono>
 #include <thread>
 #include "db/column_family.h"
-#include "monitoring/perf_context_imp.h"
 #include "port/port.h"
 #include "util/random.h"
 #include "util/sync_point.h"
@@ -74,10 +73,6 @@ uint8_t WriteThread::AwaitState(Writer* w, uint8_t goal_mask,
    port::AsmVolatilePause();
  }

-  // This is below the fast path, so that the stat is zero when all writes are
-  // from the same thread.
-  PERF_TIMER_GUARD(write_thread_wait_nanos);
-
  // If we're only going to end up waiting a short period of time,
  // it can be a lot more efficient to call std::this_thread::yield()
  // in a loop than to block in StateMutex().  For reference, on my 4.0
@@ -22,20 +22,6 @@ namespace rocksdb {
 Env::~Env() {
 }

-std::string Env::PriorityToString(Env::Priority priority) {
-  switch (priority) {
-    case Env::Priority::BOTTOM:
-      return "Bottom";
-    case Env::Priority::LOW:
-      return "Low";
-    case Env::Priority::HIGH:
-      return "High";
-    case Env::Priority::TOTAL:
-      assert(false);
-  }
-  return "Invalid";
-}
-
 uint64_t Env::GetThreadID() const {
  std::hash<std::thread::id> hasher;
  return hasher(std::this_thread::get_id());
@@ -87,8 +73,6 @@ RandomAccessFile::~RandomAccessFile() {
 WritableFile::~WritableFile() {
 }

-MemoryMappedFileBuffer::~MemoryMappedFileBuffer() {}
-
 Logger::~Logger() {}

 Status Logger::Close() {
@@ -111,17 +95,13 @@ void LogFlush(Logger *info_log) {
  }
 }

-static void Logv(Logger *info_log, const char* format, va_list ap) {
-  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::INFO_LEVEL) {
-    info_log->Logv(InfoLogLevel::INFO_LEVEL, format, ap);
-  }
-}
-
 void Log(Logger* info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Logv(info_log, format, ap);
-  va_end(ap);
+  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::INFO_LEVEL) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::INFO_LEVEL, format, ap);
+    va_end(ap);
+  }
 }

 void Logger::Logv(const InfoLogLevel log_level, const char* format, va_list ap) {
@@ -146,161 +126,152 @@ void Logger::Logv(const InfoLogLevel log_level, const char* format, va_list ap)
  }
 }

-static void Logv(const InfoLogLevel log_level, Logger *info_log, const char *format, va_list ap) {
+
+void Log(const InfoLogLevel log_level, Logger* info_log, const char* format,
+         ...) {
  if (info_log && info_log->GetInfoLogLevel() <= log_level) {
+    va_list ap;
+    va_start(ap, format);
+
    if (log_level == InfoLogLevel::HEADER_LEVEL) {
      info_log->LogHeader(format, ap);
    } else {
      info_log->Logv(log_level, format, ap);
    }
-  }
-}

-void Log(const InfoLogLevel log_level, Logger* info_log, const char* format,
-         ...) {
-  va_list ap;
-  va_start(ap, format);
-  Logv(log_level, info_log, format, ap);
-  va_end(ap);
-}
-
-static void Headerv(Logger *info_log, const char *format, va_list ap) {
-  if (info_log) {
-    info_log->LogHeader(format, ap);
+    va_end(ap);
  }
 }

 void Header(Logger* info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Headerv(info_log, format, ap);
-  va_end(ap);
-}
-
-static void Debugv(Logger* info_log, const char* format, va_list ap) {
-  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::DEBUG_LEVEL) {
-    info_log->Logv(InfoLogLevel::DEBUG_LEVEL, format, ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->LogHeader(format, ap);
+    va_end(ap);
  }
 }

 void Debug(Logger* info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Debugv(info_log, format, ap);
-  va_end(ap);
-}
-
-static void Infov(Logger* info_log, const char* format, va_list ap) {
-  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::INFO_LEVEL) {
-    info_log->Logv(InfoLogLevel::INFO_LEVEL, format, ap);
+  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::DEBUG_LEVEL) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::DEBUG_LEVEL, format, ap);
+    va_end(ap);
  }
 }

 void Info(Logger* info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Infov(info_log, format, ap);
-  va_end(ap);
-}
-
-static void Warnv(Logger* info_log, const char* format, va_list ap) {
-  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::WARN_LEVEL) {
-    info_log->Logv(InfoLogLevel::WARN_LEVEL, format, ap);
+  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::INFO_LEVEL) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::INFO_LEVEL, format, ap);
+    va_end(ap);
  }
 }

 void Warn(Logger* info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Warnv(info_log, format, ap);
-  va_end(ap);
-}
-
-static void Errorv(Logger* info_log, const char* format, va_list ap) {
-  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::ERROR_LEVEL) {
-    info_log->Logv(InfoLogLevel::ERROR_LEVEL, format, ap);
+  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::WARN_LEVEL) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::WARN_LEVEL, format, ap);
+    va_end(ap);
  }
 }
-
 void Error(Logger* info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Errorv(info_log, format, ap);
-  va_end(ap);
-}
-
-static void Fatalv(Logger* info_log, const char* format, va_list ap) {
-  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::FATAL_LEVEL) {
-    info_log->Logv(InfoLogLevel::FATAL_LEVEL, format, ap);
+  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::ERROR_LEVEL) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::ERROR_LEVEL, format, ap);
+    va_end(ap);
  }
 }
-
 void Fatal(Logger* info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Fatalv(info_log, format, ap);
-  va_end(ap);
+  if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::FATAL_LEVEL) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::FATAL_LEVEL, format, ap);
+    va_end(ap);
+  }
 }

 void LogFlush(const shared_ptr<Logger>& info_log) {
-  LogFlush(info_log.get());
+  if (info_log) {
+    info_log->Flush();
+  }
 }

 void Log(const InfoLogLevel log_level, const shared_ptr<Logger>& info_log,
         const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Logv(log_level, info_log.get(), format, ap);
-  va_end(ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(log_level, format, ap);
+    va_end(ap);
+  }
 }

 void Header(const shared_ptr<Logger>& info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Headerv(info_log.get(), format, ap);
-  va_end(ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->LogHeader(format, ap);
+    va_end(ap);
+  }
 }

 void Debug(const shared_ptr<Logger>& info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Debugv(info_log.get(), format, ap);
-  va_end(ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::DEBUG_LEVEL, format, ap);
+    va_end(ap);
+  }
 }

 void Info(const shared_ptr<Logger>& info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Infov(info_log.get(), format, ap);
-  va_end(ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::INFO_LEVEL, format, ap);
+    va_end(ap);
+  }
 }

 void Warn(const shared_ptr<Logger>& info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Warnv(info_log.get(), format, ap);
-  va_end(ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::WARN_LEVEL, format, ap);
+    va_end(ap);
+  }
 }

 void Error(const shared_ptr<Logger>& info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Errorv(info_log.get(), format, ap);
-  va_end(ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::ERROR_LEVEL, format, ap);
+    va_end(ap);
+  }
 }

 void Fatal(const shared_ptr<Logger>& info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Fatalv(info_log.get(), format, ap);
-  va_end(ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::FATAL_LEVEL, format, ap);
+    va_end(ap);
+  }
 }

 void Log(const shared_ptr<Logger>& info_log, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  Logv(info_log.get(), format, ap);
-  va_end(ap);
+  if (info_log) {
+    va_list ap;
+    va_start(ap, format);
+    info_log->Logv(InfoLogLevel::INFO_LEVEL, format, ap);
+    va_end(ap);
+  }
 }

 Status WriteStringToFile(Env* env, const Slice& data, const std::string& fname,
@@ -404,7 +375,8 @@ EnvOptions Env::OptimizeForCompactionTableWrite(
 EnvOptions Env::OptimizeForCompactionTableRead(
    const EnvOptions& env_options, const ImmutableDBOptions& db_options) const {
  EnvOptions optimized_env_options(env_options);
-  optimized_env_options.use_direct_reads = db_options.use_direct_reads;
+  optimized_env_options.use_direct_reads =
+      db_options.use_direct_io_for_flush_and_compaction;
  return optimized_env_options;
 }

@@ -74,10 +74,6 @@ ThreadStatusUpdater* CreateThreadStatusUpdater() {
  return new ThreadStatusUpdater();
 }

-inline mode_t GetDBFileMode(bool allow_non_owner_access) {
-  return allow_non_owner_access ? 0644 : 0600;
-}
-
 // list of pathnames that are locked
 static std::set<std::string> lockedFiles;
 static port::Mutex mutex_lockedFiles;
@@ -171,7 +167,7 @@ class PosixEnv : public Env {

    do {
      IOSTATS_TIMER_GUARD(open_nanos);
-      fd = open(fname.c_str(), flags, GetDBFileMode(allow_non_owner_access_));
+      fd = open(fname.c_str(), flags, 0644);
    } while (fd < 0 && errno == EINTR);
    if (fd < 0) {
      return IOError("While opening a file for sequentially reading", fname,
@@ -221,7 +217,7 @@ class PosixEnv : public Env {

    do {
      IOSTATS_TIMER_GUARD(open_nanos);
-      fd = open(fname.c_str(), flags, GetDBFileMode(allow_non_owner_access_));
+      fd = open(fname.c_str(), flags, 0644);
    } while (fd < 0 && errno == EINTR);
    if (fd < 0) {
      return IOError("While open a file for random read", fname, errno);
@@ -292,7 +288,7 @@ class PosixEnv : public Env {

    do {
      IOSTATS_TIMER_GUARD(open_nanos);
-      fd = open(fname.c_str(), flags, GetDBFileMode(allow_non_owner_access_));
+      fd = open(fname.c_str(), flags, 0644);
    } while (fd < 0 && errno == EINTR);

    if (fd < 0) {
@@ -380,8 +376,7 @@ class PosixEnv : public Env {

    do {
      IOSTATS_TIMER_GUARD(open_nanos);
-      fd = open(old_fname.c_str(), flags,
-                GetDBFileMode(allow_non_owner_access_));
+      fd = open(old_fname.c_str(), flags, 0644);
    } while (fd < 0 && errno == EINTR);
    if (fd < 0) {
      s = IOError("while reopen file for write", fname, errno);
@@ -441,7 +436,7 @@ class PosixEnv : public Env {
    int fd = -1;
    while (fd < 0) {
      IOSTATS_TIMER_GUARD(open_nanos);
-      fd = open(fname.c_str(), O_RDWR, GetDBFileMode(allow_non_owner_access_));
+      fd = open(fname.c_str(), O_CREAT | O_RDWR, 0644);
      if (fd < 0) {
        // Error while opening the file
        if (errno == EINTR) {
@@ -456,47 +451,6 @@ class PosixEnv : public Env {
    return Status::OK();
  }

-  virtual Status NewMemoryMappedFileBuffer(
-      const std::string& fname,
-      unique_ptr<MemoryMappedFileBuffer>* result) override {
-    int fd = -1;
-    Status status;
-    while (fd < 0) {
-      IOSTATS_TIMER_GUARD(open_nanos);
-      fd = open(fname.c_str(), O_RDWR, 0644);
-      if (fd < 0) {
-        // Error while opening the file
-        if (errno == EINTR) {
-          continue;
-        }
-        status =
-            IOError("While open file for raw mmap buffer access", fname, errno);
-        break;
-      }
-    }
-    uint64_t size;
-    if (status.ok()) {
-      status = GetFileSize(fname, &size);
-    }
-    void* base = nullptr;
-    if (status.ok()) {
-      base = mmap(nullptr, static_cast<size_t>(size), PROT_READ | PROT_WRITE,
-                  MAP_SHARED, fd, 0);
-      if (base == MAP_FAILED) {
-        status = IOError("while mmap file for read", fname, errno);
-      }
-    }
-    if (status.ok()) {
-      result->reset(
-          new PosixMemoryMappedFileBuffer(base, static_cast<size_t>(size)));
-    }
-    if (fd >= 0) {
-      // don't need to keep it open after mmap has been called
-      close(fd);
-    }
-    return status;
-  }
-
  virtual Status NewDirectory(const std::string& name,
                              unique_ptr<Directory>* result) override {
    result->reset();
@@ -835,11 +789,6 @@ class PosixEnv : public Env {
    return thread_pools_[pri].GetBackgroundThreads();
  }

-  virtual Status SetAllowNonOwnerAccess(bool allow_non_owner_access) override {
-    allow_non_owner_access_ = allow_non_owner_access;
-    return Status::OK();
-  }
-
  // Allow increasing the number of worker threads.
  virtual void IncBackgroundThreadsIfNeeded(int num, Priority pri) override {
    assert(pri >= Priority::BOTTOM && pri <= Priority::HIGH);
@@ -850,8 +799,6 @@ class PosixEnv : public Env {
    assert(pool >= Priority::BOTTOM && pool <= Priority::HIGH);
 #ifdef OS_LINUX
    thread_pools_[pool].LowerIOPriority();
-#else
-    (void)pool;
 #endif
  }

@@ -938,7 +885,6 @@ class PosixEnv : public Env {
        return false;
    }
 #else
-    (void)path;
    return false;
 #endif
  }
@@ -948,17 +894,13 @@ class PosixEnv : public Env {
  std::vector<ThreadPoolImpl> thread_pools_;
  pthread_mutex_t mu_;
  std::vector<pthread_t> threads_to_join_;
-  // If true, allow non owner read access for db files. Otherwise, non-owner
-  //  has no access to db files.
-  bool allow_non_owner_access_;
 };

 PosixEnv::PosixEnv()
    : checkedDiskForMmap_(false),
      forceMmapOff_(false),
      page_size_(getpagesize()),
-      thread_pools_(Priority::TOTAL),
-      allow_non_owner_access_(true) {
+      thread_pools_(Priority::TOTAL) {
  ThreadPoolImpl::PthreadCall("mutex_init", pthread_mutex_init(&mu_, nullptr));
  for (int pool_id = 0; pool_id < Env::Priority::TOTAL; ++pool_id) {
    thread_pools_[pool_id].SetThreadPriority(
Author	SHA1	Message	Date
przemyslaw.skibinski@percona.com	be955bff18	Fix GitHub issue #3716 : gcc-8 warnings Summary: Fix the following gcc-8 warnings: - conflicting C language linkage declaration [-Werror] - writing to an object with no trivial copy-assignment [-Werror=class-memaccess] - array subscript -1 is below array bounds [-Werror=array-bounds] Solves https://github.com/facebook/rocksdb/issues/3716 Closes https://github.com/facebook/rocksdb/pull/3736 Differential Revision: D7684161 Pulled By: yiwu-arbug fbshipit-source-id: 47c0423d26b74add251f1d3595211eee1e41e54a	2019-10-30 13:04:22 -07:00
Vijay Nadimpalli	424a9572e3	Making platform 007 (gcc 7) default in build_detect_platform.sh (#5947 ) Summary: Making platform 007 (gcc 7) default in build_detect_platform.sh. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5947 Differential Revision: D18038837 Pulled By: vjnadimpalli fbshipit-source-id: 9ac2ddaa93bf328a416faec028970e039886378e	2019-10-30 12:56:31 -07:00
Andrew Kryczka	4a5f01caa1	Add latest toolchain (gcc-8, etc.) build support for fbcode users (#4923 ) Summary: - When building with internal dependencies, specify this toolchain by setting `ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007=1` - It is not enabled by default. However, it is enabled for TSAN builds in CI since there is a known problem with TSAN in gcc-5: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71090 - I did not add support for Lua since (1) we agreed to deprecate it, and (2) we only have an internal build for v5.3 with this toolchain while that has breaking changes compared to our current version (v5.2). Pull Request resolved: https://github.com/facebook/rocksdb/pull/4923 Differential Revision: D13827226 Pulled By: ajkr fbshipit-source-id: 9aa3388ed3679777cfb15ef8cbcb83c07f62f947	2019-10-30 12:56:17 -07:00
sdong	abc4202e47	Revert "Reduce tail prefetching from 512KB to 4KB" This reverts commit `198052b24c`.	2018-07-20 16:02:11 -07:00
sdong	198052b24c	Reduce tail prefetching from 512KB to 4KB Summary: https://github.com/facebook/rocksdb/pull/4159 has a merging conflict so it can't be easily merged. To minimize the risk of merging, we just simply change 512KB to 4KB. It should be OK for MyRocks. Test Plan: Make all check	2018-07-20 15:55:48 -07:00
sdong	d9c289caa4	Bump up patch number to 5.13.4	2018-06-12 17:53:37 -07:00
sdong	3c6bb75133	Update HISTORY.md for 5.13.4	2018-06-12 17:41:26 -07:00
sdong	0c54d2609c	Fix regression bug of Prev() with upper bound (#3989 ) Summary: A recent change pushed down the upper bound checking to child iterators. However, this causes the logic of following sequence wrong: Seek(key); if (!Valid()) SeekToLast(); Because !Valid() may be caused by upper bounds, rather than the end of the iterator. In this case SeekToLast() points to totally wrong places. This can cause wrong results, infinite loops, or segfault in some cases. This sequence is called when changing direction from forward to backward. And this by itself also implicitly happen during reseeking optimization in Prev(). Fix this bug by using SeekForPrev() rather than this sequence, as what is already done in prefix extrator case. Closes https://github.com/facebook/rocksdb/pull/3989 Differential Revision: D8385422 Pulled By: siying fbshipit-source-id: 429e869990cfd2dc389421e0836fc496bed67bb4	2018-06-12 17:06:24 -07:00
Andrew Kryczka	f9e0a06512	update history and version	2018-06-06 11:16:32 -07:00
Huachao Huang	8d7396418c	Ignore empty filter block when data block is empty Summary: Close https://github.com/facebook/rocksdb/issues/3592 Closes https://github.com/facebook/rocksdb/pull/3614 Differential Revision: D7291706 Pulled By: ajkr fbshipit-source-id: 9dd8f40bd7716588e1e3fd6be0c2bc2766861f8c	2018-06-06 11:13:18 -07:00
Fosco Marotto	d25ca5fd49	Update history for release of 5.13.2	2018-05-25 16:41:35 -07:00
Adam Retter	2da2286dd0	Fix an issue with unnecessary capture in lambda expressions Summary: Closes https://github.com/facebook/rocksdb/issues/3900 Replaces https://github.com/facebook/rocksdb/pull/3901 I needed this to build v5.12.4 on Mac OS X (10.13.3). Closes https://github.com/facebook/rocksdb/pull/3904 Differential Revision: D8169357 Pulled By: sagar0 fbshipit-source-id: 85faac42168796e7def9250d0c221a9a03b84476	2018-05-25 16:26:04 -07:00
Yanqin Jin	83973ddd39	Fix segfault caused by object premature destruction Summary: Please refer to earlier discussion in [issue 3609](https://github.com/facebook/rocksdb/issues/3609). There was also an alternative fix in [PR 3888](https://github.com/facebook/rocksdb/pull/3888), but the proposed solution requires complex change. To summarize the cause of the problem. Upon creation of a column family, a `BlockBasedTableFactory` object is `new`ed and encapsulated by a `std::shared_ptr`. Since there is no other `std::shared_ptr` pointing to this `BlockBasedTableFactory`, when the column family is dropped, the `ColumnFamilyData` is `delete`d, causing the destructor of `std::shared_ptr`. Since there is no other `std::shared_ptr`, the underlying memory is also freed. Later when the db exits, it releases all the table readers, including the table readers that have been operating on the dropped column family. This needs to access the `table_options` owned by `BlockBasedTableFactory` that has already been deleted. Therefore, a segfault is raised. Previous workaround is to purge all obsolete files upon `ColumnFamilyData` destruction, which leads to a force release of table readers of the dropped column family. However this does not work when the user disables file deletion. Our solution in this PR is making a copy of `table_options` in `BlockBasedTable::Rep`. This solution increases memory copy and usage, but is much simpler. Test plan ``` $ make -j16 $ ./column_family_test --gtest_filter=ColumnFamilyTest.CreateDropAndDestroy:ColumnFamilyTest.CreateDropAndDestroyWithoutFileDeletion ``` Expected behavior: All tests should pass. Closes https://github.com/facebook/rocksdb/pull/3898 Differential Revision: D8149421 Pulled By: riversand963 fbshipit-source-id: eaecc2e064057ef607fbdd4cc275874f866c3438	2018-05-25 15:54:14 -07:00
Andrew Kryczka	1c18482bbf	bump version to 5.13.2 and update HISTORY	2018-05-23 21:01:48 -07:00
Andrew Kryczka	b245e51955	Introduce library-independent default compression level Summary: Previously we were using -1 as the default for every library, which was legacy from our zlib options. That worked for a while, but after zstd introduced https://github.com/facebook/zstd/commit/a146ee04ae5866b948be0c1911418e0436d80cb4, it started giving poor compression ratios by default in zstd. This PR adds a constant to RocksDB public API, `CompressionOptions::kDefaultCompressionLevel`, which will get translated to the default value specific to the compression library being used in "util/compression.h". The constant uses a number that appears to be larger than any library's maximum compression level. Closes https://github.com/facebook/rocksdb/pull/3895 Differential Revision: D8125780 Pulled By: ajkr fbshipit-source-id: 2db157a89118cd4f94577c2f4a0a5ff31c8391c6	2018-05-23 20:59:31 -07:00
Andrew Kryczka	c60df9d9e7	update history and version	2018-04-30 18:19:02 -07:00
Andrew Kryczka	747c853203	Avoid directory renames in BackupEngine Summary: We used to name private directories like "1.tmp" while BackupEngine populated them, and then rename without the ".tmp" suffix (i.e., rename "1.tmp" to "1") after all files were copied. On glusterfs, directory renames like this require operations across many hosts, and partial failures have caused operational problems. Fortunately we don't need to rename private directories. We already have a meta-file that uses the tempfile-rename pattern to commit a backup atomically after all its files have been successfully copied. So we can copy private files directly to their final location, so now there's no directory rename. Closes https://github.com/facebook/rocksdb/pull/3749 Differential Revision: D7705610 Pulled By: ajkr fbshipit-source-id: fd724a28dd2bf993ce323a5f2cb7e7d6980cc346	2018-04-30 17:50:24 -07:00
Gabriel Wicke	f5ee207c64	Support lowering CPU priority of background threads Summary: Background activities like compaction can negatively affect latency of higher-priority tasks like request processing. To avoid this, rocksdb already lowers the IO priority of background threads on Linux systems. While this takes care of typical IO-bound systems, it does not help much when CPU (temporarily) becomes the bottleneck. This is especially likely when using more expensive compression settings. This patch adds an API to allow for lowering the CPU priority of background threads, modeled on the IO priority API. Benchmarks (see below) show significant latency and throughput improvements when CPU bound. As a result, workloads with some CPU usage bursts should benefit from lower latencies at a given utilization, or should be able to push utilization higher at a given request latency target. A useful side effect is that compaction CPU usage is now easily visible in common tools, allowing for an easier estimation of the contribution of compaction vs. request processing threads. As with IO priority, the implementation is limited to Linux, degrading to a no-op on other systems. Closes https://github.com/facebook/rocksdb/pull/3763 Differential Revision: D7740096 Pulled By: gwicke fbshipit-source-id: e5d32373e8dc403a7b0c2227023f9ce4f22b413c	2018-04-24 18:18:32 -07:00
Zhongyi Xie	f2fd21fa6f	fix memory leak in two_level_iterator Summary: this PR fixes a few failed contbuild: 1. ASAN memory leak in Block::NewIterator (table/block.cc:429). the proper destruction of first_level_iter_ and second_level_iter_ of two_level_iterator.cc is missing from the code after the refactoring in https://github.com/facebook/rocksdb/pull/3406 2. various unused param errors introduced by https://github.com/facebook/rocksdb/pull/3662 3. updated comment for `ForceReleaseCachedEntry` to emphasize the use of `force_erase` flag. Closes https://github.com/facebook/rocksdb/pull/3718 Reviewed By: maysamyabandeh Differential Revision: D7621192 Pulled By: miasantreble fbshipit-source-id: 476c94264083a0730ded957c29de7807e4f5b146	2018-04-16 14:23:11 -07:00
Maysam Yabandeh	758527812c	Fix the memory leak with pinned partitioned filters Summary: The existing unit test did not set the level so the check for pinned partitioned filter/index being properly released from the block cache was not properly exercised as they only take effect in level 0. As a result a memory leak in pinned partitioned filters was hidden. The patch fix the test as well as the bug. Closes https://github.com/facebook/rocksdb/pull/3692 Differential Revision: D7559763 Pulled By: maysamyabandeh fbshipit-source-id: 55eff274945838af983c764a7d71e8daff092e4a	2018-04-16 14:12:49 -07:00
Sagar Vemuri	9d2e34ed4c	Fix History	2018-03-23 14:58:51 -07:00
Sagar Vemuri	1f5103d583	Add Java-API-Changes section to History Summary: We have not been updating our HISTORY.md change log with the RocksJava changes. Going forward, lets add Java changes also to HISTORY.md. There is an old java/HISTORY-JAVA.md, but it hasn't been updated in years. It is much easier to remember to update the change log in a single file, HISTORY.md. I added information about shared block cache here, which was introduced in #3623. Closes https://github.com/facebook/rocksdb/pull/3647 Differential Revision: D7384448 Pulled By: sagar0 fbshipit-source-id: 9b6e569f44e6df5cb7ba06413d9975df0b517d20	2018-03-23 14:56:44 -07:00
Sagar Vemuri	163dd4b81b	Shared block cache in RocksJava Summary: Changes to support sharing block cache using the Java API. Previously DB instances could share the block cache only when the same Options instance is passed to all the DB instances. But now, with this change, it is possible to explicitly create a cache and pass it to multiple options instances, to share the block cache. Implementing this for [Rocksandra](https://github.com/instagram/cassandra/tree/rocks_3.0), but this feature has been requested by many java api users over the years. Closes https://github.com/facebook/rocksdb/pull/3623 Differential Revision: D7305794 Pulled By: sagar0 fbshipit-source-id: 03e4e8ed7aeee6f88bada4a8365d4279ede2ad71	2018-03-23 14:56:05 -07:00
Sagar Vemuri	1642582559	Fsync after writing global seq number in ExternalSstFileIngestionJob Summary: Fsync after writing global sequence number to the ingestion file in ExternalSstFileIngestionJob. Otherwise the file metadata could be incorrect. Closes https://github.com/facebook/rocksdb/pull/3644 Differential Revision: D7373813 Pulled By: sagar0 fbshipit-source-id: 4da2c9e71a8beb5c08b4ac955f288ee1576358b8	2018-03-23 14:52:21 -07:00
Fosco Marotto	8d28083264	Update history for future 5.13 release	2018-03-20 16:17:53 -07:00