Fix WriteBatchBase::DeleteRange API comment

The `DeleteRange` end key is exclusive, not inclusive. Updated API comment accordingly.
2026-07-07 22:55:23 +08:00 · 2019-01-31 13:42:22 -08:00
517 changed files with 17127 additions and 33057 deletions
@@ -416,7 +416,7 @@ if(WITH_FALLOCATE)
 #include <linux/falloc.h>
 int main() {
 int fd = open(\"/dev/null\", 0);
- fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, 1024);
+ fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, 0, 1024);
 }
 " HAVE_FALLOCATE)
  if(HAVE_FALLOCATE)
@@ -489,7 +489,6 @@ set(SOURCES
        db/db_impl_debug.cc
        db/db_impl_experimental.cc
        db/db_impl_readonly.cc
-        db/db_impl_secondary.cc
        db/db_info_dumper.cc
        db/db_iter.cc
        db/dbformat.cc
@@ -502,7 +501,6 @@ set(SOURCES
        db/flush_scheduler.cc
        db/forward_iterator.cc
        db/internal_stats.cc
-        db/in_memory_stats_history.cc
        db/logs_with_prep_tracker.cc
        db/log_reader.cc
        db/log_writer.cc
@@ -532,6 +530,7 @@ set(SOURCES
        env/env_hdfs.cc
        env/mock_env.cc
        memtable/alloc_tracker.cc
+        memtable/hash_cuckoo_rep.cc
        memtable/hash_linklist_rep.cc
        memtable/hash_skiplist_rep.cc
        memtable/skiplistrep.cc
@@ -649,6 +648,7 @@ set(SOURCES
        utilities/env_mirror.cc
        utilities/env_timed.cc
        utilities/leveldb_options/leveldb_options.cc
+        utilities/lua/rocks_lua_compaction_filter.cc
        utilities/memory/memory_util.cc
        utilities/merge_operators/bytesxor.cc
        utilities/merge_operators/max.cc
@@ -874,7 +874,6 @@ if(WITH_TESTS)
        db/db_options_test.cc
        db/db_properties_test.cc
        db/db_range_del_test.cc
-        db/db_secondary_test.cc
        db/db_sst_test.cc
        db/db_statistics_test.cc
        db/db_table_properties_test.cc
@@ -966,6 +965,7 @@ if(WITH_TESTS)
        utilities/cassandra/cassandra_row_merge_test.cc
        utilities/cassandra/cassandra_serialize_test.cc
        utilities/checkpoint/checkpoint_test.cc
+        utilities/lua/rocks_lua_test.cc
        utilities/memory/memory_test.cc
        utilities/merge_operators/string_append/stringappend_test.cc
        utilities/object_registry_test.cc
@@ -1,32 +1,5 @@
 # Rocksdb Change Log
-
-## 6.1.1 (4/9/2019)
-### New Features
-* When reading from option file/string/map, customized comparators and/or merge operators can be filled according to object registry.
-### Public API Change
-### Bug Fixes
-* Fix a bug in 2PC where a sequence of txn prepare, memtable flush, and crash could result in losing the prepared transaction.
-* Fix a bug in Encryption Env which could cause encrypted files to be read beyond file boundaries.
-
-## 6.1.0 (3/27/2019)
-### New Features
-* Introduce two more stats levels, kExceptHistogramOrTimers and kExceptTimers.
-* Added a feature to perform data-block sampling for compressibility, and report stats to user.
-* Add support for trace filtering.
-* Add DBOptions.avoid_unnecessary_blocking_io. If true, we avoid file deletion when destorying ColumnFamilyHandle and Iterator. Instead, a job is scheduled to delete the files in background.
-
-### Public API Change
-* Remove bundled fbson library.
-* statistics.stats_level_ becomes atomic. It is preferred to use statistics.set_stats_level() and statistics.get_stats_level() to access it.
-* Introduce a new IOError subcode, PathNotFound, to indicate trying to open a nonexistent file or directory for read.
-* Add initial support for multiple db instances sharing the same data in single-writer, multi-reader mode.
-* Removed some "using std::xxx" from public headers.
-
-### Bug Fixes
-* Fix JEMALLOC_CXX_THROW macro missing from older Jemalloc versions, causing build failures on some platforms.
-* Fix SstFileReader not able to open file ingested with write_glbal_seqno=true.
-
-## 6.0.0 (2/19/2019)
+## Unreleased
 ### New Features
 * Enabled checkpoint on readonly db (DBImplReadOnly).
 * Make DB ignore dropped column families while committing results of atomic flush.
@@ -34,16 +7,8 @@
 * For users of dictionary compression with ZSTD v0.7.0+, we now reuse the same digested dictionary when compressing each of an SST file's data blocks for faster compression speeds.
 * For all users of dictionary compression who set `cache_index_and_filter_blocks == true`, we now store dictionary data used for decompression in the block cache for better control over memory usage. For users of ZSTD v1.1.4+ who compile with -DZSTD_STATIC_LINKING_ONLY, this includes a digested dictionary, which is used to increase decompression speed.
 * Add support for block checksums verification for external SST files before ingestion.
-* Introduce stats history which periodically saves Statistics snapshots and added `GetStatsHistory` API to retrieve these snapshots.
-* Add a place holder in manifest which indicate a record from future that can be safely ignored.
-* Add support for trace sampling.
-* Enable properties block checksum verification for block-based tables.
-* For all users of dictionary compression, we now generate a separate dictionary for compressing each bottom-level SST file. Previously we reused a single dictionary for a whole compaction to bottom level. The new approach achieves better compression ratios; however, it uses more memory and CPU for buffering/sampling data blocks and training dictionaries.
-* Add whole key bloom filter support in memtable.
-* Files written by `SstFileWriter` will now use dictionary compression if it is configured in the file writer's `CompressionOptions`.

 ### Public API Change
-* Disallow CompactionFilter::IgnoreSnapshots() = false, because it is not very useful and the behavior is confusing. The filter will filter everything if there is no snapshot declared by the time the compaction starts. However, users can define a snapshot after the compaction starts and before it finishes and this new snapshot won't be repeatable, because after the compaction finishes, some keys may be dropped.
 * CompactionPri = kMinOverlappingRatio also uses compensated file size, which boosts file with lots of tombstones to be compacted first.
 * Transaction::GetForUpdate is extended with a do_validate parameter with default value of true. If false it skips validating the snapshot before doing the read. Similarly ::Merge, ::Put, ::Delete, and ::SingleDelete are extended with assume_tracked with default value of false. If true it indicates that call is assumed to be after a ::GetForUpdate.
 * `TableProperties::num_entries` and `TableProperties::num_deletions` now also account for number of range tombstones.
@@ -51,11 +16,7 @@
 * With "ldb ----try_load_options", when wal_dir specified by the option file doesn't exist, ignore it.
 * Change time resolution in FileOperationInfo.
 * Deleting Blob files also go through SStFileManager.
-* Remove CuckooHash memtable.
-* The counter stat `number.block.not_compressed` now also counts blocks not compressed due to poor compression ratio.
-* Remove ttl option from `CompactionOptionsFIFO`. The option has been deprecated and ttl in `ColumnFamilyOptions` is used instead.
-* Support SST file ingestion across multiple column families via DB::IngestExternalFiles. See the function's comment about atomicity.
-* Remove Lua compaction filter.
+* Remove PlainTable's store_index_in_file feature. When opening an existing DB with index in SST files, the index and bloom filter will still be rebuild while SST files are opened, in the same way as there is no index in the file.

 ### Bug Fixes
 * Fix a deadlock caused by compaction and file ingestion waiting for each other in the event of write stalls.
@@ -1,9 +1,7 @@
 This is the list of all known third-party language bindings for RocksDB. If something is missing, please open a pull request to add it.

 * Java - https://github.com/facebook/rocksdb/tree/master/java
-* Python
-    * http://python-rocksdb.readthedocs.io/en/latest/
-    * http://pyrocksdb.readthedocs.org/en/latest/ (unmaintained)
+* Python - http://pyrocksdb.readthedocs.org/en/latest/
 * Perl - https://metacpan.org/pod/RocksDB
 * Node.js - https://npmjs.org/package/rocksdb
 * Go - https://github.com/tecbot/gorocksdb
@@ -443,7 +443,6 @@ TESTS = \
 	db_merge_operator_test \
 	db_options_test \
 	db_range_del_test \
-	db_secondary_test \
 	db_sst_test \
 	db_tailing_iter_test \
 	db_io_failure_test \
@@ -536,6 +535,7 @@ TESTS = \
 	ldb_cmd_test \
 	persistent_cache_test \
 	statistics_test \
+	lua_test \
 	lru_cache_test \
 	object_registry_test \
 	repair_test \
@@ -548,7 +548,6 @@ TESTS = \
 	range_tombstone_fragmenter_test \
 	range_del_aggregator_test \
 	sst_file_reader_test \
-	db_secondary_test \

 PARALLEL_TEST = \
 	backupable_db_test \
@@ -688,8 +687,7 @@ endif  # PLATFORM_SHARED_EXT
 .PHONY: blackbox_crash_test check clean coverage crash_test ldb_tests package \
 	release tags tags0 valgrind_check whitebox_crash_test format static_lib shared_lib all \
 	dbg rocksdbjavastatic rocksdbjava install install-static install-shared uninstall \
-	analyze tools tools_lib \
-	blackbox_crash_test_with_atomic_flush whitebox_crash_test_with_atomic_flush
+	analyze tools tools_lib


 all: $(LIBRARY) $(BENCHMARKS) tools tools_lib test_libs $(TESTS)
@@ -897,14 +895,10 @@ ldb_tests: ldb

 crash_test: whitebox_crash_test blackbox_crash_test

-crash_test_with_atomic_flush: whitebox_crash_test_with_atomic_flush blackbox_crash_test_with_atomic_flush
-
 blackbox_crash_test: db_stress
 	python -u tools/db_crashtest.py --simple blackbox $(CRASH_TEST_EXT_ARGS)
-	python -u tools/db_crashtest.py blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_atomic_flush: db_stress
 	python -u tools/db_crashtest.py --enable_atomic_flush blackbox $(CRASH_TEST_EXT_ARGS)
+	python -u tools/db_crashtest.py blackbox $(CRASH_TEST_EXT_ARGS)

 ifeq ($(CRASH_TEST_KILL_ODD),)
  CRASH_TEST_KILL_ODD=888887
@@ -913,12 +907,10 @@ endif
 whitebox_crash_test: db_stress
 	python -u tools/db_crashtest.py --simple whitebox --random_kill_odd \
      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-	python -u tools/db_crashtest.py whitebox  --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-whitebox_crash_test_with_atomic_flush: db_stress
 	python -u tools/db_crashtest.py --enable_atomic_flush whitebox  --random_kill_odd \
      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
+	python -u tools/db_crashtest.py whitebox  --random_kill_odd \
+      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

 asan_check:
 	$(MAKE) clean
@@ -930,11 +922,6 @@ asan_crash_test:
 	COMPILE_WITH_ASAN=1 $(MAKE) crash_test
 	$(MAKE) clean

-asan_crash_test_with_atomic_flush:
-	$(MAKE) clean
-	COMPILE_WITH_ASAN=1 $(MAKE) crash_test_with_atomic_flush
-	$(MAKE) clean
-
 ubsan_check:
 	$(MAKE) clean
 	COMPILE_WITH_UBSAN=1 $(MAKE) check -j32
@@ -945,11 +932,6 @@ ubsan_crash_test:
 	COMPILE_WITH_UBSAN=1 $(MAKE) crash_test
 	$(MAKE) clean

-ubsan_crash_test_with_atomic_flush:
-	$(MAKE) clean
-	COMPILE_WITH_UBSAN=1 $(MAKE) crash_test_with_atomic_flush
-	$(MAKE) clean
-
 valgrind_test:
 	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check

@@ -1555,6 +1537,9 @@ statistics_test: monitoring/statistics_test.o $(LIBOBJECTS) $(TESTHARNESS)
 lru_cache_test: cache/lru_cache_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

+lua_test: utilities/lua/rocks_lua_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(AM_LINK)
+
 range_del_aggregator_test: db/range_del_aggregator_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1573,9 +1558,6 @@ range_tombstone_fragmenter_test: db/range_tombstone_fragmenter_test.o db/db_test
 sst_file_reader_test: table/sst_file_reader_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-db_secondary_test: db/db_secondary_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 #-------------------------------------------------
 # make install related stuff
 INSTALL_PATH ?= /usr/local
@@ -1731,7 +1713,7 @@ endif
 	fi
 	tar xvzf snappy-$(SNAPPY_VER).tar.gz
 	mkdir snappy-$(SNAPPY_VER)/build
-	cd snappy-$(SNAPPY_VER)/build && CFLAGS='${EXTRA_CFLAGS}' CXXFLAGS='${EXTRA_CXXFLAGS}' LDFLAGS='${EXTRA_LDFLAGS}' cmake -DCMAKE_POSITION_INDEPENDENT_CODE=ON .. && $(MAKE) ${SNAPPY_MAKE_TARGET}
+	cd snappy-$(SNAPPY_VER)/build && CFLAGS='${EXTRA_CFLAGS}' CXXFLAGS='${EXTRA_CXXFLAGS}' LDFLAGS='${EXTRA_LDFLAGS}' cmake .. && $(MAKE) ${SNAPPY_MAKE_TARGET}
 	cp snappy-$(SNAPPY_VER)/build/libsnappy.a .

 liblz4.a:
@@ -5,7 +5,7 @@
 [![PPC64le Build Status](http://140.211.168.68:8080/buildStatus/icon?job=Rocksdb)](http://140.211.168.68:8080/job/Rocksdb)

 RocksDB is developed and maintained by Facebook Database Engineering Team.
-It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com)
+It is built on earlier work on LevelDB by Sanjay Ghemawat (sanjay@google.com)
 and Jeff Dean (jeff@google.com)

 This code is a library that forms the core building block for a fast
@@ -98,7 +98,6 @@ cpp_library(
        "db/db_impl_files.cc",
        "db/db_impl_open.cc",
        "db/db_impl_readonly.cc",
-        "db/db_impl_secondary.cc",
        "db/db_impl_write.cc",
        "db/db_info_dumper.cc",
        "db/db_iter.cc",
@@ -111,7 +110,6 @@ cpp_library(
        "db/flush_job.cc",
        "db/flush_scheduler.cc",
        "db/forward_iterator.cc",
-        "db/in_memory_stats_history.cc",
        "db/internal_stats.cc",
        "db/log_reader.cc",
        "db/log_writer.cc",
@@ -144,6 +142,7 @@ cpp_library(
        "env/io_posix.cc",
        "env/mock_env.cc",
        "memtable/alloc_tracker.cc",
+        "memtable/hash_cuckoo_rep.cc",
        "memtable/hash_linklist_rep.cc",
        "memtable/hash_skiplist_rep.cc",
        "memtable/skiplistrep.cc",
@@ -262,6 +261,7 @@ cpp_library(
        "utilities/env_mirror.cc",
        "utilities/env_timed.cc",
        "utilities/leveldb_options/leveldb_options.cc",
+        "utilities/lua/rocks_lua_compaction_filter.cc",
        "utilities/memory/memory_util.cc",
        "utilities/merge_operators/bytesxor.cc",
        "utilities/merge_operators/max.cc",
@@ -606,11 +606,6 @@ ROCKS_TESTS = [
        "db/db_range_del_test.cc",
        "serial",
    ],
-    [
-        "db_secondary_test",
-        "db/db_secondary_test.cc",
-        "serial",
-    ],
    [
        "db_sst_test",
        "db/db_sst_test.cc",
@@ -43,7 +43,7 @@ We plan to use this port for our business purposes here at Bing and this provide

 * Certain headers that are not present and not necessary on Windows were simply `#ifndef OS_WIN` in a few places (`unistd.h`)
 * All posix specific headers were replaced to port/port.h which worked well
-* Replaced `dirent.h` for `port/port_dirent.h` (very few places) with the implementation of the relevant interfaces within `rocksdb::port` namespace
+* Replaced `dirent.h` for `port/dirent.h` (very few places) with the implementation of the relevant interfaces within `rocksdb::port` namespace
 * Replaced `sys/time.h` to `port/sys_time.h` (few places) implemented equivalents within `rocksdb::port`
 * `printf %z` specification is not supported on Windows. To imitate existing standards we came up with a string macro `ROCKSDB_PRIszt` which expands to `zu` on posix systems and to `Iu` on windows.
 * in class member initialization were moved to a __ctors in some cases
@@ -3,7 +3,6 @@ from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
 rocksdb_target_header = """load("@fbcode_macros//build_defs:auto_headers.bzl", "AutoHeaders")
-load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
 load(":defs.bzl", "test_binary")

 REPO_PATH = package_name() + "/"
@@ -24,7 +23,6 @@ ROCKSDB_COMPILER_FLAGS = [
    "-DBZIP2",
    "-DLZ4",
    "-DZSTD",
-    "-DZSTD_STATIC_LINKING_ONLY",
    "-DGFLAGS=gflags",
    "-DNUMA",
    "-DTBB",
@@ -234,7 +234,7 @@ else
          #include <linux/falloc.h>
          int main() {
      int fd = open("/dev/null", 0);
-      fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, 1024);
+      fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, 0, 1024);
          }
 EOF
        if [ "$?" = 0 ]; then
@@ -518,8 +518,8 @@ if test "$USE_HDFS"; then
    echo "JAVA_HOME has to be set for HDFS usage."
    exit 1
  fi
-  HDFS_CCFLAGS="$HDFS_CCFLAGS -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -DUSE_HDFS -I$HADOOP_HOME/include"
-  HDFS_LDFLAGS="$HDFS_LDFLAGS -lhdfs -L$JAVA_HOME/jre/lib/amd64 -L$HADOOP_HOME/lib/native"
+  HDFS_CCFLAGS="$HDFS_CCFLAGS -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -DUSE_HDFS"
+  HDFS_LDFLAGS="$HDFS_LDFLAGS -lhdfs -L$JAVA_HOME/jre/lib/amd64"
  HDFS_LDFLAGS="$HDFS_LDFLAGS -L$JAVA_HOME/jre/lib/amd64/server -L$GLIBC_RUNTIME_PATH/lib"
  HDFS_LDFLAGS="$HDFS_LDFLAGS -ldl -lverify -ljava -ljvm"
  COMMON_FLAGS="$COMMON_FLAGS $HDFS_CCFLAGS"
@@ -132,14 +132,11 @@ _TEST_NAME_TO_PARSERS = {
    'lite': [CompilerErrorParser],
    'lite_test': [CompilerErrorParser, GTestErrorParser],
    'stress_crash': [CompilerErrorParser, DbCrashErrorParser],
-    'stress_crash_with_atomic_flush': [CompilerErrorParser, DbCrashErrorParser],
    'write_stress': [CompilerErrorParser, WriteStressErrorParser],
    'asan': [CompilerErrorParser, GTestErrorParser, AsanErrorParser],
    'asan_crash': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
-    'asan_crash_with_atomic_flush': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
    'ubsan': [CompilerErrorParser, GTestErrorParser, UbsanErrorParser],
    'ubsan_crash': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
-    'ubsan_crash_with_atomic_flush': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
    'valgrind': [CompilerErrorParser, GTestErrorParser, ValgrindErrorParser],
    'tsan': [CompilerErrorParser, GTestErrorParser, TsanErrorParser],
    'format_compatible': [CompilerErrorParser, CompatErrorParser],
@@ -400,35 +400,6 @@ STRESS_CRASH_TEST_COMMANDS="[
    }
 ]"

-#
-# RocksDB stress/crash test with atomic flush
-#
-STRESS_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
-    {
-        'name':'Rocksdb Stress/Crash Test (atomic flush)',
-        'oncall':'$ONCALL',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build and run RocksDB debug stress tests',
-                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 db_stress || $CONTRUN_NAME=db_stress $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            {
-                'name':'Build and run RocksDB debug crash tests with atomic flush',
-                'timeout': 86400,
-                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 crash_test_with_atomic_flush || $CONTRUN_NAME=crash_test_with_atomic_flush $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            }
-        ],
-        $ARTIFACTS,
-        $REPORT
-    }
-]"
-
 # RocksDB write stress test.
 # We run on disk device on purpose (i.e. no $SHM)
 # because we want to add some randomness to fsync commands
@@ -493,28 +464,6 @@ ASAN_CRASH_TEST_COMMANDS="[
    }
 ]"

-#
-# RocksDB crash testing with atomic flush under address sanitizer
-#
-ASAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
-    {
-        'name':'Rocksdb crash test (atomic flush) under ASAN',
-        'oncall':'$ONCALL',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build and run RocksDB debug asan_crash_test_with_atomic_flush',
-                'timeout': 86400,
-                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 asan_crash_test_with_atomic_flush || $CONTRUN_NAME=asan_crash_test_with_atomic_flush $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-        ],
-        $REPORT
-    }
-]"
-
 #
 # RocksDB test under undefined behavior sanitizer
 #
@@ -557,28 +506,6 @@ UBSAN_CRASH_TEST_COMMANDS="[
    }
 ]"

-#
-# RocksDB crash testing with atomic flush under undefined behavior sanitizer
-#
-UBSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
-    {
-        'name':'Rocksdb crash test (atomic flush) under UBSAN',
-        'oncall':'$ONCALL',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build and run RocksDB debug ubsan_crash_test_with_atomic_flush',
-                'timeout': 86400,
-                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 ubsan_crash_test_with_atomic_flush || $CONTRUN_NAME=ubsan_crash_test_with_atomic_flush $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-        ],
-        $REPORT
-    }
-]"
-
 #
 # RocksDB unit test under valgrind
 #
@@ -645,28 +572,6 @@ TSAN_CRASH_TEST_COMMANDS="[
    }
 ]"

-#
-# RocksDB crash test with atomic flush under TSAN
-#
-TSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
-    {
-        'name':'Rocksdb Crash Test with atomic flush under TSAN',
-        'oncall':'$ONCALL',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Compile and run',
-                'timeout': 86400,
-                'shell':'set -o pipefail && $SHM $DEBUG $TSAN $TSAN_CRASH CRASH_TEST_KILL_ODD=1887 make J=1 crash_test_with_atomic_flush || $CONTRUN_NAME=tsan_crash_test_with_atomic_flush $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-        ],
-        $REPORT
-    }
-]"
-
 #
 # RocksDB format compatible
 #
@@ -706,7 +611,7 @@ run_no_compression()
  rm -rf /dev/shm/rocksdb
  mkdir /dev/shm/rocksdb
  make clean
-  cat build_tools/fbcode_config.sh | grep -iv dzstd | grep -iv dzlib | grep -iv dlz4 | grep -iv dsnappy | grep -iv dbzip2 > .tmp.fbcode_config.sh
+  cat build_tools/fbcode_config.sh | grep -iv dzlib | grep -iv dlz4 | grep -iv dsnappy | grep -iv dbzip2 > .tmp.fbcode_config.sh
  mv .tmp.fbcode_config.sh build_tools/fbcode_config.sh
  cat Makefile | grep -v tools/ldb_test.py > .tmp.Makefile
  mv .tmp.Makefile Makefile
@@ -848,9 +753,6 @@ case $1 in
  stress_crash)
    echo $STRESS_CRASH_TEST_COMMANDS
    ;;
-  stress_crash_with_atomic_flush)
-    echo $STRESS_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS
-    ;;
  write_stress)
    echo $WRITE_STRESS_COMMANDS
    ;;
@@ -860,18 +762,12 @@ case $1 in
  asan_crash)
    echo $ASAN_CRASH_TEST_COMMANDS
    ;;
-  asan_crash_with_atomic_flush)
-    echo $ASAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS
-    ;;
  ubsan)
    echo $UBSAN_TEST_COMMANDS
    ;;
  ubsan_crash)
    echo $UBSAN_CRASH_TEST_COMMANDS
    ;;
-  ubsan_crash_with_atomic_flush)
-    echo $UBSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS
-    ;;
  valgrind)
    echo $VALGRIND_TEST_COMMANDS
    ;;
@@ -881,9 +777,6 @@ case $1 in
  tsan_crash)
    echo $TSAN_CRASH_TEST_COMMANDS
    ;;
-  tsan_crash_with_atomic_flush)
-    echo $TSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS
-    ;;
  format_compatible)
    echo $FORMAT_COMPATIBLE_COMMANDS
    ;;
@@ -73,7 +73,8 @@ class CacheTest : public testing::TestWithParam<std::string> {
    current_ = this;
  }

-  ~CacheTest() override {}
+  ~CacheTest() {
+  }

  std::shared_ptr<Cache> NewCache(size_t capacity) {
    auto type = GetParam();
@@ -98,7 +99,7 @@ class CacheTest : public testing::TestWithParam<std::string> {
    return nullptr;
  }

-  int Lookup(std::shared_ptr<Cache> cache, int key) {
+  int Lookup(shared_ptr<Cache> cache, int key) {
    Cache::Handle* handle = cache->Lookup(EncodeKey(key));
    const int r = (handle == nullptr) ? -1 : DecodeValue(cache->Value(handle));
    if (handle != nullptr) {
@@ -107,16 +108,16 @@ class CacheTest : public testing::TestWithParam<std::string> {
    return r;
  }

-  void Insert(std::shared_ptr<Cache> cache, int key, int value,
-              int charge = 1) {
+  void Insert(shared_ptr<Cache> cache, int key, int value, int charge = 1) {
    cache->Insert(EncodeKey(key), EncodeValue(value), charge,
                  &CacheTest::Deleter);
  }

-  void Erase(std::shared_ptr<Cache> cache, int key) {
+  void Erase(shared_ptr<Cache> cache, int key) {
    cache->Erase(EncodeKey(key));
  }

+
  int Lookup(int key) {
    return Lookup(cache_, key);
  }
@@ -306,7 +307,7 @@ TEST_P(CacheTest, EvictionPolicy) {
  Insert(200, 201);

  // Frequently used entry must be kept around
-  for (int i = 0; i < kCacheSize + 200; i++) {
+  for (int i = 0; i < kCacheSize + 100; i++) {
    Insert(1000+i, 2000+i);
    ASSERT_EQ(101, Lookup(100));
  }
@@ -359,7 +360,7 @@ TEST_P(CacheTest, EvictionPolicyRef) {
  Insert(303, 104);

  // Insert entries much more than Cache capacity
-  for (int i = 0; i < kCacheSize + 200; i++) {
+  for (int i = 0; i < kCacheSize + 100; i++) {
    Insert(1000 + i, 2000 + i);
  }

@@ -687,8 +688,7 @@ TEST_P(CacheTest, DefaultShardBits) {
 }

 #ifdef SUPPORT_CLOCK_CACHE
-std::shared_ptr<Cache> (*new_clock_cache_func)(size_t, int,
-                                               bool) = NewClockCache;
+shared_ptr<Cache> (*new_clock_cache_func)(size_t, int, bool) = NewClockCache;
 INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest,
                        testing::Values(kLRU, kClock));
 #else
@@ -234,35 +234,38 @@ struct CleanupContext {
 };

 // A cache shard which maintains its own CLOCK cache.
-class ClockCacheShard final : public CacheShard {
+class ClockCacheShard : public CacheShard {
 public:
  // Hash map type.
  typedef tbb::concurrent_hash_map<CacheKey, CacheHandle*, CacheKey> HashTable;

  ClockCacheShard();
-  ~ClockCacheShard() override;
+  ~ClockCacheShard();

  // Interfaces
-  void SetCapacity(size_t capacity) override;
-  void SetStrictCapacityLimit(bool strict_capacity_limit) override;
-  Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
-                void (*deleter)(const Slice& key, void* value),
-                Cache::Handle** handle, Cache::Priority priority) override;
-  Cache::Handle* Lookup(const Slice& key, uint32_t hash) override;
+  virtual void SetCapacity(size_t capacity) override;
+  virtual void SetStrictCapacityLimit(bool strict_capacity_limit) override;
+  virtual Status Insert(const Slice& key, uint32_t hash, void* value,
+                        size_t charge,
+                        void (*deleter)(const Slice& key, void* value),
+                        Cache::Handle** handle,
+                        Cache::Priority priority) override;
+  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash) override;
  // If the entry in in cache, increase reference count and return true.
  // Return false otherwise.
  //
  // Not necessary to hold mutex_ before being called.
-  bool Ref(Cache::Handle* handle) override;
-  bool Release(Cache::Handle* handle, bool force_erase = false) override;
-  void Erase(const Slice& key, uint32_t hash) override;
+  virtual bool Ref(Cache::Handle* handle) override;
+  virtual bool Release(Cache::Handle* handle,
+                       bool force_erase = false) override;
+  virtual void Erase(const Slice& key, uint32_t hash) override;
  bool EraseAndConfirm(const Slice& key, uint32_t hash,
                       CleanupContext* context);
-  size_t GetUsage() const override;
-  size_t GetPinnedUsage() const override;
-  void EraseUnRefEntries() override;
-  void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
-                              bool thread_safe) override;
+  virtual size_t GetUsage() const override;
+  virtual size_t GetPinnedUsage() const override;
+  virtual void EraseUnRefEntries() override;
+  virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
+                                      bool thread_safe) override;

 private:
  static const uint32_t kInCacheBit = 1;
@@ -672,7 +675,7 @@ void ClockCacheShard::EraseUnRefEntries() {
  Cleanup(context);
 }

-class ClockCache final : public ShardedCache {
+class ClockCache : public ShardedCache {
 public:
  ClockCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit)
      : ShardedCache(capacity, num_shard_bits, strict_capacity_limit) {
@@ -682,31 +685,31 @@ class ClockCache final : public ShardedCache {
    SetStrictCapacityLimit(strict_capacity_limit);
  }

-  ~ClockCache() override { delete[] shards_; }
+  virtual ~ClockCache() { delete[] shards_; }

-  const char* Name() const override { return "ClockCache"; }
+  virtual const char* Name() const override { return "ClockCache"; }

-  CacheShard* GetShard(int shard) override {
+  virtual CacheShard* GetShard(int shard) override {
    return reinterpret_cast<CacheShard*>(&shards_[shard]);
  }

-  const CacheShard* GetShard(int shard) const override {
+  virtual const CacheShard* GetShard(int shard) const override {
    return reinterpret_cast<CacheShard*>(&shards_[shard]);
  }

-  void* Value(Handle* handle) override {
+  virtual void* Value(Handle* handle) override {
    return reinterpret_cast<const CacheHandle*>(handle)->value;
  }

-  size_t GetCharge(Handle* handle) const override {
+  virtual size_t GetCharge(Handle* handle) const override {
    return reinterpret_cast<const CacheHandle*>(handle)->charge;
  }

-  uint32_t GetHash(Handle* handle) const override {
+  virtual uint32_t GetHash(Handle* handle) const override {
    return reinterpret_cast<const CacheHandle*>(handle)->hash;
  }

-  void DisownData() override { shards_ = nullptr; }
+  virtual void DisownData() override { shards_ = nullptr; }

 private:
  ClockCacheShard* shards_;
@@ -100,16 +100,14 @@ void LRUHandleTable::Resize() {
 }

 LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                             double high_pri_pool_ratio,
-                             bool use_adaptive_mutex)
+                             double high_pri_pool_ratio)
    : capacity_(0),
      high_pri_pool_usage_(0),
      strict_capacity_limit_(strict_capacity_limit),
      high_pri_pool_ratio_(high_pri_pool_ratio),
      high_pri_pool_capacity_(0),
      usage_(0),
-      lru_usage_(0),
-      mutex_(use_adaptive_mutex) {
+      lru_usage_(0) {
  // Make empty circular linked list
  lru_.next = &lru_;
  lru_.prev = &lru_;
@@ -464,8 +462,7 @@ std::string LRUCacheShard::GetPrintableOptions() const {

 LRUCache::LRUCache(size_t capacity, int num_shard_bits,
                   bool strict_capacity_limit, double high_pri_pool_ratio,
-                   std::shared_ptr<MemoryAllocator> allocator,
-                   bool use_adaptive_mutex)
+                   std::shared_ptr<MemoryAllocator> allocator)
    : ShardedCache(capacity, num_shard_bits, strict_capacity_limit,
                   std::move(allocator)) {
  num_shards_ = 1 << num_shard_bits;
@@ -474,8 +471,7 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
  size_t per_shard = (capacity + (num_shards_ - 1)) / num_shards_;
  for (int i = 0; i < num_shards_; i++) {
    new (&shards_[i])
-        LRUCacheShard(per_shard, strict_capacity_limit, high_pri_pool_ratio,
-            use_adaptive_mutex);
+        LRUCacheShard(per_shard, strict_capacity_limit, high_pri_pool_ratio);
  }
 }

@@ -544,15 +540,13 @@ std::shared_ptr<Cache> NewLRUCache(const LRUCacheOptions& cache_opts) {
  return NewLRUCache(cache_opts.capacity, cache_opts.num_shard_bits,
                     cache_opts.strict_capacity_limit,
                     cache_opts.high_pri_pool_ratio,
-                     cache_opts.memory_allocator,
-                     cache_opts.use_adaptive_mutex);
+                     cache_opts.memory_allocator);
 }

 std::shared_ptr<Cache> NewLRUCache(
    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
    double high_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator,
-    bool use_adaptive_mutex) {
+    std::shared_ptr<MemoryAllocator> memory_allocator) {
  if (num_shard_bits >= 20) {
    return nullptr;  // the cache cannot be sharded into too many fine pieces
  }
@@ -565,8 +559,7 @@ std::shared_ptr<Cache> NewLRUCache(
  }
  return std::make_shared<LRUCache>(capacity, num_shard_bits,
                                    strict_capacity_limit, high_pri_pool_ratio,
-                                    std::move(memory_allocator),
-                                    use_adaptive_mutex);
+                                    std::move(memory_allocator));
 }

 }  // namespace rocksdb
@@ -55,18 +55,10 @@ struct LRUHandle {
                     // cache itself is counted as 1

  // Include the following flags:
-  //   IN_CACHE:         whether this entry is referenced by the hash table.
-  //   IS_HIGH_PRI:      whether this entry is high priority entry.
-  //   IN_HIGH_PRI_POOL: whether this entry is in high-pri pool.
-  //   HAS_HIT:          whether this entry has had any lookups (hits).
-  enum Flags : uint8_t {
-    IN_CACHE = (1 << 0),
-    IS_HIGH_PRI = (1 << 1),
-    IN_HIGH_PRI_POOL = (1 << 2),
-    HAS_HIT = (1 << 3),
-  };
-
-  uint8_t flags;
+  //   in_cache:    whether this entry is referenced by the hash table.
+  //   is_high_pri: whether this entry is high priority entry.
+  //   in_high_pri_pool: whether this entry is in high-pri pool.
+  char flags;

  uint32_t hash;     // Hash of key(); used for fast sharding and comparisons

@@ -82,36 +74,36 @@ struct LRUHandle {
    }
  }

-  bool InCache() const { return flags & IN_CACHE; }
-  bool IsHighPri() const { return flags & IS_HIGH_PRI; }
-  bool InHighPriPool() const { return flags & IN_HIGH_PRI_POOL; }
-  bool HasHit() const { return flags & HAS_HIT; }
+  bool InCache() { return flags & 1; }
+  bool IsHighPri() { return flags & 2; }
+  bool InHighPriPool() { return flags & 4; }
+  bool HasHit() { return flags & 8; }

  void SetInCache(bool in_cache) {
    if (in_cache) {
-      flags |= IN_CACHE;
+      flags |= 1;
    } else {
-      flags &= ~IN_CACHE;
+      flags &= ~1;
    }
  }

  void SetPriority(Cache::Priority priority) {
    if (priority == Cache::Priority::HIGH) {
-      flags |= IS_HIGH_PRI;
+      flags |= 2;
    } else {
-      flags &= ~IS_HIGH_PRI;
+      flags &= ~2;
    }
  }

  void SetInHighPriPool(bool in_high_pri_pool) {
    if (in_high_pri_pool) {
-      flags |= IN_HIGH_PRI_POOL;
+      flags |= 4;
    } else {
-      flags &= ~IN_HIGH_PRI_POOL;
+      flags &= ~4;
    }
  }

-  void SetHit() { flags |= HAS_HIT; }
+  void SetHit() { flags |= 8; }

  void Free() {
    assert((refs == 1 && InCache()) || (refs == 0 && !InCache()));
@@ -165,10 +157,10 @@ class LRUHandleTable {
 };

 // A single shard of sharded cache.
-class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
+class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard : public CacheShard {
 public:
  LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                double high_pri_pool_ratio, bool use_adaptive_mutex);
+                double high_pri_pool_ratio);
  virtual ~LRUCacheShard();

  // Separate from constructor so caller can easily make an array of LRUCache
@@ -284,16 +276,11 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  mutable port::Mutex mutex_;
 };

-class LRUCache
-#ifdef NDEBUG
-    final
-#endif
-    : public ShardedCache {
+class LRUCache : public ShardedCache {
 public:
  LRUCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
           double high_pri_pool_ratio,
-           std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
-           bool use_adaptive_mutex = kDefaultToAdaptiveMutex);
+           std::shared_ptr<MemoryAllocator> memory_allocator = nullptr);
  virtual ~LRUCache();
  virtual const char* Name() const override { return "LRUCache"; }
  virtual CacheShard* GetShard(int shard) override;
@@ -15,7 +15,7 @@ namespace rocksdb {
 class LRUCacheTest : public testing::Test {
 public:
  LRUCacheTest() {}
-  ~LRUCacheTest() override { DeleteCache(); }
+  ~LRUCacheTest() { DeleteCache(); }

  void DeleteCache() {
    if (cache_ != nullptr) {
@@ -25,13 +25,12 @@ class LRUCacheTest : public testing::Test {
    }
  }

-  void NewCache(size_t capacity, double high_pri_pool_ratio = 0.0,
-                bool use_adaptive_mutex = kDefaultToAdaptiveMutex) {
+  void NewCache(size_t capacity, double high_pri_pool_ratio = 0.0) {
    DeleteCache();
    cache_ = reinterpret_cast<LRUCacheShard*>(
        port::cacheline_aligned_alloc(sizeof(LRUCacheShard)));
    new (cache_) LRUCacheShard(capacity, false /*strict_capcity_limit*/,
-                               high_pri_pool_ratio, use_adaptive_mutex);
+                               high_pri_pool_ratio);
  }

  void Insert(const std::string& key,
@@ -83,7 +83,7 @@ class ShardedCache : public Cache {

 private:
  static inline uint32_t HashSlice(const Slice& s) {
-    return static_cast<uint32_t>(GetSliceNPHash64(s));
+    return Hash(s.data(), s.size(), 0);
  }

  uint32_t Shard(uint32_t hash) {
@@ -47,18 +47,18 @@ TableBuilder* NewTableBuilder(
        int_tbl_prop_collector_factories,
    uint32_t column_family_id, const std::string& column_family_name,
    WritableFileWriter* file, const CompressionType compression_type,
-    uint64_t sample_for_compression, const CompressionOptions& compression_opts,
-    int level, const bool skip_filters, const uint64_t creation_time,
-    const uint64_t oldest_key_time, const uint64_t target_file_size) {
+    const CompressionOptions& compression_opts, int level,
+    const std::string* compression_dict, const bool skip_filters,
+    const uint64_t creation_time, const uint64_t oldest_key_time) {
  assert((column_family_id ==
          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
         column_family_name.empty());
  return ioptions.table_factory->NewTableBuilder(
      TableBuilderOptions(ioptions, moptions, internal_comparator,
                          int_tbl_prop_collector_factories, compression_type,
-                          sample_for_compression, compression_opts,
-                          skip_filters, column_family_name, level,
-                          creation_time, oldest_key_time, target_file_size),
+                          compression_opts, compression_dict, skip_filters,
+                          column_family_name, level, creation_time,
+                          oldest_key_time),
      column_family_id, file);
 }

@@ -75,12 +75,11 @@ Status BuildTable(
    std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
    SnapshotChecker* snapshot_checker, const CompressionType compression,
-    uint64_t sample_for_compression, const CompressionOptions& compression_opts,
-    bool paranoid_file_checks, InternalStats* internal_stats,
-    TableFileCreationReason reason, EventLogger* event_logger, int job_id,
-    const Env::IOPriority io_priority, TableProperties* table_properties,
-    int level, const uint64_t creation_time, const uint64_t oldest_key_time,
-    Env::WriteLifeTimeHint write_hint) {
+    const CompressionOptions& compression_opts, bool paranoid_file_checks,
+    InternalStats* internal_stats, TableFileCreationReason reason,
+    EventLogger* event_logger, int job_id, const Env::IOPriority io_priority,
+    TableProperties* table_properties, int level, const uint64_t creation_time,
+    const uint64_t oldest_key_time, Env::WriteLifeTimeHint write_hint) {
  assert((column_family_id ==
          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
         column_family_name.empty());
@@ -106,11 +105,6 @@ Status BuildTable(
  if (iter->Valid() || !range_del_agg->IsEmpty()) {
    TableBuilder* builder;
    std::unique_ptr<WritableFileWriter> file_writer;
-    // Currently we only enable dictionary compression during compaction to the
-    // bottommost level.
-    CompressionOptions compression_opts_for_flush(compression_opts);
-    compression_opts_for_flush.max_dict_bytes = 0;
-    compression_opts_for_flush.zstd_max_train_bytes = 0;
    {
      std::unique_ptr<WritableFile> file;
 #ifndef NDEBUG
@@ -133,9 +127,9 @@ Status BuildTable(
      builder = NewTableBuilder(
          ioptions, mutable_cf_options, internal_comparator,
          int_tbl_prop_collector_factories, column_family_id,
-          column_family_name, file_writer.get(), compression,
-          sample_for_compression, compression_opts_for_flush, level,
-          false /* skip_filters */, creation_time, oldest_key_time);
+          column_family_name, file_writer.get(), compression, compression_opts,
+          level, nullptr /* compression_dict */, false /* skip_filters */,
+          creation_time, oldest_key_time);
    }

    MergeHelper merge(env, internal_comparator.user_comparator(),
@@ -40,6 +40,8 @@ class InternalStats;
 // @param column_family_name Name of the column family that is also identified
 //    by column_family_id, or empty string if unknown. It must outlive the
 //    TableBuilder returned by this function.
+// @param compression_dict Data for presetting the compression library's
+//    dictionary, or nullptr.
 TableBuilder* NewTableBuilder(
    const ImmutableCFOptions& options, const MutableCFOptions& moptions,
    const InternalKeyComparator& internal_comparator,
@@ -47,10 +49,10 @@ TableBuilder* NewTableBuilder(
        int_tbl_prop_collector_factories,
    uint32_t column_family_id, const std::string& column_family_name,
    WritableFileWriter* file, const CompressionType compression_type,
-    const uint64_t sample_for_compression,
    const CompressionOptions& compression_opts, int level,
+    const std::string* compression_dict = nullptr,
    const bool skip_filters = false, const uint64_t creation_time = 0,
-    const uint64_t oldest_key_time = 0, const uint64_t target_file_size = 0);
+    const uint64_t oldest_key_time = 0);

 // Build a Table file from the contents of *iter.  The generated file
 // will be named according to number specified in meta. On success, the rest of
@@ -73,7 +75,6 @@ extern Status BuildTable(
    std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
    SnapshotChecker* snapshot_checker, const CompressionType compression,
-    const uint64_t sample_for_compression,
    const CompressionOptions& compression_opts, bool paranoid_file_checks,
    InternalStats* internal_stats, TableFileCreationReason reason,
    EventLogger* event_logger = nullptr, int job_id = 0,
@@ -208,10 +208,13 @@ struct rocksdb_compactionfilter_t : public CompactionFilter {
  const char* (*name_)(void*);
  unsigned char ignore_snapshots_;

-  ~rocksdb_compactionfilter_t() override { (*destructor_)(state_); }
+  virtual ~rocksdb_compactionfilter_t() {
+    (*destructor_)(state_);
+  }

-  bool Filter(int level, const Slice& key, const Slice& existing_value,
-              std::string* new_value, bool* value_changed) const override {
+  virtual bool Filter(int level, const Slice& key, const Slice& existing_value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
    char* c_new_value = nullptr;
    size_t new_value_length = 0;
    unsigned char c_value_changed = 0;
@@ -228,9 +231,9 @@ struct rocksdb_compactionfilter_t : public CompactionFilter {
    return result;
  }

-  const char* Name() const override { return (*name_)(state_); }
+  virtual const char* Name() const override { return (*name_)(state_); }

-  bool IgnoreSnapshots() const override { return ignore_snapshots_; }
+  virtual bool IgnoreSnapshots() const override { return ignore_snapshots_; }
 };

 struct rocksdb_compactionfilterfactory_t : public CompactionFilterFactory {
@@ -240,9 +243,9 @@ struct rocksdb_compactionfilterfactory_t : public CompactionFilterFactory {
      void*, rocksdb_compactionfiltercontext_t* context);
  const char* (*name_)(void*);

-  ~rocksdb_compactionfilterfactory_t() override { (*destructor_)(state_); }
+  virtual ~rocksdb_compactionfilterfactory_t() { (*destructor_)(state_); }

-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    rocksdb_compactionfiltercontext_t ccontext;
    ccontext.rep = context;
@@ -250,7 +253,7 @@ struct rocksdb_compactionfilterfactory_t : public CompactionFilterFactory {
    return std::unique_ptr<CompactionFilter>(cf);
  }

-  const char* Name() const override { return (*name_)(state_); }
+  virtual const char* Name() const override { return (*name_)(state_); }
 };

 struct rocksdb_comparator_t : public Comparator {
@@ -262,17 +265,20 @@ struct rocksdb_comparator_t : public Comparator {
      const char* b, size_t blen);
  const char* (*name_)(void*);

-  ~rocksdb_comparator_t() override { (*destructor_)(state_); }
+  virtual ~rocksdb_comparator_t() {
+    (*destructor_)(state_);
+  }

-  int Compare(const Slice& a, const Slice& b) const override {
+  virtual int Compare(const Slice& a, const Slice& b) const override {
    return (*compare_)(state_, a.data(), a.size(), b.data(), b.size());
  }

-  const char* Name() const override { return (*name_)(state_); }
+  virtual const char* Name() const override { return (*name_)(state_); }

  // No-ops since the C binding does not support key shortening methods.
-  void FindShortestSeparator(std::string*, const Slice&) const override {}
-  void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortestSeparator(std::string*,
+                                     const Slice&) const override {}
+  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
 };

 struct rocksdb_filterpolicy_t : public FilterPolicy {
@@ -292,11 +298,14 @@ struct rocksdb_filterpolicy_t : public FilterPolicy {
      void*,
      const char* filter, size_t filter_length);

-  ~rocksdb_filterpolicy_t() override { (*destructor_)(state_); }
+  virtual ~rocksdb_filterpolicy_t() {
+    (*destructor_)(state_);
+  }

-  const char* Name() const override { return (*name_)(state_); }
+  virtual const char* Name() const override { return (*name_)(state_); }

-  void CreateFilter(const Slice* keys, int n, std::string* dst) const override {
+  virtual void CreateFilter(const Slice* keys, int n,
+                            std::string* dst) const override {
    std::vector<const char*> key_pointers(n);
    std::vector<size_t> key_sizes(n);
    for (int i = 0; i < n; i++) {
@@ -314,7 +323,8 @@ struct rocksdb_filterpolicy_t : public FilterPolicy {
    }
  }

-  bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
+  virtual bool KeyMayMatch(const Slice& key,
+                           const Slice& filter) const override {
    return (*key_match_)(state_, key.data(), key.size(),
                         filter.data(), filter.size());
  }
@@ -339,12 +349,14 @@ struct rocksdb_mergeoperator_t : public MergeOperator {
      void*,
      const char* value, size_t value_length);

-  ~rocksdb_mergeoperator_t() override { (*destructor_)(state_); }
+  virtual ~rocksdb_mergeoperator_t() {
+    (*destructor_)(state_);
+  }

-  const char* Name() const override { return (*name_)(state_); }
+  virtual const char* Name() const override { return (*name_)(state_); }

-  bool FullMergeV2(const MergeOperationInput& merge_in,
-                   MergeOperationOutput* merge_out) const override {
+  virtual bool FullMergeV2(const MergeOperationInput& merge_in,
+                           MergeOperationOutput* merge_out) const override {
    size_t n = merge_in.operand_list.size();
    std::vector<const char*> operand_pointers(n);
    std::vector<size_t> operand_sizes(n);
@@ -378,10 +390,10 @@ struct rocksdb_mergeoperator_t : public MergeOperator {
    return success;
  }

-  bool PartialMergeMulti(const Slice& key,
-                         const std::deque<Slice>& operand_list,
-                         std::string* new_value,
-                         Logger* /*logger*/) const override {
+  virtual bool PartialMergeMulti(const Slice& key,
+                                 const std::deque<Slice>& operand_list,
+                                 std::string* new_value,
+                                 Logger* /*logger*/) const override {
    size_t operand_count = operand_list.size();
    std::vector<const char*> operand_pointers(operand_count);
    std::vector<size_t> operand_sizes(operand_count);
@@ -432,21 +444,23 @@ struct rocksdb_slicetransform_t : public SliceTransform {
      void*,
      const char* key, size_t length);

-  ~rocksdb_slicetransform_t() override { (*destructor_)(state_); }
+  virtual ~rocksdb_slicetransform_t() {
+    (*destructor_)(state_);
+  }

-  const char* Name() const override { return (*name_)(state_); }
+  virtual const char* Name() const override { return (*name_)(state_); }

-  Slice Transform(const Slice& src) const override {
+  virtual Slice Transform(const Slice& src) const override {
    size_t len;
    char* dst = (*transform_)(state_, src.data(), src.size(), &len);
    return Slice(dst, len);
  }

-  bool InDomain(const Slice& src) const override {
+  virtual bool InDomain(const Slice& src) const override {
    return (*in_domain_)(state_, src.data(), src.size());
  }

-  bool InRange(const Slice& src) const override {
+  virtual bool InRange(const Slice& src) const override {
    return (*in_range_)(state_, src.data(), src.size());
  }
 };
@@ -1481,10 +1495,10 @@ class H : public WriteBatch::Handler {
  void* state_;
  void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen);
  void (*deleted_)(void*, const char* k, size_t klen);
-  void Put(const Slice& key, const Slice& value) override {
+  virtual void Put(const Slice& key, const Slice& value) override {
    (*put_)(state_, key.data(), key.size(), value.data(), value.size());
  }
-  void Delete(const Slice& key) override {
+  virtual void Delete(const Slice& key) override {
    (*deleted_)(state_, key.data(), key.size());
  }
 };
@@ -2852,7 +2866,7 @@ rocksdb_compactionfilter_t* rocksdb_compactionfilter_create(
  result->state_ = state;
  result->destructor_ = destructor;
  result->filter_ = filter;
-  result->ignore_snapshots_ = true;
+  result->ignore_snapshots_ = false;
  result->name_ = name;
  return result;
 }
@@ -2952,7 +2966,7 @@ rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_format(int bits_per_ke
  // supplied C functions.
  struct Wrapper : public rocksdb_filterpolicy_t {
    const FilterPolicy* rep_;
-    ~Wrapper() override { delete rep_; }
+    ~Wrapper() { delete rep_; }
    const char* Name() const override { return rep_->Name(); }
    void CreateFilter(const Slice* keys, int n,
                      std::string* dst) const override {
@@ -3407,7 +3421,7 @@ void rocksdb_slicetransform_destroy(rocksdb_slicetransform_t* st) {

 struct Wrapper : public rocksdb_slicetransform_t {
  const SliceTransform* rep_;
-  ~Wrapper() override { delete rep_; }
+  ~Wrapper() { delete rep_; }
  const char* Name() const override { return rep_->Name(); }
  Slice Transform(const Slice& src) const override {
    return rep_->Transform(src);
@@ -3702,38 +3716,6 @@ rocksdb_transactiondb_t* rocksdb_transactiondb_open(
  return result;
 }

-rocksdb_transactiondb_t* rocksdb_transactiondb_open_column_families(
-    const rocksdb_options_t* options,
-    const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
-    int num_column_families, const char** column_family_names,
-    const rocksdb_options_t** column_family_options,
-    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
-  std::vector<ColumnFamilyDescriptor> column_families;
-  for (int i = 0; i < num_column_families; i++) {
-    column_families.push_back(ColumnFamilyDescriptor(
-        std::string(column_family_names[i]),
-        ColumnFamilyOptions(column_family_options[i]->rep)));
-  }
-
-  TransactionDB* txn_db;
-  std::vector<ColumnFamilyHandle*> handles;
-  if (SaveError(errptr, TransactionDB::Open(options->rep, txn_db_options->rep,
-                                            std::string(name), column_families,
-                                            &handles, &txn_db))) {
-    return nullptr;
-  }
-
-  for (size_t i = 0; i < handles.size(); i++) {
-    rocksdb_column_family_handle_t* c_handle =
-        new rocksdb_column_family_handle_t;
-    c_handle->rep = handles[i];
-    column_family_handles[i] = c_handle;
-  }
-  rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t;
-  result->rep = txn_db;
-  return result;
-}
-
 const rocksdb_snapshot_t* rocksdb_transactiondb_create_snapshot(
    rocksdb_transactiondb_t* txn_db) {
  rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
@@ -3854,26 +3836,6 @@ char* rocksdb_transaction_get_for_update(rocksdb_transaction_t* txn,
  return result;
 }

-char* rocksdb_transaction_get_for_update_cf(
-    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    size_t* vlen, unsigned char exclusive, char** errptr) {
-  char* result = nullptr;
-  std::string tmp;
-  Status s = txn->rep->GetForUpdate(options->rep, column_family->rep,
-                                    Slice(key, klen), &tmp, exclusive);
-  if (s.ok()) {
-    *vlen = tmp.size();
-    result = CopyString(tmp);
-  } else {
-    *vlen = 0;
-    if (!s.IsNotFound()) {
-      SaveError(errptr, s);
-    }
-  }
-  return result;
-}
-
 // Read a key outside a transaction
 char* rocksdb_transactiondb_get(
    rocksdb_transactiondb_t* txn_db,
@@ -3966,14 +3928,6 @@ void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key,
  SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen)));
 }

-void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn,
-                                  rocksdb_column_family_handle_t* column_family,
-                                  const char* key, size_t klen, const char* val,
-                                  size_t vlen, char** errptr) {
-  SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen),
-                                    Slice(val, vlen)));
-}
-
 // Merge a key outside a transaction
 void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db,
                                 const rocksdb_writeoptions_t* options,
@@ -3983,14 +3937,6 @@ void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db,
                                       Slice(val, vlen)));
 }

-void rocksdb_transactiondb_merge_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    const char* val, size_t vlen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Merge(options->rep, column_family->rep,
-                                       Slice(key, klen), Slice(val, vlen)));
-}
-
 // Delete a key inside a transaction
 void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key,
                                size_t klen, char** errptr) {
@@ -4043,14 +3989,6 @@ rocksdb_iterator_t* rocksdb_transactiondb_create_iterator(
  return result;
 }

-rocksdb_iterator_t* rocksdb_transactiondb_create_iterator_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family) {
-  rocksdb_iterator_t* result = new rocksdb_iterator_t;
-  result->rep = txn_db->rep->NewIterator(options->rep, column_family->rep);
-  return result;
-}
-
 void rocksdb_transactiondb_close(rocksdb_transactiondb_t* txn_db) {
  delete txn_db->rep;
  delete txn_db;
@@ -68,14 +68,7 @@ ColumnFamilyHandleImpl::~ColumnFamilyHandleImpl() {
    db_->FindObsoleteFiles(&job_context, false, true);
    mutex_->Unlock();
    if (job_context.HaveSomethingToDelete()) {
-      bool defer_purge =
-          db_->immutable_db_options().avoid_unnecessary_blocking_io;
-      db_->PurgeObsoleteFiles(job_context, defer_purge);
-      if (defer_purge) {
-        mutex_->Lock();
-        db_->SchedulePurge();
-        mutex_->Unlock();
-      }
+      db_->PurgeObsoleteFiles(job_context);
    }
    job_context.Clean();
  }
@@ -14,7 +14,6 @@

 #include "db/db_impl.h"
 #include "db/db_test_util.h"
-#include "memtable/hash_skiplist_rep.h"
 #include "options/options_parser.h"
 #include "port/port.h"
 #include "rocksdb/db.h"
@@ -69,7 +68,7 @@ class ColumnFamilyTestBase : public testing::Test {
    DestroyDB(dbname_, Options(db_options_, column_family_options_));
  }

-  ~ColumnFamilyTestBase() override {
+  virtual ~ColumnFamilyTestBase() {
    std::vector<ColumnFamilyDescriptor> column_families;
    for (auto h : handles_) {
      ColumnFamilyDescriptor cfdescriptor;
@@ -1207,32 +1206,29 @@ TEST_P(ColumnFamilyTest, DifferentWriteBufferSizes) {
 }
 #endif  // !ROCKSDB_LITE

-// The test is commented out because we want to test that snapshot is
-// not created for memtables not supported it, but There isn't a memtable
-// that doesn't support snapshot right now. If we have one later, we can
-// re-enable the test.
-//
-// #ifndef ROCKSDB_LITE  // Cuckoo is not supported in lite
-//   TEST_P(ColumnFamilyTest, MemtableNotSupportSnapshot) {
-//   db_options_.allow_concurrent_memtable_write = false;
-//   Open();
-//   auto* s1 = dbfull()->GetSnapshot();
-//   ASSERT_TRUE(s1 != nullptr);
-//   dbfull()->ReleaseSnapshot(s1);
+#ifndef ROCKSDB_LITE  // Cuckoo is not supported in lite
+TEST_P(ColumnFamilyTest, MemtableNotSupportSnapshot) {
+  db_options_.allow_concurrent_memtable_write = false;
+  Open();
+  auto* s1 = dbfull()->GetSnapshot();
+  ASSERT_TRUE(s1 != nullptr);
+  dbfull()->ReleaseSnapshot(s1);

-//   // Add a column family that doesn't support snapshot
-//   ColumnFamilyOptions first;
-//   first.memtable_factory.reset(new DummyMemtableNotSupportingSnapshot());
-//   CreateColumnFamilies({"first"}, {first});
-//   auto* s2 = dbfull()->GetSnapshot();
-//   ASSERT_TRUE(s2 == nullptr);
+  // Add a column family that doesn't support snapshot
+  ColumnFamilyOptions first;
+  first.memtable_factory.reset(NewHashCuckooRepFactory(1024 * 1024));
+  CreateColumnFamilies({"first"}, {first});
+  auto* s2 = dbfull()->GetSnapshot();
+  ASSERT_TRUE(s2 == nullptr);

-//   // Add a column family that supports snapshot. Snapshot stays not
-//   supported. ColumnFamilyOptions second; CreateColumnFamilies({"second"},
-//   {second}); auto* s3 = dbfull()->GetSnapshot(); ASSERT_TRUE(s3 == nullptr);
-//   Close();
-// }
-// #endif  // !ROCKSDB_LITE
+  // Add a column family that supports snapshot. Snapshot stays not supported.
+  ColumnFamilyOptions second;
+  CreateColumnFamilies({"second"}, {second});
+  auto* s3 = dbfull()->GetSnapshot();
+  ASSERT_TRUE(s3 == nullptr);
+  Close();
+}
+#endif  // !ROCKSDB_LITE

 class TestComparator : public Comparator {
  int Compare(const rocksdb::Slice& /*a*/,
@@ -35,9 +35,9 @@ class CompactFilesTest : public testing::Test {
 class FlushedFileCollector : public EventListener {
 public:
  FlushedFileCollector() {}
-  ~FlushedFileCollector() override {}
+  ~FlushedFileCollector() {}

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

-    const char* Name() const override { return "FilterWithGet"; }
+    virtual const char* Name() const override { return "FilterWithGet"; }

   private:
    DB* db_;
@@ -250,12 +250,6 @@ Compaction::Compaction(VersionStorageInfo* vstorage,
  if (max_subcompactions_ == 0) {
    max_subcompactions_ = immutable_cf_options_.max_subcompactions;
  }
-  if (!bottommost_level_) {
-    // Currently we only enable dictionary compression during compaction to the
-    // bottommost level.
-    output_compression_opts_.max_dict_bytes = 0;
-    output_compression_opts_.zstd_max_train_bytes = 0;
-  }

 #ifndef NDEBUG
  for (size_t i = 1; i < inputs_.size(); ++i) {
@@ -72,6 +72,7 @@ CompactionIterator::CompactionIterator(
      compaction_filter_(compaction_filter),
      shutting_down_(shutting_down),
      preserve_deletes_seqnum_(preserve_deletes_seqnum),
+      ignore_snapshots_(false),
      current_user_key_sequence_(0),
      current_user_key_snapshot_(0),
      merge_out_iter_(merge_helper_),
@@ -101,6 +102,13 @@ CompactionIterator::CompactionIterator(
    assert(snapshots_->at(i - 1) < snapshots_->at(i));
  }
 #endif
+  if (compaction_filter_ != nullptr) {
+    if (compaction_filter_->IgnoreSnapshots()) {
+      ignore_snapshots_ = true;
+    }
+  } else {
+    ignore_snapshots_ = false;
+  }
  input_->SetPinnedItersMgr(&pinned_iters_mgr_);
  TEST_SYNC_POINT_CALLBACK("CompactionIterator:AfterInit", compaction_.get());
 }
@@ -172,7 +180,9 @@ void CompactionIterator::Next() {
 void CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
                                              Slice* skip_until) {
  if (compaction_filter_ != nullptr &&
-      (ikey_.type == kTypeValue || ikey_.type == kTypeBlobIndex)) {
+      (ikey_.type == kTypeValue || ikey_.type == kTypeBlobIndex) &&
+      (visible_at_tip_ || ignore_snapshots_ ||
+       DEFINITELY_NOT_IN_SNAPSHOT(ikey_.sequence, latest_snapshot_))) {
    // If the user has specified a compaction filter and the sequence
    // number is greater than any external snapshot, then invoke the
    // filter. If the return value of the compaction filter is true,
@@ -482,14 +492,11 @@ void CompactionIterator::NextFromInput() {
      // this value, and findEarliestVisibleSnapshot returns the next snapshot
      // as current_user_key_snapshot. In this case last value and current
      // value are both in current_user_key_snapshot currently.
-      // Although last_snapshot is released we might still get a definitive
-      // response when key sequence number changes, e.g., when seq is determined
-      // too old and visible in all snapshots.
      assert(last_snapshot == current_user_key_snapshot_ ||
             (snapshot_checker_ != nullptr &&
              snapshot_checker_->CheckInSnapshot(current_user_key_sequence_,
-                                                 last_snapshot) !=
-                  SnapshotCheckerResult::kNotInSnapshot));
+                                                 last_snapshot) ==
+                  SnapshotCheckerResult::kSnapshotReleased));

      ++iter_stats_.num_record_drop_hidden;  // (A)
      input_->Next();
@@ -627,7 +634,8 @@ void CompactionIterator::PrepareOutput() {
  // KeyNotExistsBeyondOutputLevel() return true?
  if ((compaction_ != nullptr && !compaction_->allow_ingest_behind()) &&
      ikeyNotNeededForIncrementalSnapshot() && bottommost_level_ && valid_ &&
-      IN_EARLIEST_SNAPSHOT(ikey_.sequence) && ikey_.type != kTypeMerge) {
+      IN_EARLIEST_SNAPSHOT(ikey_.sequence) && ikey_.type != kTypeMerge &&
+      !cmp_->Equal(compaction_->GetLargestUserKey(), ikey_.user_key)) {
    assert(ikey_.type != kTypeDeletion && ikey_.type != kTypeSingleDeletion);
    ikey_.sequence = 0;
    current_key_.UpdateInternalKey(0, ikey_.type);
@@ -168,6 +168,8 @@ class CompactionIterator {
  SequenceNumber earliest_snapshot_;
  SequenceNumber latest_snapshot_;

+  bool ignore_snapshots_;
+
  // State
  //
  // Points to a copy of the current compaction iterator output (current_key_)
@@ -112,39 +112,39 @@ class LoggingForwardVectorIterator : public InternalIterator {
    assert(keys_.size() == values_.size());
  }

-  bool Valid() const override { return current_ < keys_.size(); }
+  virtual bool Valid() const override { return current_ < keys_.size(); }

-  void SeekToFirst() override {
+  virtual void SeekToFirst() override {
    log.emplace_back(Action::Type::SEEK_TO_FIRST);
    current_ = 0;
  }
-  void SeekToLast() override { assert(false); }
+  virtual void SeekToLast() override { assert(false); }

-  void Seek(const Slice& target) override {
+  virtual void Seek(const Slice& target) override {
    log.emplace_back(Action::Type::SEEK, target.ToString());
    current_ = std::lower_bound(keys_.begin(), keys_.end(), target.ToString()) -
               keys_.begin();
  }

-  void SeekForPrev(const Slice& /*target*/) override { assert(false); }
+  virtual void SeekForPrev(const Slice& /*target*/) override { assert(false); }

-  void Next() override {
+  virtual void Next() override {
    assert(Valid());
    log.emplace_back(Action::Type::NEXT);
    current_++;
  }
-  void Prev() override { assert(false); }
+  virtual void Prev() override { assert(false); }

-  Slice key() const override {
+  virtual Slice key() const override {
    assert(Valid());
    return Slice(keys_[current_]);
  }
-  Slice value() const override {
+  virtual Slice value() const override {
    assert(Valid());
    return Slice(values_[current_]);
  }

-  Status status() const override { return Status::OK(); }
+  virtual Status status() const override { return Status::OK(); }

  std::vector<Action> log;

@@ -158,20 +158,22 @@ class FakeCompaction : public CompactionIterator::CompactionProxy {
 public:
  FakeCompaction() = default;

-  int level(size_t /*compaction_input_level*/) const override { return 0; }
-  bool KeyNotExistsBeyondOutputLevel(
+  virtual int level(size_t /*compaction_input_level*/) const override {
+    return 0;
+  }
+  virtual bool KeyNotExistsBeyondOutputLevel(
      const Slice& /*user_key*/,
      std::vector<size_t>* /*level_ptrs*/) const override {
    return is_bottommost_level || key_not_exists_beyond_output_level;
  }
-  bool bottommost_level() const override { return is_bottommost_level; }
-  int number_levels() const override { return 1; }
-  Slice GetLargestUserKey() const override {
+  virtual bool bottommost_level() const override { return is_bottommost_level; }
+  virtual int number_levels() const override { return 1; }
+  virtual Slice GetLargestUserKey() const override {
    return "\xff\xff\xff\xff\xff\xff\xff\xff\xff";
  }
-  bool allow_ingest_behind() const override { return false; }
+  virtual bool allow_ingest_behind() const override { return false; }

-  bool preserve_deletes() const override { return false; }
+  virtual bool preserve_deletes() const override { return false; }

  bool key_not_exists_beyond_output_level = false;

@@ -375,9 +377,10 @@ TEST_P(CompactionIteratorTest, RangeDeletionWithSnapshots) {

 TEST_P(CompactionIteratorTest, CompactionFilterSkipUntil) {
  class Filter : public CompactionFilter {
-    Decision FilterV2(int /*level*/, const Slice& key, ValueType t,
-                      const Slice& existing_value, std::string* /*new_value*/,
-                      std::string* skip_until) const override {
+    virtual Decision FilterV2(int /*level*/, const Slice& key, ValueType t,
+                              const Slice& existing_value,
+                              std::string* /*new_value*/,
+                              std::string* skip_until) const override {
      std::string k = key.ToString();
      std::string v = existing_value.ToString();
      // See InitIterators() call below for the sequence of keys and their
@@ -557,9 +560,10 @@ TEST_P(CompactionIteratorTest, ShuttingDownInMerge) {

 TEST_P(CompactionIteratorTest, SingleMergeOperand) {
  class Filter : public CompactionFilter {
-    Decision FilterV2(int /*level*/, const Slice& key, ValueType t,
-                      const Slice& existing_value, std::string* /*new_value*/,
-                      std::string* /*skip_until*/) const override {
+    virtual Decision FilterV2(int /*level*/, const Slice& key, ValueType t,
+                              const Slice& existing_value,
+                              std::string* /*new_value*/,
+                              std::string* /*skip_until*/) const override {
      std::string k = key.ToString();
      std::string v = existing_value.ToString();

@@ -157,6 +157,7 @@ struct CompactionJob::SubcompactionState {
  uint64_t overlapped_bytes = 0;
  // A flag determine whether the key has been seen in ShouldStopBefore()
  bool seen_key = false;
+  std::string compression_dict;

  SubcompactionState(Compaction* c, Slice* _start, Slice* _end,
                     uint64_t size = 0)
@@ -172,7 +173,8 @@ struct CompactionJob::SubcompactionState {
        approx_size(size),
        grandparent_index(0),
        overlapped_bytes(0),
-        seen_key(false) {
+        seen_key(false),
+        compression_dict() {
    assert(compaction != nullptr);
  }

@@ -195,6 +197,7 @@ struct CompactionJob::SubcompactionState {
    grandparent_index = std::move(o.grandparent_index);
    overlapped_bytes = std::move(o.overlapped_bytes);
    seen_key = std::move(o.seen_key);
+    compression_dict = std::move(o.compression_dict);
    return *this;
  }

@@ -312,8 +315,7 @@ CompactionJob::CompactionJob(
    SequenceNumber earliest_write_conflict_snapshot,
    const SnapshotChecker* snapshot_checker, std::shared_ptr<Cache> table_cache,
    EventLogger* event_logger, bool paranoid_file_checks, bool measure_io_stats,
-    const std::string& dbname, CompactionJobStats* compaction_job_stats,
-    Env::Priority thread_pri)
+    const std::string& dbname, CompactionJobStats* compaction_job_stats)
    : job_id_(job_id),
      compact_(new CompactionState(compaction)),
      compaction_job_stats_(compaction_job_stats),
@@ -341,8 +343,7 @@ CompactionJob::CompactionJob(
      bottommost_level_(false),
      paranoid_file_checks_(paranoid_file_checks),
      measure_io_stats_(measure_io_stats),
-      write_hint_(Env::WLTH_NOT_SET),
-      thread_pri_(thread_pri) {
+      write_hint_(Env::WLTH_NOT_SET) {
  assert(log_buffer_ != nullptr);
  const auto* cfd = compact_->compaction->column_family_data();
  ThreadStatusUtil::SetColumnFamily(cfd, cfd->ioptions()->env,
@@ -416,10 +417,11 @@ void CompactionJob::Prepare() {
  bottommost_level_ = c->bottommost_level();

  if (c->ShouldFormSubcompactions()) {
-    {
-      StopWatch sw(env_, stats_, SUBCOMPACTION_SETUP_TIME);
-      GenSubcompactionBoundaries();
-    }
+    const uint64_t start_micros = env_->NowMicros();
+    GenSubcompactionBoundaries();
+    MeasureTime(stats_, SUBCOMPACTION_SETUP_TIME,
+                env_->NowMicros() - start_micros);
+
    assert(sizes_.size() == boundaries_.size() + 1);

    for (size_t i = 0; i <= boundaries_.size(); i++) {
@@ -427,8 +429,8 @@ void CompactionJob::Prepare() {
      Slice* end = i == boundaries_.size() ? nullptr : &boundaries_[i];
      compact_->sub_compact_states.emplace_back(c, start, end, sizes_[i]);
    }
-    RecordInHistogram(stats_, NUM_SUBCOMPACTIONS_SCHEDULED,
-                      compact_->sub_compact_states.size());
+    MeasureTime(stats_, NUM_SUBCOMPACTIONS_SCHEDULED,
+                compact_->sub_compact_states.size());
  } else {
    compact_->sub_compact_states.emplace_back(c, nullptr, nullptr);
  }
@@ -608,9 +610,8 @@ Status CompactionJob::Run() {
        compact_->sub_compact_states[i].compaction_job_stats.cpu_micros;
  }

-  RecordTimeToHistogram(stats_, COMPACTION_TIME, compaction_stats_.micros);
-  RecordTimeToHistogram(stats_, COMPACTION_CPU_TIME,
-                        compaction_stats_.cpu_micros);
+  MeasureTime(stats_, COMPACTION_TIME, compaction_stats_.micros);
+  MeasureTime(stats_, COMPACTION_CPU_TIME, compaction_stats_.cpu_micros);

  TEST_SYNC_POINT("CompactionJob::Run:BeforeVerify");

@@ -719,7 +720,7 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
  Status status = compact_->status;
  ColumnFamilyData* cfd = compact_->compaction->column_family_data();
  cfd->internal_stats()->AddCompactionStats(
-      compact_->compaction->output_level(), thread_pri_, compaction_stats_);
+      compact_->compaction->output_level(), compaction_stats_);

  if (status.ok()) {
    status = InstallCompactionResults(mutable_cf_options);
@@ -815,24 +816,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  uint64_t prev_cpu_micros = env_->NowCPUNanos() / 1000;

  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
-
-  // Create compaction filter and fail the compaction if
-  // IgnoreSnapshots() = false because it is not supported anymore
-  const CompactionFilter* compaction_filter =
-      cfd->ioptions()->compaction_filter;
-  std::unique_ptr<CompactionFilter> compaction_filter_from_factory = nullptr;
-  if (compaction_filter == nullptr) {
-    compaction_filter_from_factory =
-        sub_compact->compaction->CreateCompactionFilter();
-    compaction_filter = compaction_filter_from_factory.get();
-  }
-  if (compaction_filter != nullptr && !compaction_filter->IgnoreSnapshots()) {
-    sub_compact->status = Status::NotSupported(
-        "CompactionFilter::IgnoreSnapshots() = false is not supported "
-        "anymore.");
-    return;
-  }
-
  CompactionRangeDelAggregator range_del_agg(&cfd->internal_comparator(),
                                             existing_snapshots_);

@@ -864,6 +847,49 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    prev_cpu_read_nanos = IOSTATS(cpu_read_nanos);
  }

+  const MutableCFOptions* mutable_cf_options =
+      sub_compact->compaction->mutable_cf_options();
+
+  // To build compression dictionary, we sample the first output file, assuming
+  // it'll reach the maximum length. We optionally pass these samples through
+  // zstd's dictionary trainer, or just use them directly. Then, the dictionary
+  // is used for compressing subsequent output files in the same subcompaction.
+  const bool kUseZstdTrainer =
+      sub_compact->compaction->output_compression_opts().zstd_max_train_bytes >
+      0;
+  const size_t kSampleBytes =
+      kUseZstdTrainer
+          ? sub_compact->compaction->output_compression_opts()
+                .zstd_max_train_bytes
+          : sub_compact->compaction->output_compression_opts().max_dict_bytes;
+  const int kSampleLenShift = 6;  // 2^6 = 64-byte samples
+  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));
+    if (kOutFileLen != port::kMaxSizet) {
+      const size_t kOutFileNumSamples = kOutFileLen >> kSampleLenShift;
+      Random64 generator{versions_->NewFileNumber()};
+      for (size_t i = 0; i < kMaxSamples; ++i) {
+        sample_begin_offsets.insert(
+            static_cast<size_t>(generator.Uniform(kOutFileNumSamples))
+            << kSampleLenShift);
+      }
+    }
+  }
+
+  auto compaction_filter = cfd->ioptions()->compaction_filter;
+  std::unique_ptr<CompactionFilter> compaction_filter_from_factory = nullptr;
+  if (compaction_filter == nullptr) {
+    compaction_filter_from_factory =
+        sub_compact->compaction->CreateCompactionFilter();
+    compaction_filter = compaction_filter_from_factory.get();
+  }
  MergeHelper merge(
      env_, cfd->user_comparator(), cfd->ioptions()->merge_operator,
      compaction_filter, db_options_.info_log.get(),
@@ -901,6 +927,12 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
                                  sub_compact->current_output_file_size);
  }
  const auto& c_iter_stats = c_iter->iter_stats();
+  auto sample_begin_offset_iter = sample_begin_offsets.cbegin();
+  // data_begin_offset and dict_sample_data are only valid while generating
+  // dictionary from the first output file.
+  size_t data_begin_offset = 0;
+  std::string dict_sample_data;
+  dict_sample_data.reserve(kSampleBytes);

  while (status.ok() && !cfd->IsDropped() && c_iter->Valid()) {
    // Invariant: c_iter.status() is guaranteed to be OK if c_iter->Valid()
@@ -936,6 +968,55 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
        key, c_iter->ikey().sequence);
    sub_compact->num_output_records++;

+    if (sub_compact->outputs.size() == 1) {  // first output file
+      // Check if this key/value overlaps any sample intervals; if so, appends
+      // overlapping portions to the dictionary.
+      for (const auto& data_elmt : {key, value}) {
+        size_t data_end_offset = data_begin_offset + data_elmt.size();
+        while (sample_begin_offset_iter != sample_begin_offsets.cend() &&
+               *sample_begin_offset_iter < data_end_offset) {
+          size_t sample_end_offset =
+              *sample_begin_offset_iter + (1 << kSampleLenShift);
+          // Invariant: Because we advance sample iterator while processing the
+          // data_elmt containing the sample's last byte, the current sample
+          // cannot end before the current data_elmt.
+          assert(data_begin_offset < sample_end_offset);
+
+          size_t data_elmt_copy_offset, data_elmt_copy_len;
+          if (*sample_begin_offset_iter <= data_begin_offset) {
+            // The sample starts before data_elmt starts, so take bytes starting
+            // at the beginning of data_elmt.
+            data_elmt_copy_offset = 0;
+          } else {
+            // data_elmt starts before the sample starts, so take bytes starting
+            // at the below offset into data_elmt.
+            data_elmt_copy_offset =
+                *sample_begin_offset_iter - data_begin_offset;
+          }
+          if (sample_end_offset <= data_end_offset) {
+            // The sample ends before data_elmt ends, so take as many bytes as
+            // needed.
+            data_elmt_copy_len =
+                sample_end_offset - (data_begin_offset + data_elmt_copy_offset);
+          } else {
+            // data_elmt ends before the sample ends, so take all remaining
+            // bytes in data_elmt.
+            data_elmt_copy_len =
+                data_end_offset - (data_begin_offset + data_elmt_copy_offset);
+          }
+          dict_sample_data.append(&data_elmt.data()[data_elmt_copy_offset],
+                                  data_elmt_copy_len);
+          if (sample_end_offset > data_end_offset) {
+            // Didn't finish sample. Try to finish it with the next data_elmt.
+            break;
+          }
+          // Next sample may require bytes from same data_elmt.
+          sample_begin_offset_iter++;
+        }
+        data_begin_offset = data_end_offset;
+      }
+    }
+
    // Close output file if it is big enough. Two possibilities determine it's
    // time to close it: (1) the current key should be this file's last key, (2)
    // the next key should not be in this file.
@@ -977,6 +1058,18 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
                                     &range_del_out_stats, next_key);
      RecordDroppedKeys(range_del_out_stats,
                        &sub_compact->compaction_job_stats);
+      if (sub_compact->outputs.size() == 1) {
+        // Use samples from first output file to create dictionary for
+        // compression of subsequent files.
+        if (kUseZstdTrainer) {
+          sub_compact->compression_dict = ZSTD_TrainDictionary(
+              dict_sample_data, kSampleLenShift,
+              sub_compact->compaction->output_compression_opts()
+                  .max_dict_bytes);
+        } else {
+          sub_compact->compression_dict = std::move(dict_sample_data);
+        }
+      }
    }
  }

@@ -1135,19 +1228,10 @@ Status CompactionJob::FinishCompactionOutputFile(
      lower_bound = nullptr;
    }
    if (next_table_min_key != nullptr) {
-      // This may be the last file in the subcompaction in some cases, so we
-      // need to compare the end key of subcompaction with the next file start
-      // key. When the end key is chosen by the subcompaction, we know that
-      // it must be the biggest key in output file. Therefore, it is safe to
-      // use the smaller key as the upper bound of the output file, to ensure
-      // that there is no overlapping between different output files.
+      // This isn't the last file in the subcompaction, so extend until the next
+      // file starts.
      upper_bound_guard = ExtractUserKey(*next_table_min_key);
-      if (sub_compact->end != nullptr &&
-          ucmp->Compare(upper_bound_guard, *sub_compact->end) >= 0) {
-        upper_bound = sub_compact->end;
-      } else {
-        upper_bound = &upper_bound_guard;
-      }
+      upper_bound = &upper_bound_guard;
    } else {
      // This is the last file in the subcompaction, so extend until the
      // subcompaction ends.
@@ -1165,13 +1249,6 @@ Status CompactionJob::FinishCompactionOutputFile(
      has_overlapping_endpoints = false;
    }

-    // The end key of the subcompaction must be bigger or equal to the upper
-    // bound. If the end of subcompaction is null or the upper bound is null,
-    // it means that this file is the last file in the compaction. So there
-    // will be no overlapping between this file and others.
-    assert(sub_compact->end == nullptr ||
-           upper_bound == nullptr ||
-           ucmp->Compare(*upper_bound , *sub_compact->end) <= 0);
    auto it = range_del_agg->NewIterator(lower_bound, upper_bound,
                                         has_overlapping_endpoints);
    // Position the range tombstone output iterator. There may be tombstone
@@ -1501,11 +1578,9 @@ Status CompactionJob::OpenCompactionOutputFile(
      cfd->internal_comparator(), cfd->int_tbl_prop_collector_factories(),
      cfd->GetID(), cfd->GetName(), sub_compact->outfile.get(),
      sub_compact->compaction->output_compression(),
-      0 /*sample_for_compression */,
      sub_compact->compaction->output_compression_opts(),
-      sub_compact->compaction->output_level(), skip_filters,
-      output_file_creation_time, 0 /* oldest_key_time */,
-      sub_compact->compaction->max_output_file_size()));
+      sub_compact->compaction->output_level(), &sub_compact->compression_dict,
+      skip_filters, output_file_creation_time));
  LogFlush(db_options_.info_log);
  return s;
 }
@@ -62,17 +62,17 @@ class CompactionJob {
                const EnvOptions env_options, VersionSet* versions,
                const std::atomic<bool>* shutting_down,
                const SequenceNumber preserve_deletes_seqnum,
-                LogBuffer* log_buffer, Directory* db_directory,
-                Directory* output_directory, Statistics* stats,
-                InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
+                LogBuffer* log_buffer,
+                Directory* db_directory, Directory* output_directory,
+                Statistics* stats, InstrumentedMutex* db_mutex,
+                ErrorHandler* db_error_handler,
                std::vector<SequenceNumber> existing_snapshots,
                SequenceNumber earliest_write_conflict_snapshot,
                const SnapshotChecker* snapshot_checker,
                std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
                bool paranoid_file_checks, bool measure_io_stats,
                const std::string& dbname,
-                CompactionJobStats* compaction_job_stats,
-                Env::Priority thread_pri);
+                CompactionJobStats* compaction_job_stats);

  ~CompactionJob();

@@ -172,7 +172,6 @@ class CompactionJob {
  // Stores the approx size of keys covered in the range of each subcompaction
  std::vector<uint64_t> sizes_;
  Env::WriteLifeTimeHint write_hint_;
-  Env::Priority thread_pri_;
 };

 }  // namespace rocksdb
@@ -113,7 +113,7 @@ class CompactionJobStatsTest : public testing::Test,
    Reopen(options);
  }

-  ~CompactionJobStatsTest() override {
+  ~CompactionJobStatsTest() {
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
    rocksdb::SyncPoint::GetInstance()->LoadDependency({});
    rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
@@ -426,7 +426,7 @@ class CompactionJobStatsChecker : public EventListener {
  // Once a compaction completed, this function will verify the returned
  // CompactionJobInfo with the oldest CompactionJobInfo added earlier
  // in "expected_stats_" which has not yet being used for verification.
-  void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) override {
+  virtual void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) {
    if (verify_next_comp_io_stats_) {
      ASSERT_GT(ci.stats.file_write_nanos, 0);
      ASSERT_GT(ci.stats.file_range_sync_nanos, 0);
@@ -523,7 +523,7 @@ class CompactionJobDeletionStatsChecker : public CompactionJobStatsChecker {
 public:
  // Verifies whether two CompactionJobStats match.
  void Verify(const CompactionJobStats& current_stats,
-              const CompactionJobStats& stats) override {
+              const CompactionJobStats& stats) {
    ASSERT_EQ(
      current_stats.num_input_deletion_records,
      stats.num_input_deletion_records);
@@ -172,7 +172,7 @@ class CompactionJobTest : public testing::Test {
        // This is how the key will look like once it's written in bottommost
        // file
        InternalKey bottommost_internal_key(
-            key, 0, kTypeValue);
+            key, (key == "9999") ? sequence_number : 0, kTypeValue);

        if (corrupt_id(k)) {
          test::CorruptKeyType(&internal_key);
@@ -262,8 +262,7 @@ class CompactionJobTest : public testing::Test {
        &shutting_down_, preserve_deletes_seqnum_, &log_buffer, nullptr,
        nullptr, nullptr, &mutex_, &error_handler_, snapshots,
        earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
-        &event_logger, false, false, dbname_, &compaction_job_stats_,
-        Env::Priority::USER);
+        &event_logger, false, false, dbname_, &compaction_job_stats_);
    VerifyInitializationOfCompactionJobStats(compaction_job_stats_);

    compaction_job.Prepare();
@@ -380,7 +379,7 @@ TEST_F(CompactionJobTest, SimpleOverwrite) {

  auto expected_results =
      mock::MakeMockFile({{KeyStr("a", 0U, kTypeValue), "val2"},
-                          {KeyStr("b", 0U, kTypeValue), "val3"}});
+                          {KeyStr("b", 4U, kTypeValue), "val3"}});

  SetLastSequence(4U);
  auto files = cfd_->current()->storage_info()->LevelFiles(0);
@@ -433,7 +432,7 @@ TEST_F(CompactionJobTest, SimpleMerge) {

  auto expected_results =
      mock::MakeMockFile({{KeyStr("a", 0U, kTypeValue), "3,4,5"},
-                          {KeyStr("b", 0U, kTypeValue), "1,2"}});
+                          {KeyStr("b", 2U, kTypeValue), "1,2"}});

  SetLastSequence(5U);
  auto files = cfd_->current()->storage_info()->LevelFiles(0);
@@ -457,7 +456,7 @@ TEST_F(CompactionJobTest, NonAssocMerge) {

  auto expected_results =
      mock::MakeMockFile({{KeyStr("a", 0U, kTypeValue), "3,4,5"},
-                          {KeyStr("b", 0U, kTypeValue), "1,2"}});
+                          {KeyStr("b", 2U, kTypeValue), "1,2"}});

  SetLastSequence(5U);
  auto files = cfd_->current()->storage_info()->LevelFiles(0);
@@ -484,7 +483,7 @@ TEST_F(CompactionJobTest, MergeOperandFilter) {

  auto expected_results =
      mock::MakeMockFile({{KeyStr("a", 0U, kTypeValue), test::EncodeInt(8U)},
-                          {KeyStr("b", 0U, kTypeValue), test::EncodeInt(2U)}});
+                          {KeyStr("b", 2U, kTypeValue), test::EncodeInt(2U)}});

  SetLastSequence(5U);
  auto files = cfd_->current()->storage_info()->LevelFiles(0);
@@ -747,7 +746,7 @@ TEST_F(CompactionJobTest, SingleDeleteZeroSeq) {
  AddMockFile(file2);

  auto expected_results = mock::MakeMockFile({
-      {KeyStr("dummy", 0U, kTypeValue), "val2"},
+      {KeyStr("dummy", 5U, kTypeValue), "val2"},
  });

  SetLastSequence(22U);
@@ -931,7 +930,7 @@ TEST_F(CompactionJobTest, CorruptionAfterDeletion) {
      mock::MakeMockFile({{test::KeyStr("A", 0U, kTypeValue), "val3"},
                          {test::KeyStr("a", 0U, kTypeValue, true), "val"},
                          {test::KeyStr("b", 0U, kTypeValue, true), "val"},
-                          {test::KeyStr("c", 0U, kTypeValue), "val2"}});
+                          {test::KeyStr("c", 1U, kTypeValue), "val2"}});

  SetLastSequence(6U);
  auto files = cfd_->current()->storage_info()->LevelFiles(0);
@@ -41,7 +41,7 @@ bool FIFOCompactionPicker::NeedsCompaction(
 Compaction* FIFOCompactionPicker::PickTTLCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
    VersionStorageInfo* vstorage, LogBuffer* log_buffer) {
-  assert(mutable_cf_options.ttl > 0);
+  assert(mutable_cf_options.compaction_options_fifo.ttl > 0);

  const int kLevel0 = 0;
  const std::vector<FileMetaData*>& level_files = vstorage->LevelFiles(kLevel0);
@@ -63,7 +63,7 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
  inputs[0].level = 0;

  // avoid underflow
-  if (current_time > mutable_cf_options.ttl) {
+  if (current_time > mutable_cf_options.compaction_options_fifo.ttl) {
    for (auto ritr = level_files.rbegin(); ritr != level_files.rend(); ++ritr) {
      auto f = *ritr;
      if (f->fd.table_reader != nullptr &&
@@ -71,7 +71,8 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
        auto creation_time =
            f->fd.table_reader->GetTableProperties()->creation_time;
        if (creation_time == 0 ||
-            creation_time >= (current_time - mutable_cf_options.ttl)) {
+            creation_time >= (current_time -
+                              mutable_cf_options.compaction_options_fifo.ttl)) {
          break;
        }
        total_size -= f->compensated_file_size;
@@ -200,7 +201,7 @@ Compaction* FIFOCompactionPicker::PickCompaction(
  assert(vstorage->num_levels() == 1);

  Compaction* c = nullptr;
-  if (mutable_cf_options.ttl > 0) {
+  if (mutable_cf_options.compaction_options_fifo.ttl > 0) {
    c = PickTTLCompaction(cf_name, mutable_cf_options, vstorage, log_buffer);
  }
  if (c == nullptr) {
@@ -22,7 +22,9 @@ namespace rocksdb {
 class CountingLogger : public Logger {
 public:
  using Logger::Logv;
-  void Logv(const char* /*format*/, va_list /*ap*/) override { log_count++; }
+  virtual void Logv(const char* /*format*/, va_list /*ap*/) override {
+    log_count++;
+  }
  size_t log_count;
 };

@@ -66,7 +68,8 @@ class CompactionPickerTest : public testing::Test {
                                    std::numeric_limits<uint64_t>::max());
  }

-  ~CompactionPickerTest() override {}
+  ~CompactionPickerTest() {
+  }

  void NewVersionStorage(int num_levels, CompactionStyle style) {
    DeleteVersionStorage();
@@ -395,8 +395,8 @@ Compaction* UniversalCompactionPicker::PickCompaction(
  }
 #endif
  // update statistics
-  RecordInHistogram(ioptions_.statistics, NUM_FILES_IN_SINGLE_COMPACTION,
-                    c->inputs(0)->size());
+  MeasureTime(ioptions_.statistics, NUM_FILES_IN_SINGLE_COMPACTION,
+              c->inputs(0)->size());

  RegisterCompaction(c);
  vstorage->ComputeCompactionScore(ioptions_, mutable_cf_options);
@@ -27,24 +27,24 @@ class KVIter : public Iterator {
 public:
  explicit KVIter(const stl_wrappers::KVMap* map)
      : map_(map), iter_(map_->end()) {}
-  bool Valid() const override { return iter_ != map_->end(); }
-  void SeekToFirst() override { iter_ = map_->begin(); }
-  void SeekToLast() override {
+  virtual bool Valid() const override { return iter_ != map_->end(); }
+  virtual void SeekToFirst() override { iter_ = map_->begin(); }
+  virtual void SeekToLast() override {
    if (map_->empty()) {
      iter_ = map_->end();
    } else {
      iter_ = map_->find(map_->rbegin()->first);
    }
  }
-  void Seek(const Slice& k) override {
+  virtual void Seek(const Slice& k) override {
    iter_ = map_->lower_bound(k.ToString());
  }
-  void SeekForPrev(const Slice& k) override {
+  virtual void SeekForPrev(const Slice& k) override {
    iter_ = map_->upper_bound(k.ToString());
    Prev();
  }
-  void Next() override { ++iter_; }
-  void Prev() override {
+  virtual void Next() override { ++iter_; }
+  virtual void Prev() override {
    if (iter_ == map_->begin()) {
      iter_ = map_->end();
      return;
@@ -52,9 +52,9 @@ class KVIter : public Iterator {
    --iter_;
  }

-  Slice key() const override { return iter_->first; }
-  Slice value() const override { return iter_->second; }
-  Status status() const override { return Status::OK(); }
+  virtual Slice key() const override { return iter_->first; }
+  virtual Slice value() const override { return iter_->second; }
+  virtual Status status() const override { return Status::OK(); }

 private:
  const stl_wrappers::KVMap* const map_;
@@ -171,9 +171,9 @@ class DoubleComparator : public Comparator {
 public:
  DoubleComparator() {}

-  const char* Name() const override { return "DoubleComparator"; }
+  virtual const char* Name() const override { return "DoubleComparator"; }

-  int Compare(const Slice& a, const Slice& b) const override {
+  virtual int Compare(const Slice& a, const Slice& b) const override {
 #ifndef CYGWIN
    double da = std::stod(a.ToString());
    double db = std::stod(b.ToString());
@@ -189,19 +189,19 @@ class DoubleComparator : public Comparator {
      return -1;
    }
  }
-  void FindShortestSeparator(std::string* /*start*/,
-                             const Slice& /*limit*/) const override {}
+  virtual void FindShortestSeparator(std::string* /*start*/,
+                                     const Slice& /*limit*/) const override {}

-  void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
 };

 class HashComparator : public Comparator {
 public:
  HashComparator() {}

-  const char* Name() const override { return "HashComparator"; }
+  virtual const char* Name() const override { return "HashComparator"; }

-  int Compare(const Slice& a, const Slice& b) const override {
+  virtual int Compare(const Slice& a, const Slice& b) const override {
    uint32_t ha = Hash(a.data(), a.size(), 66);
    uint32_t hb = Hash(b.data(), b.size(), 66);
    if (ha == hb) {
@@ -212,19 +212,19 @@ class HashComparator : public Comparator {
      return -1;
    }
  }
-  void FindShortestSeparator(std::string* /*start*/,
-                             const Slice& /*limit*/) const override {}
+  virtual void FindShortestSeparator(std::string* /*start*/,
+                                     const Slice& /*limit*/) const override {}

-  void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
 };

 class TwoStrComparator : public Comparator {
 public:
  TwoStrComparator() {}

-  const char* Name() const override { return "TwoStrComparator"; }
+  virtual const char* Name() const override { return "TwoStrComparator"; }

-  int Compare(const Slice& a, const Slice& b) const override {
+  virtual int Compare(const Slice& a, const Slice& b) const override {
    assert(a.size() >= 2);
    assert(b.size() >= 2);
    size_t size_a1 = static_cast<size_t>(a[0]);
@@ -244,10 +244,10 @@ class TwoStrComparator : public Comparator {
    }
    return a2.compare(b2);
  }
-  void FindShortestSeparator(std::string* /*start*/,
-                             const Slice& /*limit*/) const override {}
+  virtual void FindShortestSeparator(std::string* /*start*/,
+                                     const Slice& /*limit*/) const override {}

-  void FindShortSuccessor(std::string* /*key*/) const override {}
+  virtual void FindShortSuccessor(std::string* /*key*/) const override {}
 };
 }  // namespace

@@ -272,7 +272,7 @@ class ComparatorDBTest
    EXPECT_OK(DestroyDB(dbname_, last_options_));
  }

-  ~ComparatorDBTest() override {
+  ~ComparatorDBTest() {
    delete db_;
    EXPECT_OK(DestroyDB(dbname_, last_options_));
    comparator = BytewiseComparator();
@@ -62,9 +62,9 @@ class CorruptionTest : public testing::Test {
    options_.create_if_missing = false;
  }

-  ~CorruptionTest() override {
-    delete db_;
-    DestroyDB(dbname_, Options());
+  ~CorruptionTest() {
+     delete db_;
+     DestroyDB(dbname_, Options());
  }

  void CloseDb() {
@@ -31,7 +31,7 @@ class CuckooTableDBTest : public testing::Test {
    Reopen();
  }

-  ~CuckooTableDBTest() override {
+  ~CuckooTableDBTest() {
    delete db_;
    EXPECT_OK(DestroyDB(dbname_, Options()));
  }
@@ -215,11 +215,11 @@ TEST_F(DBBasicTest, PutSingleDeleteGet) {
    ASSERT_EQ("v2", Get(1, "foo2"));
    ASSERT_OK(SingleDelete(1, "foo"));
    ASSERT_EQ("NOT_FOUND", Get(1, "foo"));
-    // Ski FIFO and universal compaction because they do not apply to the test
-    // case. Skip MergePut because single delete does not get removed when it
-    // encounters a merge.
-  } while (ChangeOptions(kSkipFIFOCompaction | kSkipUniversalCompaction |
-                         kSkipMergePut));
+    // Skip HashCuckooRep as it does not support single delete. FIFO and
+    // universal compaction do not apply to the test case. Skip MergePut
+    // because single delete does not get removed when it encounters a merge.
+  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction |
+                         kSkipUniversalCompaction | kSkipMergePut));
 }

 TEST_F(DBBasicTest, EmptyFlush) {
@@ -237,11 +237,11 @@ TEST_F(DBBasicTest, EmptyFlush) {
    ASSERT_OK(Flush(1));

    ASSERT_EQ("[ ]", AllEntriesFor("a", 1));
-    // Skip FIFO and  universal compaction as they do not apply to the test
-    // case. Skip MergePut because merges cannot be combined with single
-    // deletions.
-  } while (ChangeOptions(kSkipFIFOCompaction | kSkipUniversalCompaction |
-                         kSkipMergePut));
+    // Skip HashCuckooRep as it does not support single delete. FIFO and
+    // universal compaction do not apply to the test case. Skip MergePut
+    // because merges cannot be combined with single deletions.
+  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction |
+                         kSkipUniversalCompaction | kSkipMergePut));
 }

 TEST_F(DBBasicTest, GetFromVersions) {
@@ -265,6 +265,11 @@ TEST_F(DBBasicTest, GetSnapshot) {
      std::string key = (i == 0) ? std::string("foo") : std::string(200, 'x');
      ASSERT_OK(Put(1, key, "v1"));
      const Snapshot* s1 = db_->GetSnapshot();
+      if (option_config_ == kHashCuckoo) {
+        // Unsupported case.
+        ASSERT_TRUE(s1 == nullptr);
+        break;
+      }
      ASSERT_OK(Put(1, key, "v2"));
      ASSERT_EQ("v2", Get(1, key));
      ASSERT_EQ("v1", Get(1, key, s1));
@@ -505,7 +510,7 @@ TEST_F(DBBasicTest, Snapshot) {
    ASSERT_EQ(0U, GetNumSnapshots());
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
-  } while (ChangeOptions());
+  } while (ChangeOptions(kSkipHashCuckoo));
 }

 #endif  // ROCKSDB_LITE
@@ -561,7 +566,8 @@ TEST_F(DBBasicTest, CompactBetweenSnapshots) {
                           nullptr);
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ sixth ]");
-  } while (ChangeOptions(kSkipFIFOCompaction));
+    // skip HashCuckooRep as it does not support snapshot
+  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction));
 }

 TEST_F(DBBasicTest, DBOpen_Options) {
@@ -852,17 +858,18 @@ class TestEnv : public EnvWrapper {
      public:
        using Logger::Logv;
        TestLogger(TestEnv *env_ptr) : Logger() { env = env_ptr; }
-        ~TestLogger() override {
+        ~TestLogger() {
          if (!closed_) {
            CloseHelper();
          }
        }
-        void Logv(const char* /*format*/, va_list /*ap*/) override{};
+        virtual void Logv(const char* /*format*/, va_list /*ap*/) override{};

       protected:
-        Status CloseImpl() override { return CloseHelper(); }
-
-       private:
+        virtual Status CloseImpl() override {
+          return CloseHelper();
+        }
+      private:
        Status CloseHelper() {
          env->CloseCountInc();;
          return Status::IOError();
@@ -874,8 +881,8 @@ class TestEnv : public EnvWrapper {

    int GetCloseCount() { return close_count; }

-    Status NewLogger(const std::string& /*fname*/,
-                     std::shared_ptr<Logger>* result) override {
+    virtual Status NewLogger(const std::string& /*fname*/,
+                             std::shared_ptr<Logger>* result) {
      result->reset(new TestLogger(this));
      return Status::OK();
    }
@@ -395,9 +395,9 @@ class MockCache : public LRUCache {
                 false /*strict_capacity_limit*/, 0.0 /*high_pri_pool_ratio*/) {
  }

-  Status Insert(const Slice& key, void* value, size_t charge,
-                void (*deleter)(const Slice& key, void* value), Handle** handle,
-                Priority priority) override {
+  virtual Status Insert(const Slice& key, void* value, size_t charge,
+                        void (*deleter)(const Slice& key, void* value),
+                        Handle** handle, Priority priority) override {
    if (priority == Priority::LOW) {
      low_pri_insert_count++;
    } else {
@@ -633,7 +633,7 @@ TEST_F(DBBlockCacheTest, CompressedCache) {

 TEST_F(DBBlockCacheTest, CacheCompressionDict) {
  const int kNumFiles = 4;
-  const int kNumEntriesPerFile = 128;
+  const int kNumEntriesPerFile = 32;
  const int kNumBytesPerEntry = 1024;

  // Try all the available libraries that support dictionary compression
@@ -32,7 +32,7 @@ class DBBloomFilterTestWithParam
 public:
  DBBloomFilterTestWithParam() : DBTestBase("/db_bloom_filter_tests") {}

-  ~DBBloomFilterTestWithParam() override {}
+  ~DBBloomFilterTestWithParam() {}

  void SetUp() override {
    use_block_based_filter_ = std::get<0>(GetParam());
@@ -642,7 +642,7 @@ class WrappedBloom : public FilterPolicy {
  explicit WrappedBloom(int bits_per_key)
      : filter_(NewBloomFilterPolicy(bits_per_key)), counter_(0) {}

-  ~WrappedBloom() override { delete filter_; }
+  ~WrappedBloom() { delete filter_; }

  const char* Name() const override { return "WrappedRocksDbFilterPolicy"; }

@@ -786,56 +786,6 @@ TEST_F(DBBloomFilterTest, PrefixExtractorBlockFilter) {
  delete iter;
 }

-TEST_F(DBBloomFilterTest, MemtableWholeKeyBloomFilter) {
-  // regression test for #2743. the range delete tombstones in memtable should
-  // be added even when Get() skips searching due to its prefix bloom filter
-  const int kMemtableSize = 1 << 20;              // 1MB
-  const int kMemtablePrefixFilterSize = 1 << 13;  // 8KB
-  const int kPrefixLen = 4;
-  Options options = CurrentOptions();
-  options.memtable_prefix_bloom_size_ratio =
-      static_cast<double>(kMemtablePrefixFilterSize) / kMemtableSize;
-  options.prefix_extractor.reset(rocksdb::NewFixedPrefixTransform(kPrefixLen));
-  options.write_buffer_size = kMemtableSize;
-  options.memtable_whole_key_filtering = false;
-  Reopen(options);
-  std::string key1("AAAABBBB");
-  std::string key2("AAAACCCC");  // not in DB
-  std::string key3("AAAADDDD");
-  std::string key4("AAAAEEEE");
-  std::string value1("Value1");
-  std::string value3("Value3");
-  std::string value4("Value4");
-
-  ASSERT_OK(Put(key1, value1, WriteOptions()));
-
-  // check memtable bloom stats
-  ASSERT_EQ("NOT_FOUND", Get(key2));
-  ASSERT_EQ(0, get_perf_context()->bloom_memtable_miss_count);
-  // same prefix, bloom filter false positive
-  ASSERT_EQ(1, get_perf_context()->bloom_memtable_hit_count);
-
-  // enable whole key bloom filter
-  options.memtable_whole_key_filtering = true;
-  Reopen(options);
-  // check memtable bloom stats
-  ASSERT_OK(Put(key3, value3, WriteOptions()));
-  ASSERT_EQ("NOT_FOUND", Get(key2));
-  // whole key bloom filter kicks in and determines it's a miss
-  ASSERT_EQ(1, get_perf_context()->bloom_memtable_miss_count);
-  ASSERT_EQ(1, get_perf_context()->bloom_memtable_hit_count);
-
-  // verify whole key filtering does not depend on prefix_extractor
-  options.prefix_extractor.reset();
-  Reopen(options);
-  // check memtable bloom stats
-  ASSERT_OK(Put(key4, value4, WriteOptions()));
-  ASSERT_EQ("NOT_FOUND", Get(key2));
-  // whole key bloom filter kicks in and determines it's a miss
-  ASSERT_EQ(2, get_perf_context()->bloom_memtable_miss_count);
-  ASSERT_EQ(1, get_perf_context()->bloom_memtable_hit_count);
-}
-
 #ifndef ROCKSDB_LITE
 class BloomStatsTestWithParam
    : public DBBloomFilterTest,
@@ -873,7 +823,7 @@ class BloomStatsTestWithParam
    DestroyAndReopen(options_);
  }

-  ~BloomStatsTestWithParam() override {
+  ~BloomStatsTestWithParam() {
    get_perf_context()->Reset();
    Destroy(options_);
  }
@@ -63,33 +63,33 @@ INSTANTIATE_TEST_CASE_P(DBTestCompactionFilterWithCompactOption,

 class KeepFilter : public CompactionFilter {
 public:
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*value*/, std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    cfilter_count++;
    return false;
  }

-  const char* Name() const override { return "KeepFilter"; }
+  virtual const char* Name() const override { return "KeepFilter"; }
 };

 class DeleteFilter : public CompactionFilter {
 public:
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*value*/, std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    cfilter_count++;
    return true;
  }

-  const char* Name() const override { return "DeleteFilter"; }
+  virtual const char* Name() const override { return "DeleteFilter"; }
 };

 class DeleteISFilter : public CompactionFilter {
 public:
-  bool Filter(int /*level*/, const Slice& key, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& key, const Slice& /*value*/,
+                      std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    cfilter_count++;
    int i = std::stoi(key.ToString());
    if (i > 5 && i <= 105) {
@@ -98,18 +98,20 @@ class DeleteISFilter : public CompactionFilter {
    return false;
  }

-  bool IgnoreSnapshots() const override { return true; }
+  virtual bool IgnoreSnapshots() const override { return true; }

-  const char* Name() const override { return "DeleteFilter"; }
+  virtual const char* Name() const override { return "DeleteFilter"; }
 };

 // Skip x if floor(x/10) is even, use range skips. Requires that keys are
 // zero-padded to length 10.
 class SkipEvenFilter : public CompactionFilter {
 public:
-  Decision FilterV2(int /*level*/, const Slice& key, ValueType /*value_type*/,
-                    const Slice& /*existing_value*/, std::string* /*new_value*/,
-                    std::string* skip_until) const override {
+  virtual Decision FilterV2(int /*level*/, const Slice& key,
+                            ValueType /*value_type*/,
+                            const Slice& /*existing_value*/,
+                            std::string* /*new_value*/,
+                            std::string* skip_until) const override {
    cfilter_count++;
    int i = std::stoi(key.ToString());
    if (i / 10 % 2 == 0) {
@@ -122,22 +124,22 @@ class SkipEvenFilter : public CompactionFilter {
    return Decision::kKeep;
  }

-  bool IgnoreSnapshots() const override { return true; }
+  virtual bool IgnoreSnapshots() const override { return true; }

-  const char* Name() const override { return "DeleteFilter"; }
+  virtual const char* Name() const override { return "DeleteFilter"; }
 };

 class DelayFilter : public CompactionFilter {
 public:
  explicit DelayFilter(DBTestBase* d) : db_test(d) {}
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*value*/, std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    db_test->env_->addon_time_.fetch_add(1000);
    return true;
  }

-  const char* Name() const override { return "DelayFilter"; }
+  virtual const char* Name() const override { return "DelayFilter"; }

 private:
  DBTestBase* db_test;
@@ -147,13 +149,13 @@ class ConditionalFilter : public CompactionFilter {
 public:
  explicit ConditionalFilter(const std::string* filtered_value)
      : filtered_value_(filtered_value) {}
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& value,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/, const Slice& value,
+                      std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    return value.ToString() == *filtered_value_;
  }

-  const char* Name() const override { return "ConditionalFilter"; }
+  virtual const char* Name() const override { return "ConditionalFilter"; }

 private:
  const std::string* filtered_value_;
@@ -163,15 +165,16 @@ class ChangeFilter : public CompactionFilter {
 public:
  explicit ChangeFilter() {}

-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* new_value, bool* value_changed) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*value*/, std::string* new_value,
+                      bool* value_changed) const override {
    assert(new_value != nullptr);
    *new_value = NEW_VALUE;
    *value_changed = true;
    return false;
  }

-  const char* Name() const override { return "ChangeFilter"; }
+  virtual const char* Name() const override { return "ChangeFilter"; }
 };

 class KeepFilterFactory : public CompactionFilterFactory {
@@ -182,7 +185,7 @@ class KeepFilterFactory : public CompactionFilterFactory {
        check_context_cf_id_(check_context_cf_id),
        compaction_filter_created_(false) {}

-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    if (check_context_) {
      EXPECT_EQ(expect_full_compaction_.load(), context.is_full_compaction);
@@ -197,7 +200,7 @@ class KeepFilterFactory : public CompactionFilterFactory {

  bool compaction_filter_created() const { return compaction_filter_created_; }

-  const char* Name() const override { return "KeepFilterFactory"; }
+  virtual const char* Name() const override { return "KeepFilterFactory"; }
  bool check_context_;
  bool check_context_cf_id_;
  std::atomic_bool expect_full_compaction_;
@@ -208,7 +211,7 @@ class KeepFilterFactory : public CompactionFilterFactory {

 class DeleteFilterFactory : public CompactionFilterFactory {
 public:
-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    if (context.is_manual_compaction) {
      return std::unique_ptr<CompactionFilter>(new DeleteFilter());
@@ -217,13 +220,13 @@ class DeleteFilterFactory : public CompactionFilterFactory {
    }
  }

-  const char* Name() const override { return "DeleteFilterFactory"; }
+  virtual const char* Name() const override { return "DeleteFilterFactory"; }
 };

 // Delete Filter Factory which ignores snapshots
 class DeleteISFilterFactory : public CompactionFilterFactory {
 public:
-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    if (context.is_manual_compaction) {
      return std::unique_ptr<CompactionFilter>(new DeleteISFilter());
@@ -232,12 +235,12 @@ class DeleteISFilterFactory : public CompactionFilterFactory {
    }
  }

-  const char* Name() const override { return "DeleteFilterFactory"; }
+  virtual const char* Name() const override { return "DeleteFilterFactory"; }
 };

 class SkipEvenFilterFactory : public CompactionFilterFactory {
 public:
-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    if (context.is_manual_compaction) {
      return std::unique_ptr<CompactionFilter>(new SkipEvenFilter());
@@ -246,18 +249,18 @@ class SkipEvenFilterFactory : public CompactionFilterFactory {
    }
  }

-  const char* Name() const override { return "SkipEvenFilterFactory"; }
+  virtual const char* Name() const override { return "SkipEvenFilterFactory"; }
 };

 class DelayFilterFactory : public CompactionFilterFactory {
 public:
  explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {}
-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& /*context*/) override {
    return std::unique_ptr<CompactionFilter>(new DelayFilter(db_test));
  }

-  const char* Name() const override { return "DelayFilterFactory"; }
+  virtual const char* Name() const override { return "DelayFilterFactory"; }

 private:
  DBTestBase* db_test;
@@ -268,13 +271,15 @@ class ConditionalFilterFactory : public CompactionFilterFactory {
  explicit ConditionalFilterFactory(const Slice& filtered_value)
      : filtered_value_(filtered_value.ToString()) {}

-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& /*context*/) override {
    return std::unique_ptr<CompactionFilter>(
        new ConditionalFilter(&filtered_value_));
  }

-  const char* Name() const override { return "ConditionalFilterFactory"; }
+  virtual const char* Name() const override {
+    return "ConditionalFilterFactory";
+  }

 private:
  std::string filtered_value_;
@@ -284,12 +289,12 @@ class ChangeFilterFactory : public CompactionFilterFactory {
 public:
  explicit ChangeFilterFactory() {}

-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& /*context*/) override {
    return std::unique_ptr<CompactionFilter>(new ChangeFilter());
  }

-  const char* Name() const override { return "ChangeFilterFactory"; }
+  virtual const char* Name() const override { return "ChangeFilterFactory"; }
 };

 #ifndef ROCKSDB_LITE
@@ -352,7 +357,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
    }
  }
  ASSERT_EQ(total, 100000);
-  ASSERT_EQ(count, 0);
+  ASSERT_EQ(count, 1);

  // overwrite all the 100K keys once again.
  for (int i = 0; i < 100000; i++) {
@@ -659,7 +664,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextManual) {
      iter->Next();
    }
    ASSERT_EQ(total, 700);
-    ASSERT_EQ(count, 0);
+    ASSERT_EQ(count, 1);
  }
 }
 #endif  // ROCKSDB_LITE
@@ -694,7 +699,44 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextCfId) {
 }

 #ifndef ROCKSDB_LITE
-// Compaction filters aplies to all records, regardless snapshots.
+// Compaction filters should only be applied to records that are newer than the
+// latest snapshot. This test inserts records and applies a delete filter.
+TEST_F(DBTestCompactionFilter, CompactionFilterSnapshot) {
+  Options options = CurrentOptions();
+  options.compaction_filter_factory = std::make_shared<DeleteFilterFactory>();
+  options.disable_auto_compactions = true;
+  options.create_if_missing = true;
+  DestroyAndReopen(options);
+
+  // Put some data.
+  const Snapshot* snapshot = nullptr;
+  for (int table = 0; table < 4; ++table) {
+    for (int i = 0; i < 10; ++i) {
+      Put(ToString(table * 100 + i), "val");
+    }
+    Flush();
+
+    if (table == 0) {
+      snapshot = db_->GetSnapshot();
+    }
+  }
+  assert(snapshot != nullptr);
+
+  cfilter_count = 0;
+  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  // The filter should delete 10 records.
+  ASSERT_EQ(30U, cfilter_count);
+
+  // Release the snapshot and compact again -> now all records should be
+  // removed.
+  db_->ReleaseSnapshot(snapshot);
+  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  ASSERT_EQ(0U, CountLiveFiles());
+}
+
+// Compaction filters should only be applied to records that are newer than the
+// latest snapshot. However, if the compaction filter asks to ignore snapshots
+// records newer than the snapshot will also be processed
 TEST_F(DBTestCompactionFilter, CompactionFilterIgnoreSnapshot) {
  std::string five = ToString(5);
  Options options = CurrentOptions();
@@ -832,38 +874,6 @@ TEST_F(DBTestCompactionFilter, SkipUntilWithBloomFilter) {
  EXPECT_EQ("v50", val);
 }

-class TestNotSupportedFilter : public CompactionFilter {
- public:
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
-    return true;
-  }
-
-  const char* Name() const override { return "NotSupported"; }
-  bool IgnoreSnapshots() const override { return false; }
-};
-
-TEST_F(DBTestCompactionFilter, IgnoreSnapshotsFalse) {
-  Options options = CurrentOptions();
-  options.compaction_filter = new TestNotSupportedFilter();
-  DestroyAndReopen(options);
-
-  Put("a", "v10");
-  Put("z", "v20");
-  Flush();
-
-  Put("a", "v10");
-  Put("z", "v20");
-  Flush();
-
-  // Comapction should fail because IgnoreSnapshots() = false
-  EXPECT_TRUE(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr)
-                  .IsNotSupported());
-
-  delete options.compaction_filter;
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -55,9 +55,9 @@ namespace {
 class FlushedFileCollector : public EventListener {
 public:
  FlushedFileCollector() {}
-  ~FlushedFileCollector() override {}
+  ~FlushedFileCollector() {}

-  void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
+  virtual void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
    std::lock_guard<std::mutex> lock(mutex_);
    flushed_files_.push_back(info.file_path);
  }
@@ -87,23 +87,24 @@ public:
    }
  }

-  ~CompactionStatsCollector() override {}
+  ~CompactionStatsCollector() {}

-  void OnCompactionCompleted(DB* /* db */,
-                             const CompactionJobInfo& info) override {
+  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]++;
  }

-  void OnExternalFileIngested(
-      DB* /* db */, const ExternalFileIngestionInfo& /* info */) override {
+  virtual void OnExternalFileIngested(DB* /* db */,
+      const ExternalFileIngestionInfo& /* info */) override {
    int k = static_cast<int>(CompactionReason::kExternalSstIngestion);
    compaction_completed_[k]++;
  }

-  void OnFlushCompleted(DB* /* db */, const FlushJobInfo& /* info */) override {
+  virtual void OnFlushCompleted(DB* /* db */,
+      const FlushJobInfo& /* info */) override {
    int k = static_cast<int>(CompactionReason::kFlush);
    compaction_completed_[k]++;
  }
@@ -3348,7 +3349,7 @@ TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
  options.level0_file_num_compaction_trigger = kNumLevelFiles;
  // inflate it a bit to account for key/metadata overhead
  options.target_file_size_base = 120 * kNumKeysPerFile * kValueSize / 100;
-  CreateAndReopenWithCF({"one"}, options);
+  Reopen(options);

  Random rnd(301);
  const Snapshot* snapshot = nullptr;
@@ -3379,12 +3380,10 @@ TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
  // just need to bump seqnum so ReleaseSnapshot knows the newest key in the SST
  // files does not need to be preserved in case of a future snapshot.
  ASSERT_OK(Put(Key(0), "val"));
-  ASSERT_NE(kMaxSequenceNumber, dbfull()->bottommost_files_mark_threshold_);
  // release snapshot and wait for compactions to finish. Single-file
  // compactions should be triggered, which reduce the size of each bottom-level
  // file without changing file count.
  db_->ReleaseSnapshot(snapshot);
-  ASSERT_EQ(kMaxSequenceNumber, dbfull()->bottommost_files_mark_threshold_);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
        Compaction* compaction = reinterpret_cast<Compaction*>(arg);
@@ -4188,14 +4187,14 @@ class NoopMergeOperator : public MergeOperator {
 public:
  NoopMergeOperator() {}

-  bool FullMergeV2(const MergeOperationInput& /*merge_in*/,
-                   MergeOperationOutput* merge_out) const override {
+  virtual bool FullMergeV2(const MergeOperationInput& /*merge_in*/,
+                           MergeOperationOutput* merge_out) const override {
    std::string val("bar");
    merge_out->new_value = val;
    return true;
  }

-  const char* Name() const override { return "Noop"; }
+  virtual const char* Name() const override { return "Noop"; }
 };

 TEST_F(DBCompactionTest, PartialManualCompaction) {
@@ -37,7 +37,6 @@
 #include "db/external_sst_file_ingestion_job.h"
 #include "db/flush_job.h"
 #include "db/forward_iterator.h"
-#include "db/in_memory_stats_history.h"
 #include "db/job_context.h"
 #include "db/log_reader.h"
 #include "db/log_writer.h"
@@ -70,7 +69,6 @@
 #include "rocksdb/env.h"
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/statistics.h"
-#include "rocksdb/stats_history.h"
 #include "rocksdb/status.h"
 #include "rocksdb/table.h"
 #include "rocksdb/write_buffer_manager.h"
@@ -148,21 +146,18 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      immutable_db_options_(initial_db_options_),
      mutable_db_options_(initial_db_options_),
      stats_(immutable_db_options_.statistics.get()),
+      db_lock_(nullptr),
      mutex_(stats_, env_, DB_MUTEX_WAIT_MICROS,
             immutable_db_options_.use_adaptive_mutex),
-      default_cf_handle_(nullptr),
-      max_total_in_memory_state_(0),
-      env_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
-      env_options_for_compaction_(env_->OptimizeForCompactionTableWrite(
-          env_options_, immutable_db_options_)),
-      db_lock_(nullptr),
      shutting_down_(false),
      bg_cv_(&mutex_),
      logfile_number_(0),
      log_dir_synced_(false),
      log_empty_(true),
+      default_cf_handle_(nullptr),
      log_sync_cv_(&mutex_),
      total_log_size_(0),
+      max_total_in_memory_state_(0),
      is_snapshot_supported_(true),
      write_buffer_manager_(immutable_db_options_.write_buffer_manager.get()),
      write_thread_(immutable_db_options_),
@@ -189,6 +184,9 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      next_job_id_(1),
      has_unpersisted_data_(false),
      unable_to_release_oldest_log_(false),
+      env_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
+      env_options_for_compaction_(env_->OptimizeForCompactionTableWrite(
+          env_options_, immutable_db_options_)),
      num_running_ingest_file_(0),
 #ifndef ROCKSDB_LITE
      wal_manager_(immutable_db_options_, env_options_, seq_per_batch),
@@ -299,8 +297,7 @@ Status DBImpl::ResumeImpl() {
    s = Status::ShutdownInProgress();
  }
  if (s.ok() && bg_error.severity() > Status::Severity::kHardError) {
-    ROCKS_LOG_INFO(
-        immutable_db_options_.info_log,
+    ROCKS_LOG_INFO(immutable_db_options_.info_log,
        "DB resume requested but failed due to Fatal/Unrecoverable error");
    s = bg_error;
  }
@@ -371,8 +368,8 @@ Status DBImpl::ResumeImpl() {
  // Wake up any waiters - in this case, it could be the shutdown thread
  bg_cv_.SignalAll();

-  // No need to check BGError again. If something happened, event listener would
-  // be notified and the operation causing it would have failed
+  // No need to check BGError again. If something happened, event listener would be
+  // notified and the operation causing it would have failed
  return s;
 }

@@ -386,18 +383,20 @@ void DBImpl::WaitForBackgroundWork() {

 // Will lock the mutex_,  will wait for completion if wait is true
 void DBImpl::CancelAllBackgroundWork(bool wait) {
+
  ROCKS_LOG_INFO(immutable_db_options_.info_log,
                 "Shutdown: canceling all background work");

+  InstrumentedMutexLock l(&mutex_);
+  // To avoid deadlock, `thread_dump_stats_->cancel()` needs to be called
+  // before grabbing db mutex because the actual worker function
+  // `DBImpl::DumpStats()` also holds db mutex
  if (thread_dump_stats_ != nullptr) {
+    mutex_.Unlock();
    thread_dump_stats_->cancel();
+    mutex_.Lock();
    thread_dump_stats_.reset();
  }
-  if (thread_persist_stats_ != nullptr) {
-    thread_persist_stats_->cancel();
-    thread_persist_stats_.reset();
-  }
-  InstrumentedMutexLock l(&mutex_);
  if (!shutting_down_.load(std::memory_order_acquire) &&
      has_unpersisted_data_.load(std::memory_order_relaxed) &&
      !mutable_db_options_.avoid_flush_during_shutdown) {
@@ -572,7 +571,7 @@ Status DBImpl::CloseHelper() {
        immutable_db_options_.sst_file_manager.get());
    sfm->Close();
  }
-#endif  // ROCKSDB_LITE
+#endif // ROCKSDB_LITE

  if (immutable_db_options_.info_log && own_info_log_) {
    Status s = immutable_db_options_.info_log->Close();
@@ -614,14 +613,13 @@ const Status DBImpl::CreateArchivalDirectory() {
 void DBImpl::PrintStatistics() {
  auto dbstats = immutable_db_options_.statistics.get();
  if (dbstats) {
-    ROCKS_LOG_INFO(immutable_db_options_.info_log, "STATISTICS:\n %s",
+    ROCKS_LOG_WARN(immutable_db_options_.info_log, "STATISTICS:\n %s",
                   dbstats->ToString().c_str());
  }
 }

 void DBImpl::StartTimedTasks() {
  unsigned int stats_dump_period_sec = 0;
-  unsigned int stats_persist_period_sec = 0;
  {
    InstrumentedMutexLock l(&mutex_);
    stats_dump_period_sec = mutable_db_options_.stats_dump_period_sec;
@@ -632,115 +630,9 @@ void DBImpl::StartTimedTasks() {
            stats_dump_period_sec * 1000000));
      }
    }
-    stats_persist_period_sec = mutable_db_options_.stats_persist_period_sec;
-    if (stats_persist_period_sec > 0) {
-      if (!thread_persist_stats_) {
-        thread_persist_stats_.reset(new rocksdb::RepeatableThread(
-            [this]() { DBImpl::PersistStats(); }, "pst_st", env_,
-            stats_persist_period_sec * 1000000));
-      }
-    }
  }
 }

-// esitmate the total size of stats_history_
-size_t DBImpl::EstiamteStatsHistorySize() const {
-  size_t size_total =
-      sizeof(std::map<uint64_t, std::map<std::string, uint64_t>>);
-  if (stats_history_.size() == 0) return size_total;
-  size_t size_per_slice =
-      sizeof(uint64_t) + sizeof(std::map<std::string, uint64_t>);
-  // non-empty map, stats_history_.begin() guaranteed to exist
-  std::map<std::string, uint64_t> sample_slice(stats_history_.begin()->second);
-  for (const auto& pairs : sample_slice) {
-    size_per_slice +=
-        pairs.first.capacity() + sizeof(pairs.first) + sizeof(pairs.second);
-  }
-  size_total = size_per_slice * stats_history_.size();
-  return size_total;
-}
-
-void DBImpl::PersistStats() {
-  TEST_SYNC_POINT("DBImpl::PersistStats:Entry");
-#ifndef ROCKSDB_LITE
-  if (shutdown_initiated_) {
-    return;
-  }
-  uint64_t now_micros = env_->NowMicros();
-  Statistics* statistics = immutable_db_options_.statistics.get();
-  if (!statistics) {
-    return;
-  }
-  size_t stats_history_size_limit = 0;
-  {
-    InstrumentedMutexLock l(&mutex_);
-    stats_history_size_limit = mutable_db_options_.stats_history_buffer_size;
-  }
-
-  // TODO(Zhongyi): also persist immutable_db_options_.statistics
-  {
-    std::map<std::string, uint64_t> stats_map;
-    if (!statistics->getTickerMap(&stats_map)) {
-      return;
-    }
-    InstrumentedMutexLock l(&stats_history_mutex_);
-    // calculate the delta from last time
-    if (stats_slice_initialized_) {
-      std::map<std::string, uint64_t> stats_delta;
-      for (const auto& stat : stats_map) {
-        if (stats_slice_.find(stat.first) != stats_slice_.end()) {
-          stats_delta[stat.first] = stat.second - stats_slice_[stat.first];
-        }
-      }
-      stats_history_[now_micros] = stats_delta;
-    }
-    stats_slice_initialized_ = true;
-    std::swap(stats_slice_, stats_map);
-    TEST_SYNC_POINT("DBImpl::PersistStats:StatsCopied");
-
-    // delete older stats snapshots to control memory consumption
-    bool purge_needed = EstiamteStatsHistorySize() > stats_history_size_limit;
-    while (purge_needed && !stats_history_.empty()) {
-      stats_history_.erase(stats_history_.begin());
-      purge_needed = EstiamteStatsHistorySize() > stats_history_size_limit;
-    }
-  }
-  // TODO: persist stats to disk
-#endif  // !ROCKSDB_LITE
-}
-
-bool DBImpl::FindStatsByTime(uint64_t start_time, uint64_t end_time,
-                             uint64_t* new_time,
-                             std::map<std::string, uint64_t>* stats_map) {
-  assert(new_time);
-  assert(stats_map);
-  if (!new_time || !stats_map) return false;
-  // lock when search for start_time
-  {
-    InstrumentedMutexLock l(&stats_history_mutex_);
-    auto it = stats_history_.lower_bound(start_time);
-    if (it != stats_history_.end() && it->first < end_time) {
-      // make a copy for timestamp and stats_map
-      *new_time = it->first;
-      *stats_map = it->second;
-      return true;
-    } else {
-      return false;
-    }
-  }
-}
-
-Status DBImpl::GetStatsHistory(
-    uint64_t start_time, uint64_t end_time,
-    std::unique_ptr<StatsHistoryIterator>* stats_iterator) {
-  if (!stats_iterator) {
-    return Status::InvalidArgument("stats_iterator not preallocated.");
-  }
-  stats_iterator->reset(
-      new InMemoryStatsHistoryIterator(start_time, end_time, this));
-  return (*stats_iterator)->status();
-}
-
 void DBImpl::DumpStats() {
  TEST_SYNC_POINT("DBImpl::DumpStats:1");
 #ifndef ROCKSDB_LITE
@@ -773,16 +665,16 @@ void DBImpl::DumpStats() {
    }
  }
  TEST_SYNC_POINT("DBImpl::DumpStats:2");
-  ROCKS_LOG_INFO(immutable_db_options_.info_log,
+  ROCKS_LOG_WARN(immutable_db_options_.info_log,
                 "------- DUMPING STATS -------");
-  ROCKS_LOG_INFO(immutable_db_options_.info_log, "%s", stats.c_str());
+  ROCKS_LOG_WARN(immutable_db_options_.info_log, "%s", stats.c_str());
  if (immutable_db_options_.dump_malloc_stats) {
    stats.clear();
    DumpMallocStats(&stats);
    if (!stats.empty()) {
-      ROCKS_LOG_INFO(immutable_db_options_.info_log,
+      ROCKS_LOG_WARN(immutable_db_options_.info_log,
                     "------- Malloc STATS -------");
-      ROCKS_LOG_INFO(immutable_db_options_.info_log, "%s", stats.c_str());
+      ROCKS_LOG_WARN(immutable_db_options_.info_log, "%s", stats.c_str());
    }
  }
 #endif  // !ROCKSDB_LITE
@@ -913,33 +805,19 @@ Status DBImpl::SetDBOptions(
      }
      if (new_options.stats_dump_period_sec !=
          mutable_db_options_.stats_dump_period_sec) {
-        if (thread_dump_stats_) {
-          mutex_.Unlock();
-          thread_dump_stats_->cancel();
-          mutex_.Lock();
-        }
-        if (new_options.stats_dump_period_sec > 0) {
-          thread_dump_stats_.reset(new rocksdb::RepeatableThread(
-              [this]() { DBImpl::DumpStats(); }, "dump_st", env_,
-              new_options.stats_dump_period_sec * 1000000));
-        } else {
-          thread_dump_stats_.reset();
-        }
-      }
-      if (new_options.stats_persist_period_sec !=
-          mutable_db_options_.stats_persist_period_sec) {
-        if (thread_persist_stats_) {
-          mutex_.Unlock();
-          thread_persist_stats_->cancel();
-          mutex_.Lock();
-        }
-        if (new_options.stats_persist_period_sec > 0) {
-          thread_persist_stats_.reset(new rocksdb::RepeatableThread(
-              [this]() { DBImpl::PersistStats(); }, "pst_st", env_,
-              new_options.stats_persist_period_sec * 1000000));
-        } else {
-          thread_persist_stats_.reset();
-        }
+          if (thread_dump_stats_) {
+            mutex_.Unlock();
+            thread_dump_stats_->cancel();
+            mutex_.Lock();
+          }
+          if (new_options.stats_dump_period_sec > 0) {
+            thread_dump_stats_.reset(new rocksdb::RepeatableThread(
+                [this]() { DBImpl::DumpStats(); }, "dump_st", env_,
+                new_options.stats_dump_period_sec * 1000000));
+          }
+          else {
+            thread_dump_stats_.reset();
+          }
      }
      write_controller_.set_max_delayed_write_rate(
          new_options.delayed_write_rate);
@@ -1112,25 +990,6 @@ Status DBImpl::SyncWAL() {
  return status;
 }

-Status DBImpl::LockWAL() {
-  log_write_mutex_.Lock();
-  auto cur_log_writer = logs_.back().writer;
-  auto status = cur_log_writer->WriteBuffer();
-  if (!status.ok()) {
-    ROCKS_LOG_ERROR(immutable_db_options_.info_log, "WAL flush error %s",
-                    status.ToString().c_str());
-    // In case there is a fs error we should set it globally to prevent the
-    // future writes
-    WriteStatusCheck(status);
-  }
-  return status;
-}
-
-Status DBImpl::UnlockWAL() {
-  log_write_mutex_.Unlock();
-  return Status::OK();
-}
-
 void DBImpl::MarkLogsSynced(uint64_t up_to, bool synced_dir,
                            const Status& status) {
  mutex_.AssertHeld();
@@ -1332,8 +1191,7 @@ InternalIterator* DBImpl::NewInternalIterator(const ReadOptions& read_options,
    internal_iter = merge_iter_builder.Finish();
    IterState* cleanup =
        new IterState(this, &mutex_, super_version,
-                      read_options.background_purge_on_iterator_cleanup ||
-                      immutable_db_options_.avoid_unnecessary_blocking_io);
+                      read_options.background_purge_on_iterator_cleanup);
    internal_iter->RegisterCleanup(CleanupIteratorState, cleanup, nullptr);

    return internal_iter;
@@ -1393,7 +1251,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
    snapshot =
        reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)->number_;
    if (callback) {
-      snapshot = std::max(snapshot, callback->max_visible_seq());
+      snapshot = std::max(snapshot, callback->MaxUnpreparedSequenceNumber());
    }
  } else {
    // Since we get and reference the super version before getting
@@ -1461,13 +1319,10 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
    ReturnAndCleanupSuperVersion(cfd, sv);

    RecordTick(stats_, NUMBER_KEYS_READ);
-    size_t size = 0;
-    if (s.ok()) {
-      size = pinnable_val->size();
-      RecordTick(stats_, BYTES_READ, size);
-      PERF_COUNTER_ADD(get_read_bytes, size);
-    }
-    RecordInHistogram(stats_, BYTES_PER_READ, size);
+    size_t size = pinnable_val->size();
+    RecordTick(stats_, BYTES_READ, size);
+    MeasureTime(stats_, BYTES_PER_READ, size);
+    PERF_COUNTER_ADD(get_read_bytes, size);
  }
  return s;
 }
@@ -1652,7 +1507,7 @@ std::vector<Status> DBImpl::MultiGet(
  RecordTick(stats_, NUMBER_MULTIGET_KEYS_READ, num_keys);
  RecordTick(stats_, NUMBER_MULTIGET_KEYS_FOUND, num_found);
  RecordTick(stats_, NUMBER_MULTIGET_BYTES_READ, bytes_read);
-  RecordInHistogram(stats_, BYTES_PER_MULTIGET, bytes_read);
+  MeasureTime(stats_, BYTES_PER_MULTIGET, bytes_read);
  PERF_COUNTER_ADD(multiget_read_bytes, bytes_read);
  PERF_TIMER_STOP(get_post_process_time);

@@ -1959,7 +1814,7 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
  auto cfd = cfh->cfd();
  ReadCallback* read_callback = nullptr;  // No read callback provided.
-  if (read_options.tailing) {
+if (read_options.tailing) {
 #ifdef ROCKSDB_LITE
    // not supported in lite version
    result = nullptr;
@@ -2133,18 +1988,6 @@ SnapshotImpl* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary,
  return snapshot;
 }

-namespace {
-typedef autovector<ColumnFamilyData*, 2> CfdList;
-bool CfdListContains(const CfdList& list, ColumnFamilyData* cfd) {
-  for (const ColumnFamilyData* t : list) {
-    if (t == cfd) {
-      return true;
-    }
-  }
-  return false;
-}
-}  //  namespace
-
 void DBImpl::ReleaseSnapshot(const Snapshot* s) {
  const SnapshotImpl* casted_s = reinterpret_cast<const SnapshotImpl*>(s);
  {
@@ -2158,35 +2001,15 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
    } else {
      oldest_snapshot = snapshots_.oldest()->number_;
    }
-    // Avoid to go through every column family by checking a global threshold
-    // first.
-    if (oldest_snapshot > bottommost_files_mark_threshold_) {
-      CfdList cf_scheduled;
-      for (auto* cfd : *versions_->GetColumnFamilySet()) {
-        cfd->current()->storage_info()->UpdateOldestSnapshot(oldest_snapshot);
-        if (!cfd->current()
-                 ->storage_info()
-                 ->BottommostFilesMarkedForCompaction()
-                 .empty()) {
-          SchedulePendingCompaction(cfd);
-          MaybeScheduleFlushOrCompaction();
-          cf_scheduled.push_back(cfd);
-        }
+    for (auto* cfd : *versions_->GetColumnFamilySet()) {
+      cfd->current()->storage_info()->UpdateOldestSnapshot(oldest_snapshot);
+      if (!cfd->current()
+               ->storage_info()
+               ->BottommostFilesMarkedForCompaction()
+               .empty()) {
+        SchedulePendingCompaction(cfd);
+        MaybeScheduleFlushOrCompaction();
      }
-
-      // Calculate a new threshold, skipping those CFs where compactions are
-      // scheduled. We do not do the same pass as the previous loop because
-      // mutex might be unlocked during the loop, making the result inaccurate.
-      SequenceNumber new_bottommost_files_mark_threshold = kMaxSequenceNumber;
-      for (auto* cfd : *versions_->GetColumnFamilySet()) {
-        if (CfdListContains(cf_scheduled, cfd)) {
-          continue;
-        }
-        new_bottommost_files_mark_threshold = std::min(
-            new_bottommost_files_mark_threshold,
-            cfd->current()->storage_info()->bottommost_files_mark_threshold());
-      }
-      bottommost_files_mark_threshold_ = new_bottommost_files_mark_threshold;
    }
  }
  delete casted_s;
@@ -2805,8 +2628,7 @@ Status DBImpl::GetDbIdentity(std::string& identity) const {
  if (!s.ok()) {
    return s;
  }
-  char* buffer =
-      reinterpret_cast<char*>(alloca(static_cast<size_t>(file_size)));
+  char* buffer = reinterpret_cast<char*>(alloca(static_cast<size_t>(file_size)));
  Slice id;
  s = id_file_reader->Read(static_cast<size_t>(file_size), &id, buffer);
  if (!s.ok()) {
@@ -2893,13 +2715,13 @@ Status DestroyDB(const std::string& dbname, const Options& options,
    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
+        type != kDBLockFile) {  // Lock file will be deleted at end
        Status del;
        std::string path_to_delete = dbname + "/" + fname;
        if (type == kMetaDatabase) {
          del = DestroyDB(path_to_delete, options);
-        } else if (type == kTableFile || type == kLogFile) {
-          del = DeleteDBFile(&soptions, path_to_delete, dbname);
+        } else if (type == kTableFile) {
+          del = DeleteSSTFile(&soptions, path_to_delete, dbname);
        } else {
          del = env->DeleteFile(path_to_delete);
        }
@@ -2931,9 +2753,9 @@ Status DestroyDB(const std::string& dbname, const Options& options,
      if (env->GetChildren(path, &filenames).ok()) {
        for (const auto& fname : filenames) {
          if (ParseFileName(fname, &number, &type) &&
-              type == kTableFile) {  // Lock file will be deleted at end
+            type == kTableFile) {  // Lock file will be deleted at end
            std::string table_path = path + "/" + fname;
-            Status del = DeleteDBFile(&soptions, table_path, dbname);
+            Status del = DeleteSSTFile(&soptions, table_path, dbname);
            if (result.ok() && !del.ok()) {
              result = del;
            }
@@ -2958,9 +2780,9 @@ Status DestroyDB(const std::string& dbname, const Options& options,
    if (env->GetChildren(archivedir, &archiveFiles).ok()) {
      // Delete archival files.
      for (const auto& file : archiveFiles) {
-        if (ParseFileName(file, &number, &type) && type == kLogFile) {
-          Status del =
-              DeleteDBFile(&soptions, archivedir + "/" + file, archivedir);
+        if (ParseFileName(file, &number, &type) &&
+          type == kLogFile) {
+          Status del = env->DeleteFile(archivedir + "/" + file);
          if (result.ok() && !del.ok()) {
            result = del;
          }
@@ -2973,9 +2795,7 @@ Status DestroyDB(const std::string& dbname, const Options& options,
    if (wal_dir_exists) {
      for (const auto& file : walDirFiles) {
        if (ParseFileName(file, &number, &type) && type == kLogFile) {
-          Status del =
-              DeleteDBFile(&soptions, LogFileName(soptions.wal_dir, number),
-                           soptions.wal_dir);
+          Status del = env->DeleteFile(LogFileName(soptions.wal_dir, number));
          if (result.ok() && !del.ok()) {
            result = del;
          }
@@ -3170,7 +2990,7 @@ void DumpRocksDBBuildVersion(Logger* log) {
  ROCKS_LOG_HEADER(log, "Git sha %s", rocksdb_build_git_sha);
  ROCKS_LOG_HEADER(log, "Compile date %s", rocksdb_build_compile_date);
 #else
-  (void)log;  // ignore "-Wunused-parameter"
+    (void)log;  // ignore "-Wunused-parameter"
 #endif
 }

@@ -3289,124 +3109,74 @@ Status DBImpl::IngestExternalFile(
    ColumnFamilyHandle* column_family,
    const std::vector<std::string>& external_files,
    const IngestExternalFileOptions& ingestion_options) {
-  IngestExternalFileArg arg;
-  arg.column_family = column_family;
-  arg.external_files = external_files;
-  arg.options = ingestion_options;
-  return IngestExternalFiles({arg});
-}
+  if (external_files.empty()) {
+    return Status::InvalidArgument("external_files is empty");
+  }

-Status DBImpl::IngestExternalFiles(
-    const std::vector<IngestExternalFileArg>& args) {
-  if (args.empty()) {
-    return Status::InvalidArgument("ingestion arg list is empty");
-  }
-  {
-    std::unordered_set<ColumnFamilyHandle*> unique_cfhs;
-    for (const auto& arg : args) {
-      if (arg.column_family == nullptr) {
-        return Status::InvalidArgument("column family handle is null");
-      } else if (unique_cfhs.count(arg.column_family) > 0) {
-        return Status::InvalidArgument(
-            "ingestion args have duplicate column families");
-      }
-      unique_cfhs.insert(arg.column_family);
-    }
-  }
-  // Ingest multiple external SST files atomically.
-  size_t num_cfs = args.size();
-  for (size_t i = 0; i != num_cfs; ++i) {
-    if (args[i].external_files.empty()) {
-      char err_msg[128] = {0};
-      snprintf(err_msg, 128, "external_files[%zu] is empty", i);
-      return Status::InvalidArgument(err_msg);
-    }
-  }
-  for (const auto& arg : args) {
-    const IngestExternalFileOptions& ingest_opts = arg.options;
-    if (ingest_opts.ingest_behind &&
-        !immutable_db_options_.allow_ingest_behind) {
+  Status status;
+  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
+  auto cfd = cfh->cfd();
+
+  // Ingest should immediately fail if ingest_behind is requested,
+  // but the DB doesn't support it.
+  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");
    }
  }

-  // TODO (yanqin) maybe handle the case in which column_families have
-  // duplicates
-  std::list<uint64_t>::iterator pending_output_elem;
-  size_t total = 0;
-  for (const auto& arg : args) {
-    total += arg.external_files.size();
-  }
+  ExternalSstFileIngestionJob ingestion_job(env_, versions_.get(), cfd,
+                                            immutable_db_options_, env_options_,
+                                            &snapshots_, ingestion_options);
+
+  SuperVersionContext dummy_sv_ctx(/* create_superversion */ true);
+  VersionEdit dummy_edit;
  uint64_t next_file_number = 0;
-  Status status = ReserveFileNumbersBeforeIngestion(
-      static_cast<ColumnFamilyHandleImpl*>(args[0].column_family)->cfd(), total,
-      &pending_output_elem, &next_file_number);
-  if (!status.ok()) {
-    InstrumentedMutexLock l(&mutex_);
-    ReleaseFileNumberFromPendingOutputs(pending_output_elem);
-    return status;
-  }
-
-  std::vector<ExternalSstFileIngestionJob> ingestion_jobs;
-  for (const auto& arg : args) {
-    auto* cfd = static_cast<ColumnFamilyHandleImpl*>(arg.column_family)->cfd();
-    ingestion_jobs.emplace_back(env_, versions_.get(), cfd,
-                                immutable_db_options_, env_options_,
-                                &snapshots_, arg.options);
-  }
-  std::vector<std::pair<bool, Status>> exec_results;
-  for (size_t i = 0; i != num_cfs; ++i) {
-    exec_results.emplace_back(false, Status::OK());
-  }
-  // TODO(yanqin) maybe make jobs run in parallel
-  for (size_t i = 1; i != num_cfs; ++i) {
-    uint64_t start_file_number =
-        next_file_number + args[i - 1].external_files.size();
-    auto* cfd =
-        static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
-    SuperVersion* super_version = cfd->GetReferencedSuperVersion(&mutex_);
-    exec_results[i].second = ingestion_jobs[i].Prepare(
-        args[i].external_files, start_file_number, super_version);
-    exec_results[i].first = true;
-    CleanupSuperVersion(super_version);
-  }
-  TEST_SYNC_POINT("DBImpl::IngestExternalFiles:BeforeLastJobPrepare:0");
-  TEST_SYNC_POINT("DBImpl::IngestExternalFiles:BeforeLastJobPrepare:1");
+  std::list<uint64_t>::iterator pending_output_elem;
  {
-    auto* cfd =
-        static_cast<ColumnFamilyHandleImpl*>(args[0].column_family)->cfd();
-    SuperVersion* super_version = cfd->GetReferencedSuperVersion(&mutex_);
-    exec_results[0].second = ingestion_jobs[0].Prepare(
-        args[0].external_files, next_file_number, super_version);
-    exec_results[0].first = true;
-    CleanupSuperVersion(super_version);
-  }
-  for (const auto& exec_result : exec_results) {
-    if (!exec_result.second.ok()) {
-      status = exec_result.second;
-      break;
+    InstrumentedMutexLock l(&mutex_);
+    if (error_handler_.IsDBStopped()) {
+      // Don't ingest files when there is a bg_error
+      return error_handler_.GetBGError();
+    }
+
+    // Make sure that bg cleanup wont delete the files that we are ingesting
+    pending_output_elem = CaptureCurrentFileNumberInPendingOutputs();
+
+    // If crash happen after a hard link established, Recover function may
+    // reuse the file number that has already assigned to the internal file,
+    // and this will overwrite the external file. To protect the external
+    // file, we have to make sure the file number will never being reused.
+    next_file_number = versions_->FetchAddFileNumber(external_files.size());
+    auto cf_options = cfd->GetLatestMutableCFOptions();
+    status = versions_->LogAndApply(cfd, *cf_options, &dummy_edit, &mutex_,
+                                    directories_.GetDbDir());
+    if (status.ok()) {
+      InstallSuperVersionAndScheduleWork(cfd, &dummy_sv_ctx, *cf_options);
    }
  }
+  dummy_sv_ctx.Clean();
  if (!status.ok()) {
-    for (size_t i = 0; i != num_cfs; ++i) {
-      if (exec_results[i].first) {
-        ingestion_jobs[i].Cleanup(status);
-      }
-    }
    InstrumentedMutexLock l(&mutex_);
    ReleaseFileNumberFromPendingOutputs(pending_output_elem);
    return status;
  }

-  std::vector<SuperVersionContext> sv_ctxs;
-  for (size_t i = 0; i != num_cfs; ++i) {
-    sv_ctxs.emplace_back(true /* create_superversion */);
+  SuperVersion* super_version = cfd->GetReferencedSuperVersion(&mutex_);
+  status =
+      ingestion_job.Prepare(external_files, next_file_number, super_version);
+  CleanupSuperVersion(super_version);
+  if (!status.ok()) {
+    InstrumentedMutexLock l(&mutex_);
+    ReleaseFileNumberFromPendingOutputs(pending_output_elem);
+    return status;
  }
-  TEST_SYNC_POINT("DBImpl::IngestExternalFiles:BeforeJobsRun:0");
-  TEST_SYNC_POINT("DBImpl::IngestExternalFiles:BeforeJobsRun:1");
+
+  SuperVersionContext sv_context(/* create_superversion */ true);
  TEST_SYNC_POINT("DBImpl::AddFile:Start");
  {
+    // Lock db mutex
    InstrumentedMutexLock l(&mutex_);
    TEST_SYNC_POINT("DBImpl::AddFile:MutexLock");

@@ -3418,133 +3188,55 @@ Status DBImpl::IngestExternalFiles(
      nonmem_write_thread_.EnterUnbatched(&nonmem_w, &mutex_);
    }

-    num_running_ingest_file_ += static_cast<int>(num_cfs);
+    num_running_ingest_file_++;
    TEST_SYNC_POINT("DBImpl::IngestExternalFile:AfterIncIngestFileCounter");

-    bool at_least_one_cf_need_flush = false;
-    std::vector<bool> need_flush(num_cfs, false);
-    for (size_t i = 0; i != num_cfs; ++i) {
-      auto* cfd =
-          static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
-      if (cfd->IsDropped()) {
-        // TODO (yanqin) investigate whether we should abort ingestion or
-        // proceed with other non-dropped column families.
-        status = Status::InvalidArgument(
-            "cannot ingest an external file into a dropped CF");
-        break;
-      }
-      bool tmp = false;
-      status = ingestion_jobs[i].NeedsFlush(&tmp, cfd->GetSuperVersion());
-      need_flush[i] = tmp;
-      at_least_one_cf_need_flush = (at_least_one_cf_need_flush || tmp);
-      if (!status.ok()) {
-        break;
-      }
+    // We cannot ingest a file into a dropped CF
+    if (cfd->IsDropped()) {
+      status = Status::InvalidArgument(
+          "Cannot ingest an external file into a dropped CF");
    }
-    TEST_SYNC_POINT_CALLBACK("DBImpl::IngestExternalFile:NeedFlush",
-                             &at_least_one_cf_need_flush);

-    if (status.ok() && at_least_one_cf_need_flush) {
-      FlushOptions flush_opts;
-      flush_opts.allow_write_stall = true;
-      if (immutable_db_options_.atomic_flush) {
-        autovector<ColumnFamilyData*> cfds_to_flush;
-        SelectColumnFamiliesForAtomicFlush(&cfds_to_flush);
-        mutex_.Unlock();
-        status = AtomicFlushMemTables(cfds_to_flush, flush_opts,
-                                      FlushReason::kExternalFileIngestion,
-                                      true /* writes_stopped */);
+    // Figure out if we need to flush the memtable first
+    if (status.ok()) {
+      bool need_flush = false;
+      status = ingestion_job.NeedsFlush(&need_flush, cfd->GetSuperVersion());
+      TEST_SYNC_POINT_CALLBACK("DBImpl::IngestExternalFile:NeedFlush",
+                               &need_flush);
+      if (status.ok() && need_flush) {
+        FlushOptions flush_opts;
+        flush_opts.allow_write_stall = true;
+        if (immutable_db_options_.atomic_flush) {
+          autovector<ColumnFamilyData*> cfds;
+          SelectColumnFamiliesForAtomicFlush(&cfds);
+          mutex_.Unlock();
+          status = AtomicFlushMemTables(cfds, flush_opts,
+                                        FlushReason::kExternalFileIngestion,
+                                        true /* writes_stopped */);
+        } else {
+          mutex_.Unlock();
+          status = FlushMemTable(cfd, flush_opts,
+                                 FlushReason::kExternalFileIngestion,
+                                 true /* writes_stopped */);
+        }
        mutex_.Lock();
-      } else {
-        for (size_t i = 0; i != num_cfs; ++i) {
-          if (need_flush[i]) {
-            mutex_.Unlock();
-            auto* cfd =
-                static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)
-                    ->cfd();
-            status = FlushMemTable(cfd, flush_opts,
-                                   FlushReason::kExternalFileIngestion,
-                                   true /* writes_stopped */);
-            mutex_.Lock();
-            if (!status.ok()) {
-              break;
-            }
-          }
-        }
      }
    }
-    // Run ingestion jobs.
-    if (status.ok()) {
-      for (size_t i = 0; i != num_cfs; ++i) {
-        status = ingestion_jobs[i].Run();
-        if (!status.ok()) {
-          break;
-        }
-      }
-    }
-    if (status.ok()) {
-      bool should_increment_last_seqno =
-          ingestion_jobs[0].ShouldIncrementLastSequence();
-#ifndef NDEBUG
-      for (size_t i = 1; i != num_cfs; ++i) {
-        assert(should_increment_last_seqno ==
-               ingestion_jobs[i].ShouldIncrementLastSequence());
-      }
-#endif
-      if (should_increment_last_seqno) {
-        const SequenceNumber last_seqno = versions_->LastSequence();
-        versions_->SetLastAllocatedSequence(last_seqno + 1);
-        versions_->SetLastPublishedSequence(last_seqno + 1);
-        versions_->SetLastSequence(last_seqno + 1);
-      }
-      autovector<ColumnFamilyData*> cfds_to_commit;
-      autovector<const MutableCFOptions*> mutable_cf_options_list;
-      autovector<autovector<VersionEdit*>> edit_lists;
-      uint32_t num_entries = 0;
-      for (size_t i = 0; i != num_cfs; ++i) {
-        auto* cfd =
-            static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
-        if (cfd->IsDropped()) {
-          continue;
-        }
-        cfds_to_commit.push_back(cfd);
-        mutable_cf_options_list.push_back(cfd->GetLatestMutableCFOptions());
-        autovector<VersionEdit*> edit_list;
-        edit_list.push_back(ingestion_jobs[i].edit());
-        edit_lists.push_back(edit_list);
-        ++num_entries;
-      }
-      // Mark the version edits as an atomic group if the number of version
-      // edits exceeds 1.
-      if (cfds_to_commit.size() > 1) {
-        for (auto& edits : edit_lists) {
-          assert(edits.size() == 1);
-          edits[0]->MarkAtomicGroup(--num_entries);
-        }
-        assert(0 == num_entries);
-      }
-      status =
-          versions_->LogAndApply(cfds_to_commit, mutable_cf_options_list,
-                                 edit_lists, &mutex_, directories_.GetDbDir());
-    }

+    // Run the ingestion job
    if (status.ok()) {
-      for (size_t i = 0; i != num_cfs; ++i) {
-        auto* cfd =
-            static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
-        if (!cfd->IsDropped()) {
-          InstallSuperVersionAndScheduleWork(cfd, &sv_ctxs[i],
-                                             *cfd->GetLatestMutableCFOptions());
-#ifndef NDEBUG
-          if (0 == i && num_cfs > 1) {
-            TEST_SYNC_POINT(
-                "DBImpl::IngestExternalFiles:InstallSVForFirstCF:0");
-            TEST_SYNC_POINT(
-                "DBImpl::IngestExternalFiles:InstallSVForFirstCF:1");
-          }
-#endif  // !NDEBUG
-        }
-      }
+      status = ingestion_job.Run();
+    }
+
+    // Install job edit [Mutex will be unlocked here]
+    auto mutable_cf_options = cfd->GetLatestMutableCFOptions();
+    if (status.ok()) {
+      status =
+          versions_->LogAndApply(cfd, *mutable_cf_options, ingestion_job.edit(),
+                                 &mutex_, directories_.GetDbDir());
+    }
+    if (status.ok()) {
+      InstallSuperVersionAndScheduleWork(cfd, &sv_context, *mutable_cf_options);
    }

    // Resume writes to the DB
@@ -3553,36 +3245,30 @@ Status DBImpl::IngestExternalFiles(
    }
    write_thread_.ExitUnbatched(&w);

+    // Update stats
    if (status.ok()) {
-      for (auto& job : ingestion_jobs) {
-        job.UpdateStats();
-      }
+      ingestion_job.UpdateStats();
    }
+
    ReleaseFileNumberFromPendingOutputs(pending_output_elem);
-    num_running_ingest_file_ -= static_cast<int>(num_cfs);
-    if (0 == num_running_ingest_file_) {
+
+    num_running_ingest_file_--;
+    if (num_running_ingest_file_ == 0) {
      bg_cv_.SignalAll();
    }
+
    TEST_SYNC_POINT("DBImpl::AddFile:MutexUnlock");
  }
  // mutex_ is unlocked here

  // Cleanup
-  for (size_t i = 0; i != num_cfs; ++i) {
-    sv_ctxs[i].Clean();
-    // This may rollback jobs that have completed successfully. This is
-    // intended for atomicity.
-    ingestion_jobs[i].Cleanup(status);
-  }
+  sv_context.Clean();
+  ingestion_job.Cleanup(status);
+
  if (status.ok()) {
-    for (size_t i = 0; i != num_cfs; ++i) {
-      auto* cfd =
-          static_cast<ColumnFamilyHandleImpl*>(args[i].column_family)->cfd();
-      if (!cfd->IsDropped()) {
-        NotifyOnExternalFileIngested(cfd, ingestion_jobs[i]);
-      }
-    }
+    NotifyOnExternalFileIngested(cfd, ingestion_job);
  }
+
  return status;
 }

@@ -3608,8 +3294,8 @@ Status DBImpl::VerifyChecksum() {
    Options opts;
    {
      InstrumentedMutexLock l(&mutex_);
-      opts = Options(BuildDBOptions(immutable_db_options_, mutable_db_options_),
-                     cfd->GetLatestCFOptions());
+      opts = Options(BuildDBOptions(immutable_db_options_,
+         mutable_db_options_), cfd->GetLatestCFOptions());
    }
    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();
@@ -3674,13 +3360,8 @@ Status DBImpl::StartTrace(const TraceOptions& trace_options,

 Status DBImpl::EndTrace() {
  InstrumentedMutexLock lock(&trace_mutex_);
-  Status s;
-  if (tracer_ != nullptr) {
-    s = tracer_->Close();
-    tracer_.reset();
-  } else {
-    return Status::IOError("No trace file to close");
-  }
+  Status s = tracer_->Close();
+  tracer_.reset();
  return s;
 }

@@ -3707,35 +3388,6 @@ Status DBImpl::TraceIteratorSeekForPrev(const uint32_t& cf_id,
  return s;
 }

-Status DBImpl::ReserveFileNumbersBeforeIngestion(
-    ColumnFamilyData* cfd, uint64_t num,
-    std::list<uint64_t>::iterator* pending_output_elem,
-    uint64_t* next_file_number) {
-  Status s;
-  SuperVersionContext dummy_sv_ctx(true /* create_superversion */);
-  assert(nullptr != pending_output_elem);
-  assert(nullptr != next_file_number);
-  InstrumentedMutexLock l(&mutex_);
-  if (error_handler_.IsDBStopped()) {
-    // Do not ingest files when there is a bg_error
-    return error_handler_.GetBGError();
-  }
-  *pending_output_elem = CaptureCurrentFileNumberInPendingOutputs();
-  *next_file_number = versions_->FetchAddFileNumber(static_cast<uint64_t>(num));
-  auto cf_options = cfd->GetLatestMutableCFOptions();
-  VersionEdit dummy_edit;
-  // If crash happen after a hard link established, Recover function may
-  // reuse the file number that has already assigned to the internal file,
-  // and this will overwrite the external file. To protect the external
-  // file, we have to make sure the file number will never being reused.
-  s = versions_->LogAndApply(cfd, *cf_options, &dummy_edit, &mutex_,
-                             directories_.GetDbDir());
-  if (s.ok()) {
-    InstallSuperVersionAndScheduleWork(cfd, &dummy_sv_ctx, *cf_options);
-  }
-  dummy_sv_ctx.Clean();
-  return s;
-}
 #endif  // ROCKSDB_LITE

 }  // namespace rocksdb
@@ -63,7 +63,6 @@ namespace rocksdb {

 class Arena;
 class ArenaWrappedDBIter;
-class InMemoryStatsHistoryIterator;
 class MemTable;
 class TableCache;
 class TaskLimiterToken;
@@ -178,9 +177,10 @@ class DBImpl : public DB {
  virtual bool GetAggregatedIntProperty(const Slice& property,
                                        uint64_t* aggregated_value) override;
  using DB::GetApproximateSizes;
-  virtual void GetApproximateSizes(
-      ColumnFamilyHandle* column_family, const Range* range, int n,
-      uint64_t* sizes, uint8_t include_flags = INCLUDE_FILES) override;
+  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
+                                   const Range* range, int n, uint64_t* sizes,
+                                   uint8_t include_flags
+                                   = INCLUDE_FILES) override;
  using DB::GetApproximateMemTableStats;
  virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
                                           const Range& range,
@@ -234,10 +234,8 @@ class DBImpl : public DB {
      const FlushOptions& options,
      const std::vector<ColumnFamilyHandle*>& column_families) override;
  virtual Status FlushWAL(bool sync) override;
-  bool TEST_WALBufferIsEmpty(bool lock = true);
+  bool TEST_WALBufferIsEmpty();
  virtual Status SyncWAL() override;
-  virtual Status LockWAL() override;
-  virtual Status UnlockWAL() override;

  virtual SequenceNumber GetLatestSequenceNumber() const override;
  virtual SequenceNumber GetLastPublishedSequence() const {
@@ -285,8 +283,9 @@ class DBImpl : public DB {
  // Status::NotFound() will be returned if the current DB does not have
  // any column family match the specified name.
  // TODO(yhchiang): output parameter is placed in the end in this codebase.
-  virtual void GetColumnFamilyMetaData(ColumnFamilyHandle* column_family,
-                                       ColumnFamilyMetaData* metadata) override;
+  virtual void GetColumnFamilyMetaData(
+      ColumnFamilyHandle* column_family,
+      ColumnFamilyMetaData* metadata) override;

  Status SuggestCompactRange(ColumnFamilyHandle* column_family,
                             const Slice* begin, const Slice* end) override;
@@ -347,10 +346,6 @@ class DBImpl : public DB {
      const std::vector<std::string>& external_files,
      const IngestExternalFileOptions& ingestion_options) override;

-  using DB::IngestExternalFiles;
-  virtual Status IngestExternalFiles(
-      const std::vector<IngestExternalFileArg>& args) override;
-
  virtual Status VerifyChecksum() override;

  using DB::StartTrace;
@@ -378,8 +373,9 @@ 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,
+                             uint32_t max_subcompactions,
+                             const Slice* begin, const Slice* end,
+                             bool exclusive,
                             bool disallow_trivial_move = false);

  // Return an internal iterator over the current state of the database.
@@ -426,8 +422,8 @@ class DBImpl : public DB {

  // Return the maximum overlapping data (in bytes) at next level for any
  // file at a level >= 1.
-  int64_t TEST_MaxNextLevelOverlappingBytes(
-      ColumnFamilyHandle* column_family = nullptr);
+  int64_t TEST_MaxNextLevelOverlappingBytes(ColumnFamilyHandle* column_family =
+                                                nullptr);

  // Return the current manifest file no.
  uint64_t TEST_Current_Manifest_FileNo();
@@ -482,10 +478,7 @@ class DBImpl : public DB {
  int TEST_BGCompactionsAllowed() const;
  int TEST_BGFlushesAllowed() const;
  size_t TEST_GetWalPreallocateBlockSize(uint64_t write_buffer_size) const;
-  void TEST_WaitForDumpStatsRun(std::function<void()> callback) const;
-  void TEST_WaitForPersistStatsRun(std::function<void()> callback) const;
-  bool TEST_IsPersistentStatsEnabled() const;
-  size_t TEST_EstiamteStatsHistorySize() const;
+  void TEST_WaitForTimedTaskRun(std::function<void()> callback) const;

 #endif  // NDEBUG

@@ -731,17 +724,6 @@ class DBImpl : public DB {
  static Status CreateAndNewDirectory(Env* env, const std::string& dirname,
                                      std::unique_ptr<Directory>* directory);

-  // Given a time window, return an iterator for accessing stats history
-  Status GetStatsHistory(
-      uint64_t start_time, uint64_t end_time,
-      std::unique_ptr<StatsHistoryIterator>* stats_iterator) override;
-
-  // find stats map from stats_history_ with smallest timestamp in
-  // the range of [start_time, end_time)
-  bool FindStatsByTime(uint64_t start_time, uint64_t end_time,
-                       uint64_t* new_time,
-                       std::map<std::string, uint64_t>* stats_map);
-
 protected:
  Env* const env_;
  const std::string dbname_;
@@ -757,29 +739,6 @@ class DBImpl : public DB {
  std::unique_ptr<Tracer> tracer_;
  InstrumentedMutex trace_mutex_;

-  // State below is protected by mutex_
-  // With two_write_queues enabled, some of the variables that accessed during
-  // WriteToWAL need different synchronization: log_empty_, alive_log_files_,
-  // logs_, logfile_number_. Refer to the definition of each variable below for
-  // more description.
-  mutable InstrumentedMutex mutex_;
-
-  ColumnFamilyHandleImpl* default_cf_handle_;
-  InternalStats* default_cf_internal_stats_;
-
-  // only used for dynamically adjusting max_total_wal_size. it is a sum of
-  // [write_buffer_size * max_write_buffer_number] over all column families
-  uint64_t max_total_in_memory_state_;
-  // If true, we have only one (default) column family. We use this to optimize
-  // some code-paths
-  bool single_column_family_mode_;
-
-  // The options to access storage files
-  const EnvOptions env_options_;
-
-  // Additonal options for compaction and flush
-  EnvOptions env_options_for_compaction_;
-
  // Except in DB::Open(), WriteOptionsFile can only be called when:
  // Persist options to options file.
  // If need_mutex_lock = false, the method will lock DB mutex.
@@ -800,12 +759,13 @@ class DBImpl : public DB {
                              const MutableCFOptions& mutable_cf_options,
                              int job_id, TableProperties prop);

-  void NotifyOnCompactionBegin(ColumnFamilyData* cfd, Compaction* c,
-                               const Status& st,
-                               const CompactionJobStats& job_stats, int job_id);
+  void NotifyOnCompactionBegin(ColumnFamilyData* cfd,
+                               Compaction *c, const Status &st,
+                               const CompactionJobStats& job_stats,
+                               int job_id);

-  void NotifyOnCompactionCompleted(ColumnFamilyData* cfd, Compaction* c,
-                                   const Status& st,
+  void NotifyOnCompactionCompleted(ColumnFamilyData* cfd,
+                                   Compaction *c, const Status &st,
                                   const CompactionJobStats& job_stats,
                                   int job_id);
  void NotifyOnMemTableSealed(ColumnFamilyData* cfd,
@@ -866,14 +826,6 @@ class DBImpl : public DB {
  // Actual implementation of Close()
  Status CloseImpl();

-  // Recover the descriptor from persistent storage.  May do a significant
-  // amount of work to recover recently logged updates.  Any changes to
-  // be made to the descriptor are added to *edit.
-  virtual Status Recover(
-      const std::vector<ColumnFamilyDescriptor>& column_families,
-      bool read_only = false, bool error_if_log_file_exist = false,
-      bool error_if_data_exists_in_logs = false);
-
 private:
  friend class DB;
  friend class ErrorHandler;
@@ -894,7 +846,6 @@ class DBImpl : public DB {
  friend class CompactedDBImpl;
  friend class DBTest_ConcurrentFlushWAL_Test;
  friend class DBTest_MixedSlowdownOptionsStop_Test;
-  friend class DBCompactionTest_CompactBottomLevelFilesWithDeletions_Test;
 #ifndef NDEBUG
  friend class DBTest2_ReadCallbackTest_Test;
  friend class WriteCallbackTest_WriteWithCallbackTest_Test;
@@ -922,6 +873,13 @@ class DBImpl : public DB {
  struct PrepickedCompaction;
  struct PurgeFileInfo;

+  // Recover the descriptor from persistent storage.  May do a significant
+  // amount of work to recover recently logged updates.  Any changes to
+  // be made to the descriptor are added to *edit.
+  Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
+                 bool read_only = false, bool error_if_log_file_exist = false,
+                 bool error_if_data_exists_in_logs = false);
+
  Status ResumeImpl();

  void MaybeIgnoreError(Status* s) const;
@@ -971,8 +929,7 @@ class DBImpl : public DB {
      SuperVersionContext* superversion_context,
      std::vector<SequenceNumber>& snapshot_seqs,
      SequenceNumber earliest_write_conflict_snapshot,
-      SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
-      Env::Priority thread_pri);
+      SnapshotChecker* snapshot_checker, LogBuffer* log_buffer);

  // Argument required by background flush thread.
  struct BGFlushArg {
@@ -995,22 +952,15 @@ class DBImpl : public DB {
    SuperVersionContext* superversion_context_;
  };

-  // Argument passed to flush thread.
-  struct FlushThreadArg {
-    DBImpl* db_;
-
-    Env::Priority thread_pri_;
-  };
-
  // Flush the memtables of (multiple) column families to multiple files on
  // persistent storage.
  Status FlushMemTablesToOutputFiles(
      const autovector<BGFlushArg>& bg_flush_args, bool* made_progress,
-      JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri);
+      JobContext* job_context, LogBuffer* log_buffer);

  Status AtomicFlushMemTablesToOutputFiles(
      const autovector<BGFlushArg>& bg_flush_args, bool* made_progress,
-      JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri);
+      JobContext* job_context, LogBuffer* log_buffer);

  // REQUIRES: log_numbers are sorted in ascending order
  Status RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
@@ -1153,21 +1103,18 @@ class DBImpl : public DB {
  // Runs a pre-chosen universal compaction involving bottom level in a
  // separate, bottom-pri thread pool.
  static void BGWorkBottomCompaction(void* arg);
-  static void BGWorkFlush(void* arg);
+  static void BGWorkFlush(void* db);
  static void BGWorkPurge(void* arg);
-  static void UnscheduleCompactionCallback(void* arg);
-  static void UnscheduleFlushCallback(void* arg);
+  static void UnscheduleCallback(void* arg);
  void BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
-                                Env::Priority thread_pri);
-  void BackgroundCallFlush(Env::Priority thread_pri);
+                                Env::Priority bg_thread_pri);
+  void BackgroundCallFlush();
  void BackgroundCallPurge();
  Status BackgroundCompaction(bool* madeProgress, JobContext* job_context,
                              LogBuffer* log_buffer,
-                              PrepickedCompaction* prepicked_compaction,
-                              Env::Priority thread_pri);
+                              PrepickedCompaction* prepicked_compaction);
  Status BackgroundFlush(bool* madeProgress, JobContext* job_context,
-                         LogBuffer* log_buffer, FlushReason* reason,
-                         Env::Priority thread_pri);
+                         LogBuffer* log_buffer, FlushReason* reason);

  bool EnoughRoomForCompaction(ColumnFamilyData* cfd,
                               const std::vector<CompactionInputFiles>& inputs,
@@ -1184,19 +1131,13 @@ class DBImpl : public DB {

  void PrintStatistics();

-  size_t EstiamteStatsHistorySize() const;
-
-  // persist stats to column family "_persistent_stats"
-  void PersistStats();
-
  // dump rocksdb.stats to LOG
  void DumpStats();

  // Return the minimum empty level that could hold the total data in the
  // input level. Return the input level, if such level could not be found.
  int FindMinimumEmptyLevelFitting(ColumnFamilyData* cfd,
-                                   const MutableCFOptions& mutable_cf_options,
-                                   int level);
+      const MutableCFOptions& mutable_cf_options, int level);

  // Move the files in the input level to the target level.
  // If target_level < 0, automatically calculate the minimum level that could
@@ -1232,13 +1173,17 @@ class DBImpl : public DB {
  // Lock over the persistent DB state.  Non-nullptr iff successfully acquired.
  FileLock* db_lock_;

-  // In addition to mutex_, log_write_mutex_ protected writes to stats_history_
-  InstrumentedMutex stats_history_mutex_;
  // In addition to mutex_, log_write_mutex_ protected writes to logs_ and
  // logfile_number_. With two_write_queues it also protects alive_log_files_,
  // and log_empty_. Refer to the definition of each variable below for more
  // details.
  InstrumentedMutex log_write_mutex_;
+  // State below is protected by mutex_
+  // With two_write_queues enabled, some of the variables that accessed during
+  // WriteToWAL need different synchronization: log_empty_, alive_log_files_,
+  // logs_, logfile_number_. Refer to the definition of each variable below for
+  // more description.
+  mutable InstrumentedMutex mutex_;

  std::atomic<bool> shutting_down_;
  // This condition variable is signaled on these conditions:
@@ -1270,10 +1215,12 @@ class DBImpl : public DB {
  // read and writes are protected by log_write_mutex_ instead. This is to avoid
  // expesnive mutex_ lock during WAL write, which update log_empty_.
  bool log_empty_;
-
+  ColumnFamilyHandleImpl* default_cf_handle_;
+  InternalStats* default_cf_internal_stats_;
  std::unique_ptr<ColumnFamilyMemTablesImpl> column_family_memtables_;
  struct LogFileNumberSize {
-    explicit LogFileNumberSize(uint64_t _number) : number(_number) {}
+    explicit LogFileNumberSize(uint64_t _number)
+        : number(_number) {}
    void AddSize(uint64_t new_size) { size += new_size; }
    uint64_t number;
    uint64_t size = 0;
@@ -1336,19 +1283,18 @@ class DBImpl : public DB {
  WriteBatch cached_recoverable_state_;
  std::atomic<bool> cached_recoverable_state_empty_ = {true};
  std::atomic<uint64_t> total_log_size_;
-
+  // only used for dynamically adjusting max_total_wal_size. it is a sum of
+  // [write_buffer_size * max_write_buffer_number] over all column families
+  uint64_t max_total_in_memory_state_;
+  // If true, we have only one (default) column family. We use this to optimize
+  // some code-paths
+  bool single_column_family_mode_;
  // If this is non-empty, we need to delete these log files in background
  // threads. Protected by db mutex.
  autovector<log::Writer*> logs_to_free_;

  bool is_snapshot_supported_;

-  std::map<uint64_t, std::map<std::string, uint64_t>> stats_history_;
-
-  std::map<std::string, uint64_t> stats_slice_;
-
-  bool stats_slice_initialized_ = false;
-
  // Class to maintain directories for all database paths other than main one.
  class Directories {
   public:
@@ -1485,15 +1431,15 @@ class DBImpl : public DB {
    uint32_t output_path_id;
    Status status;
    bool done;
-    bool in_progress;            // compaction request being processed?
-    bool incomplete;             // only part of requested range compacted
-    bool exclusive;              // current behavior of only one manual
-    bool disallow_trivial_move;  // Force actual compaction to run
-    const InternalKey* begin;    // nullptr means beginning of key range
-    const InternalKey* end;      // nullptr means end of key range
-    InternalKey* manual_end;     // how far we are compacting
-    InternalKey tmp_storage;     // Used to keep track of compaction progress
-    InternalKey tmp_storage1;    // Used to keep track of compaction progress
+    bool in_progress;             // compaction request being processed?
+    bool incomplete;              // only part of requested range compacted
+    bool exclusive;               // current behavior of only one manual
+    bool disallow_trivial_move;   // Force actual compaction to run
+    const InternalKey* begin;     // nullptr means beginning of key range
+    const InternalKey* end;       // nullptr means end of key range
+    InternalKey* manual_end;      // how far we are compacting
+    InternalKey tmp_storage;      // Used to keep track of compaction progress
+    InternalKey tmp_storage1;     // Used to keep track of compaction progress
  };
  struct PrepickedCompaction {
    // background compaction takes ownership of `compaction`.
@@ -1555,6 +1501,12 @@ class DBImpl : public DB {

  std::string db_absolute_path_;

+  // The options to access storage files
+  const EnvOptions env_options_;
+
+  // Additonal options for compaction and flush
+  EnvOptions env_options_for_compaction_;
+
  // Number of running IngestExternalFile() calls.
  // REQUIRES: mutex held
  int num_running_ingest_file_;
@@ -1578,10 +1530,6 @@ class DBImpl : public DB {
  // Indicate DB was opened successfully
  bool opened_successfully_;

-  // The min threshold to triggere bottommost compaction for removing
-  // garbages, among all column families.
-  SequenceNumber bottommost_files_mark_threshold_ = kMaxSequenceNumber;
-
  LogsWithPrepTracker logs_with_prep_tracker_;

  // Callback for compaction to check if a key is visible to a snapshot.
@@ -1592,14 +1540,10 @@ class DBImpl : public DB {
  // Only to be set during initialization
  std::unique_ptr<PreReleaseCallback> recoverable_state_pre_release_callback_;

-  // handle for scheduling stats dumping at fixed intervals
+  // handle for scheduling jobs at fixed intervals
  // REQUIRES: mutex locked
  std::unique_ptr<rocksdb::RepeatableThread> thread_dump_stats_;

-  // handle for scheduling stats snapshoting at fixed intervals
-  // REQUIRES: mutex locked
-  std::unique_ptr<rocksdb::RepeatableThread> thread_persist_stats_;
-
  // No copying allowed
  DBImpl(const DBImpl&);
  void operator=(const DBImpl&);
@@ -1617,9 +1561,9 @@ class DBImpl : public DB {

 #ifndef ROCKSDB_LITE
  using DB::GetPropertiesOfAllTables;
-  virtual Status GetPropertiesOfAllTables(
-      ColumnFamilyHandle* column_family,
-      TablePropertiesCollection* props) override;
+  virtual Status GetPropertiesOfAllTables(ColumnFamilyHandle* column_family,
+                                          TablePropertiesCollection* props)
+      override;
  virtual Status GetPropertiesOfTablesInRange(
      ColumnFamilyHandle* column_family, const Range* range, std::size_t n,
      TablePropertiesCollection* props) override;
@@ -1644,20 +1588,15 @@ class DBImpl : public DB {
                              const CompactionJobStats& compaction_job_stats,
                              const int job_id, const Version* current,
                              CompactionJobInfo* compaction_job_info) const;
-  // Reserve the next 'num' file numbers for to-be-ingested external SST files,
-  // and return the current file_number in 'next_file_number'.
-  // Write a version edit to the MANIFEST.
-  Status ReserveFileNumbersBeforeIngestion(
-      ColumnFamilyData* cfd, uint64_t num,
-      std::list<uint64_t>::iterator* pending_output_elem,
-      uint64_t* next_file_number);
-#endif  //! ROCKSDB_LITE
+#endif

  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; }
+  Env::WriteLifeTimeHint CalculateWALWriteHint() {
+    return Env::WLTH_SHORT;
+  }

  // When set, we use a separate queue for writes that dont write to memtable.
  // In 2PC these are the writes at Prepare phase.
@@ -1719,7 +1658,8 @@ class DBImpl : public DB {
  InstrumentedCondVar atomic_flush_install_cv_;
 };

-extern Options SanitizeOptions(const std::string& db, const Options& src);
+extern Options SanitizeOptions(const std::string& db,
+                               const Options& src);

 extern DBOptions SanitizeOptions(const std::string& db, const DBOptions& src);

@@ -135,12 +135,12 @@ Status DBImpl::FlushMemTableToOutputFile(
    SuperVersionContext* superversion_context,
    std::vector<SequenceNumber>& snapshot_seqs,
    SequenceNumber earliest_write_conflict_snapshot,
-    SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
-    Env::Priority thread_pri) {
+    SnapshotChecker* snapshot_checker, LogBuffer* log_buffer) {
  mutex_.AssertHeld();
  assert(cfd->imm()->NumNotFlushed() != 0);
  assert(cfd->imm()->IsFlushPending());

+
  FlushJob flush_job(
      dbname_, cfd, immutable_db_options_, mutable_cf_options,
      nullptr /* memtable_id */, env_options_for_compaction_, versions_.get(),
@@ -149,7 +149,7 @@ Status DBImpl::FlushMemTableToOutputFile(
      GetDataDir(cfd, 0U),
      GetCompressionFlush(*cfd->ioptions(), mutable_cf_options), stats_,
      &event_logger_, mutable_cf_options.report_bg_io_stats,
-      true /* sync_output_directory */, true /* write_manifest */, thread_pri);
+      true /* sync_output_directory */, true /* write_manifest */);

  FileMetaData file_meta;

@@ -218,8 +218,7 @@ Status DBImpl::FlushMemTableToOutputFile(
          cfd->ioptions()->cf_paths[0].path, file_meta.fd.GetNumber());
      sfm->OnAddFile(file_path);
      if (sfm->IsMaxAllowedSpaceReached()) {
-        Status new_bg_error =
-            Status::SpaceLimit("Max allowed space was reached");
+        Status new_bg_error = Status::SpaceLimit("Max allowed space was reached");
        TEST_SYNC_POINT_CALLBACK(
            "DBImpl::FlushMemTableToOutputFile:MaxAllowedSpaceReached",
            &new_bg_error);
@@ -233,10 +232,10 @@ Status DBImpl::FlushMemTableToOutputFile(

 Status DBImpl::FlushMemTablesToOutputFiles(
    const autovector<BGFlushArg>& bg_flush_args, bool* made_progress,
-    JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri) {
+    JobContext* job_context, LogBuffer* log_buffer) {
  if (immutable_db_options_.atomic_flush) {
-    return AtomicFlushMemTablesToOutputFiles(
-        bg_flush_args, made_progress, job_context, log_buffer, thread_pri);
+    return AtomicFlushMemTablesToOutputFiles(bg_flush_args, made_progress,
+                                             job_context, log_buffer);
  }
  std::vector<SequenceNumber> snapshot_seqs;
  SequenceNumber earliest_write_conflict_snapshot;
@@ -251,7 +250,7 @@ Status DBImpl::FlushMemTablesToOutputFiles(
    Status s = FlushMemTableToOutputFile(
        cfd, mutable_cf_options, made_progress, job_context,
        superversion_context, snapshot_seqs, earliest_write_conflict_snapshot,
-        snapshot_checker, log_buffer, thread_pri);
+        snapshot_checker, log_buffer);
    if (!s.ok()) {
      status = s;
      if (!s.IsShutdownInProgress()) {
@@ -275,7 +274,7 @@ Status DBImpl::FlushMemTablesToOutputFiles(
 */
 Status DBImpl::AtomicFlushMemTablesToOutputFiles(
    const autovector<BGFlushArg>& bg_flush_args, bool* made_progress,
-    JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri) {
+    JobContext* job_context, LogBuffer* log_buffer) {
  mutex_.AssertHeld();

  autovector<ColumnFamilyData*> cfds;
@@ -297,7 +296,6 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
                     &earliest_write_conflict_snapshot, &snapshot_checker);

  autovector<Directory*> distinct_output_dirs;
-  autovector<std::string> distinct_output_dir_paths;
  std::vector<FlushJob> jobs;
  std::vector<MutableCFOptions> all_mutable_cf_options;
  int num_cfs = static_cast<int>(cfds.size());
@@ -305,20 +303,18 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
  for (int i = 0; i < num_cfs; ++i) {
    auto cfd = cfds[i];
    Directory* data_dir = GetDataDir(cfd, 0U);
-    const std::string& curr_path = cfd->ioptions()->cf_paths[0].path;

    // Add to distinct output directories if eligible. Use linear search. Since
    // the number of elements in the vector is not large, performance should be
    // tolerable.
    bool found = false;
-    for (const auto& path : distinct_output_dir_paths) {
-      if (path == curr_path) {
+    for (const auto dir : distinct_output_dirs) {
+      if (dir == data_dir) {
        found = true;
        break;
      }
    }
    if (!found) {
-      distinct_output_dir_paths.emplace_back(curr_path);
      distinct_output_dirs.emplace_back(data_dir);
    }

@@ -326,29 +322,31 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
    const MutableCFOptions& mutable_cf_options = all_mutable_cf_options.back();
    const uint64_t* max_memtable_id = &(bg_flush_args[i].max_memtable_id_);
    jobs.emplace_back(
-        dbname_, cfd, immutable_db_options_, mutable_cf_options,
+        dbname_, cfds[i], immutable_db_options_, mutable_cf_options,
        max_memtable_id, env_options_for_compaction_, versions_.get(), &mutex_,
        &shutting_down_, snapshot_seqs, earliest_write_conflict_snapshot,
        snapshot_checker, job_context, log_buffer, directories_.GetDbDir(),
        data_dir, GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
        stats_, &event_logger_, mutable_cf_options.report_bg_io_stats,
-        false /* sync_output_directory */, false /* write_manifest */,
-        thread_pri);
+        false /* sync_output_directory */, false /* write_manifest */);
    jobs.back().PickMemTable();
  }

-  std::vector<FileMetaData> file_meta(num_cfs);
+  autovector<FileMetaData> file_meta;
  Status s;
  assert(num_cfs == static_cast<int>(jobs.size()));

-#ifndef ROCKSDB_LITE
  for (int i = 0; i != num_cfs; ++i) {
-    const MutableCFOptions& mutable_cf_options = all_mutable_cf_options.at(i);
+    file_meta.emplace_back();
+
+#ifndef ROCKSDB_LITE
+    const MutableCFOptions& mutable_cf_options =
+        *cfds[i]->GetLatestMutableCFOptions();
    // may temporarily unlock and lock the mutex.
    NotifyOnFlushBegin(cfds[i], &file_meta[i], mutable_cf_options,
                       job_context->job_id, jobs[i].GetTableProperties());
-  }
 #endif /* !ROCKSDB_LITE */
+  }

  if (logfile_number_ > 0) {
    // TODO (yanqin) investigate whether we should sync the closed logs for
@@ -452,21 +450,19 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
    autovector<ColumnFamilyData*> tmp_cfds;
    autovector<const autovector<MemTable*>*> mems_list;
    autovector<const MutableCFOptions*> mutable_cf_options_list;
-    autovector<FileMetaData*> tmp_file_meta;
    for (int i = 0; i != num_cfs; ++i) {
      const auto& mems = jobs[i].GetMemTables();
      if (!cfds[i]->IsDropped() && !mems.empty()) {
        tmp_cfds.emplace_back(cfds[i]);
        mems_list.emplace_back(&mems);
        mutable_cf_options_list.emplace_back(&all_mutable_cf_options[i]);
-        tmp_file_meta.emplace_back(&file_meta[i]);
      }
    }

    s = InstallMemtableAtomicFlushResults(
        nullptr /* imm_lists */, tmp_cfds, mutable_cf_options_list, mems_list,
-        versions_.get(), &mutex_, tmp_file_meta,
-        &job_context->memtables_to_free, directories_.GetDbDir(), log_buffer);
+        versions_.get(), &mutex_, file_meta, &job_context->memtables_to_free,
+        directories_.GetDbDir(), log_buffer);
  }

  if (s.ok() || s.IsShutdownInProgress()) {
@@ -478,7 +474,7 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
      }
      InstallSuperVersionAndScheduleWork(cfds[i],
                                         &job_context->superversion_contexts[i],
-                                         all_mutable_cf_options[i]);
+                                         *cfds[i]->GetLatestMutableCFOptions());
      VersionStorageInfo::LevelSummaryStorage tmp;
      ROCKS_LOG_BUFFER(log_buffer, "[%s] Level summary: %s\n",
                       cfds[i]->GetName().c_str(),
@@ -494,7 +490,8 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
      if (cfds[i]->IsDropped()) {
        continue;
      }
-      NotifyOnFlushCompleted(cfds[i], &file_meta[i], all_mutable_cf_options[i],
+      NotifyOnFlushCompleted(cfds[i], &file_meta[i],
+                             *cfds[i]->GetLatestMutableCFOptions(),
                             job_context->job_id, jobs[i].GetTableProperties());
      if (sfm) {
        std::string file_path = MakeTableFileName(
@@ -740,8 +737,7 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
        }
      }
      s = RunManualCompaction(cfd, level, output_level, options.target_path_id,
-                              options.max_subcompactions, begin, end,
-                              exclusive);
+                              options.max_subcompactions, begin, end, exclusive);
      if (!s.ok()) {
        break;
      }
@@ -960,7 +956,7 @@ Status DBImpl::CompactFilesImpl(
      snapshot_checker, table_cache_, &event_logger_,
      c->mutable_cf_options()->paranoid_file_checks,
      c->mutable_cf_options()->report_bg_io_stats, dbname_,
-      &compaction_job_stats, Env::Priority::USER);
+      &compaction_job_stats);

  // Creating a compaction influences the compaction score because the score
  // takes running compactions into account (by skipping files that are already
@@ -1029,7 +1025,6 @@ Status DBImpl::CompactFilesImpl(
  if (bg_compaction_scheduled_ == 0) {
    bg_cv_.SignalAll();
  }
-  MaybeScheduleFlushOrCompaction();
  TEST_SYNC_POINT("CompactFilesImpl:End");

  return status;
@@ -1064,8 +1059,8 @@ Status DBImpl::ContinueBackgroundWork() {
  return Status::OK();
 }

-void DBImpl::NotifyOnCompactionBegin(ColumnFamilyData* cfd, Compaction* c,
-                                     const Status& st,
+void DBImpl::NotifyOnCompactionBegin(ColumnFamilyData* cfd,
+                                     Compaction *c, const Status &st,
                                     const CompactionJobStats& job_stats,
                                     int job_id) {
 #ifndef ROCKSDB_LITE
@@ -1310,9 +1305,8 @@ Status DBImpl::Flush(const FlushOptions& flush_options,
                  });
    s = AtomicFlushMemTables(cfds, flush_options, FlushReason::kManualFlush);
    ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "Manual atomic flush finished, status: %s\n"
-                   "=====Column families:=====",
-                   s.ToString().c_str());
+                   "Manual atomic flush finished, status: %s\n",
+                   "=====Column families:=====", s.ToString().c_str());
    for (auto cfh : column_families) {
      auto cfhi = static_cast<ColumnFamilyHandleImpl*>(cfh);
      ROCKS_LOG_INFO(immutable_db_options_.info_log, "%s",
@@ -1449,7 +1443,7 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
      manual.incomplete = false;
      bg_compaction_scheduled_++;
      env_->Schedule(&DBImpl::BGWorkCompaction, ca, Env::Priority::LOW, this,
-                     &DBImpl::UnscheduleCompactionCallback);
+                     &DBImpl::UnscheduleCallback);
      scheduled = true;
    }
  }
@@ -1626,7 +1620,7 @@ Status DBImpl::AtomicFlushMemTables(
 // it against various constrains and delays flush if it'd cause write stall.
 // Called should check status and flush_needed to see if flush already happened.
 Status DBImpl::WaitUntilFlushWouldNotStallWrites(ColumnFamilyData* cfd,
-                                                 bool* flush_needed) {
+    bool* flush_needed) {
  {
    *flush_needed = true;
    InstrumentedMutexLock l(&mutex_);
@@ -1774,7 +1768,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
    // we paused the background work
    return;
  } else if (error_handler_.IsBGWorkStopped() &&
-             !error_handler_.IsRecoveryInProgress()) {
+      !error_handler_.IsRecoveryInProgress()) {
    // There has been a hard error and this call is not part of the recovery
    // sequence. Bail out here so we don't get into an endless loop of
    // scheduling BG work which will again call this function
@@ -1789,11 +1783,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
  while (!is_flush_pool_empty && unscheduled_flushes_ > 0 &&
         bg_flush_scheduled_ < bg_job_limits.max_flushes) {
    bg_flush_scheduled_++;
-    FlushThreadArg* fta = new FlushThreadArg;
-    fta->db_ = this;
-    fta->thread_pri_ = Env::Priority::HIGH;
-    env_->Schedule(&DBImpl::BGWorkFlush, fta, Env::Priority::HIGH, this,
-                   &DBImpl::UnscheduleFlushCallback);
+    env_->Schedule(&DBImpl::BGWorkFlush, this, Env::Priority::HIGH, this);
  }

  // special case -- if high-pri (flush) thread pool is empty, then schedule
@@ -1803,11 +1793,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
           bg_flush_scheduled_ + bg_compaction_scheduled_ <
               bg_job_limits.max_flushes) {
      bg_flush_scheduled_++;
-      FlushThreadArg* fta = new FlushThreadArg;
-      fta->db_ = this;
-      fta->thread_pri_ = Env::Priority::LOW;
-      env_->Schedule(&DBImpl::BGWorkFlush, fta, Env::Priority::LOW, this,
-                     &DBImpl::UnscheduleFlushCallback);
+      env_->Schedule(&DBImpl::BGWorkFlush, this, Env::Priority::LOW, this);
    }
  }

@@ -1837,7 +1823,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
    bg_compaction_scheduled_++;
    unscheduled_compactions_--;
    env_->Schedule(&DBImpl::BGWorkCompaction, ca, Env::Priority::LOW, this,
-                   &DBImpl::UnscheduleCompactionCallback);
+                   &DBImpl::UnscheduleCallback);
  }
 }

@@ -1952,13 +1938,10 @@ void DBImpl::SchedulePendingPurge(std::string fname, std::string dir_to_sync,
  purge_queue_.push_back(std::move(file_info));
 }

-void DBImpl::BGWorkFlush(void* arg) {
-  FlushThreadArg fta = *(reinterpret_cast<FlushThreadArg*>(arg));
-  delete reinterpret_cast<FlushThreadArg*>(arg);
-
-  IOSTATS_SET_THREAD_POOL_ID(fta.thread_pri_);
+void DBImpl::BGWorkFlush(void* db) {
+  IOSTATS_SET_THREAD_POOL_ID(Env::Priority::HIGH);
  TEST_SYNC_POINT("DBImpl::BGWorkFlush");
-  reinterpret_cast<DBImpl*>(fta.db_)->BackgroundCallFlush(fta.thread_pri_);
+  reinterpret_cast<DBImpl*>(db)->BackgroundCallFlush();
  TEST_SYNC_POINT("DBImpl::BGWorkFlush:done");
 }

@@ -1993,7 +1976,7 @@ void DBImpl::BGWorkPurge(void* db) {
  TEST_SYNC_POINT("DBImpl::BGWorkPurge:end");
 }

-void DBImpl::UnscheduleCompactionCallback(void* arg) {
+void DBImpl::UnscheduleCallback(void* arg) {
  CompactionArg ca = *(reinterpret_cast<CompactionArg*>(arg));
  delete reinterpret_cast<CompactionArg*>(arg);
  if (ca.prepicked_compaction != nullptr) {
@@ -2002,17 +1985,11 @@ void DBImpl::UnscheduleCompactionCallback(void* arg) {
    }
    delete ca.prepicked_compaction;
  }
-  TEST_SYNC_POINT("DBImpl::UnscheduleCompactionCallback");
-}
-
-void DBImpl::UnscheduleFlushCallback(void* arg) {
-  delete reinterpret_cast<FlushThreadArg*>(arg);
-  TEST_SYNC_POINT("DBImpl::UnscheduleFlushCallback");
+  TEST_SYNC_POINT("DBImpl::UnscheduleCallback");
 }

 Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
-                               LogBuffer* log_buffer, FlushReason* reason,
-                               Env::Priority thread_pri) {
+                               LogBuffer* log_buffer, FlushReason* reason) {
  mutex_.AssertHeld();

  Status status;
@@ -2073,7 +2050,7 @@ Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
          bg_compaction_scheduled_);
    }
    status = FlushMemTablesToOutputFiles(bg_flush_args, made_progress,
-                                         job_context, log_buffer, thread_pri);
+                                         job_context, log_buffer);
    // All the CFDs in the FlushReq must have the same flush reason, so just
    // grab the first one
    *reason = bg_flush_args[0].cfd_->GetFlushReason();
@@ -2088,7 +2065,7 @@ Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
  return status;
 }

-void DBImpl::BackgroundCallFlush(Env::Priority thread_pri) {
+void DBImpl::BackgroundCallFlush() {
  bool made_progress = false;
  JobContext job_context(next_job_id_.fetch_add(1), true);

@@ -2105,8 +2082,8 @@ void DBImpl::BackgroundCallFlush(Env::Priority thread_pri) {
        CaptureCurrentFileNumberInPendingOutputs();
    FlushReason reason;

-    Status s = BackgroundFlush(&made_progress, &job_context, &log_buffer,
-                               &reason, thread_pri);
+    Status s =
+        BackgroundFlush(&made_progress, &job_context, &log_buffer, &reason);
    if (!s.ok() && !s.IsShutdownInProgress() &&
        reason != FlushReason::kErrorRecovery) {
      // Wait a little bit before retrying background flush in
@@ -2189,12 +2166,12 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
            bg_bottom_compaction_scheduled_) ||
           (bg_thread_pri == Env::Priority::LOW && bg_compaction_scheduled_));
    Status s = BackgroundCompaction(&made_progress, &job_context, &log_buffer,
-                                    prepicked_compaction, bg_thread_pri);
+                                    prepicked_compaction);
    TEST_SYNC_POINT("BackgroundCallCompaction:1");
    if (s.IsBusy()) {
      bg_cv_.SignalAll();  // In case a waiter can proceed despite the error
      mutex_.Unlock();
-      env_->SleepForMicroseconds(10000);  // prevent hot loop
+      env_->SleepForMicroseconds(10000); // prevent hot loop
      mutex_.Lock();
    } else if (!s.ok() && !s.IsShutdownInProgress()) {
      // Wait a little bit before retrying background compaction in
@@ -2276,8 +2253,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
 Status DBImpl::BackgroundCompaction(bool* made_progress,
                                    JobContext* job_context,
                                    LogBuffer* log_buffer,
-                                    PrepickedCompaction* prepicked_compaction,
-                                    Env::Priority thread_pri) {
+                                    PrepickedCompaction* prepicked_compaction) {
  ManualCompactionState* manual_compaction =
      prepicked_compaction == nullptr
          ? nullptr
@@ -2440,8 +2416,8 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
          status = Status::CompactionTooLarge();
        } else {
          // update statistics
-          RecordInHistogram(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
-                            c->inputs(0)->size());
+          MeasureTime(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
+                      c->inputs(0)->size());
          // There are three things that can change compaction score:
          // 1) When flush or compaction finish. This case is covered by
          // InstallSuperVersionAndScheduleWork
@@ -2590,7 +2566,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    ca->prepicked_compaction->task_token = std::move(task_token);
    ++bg_bottom_compaction_scheduled_;
    env_->Schedule(&DBImpl::BGWorkBottomCompaction, ca, Env::Priority::BOTTOM,
-                   this, &DBImpl::UnscheduleCompactionCallback);
+                   this, &DBImpl::UnscheduleCallback);
  } else {
    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:BeforeCompaction",
                             c->column_family_data());
@@ -2609,11 +2585,11 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
        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_, &error_handler_, snapshot_seqs,
-        earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
-        &event_logger_, c->mutable_cf_options()->paranoid_file_checks,
+        &mutex_, &error_handler_, 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_,
-        &compaction_job_stats, thread_pri);
+        &compaction_job_stats);
    compaction_job.Prepare();

    NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
@@ -2836,7 +2812,7 @@ void DBImpl::BuildCompactionJobInfo(
                              fmd->fd.GetNumber(), fmd->fd.GetPathId());
      compaction_job_info->input_files.push_back(fn);
      if (compaction_job_info->table_properties.count(fn) == 0) {
-        std::shared_ptr<const TableProperties> tp;
+        shared_ptr<const TableProperties> tp;
        auto s = current->GetTableProperties(&tp, fmd, &fn);
        if (s.ok()) {
          compaction_job_info->table_properties[fn] = tp;
@@ -2883,17 +2859,6 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
  }
  cfd->InstallSuperVersion(sv_context, &mutex_, mutable_cf_options);

-  // There may be a small data race here. The snapshot tricking bottommost
-  // compaction may already be released here. But assuming there will always be
-  // newer snapshot created and released frequently, the compaction will be
-  // triggered soon anyway.
-  bottommost_files_mark_threshold_ = kMaxSequenceNumber;
-  for (auto* my_cfd : *versions_->GetColumnFamilySet()) {
-    bottommost_files_mark_threshold_ = std::min(
-        bottommost_files_mark_threshold_,
-        my_cfd->current()->storage_info()->bottommost_files_mark_threshold());
-  }
-
  // Whenever we install new SuperVersion, we might need to issue new flushes or
  // compactions.
  SchedulePendingCompaction(cfd);
@@ -26,16 +26,10 @@ void DBImpl::TEST_SwitchWAL() {
  SwitchWAL(&write_context);
 }

-bool DBImpl::TEST_WALBufferIsEmpty(bool lock) {
-  if (lock) {
-    log_write_mutex_.Lock();
-  }
+bool DBImpl::TEST_WALBufferIsEmpty() {
+  InstrumentedMutexLock wl(&log_write_mutex_);
  log::Writer* cur_log_writer = logs_.back().writer;
-  auto res = cur_log_writer->TEST_BufferIsEmpty();
-  if (lock) {
-    log_write_mutex_.Unlock();
-  }
-  return res;
+  return cur_log_writer->TEST_BufferIsEmpty();
 }

 int64_t DBImpl::TEST_MaxNextLevelOverlappingBytes(
@@ -107,7 +101,7 @@ Status DBImpl::TEST_SwitchMemtable(ColumnFamilyData* cfd) {
 }

 Status DBImpl::TEST_FlushMemTable(bool wait, bool allow_write_stall,
-                                  ColumnFamilyHandle* cfh) {
+    ColumnFamilyHandle* cfh) {
  FlushOptions fo;
  fo.wait = wait;
  fo.allow_write_stall = allow_write_stall;
@@ -149,9 +143,13 @@ Status DBImpl::TEST_WaitForCompact(bool wait_unscheduled) {
  return error_handler_.GetBGError();
 }

-void DBImpl::TEST_LockMutex() { mutex_.Lock(); }
+void DBImpl::TEST_LockMutex() {
+  mutex_.Lock();
+}

-void DBImpl::TEST_UnlockMutex() { mutex_.Unlock(); }
+void DBImpl::TEST_UnlockMutex() {
+  mutex_.Unlock();
+}

 void* DBImpl::TEST_BeginWrite() {
  auto w = new WriteThread::Writer();
@@ -245,24 +243,10 @@ size_t DBImpl::TEST_GetWalPreallocateBlockSize(
  return GetWalPreallocateBlockSize(write_buffer_size);
 }

-void DBImpl::TEST_WaitForDumpStatsRun(std::function<void()> callback) const {
+void DBImpl::TEST_WaitForTimedTaskRun(std::function<void()> callback) const {
  if (thread_dump_stats_ != nullptr) {
    thread_dump_stats_->TEST_WaitForRun(callback);
  }
 }
-
-void DBImpl::TEST_WaitForPersistStatsRun(std::function<void()> callback) const {
-  if (thread_persist_stats_ != nullptr) {
-    thread_persist_stats_->TEST_WaitForRun(callback);
-  }
-}
-
-bool DBImpl::TEST_IsPersistentStatsEnabled() const {
-  return thread_persist_stats_ && thread_persist_stats_->IsRunning();
-}
-
-size_t DBImpl::TEST_EstiamteStatsHistorySize() const {
-  return EstiamteStatsHistorySize();
-}
 }  // namespace rocksdb
 #endif  // NDEBUG
@@ -108,7 +108,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
  versions_->AddLiveFiles(&job_context->sst_live);
  if (doing_the_full_scan) {
    InfoLogPrefix info_log_prefix(!immutable_db_options_.db_log_dir.empty(),
-                                  dbname_);
+        dbname_);
    std::set<std::string> paths;
    for (size_t path_id = 0; path_id < immutable_db_options_.db_paths.size();
         path_id++) {
@@ -152,7 +152,8 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
        }

        // TODO(icanadi) clean up this mess to avoid having one-off "/" prefixes
-        job_context->full_scan_candidate_files.emplace_back("/" + file, path);
+        job_context->full_scan_candidate_files.emplace_back(
+            "/" + file, path);
      }
    }

@@ -162,8 +163,8 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
      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);
+        job_context->full_scan_candidate_files.emplace_back(log_file,
+            immutable_db_options_.wal_dir);
      }
    }
    // Add info log files in db_log_dir
@@ -173,8 +174,8 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
      // 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);
+        job_context->full_scan_candidate_files.emplace_back(log_file,
+            immutable_db_options_.db_log_dir);
      }
    }
  }
@@ -259,14 +260,14 @@ void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
                                    const std::string& path_to_sync,
                                    FileType type, uint64_t number) {
  Status file_deletion_status;
-  if (type == kTableFile || type == kLogFile) {
+  if (type == kTableFile) {
    file_deletion_status =
-        DeleteDBFile(&immutable_db_options_, fname, path_to_sync);
+        DeleteSSTFile(&immutable_db_options_, fname, path_to_sync);
  } else {
    file_deletion_status = env_->DeleteFile(fname);
  }
  TEST_SYNC_POINT_CALLBACK("DBImpl::DeleteObsoleteFileImpl:AfterDeletion",
-                           &file_deletion_status);
+      &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,
@@ -321,8 +322,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
  const char* kDumbDbName = "";
  for (auto& file : state.sst_delete_files) {
    candidate_files.emplace_back(
-        MakeTableFileName(kDumbDbName, file.metadata->fd.GetNumber()),
-        file.path);
+        MakeTableFileName(kDumbDbName, file.metadata->fd.GetNumber()), file.path);
    if (file.metadata->table_reader_handle) {
      table_cache_->Release(file.metadata->table_reader_handle);
    }
@@ -332,7 +332,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
  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);
+          immutable_db_options_.wal_dir);
    }
  }
  for (const auto& filename : state.manifest_delete_files) {
@@ -465,12 +465,13 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
    } else {
      dir_to_sync =
          (type == kLogFile) ? immutable_db_options_.wal_dir : dbname_;
-      fname = dir_to_sync +
-              ((!dir_to_sync.empty() && dir_to_sync.back() == '/') ||
-                       (!to_delete.empty() && to_delete.front() == '/')
-                   ? ""
-                   : "/") +
-              to_delete;
+      fname = dir_to_sync
+            + (
+                (!dir_to_sync.empty() && dir_to_sync.back() == '/') ||
+                (!to_delete.empty() && to_delete.front() == '/')
+                ? "" : "/"
+              )
+            + to_delete;
    }

 #ifndef ROCKSDB_LITE
@@ -176,7 +176,7 @@ static Status ValidateOptions(
      return s;
    }

-    if (cfd.options.ttl > 0) {
+    if (cfd.options.ttl > 0 || 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 "
@@ -512,7 +512,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
    Logger* info_log;
    const char* fname;
    Status* status;  // nullptr if immutable_db_options_.paranoid_checks==false
-    void Corruption(size_t bytes, const Status& s) override {
+    virtual void Corruption(size_t bytes, const Status& s) override {
      ROCKS_LOG_WARN(info_log, "%s%s: dropping %d bytes; %s",
                     (this->status == nullptr ? "(ignoring error) " : ""),
                     fname, static_cast<int>(bytes), s.ToString().c_str());
@@ -580,7 +580,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,

    ROCKS_LOG_INFO(immutable_db_options_.info_log,
                   "Recovering log #%" PRIu64 " mode %d", log_number,
-                   static_cast<int>(immutable_db_options_.wal_recovery_mode));
+                   immutable_db_options_.wal_recovery_mode);
    auto logFileDropped = [this, &fname]() {
      uint64_t bytes;
      if (env_->GetFileSize(fname, &bytes).ok()) {
@@ -629,7 +629,8 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
    // to be skipped instead of propagating bad information (like overly
    // large sequence numbers).
    log::Reader reader(immutable_db_options_.info_log, std::move(file_reader),
-                       &reporter, true /*checksum*/, log_number);
+                       &reporter, true /*checksum*/, log_number,
+                       false /* retry_after_eof */);

    // Determine if we should tolerate incomplete records at the tail end of the
    // Read all the records and add to a memtable
@@ -723,8 +724,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
                " mode %d log filter %s returned "
                "more records (%d) than original (%d) which is not allowed. "
                "Aborting recovery.",
-                log_number,
-                static_cast<int>(immutable_db_options_.wal_recovery_mode),
+                log_number, immutable_db_options_.wal_recovery_mode,
                immutable_db_options_.wal_filter->Name(), new_count,
                original_count);
            status = Status::NotSupported(
@@ -1029,7 +1029,6 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
          snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
          GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
-          mutable_cf_options.sample_for_compression,
          cfd->ioptions()->compression_opts, paranoid_file_checks,
          cfd->internal_stats(), TableFileCreationReason::kRecovery,
          &event_logger_, job_id, Env::IO_HIGH, nullptr /* table_properties */,
@@ -1059,7 +1058,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
  stats.micros = env_->NowMicros() - start_micros;
  stats.bytes_written = meta.fd.GetFileSize();
  stats.num_output_files = 1;
-  cfd->internal_stats()->AddCompactionStats(level, Env::Priority::USER, stats);
+  cfd->internal_stats()->AddCompactionStats(level, stats);
  cfd->internal_stats()->AddCFStats(InternalStats::BYTES_FLUSHED,
                                    meta.fd.GetFileSize());
  RecordTick(stats_, COMPACT_WRITE_BYTES, meta.fd.GetFileSize());
@@ -1317,8 +1316,7 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
 #endif  // !ROCKSDB_LITE

  if (s.ok()) {
-    ROCKS_LOG_HEADER(impl->immutable_db_options_.info_log, "DB pointer %p",
-                     impl);
+    ROCKS_LOG_INFO(impl->immutable_db_options_.info_log, "DB pointer %p", impl);
    LogFlush(impl->immutable_db_options_.info_log);
    assert(impl->TEST_WALBufferIsEmpty());
    // If the assert above fails then we need to FlushWAL before returning
@@ -60,7 +60,7 @@ Status DBImplReadOnly::Get(const ReadOptions& read_options,
  RecordTick(stats_, NUMBER_KEYS_READ);
  size_t size = pinnable_val->size();
  RecordTick(stats_, BYTES_READ, size);
-  RecordInHistogram(stats_, BYTES_PER_READ, size);
+  MeasureTime(stats_, BYTES_PER_READ, size);
  PERF_COUNTER_ADD(get_read_bytes, size);
  return s;
 }
@@ -7,9 +7,9 @@

 #ifndef ROCKSDB_LITE

-#include <string>
-#include <vector>
 #include "db/db_impl.h"
+#include <vector>
+#include <string>

 namespace rocksdb {

@@ -122,6 +122,6 @@ class DBImplReadOnly : public DBImpl {
  DBImplReadOnly(const DBImplReadOnly&);
  void operator=(const DBImplReadOnly&);
 };
-}  // namespace rocksdb
+}

 #endif  // !ROCKSDB_LITE
@@ -1,356 +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/db_impl_secondary.h"
-#include "db/db_iter.h"
-#include "db/merge_context.h"
-#include "monitoring/perf_context_imp.h"
-#include "util/auto_roll_logger.h"
-
-namespace rocksdb {
-
-#ifndef ROCKSDB_LITE
-
-DBImplSecondary::DBImplSecondary(const DBOptions& db_options,
-                                 const std::string& dbname)
-    : DBImpl(db_options, dbname) {
-  ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                 "Opening the db in secondary mode");
-  LogFlush(immutable_db_options_.info_log);
-}
-
-DBImplSecondary::~DBImplSecondary() {}
-
-Status DBImplSecondary::Recover(
-    const std::vector<ColumnFamilyDescriptor>& column_families,
-    bool /*readonly*/, bool /*error_if_log_file_exist*/,
-    bool /*error_if_data_exists_in_logs*/) {
-  mutex_.AssertHeld();
-
-  Status s;
-  s = static_cast<ReactiveVersionSet*>(versions_.get())
-          ->Recover(column_families, &manifest_reader_, &manifest_reporter_,
-                    &manifest_reader_status_);
-  if (!s.ok()) {
-    return s;
-  }
-  if (immutable_db_options_.paranoid_checks && s.ok()) {
-    s = CheckConsistency();
-  }
-  // Initial max_total_in_memory_state_ before recovery logs.
-  max_total_in_memory_state_ = 0;
-  for (auto cfd : *versions_->GetColumnFamilySet()) {
-    auto* mutable_cf_options = cfd->GetLatestMutableCFOptions();
-    max_total_in_memory_state_ += mutable_cf_options->write_buffer_size *
-                                  mutable_cf_options->max_write_buffer_number;
-  }
-  if (s.ok()) {
-    default_cf_handle_ = new ColumnFamilyHandleImpl(
-        versions_->GetColumnFamilySet()->GetDefault(), this, &mutex_);
-    default_cf_internal_stats_ = default_cf_handle_->cfd()->internal_stats();
-    single_column_family_mode_ =
-        versions_->GetColumnFamilySet()->NumberOfColumnFamilies() == 1;
-  }
-
-  // TODO: attempt to recover from WAL files.
-  return s;
-}
-
-// Implementation of the DB interface
-Status DBImplSecondary::Get(const ReadOptions& read_options,
-                            ColumnFamilyHandle* column_family, const Slice& key,
-                            PinnableSlice* value) {
-  return GetImpl(read_options, column_family, key, value);
-}
-
-Status DBImplSecondary::GetImpl(const ReadOptions& read_options,
-                                ColumnFamilyHandle* column_family,
-                                const Slice& key, PinnableSlice* pinnable_val) {
-  assert(pinnable_val != nullptr);
-  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
-  StopWatch sw(env_, stats_, DB_GET);
-  PERF_TIMER_GUARD(get_snapshot_time);
-
-  auto cfh = static_cast<ColumnFamilyHandleImpl*>(column_family);
-  ColumnFamilyData* cfd = cfh->cfd();
-  if (tracer_) {
-    InstrumentedMutexLock lock(&trace_mutex_);
-    if (tracer_) {
-      tracer_->Get(column_family, key);
-    }
-  }
-  // Acquire SuperVersion
-  SuperVersion* super_version = GetAndRefSuperVersion(cfd);
-  SequenceNumber snapshot = versions_->LastSequence();
-  MergeContext merge_context;
-  SequenceNumber max_covering_tombstone_seq = 0;
-  Status s;
-  LookupKey lkey(key, snapshot);
-  PERF_TIMER_STOP(get_snapshot_time);
-
-  bool done = false;
-  if (super_version->mem->Get(lkey, pinnable_val->GetSelf(), &s, &merge_context,
-                              &max_covering_tombstone_seq, read_options)) {
-    done = true;
-    pinnable_val->PinSelf();
-    RecordTick(stats_, MEMTABLE_HIT);
-  } else if ((s.ok() || s.IsMergeInProgress()) &&
-             super_version->imm->Get(
-                 lkey, pinnable_val->GetSelf(), &s, &merge_context,
-                 &max_covering_tombstone_seq, read_options)) {
-    done = true;
-    pinnable_val->PinSelf();
-    RecordTick(stats_, MEMTABLE_HIT);
-  }
-  if (!done && !s.ok() && !s.IsMergeInProgress()) {
-    ReturnAndCleanupSuperVersion(cfd, super_version);
-    return s;
-  }
-  if (!done) {
-    PERF_TIMER_GUARD(get_from_output_files_time);
-    super_version->current->Get(read_options, lkey, pinnable_val, &s,
-                                &merge_context, &max_covering_tombstone_seq);
-    RecordTick(stats_, MEMTABLE_MISS);
-  }
-  {
-    PERF_TIMER_GUARD(get_post_process_time);
-    ReturnAndCleanupSuperVersion(cfd, super_version);
-    RecordTick(stats_, NUMBER_KEYS_READ);
-    size_t size = pinnable_val->size();
-    RecordTick(stats_, BYTES_READ, size);
-    RecordTimeToHistogram(stats_, BYTES_PER_READ, size);
-    PERF_COUNTER_ADD(get_read_bytes, size);
-  }
-  return s;
-}
-
-Iterator* DBImplSecondary::NewIterator(const ReadOptions& read_options,
-                                       ColumnFamilyHandle* column_family) {
-  if (read_options.managed) {
-    return NewErrorIterator(
-        Status::NotSupported("Managed iterator is not supported anymore."));
-  }
-  if (read_options.read_tier == kPersistedTier) {
-    return NewErrorIterator(Status::NotSupported(
-        "ReadTier::kPersistedData is not yet supported in iterators."));
-  }
-  Iterator* result = nullptr;
-  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
-  auto cfd = cfh->cfd();
-  ReadCallback* read_callback = nullptr;  // No read callback provided.
-  if (read_options.tailing) {
-    return NewErrorIterator(Status::NotSupported(
-        "tailing iterator not supported in secondary mode"));
-  } else if (read_options.snapshot != nullptr) {
-    // TODO (yanqin) support snapshot.
-    return NewErrorIterator(
-        Status::NotSupported("snapshot not supported in secondary mode"));
-  } else {
-    auto snapshot = versions_->LastSequence();
-    result = NewIteratorImpl(read_options, cfd, snapshot, read_callback);
-  }
-  return result;
-}
-
-ArenaWrappedDBIter* DBImplSecondary::NewIteratorImpl(
-    const ReadOptions& read_options, ColumnFamilyData* cfd,
-    SequenceNumber snapshot, ReadCallback* read_callback) {
-  assert(nullptr != cfd);
-  SuperVersion* super_version = cfd->GetReferencedSuperVersion(&mutex_);
-  auto db_iter = NewArenaWrappedDbIterator(
-      env_, read_options, *cfd->ioptions(), super_version->mutable_cf_options,
-      snapshot,
-      super_version->mutable_cf_options.max_sequential_skip_in_iterations,
-      super_version->version_number, read_callback);
-  auto internal_iter =
-      NewInternalIterator(read_options, cfd, super_version, db_iter->GetArena(),
-                          db_iter->GetRangeDelAggregator(), snapshot);
-  db_iter->SetIterUnderDBIter(internal_iter);
-  return db_iter;
-}
-
-Status DBImplSecondary::NewIterators(
-    const ReadOptions& read_options,
-    const std::vector<ColumnFamilyHandle*>& column_families,
-    std::vector<Iterator*>* iterators) {
-  if (read_options.managed) {
-    return Status::NotSupported("Managed iterator is not supported anymore.");
-  }
-  if (read_options.read_tier == kPersistedTier) {
-    return Status::NotSupported(
-        "ReadTier::kPersistedData is not yet supported in iterators.");
-  }
-  ReadCallback* read_callback = nullptr;  // No read callback provided.
-  if (iterators == nullptr) {
-    return Status::InvalidArgument("iterators not allowed to be nullptr");
-  }
-  iterators->clear();
-  iterators->reserve(column_families.size());
-  if (read_options.tailing) {
-    return Status::NotSupported(
-        "tailing iterator not supported in secondary mode");
-  } else if (read_options.snapshot != nullptr) {
-    // TODO (yanqin) support snapshot.
-    return Status::NotSupported("snapshot not supported in secondary mode");
-  } else {
-    SequenceNumber read_seq = versions_->LastSequence();
-    for (auto cfh : column_families) {
-      ColumnFamilyData* cfd = static_cast<ColumnFamilyHandleImpl*>(cfh)->cfd();
-      iterators->push_back(
-          NewIteratorImpl(read_options, cfd, read_seq, read_callback));
-    }
-  }
-  return Status::OK();
-}
-
-Status DBImplSecondary::TryCatchUpWithPrimary() {
-  assert(versions_.get() != nullptr);
-  assert(manifest_reader_.get() != nullptr);
-  Status s;
-  std::unordered_set<ColumnFamilyData*> cfds_changed;
-  InstrumentedMutexLock lock_guard(&mutex_);
-  s = static_cast<ReactiveVersionSet*>(versions_.get())
-          ->ReadAndApply(&mutex_, &manifest_reader_, &cfds_changed);
-  if (s.ok()) {
-    SuperVersionContext sv_context(true /* create_superversion */);
-    for (auto cfd : cfds_changed) {
-      sv_context.NewSuperVersion();
-      cfd->InstallSuperVersion(&sv_context, &mutex_);
-    }
-    sv_context.Clean();
-  }
-  return s;
-}
-
-Status DB::OpenAsSecondary(const Options& options, const std::string& dbname,
-                           const std::string& secondary_path, DB** dbptr) {
-  *dbptr = nullptr;
-
-  DBOptions db_options(options);
-  ColumnFamilyOptions cf_options(options);
-  std::vector<ColumnFamilyDescriptor> column_families;
-  column_families.emplace_back(kDefaultColumnFamilyName, cf_options);
-  std::vector<ColumnFamilyHandle*> handles;
-
-  Status s = DB::OpenAsSecondary(db_options, dbname, secondary_path,
-                                 column_families, &handles, dbptr);
-  if (s.ok()) {
-    assert(handles.size() == 1);
-    delete handles[0];
-  }
-  return s;
-}
-
-Status DB::OpenAsSecondary(
-    const DBOptions& db_options, const std::string& dbname,
-    const std::string& secondary_path,
-    const std::vector<ColumnFamilyDescriptor>& column_families,
-    std::vector<ColumnFamilyHandle*>* handles, DB** dbptr) {
-  *dbptr = nullptr;
-  if (db_options.max_open_files != -1) {
-    // TODO (yanqin) maybe support max_open_files != -1 by creating hard links
-    // on SST files so that db secondary can still have access to old SSTs
-    // while primary instance may delete original.
-    return Status::InvalidArgument("require max_open_files to be -1");
-  }
-
-  DBOptions tmp_opts(db_options);
-  if (nullptr == tmp_opts.info_log) {
-    Env* env = tmp_opts.env;
-    assert(env != nullptr);
-    std::string secondary_abs_path;
-    env->GetAbsolutePath(secondary_path, &secondary_abs_path);
-    std::string fname = InfoLogFileName(secondary_path, secondary_abs_path,
-                                        tmp_opts.db_log_dir);
-
-    env->CreateDirIfMissing(secondary_path);
-    if (tmp_opts.log_file_time_to_roll > 0 || tmp_opts.max_log_file_size > 0) {
-      AutoRollLogger* result = new AutoRollLogger(
-          env, secondary_path, tmp_opts.db_log_dir, tmp_opts.max_log_file_size,
-          tmp_opts.log_file_time_to_roll, tmp_opts.info_log_level);
-      Status s = result->GetStatus();
-      if (!s.ok()) {
-        delete result;
-      } else {
-        tmp_opts.info_log.reset(result);
-      }
-    }
-    if (nullptr == tmp_opts.info_log) {
-      env->RenameFile(
-          fname, OldInfoLogFileName(secondary_path, env->NowMicros(),
-                                    secondary_abs_path, tmp_opts.db_log_dir));
-      Status s = env->NewLogger(fname, &(tmp_opts.info_log));
-      if (tmp_opts.info_log != nullptr) {
-        tmp_opts.info_log->SetInfoLogLevel(tmp_opts.info_log_level);
-      }
-    }
-  }
-
-  assert(tmp_opts.info_log != nullptr);
-
-  handles->clear();
-  DBImplSecondary* impl = new DBImplSecondary(tmp_opts, dbname);
-  impl->versions_.reset(new ReactiveVersionSet(
-      dbname, &impl->immutable_db_options_, impl->env_options_,
-      impl->table_cache_.get(), impl->write_buffer_manager_,
-      &impl->write_controller_));
-  impl->column_family_memtables_.reset(
-      new ColumnFamilyMemTablesImpl(impl->versions_->GetColumnFamilySet()));
-  impl->mutex_.Lock();
-  Status s = impl->Recover(column_families, true, false, false);
-  if (s.ok()) {
-    for (auto cf : column_families) {
-      auto cfd =
-          impl->versions_->GetColumnFamilySet()->GetColumnFamily(cf.name);
-      if (nullptr == cfd) {
-        s = Status::InvalidArgument("Column family not found: ", cf.name);
-        break;
-      }
-      handles->push_back(new ColumnFamilyHandleImpl(cfd, impl, &impl->mutex_));
-    }
-  }
-  SuperVersionContext sv_context(true /* create_superversion */);
-  if (s.ok()) {
-    for (auto cfd : *impl->versions_->GetColumnFamilySet()) {
-      sv_context.NewSuperVersion();
-      cfd->InstallSuperVersion(&sv_context, &impl->mutex_);
-    }
-  }
-  impl->mutex_.Unlock();
-  sv_context.Clean();
-  if (s.ok()) {
-    *dbptr = impl;
-    for (auto h : *handles) {
-      impl->NewThreadStatusCfInfo(
-          reinterpret_cast<ColumnFamilyHandleImpl*>(h)->cfd());
-    }
-  } else {
-    for (auto h : *handles) {
-      delete h;
-    }
-    handles->clear();
-    delete impl;
-  }
-  return s;
-}
-#else   // !ROCKSDB_LITE
-
-Status DB::OpenAsSecondary(const Options& /*options*/,
-                           const std::string& /*name*/,
-                           const std::string& /*secondary_path*/,
-                           DB** /*dbptr*/) {
-  return Status::NotSupported("Not supported in ROCKSDB_LITE.");
-}
-
-Status DB::OpenAsSecondary(
-    const DBOptions& /*db_options*/, const std::string& /*dbname*/,
-    const std::string& /*secondary_path*/,
-    const std::vector<ColumnFamilyDescriptor>& /*column_families*/,
-    std::vector<ColumnFamilyHandle*>* /*handles*/, DB** /*dbptr*/) {
-  return Status::NotSupported("Not supported in ROCKSDB_LITE.");
-}
-#endif  // !ROCKSDB_LITE
-
-}  // namespace rocksdb
@@ -1,151 +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
-
-#ifndef ROCKSDB_LITE
-
-#include <string>
-#include <vector>
-#include "db/db_impl.h"
-
-namespace rocksdb {
-
-class DBImplSecondary : public DBImpl {
- public:
-  DBImplSecondary(const DBOptions& options, const std::string& dbname);
-  ~DBImplSecondary() override;
-
-  Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
-                 bool read_only, bool error_if_log_file_exist,
-                 bool error_if_data_exists_in_logs) override;
-
-  // Implementations of the DB interface
-  using DB::Get;
-  Status Get(const ReadOptions& options, ColumnFamilyHandle* column_family,
-             const Slice& key, PinnableSlice* value) override;
-
-  Status GetImpl(const ReadOptions& options, ColumnFamilyHandle* column_family,
-                 const Slice& key, PinnableSlice* value);
-
-  using DBImpl::NewIterator;
-  Iterator* NewIterator(const ReadOptions&,
-                        ColumnFamilyHandle* column_family) override;
-
-  ArenaWrappedDBIter* NewIteratorImpl(const ReadOptions& read_options,
-                                      ColumnFamilyData* cfd,
-                                      SequenceNumber snapshot,
-                                      ReadCallback* read_callback);
-
-  Status NewIterators(const ReadOptions& options,
-                      const std::vector<ColumnFamilyHandle*>& column_families,
-                      std::vector<Iterator*>* iterators) override;
-
-  using DBImpl::Put;
-  Status Put(const WriteOptions& /*options*/,
-             ColumnFamilyHandle* /*column_family*/, const Slice& /*key*/,
-             const Slice& /*value*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::Merge;
-  Status Merge(const WriteOptions& /*options*/,
-               ColumnFamilyHandle* /*column_family*/, const Slice& /*key*/,
-               const Slice& /*value*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::Delete;
-  Status Delete(const WriteOptions& /*options*/,
-                ColumnFamilyHandle* /*column_family*/,
-                const Slice& /*key*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::SingleDelete;
-  Status SingleDelete(const WriteOptions& /*options*/,
-                      ColumnFamilyHandle* /*column_family*/,
-                      const Slice& /*key*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status Write(const WriteOptions& /*options*/,
-               WriteBatch* /*updates*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::CompactRange;
-  Status CompactRange(const CompactRangeOptions& /*options*/,
-                      ColumnFamilyHandle* /*column_family*/,
-                      const Slice* /*begin*/, const Slice* /*end*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::CompactFiles;
-  Status CompactFiles(
-      const CompactionOptions& /*compact_options*/,
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*input_file_names*/,
-      const int /*output_level*/, const int /*output_path_id*/ = -1,
-      std::vector<std::string>* const /*output_file_names*/ = nullptr,
-      CompactionJobInfo* /*compaction_job_info*/ = nullptr) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status DisableFileDeletions() override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status EnableFileDeletions(bool /*force*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status GetLiveFiles(std::vector<std::string>&,
-                      uint64_t* /*manifest_file_size*/,
-                      bool /*flush_memtable*/ = true) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::Flush;
-  Status Flush(const FlushOptions& /*options*/,
-               ColumnFamilyHandle* /*column_family*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::SyncWAL;
-  Status SyncWAL() override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DB::IngestExternalFile;
-  Status IngestExternalFile(
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*external_files*/,
-      const IngestExternalFileOptions& /*ingestion_options*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  // Try to catch up with the primary by reading as much as possible from the
-  // log files until there is nothing more to read or encounters an error. If
-  // the amount of information in the log files to process is huge, this
-  // method can take long time due to all the I/O and CPU costs.
-  Status TryCatchUpWithPrimary() override;
-
- private:
-  friend class DB;
-
-  // No copying allowed
-  DBImplSecondary(const DBImplSecondary&);
-  void operator=(const DBImplSecondary&);
-
-  using DBImpl::Recover;
-
-  std::unique_ptr<log::FragmentBufferedReader> manifest_reader_;
-  std::unique_ptr<log::Reader::Reporter> manifest_reporter_;
-  std::unique_ptr<Status> manifest_reader_status_;
-};
-}  // namespace rocksdb
-
-#endif  // !ROCKSDB_LITE
@@ -146,6 +146,17 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,

    if (write_thread_.CompleteParallelMemTableWriter(&w)) {
      // we're responsible for exit batch group
+      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);
+          if (!ws.ok()) {
+            status = ws;
+            break;
+          }
+        }
+      }
      // TODO(myabandeh): propagate status to write_group
      auto last_sequence = w.write_group->last_sequence;
      versions_->SetLastSequence(last_sequence);
@@ -268,7 +279,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
                        concurrent_update);
      RecordTick(stats_, WRITE_DONE_BY_OTHER, write_done_by_other);
    }
-    RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);
+    MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);

    if (write_options.disableWAL) {
      has_unpersisted_data_.store(true, std::memory_order_relaxed);
@@ -298,35 +309,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    const SequenceNumber current_sequence = last_sequence + 1;
    last_sequence += seq_inc;

-    // PreReleaseCallback is called after WAL write and before memtable write
-    if (status.ok()) {
-      SequenceNumber next_sequence = current_sequence;
-      // Note: the logic for advancing seq here must be consistent with the
-      // logic in WriteBatchInternal::InsertInto(write_group...) as well as
-      // with WriteBatchInternal::InsertInto(write_batch...) that is called on
-      // the merged batch during recovery from the WAL.
-      for (auto* writer : write_group) {
-        if (writer->CallbackFailed()) {
-          continue;
-        }
-        writer->sequence = next_sequence;
-        if (writer->pre_release_callback) {
-          Status ws = writer->pre_release_callback->Callback(
-              writer->sequence, disable_memtable, writer->log_used);
-          if (!ws.ok()) {
-            status = ws;
-            break;
-          }
-        }
-        if (seq_per_batch_) {
-          assert(writer->batch_cnt);
-          next_sequence += writer->batch_cnt;
-        } else if (writer->ShouldWriteToMemtable()) {
-          next_sequence += WriteBatchInternal::Count(writer->batch);
-        }
-      }
-    }
-
    if (status.ok()) {
      PERF_TIMER_GUARD(write_memtable_time);

@@ -338,6 +320,23 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
            0 /*recovery_log_number*/, this, parallel, seq_per_batch_,
            batch_per_txn_);
      } else {
+        SequenceNumber next_sequence = current_sequence;
+        // Note: the logic for advancing seq here must be consistent with the
+        // logic in WriteBatchInternal::InsertInto(write_group...) as well as
+        // with WriteBatchInternal::InsertInto(write_batch...) that is called on
+        // the merged batch during recovery from the WAL.
+        for (auto* writer : write_group) {
+          if (writer->CallbackFailed()) {
+            continue;
+          }
+          writer->sequence = next_sequence;
+          if (seq_per_batch_) {
+            assert(writer->batch_cnt);
+            next_sequence += writer->batch_cnt;
+          } else if (writer->ShouldWriteToMemtable()) {
+            next_sequence += WriteBatchInternal::Count(writer->batch);
+          }
+        }
        write_group.last_sequence = last_sequence;
        write_thread_.LaunchParallelMemTableWriters(&write_group);
        in_parallel_group = true;
@@ -389,8 +388,17 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
  }
  if (should_exit_batch_group) {
    if (status.ok()) {
-      // Note: if we are to resume after non-OK statuses we need to revisit how
-      // we reacts to non-OK statuses here.
+      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);
+          if (!ws.ok()) {
+            status = ws;
+            break;
+          }
+        }
+      }
      versions_->SetLastSequence(last_sequence);
    }
    MemTableInsertStatusCheck(w.status);
@@ -463,7 +471,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    RecordTick(stats_, NUMBER_KEYS_WRITTEN, total_count);
    stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size);
    RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
-    RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);
+    MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);

    PERF_TIMER_STOP(write_pre_and_post_process_time);

@@ -594,7 +602,7 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
                      concurrent_update);
    RecordTick(stats_, WRITE_DONE_BY_OTHER, write_done_by_other);
  }
-  RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);
+  MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);

  PERF_TIMER_STOP(write_pre_and_post_process_time);

@@ -649,8 +657,8 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
      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, writer->log_used);
+        Status ws = writer->pre_release_callback->Callback(writer->sequence,
+                                                           DISABLE_MEMTABLE);
        if (!ws.ok()) {
          status = ws;
          break;
@@ -868,7 +876,7 @@ Status DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
  status = WriteToWAL(*merged_batch, log_writer, log_used, &log_size);
  if (to_be_cached_state) {
    cached_recoverable_state_ = *to_be_cached_state;
-    cached_recoverable_state_empty_ = false;
+      cached_recoverable_state_empty_ = false;
  }

  if (status.ok() && need_log_sync) {
@@ -944,7 +952,7 @@ Status DBImpl::ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
  status = WriteToWAL(*merged_batch, log_writer, log_used, &log_size);
  if (to_be_cached_state) {
    cached_recoverable_state_ = *to_be_cached_state;
-    cached_recoverable_state_empty_ = false;
+      cached_recoverable_state_empty_ = false;
  }
  log_write_mutex_.Unlock();

@@ -993,9 +1001,8 @@ Status DBImpl::WriteRecoverableState() {
      const bool DISABLE_MEMTABLE = true;
      for (uint64_t sub_batch_seq = seq + 1;
           sub_batch_seq < next_seq && status.ok(); sub_batch_seq++) {
-        uint64_t const no_log_num = 0;
        status = recoverable_state_pre_release_callback_->Callback(
-            sub_batch_seq, !DISABLE_MEMTABLE, no_log_num);
+            sub_batch_seq, !DISABLE_MEMTABLE);
      }
    }
    if (status.ok()) {
@@ -1065,17 +1072,16 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
  if (!flush_wont_release_oldest_log) {
    // 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.
+    // transactions then we cannot flush this log until those transactions are commited.
    unable_to_release_oldest_log_ = false;
    alive_log_files_.begin()->getting_flushed = true;
  }

-  ROCKS_LOG_INFO(
-      immutable_db_options_.info_log,
-      "Flushing all column families with data in WAL number %" PRIu64
-      ". Total log size is %" PRIu64 " while max_total_wal_size is %" PRIu64,
-      oldest_alive_log, total_log_size_.load(), GetMaxTotalWalSize());
+  ROCKS_LOG_INFO(immutable_db_options_.info_log,
+                 "Flushing all column families with data in WAL number %" PRIu64
+                 ". Total log size is %" PRIu64
+                 " while max_total_wal_size is %" PRIu64,
+                 oldest_alive_log, total_log_size_.load(), GetMaxTotalWalSize());
  // no need to refcount because drop is happening in write thread, so can't
  // happen while we're in the write thread
  autovector<ColumnFamilyData*> cfds;
@@ -1127,7 +1133,7 @@ Status DBImpl::HandleWriteBufferFull(WriteContext* write_context) {
  ROCKS_LOG_INFO(
      immutable_db_options_.info_log,
      "Flushing column family with largest mem table size. Write buffer is "
-      "using %" ROCKSDB_PRIszt " bytes out of a total of %" ROCKSDB_PRIszt ".",
+      "using %" PRIu64 " bytes out of a total of %" PRIu64 ".",
      write_buffer_manager_->memory_usage(),
      write_buffer_manager_->buffer_size());
  // no need to refcount because drop is happening in write thread, so can't
@@ -1421,7 +1427,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  DBOptions db_options =
      BuildDBOptions(immutable_db_options_, mutable_db_options_);
  const auto preallocate_block_size =
-      GetWalPreallocateBlockSize(mutable_cf_options.write_buffer_size);
+    GetWalPreallocateBlockSize(mutable_cf_options.write_buffer_size);
  auto write_hint = CalculateWALWriteHint();
  mutex_.Unlock();
  {
@@ -1463,6 +1469,13 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
      new_mem = cfd->ConstructNewMemtable(mutable_cf_options, seq);
      context->superversion_context.NewSuperVersion();
    }
+
+#ifndef ROCKSDB_LITE
+    // PLEASE NOTE: We assume that there are no failable operations
+    // after lock is acquired below since we are already notifying
+    // client about mem table becoming immutable.
+    NotifyOnMemTableSealed(cfd, memtable_info);
+#endif //ROCKSDB_LITE
  }
  ROCKS_LOG_INFO(immutable_db_options_.info_log,
                 "[%s] New memtable created with log file: #%" PRIu64
@@ -1471,7 +1484,10 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  mutex_.Lock();
  if (s.ok() && creating_new_log) {
    log_write_mutex_.Lock();
+    logfile_number_ = new_log_number;
    assert(new_log != nullptr);
+    log_empty_ = true;
+    log_dir_synced_ = false;
    if (!logs_.empty()) {
      // Alway flush the buffer of the last log before switching to a new one
      log::Writer* cur_log_writer = logs_.back().writer;
@@ -1479,41 +1495,21 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
      if (!s.ok()) {
        ROCKS_LOG_WARN(immutable_db_options_.info_log,
                       "[%s] Failed to switch from #%" PRIu64 " to #%" PRIu64
-                       "  WAL file\n",
+                       "  WAL file -- %s\n",
                       cfd->GetName().c_str(), cur_log_writer->get_log_number(),
                       new_log_number);
      }
    }
-    if (s.ok()) {
-      logfile_number_ = new_log_number;
-      log_empty_ = true;
-      log_dir_synced_ = false;
-      logs_.emplace_back(logfile_number_, new_log);
-      alive_log_files_.push_back(LogFileNumberSize(logfile_number_));
-    }
+    logs_.emplace_back(logfile_number_, new_log);
+    alive_log_files_.push_back(LogFileNumberSize(logfile_number_));
    log_write_mutex_.Unlock();
  }

  if (!s.ok()) {
    // how do we fail if we're not creating new log?
    assert(creating_new_log);
-    if (new_mem) {
-      delete new_mem;
-    }
-    if (new_log) {
-      delete new_log;
-    }
-    SuperVersion* new_superversion =
-        context->superversion_context.new_superversion.release();
-    if (new_superversion != nullptr) {
-      delete new_superversion;
-    }
-    // We may have lost data from the WritableFileBuffer in-memory buffer for
-    // the current log, so treat it as a fatal error and set bg_error
-    error_handler_.SetBGError(s, BackgroundErrorReason::kMemTable);
-    // Read back bg_error in order to get the right severity
-    s = error_handler_.GetBGError();
-
+    assert(!new_mem);
+    assert(!new_log);
    if (two_write_queues_) {
      nonmem_write_thread_.ExitUnbatched(&nonmem_w);
    }
@@ -1540,13 +1536,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  cfd->SetMemtable(new_mem);
  InstallSuperVersionAndScheduleWork(cfd, &context->superversion_context,
                                     mutable_cf_options);
-#ifndef ROCKSDB_LITE
-  mutex_.Unlock();
-  // Notify client that memtable is sealed, now that we have successfully
-  // installed a new memtable
-  NotifyOnMemTableSealed(cfd, memtable_info);
-  mutex_.Lock();
-#endif  // ROCKSDB_LITE
  if (two_write_queues_) {
    nonmem_write_thread_.ExitUnbatched(&nonmem_w);
  }
@@ -1555,13 +1544,13 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {

 size_t DBImpl::GetWalPreallocateBlockSize(uint64_t write_buffer_size) const {
  mutex_.AssertHeld();
-  size_t bsize =
-      static_cast<size_t>(write_buffer_size / 10 + write_buffer_size);
+  size_t bsize = static_cast<size_t>(
+    write_buffer_size / 10 + write_buffer_size);
  // Some users might set very high write_buffer_size and rely on
  // max_total_wal_size or other parameters to control the WAL size.
  if (mutable_db_options_.max_total_wal_size > 0) {
-    bsize = std::min<size_t>(
-        bsize, static_cast<size_t>(mutable_db_options_.max_total_wal_size));
+    bsize = std::min<size_t>(bsize, static_cast<size_t>(
+      mutable_db_options_.max_total_wal_size));
  }
  if (immutable_db_options_.db_write_buffer_size > 0) {
    bsize = std::min<size_t>(bsize, immutable_db_options_.db_write_buffer_size);
@@ -28,7 +28,6 @@
 #include "util/mutexlock.h"
 #include "util/string_util.h"
 #include "util/trace_replay.h"
-#include "util/user_comparator_wrapper.h"

 namespace rocksdb {

@@ -118,29 +117,29 @@ class DBIter final: public Iterator {
         uint64_t max_sequential_skip_in_iterations,
         ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
         bool allow_blob)
-      : env_(_env),
+      : arena_mode_(arena_mode),
+        env_(_env),
        logger_(cf_options.info_log),
        user_comparator_(cmp),
        merge_operator_(cf_options.merge_operator),
        iter_(iter),
-        read_callback_(read_callback),
        sequence_(s),
+        direction_(kForward),
+        valid_(false),
+        current_entry_is_merged_(false),
        statistics_(cf_options.statistics),
        num_internal_keys_skipped_(0),
        iterate_lower_bound_(read_options.iterate_lower_bound),
        iterate_upper_bound_(read_options.iterate_upper_bound),
-        direction_(kForward),
-        valid_(false),
-        current_entry_is_merged_(false),
        prefix_same_as_start_(read_options.prefix_same_as_start),
        pin_thru_lifetime_(read_options.pin_data),
        total_order_seek_(read_options.total_order_seek),
-        allow_blob_(allow_blob),
-        is_blob_(false),
-        arena_mode_(arena_mode),
        range_del_agg_(&cf_options.internal_comparator, s),
+        read_callback_(read_callback),
        db_impl_(db_impl),
        cfd_(cfd),
+        allow_blob_(allow_blob),
+        is_blob_(false),
        start_seqnum_(read_options.iter_start_seqnum) {
    RecordTick(statistics_, NO_ITERATOR_CREATED);
    prefix_extractor_ = mutable_cf_options.prefix_extractor.get();
@@ -153,7 +152,7 @@ class DBIter final: public Iterator {
      iter_->SetPinnedItersMgr(&pinned_iters_mgr_);
    }
  }
-  ~DBIter() override {
+  virtual ~DBIter() {
    // Release pinned data if any
    if (pinned_iters_mgr_.PinningEnabled()) {
      pinned_iters_mgr_.ReleasePinnedData();
@@ -176,16 +175,17 @@ class DBIter final: public Iterator {
    return &range_del_agg_;
  }

-  bool Valid() const override { return valid_; }
-  Slice key() const override {
+  virtual bool Valid() const override { return valid_; }
+  virtual Slice key() const override {
    assert(valid_);
    if(start_seqnum_ > 0) {
      return saved_key_.GetInternalKey();
    } else {
      return saved_key_.GetUserKey();
    }
+
  }
-  Slice value() const override {
+  virtual Slice value() const override {
    assert(valid_);
    if (current_entry_is_merged_) {
      // If pinned_value_ is set then the result of merge operator is one of
@@ -197,7 +197,7 @@ class DBIter final: public Iterator {
      return iter_->value();
    }
  }
-  Status status() const override {
+  virtual Status status() const override {
    if (status_.ok()) {
      return iter_->status();
    } else {
@@ -210,7 +210,8 @@ class DBIter final: public Iterator {
    return is_blob_;
  }

-  Status GetProperty(std::string prop_name, std::string* prop) override {
+  virtual Status GetProperty(std::string prop_name,
+                             std::string* prop) override {
    if (prop == nullptr) {
      return Status::InvalidArgument("prop is nullptr");
    }
@@ -231,19 +232,14 @@ class DBIter final: public Iterator {
    return Status::InvalidArgument("Unidentified property.");
  }

-  void Next() override;
-  void Prev() override;
-  void Seek(const Slice& target) override;
-  void SeekForPrev(const Slice& target) override;
-  void SeekToFirst() override;
-  void SeekToLast() override;
+  virtual void Next() override;
+  virtual void Prev() override;
+  virtual void Seek(const Slice& target) override;
+  virtual void SeekForPrev(const Slice& target) override;
+  virtual void SeekToFirst() override;
+  virtual void SeekToLast() override;
  Env* env() { return env_; }
-  void set_sequence(uint64_t s) {
-    sequence_ = s;
-    if (read_callback_) {
-      read_callback_->Refresh(s);
-    }
-  }
+  void set_sequence(uint64_t s) { sequence_ = s; }
  void set_valid(bool v) { valid_ = v; }

 private:
@@ -263,7 +259,7 @@ class DBIter final: public Iterator {

  void PrevInternal();
  bool TooManyInternalKeysSkipped(bool increment = true);
-  inline bool IsVisible(SequenceNumber sequence);
+  bool IsVisible(SequenceNumber sequence);

  // CanReseekToSkip() returns whether the iterator can use the optimization
  // where it reseek by sequence number to get the next key when there are too
@@ -271,6 +267,12 @@ class DBIter final: public Iterator {
  // sequence number does not guarantee that it is visible.
  inline bool CanReseekToSkip();

+  // MaxVisibleSequenceNumber() returns the maximum visible sequence number
+  // for this snapshot. This sequence number may be greater than snapshot
+  // seqno because uncommitted data written to DB for write unprepared will
+  // have a higher sequence number.
+  inline SequenceNumber MaxVisibleSequenceNumber();
+
  // Temporarily pin the blocks that we encounter until ReleaseTempPinnedData()
  // is called
  void TempPinData() {
@@ -304,16 +306,15 @@ class DBIter final: public Iterator {
  }

  const SliceTransform* prefix_extractor_;
+  bool arena_mode_;
  Env* const env_;
  Logger* logger_;
-  UserComparatorWrapper user_comparator_;
+  const Comparator* const user_comparator_;
  const MergeOperator* const merge_operator_;
  InternalIterator* iter_;
-  ReadCallback* read_callback_;
-  // Max visible sequence number. It is normally the snapshot seq unless we have
-  // uncommitted data in db as in WriteUnCommitted.
  SequenceNumber sequence_;

+  Status status_;
  IterKey saved_key_;
  // Reusable internal key data structure. This is only used inside one function
  // and should not be used across functions. Reusing this object can reduce
@@ -321,6 +322,9 @@ class DBIter final: public Iterator {
  ParsedInternalKey ikey_;
  std::string saved_value_;
  Slice pinned_value_;
+  Direction direction_;
+  bool valid_;
+  bool current_entry_is_merged_;
  // for prefix seek mode to support prev()
  Statistics* statistics_;
  uint64_t max_skip_;
@@ -328,29 +332,23 @@ class DBIter final: public Iterator {
  uint64_t num_internal_keys_skipped_;
  const Slice* iterate_lower_bound_;
  const Slice* iterate_upper_bound_;
-
  IterKey prefix_start_buf_;
-
-  Status status_;
  Slice prefix_start_key_;
-  Direction direction_;
-  bool valid_;
-  bool current_entry_is_merged_;
  const bool prefix_same_as_start_;
  // Means that we will pin all data blocks we read as long the Iterator
  // is not deleted, will be true if ReadOptions::pin_data is true
  const bool pin_thru_lifetime_;
  const bool total_order_seek_;
-  bool allow_blob_;
-  bool is_blob_;
-  bool arena_mode_;
  // List of operands for merge operator.
  MergeContext merge_context_;
  ReadRangeDelAggregator range_del_agg_;
  LocalStatistics local_stats_;
  PinnedIteratorsManager pinned_iters_mgr_;
+  ReadCallback* read_callback_;
  DBImpl* db_impl_;
  ColumnFamilyData* cfd_;
+  bool allow_blob_;
+  bool is_blob_;
  // for diff snapshots we want the lower bound on the seqnum;
  // if this value > 0 iterator will return internal keys
  SequenceNumber start_seqnum_;
@@ -376,7 +374,6 @@ void DBIter::Next() {
  assert(valid_);
  assert(status_.ok());

-  PERF_CPU_TIMER_GUARD(iter_next_cpu_nanos, env_);
  // Release temporarily pinned blocks from last operation
  ReleaseTempPinnedData();
  ResetInternalKeysSkippedCounter();
@@ -457,7 +454,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
    }

    if (iterate_upper_bound_ != nullptr &&
-        user_comparator_.Compare(ikey_.user_key, *iterate_upper_bound_) >= 0) {
+        user_comparator_->Compare(ikey_.user_key, *iterate_upper_bound_) >= 0) {
      break;
    }

@@ -472,8 +469,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
    }

    if (IsVisible(ikey_.sequence)) {
-      if (skipping && user_comparator_.Compare(ikey_.user_key,
-                                               saved_key_.GetUserKey()) <= 0) {
+      if (skipping && user_comparator_->Compare(ikey_.user_key,
+                                                saved_key_.GetUserKey()) <= 0) {
        num_skipped++;  // skip this entry
        PERF_COUNTER_ADD(internal_key_skipped_count, 1);
      } else {
@@ -580,7 +577,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
      // If this happens too many times in a row for the same user key, we want
      // to seek to the target sequence number.
      int cmp =
-          user_comparator_.Compare(ikey_.user_key, saved_key_.GetUserKey());
+          user_comparator_->Compare(ikey_.user_key, saved_key_.GetUserKey());
      if (cmp == 0 || (skipping && cmp <= 0)) {
        num_skipped++;
      } else {
@@ -656,7 +653,7 @@ bool DBIter::MergeValuesNewToOld() {
      return false;
    }

-    if (!user_comparator_.Equal(ikey.user_key, saved_key_.GetUserKey())) {
+    if (!user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
      // hit the next user key, stop right here
      break;
    } else if (kTypeDeletion == ikey.type || kTypeSingleDeletion == ikey.type ||
@@ -734,8 +731,6 @@ bool DBIter::MergeValuesNewToOld() {
 void DBIter::Prev() {
  assert(valid_);
  assert(status_.ok());
-
-  PERF_CPU_TIMER_GUARD(iter_prev_cpu_nanos, env_);
  ReleaseTempPinnedData();
  ResetInternalKeysSkippedCounter();
  bool ok = true;
@@ -776,7 +771,8 @@ bool DBIter::ReverseToForward() {
    if (!ParseKey(&ikey)) {
      return false;
    }
-    if (user_comparator_.Compare(ikey.user_key, saved_key_.GetUserKey()) >= 0) {
+    if (user_comparator_->Compare(ikey.user_key, saved_key_.GetUserKey()) >=
+        0) {
      return true;
    }
    iter_->Next();
@@ -839,8 +835,8 @@ void DBIter::PrevInternal() {
    }

    if (iterate_lower_bound_ != nullptr &&
-        user_comparator_.Compare(saved_key_.GetUserKey(),
-                                 *iterate_lower_bound_) < 0) {
+        user_comparator_->Compare(saved_key_.GetUserKey(),
+                                  *iterate_lower_bound_) < 0) {
      // We've iterated earlier than the user-specified lower bound.
      valid_ = false;
      return;
@@ -901,7 +897,7 @@ bool DBIter::FindValueForCurrentKey() {
    }

    if (!IsVisible(ikey.sequence) ||
-        !user_comparator_.Equal(ikey.user_key, saved_key_.GetUserKey())) {
+        !user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
      break;
    }
    if (TooManyInternalKeysSkipped()) {
@@ -1054,7 +1050,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
    if (!ParseKey(&ikey)) {
      return false;
    }
-    if (!user_comparator_.Equal(ikey.user_key, saved_key_.GetUserKey())) {
+    if (!user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
      // No visible values for this key, even though FindValueForCurrentKey()
      // has seen some. This is possible if we're using a tailing iterator, and
      // the entries were discarded in a compaction.
@@ -1110,7 +1106,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
    if (!ParseKey(&ikey)) {
      return false;
    }
-    if (!user_comparator_.Equal(ikey.user_key, saved_key_.GetUserKey())) {
+    if (!user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
      break;
    }

@@ -1192,7 +1188,7 @@ bool DBIter::FindUserKeyBeforeSavedKey() {
      return false;
    }

-    if (user_comparator_.Compare(ikey.user_key, saved_key_.GetUserKey()) < 0) {
+    if (user_comparator_->Compare(ikey.user_key, saved_key_.GetUserKey()) < 0) {
      return true;
    }

@@ -1247,25 +1243,30 @@ bool DBIter::TooManyInternalKeysSkipped(bool increment) {
 }

 bool DBIter::IsVisible(SequenceNumber sequence) {
-  if (read_callback_ == nullptr) {
-    return sequence <= sequence_;
-  } else {
-    return read_callback_->IsVisible(sequence);
-  }
+  return sequence <= MaxVisibleSequenceNumber() &&
+         (read_callback_ == nullptr || read_callback_->IsVisible(sequence));
 }

 bool DBIter::CanReseekToSkip() {
-  return read_callback_ == nullptr || read_callback_->CanReseekToSkip();
+  return read_callback_ == nullptr ||
+         read_callback_->MaxUnpreparedSequenceNumber() == 0;
+}
+
+SequenceNumber DBIter::MaxVisibleSequenceNumber() {
+  if (read_callback_ == nullptr) {
+    return sequence_;
+  }
+
+  return std::max(sequence_, read_callback_->MaxUnpreparedSequenceNumber());
 }

 void DBIter::Seek(const Slice& target) {
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
  StopWatch sw(env_, statistics_, DB_SEEK);
  status_ = Status::OK();
  ReleaseTempPinnedData();
  ResetInternalKeysSkippedCounter();

-  SequenceNumber seq = sequence_;
+  SequenceNumber seq = MaxVisibleSequenceNumber();
  saved_key_.Clear();
  saved_key_.SetInternalKey(target, seq);

@@ -1276,8 +1277,8 @@ void DBIter::Seek(const Slice& target) {
 #endif  // ROCKSDB_LITE

  if (iterate_lower_bound_ != nullptr &&
-      user_comparator_.Compare(saved_key_.GetUserKey(), *iterate_lower_bound_) <
-          0) {
+      user_comparator_->Compare(saved_key_.GetUserKey(),
+                                *iterate_lower_bound_) < 0) {
    saved_key_.Clear();
    saved_key_.SetInternalKey(*iterate_lower_bound_, seq);
  }
@@ -1317,7 +1318,6 @@ void DBIter::Seek(const Slice& target) {
 }

 void DBIter::SeekForPrev(const Slice& target) {
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
  StopWatch sw(env_, statistics_, DB_SEEK);
  status_ = Status::OK();
  ReleaseTempPinnedData();
@@ -1328,8 +1328,8 @@ void DBIter::SeekForPrev(const Slice& target) {
                            kValueTypeForSeekForPrev);

  if (iterate_upper_bound_ != nullptr &&
-      user_comparator_.Compare(saved_key_.GetUserKey(),
-                               *iterate_upper_bound_) >= 0) {
+      user_comparator_->Compare(saved_key_.GetUserKey(),
+                                *iterate_upper_bound_) >= 0) {
    saved_key_.Clear();
    saved_key_.SetInternalKey(*iterate_upper_bound_, kMaxSequenceNumber);
  }
@@ -1378,7 +1378,6 @@ void DBIter::SeekToFirst() {
    Seek(*iterate_lower_bound_);
    return;
  }
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
  // Don't use iter_::Seek() if we set a prefix extractor
  // because prefix seek will be used.
  if (prefix_extractor_ != nullptr && !total_order_seek_) {
@@ -1423,14 +1422,13 @@ void DBIter::SeekToLast() {
  if (iterate_upper_bound_ != nullptr) {
    // Seek to last key strictly less than ReadOptions.iterate_upper_bound.
    SeekForPrev(*iterate_upper_bound_);
-    if (Valid() && user_comparator_.Equal(*iterate_upper_bound_, key())) {
+    if (Valid() && user_comparator_->Equal(*iterate_upper_bound_, key())) {
      ReleaseTempPinnedData();
      PrevInternal();
    }
    return;
  }

-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
  // Don't use iter_::Seek() if we set a prefix extractor
  // because prefix seek will be used.
  if (prefix_extractor_ != nullptr && !total_order_seek_) {
@@ -1551,9 +1549,6 @@ Status ArenaWrappedDBIter::Refresh() {
    new (&arena_) Arena();

    SuperVersion* sv = cfd_->GetReferencedSuperVersion(db_impl_->mutex());
-    if (read_callback_) {
-      read_callback_->Refresh(latest_seq);
-    }
    Init(env, read_options_, *(cfd_->ioptions()), sv->mutable_cf_options,
         latest_seq, sv->mutable_cf_options.max_sequential_skip_in_iterations,
         cur_sv_number, read_callback_, db_impl_, cfd_, allow_blob_,
@@ -116,12 +116,12 @@ class TestIterator : public InternalIterator {
  // Number of operations done on this iterator since construction.
  size_t steps() const { return steps_; }

-  bool Valid() const override {
+  virtual bool Valid() const override {
    assert(initialized_);
    return valid_;
  }

-  void SeekToFirst() override {
+  virtual void SeekToFirst() override {
    assert(initialized_);
    ++steps_;
    DeleteCurrentIfNeeded();
@@ -129,7 +129,7 @@ class TestIterator : public InternalIterator {
    iter_ = 0;
  }

-  void SeekToLast() override {
+  virtual void SeekToLast() override {
    assert(initialized_);
    ++steps_;
    DeleteCurrentIfNeeded();
@@ -137,7 +137,7 @@ class TestIterator : public InternalIterator {
    iter_ = data_.size() - 1;
  }

-  void Seek(const Slice& target) override {
+  virtual void Seek(const Slice& target) override {
    assert(initialized_);
    SeekToFirst();
    ++steps_;
@@ -154,13 +154,13 @@ class TestIterator : public InternalIterator {
    }
  }

-  void SeekForPrev(const Slice& target) override {
+  virtual void SeekForPrev(const Slice& target) override {
    assert(initialized_);
    DeleteCurrentIfNeeded();
    SeekForPrevImpl(target, &cmp);
  }

-  void Next() override {
+  virtual void Next() override {
    assert(initialized_);
    assert(valid_);
    assert(iter_ < data_.size());
@@ -174,7 +174,7 @@ class TestIterator : public InternalIterator {
    valid_ = iter_ < data_.size();
  }

-  void Prev() override {
+  virtual void Prev() override {
    assert(initialized_);
    assert(valid_);
    assert(iter_ < data_.size());
@@ -188,23 +188,23 @@ class TestIterator : public InternalIterator {
    }
  }

-  Slice key() const override {
+  virtual Slice key() const override {
    assert(initialized_);
    return data_[iter_].first;
  }

-  Slice value() const override {
+  virtual Slice value() const override {
    assert(initialized_);
    return data_[iter_].second;
  }

-  Status status() const override {
+  virtual Status status() const override {
    assert(initialized_);
    return Status::OK();
  }

-  bool IsKeyPinned() const override { return true; }
-  bool IsValuePinned() const override { return true; }
+  virtual bool IsKeyPinned() const override { return true; }
+  virtual bool IsValuePinned() const override { return true; }

 private:
  bool initialized_;
@@ -20,10 +20,7 @@ namespace rocksdb {

 // A dumb ReadCallback which saying every key is committed.
 class DummyReadCallback : public ReadCallback {
- public:
-  DummyReadCallback() : ReadCallback(kMaxSequenceNumber) {}
-  bool IsVisibleFullCheck(SequenceNumber /*seq*/) override { return true; }
-  void SetSnapshot(SequenceNumber seq) { max_visible_seq_ = seq; }
+  bool IsVisible(SequenceNumber /*seq*/) override { return true; }
 };

 // Test param:
@@ -43,32 +40,23 @@ class DBIteratorTest : public DBTestBase,
                             ? read_options.snapshot->GetSequenceNumber()
                             : db_->GetLatestSequenceNumber();
    bool use_read_callback = GetParam();
-    DummyReadCallback* read_callback = nullptr;
-    if (use_read_callback) {
-      read_callback = new DummyReadCallback();
-      read_callback->SetSnapshot(seq);
-      InstrumentedMutexLock lock(&mutex_);
-      read_callbacks_.push_back(
-          std::unique_ptr<DummyReadCallback>(read_callback));
-    }
+    ReadCallback* read_callback = use_read_callback ? &read_callback_ : nullptr;
    return dbfull()->NewIteratorImpl(read_options, cfd, seq, read_callback);
  }

 private:
-  InstrumentedMutex mutex_;
-  std::vector<std::unique_ptr<DummyReadCallback>> read_callbacks_;
+  DummyReadCallback read_callback_;
 };

 class FlushBlockEveryKeyPolicy : public FlushBlockPolicy {
 public:
-  bool Update(const Slice& /*key*/, const Slice& /*value*/) override {
+  virtual bool Update(const Slice& /*key*/, const Slice& /*value*/) override {
    if (!start_) {
      start_ = true;
      return false;
    }
    return true;
  }
-
 private:
  bool start_ = false;
 };
@@ -191,7 +179,9 @@ TEST_P(DBIteratorTest, NonBlockingIteration) {

    // This test verifies block cache behaviors, which is not used by plain
    // table format.
-  } while (ChangeOptions(kSkipPlainTable | kSkipNoSeekToLast | kSkipMmapReads));
+    // Exclude kHashCuckoo as it does not support iteration currently
+  } while (ChangeOptions(kSkipPlainTable | kSkipNoSeekToLast | kSkipHashCuckoo |
+                         kSkipMmapReads));
 }

 TEST_P(DBIteratorTest, IterSeekBeforePrev) {
@@ -775,7 +765,8 @@ TEST_P(DBIteratorTest, IterWithSnapshot) {
    }
    db_->ReleaseSnapshot(snapshot);
    delete iter;
-  } while (ChangeOptions());
+    // skip as HashCuckooRep does not support snapshot
+  } while (ChangeOptions(kSkipHashCuckoo));
 }

 TEST_P(DBIteratorTest, IteratorPinsRef) {
@@ -2487,12 +2478,15 @@ class DBIteratorWithReadCallbackTest : public DBIteratorTest {};
 TEST_F(DBIteratorWithReadCallbackTest, ReadCallback) {
  class TestReadCallback : public ReadCallback {
   public:
-    explicit TestReadCallback(SequenceNumber _max_visible_seq)
-        : ReadCallback(_max_visible_seq) {}
+    explicit TestReadCallback(SequenceNumber last_visible_seq)
+        : last_visible_seq_(last_visible_seq) {}

-    bool IsVisibleFullCheck(SequenceNumber seq) override {
-      return seq <= max_visible_seq_;
+    bool IsVisible(SequenceNumber seq) override {
+      return seq <= last_visible_seq_;
    }
+
+   private:
+    SequenceNumber last_visible_seq_;
  };

  ASSERT_OK(Put("foo", "v1"));
@@ -249,20 +249,22 @@ TEST_F(DBTestXactLogIterator, TransactionLogIteratorBlobs) {
  auto res = OpenTransactionLogIter(0)->GetBatch();
  struct Handler : public WriteBatch::Handler {
    std::string seen;
-    Status PutCF(uint32_t cf, const Slice& key, const Slice& value) override {
+    virtual Status PutCF(uint32_t cf, const Slice& key,
+                         const Slice& value) override {
      seen += "Put(" + ToString(cf) + ", " + key.ToString() + ", " +
              ToString(value.size()) + ")";
      return Status::OK();
    }
-    Status MergeCF(uint32_t cf, const Slice& key, const Slice& value) override {
+    virtual Status MergeCF(uint32_t cf, const Slice& key,
+                           const Slice& value) override {
      seen += "Merge(" + ToString(cf) + ", " + key.ToString() + ", " +
              ToString(value.size()) + ")";
      return Status::OK();
    }
-    void LogData(const Slice& blob) override {
+    virtual void LogData(const Slice& blob) override {
      seen += "LogData(" + blob.ToString() + ")";
    }
-    Status DeleteCF(uint32_t cf, const Slice& key) override {
+    virtual Status DeleteCF(uint32_t cf, const Slice& key) override {
      seen += "Delete(" + ToString(cf) + ", " + key.ToString() + ")";
      return Status::OK();
    }
@@ -25,13 +25,13 @@ class MockMemTableRep : public MemTableRep {
  explicit MockMemTableRep(Allocator* allocator, MemTableRep* rep)
      : MemTableRep(allocator), rep_(rep), num_insert_with_hint_(0) {}

-  KeyHandle Allocate(const size_t len, char** buf) override {
+  virtual KeyHandle Allocate(const size_t len, char** buf) override {
    return rep_->Allocate(len, buf);
  }

-  void Insert(KeyHandle handle) override { rep_->Insert(handle); }
+  virtual void Insert(KeyHandle handle) override { rep_->Insert(handle); }

-  void InsertWithHint(KeyHandle handle, void** hint) override {
+  virtual void InsertWithHint(KeyHandle handle, void** hint) override {
    num_insert_with_hint_++;
    EXPECT_NE(nullptr, hint);
    last_hint_in_ = *hint;
@@ -39,18 +39,21 @@ class MockMemTableRep : public MemTableRep {
    last_hint_out_ = *hint;
  }

-  bool Contains(const char* key) const override { return rep_->Contains(key); }
+  virtual bool Contains(const char* key) const override {
+    return rep_->Contains(key);
+  }

-  void Get(const LookupKey& k, void* callback_args,
-           bool (*callback_func)(void* arg, const char* entry)) override {
+  virtual void Get(const LookupKey& k, void* callback_args,
+                   bool (*callback_func)(void* arg,
+                                         const char* entry)) override {
    rep_->Get(k, callback_args, callback_func);
  }

-  size_t ApproximateMemoryUsage() override {
+  virtual size_t ApproximateMemoryUsage() override {
    return rep_->ApproximateMemoryUsage();
  }

-  Iterator* GetIterator(Arena* arena) override {
+  virtual Iterator* GetIterator(Arena* arena) override {
    return rep_->GetIterator(arena);
  }

@@ -67,10 +70,10 @@ class MockMemTableRep : public MemTableRep {

 class MockMemTableRepFactory : public MemTableRepFactory {
 public:
-  MemTableRep* CreateMemTableRep(const MemTableRep::KeyComparator& cmp,
-                                 Allocator* allocator,
-                                 const SliceTransform* transform,
-                                 Logger* logger) override {
+  virtual MemTableRep* CreateMemTableRep(const MemTableRep::KeyComparator& cmp,
+                                         Allocator* allocator,
+                                         const SliceTransform* transform,
+                                         Logger* logger) override {
    SkipListFactory factory;
    MemTableRep* skiplist_rep =
        factory.CreateMemTableRep(cmp, allocator, transform, logger);
@@ -78,16 +81,16 @@ class MockMemTableRepFactory : public MemTableRepFactory {
    return mock_rep_;
  }

-  MemTableRep* CreateMemTableRep(const MemTableRep::KeyComparator& cmp,
-                                 Allocator* allocator,
-                                 const SliceTransform* transform,
-                                 Logger* logger,
-                                 uint32_t column_family_id) override {
+  virtual MemTableRep* CreateMemTableRep(const MemTableRep::KeyComparator& cmp,
+                                         Allocator* allocator,
+                                         const SliceTransform* transform,
+                                         Logger* logger,
+                                         uint32_t column_family_id) override {
    last_column_family_id_ = column_family_id;
    return CreateMemTableRep(cmp, allocator, transform, logger);
  }

-  const char* Name() const override { return "MockMemTableRepFactory"; }
+  virtual const char* Name() const override { return "MockMemTableRepFactory"; }

  MockMemTableRep* rep() { return mock_rep_; }

@@ -103,9 +106,9 @@ class MockMemTableRepFactory : public MemTableRepFactory {

 class TestPrefixExtractor : public SliceTransform {
 public:
-  const char* Name() const override { return "TestPrefixExtractor"; }
+  virtual const char* Name() const override { return "TestPrefixExtractor"; }

-  Slice Transform(const Slice& key) const override {
+  virtual Slice Transform(const Slice& key) const override {
    const char* p = separator(key);
    if (p == nullptr) {
      return Slice();
@@ -113,11 +116,11 @@ class TestPrefixExtractor : public SliceTransform {
    return Slice(key.data(), p - key.data() + 1);
  }

-  bool InDomain(const Slice& key) const override {
+  virtual bool InDomain(const Slice& key) const override {
    return separator(key) != nullptr;
  }

-  bool InRange(const Slice& /*key*/) const override { return false; }
+  virtual bool InRange(const Slice& /*key*/) const override { return false; }

 private:
  const char* separator(const Slice& key) const {
@@ -18,11 +18,9 @@ class TestReadCallback : public ReadCallback {
 public:
  TestReadCallback(SnapshotChecker* snapshot_checker,
                   SequenceNumber snapshot_seq)
-      : ReadCallback(snapshot_seq),
-        snapshot_checker_(snapshot_checker),
-        snapshot_seq_(snapshot_seq) {}
+      : snapshot_checker_(snapshot_checker), snapshot_seq_(snapshot_seq) {}

-  bool IsVisibleFullCheck(SequenceNumber seq) override {
+  bool IsVisible(SequenceNumber seq) override {
    return snapshot_checker_->CheckInSnapshot(seq, snapshot_seq_) ==
           SnapshotCheckerResult::kInSnapshot;
  }
@@ -334,7 +332,8 @@ TEST_P(MergeOperatorPinningTest, Randomized) {

    VerifyDBFromMap(true_data);

-  } while (ChangeOptions(kSkipMergePut));
+    // Skip HashCuckoo since it does not support merge operators
+  } while (ChangeOptions(kSkipMergePut | kSkipHashCuckoo));
 }

 class MergeOperatorHook : public MergeOperator {
@@ -342,15 +341,15 @@ class MergeOperatorHook : public MergeOperator {
  explicit MergeOperatorHook(std::shared_ptr<MergeOperator> _merge_op)
      : merge_op_(_merge_op) {}

-  bool FullMergeV2(const MergeOperationInput& merge_in,
-                   MergeOperationOutput* merge_out) const override {
+  virtual bool FullMergeV2(const MergeOperationInput& merge_in,
+                           MergeOperationOutput* merge_out) const override {
    before_merge_();
    bool res = merge_op_->FullMergeV2(merge_in, merge_out);
    after_merge_();
    return res;
  }

-  const char* Name() const override { return merge_op_->Name(); }
+  virtual const char* Name() const override { return merge_op_->Name(); }

  std::shared_ptr<MergeOperator> merge_op_;
  std::function<void()> before_merge_ = []() {};
@@ -18,15 +18,12 @@
 #include "rocksdb/cache.h"
 #include "rocksdb/convenience.h"
 #include "rocksdb/rate_limiter.h"
-#include "rocksdb/stats_history.h"
 #include "util/random.h"
 #include "util/sync_point.h"
 #include "util/testutil.h"

 namespace rocksdb {

-const int kMicrosInSec = 1000000;
-
 class DBOptionsTest : public DBTestBase {
 public:
  DBOptionsTest() : DBTestBase("/db_options_test") {}
@@ -511,11 +508,10 @@ TEST_F(DBOptionsTest, SetStatsDumpPeriodSec) {

  for (int i = 0; i < 20; i++) {
    int num = rand() % 5000 + 1;
-    ASSERT_OK(
-        dbfull()->SetDBOptions({{"stats_dump_period_sec", ToString(num)}}));
+    ASSERT_OK(dbfull()->SetDBOptions(
+        {{"stats_dump_period_sec", std::to_string(num)}}));
    ASSERT_EQ(num, dbfull()->GetDBOptions().stats_dump_period_sec);
  }
-  Close();
 }

 TEST_F(DBOptionsTest, RunStatsDumpPeriodSec) {
@@ -527,17 +523,6 @@ TEST_F(DBOptionsTest, RunStatsDumpPeriodSec) {
  mock_env->set_current_time(0); // in seconds
  options.env = mock_env.get();
  int counter = 0;
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-#endif  // OS_MACOSX && !NDEBUG
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::DumpStats:1", [&](void* /*arg*/) {
        counter++;
@@ -545,258 +530,17 @@ TEST_F(DBOptionsTest, RunStatsDumpPeriodSec) {
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  Reopen(options);
  ASSERT_EQ(5, dbfull()->GetDBOptions().stats_dump_period_sec);
-  dbfull()->TEST_WaitForDumpStatsRun([&] { mock_env->set_current_time(5); });
+  dbfull()->TEST_WaitForTimedTaskRun([&] { mock_env->set_current_time(5); });
  ASSERT_GE(counter, 1);

  // Test cacel job through SetOptions
  ASSERT_OK(dbfull()->SetDBOptions({{"stats_dump_period_sec", "0"}}));
  int old_val = counter;
-  for (int i = 6; i < 20; ++i) {
-    dbfull()->TEST_WaitForDumpStatsRun([&] { mock_env->set_current_time(i); });
-  }
+  env_->SleepForMicroseconds(10000000);
  ASSERT_EQ(counter, old_val);
  Close();
 }

-// Test persistent stats background thread scheduling and cancelling
-TEST_F(DBOptionsTest, StatsPersistScheduling) {
-  Options options;
-  options.create_if_missing = true;
-  options.stats_persist_period_sec = 5;
-  std::unique_ptr<rocksdb::MockTimeEnv> mock_env;
-  mock_env.reset(new rocksdb::MockTimeEnv(env_));
-  mock_env->set_current_time(0);  // in seconds
-  options.env = mock_env.get();
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-#endif  // OS_MACOSX && !NDEBUG
-  int counter = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::PersistStats:Entry", [&](void* /*arg*/) { counter++; });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  Reopen(options);
-  ASSERT_EQ(5, dbfull()->GetDBOptions().stats_persist_period_sec);
-  dbfull()->TEST_WaitForPersistStatsRun([&] { mock_env->set_current_time(5); });
-  ASSERT_GE(counter, 1);
-
-  // Test cacel job through SetOptions
-  ASSERT_TRUE(dbfull()->TEST_IsPersistentStatsEnabled());
-  ASSERT_OK(dbfull()->SetDBOptions({{"stats_persist_period_sec", "0"}}));
-  ASSERT_FALSE(dbfull()->TEST_IsPersistentStatsEnabled());
-  Close();
-}
-
-// Test enabling persistent stats for the first time
-TEST_F(DBOptionsTest, PersistentStatsFreshInstall) {
-  Options options;
-  options.create_if_missing = true;
-  options.stats_persist_period_sec = 0;
-  std::unique_ptr<rocksdb::MockTimeEnv> mock_env;
-  mock_env.reset(new rocksdb::MockTimeEnv(env_));
-  mock_env->set_current_time(0);  // in seconds
-  options.env = mock_env.get();
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-#endif  // OS_MACOSX && !NDEBUG
-  int counter = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::PersistStats:Entry", [&](void* /*arg*/) { counter++; });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  Reopen(options);
-  ASSERT_OK(dbfull()->SetDBOptions({{"stats_persist_period_sec", "5"}}));
-  ASSERT_EQ(5, dbfull()->GetDBOptions().stats_persist_period_sec);
-  dbfull()->TEST_WaitForPersistStatsRun([&] { mock_env->set_current_time(5); });
-  ASSERT_GE(counter, 1);
-  Close();
-}
-
-TEST_F(DBOptionsTest, SetOptionsStatsPersistPeriodSec) {
-  Options options;
-  options.create_if_missing = true;
-  options.stats_persist_period_sec = 5;
-  options.env = env_;
-  Reopen(options);
-  ASSERT_EQ(5, dbfull()->GetDBOptions().stats_persist_period_sec);
-
-  ASSERT_OK(dbfull()->SetDBOptions({{"stats_persist_period_sec", "12345"}}));
-  ASSERT_EQ(12345, dbfull()->GetDBOptions().stats_persist_period_sec);
-  ASSERT_NOK(dbfull()->SetDBOptions({{"stats_persist_period_sec", "abcde"}}));
-  ASSERT_EQ(12345, dbfull()->GetDBOptions().stats_persist_period_sec);
-}
-
-TEST_F(DBOptionsTest, GetStatsHistory) {
-  Options options;
-  options.create_if_missing = true;
-  options.stats_persist_period_sec = 5;
-  options.statistics = rocksdb::CreateDBStatistics();
-  std::unique_ptr<rocksdb::MockTimeEnv> mock_env;
-  mock_env.reset(new rocksdb::MockTimeEnv(env_));
-  mock_env->set_current_time(0);  // in seconds
-  options.env = mock_env.get();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-#endif  // OS_MACOSX && !NDEBUG
-
-  CreateColumnFamilies({"pikachu"}, options);
-  ASSERT_OK(Put("foo", "bar"));
-  ReopenWithColumnFamilies({"default", "pikachu"}, options);
-
-  int mock_time = 1;
-  // Wait for stats persist to finish
-  dbfull()->TEST_WaitForPersistStatsRun([&] { mock_env->set_current_time(5); });
-  std::unique_ptr<StatsHistoryIterator> stats_iter;
-  db_->GetStatsHistory(0, 6 * kMicrosInSec, &stats_iter);
-  ASSERT_TRUE(stats_iter != nullptr);
-  // disabled stats snapshots
-  ASSERT_OK(dbfull()->SetDBOptions({{"stats_persist_period_sec", "0"}}));
-  size_t stats_count = 0;
-  for (; stats_iter->Valid(); stats_iter->Next()) {
-    auto stats_map = stats_iter->GetStatsMap();
-    stats_count += stats_map.size();
-  }
-  ASSERT_GT(stats_count, 0);
-  // Wait a bit and verify no more stats are found
-  for (mock_time = 6; mock_time < 20; ++mock_time) {
-    dbfull()->TEST_WaitForPersistStatsRun(
-        [&] { mock_env->set_current_time(mock_time); });
-  }
-  db_->GetStatsHistory(0, 20 * kMicrosInSec, &stats_iter);
-  ASSERT_TRUE(stats_iter != nullptr);
-  size_t stats_count_new = 0;
-  for (; stats_iter->Valid(); stats_iter->Next()) {
-    stats_count_new += stats_iter->GetStatsMap().size();
-  }
-  ASSERT_EQ(stats_count_new, stats_count);
-  Close();
-}
-
-TEST_F(DBOptionsTest, InMemoryStatsHistoryPurging) {
-  Options options;
-  options.create_if_missing = true;
-  options.statistics = rocksdb::CreateDBStatistics();
-  options.stats_persist_period_sec = 1;
-  std::unique_ptr<rocksdb::MockTimeEnv> mock_env;
-  mock_env.reset(new rocksdb::MockTimeEnv(env_));
-  mock_env->set_current_time(0);  // in seconds
-  options.env = mock_env.get();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-#endif  // OS_MACOSX && !NDEBUG
-
-  CreateColumnFamilies({"pikachu"}, options);
-  ASSERT_OK(Put("foo", "bar"));
-  ReopenWithColumnFamilies({"default", "pikachu"}, options);
-  // some random operation to populate statistics
-  ASSERT_OK(Delete("foo"));
-  ASSERT_OK(Put("sol", "sol"));
-  ASSERT_OK(Put("epic", "epic"));
-  ASSERT_OK(Put("ltd", "ltd"));
-  ASSERT_EQ("sol", Get("sol"));
-  ASSERT_EQ("epic", Get("epic"));
-  ASSERT_EQ("ltd", Get("ltd"));
-  Iterator* iterator = db_->NewIterator(ReadOptions());
-  for (iterator->SeekToFirst(); iterator->Valid(); iterator->Next()) {
-    ASSERT_TRUE(iterator->key() == iterator->value());
-  }
-  delete iterator;
-  ASSERT_OK(Flush());
-  ASSERT_OK(Delete("sol"));
-  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  int mock_time = 1;
-  // Wait for stats persist to finish
-  for (; mock_time < 5; ++mock_time) {
-    dbfull()->TEST_WaitForPersistStatsRun(
-        [&] { mock_env->set_current_time(mock_time); });
-  }
-
-  // second round of ops
-  ASSERT_OK(Put("saigon", "saigon"));
-  ASSERT_OK(Put("noodle talk", "noodle talk"));
-  ASSERT_OK(Put("ping bistro", "ping bistro"));
-  iterator = db_->NewIterator(ReadOptions());
-  for (iterator->SeekToFirst(); iterator->Valid(); iterator->Next()) {
-    ASSERT_TRUE(iterator->key() == iterator->value());
-  }
-  delete iterator;
-  ASSERT_OK(Flush());
-  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  for (; mock_time < 10; ++mock_time) {
-    dbfull()->TEST_WaitForPersistStatsRun(
-        [&] { mock_env->set_current_time(mock_time); });
-  }
-  std::unique_ptr<StatsHistoryIterator> stats_iter;
-  db_->GetStatsHistory(0, 10 * kMicrosInSec, &stats_iter);
-  ASSERT_TRUE(stats_iter != nullptr);
-  size_t stats_count = 0;
-  int slice_count = 0;
-  for (; stats_iter->Valid(); stats_iter->Next()) {
-    slice_count++;
-    auto stats_map = stats_iter->GetStatsMap();
-    stats_count += stats_map.size();
-  }
-  size_t stats_history_size = dbfull()->TEST_EstiamteStatsHistorySize();
-  ASSERT_GE(slice_count, 9);
-  ASSERT_GE(stats_history_size, 12000);
-  // capping memory cost at 12000 bytes since one slice is around 10000~12000
-  ASSERT_OK(dbfull()->SetDBOptions({{"stats_history_buffer_size", "12000"}}));
-  ASSERT_EQ(12000, dbfull()->GetDBOptions().stats_history_buffer_size);
-  // Wait for stats persist to finish
-  for (; mock_time < 20; ++mock_time) {
-    dbfull()->TEST_WaitForPersistStatsRun(
-        [&] { mock_env->set_current_time(mock_time); });
-  }
-  db_->GetStatsHistory(0, 20 * kMicrosInSec, &stats_iter);
-  ASSERT_TRUE(stats_iter != nullptr);
-  size_t stats_count_reopen = 0;
-  slice_count = 0;
-  for (; stats_iter->Valid(); stats_iter->Next()) {
-    slice_count++;
-    auto stats_map = stats_iter->GetStatsMap();
-    stats_count_reopen += stats_map.size();
-  }
-  size_t stats_history_size_reopen = dbfull()->TEST_EstiamteStatsHistorySize();
-  // only one slice can fit under the new stats_history_buffer_size
-  ASSERT_LT(slice_count, 2);
-  ASSERT_TRUE(stats_history_size_reopen < 12000 &&
-              stats_history_size_reopen > 0);
-  ASSERT_TRUE(stats_count_reopen < stats_count && stats_count_reopen > 0);
-  Close();
-}
-
 static void assert_candidate_files_empty(DBImpl* dbfull, const bool empty) {
  dbfull->TEST_LockMutex();
  JobContext job_context(0);
@@ -884,9 +628,9 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
  env_->time_elapse_only_sleep_ = false;
  options.env = env_;

-  // Test dynamically changing ttl.
+  // Test dynamically changing compaction_options_fifo.ttl
  env_->addon_time_.store(0);
-  options.ttl = 1 * 60 * 60;  // 1 hour
+  options.compaction_options_fifo.ttl = 1 * 60 * 60;  // 1 hour
  ASSERT_OK(TryReopen(options));

  Random rnd(301);
@@ -904,13 +648,13 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
  env_->addon_time_.fetch_add(61);

  // No files should be compacted as ttl is set to 1 hour.
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 3600);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 3600);
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
  ASSERT_EQ(NumTableFilesAtLevel(0), 10);

  // Set ttl to 1 minute. So all files should get deleted.
-  ASSERT_OK(dbfull()->SetOptions({{"ttl", "60"}}));
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 60);
+  ASSERT_OK(dbfull()->SetOptions({{"compaction_options_fifo", "{ttl=60;}"}}));
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 60);
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
  ASSERT_OK(dbfull()->TEST_WaitForCompact());
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
@@ -918,7 +662,7 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
  // Test dynamically changing compaction_options_fifo.max_table_files_size
  env_->addon_time_.store(0);
  options.compaction_options_fifo.max_table_files_size = 500 << 10;  // 00KB
-  options.ttl = 0;
+  options.compaction_options_fifo.ttl = 0;
  DestroyAndReopen(options);

  for (int i = 0; i < 10; i++) {
@@ -948,7 +692,7 @@ TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {

  // Test dynamically changing compaction_options_fifo.allow_compaction
  options.compaction_options_fifo.max_table_files_size = 500 << 10;  // 500KB
-  options.ttl = 0;
+  options.compaction_options_fifo.ttl = 0;
  options.compaction_options_fifo.allow_compaction = false;
  options.level0_file_num_compaction_trigger = 6;
  DestroyAndReopen(options);
@@ -1094,7 +1094,7 @@ class CountingUserTblPropCollector : public TablePropertiesCollector {
    return Status::OK();
  }

-  UserCollectedProperties GetReadableProperties() const override {
+  virtual UserCollectedProperties GetReadableProperties() const override {
    return UserCollectedProperties{};
  }

@@ -1110,7 +1110,7 @@ class CountingUserTblPropCollectorFactory
      uint32_t expected_column_family_id)
      : expected_column_family_id_(expected_column_family_id),
        num_created_(0) {}
-  TablePropertiesCollector* CreateTablePropertiesCollector(
+  virtual TablePropertiesCollector* CreateTablePropertiesCollector(
      TablePropertiesCollectorFactory::Context context) override {
    EXPECT_EQ(expected_column_family_id_, context.column_family_id);
    num_created_++;
@@ -1158,7 +1158,7 @@ class CountingDeleteTabPropCollector : public TablePropertiesCollector {
 class CountingDeleteTabPropCollectorFactory
    : public TablePropertiesCollectorFactory {
 public:
-  TablePropertiesCollector* CreateTablePropertiesCollector(
+  virtual TablePropertiesCollector* CreateTablePropertiesCollector(
      TablePropertiesCollectorFactory::Context /*context*/) override {
    return new CountingDeleteTabPropCollector();
  }
@@ -1432,7 +1432,7 @@ TEST_F(DBPropertiesTest, EstimateOldestKeyTime) {
  }

  options.compaction_style = kCompactionStyleFIFO;
-  options.ttl = 300;
+  options.compaction_options_fifo.ttl = 300;
  options.compaction_options_fifo.allow_compaction = false;
  DestroyAndReopen(options);

@@ -72,8 +72,8 @@ TEST_F(DBRangeDelTest, CompactionOutputHasOnlyRangeTombstone) {
    // Skip cuckoo memtables, which do not support snapshots. Skip non-leveled
    // compactions as the above assertions about the number of files in a level
    // do not hold true.
-  } while (ChangeOptions(kRangeDelSkipConfigs | kSkipUniversalCompaction |
-                         kSkipFIFOCompaction));
+  } while (ChangeOptions(kRangeDelSkipConfigs | kSkipHashCuckoo |
+                         kSkipUniversalCompaction | kSkipFIFOCompaction));
 }

 TEST_F(DBRangeDelTest, CompactionOutputFilesExactlyFilled) {
@@ -645,7 +645,8 @@ TEST_F(DBRangeDelTest, GetCoveredKeyFromSst) {
    std::string value;
    ASSERT_TRUE(db_->Get(read_opts, "key", &value).IsNotFound());
    db_->ReleaseSnapshot(snapshot);
-  } while (ChangeOptions(kRangeDelSkipConfigs));
+    // Cuckoo memtables do not support snapshots.
+  } while (ChangeOptions(kRangeDelSkipConfigs | kSkipHashCuckoo));
 }

 TEST_F(DBRangeDelTest, GetCoveredMergeOperandFromMemtable) {
@@ -1111,14 +1112,14 @@ class MockMergeOperator : public MergeOperator {
  // Mock non-associative operator. Non-associativity is expressed by lack of
  // implementation for any `PartialMerge*` functions.
 public:
-  bool FullMergeV2(const MergeOperationInput& merge_in,
-                   MergeOperationOutput* merge_out) const override {
+  virtual bool FullMergeV2(const MergeOperationInput& merge_in,
+                           MergeOperationOutput* merge_out) const override {
    assert(merge_out != nullptr);
    merge_out->new_value = merge_in.operand_list.back().ToString();
    return true;
  }

-  const char* Name() const override { return "MockMergeOperator"; }
+  virtual const char* Name() const override { return "MockMergeOperator"; }
 };

 TEST_F(DBRangeDelTest, KeyAtOverlappingEndpointReappears) {
@@ -1,480 +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.
-
-#include "db/db_impl_secondary.h"
-#include "db/db_test_util.h"
-#include "port/stack_trace.h"
-#include "util/fault_injection_test_env.h"
-#include "util/sync_point.h"
-
-namespace rocksdb {
-
-#ifndef ROCKSDB_LITE
-class DBSecondaryTest : public DBTestBase {
- public:
-  DBSecondaryTest()
-      : DBTestBase("/db_secondary_test"),
-        secondary_path_(),
-        handles_secondary_(),
-        db_secondary_(nullptr) {
-    secondary_path_ =
-        test::PerThreadDBPath(env_, "/db_secondary_test_secondary");
-  }
-
-  ~DBSecondaryTest() override {
-    CloseSecondary();
-    if (getenv("KEEP_DB") != nullptr) {
-      fprintf(stdout, "Secondary DB is still at %s\n", secondary_path_.c_str());
-    } else {
-      Options options;
-      options.env = env_;
-      EXPECT_OK(DestroyDB(secondary_path_, options));
-    }
-  }
-
- protected:
-  Status ReopenAsSecondary(const Options& options) {
-    return DB::OpenAsSecondary(options, dbname_, secondary_path_, &db_);
-  }
-
-  void OpenSecondary(const Options& options);
-
-  void OpenSecondaryWithColumnFamilies(
-      const std::vector<std::string>& column_families, const Options& options);
-
-  void CloseSecondary() {
-    for (auto h : handles_secondary_) {
-      db_secondary_->DestroyColumnFamilyHandle(h);
-    }
-    handles_secondary_.clear();
-    delete db_secondary_;
-    db_secondary_ = nullptr;
-  }
-
-  DBImplSecondary* db_secondary_full() {
-    return static_cast<DBImplSecondary*>(db_secondary_);
-  }
-
-  void CheckFileTypeCounts(const std::string& dir, int expected_log,
-                           int expected_sst, int expected_manifest) const;
-
-  std::string secondary_path_;
-  std::vector<ColumnFamilyHandle*> handles_secondary_;
-  DB* db_secondary_;
-};
-
-void DBSecondaryTest::OpenSecondary(const Options& options) {
-  Status s =
-      DB::OpenAsSecondary(options, dbname_, secondary_path_, &db_secondary_);
-  ASSERT_OK(s);
-}
-
-void DBSecondaryTest::OpenSecondaryWithColumnFamilies(
-    const std::vector<std::string>& column_families, const Options& options) {
-  std::vector<ColumnFamilyDescriptor> cf_descs;
-  cf_descs.emplace_back(kDefaultColumnFamilyName, options);
-  for (const auto& cf_name : column_families) {
-    cf_descs.emplace_back(cf_name, options);
-  }
-  Status s = DB::OpenAsSecondary(options, dbname_, secondary_path_, cf_descs,
-                                 &handles_secondary_, &db_secondary_);
-  ASSERT_OK(s);
-}
-
-void DBSecondaryTest::CheckFileTypeCounts(const std::string& dir,
-                                          int expected_log, int expected_sst,
-                                          int expected_manifest) const {
-  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(expected_log, log_cnt);
-  ASSERT_EQ(expected_sst, sst_cnt);
-  ASSERT_EQ(expected_manifest, manifest_cnt);
-}
-
-TEST_F(DBSecondaryTest, ReopenAsSecondary) {
-  Options options;
-  options.env = env_;
-  Reopen(options);
-  ASSERT_OK(Put("foo", "foo_value"));
-  ASSERT_OK(Put("bar", "bar_value"));
-  ASSERT_OK(dbfull()->Flush(FlushOptions()));
-  Close();
-
-  ASSERT_OK(ReopenAsSecondary(options));
-  ASSERT_EQ("foo_value", Get("foo"));
-  ASSERT_EQ("bar_value", Get("bar"));
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  auto db1 = static_cast<DBImplSecondary*>(db_);
-  ASSERT_NE(nullptr, db1);
-  Iterator* iter = db1->NewIterator(ropts);
-  ASSERT_NE(nullptr, iter);
-  size_t count = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    if (0 == count) {
-      ASSERT_EQ("bar", iter->key().ToString());
-      ASSERT_EQ("bar_value", iter->value().ToString());
-    } else if (1 == count) {
-      ASSERT_EQ("foo", iter->key().ToString());
-      ASSERT_EQ("foo_value", iter->value().ToString());
-    }
-    ++count;
-  }
-  delete iter;
-  ASSERT_EQ(2, count);
-}
-
-TEST_F(DBSecondaryTest, OpenAsSecondary) {
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(Flush());
-  }
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  const auto verify_db_func = [&](const std::string& foo_val,
-                                  const std::string& bar_val) {
-    std::string value;
-    ASSERT_OK(db_secondary_->Get(ropts, "foo", &value));
-    ASSERT_EQ(foo_val, value);
-    ASSERT_OK(db_secondary_->Get(ropts, "bar", &value));
-    ASSERT_EQ(bar_val, value);
-    Iterator* iter = db_secondary_->NewIterator(ropts);
-    ASSERT_NE(nullptr, iter);
-    iter->Seek("foo");
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ("foo", iter->key().ToString());
-    ASSERT_EQ(foo_val, iter->value().ToString());
-    iter->Seek("bar");
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ("bar", iter->key().ToString());
-    ASSERT_EQ(bar_val, iter->value().ToString());
-    size_t count = 0;
-    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-      ++count;
-    }
-    ASSERT_EQ(2, count);
-    delete iter;
-  };
-
-  verify_db_func("foo_value2", "bar_value2");
-
-  ASSERT_OK(Put("foo", "new_foo_value"));
-  ASSERT_OK(Put("bar", "new_bar_value"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  verify_db_func("new_foo_value", "new_bar_value");
-}
-
-TEST_F(DBSecondaryTest, OpenWithNonExistColumnFamily) {
-  Options options;
-  options.env = env_;
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  std::vector<ColumnFamilyDescriptor> cf_descs;
-  cf_descs.emplace_back(kDefaultColumnFamilyName, options1);
-  cf_descs.emplace_back("pikachu", options1);
-  cf_descs.emplace_back("eevee", options1);
-  Status s = DB::OpenAsSecondary(options1, dbname_, secondary_path_, cf_descs,
-                                 &handles_secondary_, &db_secondary_);
-  ASSERT_NOK(s);
-}
-
-TEST_F(DBSecondaryTest, OpenWithSubsetOfColumnFamilies) {
-  Options options;
-  options.env = env_;
-  CreateAndReopenWithCF({"pikachu"}, options);
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-  ASSERT_EQ(0, handles_secondary_.size());
-  ASSERT_NE(nullptr, db_secondary_);
-
-  ASSERT_OK(Put(0 /*cf*/, "foo", "foo_value"));
-  ASSERT_OK(Put(1 /*cf*/, "foo", "foo_value"));
-  ASSERT_OK(Flush(0 /*cf*/));
-  ASSERT_OK(Flush(1 /*cf*/));
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  std::string value;
-  ASSERT_OK(db_secondary_->Get(ropts, "foo", &value));
-  ASSERT_EQ("foo_value", value);
-}
-
-TEST_F(DBSecondaryTest, SwitchToNewManifestDuringOpen) {
-  Options options;
-  options.env = env_;
-  Reopen(options);
-  Close();
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"ReactiveVersionSet::MaybeSwitchManifest:AfterGetCurrentManifestPath:0",
-        "VersionSet::ProcessManifestWrites:BeforeNewManifest"},
-       {"VersionSet::ProcessManifestWrites:AfterNewManifest",
-        "ReactiveVersionSet::MaybeSwitchManifest:AfterGetCurrentManifestPath:"
-        "1"}});
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // Make sure db calls RecoverLogFiles so as to trigger a manifest write,
-  // which causes the db to switch to a new MANIFEST upon start.
-  port::Thread ro_db_thread([&]() {
-    Options options1;
-    options1.env = env_;
-    options1.max_open_files = -1;
-    OpenSecondary(options1);
-    CloseSecondary();
-  });
-  Reopen(options);
-  ro_db_thread.join();
-}
-
-TEST_F(DBSecondaryTest, MissingTableFileDuringOpen) {
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-  for (int i = 0; i != options.level0_file_num_compaction_trigger; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(dbfull()->Flush(FlushOptions()));
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  std::string value;
-  ASSERT_OK(db_secondary_->Get(ropts, "foo", &value));
-  ASSERT_EQ("foo_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            value);
-  ASSERT_OK(db_secondary_->Get(ropts, "bar", &value));
-  ASSERT_EQ("bar_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            value);
-  Iterator* iter = db_secondary_->NewIterator(ropts);
-  ASSERT_NE(nullptr, iter);
-  iter->Seek("bar");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("bar", iter->key().ToString());
-  ASSERT_EQ("bar_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            iter->value().ToString());
-  iter->Seek("foo");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("foo", iter->key().ToString());
-  ASSERT_EQ("foo_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            iter->value().ToString());
-  size_t count = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    ++count;
-  }
-  ASSERT_EQ(2, count);
-  delete iter;
-}
-
-TEST_F(DBSecondaryTest, MissingTableFile) {
-  int table_files_not_exist = 0;
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "ReactiveVersionSet::ReadAndApply:AfterLoadTableHandlers",
-      [&](void* arg) {
-        Status s = *reinterpret_cast<Status*>(arg);
-        if (s.IsPathNotFound()) {
-          ++table_files_not_exist;
-        } else if (!s.ok()) {
-          assert(false);  // Should not reach here
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-
-  for (int i = 0; i != options.level0_file_num_compaction_trigger; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(dbfull()->Flush(FlushOptions()));
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  ASSERT_NE(nullptr, db_secondary_full());
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  std::string value;
-  ASSERT_NOK(db_secondary_->Get(ropts, "foo", &value));
-  ASSERT_NOK(db_secondary_->Get(ropts, "bar", &value));
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  ASSERT_EQ(options.level0_file_num_compaction_trigger, table_files_not_exist);
-  ASSERT_OK(db_secondary_->Get(ropts, "foo", &value));
-  ASSERT_EQ("foo_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            value);
-  ASSERT_OK(db_secondary_->Get(ropts, "bar", &value));
-  ASSERT_EQ("bar_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            value);
-  Iterator* iter = db_secondary_->NewIterator(ropts);
-  ASSERT_NE(nullptr, iter);
-  iter->Seek("bar");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("bar", iter->key().ToString());
-  ASSERT_EQ("bar_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            iter->value().ToString());
-  iter->Seek("foo");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("foo", iter->key().ToString());
-  ASSERT_EQ("foo_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            iter->value().ToString());
-  size_t count = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    ++count;
-  }
-  ASSERT_EQ(2, count);
-  delete iter;
-}
-
-TEST_F(DBSecondaryTest, PrimaryDropColumnFamily) {
-  Options options;
-  options.env = env_;
-  const std::string kCfName1 = "pikachu";
-  CreateAndReopenWithCF({kCfName1}, options);
-
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondaryWithColumnFamilies({kCfName1}, options1);
-  ASSERT_EQ(2, handles_secondary_.size());
-
-  ASSERT_OK(Put(1 /*cf*/, "foo", "foo_val_1"));
-  ASSERT_OK(Flush(1 /*cf*/));
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  std::string value;
-  ASSERT_OK(db_secondary_->Get(ropts, handles_secondary_[1], "foo", &value));
-  ASSERT_EQ("foo_val_1", value);
-
-  ASSERT_OK(dbfull()->DropColumnFamily(handles_[1]));
-  Close();
-  CheckFileTypeCounts(dbname_, 1, 0, 1);
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  value.clear();
-  ASSERT_OK(db_secondary_->Get(ropts, handles_secondary_[1], "foo", &value));
-  ASSERT_EQ("foo_val_1", value);
-}
-
-TEST_F(DBSecondaryTest, SwitchManifest) {
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-
-  const int kNumFiles = options.level0_file_num_compaction_trigger - 1;
-  // Keep it smaller than 10 so that key0, key1, ..., key9 are sorted as 0, 1,
-  // ..., 9.
-  const int kNumKeys = 10;
-  // Create two sst
-  for (int i = 0; i != kNumFiles; ++i) {
-    for (int j = 0; j != kNumKeys; ++j) {
-      ASSERT_OK(Put("key" + std::to_string(j), "value_" + std::to_string(i)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  const auto& range_scan_db = [&]() {
-    ReadOptions tmp_ropts;
-    tmp_ropts.total_order_seek = true;
-    tmp_ropts.verify_checksums = true;
-    std::unique_ptr<Iterator> iter(db_secondary_->NewIterator(tmp_ropts));
-    int cnt = 0;
-    for (iter->SeekToFirst(); iter->Valid(); iter->Next(), ++cnt) {
-      ASSERT_EQ("key" + std::to_string(cnt), iter->key().ToString());
-      ASSERT_EQ("value_" + std::to_string(kNumFiles - 1),
-                iter->value().ToString());
-    }
-  };
-
-  range_scan_db();
-
-  // While secondary instance still keeps old MANIFEST open, we close primary,
-  // restart primary, performs full compaction, close again, restart again so
-  // that next time secondary tries to catch up with primary, the secondary
-  // will skip the MANIFEST in middle.
-  Reopen(options);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  Reopen(options);
-  ASSERT_OK(dbfull()->SetOptions({{"disable_auto_compactions", "false"}}));
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  range_scan_db();
-}
-#endif  //! ROCKSDB_LITE
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -25,9 +25,9 @@ class DBSSTTest : public DBTestBase {
 class FlushedFileCollector : public EventListener {
 public:
  FlushedFileCollector() {}
-  ~FlushedFileCollector() override {}
+  ~FlushedFileCollector() {}

-  void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
+  virtual void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
    std::lock_guard<std::mutex> lock(mutex_);
    flushed_files_.push_back(info.file_path);
  }
@@ -356,14 +356,6 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
  env_->time_elapse_only_sleep_ = true;
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
-  // Need to disable stats dumping and persisting which also use
-  // RepeatableThread, one of whose member variables is of type
-  // InstrumentedCondVar. The callback for
-  // InstrumentedCondVar::TimedWaitInternal can be triggered by stats dumping
-  // and persisting threads and cause time_spent_deleting measurement to become
-  // incorrect.
-  options.stats_dump_period_sec = 0;
-  options.stats_persist_period_sec = 0;
  options.env = env_;

  int64_t rate_bytes_per_sec = 1024 * 10;  // 10 Kbs / Sec
@@ -375,16 +367,14 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
  auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());
  sfm->delete_scheduler()->SetMaxTrashDBRatio(1.1);

-  WriteOptions wo;
-  wo.disableWAL = true;
  ASSERT_OK(TryReopen(options));
  // Create 4 files in L0
  for (char v = 'a'; v <= 'd'; v++) {
-    ASSERT_OK(Put("Key2", DummyString(1024, v), wo));
-    ASSERT_OK(Put("Key3", DummyString(1024, v), wo));
-    ASSERT_OK(Put("Key4", DummyString(1024, v), wo));
-    ASSERT_OK(Put("Key1", DummyString(1024, v), wo));
-    ASSERT_OK(Put("Key4", DummyString(1024, v), wo));
+    ASSERT_OK(Put("Key2", DummyString(1024, v)));
+    ASSERT_OK(Put("Key3", DummyString(1024, v)));
+    ASSERT_OK(Put("Key4", DummyString(1024, v)));
+    ASSERT_OK(Put("Key1", DummyString(1024, v)));
+    ASSERT_OK(Put("Key4", DummyString(1024, v)));
    ASSERT_OK(Flush());
  }
  // We created 4 sst files in L0
@@ -418,55 +408,6 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }

-TEST_F(DBSSTTest, RateLimitedWALDelete) {
-  Destroy(last_options_);
-
-  std::vector<uint64_t> penalties;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DeleteScheduler::BackgroundEmptyTrash:Wait",
-      [&](void* arg) { penalties.push_back(*(static_cast<uint64_t*>(arg))); });
-
-  env_->no_slowdown_ = true;
-  env_->time_elapse_only_sleep_ = true;
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.env = env_;
-
-  int64_t rate_bytes_per_sec = 1024 * 10;  // 10 Kbs / Sec
-  Status s;
-  options.sst_file_manager.reset(
-      NewSstFileManager(env_, nullptr, "", 0, false, &s, 0));
-  ASSERT_OK(s);
-  options.sst_file_manager->SetDeleteRateBytesPerSecond(rate_bytes_per_sec);
-  auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());
-  sfm->delete_scheduler()->SetMaxTrashDBRatio(2.1);
-
-  ASSERT_OK(TryReopen(options));
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  // Create 4 files in L0
-  for (char v = 'a'; v <= 'd'; v++) {
-    ASSERT_OK(Put("Key2", DummyString(1024, v)));
-    ASSERT_OK(Put("Key3", DummyString(1024, v)));
-    ASSERT_OK(Put("Key4", DummyString(1024, v)));
-    ASSERT_OK(Put("Key1", DummyString(1024, v)));
-    ASSERT_OK(Put("Key4", DummyString(1024, v)));
-    ASSERT_OK(Flush());
-  }
-  // We created 4 sst files in L0
-  ASSERT_EQ("4", FilesPerLevel(0));
-
-  // Compaction will move the 4 files in L0 to trash and create 1 L1 file
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact(true));
-  ASSERT_EQ("0,1", FilesPerLevel(0));
-
-  sfm->WaitForEmptyTrash();
-  ASSERT_EQ(penalties.size(), 8);
-
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
 TEST_F(DBSSTTest, OpenDBWithExistingTrash) {
  Options options = CurrentOptions();

@@ -505,6 +446,7 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DeleteScheduler::DeleteFile",
      [&](void* /*arg*/) { bg_delete_file++; });
+  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
@@ -522,14 +464,10 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
  auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());

  DestroyAndReopen(options);
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  WriteOptions wo;
-  wo.disableWAL = true;

  // Create 4 files in L0
  for (int i = 0; i < 4; i++) {
-    ASSERT_OK(Put("Key" + ToString(i), DummyString(1024, 'A'), wo));
+    ASSERT_OK(Put("Key" + ToString(i), DummyString(1024, 'A')));
    ASSERT_OK(Flush());
  }
  // We created 4 sst files in L0
@@ -545,7 +483,7 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {

  // Create 4 files in L0
  for (int i = 4; i < 8; i++) {
-    ASSERT_OK(Put("Key" + ToString(i), DummyString(1024, 'B'), wo));
+    ASSERT_OK(Put("Key" + ToString(i), DummyString(1024, 'B')));
    ASSERT_OK(Flush());
  }
  ASSERT_EQ("4,1", FilesPerLevel(0));
@@ -600,27 +538,14 @@ TEST_F(DBSSTTest, DestroyDBWithRateLimitedDelete) {
  // Close DB and destroy it using DeleteScheduler
  Close();

-  int num_sst_files = 0;
-  int num_wal_files = 0;
-  std::vector<std::string> db_files;
-  env_->GetChildren(dbname_, &db_files);
-  for (std::string f : db_files) {
-    if (f.substr(f.find_last_of(".") + 1) == "sst") {
-      num_sst_files++;
-    } else if (f.substr(f.find_last_of(".") + 1) == "log") {
-      num_wal_files++;
-    }
-  }
-  ASSERT_GT(num_sst_files, 0);
-  ASSERT_GT(num_wal_files, 0);
-
  auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());

  sfm->SetDeleteRateBytesPerSecond(1024 * 1024);
  sfm->delete_scheduler()->SetMaxTrashDBRatio(1.1);
  ASSERT_OK(DestroyDB(dbname_, options));
  sfm->WaitForEmptyTrash();
-  ASSERT_EQ(bg_delete_file, num_sst_files + num_wal_files);
+  // We have deleted the 4 sst files in the delete_scheduler
+  ASSERT_EQ(bg_delete_file, 4);
 }

 TEST_F(DBSSTTest, DBWithMaxSpaceAllowed) {
@@ -46,7 +46,7 @@ TEST_F(DBStatisticsTest, CompressionStatsTest) {
  Options options = CurrentOptions();
  options.compression = type;
  options.statistics = rocksdb::CreateDBStatistics();
-  options.statistics->set_stats_level(StatsLevel::kExceptTimeForMutex);
+  options.statistics->stats_level_ = StatsLevel::kExceptTimeForMutex;
  DestroyAndReopen(options);

  int kNumKeysWritten = 100000;
@@ -105,7 +105,7 @@ TEST_F(DBStatisticsTest, MutexWaitStats) {
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
-  options.statistics->set_stats_level(StatsLevel::kAll);
+  options.statistics->stats_level_ = StatsLevel::kAll;
  CreateAndReopenWithCF({"pikachu"}, options);
  const uint64_t kMutexWaitDelay = 100;
  ThreadStatusUtil::TEST_SetStateDelay(ThreadStatus::STATE_MUTEX_WAIT,
@@ -487,11 +487,11 @@ TEST_F(DBTest, PutSingleDeleteGet) {
    ASSERT_EQ("v2", Get(1, "foo2"));
    ASSERT_OK(SingleDelete(1, "foo"));
    ASSERT_EQ("NOT_FOUND", Get(1, "foo"));
-    // Skip FIFO and universal compaction beccause they do not apply to the test
-    // case. Skip MergePut because single delete does not get removed when it
-    // encounters a merge.
-  } while (ChangeOptions(kSkipFIFOCompaction | kSkipUniversalCompaction |
-                         kSkipMergePut));
+    // Skip HashCuckooRep as it does not support single delete. FIFO and
+    // universal compaction do not apply to the test case. Skip MergePut
+    // because single delete does not get removed when it encounters a merge.
+  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction |
+                         kSkipUniversalCompaction | kSkipMergePut));
 }

 TEST_F(DBTest, ReadFromPersistedTier) {
@@ -604,7 +604,7 @@ TEST_F(DBTest, ReadFromPersistedTier) {
        DestroyAndReopen(options);
      }
    }
-  } while (ChangeOptions());
+  } while (ChangeOptions(kSkipHashCuckoo));
 }

 TEST_F(DBTest, SingleDeleteFlush) {
@@ -640,11 +640,11 @@ TEST_F(DBTest, SingleDeleteFlush) {

    ASSERT_EQ("NOT_FOUND", Get(1, "bar"));
    ASSERT_EQ("NOT_FOUND", Get(1, "foo"));
-    // Skip FIFO and universal compaction beccause they do not apply to the test
-    // case. Skip MergePut because single delete does not get removed when it
-    // encounters a merge.
-  } while (ChangeOptions(kSkipFIFOCompaction | kSkipUniversalCompaction |
-                         kSkipMergePut));
+    // Skip HashCuckooRep as it does not support single delete. FIFO and
+    // universal compaction do not apply to the test case. Skip MergePut
+    // because merges cannot be combined with single deletions.
+  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction |
+                         kSkipUniversalCompaction | kSkipMergePut));
 }

 TEST_F(DBTest, SingleDeletePutFlush) {
@@ -663,11 +663,11 @@ TEST_F(DBTest, SingleDeletePutFlush) {
    ASSERT_OK(Flush(1));

    ASSERT_EQ("[ ]", AllEntriesFor("a", 1));
-    // Skip FIFO and universal compaction beccause they do not apply to the test
-    // case. Skip MergePut because single delete does not get removed when it
-    // encounters a merge.
-  } while (ChangeOptions(kSkipFIFOCompaction | kSkipUniversalCompaction |
-                         kSkipMergePut));
+    // Skip HashCuckooRep as it does not support single delete. FIFO and
+    // universal compaction do not apply to the test case. Skip MergePut
+    // because merges cannot be combined with single deletions.
+  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction |
+                         kSkipUniversalCompaction | kSkipMergePut));
 }

 // Disable because not all platform can run it.
@@ -940,13 +940,13 @@ TEST_F(DBTest, FlushSchedule) {
 namespace {
 class KeepFilter : public CompactionFilter {
 public:
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*value*/, std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    return false;
  }

-  const char* Name() const override { return "KeepFilter"; }
+  virtual const char* Name() const override { return "KeepFilter"; }
 };

 class KeepFilterFactory : public CompactionFilterFactory {
@@ -954,7 +954,7 @@ class KeepFilterFactory : public CompactionFilterFactory {
  explicit KeepFilterFactory(bool check_context = false)
      : check_context_(check_context) {}

-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    if (check_context_) {
      EXPECT_EQ(expect_full_compaction_.load(), context.is_full_compaction);
@@ -963,7 +963,7 @@ class KeepFilterFactory : public CompactionFilterFactory {
    return std::unique_ptr<CompactionFilter>(new KeepFilter());
  }

-  const char* Name() const override { return "KeepFilterFactory"; }
+  virtual const char* Name() const override { return "KeepFilterFactory"; }
  bool check_context_;
  std::atomic_bool expect_full_compaction_;
  std::atomic_bool expect_manual_compaction_;
@@ -972,14 +972,14 @@ class KeepFilterFactory : public CompactionFilterFactory {
 class DelayFilter : public CompactionFilter {
 public:
  explicit DelayFilter(DBTestBase* d) : db_test(d) {}
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*value*/, std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    db_test->env_->addon_time_.fetch_add(1000);
    return true;
  }

-  const char* Name() const override { return "DelayFilter"; }
+  virtual const char* Name() const override { return "DelayFilter"; }

 private:
  DBTestBase* db_test;
@@ -988,12 +988,12 @@ class DelayFilter : public CompactionFilter {
 class DelayFilterFactory : public CompactionFilterFactory {
 public:
  explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {}
-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& /*context*/) override {
    return std::unique_ptr<CompactionFilter>(new DelayFilter(db_test));
  }

-  const char* Name() const override { return "DelayFilterFactory"; }
+  virtual const char* Name() const override { return "DelayFilterFactory"; }

 private:
  DBTestBase* db_test;
@@ -1569,7 +1569,7 @@ TEST_F(DBTest, Snapshot) {
    ASSERT_EQ(0U, GetNumSnapshots());
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
-  } while (ChangeOptions());
+  } while (ChangeOptions(kSkipHashCuckoo));
 }

 TEST_F(DBTest, HiddenValuesAreRemoved) {
@@ -1606,8 +1606,9 @@ TEST_F(DBTest, HiddenValuesAreRemoved) {
    ASSERT_TRUE(Between(Size("", "pastfoo", 1), 0, 1000));
    // ApproximateOffsetOf() is not yet implemented in plain table format,
    // which is used by Size().
+    // skip HashCuckooRep as it does not support snapshot
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction |
-                         kSkipPlainTable));
+                         kSkipPlainTable | kSkipHashCuckoo));
 }
 #endif  // ROCKSDB_LITE

@@ -1653,11 +1654,11 @@ TEST_F(DBTest, UnremovableSingleDelete) {
    ASSERT_EQ("first", Get(1, "foo", snapshot));
    ASSERT_EQ("NOT_FOUND", Get(1, "foo"));
    db_->ReleaseSnapshot(snapshot);
-    // Skip FIFO and universal compaction beccause they do not apply to the test
-    // case. Skip MergePut because single delete does not get removed when it
-    // encounters a merge.
-  } while (ChangeOptions(kSkipFIFOCompaction | kSkipUniversalCompaction |
-                         kSkipMergePut));
+    // Skip HashCuckooRep as it does not support single delete.  FIFO and
+    // universal compaction do not apply to the test case.  Skip MergePut
+    // because single delete does not get removed when it encounters a merge.
+  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction |
+                         kSkipUniversalCompaction | kSkipMergePut));
 }

 #ifndef ROCKSDB_LITE
@@ -1775,14 +1776,17 @@ TEST_F(DBTest, OverlapInLevel0) {
 TEST_F(DBTest, ComparatorCheck) {
  class NewComparator : public Comparator {
   public:
-    const char* Name() const override { return "rocksdb.NewComparator"; }
-    int Compare(const Slice& a, const Slice& b) const override {
+    virtual const char* Name() const override {
+      return "rocksdb.NewComparator";
+    }
+    virtual int Compare(const Slice& a, const Slice& b) const override {
      return BytewiseComparator()->Compare(a, b);
    }
-    void FindShortestSeparator(std::string* s, const Slice& l) const override {
+    virtual void FindShortestSeparator(std::string* s,
+                                       const Slice& l) const override {
      BytewiseComparator()->FindShortestSeparator(s, l);
    }
-    void FindShortSuccessor(std::string* key) const override {
+    virtual void FindShortSuccessor(std::string* key) const override {
      BytewiseComparator()->FindShortSuccessor(key);
    }
  };
@@ -1805,15 +1809,18 @@ TEST_F(DBTest, ComparatorCheck) {
 TEST_F(DBTest, CustomComparator) {
  class NumberComparator : public Comparator {
   public:
-    const char* Name() const override { return "test.NumberComparator"; }
-    int Compare(const Slice& a, const Slice& b) const override {
+    virtual const char* Name() const override {
+      return "test.NumberComparator";
+    }
+    virtual int Compare(const Slice& a, const Slice& b) const override {
      return ToNumber(a) - ToNumber(b);
    }
-    void FindShortestSeparator(std::string* s, const Slice& l) const override {
+    virtual void FindShortestSeparator(std::string* s,
+                                       const Slice& l) const override {
      ToNumber(*s);  // Check format
      ToNumber(l);   // Check format
    }
-    void FindShortSuccessor(std::string* key) const override {
+    virtual void FindShortSuccessor(std::string* key) const override {
      ToNumber(*key);  // Check format
    }

@@ -2247,12 +2254,15 @@ static void MTThreadBody(void* arg) {
 class MultiThreadedDBTest : public DBTest,
                            public ::testing::WithParamInterface<int> {
 public:
-  void SetUp() override { option_config_ = GetParam(); }
+  virtual void SetUp() override { option_config_ = GetParam(); }

  static std::vector<int> GenerateOptionConfigs() {
    std::vector<int> optionConfigs;
    for (int optionConfig = kDefault; optionConfig < kEnd; ++optionConfig) {
-      optionConfigs.push_back(optionConfig);
+      // skip as HashCuckooRep does not support snapshot
+      if (optionConfig != kHashCuckoo) {
+        optionConfigs.push_back(optionConfig);
+      }
    }
    return optionConfigs;
  }
@@ -2392,7 +2402,7 @@ class ModelDB : public DB {
   public:
    KVMap map_;

-    SequenceNumber GetSequenceNumber() const override {
+    virtual SequenceNumber GetSequenceNumber() const override {
      // no need to call this
      assert(false);
      return 0;
@@ -2401,43 +2411,43 @@ class ModelDB : public DB {

  explicit ModelDB(const Options& options) : options_(options) {}
  using DB::Put;
-  Status Put(const WriteOptions& o, ColumnFamilyHandle* cf, const Slice& k,
-             const Slice& v) override {
+  virtual Status Put(const WriteOptions& o, ColumnFamilyHandle* cf,
+                     const Slice& k, const Slice& v) override {
    WriteBatch batch;
    batch.Put(cf, k, v);
    return Write(o, &batch);
  }
  using DB::Close;
-  Status Close() override { return Status::OK(); }
+  virtual Status Close() override { return Status::OK(); }
  using DB::Delete;
-  Status Delete(const WriteOptions& o, ColumnFamilyHandle* cf,
-                const Slice& key) override {
+  virtual Status Delete(const WriteOptions& o, ColumnFamilyHandle* cf,
+                        const Slice& key) override {
    WriteBatch batch;
    batch.Delete(cf, key);
    return Write(o, &batch);
  }
  using DB::SingleDelete;
-  Status SingleDelete(const WriteOptions& o, ColumnFamilyHandle* cf,
-                      const Slice& key) override {
+  virtual Status SingleDelete(const WriteOptions& o, ColumnFamilyHandle* cf,
+                              const Slice& key) override {
    WriteBatch batch;
    batch.SingleDelete(cf, key);
    return Write(o, &batch);
  }
  using DB::Merge;
-  Status Merge(const WriteOptions& o, ColumnFamilyHandle* cf, const Slice& k,
-               const Slice& v) override {
+  virtual Status Merge(const WriteOptions& o, ColumnFamilyHandle* cf,
+                       const Slice& k, const Slice& v) override {
    WriteBatch batch;
    batch.Merge(cf, k, v);
    return Write(o, &batch);
  }
  using DB::Get;
-  Status Get(const ReadOptions& /*options*/, ColumnFamilyHandle* /*cf*/,
-             const Slice& key, PinnableSlice* /*value*/) override {
+  virtual Status Get(const ReadOptions& /*options*/, ColumnFamilyHandle* /*cf*/,
+                     const Slice& key, PinnableSlice* /*value*/) override {
    return Status::NotSupported(key);
  }

  using DB::MultiGet;
-  std::vector<Status> MultiGet(
+  virtual std::vector<Status> MultiGet(
      const ReadOptions& /*options*/,
      const std::vector<ColumnFamilyHandle*>& /*column_family*/,
      const std::vector<Slice>& keys,
@@ -2449,31 +2459,25 @@ class ModelDB : public DB {

 #ifndef ROCKSDB_LITE
  using DB::IngestExternalFile;
-  Status IngestExternalFile(
+  virtual Status IngestExternalFile(
      ColumnFamilyHandle* /*column_family*/,
      const std::vector<std::string>& /*external_files*/,
      const IngestExternalFileOptions& /*options*/) override {
    return Status::NotSupported("Not implemented.");
  }

-  using DB::IngestExternalFiles;
-  Status IngestExternalFiles(
-      const std::vector<IngestExternalFileArg>& /*args*/) override {
-    return Status::NotSupported("Not implemented");
-  }
-
-  Status VerifyChecksum() override {
+  virtual Status VerifyChecksum() override {
    return Status::NotSupported("Not implemented.");
  }

  using DB::GetPropertiesOfAllTables;
-  Status GetPropertiesOfAllTables(
+  virtual Status GetPropertiesOfAllTables(
      ColumnFamilyHandle* /*column_family*/,
      TablePropertiesCollection* /*props*/) override {
    return Status();
  }

-  Status GetPropertiesOfTablesInRange(
+  virtual Status GetPropertiesOfTablesInRange(
      ColumnFamilyHandle* /*column_family*/, const Range* /*range*/,
      std::size_t /*n*/, TablePropertiesCollection* /*props*/) override {
    return Status();
@@ -2481,18 +2485,19 @@ class ModelDB : public DB {
 #endif  // ROCKSDB_LITE

  using DB::KeyMayExist;
-  bool KeyMayExist(const ReadOptions& /*options*/,
-                   ColumnFamilyHandle* /*column_family*/, const Slice& /*key*/,
-                   std::string* /*value*/,
-                   bool* value_found = nullptr) override {
+  virtual bool KeyMayExist(const ReadOptions& /*options*/,
+                           ColumnFamilyHandle* /*column_family*/,
+                           const Slice& /*key*/, std::string* /*value*/,
+                           bool* value_found = nullptr) override {
    if (value_found != nullptr) {
      *value_found = false;
    }
    return true;  // Not Supported directly
  }
  using DB::NewIterator;
-  Iterator* NewIterator(const ReadOptions& options,
-                        ColumnFamilyHandle* /*column_family*/) override {
+  virtual Iterator* NewIterator(
+      const ReadOptions& options,
+      ColumnFamilyHandle* /*column_family*/) override {
    if (options.snapshot == nullptr) {
      KVMap* saved = new KVMap;
      *saved = map_;
@@ -2503,33 +2508,38 @@ class ModelDB : public DB {
      return new ModelIter(snapshot_state, false);
    }
  }
-  Status NewIterators(const ReadOptions& /*options*/,
-                      const std::vector<ColumnFamilyHandle*>& /*column_family*/,
-                      std::vector<Iterator*>* /*iterators*/) override {
+  virtual Status NewIterators(
+      const ReadOptions& /*options*/,
+      const std::vector<ColumnFamilyHandle*>& /*column_family*/,
+      std::vector<Iterator*>* /*iterators*/) override {
    return Status::NotSupported("Not supported yet");
  }
-  const Snapshot* GetSnapshot() override {
+  virtual const Snapshot* GetSnapshot() override {
    ModelSnapshot* snapshot = new ModelSnapshot;
    snapshot->map_ = map_;
    return snapshot;
  }

-  void ReleaseSnapshot(const Snapshot* snapshot) override {
+  virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
    delete reinterpret_cast<const ModelSnapshot*>(snapshot);
  }

-  Status Write(const WriteOptions& /*options*/, WriteBatch* batch) override {
+  virtual Status Write(const WriteOptions& /*options*/,
+                       WriteBatch* batch) override {
    class Handler : public WriteBatch::Handler {
     public:
      KVMap* map_;
-      void Put(const Slice& key, const Slice& value) override {
+      virtual void Put(const Slice& key, const Slice& value) override {
        (*map_)[key.ToString()] = value.ToString();
      }
-      void Merge(const Slice& /*key*/, const Slice& /*value*/) override {
+      virtual void Merge(const Slice& /*key*/,
+                         const Slice& /*value*/) override {
        // ignore merge for now
        // (*map_)[key.ToString()] = value.ToString();
      }
-      void Delete(const Slice& key) override { map_->erase(key.ToString()); }
+      virtual void Delete(const Slice& key) override {
+        map_->erase(key.ToString());
+      }
    };
    Handler handler;
    handler.map_ = &map_;
@@ -2537,58 +2547,61 @@ class ModelDB : public DB {
  }

  using DB::GetProperty;
-  bool GetProperty(ColumnFamilyHandle* /*column_family*/,
-                   const Slice& /*property*/, std::string* /*value*/) override {
+  virtual bool GetProperty(ColumnFamilyHandle* /*column_family*/,
+                           const Slice& /*property*/,
+                           std::string* /*value*/) override {
    return false;
  }
  using DB::GetIntProperty;
-  bool GetIntProperty(ColumnFamilyHandle* /*column_family*/,
-                      const Slice& /*property*/, uint64_t* /*value*/) override {
+  virtual bool GetIntProperty(ColumnFamilyHandle* /*column_family*/,
+                              const Slice& /*property*/,
+                              uint64_t* /*value*/) override {
    return false;
  }
  using DB::GetMapProperty;
-  bool GetMapProperty(ColumnFamilyHandle* /*column_family*/,
-                      const Slice& /*property*/,
-                      std::map<std::string, std::string>* /*value*/) override {
+  virtual bool GetMapProperty(
+      ColumnFamilyHandle* /*column_family*/, const Slice& /*property*/,
+      std::map<std::string, std::string>* /*value*/) override {
    return false;
  }
  using DB::GetAggregatedIntProperty;
-  bool GetAggregatedIntProperty(const Slice& /*property*/,
-                                uint64_t* /*value*/) override {
+  virtual bool GetAggregatedIntProperty(const Slice& /*property*/,
+                                        uint64_t* /*value*/) override {
    return false;
  }
  using DB::GetApproximateSizes;
-  void GetApproximateSizes(ColumnFamilyHandle* /*column_family*/,
-                           const Range* /*range*/, int n, uint64_t* sizes,
-                           uint8_t /*include_flags*/
-                           = INCLUDE_FILES) override {
+  virtual void GetApproximateSizes(ColumnFamilyHandle* /*column_family*/,
+                                   const Range* /*range*/, int n,
+                                   uint64_t* sizes,
+                                   uint8_t /*include_flags*/
+                                   = INCLUDE_FILES) override {
    for (int i = 0; i < n; i++) {
      sizes[i] = 0;
    }
  }
  using DB::GetApproximateMemTableStats;
-  void GetApproximateMemTableStats(ColumnFamilyHandle* /*column_family*/,
-                                   const Range& /*range*/,
-                                   uint64_t* const count,
-                                   uint64_t* const size) override {
+  virtual void GetApproximateMemTableStats(
+      ColumnFamilyHandle* /*column_family*/, const Range& /*range*/,
+      uint64_t* const count, uint64_t* const size) override {
    *count = 0;
    *size = 0;
  }
  using DB::CompactRange;
-  Status CompactRange(const CompactRangeOptions& /*options*/,
-                      ColumnFamilyHandle* /*column_family*/,
-                      const Slice* /*start*/, const Slice* /*end*/) override {
+  virtual Status CompactRange(const CompactRangeOptions& /*options*/,
+                              ColumnFamilyHandle* /*column_family*/,
+                              const Slice* /*start*/,
+                              const Slice* /*end*/) override {
    return Status::NotSupported("Not supported operation.");
  }

-  Status SetDBOptions(
+  virtual Status SetDBOptions(
      const std::unordered_map<std::string, std::string>& /*new_options*/)
      override {
    return Status::NotSupported("Not supported operation.");
  }

  using DB::CompactFiles;
-  Status CompactFiles(
+  virtual Status CompactFiles(
      const CompactionOptions& /*compact_options*/,
      ColumnFamilyHandle* /*column_family*/,
      const std::vector<std::string>& /*input_file_names*/,
@@ -2613,60 +2626,69 @@ class ModelDB : public DB {
  }

  using DB::NumberLevels;
-  int NumberLevels(ColumnFamilyHandle* /*column_family*/) override { return 1; }
+  virtual int NumberLevels(ColumnFamilyHandle* /*column_family*/) override {
+    return 1;
+  }

  using DB::MaxMemCompactionLevel;
-  int MaxMemCompactionLevel(ColumnFamilyHandle* /*column_family*/) override {
+  virtual int MaxMemCompactionLevel(
+      ColumnFamilyHandle* /*column_family*/) override {
    return 1;
  }

  using DB::Level0StopWriteTrigger;
-  int Level0StopWriteTrigger(ColumnFamilyHandle* /*column_family*/) override {
+  virtual int Level0StopWriteTrigger(
+      ColumnFamilyHandle* /*column_family*/) override {
    return -1;
  }

-  const std::string& GetName() const override { return name_; }
+  virtual const std::string& GetName() const override { return name_; }

-  Env* GetEnv() const override { return nullptr; }
+  virtual Env* GetEnv() const override { return nullptr; }

  using DB::GetOptions;
-  Options GetOptions(ColumnFamilyHandle* /*column_family*/) const override {
+  virtual Options GetOptions(
+      ColumnFamilyHandle* /*column_family*/) const override {
    return options_;
  }

  using DB::GetDBOptions;
-  DBOptions GetDBOptions() const override { return options_; }
+  virtual DBOptions GetDBOptions() const override { return options_; }

  using DB::Flush;
-  Status Flush(const rocksdb::FlushOptions& /*options*/,
-               ColumnFamilyHandle* /*column_family*/) override {
+  virtual Status Flush(const rocksdb::FlushOptions& /*options*/,
+                       ColumnFamilyHandle* /*column_family*/) override {
    Status ret;
    return ret;
  }
-  Status Flush(
+  virtual Status Flush(
      const rocksdb::FlushOptions& /*options*/,
      const std::vector<ColumnFamilyHandle*>& /*column_families*/) override {
    return Status::OK();
  }

-  Status SyncWAL() override { return Status::OK(); }
+  virtual Status SyncWAL() override { return Status::OK(); }

 #ifndef ROCKSDB_LITE
-  Status DisableFileDeletions() override { return Status::OK(); }
+  virtual Status DisableFileDeletions() override { return Status::OK(); }

-  Status EnableFileDeletions(bool /*force*/) override { return Status::OK(); }
-  Status GetLiveFiles(std::vector<std::string>&, uint64_t* /*size*/,
-                      bool /*flush_memtable*/ = true) override {
+  virtual Status EnableFileDeletions(bool /*force*/) override {
+    return Status::OK();
+  }
+  virtual Status GetLiveFiles(std::vector<std::string>&, uint64_t* /*size*/,
+                              bool /*flush_memtable*/ = true) override {
    return Status::OK();
  }

-  Status GetSortedWalFiles(VectorLogPtr& /*files*/) override {
+  virtual Status GetSortedWalFiles(VectorLogPtr& /*files*/) override {
    return Status::OK();
  }

-  Status DeleteFile(std::string /*name*/) override { return Status::OK(); }
+  virtual Status DeleteFile(std::string /*name*/) override {
+    return Status::OK();
+  }

-  Status GetUpdatesSince(
+  virtual Status GetUpdatesSince(
      rocksdb::SequenceNumber,
      std::unique_ptr<rocksdb::TransactionLogIterator>*,
      const TransactionLogIterator::ReadOptions& /*read_options*/ =
@@ -2674,48 +2696,52 @@ class ModelDB : public DB {
    return Status::NotSupported("Not supported in Model DB");
  }

-  void GetColumnFamilyMetaData(ColumnFamilyHandle* /*column_family*/,
-                               ColumnFamilyMetaData* /*metadata*/) override {}
+  virtual void GetColumnFamilyMetaData(
+      ColumnFamilyHandle* /*column_family*/,
+      ColumnFamilyMetaData* /*metadata*/) override {}
 #endif  // ROCKSDB_LITE

-  Status GetDbIdentity(std::string& /*identity*/) const override {
+  virtual Status GetDbIdentity(std::string& /*identity*/) const override {
    return Status::OK();
  }

-  SequenceNumber GetLatestSequenceNumber() const override { return 0; }
+  virtual SequenceNumber GetLatestSequenceNumber() const override { return 0; }

-  bool SetPreserveDeletesSequenceNumber(SequenceNumber /*seqnum*/) override {
+  virtual bool SetPreserveDeletesSequenceNumber(
+      SequenceNumber /*seqnum*/) override {
    return true;
  }

-  ColumnFamilyHandle* DefaultColumnFamily() const override { return nullptr; }
+  virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
+    return nullptr;
+  }

 private:
  class ModelIter : public Iterator {
   public:
    ModelIter(const KVMap* map, bool owned)
        : map_(map), owned_(owned), iter_(map_->end()) {}
-    ~ModelIter() override {
+    ~ModelIter() {
      if (owned_) delete map_;
    }
-    bool Valid() const override { return iter_ != map_->end(); }
-    void SeekToFirst() override { iter_ = map_->begin(); }
-    void SeekToLast() override {
+    virtual bool Valid() const override { return iter_ != map_->end(); }
+    virtual void SeekToFirst() override { iter_ = map_->begin(); }
+    virtual void SeekToLast() override {
      if (map_->empty()) {
        iter_ = map_->end();
      } else {
        iter_ = map_->find(map_->rbegin()->first);
      }
    }
-    void Seek(const Slice& k) override {
+    virtual void Seek(const Slice& k) override {
      iter_ = map_->lower_bound(k.ToString());
    }
-    void SeekForPrev(const Slice& k) override {
+    virtual void SeekForPrev(const Slice& k) override {
      iter_ = map_->upper_bound(k.ToString());
      Prev();
    }
-    void Next() override { ++iter_; }
-    void Prev() override {
+    virtual void Next() override { ++iter_; }
+    virtual void Prev() override {
      if (iter_ == map_->begin()) {
        iter_ = map_->end();
        return;
@@ -2723,9 +2749,9 @@ class ModelDB : public DB {
      --iter_;
    }

-    Slice key() const override { return iter_->first; }
-    Slice value() const override { return iter_->second; }
-    Status status() const override { return Status::OK(); }
+    virtual Slice key() const override { return iter_->first; }
+    virtual Slice value() const override { return iter_->second; }
+    virtual Status status() const override { return Status::OK(); }

   private:
    const KVMap* const map_;
@@ -2793,14 +2819,15 @@ static bool CompareIterators(int step, DB* model, DB* db,
 class DBTestRandomized : public DBTest,
                         public ::testing::WithParamInterface<int> {
 public:
-  void SetUp() override { option_config_ = GetParam(); }
+  virtual void SetUp() override { option_config_ = GetParam(); }

  static std::vector<int> GenerateOptionConfigs() {
    std::vector<int> option_configs;
    // skip cuckoo hash as it does not support snapshot.
    for (int option_config = kDefault; option_config < kEnd; ++option_config) {
-      if (!ShouldSkipOptions(option_config,
-                             kSkipDeletesFilterFirst | kSkipNoSeekToLast)) {
+      if (!ShouldSkipOptions(option_config, kSkipDeletesFilterFirst |
+                                                kSkipNoSeekToLast |
+                                                kSkipHashCuckoo)) {
        option_configs.push_back(option_config);
      }
    }
@@ -2830,6 +2857,7 @@ TEST_P(DBTestRandomized, Randomized) {
    int p = rnd.Uniform(100);
    int minimum = 0;
    if (option_config_ == kHashSkipList || option_config_ == kHashLinkList ||
+        option_config_ == kHashCuckoo ||
        option_config_ == kPlainTableFirstBytePrefix ||
        option_config_ == kBlockBasedTableWithWholeKeyHashIndex ||
        option_config_ == kBlockBasedTableWithPrefixHashIndex) {
@@ -3083,7 +3111,7 @@ TEST_F(DBTest, FIFOCompactionWithTTLAndMaxOpenFilesTest) {
  Options options;
  options.compaction_style = kCompactionStyleFIFO;
  options.create_if_missing = true;
-  options.ttl = 600;  // seconds
+  options.compaction_options_fifo.ttl = 600;  // seconds

  // Check that it is not supported with max_open_files != -1.
  options.max_open_files = 100;
@@ -3099,7 +3127,7 @@ TEST_F(DBTest, FIFOCompactionWithTTLAndVariousTableFormatsTest) {
  Options options;
  options.compaction_style = kCompactionStyleFIFO;
  options.create_if_missing = true;
-  options.ttl = 600;  // seconds
+  options.compaction_options_fifo.ttl = 600;  // seconds

  options = CurrentOptions(options);
  options.table_factory.reset(NewBlockBasedTableFactory());
@@ -3109,6 +3137,10 @@ TEST_F(DBTest, FIFOCompactionWithTTLAndVariousTableFormatsTest) {
  options.table_factory.reset(NewPlainTableFactory());
  ASSERT_TRUE(TryReopen(options).IsNotSupported());

+  Destroy(options);
+  options.table_factory.reset(NewCuckooTableFactory());
+  ASSERT_TRUE(TryReopen(options).IsNotSupported());
+
  Destroy(options);
  options.table_factory.reset(NewAdaptiveTableFactory());
  ASSERT_TRUE(TryReopen(options).IsNotSupported());
@@ -3130,7 +3162,7 @@ TEST_F(DBTest, FIFOCompactionWithTTLTest) {
    env_->addon_time_.store(0);
    options.compaction_options_fifo.max_table_files_size = 150 << 10;  // 150KB
    options.compaction_options_fifo.allow_compaction = false;
-    options.ttl = 1 * 60 * 60 ;  // 1 hour
+    options.compaction_options_fifo.ttl = 1 * 60 * 60 ;  // 1 hour
    options = CurrentOptions(options);
    DestroyAndReopen(options);

@@ -3165,7 +3197,7 @@ TEST_F(DBTest, FIFOCompactionWithTTLTest) {
  {
    options.compaction_options_fifo.max_table_files_size = 150 << 10;  // 150KB
    options.compaction_options_fifo.allow_compaction = false;
-    options.ttl = 1 * 60 * 60;  // 1 hour
+    options.compaction_options_fifo.ttl = 1 * 60 * 60;  // 1 hour
    options = CurrentOptions(options);
    DestroyAndReopen(options);

@@ -3207,7 +3239,7 @@ TEST_F(DBTest, FIFOCompactionWithTTLTest) {
    options.write_buffer_size = 10 << 10;                              // 10KB
    options.compaction_options_fifo.max_table_files_size = 150 << 10;  // 150KB
    options.compaction_options_fifo.allow_compaction = false;
-    options.ttl =  1 * 60 * 60;  // 1 hour
+    options.compaction_options_fifo.ttl =  1 * 60 * 60;  // 1 hour
    options = CurrentOptions(options);
    DestroyAndReopen(options);

@@ -3244,7 +3276,7 @@ TEST_F(DBTest, FIFOCompactionWithTTLTest) {
  {
    options.compaction_options_fifo.max_table_files_size = 150 << 10;  // 150KB
    options.compaction_options_fifo.allow_compaction = true;
-    options.ttl = 1 * 60 * 60;  // 1 hour
+    options.compaction_options_fifo.ttl = 1 * 60 * 60;  // 1 hour
    options.level0_file_num_compaction_trigger = 6;
    options = CurrentOptions(options);
    DestroyAndReopen(options);
@@ -3288,7 +3320,7 @@ TEST_F(DBTest, FIFOCompactionWithTTLTest) {
    options.write_buffer_size = 20 << 10;                               // 20K
    options.compaction_options_fifo.max_table_files_size = 1500 << 10;  // 1.5MB
    options.compaction_options_fifo.allow_compaction = true;
-    options.ttl = 1 * 60 * 60;  // 1 hour
+    options.compaction_options_fifo.ttl = 1 * 60 * 60;  // 1 hour
    options.level0_file_num_compaction_trigger = 6;
    options = CurrentOptions(options);
    DestroyAndReopen(options);
@@ -4587,7 +4619,7 @@ TEST_F(DBTest, DynamicCompactionOptions) {
  ASSERT_LT(NumTableFilesAtLevel(0), 4);
 }

-// Test dynamic FIFO compaction options.
+// Test dynamic FIFO copmaction options.
 // This test covers just option parsing and makes sure that the options are
 // correctly assigned. Also look at DBOptionsTest.SetFIFOCompactionOptions
 // test which makes sure that the FIFO compaction funcionality is working
@@ -4601,7 +4633,7 @@ TEST_F(DBTest, DynamicFIFOCompactionOptions) {
  // Initial defaults
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
            1024 * 1024 * 1024);
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 0);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 0);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
            false);

@@ -4609,21 +4641,21 @@ TEST_F(DBTest, DynamicFIFOCompactionOptions) {
      {{"compaction_options_fifo", "{max_table_files_size=23;}"}}));
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
            23);
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 0);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 0);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
            false);

-  ASSERT_OK(dbfull()->SetOptions({{"ttl", "97"}}));
+  ASSERT_OK(dbfull()->SetOptions({{"compaction_options_fifo", "{ttl=97}"}}));
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
            23);
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 97);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 97);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
            false);

-  ASSERT_OK(dbfull()->SetOptions({{"ttl", "203"}}));
+  ASSERT_OK(dbfull()->SetOptions({{"compaction_options_fifo", "{ttl=203;}"}}));
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
            23);
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 203);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 203);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
            false);

@@ -4631,25 +4663,24 @@ TEST_F(DBTest, DynamicFIFOCompactionOptions) {
      {{"compaction_options_fifo", "{allow_compaction=true;}"}}));
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
            23);
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 203);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 203);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
            true);

  ASSERT_OK(dbfull()->SetOptions(
-      {{"compaction_options_fifo", "{max_table_files_size=31;}"}}));
+      {{"compaction_options_fifo", "{max_table_files_size=31;ttl=19;}"}}));
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
            31);
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 203);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 19);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
            true);

  ASSERT_OK(dbfull()->SetOptions(
      {{"compaction_options_fifo",
-        "{max_table_files_size=51;allow_compaction=true;}"}}));
-  ASSERT_OK(dbfull()->SetOptions({{"ttl", "49"}}));
+        "{max_table_files_size=51;ttl=49;allow_compaction=true;}"}}));
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
            51);
-  ASSERT_EQ(dbfull()->GetOptions().ttl, 49);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 49);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
            true);
 }
@@ -5016,14 +5047,14 @@ class DelayedMergeOperator : public MergeOperator {
 public:
  explicit DelayedMergeOperator(DBTest* d) : db_test_(d) {}

-  bool FullMergeV2(const MergeOperationInput& /*merge_in*/,
-                   MergeOperationOutput* merge_out) const override {
+  virtual bool FullMergeV2(const MergeOperationInput& /*merge_in*/,
+                           MergeOperationOutput* merge_out) const override {
    db_test_->env_->addon_time_.fetch_add(1000);
    merge_out->new_value = "";
    return true;
  }

-  const char* Name() const override { return "DelayedMergeOperator"; }
+  virtual const char* Name() const override { return "DelayedMergeOperator"; }
 };

 TEST_F(DBTest, MergeTestTime) {
@@ -5102,7 +5133,7 @@ TEST_P(DBTestWithParam, FilterCompactionTimeTest) {
  options.disable_auto_compactions = true;
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
-  options.statistics->set_stats_level(kExceptTimeForMutex);
+  options.statistics->stats_level_ = kExceptTimeForMutex;
  options.max_subcompactions = max_subcompactions_;
  DestroyAndReopen(options);

@@ -5159,7 +5190,7 @@ TEST_F(DBTest, EmptyCompactedDB) {
 TEST_F(DBTest, SuggestCompactRangeTest) {
  class CompactionFilterFactoryGetContext : public CompactionFilterFactory {
   public:
-    std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+    virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
        const CompactionFilter::Context& context) override {
      saved_context = context;
      std::unique_ptr<CompactionFilter> empty_filter;
@@ -5409,69 +5440,6 @@ TEST_F(DBTest, AutomaticConflictsWithManualCompaction) {
  dbfull()->TEST_WaitForCompact();
 }

-#ifndef ROCKSDB_LITE
-TEST_F(DBTest, CompactFilesShouldTriggerAutoCompaction) {
-  Options options = CurrentOptions();
-  options.max_background_compactions = 1;
-  options.level0_file_num_compaction_trigger = 4;
-  options.level0_slowdown_writes_trigger = 36;
-  options.level0_stop_writes_trigger = 36;
-  DestroyAndReopen(options);
-
-  // generate files for manual compaction
-  Random rnd(301);
-  for (int i = 0; i < 2; ++i) {
-    // put two keys to ensure no trivial move
-    for (int j = 0; j < 2; ++j) {
-      ASSERT_OK(Put(Key(j), RandomString(&rnd, 1024)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  rocksdb::ColumnFamilyMetaData cf_meta_data;
-  db_->GetColumnFamilyMetaData(db_->DefaultColumnFamily(), &cf_meta_data);
-
-  std::vector<std::string> input_files;
-  input_files.push_back(cf_meta_data.levels[0].files[0].name);
-
-  SyncPoint::GetInstance()->LoadDependency({
-      {"CompactFilesImpl:0",
-       "DBTest::CompactFilesShouldTriggerAutoCompaction:Begin"},
-      {"DBTest::CompactFilesShouldTriggerAutoCompaction:End",
-       "CompactFilesImpl:1"},
-  });
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  port::Thread manual_compaction_thread([&]() {
-      auto s = db_->CompactFiles(CompactionOptions(),
-          db_->DefaultColumnFamily(), input_files, 0);
-  });
-
-  TEST_SYNC_POINT(
-          "DBTest::CompactFilesShouldTriggerAutoCompaction:Begin");
-  // generate enough files to trigger compaction
-  for (int i = 0; i < 20; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      ASSERT_OK(Put(Key(j), RandomString(&rnd, 1024)));
-    }
-    ASSERT_OK(Flush());
-  }
-  db_->GetColumnFamilyMetaData(db_->DefaultColumnFamily(), &cf_meta_data);
-  ASSERT_GT(cf_meta_data.levels[0].files.size(),
-      options.level0_file_num_compaction_trigger);
-  TEST_SYNC_POINT(
-          "DBTest::CompactFilesShouldTriggerAutoCompaction:End");
-
-  manual_compaction_thread.join();
-  dbfull()->TEST_WaitForCompact();
-
-  db_->GetColumnFamilyMetaData(db_->DefaultColumnFamily(), &cf_meta_data);
-  ASSERT_LE(cf_meta_data.levels[0].files.size(),
-      options.level0_file_num_compaction_trigger);
-}
-#endif  // ROCKSDB_LITE
-
 // Github issue #595
 // Large write batch with column families
 TEST_F(DBTest, LargeBatchWithColumnFamilies) {
@@ -30,7 +30,7 @@ class PrefixFullBloomWithReverseComparator
 public:
  PrefixFullBloomWithReverseComparator()
      : DBTestBase("/prefix_bloom_reverse") {}
-  void SetUp() override { if_cache_filter_ = GetParam(); }
+  virtual void SetUp() override { if_cache_filter_ = GetParam(); }
  bool if_cache_filter_;
 };

@@ -515,9 +515,9 @@ TEST_F(DBTest2, WalFilterTest) {
      apply_option_at_record_index_(apply_option_for_record_index),
      current_record_index_(0) {}

-    WalProcessingOption LogRecord(const WriteBatch& /*batch*/,
-                                  WriteBatch* /*new_batch*/,
-                                  bool* /*batch_changed*/) const override {
+    virtual WalProcessingOption LogRecord(
+        const WriteBatch& /*batch*/, WriteBatch* /*new_batch*/,
+        bool* /*batch_changed*/) const override {
      WalFilter::WalProcessingOption option_to_return;

      if (current_record_index_ == apply_option_at_record_index_) {
@@ -535,7 +535,7 @@ TEST_F(DBTest2, WalFilterTest) {
      return option_to_return;
    }

-    const char* Name() const override { return "TestWalFilter"; }
+    virtual const char* Name() const override { return "TestWalFilter"; }
  };

  // Create 3 batches with two keys each
@@ -687,7 +687,7 @@ TEST_F(DBTest2, WalFilterTestWithChangeBatch) {
      : new_write_batch_(new_write_batch),
      num_keys_to_add_in_new_batch_(num_keys_to_add_in_new_batch),
      num_keys_added_(0) {}
-    void Put(const Slice& key, const Slice& value) override {
+    virtual void Put(const Slice& key, const Slice& value) override {
      if (num_keys_added_ < num_keys_to_add_in_new_batch_) {
        new_write_batch_->Put(key, value);
        ++num_keys_added_;
@@ -711,9 +711,9 @@ TEST_F(DBTest2, WalFilterTestWithChangeBatch) {
      num_keys_to_add_in_new_batch_(num_keys_to_add_in_new_batch),
      current_record_index_(0) {}

-    WalProcessingOption LogRecord(const WriteBatch& batch,
-                                  WriteBatch* new_batch,
-                                  bool* batch_changed) const override {
+    virtual WalProcessingOption LogRecord(const WriteBatch& batch,
+      WriteBatch* new_batch,
+      bool* batch_changed) const override {
      if (current_record_index_ >= change_records_from_index_) {
        ChangeBatchHandler handler(new_batch, num_keys_to_add_in_new_batch_);
        batch.Iterate(&handler);
@@ -729,7 +729,9 @@ TEST_F(DBTest2, WalFilterTestWithChangeBatch) {
      return WalProcessingOption::kContinueProcessing;
    }

-    const char* Name() const override { return "TestWalFilterWithChangeBatch"; }
+    virtual const char* Name() const override {
+      return "TestWalFilterWithChangeBatch";
+    }
  };

  std::vector<std::vector<std::string>> batch_keys(3);
@@ -807,17 +809,18 @@ TEST_F(DBTest2, WalFilterTestWithChangeBatch) {
 TEST_F(DBTest2, WalFilterTestWithChangeBatchExtraKeys) {
  class TestWalFilterWithChangeBatchAddExtraKeys : public WalFilter {
  public:
-   WalProcessingOption LogRecord(const WriteBatch& batch, WriteBatch* new_batch,
-                                 bool* batch_changed) const override {
-     *new_batch = batch;
-     new_batch->Put("key_extra", "value_extra");
-     *batch_changed = true;
-     return WalProcessingOption::kContinueProcessing;
-   }
+    virtual WalProcessingOption LogRecord(const WriteBatch& batch,
+      WriteBatch* new_batch,
+      bool* batch_changed) const override {
+      *new_batch = batch;
+      new_batch->Put("key_extra", "value_extra");
+      *batch_changed = true;
+      return WalProcessingOption::kContinueProcessing;
+    }

-   const char* Name() const override {
-     return "WalFilterTestWithChangeBatchExtraKeys";
-   }
+    virtual const char* Name() const override {
+      return "WalFilterTestWithChangeBatchExtraKeys";
+    }
  };

  std::vector<std::vector<std::string>> batch_keys(3);
@@ -881,19 +884,18 @@ TEST_F(DBTest2, WalFilterTestWithColumnFamilies) {
    // for verification against the keys we expect.
    std::map<uint32_t, std::vector<std::string>> cf_wal_keys_;
  public:
-   void ColumnFamilyLogNumberMap(
-       const std::map<uint32_t, uint64_t>& cf_lognumber_map,
-       const std::map<std::string, uint32_t>& cf_name_id_map) override {
-     cf_log_number_map_ = cf_lognumber_map;
-     cf_name_id_map_ = cf_name_id_map;
-   }
+    virtual void ColumnFamilyLogNumberMap(
+      const std::map<uint32_t, uint64_t>& cf_lognumber_map,
+      const std::map<std::string, uint32_t>& cf_name_id_map) override {
+      cf_log_number_map_ = cf_lognumber_map;
+      cf_name_id_map_ = cf_name_id_map;
+    }

-   WalProcessingOption LogRecordFound(unsigned long long log_number,
-                                      const std::string& /*log_file_name*/,
-                                      const WriteBatch& batch,
-                                      WriteBatch* /*new_batch*/,
-                                      bool* /*batch_changed*/) override {
-     class LogRecordBatchHandler : public WriteBatch::Handler {
+    virtual WalProcessingOption LogRecordFound(
+        unsigned long long log_number, const std::string& /*log_file_name*/,
+        const WriteBatch& batch, WriteBatch* /*new_batch*/,
+        bool* /*batch_changed*/) override {
+      class LogRecordBatchHandler : public WriteBatch::Handler {
      private:
        const std::map<uint32_t, uint64_t> & cf_log_number_map_;
        std::map<uint32_t, std::vector<std::string>> & cf_wal_keys_;
@@ -906,8 +908,8 @@ TEST_F(DBTest2, WalFilterTestWithColumnFamilies) {
          cf_wal_keys_(cf_wal_keys),
          log_number_(current_log_number){}

-        Status PutCF(uint32_t column_family_id, const Slice& key,
-                     const Slice& /*value*/) override {
+        virtual Status PutCF(uint32_t column_family_id, const Slice& key,
+          const Slice& /*value*/) override {
          auto it = cf_log_number_map_.find(column_family_id);
          assert(it != cf_log_number_map_.end());
          unsigned long long log_number_for_cf = it->second;
@@ -925,11 +927,11 @@ TEST_F(DBTest2, WalFilterTestWithColumnFamilies) {
      batch.Iterate(&handler);

      return WalProcessingOption::kContinueProcessing;
-   }
+    }

-   const char* Name() const override {
-     return "WalFilterTestWithColumnFamilies";
-   }
+    virtual const char* Name() const override {
+      return "WalFilterTestWithColumnFamilies";
+    }

    const std::map<uint32_t, std::vector<std::string>>& GetColumnFamilyKeys() {
      return cf_wal_keys_;
@@ -1036,19 +1038,18 @@ TEST_F(DBTest2, WalFilterTestWithColumnFamilies) {
  ASSERT_TRUE(index == keys_cf.size());
 }

-// Temporarily disable it because the test is flaky.
-TEST_F(DBTest2, DISABLED_PresetCompressionDict) {
-  // Verifies that compression ratio improves when dictionary is enabled, and
-  // improves even further when the dictionary is trained by ZSTD.
+TEST_F(DBTest2, PresetCompressionDict) {
  const size_t kBlockSizeBytes = 4 << 10;
  const size_t kL0FileBytes = 128 << 10;
  const size_t kApproxPerBlockOverheadBytes = 50;
  const int kNumL0Files = 5;
+  const int kZstdTrainFactor = 16;

  Options options;
  options.env = CurrentOptions().env; // Make sure to use any custom env that the test is configured with.
  options.allow_concurrent_memtable_write = false;
  options.arena_block_size = kBlockSizeBytes;
+  options.compaction_style = kCompactionStyleUniversal;
  options.create_if_missing = true;
  options.disable_auto_compactions = true;
  options.level0_file_num_compaction_trigger = kNumL0Files;
@@ -1090,15 +1091,16 @@ TEST_F(DBTest2, DISABLED_PresetCompressionDict) {
          options.compression_opts.zstd_max_train_bytes = 0;
          break;
        case 1:
-          options.compression_opts.max_dict_bytes = 4 * kBlockSizeBytes;
+          options.compression_opts.max_dict_bytes = kBlockSizeBytes;
          options.compression_opts.zstd_max_train_bytes = 0;
          break;
        case 2:
          if (compression_type != kZSTD) {
            continue;
          }
-          options.compression_opts.max_dict_bytes = 4 * kBlockSizeBytes;
-          options.compression_opts.zstd_max_train_bytes = kL0FileBytes;
+          options.compression_opts.max_dict_bytes = kBlockSizeBytes;
+          options.compression_opts.zstd_max_train_bytes =
+              kZstdTrainFactor * kBlockSizeBytes;
          break;
        default:
          assert(false);
@@ -1108,24 +1110,20 @@ TEST_F(DBTest2, DISABLED_PresetCompressionDict) {
      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
      CreateAndReopenWithCF({"pikachu"}, options);
      Random rnd(301);
-      std::string seq_datas[10];
-      for (int j = 0; j < 10; ++j) {
-        seq_datas[j] =
-            RandomString(&rnd, kBlockSizeBytes - kApproxPerBlockOverheadBytes);
-      }
+      std::string seq_data =
+          RandomString(&rnd, kBlockSizeBytes - kApproxPerBlockOverheadBytes);

      ASSERT_EQ(0, NumTableFilesAtLevel(0, 1));
      for (int j = 0; j < kNumL0Files; ++j) {
        for (size_t k = 0; k < kL0FileBytes / kBlockSizeBytes + 1; ++k) {
-          auto key_num = j * (kL0FileBytes / kBlockSizeBytes) + k;
-          ASSERT_OK(Put(1, Key(static_cast<int>(key_num)),
-                        seq_datas[(key_num / 10) % 10]));
+          ASSERT_OK(Put(1, Key(static_cast<int>(
+                               j * (kL0FileBytes / kBlockSizeBytes) + k)),
+                        seq_data));
        }
        dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
        ASSERT_EQ(j + 1, NumTableFilesAtLevel(0, 1));
      }
-      dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1],
-                                  true /* disallow_trivial_move */);
+      db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
      ASSERT_EQ(0, NumTableFilesAtLevel(0, 1));
      ASSERT_GT(NumTableFilesAtLevel(1, 1), 0);

@@ -1140,7 +1138,7 @@ TEST_F(DBTest2, DISABLED_PresetCompressionDict) {

      for (size_t j = 0; j < kNumL0Files * (kL0FileBytes / kBlockSizeBytes);
           j++) {
-        ASSERT_EQ(seq_datas[(j / 10) % 10], Get(1, Key(static_cast<int>(j))));
+        ASSERT_EQ(seq_data, Get(1, Key(static_cast<int>(j))));
      }
      if (i) {
        ASSERT_GT(prev_out_bytes, out_bytes);
@@ -1151,70 +1149,6 @@ TEST_F(DBTest2, DISABLED_PresetCompressionDict) {
  }
 }

-TEST_F(DBTest2, PresetCompressionDictLocality) {
-  if (!ZSTD_Supported()) {
-    return;
-  }
-  // Verifies that compression dictionary is generated from local data. The
-  // verification simply checks all output SSTs have different compression
-  // dictionaries. We do not verify effectiveness as that'd likely be flaky in
-  // the future.
-  const int kNumEntriesPerFile = 1 << 10;  // 1KB
-  const int kNumBytesPerEntry = 1 << 10;   // 1KB
-  const int kNumFiles = 4;
-  Options options = CurrentOptions();
-  options.compression = kZSTD;
-  options.compression_opts.max_dict_bytes = 1 << 14;        // 16KB
-  options.compression_opts.zstd_max_train_bytes = 1 << 18;  // 256KB
-  options.statistics = rocksdb::CreateDBStatistics();
-  options.target_file_size_base = kNumEntriesPerFile * kNumBytesPerEntry;
-  BlockBasedTableOptions table_options;
-  table_options.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  Reopen(options);
-
-  Random rnd(301);
-  for (int i = 0; i < kNumFiles; ++i) {
-    for (int j = 0; j < kNumEntriesPerFile; ++j) {
-      ASSERT_OK(Put(Key(i * kNumEntriesPerFile + j),
-                    RandomString(&rnd, kNumBytesPerEntry)));
-    }
-    ASSERT_OK(Flush());
-    MoveFilesToLevel(1);
-    ASSERT_EQ(NumTableFilesAtLevel(1), i + 1);
-  }
-
-  // Store all the dictionaries generated during a full compaction.
-  std::vector<std::string> compression_dicts;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTableBuilder::WriteCompressionDictBlock:RawDict",
-      [&](void* arg) {
-        compression_dicts.emplace_back(static_cast<Slice*>(arg)->ToString());
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  CompactRangeOptions compact_range_opts;
-  compact_range_opts.bottommost_level_compaction =
-      BottommostLevelCompaction::kForce;
-  ASSERT_OK(db_->CompactRange(compact_range_opts, nullptr, nullptr));
-
-  // Dictionary compression should not be so good as to compress four totally
-  // random files into one. If it does then there's probably something wrong
-  // with the test.
-  ASSERT_GT(NumTableFilesAtLevel(1), 1);
-
-  // Furthermore, there should be one compression dictionary generated per file.
-  // And they should all be different from each other.
-  ASSERT_EQ(NumTableFilesAtLevel(1),
-            static_cast<int>(compression_dicts.size()));
-  for (size_t i = 1; i < compression_dicts.size(); ++i) {
-    std::string& a = compression_dicts[i - 1];
-    std::string& b = compression_dicts[i];
-    size_t alen = a.size();
-    size_t blen = b.size();
-    ASSERT_TRUE(alen != blen || memcmp(a.data(), b.data(), alen) != 0);
-  }
-}
-
 class CompactionCompressionListener : public EventListener {
 public:
  explicit CompactionCompressionListener(Options* db_options)
@@ -1451,7 +1385,7 @@ class PinL0IndexAndFilterBlocksTest
      public testing::WithParamInterface<std::tuple<bool, bool>> {
 public:
  PinL0IndexAndFilterBlocksTest() : DBTestBase("/db_pin_l0_index_bloom_test") {}
-  void SetUp() override {
+  virtual void SetUp() override {
    infinite_max_files_ = std::get<0>(GetParam());
    disallow_preload_ = std::get<1>(GetParam());
  }
@@ -1754,7 +1688,7 @@ class MockPersistentCache : public PersistentCache {
        "GetUniqueIdFromFile:FS_IOC_GETVERSION", UniqueIdCallback);
  }

-  ~MockPersistentCache() override {}
+  virtual ~MockPersistentCache() {}

  PersistentCache::StatsType Stats() override {
    return PersistentCache::StatsType();
@@ -1805,7 +1739,7 @@ class MockPersistentCache : public PersistentCache {
 #ifdef OS_LINUX
 // Make sure that in CPU time perf context counters, Env::NowCPUNanos()
 // is used, rather than Env::CPUNanos();
-TEST_F(DBTest2, TestPerfContextGetCpuTime) {
+TEST_F(DBTest2, TestPerfContextCpuTime) {
  // force resizing table cache so table handle is not preloaded so that
  // we can measure find_table_nanos during Get().
  dbfull()->TEST_table_cache()->SetCapacity(0);
@@ -1836,91 +1770,6 @@ TEST_F(DBTest2, TestPerfContextGetCpuTime) {
  SetPerfLevel(PerfLevel::kDisable);
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
-
-TEST_F(DBTest2, TestPerfContextIterCpuTime) {
-  DestroyAndReopen(CurrentOptions());
-  // force resizing table cache so table handle is not preloaded so that
-  // we can measure find_table_nanos during iteration
-  dbfull()->TEST_table_cache()->SetCapacity(0);
-
-  const size_t kNumEntries = 10;
-  for (size_t i = 0; i < kNumEntries; ++i) {
-    ASSERT_OK(Put("k" + ToString(i), "v" + ToString(i)));
-  }
-  ASSERT_OK(Flush());
-  for (size_t i = 0; i < kNumEntries; ++i) {
-    ASSERT_EQ("v" + ToString(i), Get("k" + ToString(i)));
-  }
-  std::string last_key = "k" + ToString(kNumEntries - 1);
-  std::string last_value = "v" + ToString(kNumEntries - 1);
-  env_->now_cpu_count_.store(0);
-
-  // CPU timing is not enabled with kEnableTimeExceptForMutex
-  SetPerfLevel(PerfLevel::kEnableTimeExceptForMutex);
-  Iterator* iter = db_->NewIterator(ReadOptions());
-  iter->Seek("k0");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  iter->SeekForPrev(last_key);
-  ASSERT_TRUE(iter->Valid());
-  iter->SeekToLast();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(last_value, iter->value().ToString());
-  iter->SeekToFirst();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  ASSERT_EQ(0, get_perf_context()->iter_seek_cpu_nanos);
-  iter->Next();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v1", iter->value().ToString());
-  ASSERT_EQ(0, get_perf_context()->iter_next_cpu_nanos);
-  iter->Prev();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  ASSERT_EQ(0, get_perf_context()->iter_prev_cpu_nanos);
-  ASSERT_EQ(0, env_->now_cpu_count_.load());
-  delete iter;
-
-  uint64_t kDummyAddonTime = uint64_t{1000000000000};
-
-  // Add time to NowNanos() reading.
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "TableCache::FindTable:0",
-      [&](void* /*arg*/) { env_->addon_time_.fetch_add(kDummyAddonTime); });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  SetPerfLevel(PerfLevel::kEnableTimeAndCPUTimeExceptForMutex);
-  iter = db_->NewIterator(ReadOptions());
-  iter->Seek("k0");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  iter->SeekForPrev(last_key);
-  ASSERT_TRUE(iter->Valid());
-  iter->SeekToLast();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(last_value, iter->value().ToString());
-  iter->SeekToFirst();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  ASSERT_GT(get_perf_context()->iter_seek_cpu_nanos, 0);
-  ASSERT_LT(get_perf_context()->iter_seek_cpu_nanos, kDummyAddonTime);
-  iter->Next();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v1", iter->value().ToString());
-  ASSERT_GT(get_perf_context()->iter_next_cpu_nanos, 0);
-  ASSERT_LT(get_perf_context()->iter_next_cpu_nanos, kDummyAddonTime);
-  iter->Prev();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  ASSERT_GT(get_perf_context()->iter_prev_cpu_nanos, 0);
-  ASSERT_LT(get_perf_context()->iter_prev_cpu_nanos, kDummyAddonTime);
-  ASSERT_GE(env_->now_cpu_count_.load(), 12);
-  ASSERT_GT(get_perf_context()->find_table_nanos, kDummyAddonTime);
-
-  SetPerfLevel(PerfLevel::kDisable);
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  delete iter;
-}
 #endif  // OS_LINUX

 #ifndef OS_SOLARIS // GetUniqueIdFromFile is not implemented
@@ -2729,9 +2578,8 @@ TEST_F(DBTest2, ReadCallbackTest) {

  class TestReadCallback : public ReadCallback {
   public:
-    explicit TestReadCallback(SequenceNumber snapshot)
-        : ReadCallback(snapshot), snapshot_(snapshot) {}
-    bool IsVisibleFullCheck(SequenceNumber seq) override {
+    explicit TestReadCallback(SequenceNumber snapshot) : snapshot_(snapshot) {}
+    virtual bool IsVisible(SequenceNumber seq) override {
      return seq <= snapshot_;
    }

@@ -2875,8 +2723,6 @@ TEST_F(DBTest2, TraceAndReplay) {
  Random rnd(301);
  Iterator* single_iter = nullptr;

-  ASSERT_TRUE(db_->EndTrace().IsIOError());
-
  std::string trace_filename = dbname_ + "/rocksdb.trace";
  std::unique_ptr<TraceWriter> trace_writer;
  ASSERT_OK(NewFileTraceWriter(env_, env_opts, trace_filename, &trace_writer));
@@ -3036,248 +2882,6 @@ TEST_F(DBTest2, TraceWithLimit) {
  ASSERT_OK(DestroyDB(dbname2, options));
 }

-TEST_F(DBTest2, TraceWithSampling) {
-  Options options = CurrentOptions();
-  ReadOptions ro;
-  WriteOptions wo;
-  TraceOptions trace_opts;
-  EnvOptions env_opts;
-  CreateAndReopenWithCF({"pikachu"}, options);
-  Random rnd(301);
-
-  // test the trace file sampling options
-  trace_opts.sampling_frequency = 2;
-  std::string trace_filename = dbname_ + "/rocksdb.trace_sampling";
-  std::unique_ptr<TraceWriter> trace_writer;
-  ASSERT_OK(NewFileTraceWriter(env_, env_opts, trace_filename, &trace_writer));
-  ASSERT_OK(db_->StartTrace(trace_opts, std::move(trace_writer)));
-  ASSERT_OK(Put(0, "a", "1"));
-  ASSERT_OK(Put(0, "b", "2"));
-  ASSERT_OK(Put(0, "c", "3"));
-  ASSERT_OK(Put(0, "d", "4"));
-  ASSERT_OK(Put(0, "e", "5"));
-  ASSERT_OK(db_->EndTrace());
-
-  std::string dbname2 = test::TmpDir(env_) + "/db_replay_sampling";
-  std::string value;
-  ASSERT_OK(DestroyDB(dbname2, options));
-
-  // Using a different name than db2, to pacify infer's use-after-lifetime
-  // warnings (http://fbinfer.com).
-  DB* db2_init = nullptr;
-  options.create_if_missing = true;
-  ASSERT_OK(DB::Open(options, dbname2, &db2_init));
-  ColumnFamilyHandle* cf;
-  ASSERT_OK(
-      db2_init->CreateColumnFamily(ColumnFamilyOptions(), "pikachu", &cf));
-  delete cf;
-  delete db2_init;
-
-  DB* db2 = nullptr;
-  std::vector<ColumnFamilyDescriptor> column_families;
-  ColumnFamilyOptions cf_options;
-  column_families.push_back(ColumnFamilyDescriptor("default", cf_options));
-  column_families.push_back(
-      ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
-  std::vector<ColumnFamilyHandle*> handles;
-  ASSERT_OK(DB::Open(DBOptions(), dbname2, column_families, &handles, &db2));
-
-  env_->SleepForMicroseconds(100);
-  ASSERT_TRUE(db2->Get(ro, handles[0], "a", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "b", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "c", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "d", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "e", &value).IsNotFound());
-
-  std::unique_ptr<TraceReader> trace_reader;
-  ASSERT_OK(NewFileTraceReader(env_, env_opts, trace_filename, &trace_reader));
-  Replayer replayer(db2, handles_, std::move(trace_reader));
-  ASSERT_OK(replayer.Replay());
-
-  ASSERT_TRUE(db2->Get(ro, handles[0], "a", &value).IsNotFound());
-  ASSERT_FALSE(db2->Get(ro, handles[0], "b", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "c", &value).IsNotFound());
-  ASSERT_FALSE(db2->Get(ro, handles[0], "d", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "e", &value).IsNotFound());
-
-  for (auto handle : handles) {
-    delete handle;
-  }
-  delete db2;
-  ASSERT_OK(DestroyDB(dbname2, options));
-}
-
-TEST_F(DBTest2, TraceWithFilter) {
-  Options options = CurrentOptions();
-  options.merge_operator = MergeOperators::CreatePutOperator();
-  ReadOptions ro;
-  WriteOptions wo;
-  TraceOptions trace_opts;
-  EnvOptions env_opts;
-  CreateAndReopenWithCF({"pikachu"}, options);
-  Random rnd(301);
-  Iterator* single_iter = nullptr;
-
-  trace_opts.filter = TraceFilterType::kTraceFilterWrite;
-
-  std::string trace_filename = dbname_ + "/rocksdb.trace";
-  std::unique_ptr<TraceWriter> trace_writer;
-  ASSERT_OK(NewFileTraceWriter(env_, env_opts, trace_filename, &trace_writer));
-  ASSERT_OK(db_->StartTrace(trace_opts, std::move(trace_writer)));
-
-  ASSERT_OK(Put(0, "a", "1"));
-  ASSERT_OK(Merge(0, "b", "2"));
-  ASSERT_OK(Delete(0, "c"));
-  ASSERT_OK(SingleDelete(0, "d"));
-  ASSERT_OK(db_->DeleteRange(wo, dbfull()->DefaultColumnFamily(), "e", "f"));
-
-  WriteBatch batch;
-  ASSERT_OK(batch.Put("f", "11"));
-  ASSERT_OK(batch.Merge("g", "12"));
-  ASSERT_OK(batch.Delete("h"));
-  ASSERT_OK(batch.SingleDelete("i"));
-  ASSERT_OK(batch.DeleteRange("j", "k"));
-  ASSERT_OK(db_->Write(wo, &batch));
-
-  single_iter = db_->NewIterator(ro);
-  single_iter->Seek("f");
-  single_iter->SeekForPrev("g");
-  delete single_iter;
-
-  ASSERT_EQ("1", Get(0, "a"));
-  ASSERT_EQ("12", Get(0, "g"));
-
-  ASSERT_OK(Put(1, "foo", "bar"));
-  ASSERT_OK(Put(1, "rocksdb", "rocks"));
-  ASSERT_EQ("NOT_FOUND", Get(1, "leveldb"));
-
-  ASSERT_OK(db_->EndTrace());
-  // These should not get into the trace file as it is after EndTrace.
-  Put("hello", "world");
-  Merge("foo", "bar");
-
-  // Open another db, replay, and verify the data
-  std::string value;
-  std::string dbname2 = test::TmpDir(env_) + "/db_replay";
-  ASSERT_OK(DestroyDB(dbname2, options));
-
-  // Using a different name than db2, to pacify infer's use-after-lifetime
-  // warnings (http://fbinfer.com).
-  DB* db2_init = nullptr;
-  options.create_if_missing = true;
-  ASSERT_OK(DB::Open(options, dbname2, &db2_init));
-  ColumnFamilyHandle* cf;
-  ASSERT_OK(
-      db2_init->CreateColumnFamily(ColumnFamilyOptions(), "pikachu", &cf));
-  delete cf;
-  delete db2_init;
-
-  DB* db2 = nullptr;
-  std::vector<ColumnFamilyDescriptor> column_families;
-  ColumnFamilyOptions cf_options;
-  cf_options.merge_operator = MergeOperators::CreatePutOperator();
-  column_families.push_back(ColumnFamilyDescriptor("default", cf_options));
-  column_families.push_back(
-      ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
-  std::vector<ColumnFamilyHandle*> handles;
-  ASSERT_OK(DB::Open(DBOptions(), dbname2, column_families, &handles, &db2));
-
-  env_->SleepForMicroseconds(100);
-  // Verify that the keys don't already exist
-  ASSERT_TRUE(db2->Get(ro, handles[0], "a", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "g", &value).IsNotFound());
-
-  std::unique_ptr<TraceReader> trace_reader;
-  ASSERT_OK(NewFileTraceReader(env_, env_opts, trace_filename, &trace_reader));
-  Replayer replayer(db2, handles_, std::move(trace_reader));
-  ASSERT_OK(replayer.Replay());
-
-  // All the key-values should not present since we filter out the WRITE ops.
-  ASSERT_TRUE(db2->Get(ro, handles[0], "a", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "g", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "hello", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "world", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "foo", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "rocksdb", &value).IsNotFound());
-
-  for (auto handle : handles) {
-    delete handle;
-  }
-  delete db2;
-  ASSERT_OK(DestroyDB(dbname2, options));
-
-  // Set up a new db.
-  std::string dbname3 = test::TmpDir(env_) + "/db_not_trace_read";
-  ASSERT_OK(DestroyDB(dbname3, options));
-
-  DB* db3_init = nullptr;
-  options.create_if_missing = true;
-  ColumnFamilyHandle* cf3;
-  ASSERT_OK(DB::Open(options, dbname3, &db3_init));
-  ASSERT_OK(
-      db3_init->CreateColumnFamily(ColumnFamilyOptions(), "pikachu", &cf3));
-  delete cf3;
-  delete db3_init;
-
-  column_families.clear();
-  column_families.push_back(ColumnFamilyDescriptor("default", cf_options));
-  column_families.push_back(
-      ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
-  handles.clear();
-
-  DB* db3 =  nullptr;
-  ASSERT_OK(DB::Open(DBOptions(), dbname3, column_families, &handles, &db3));
-
-  env_->SleepForMicroseconds(100);
-  // Verify that the keys don't already exist
-  ASSERT_TRUE(db3->Get(ro, handles[0], "a", &value).IsNotFound());
-  ASSERT_TRUE(db3->Get(ro, handles[0], "g", &value).IsNotFound());
-
-  //The tracer will not record the READ ops.
-  trace_opts.filter = TraceFilterType::kTraceFilterGet;
-  std::string trace_filename3 = dbname_ + "/rocksdb.trace_3";
-  std::unique_ptr<TraceWriter> trace_writer3;
-  ASSERT_OK(
-    NewFileTraceWriter(env_, env_opts, trace_filename3, &trace_writer3));
-  ASSERT_OK(db3->StartTrace(trace_opts, std::move(trace_writer3)));
-
-  ASSERT_OK(db3->Put(wo, handles[0], "a", "1"));
-  ASSERT_OK(db3->Merge(wo, handles[0], "b", "2"));
-  ASSERT_OK(db3->Delete(wo, handles[0], "c"));
-  ASSERT_OK(db3->SingleDelete(wo, handles[0], "d"));
-
-  ASSERT_OK(db3->Get(ro, handles[0], "a", &value));
-  ASSERT_EQ(value, "1");
-  ASSERT_TRUE(db3->Get(ro, handles[0], "c", &value).IsNotFound());
-
-  ASSERT_OK(db3->EndTrace());
-
-  for (auto handle : handles) {
-    delete handle;
-  }
-  delete db3;
-  ASSERT_OK(DestroyDB(dbname3, options));
-
-  std::unique_ptr<TraceReader> trace_reader3;
-  ASSERT_OK(
-    NewFileTraceReader(env_, env_opts, trace_filename3, &trace_reader3));
-
-  // Count the number of records in the trace file;
-  int count = 0;
-  std::string data;
-  Status s;
-  while (true) {
-    s = trace_reader3->Read(&data);
-    if (!s.ok()) {
-      break;
-    }
-    count += 1;
-  }
-  // We also need to count the header and footer
-  // 4 WRITE + HEADER + FOOTER = 6
-  ASSERT_EQ(count, 6);
-}
-
 #endif  // ROCKSDB_LITE

 TEST_F(DBTest2, PinnableSliceAndMmapReads) {
@@ -3661,48 +3265,6 @@ TEST_F(DBTest2, MultiDBParallelOpenTest) {
 }
 #endif  // OS_WIN

-namespace {
-class DummyOldStats : public Statistics {
- public:
-  uint64_t getTickerCount(uint32_t /*ticker_type*/) const override { return 0; }
-  void recordTick(uint32_t /* ticker_type */, uint64_t /* count */) override {
-    num_rt++;
-  }
-  void setTickerCount(uint32_t /*ticker_type*/, uint64_t /*count*/) override {}
-  uint64_t getAndResetTickerCount(uint32_t /*ticker_type*/) override {
-    return 0;
-  }
-  void measureTime(uint32_t /*histogram_type*/, uint64_t /*count*/) override {
-    num_mt++;
-  }
-  void histogramData(uint32_t /*histogram_type*/,
-                     rocksdb::HistogramData* const /*data*/) const override {}
-  std::string getHistogramString(uint32_t /*type*/) const override {
-    return "";
-  }
-  bool HistEnabledForType(uint32_t /*type*/) const override { return false; }
-  std::string ToString() const override { return ""; }
-  int num_rt = 0;
-  int num_mt = 0;
-};
-}  // namespace
-
-TEST_F(DBTest2, OldStatsInterface) {
-  DummyOldStats* dos = new DummyOldStats();
-  std::shared_ptr<Statistics> stats(dos);
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = stats;
-  Reopen(options);
-
-  Put("foo", "bar");
-  ASSERT_EQ("bar", Get("foo"));
-  ASSERT_OK(Flush());
-  ASSERT_EQ("bar", Get("foo"));
-
-  ASSERT_GT(dos->num_rt, 0);
-  ASSERT_GT(dos->num_mt, 0);
-}
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -101,18 +101,18 @@ DBTestBase::~DBTestBase() {
 bool DBTestBase::ShouldSkipOptions(int option_config, int skip_mask) {
 #ifdef ROCKSDB_LITE
    // These options are not supported in ROCKSDB_LITE
-    if (option_config == kHashSkipList ||
-        option_config == kPlainTableFirstBytePrefix ||
-        option_config == kPlainTableCappedPrefix ||
-        option_config == kPlainTableCappedPrefixNonMmap ||
-        option_config == kPlainTableAllBytesPrefix ||
-        option_config == kVectorRep || option_config == kHashLinkList ||
-        option_config == kUniversalCompaction ||
-        option_config == kUniversalCompactionMultiLevel ||
-        option_config == kUniversalSubcompactions ||
-        option_config == kFIFOCompaction ||
-        option_config == kConcurrentSkipList) {
-      return true;
+  if (option_config == kHashSkipList ||
+      option_config == kPlainTableFirstBytePrefix ||
+      option_config == kPlainTableCappedPrefix ||
+      option_config == kPlainTableCappedPrefixNonMmap ||
+      option_config == kPlainTableAllBytesPrefix ||
+      option_config == kVectorRep || option_config == kHashLinkList ||
+      option_config == kHashCuckoo || option_config == kUniversalCompaction ||
+      option_config == kUniversalCompactionMultiLevel ||
+      option_config == kUniversalSubcompactions ||
+      option_config == kFIFOCompaction ||
+      option_config == kConcurrentSkipList) {
+    return true;
    }
 #endif

@@ -141,6 +141,9 @@ bool DBTestBase::ShouldSkipOptions(int option_config, int skip_mask) {
         option_config == kBlockBasedTableWithWholeKeyHashIndex)) {
      return true;
    }
+    if ((skip_mask & kSkipHashCuckoo) && (option_config == kHashCuckoo)) {
+      return true;
+    }
    if ((skip_mask & kSkipFIFOCompaction) && option_config == kFIFOCompaction) {
      return true;
    }
@@ -380,6 +383,11 @@ Options DBTestBase::GetOptions(
          NewHashLinkListRepFactory(4, 0, 3, true, 4));
      options.allow_concurrent_memtable_write = false;
      break;
+    case kHashCuckoo:
+      options.memtable_factory.reset(
+          NewHashCuckooRepFactory(options.write_buffer_size));
+      options.allow_concurrent_memtable_write = false;
+      break;
      case kDirectIO: {
        options.use_direct_reads = true;
        options.use_direct_io_for_flush_and_compaction = true;
@@ -652,28 +652,29 @@ class DBTestBase : public testing::Test {
    kPlainTableAllBytesPrefix = 6,
    kVectorRep = 7,
    kHashLinkList = 8,
-    kMergePut = 9,
-    kFilter = 10,
-    kFullFilterWithNewTableReaderForCompactions = 11,
-    kUncompressed = 12,
-    kNumLevel_3 = 13,
-    kDBLogDir = 14,
-    kWalDirAndMmapReads = 15,
-    kManifestFileSize = 16,
-    kPerfOptions = 17,
-    kHashSkipList = 18,
-    kUniversalCompaction = 19,
-    kUniversalCompactionMultiLevel = 20,
-    kCompressedBlockCache = 21,
-    kInfiniteMaxOpenFiles = 22,
-    kxxHashChecksum = 23,
-    kFIFOCompaction = 24,
-    kOptimizeFiltersForHits = 25,
-    kRowCache = 26,
-    kRecycleLogFiles = 27,
-    kConcurrentSkipList = 28,
-    kPipelinedWrite = 29,
-    kConcurrentWALWrites = 30,
+    kHashCuckoo = 9,
+    kMergePut = 10,
+    kFilter = 11,
+    kFullFilterWithNewTableReaderForCompactions = 12,
+    kUncompressed = 13,
+    kNumLevel_3 = 14,
+    kDBLogDir = 15,
+    kWalDirAndMmapReads = 16,
+    kManifestFileSize = 17,
+    kPerfOptions = 18,
+    kHashSkipList = 19,
+    kUniversalCompaction = 20,
+    kUniversalCompactionMultiLevel = 21,
+    kCompressedBlockCache = 22,
+    kInfiniteMaxOpenFiles = 23,
+    kxxHashChecksum = 24,
+    kFIFOCompaction = 25,
+    kOptimizeFiltersForHits = 26,
+    kRowCache = 27,
+    kRecycleLogFiles = 28,
+    kConcurrentSkipList = 29,
+    kPipelinedWrite = 30,
+    kConcurrentWALWrites = 31,
    kDirectIO,
    kLevelSubcompactions,
    kBlockBasedTableWithIndexRestartInterval,
@@ -709,6 +710,7 @@ class DBTestBase : public testing::Test {
    kSkipPlainTable = 8,
    kSkipHashIndex = 16,
    kSkipNoSeekToLast = 32,
+    kSkipHashCuckoo = 64,
    kSkipFIFOCompaction = 128,
    kSkipMmapReads = 256,
  };
@@ -27,7 +27,7 @@ class DBTestUniversalCompactionBase
 public:
  explicit DBTestUniversalCompactionBase(
      const std::string& path) : DBTestBase(path) {}
-  void SetUp() override {
+  virtual void SetUp() override {
    num_levels_ = std::get<0>(GetParam());
    exclusive_manual_compaction_ = std::get<1>(GetParam());
  }
@@ -63,13 +63,13 @@ void VerifyCompactionResult(

 class KeepFilter : public CompactionFilter {
 public:
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*value*/, std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    return false;
  }

-  const char* Name() const override { return "KeepFilter"; }
+  virtual const char* Name() const override { return "KeepFilter"; }
 };

 class KeepFilterFactory : public CompactionFilterFactory {
@@ -77,7 +77,7 @@ class KeepFilterFactory : public CompactionFilterFactory {
  explicit KeepFilterFactory(bool check_context = false)
      : check_context_(check_context) {}

-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    if (check_context_) {
      EXPECT_EQ(expect_full_compaction_.load(), context.is_full_compaction);
@@ -86,7 +86,7 @@ class KeepFilterFactory : public CompactionFilterFactory {
    return std::unique_ptr<CompactionFilter>(new KeepFilter());
  }

-  const char* Name() const override { return "KeepFilterFactory"; }
+  virtual const char* Name() const override { return "KeepFilterFactory"; }
  bool check_context_;
  std::atomic_bool expect_full_compaction_;
  std::atomic_bool expect_manual_compaction_;
@@ -95,14 +95,14 @@ class KeepFilterFactory : public CompactionFilterFactory {
 class DelayFilter : public CompactionFilter {
 public:
  explicit DelayFilter(DBTestBase* d) : db_test(d) {}
-  bool Filter(int /*level*/, const Slice& /*key*/, const Slice& /*value*/,
-              std::string* /*new_value*/,
-              bool* /*value_changed*/) const override {
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*value*/, std::string* /*new_value*/,
+                      bool* /*value_changed*/) const override {
    db_test->env_->addon_time_.fetch_add(1000);
    return true;
  }

-  const char* Name() const override { return "DelayFilter"; }
+  virtual const char* Name() const override { return "DelayFilter"; }

 private:
  DBTestBase* db_test;
@@ -111,12 +111,12 @@ class DelayFilter : public CompactionFilter {
 class DelayFilterFactory : public CompactionFilterFactory {
 public:
  explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {}
-  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& /*context*/) override {
    return std::unique_ptr<CompactionFilter>(new DelayFilter(db_test));
  }

-  const char* Name() const override { return "DelayFilterFactory"; }
+  virtual const char* Name() const override { return "DelayFilterFactory"; }

 private:
  DBTestBase* db_test;
@@ -140,51 +140,6 @@ TEST_P(DBWriteTest, IOErrorOnWALWriteTriggersReadOnlyMode) {
  Close();
 }

-TEST_P(DBWriteTest, IOErrorOnSwitchMemtable) {
-  Random rnd(301);
-  std::unique_ptr<FaultInjectionTestEnv> mock_env(
-      new FaultInjectionTestEnv(Env::Default()));
-  Options options = GetOptions();
-  options.env = mock_env.get();
-  options.writable_file_max_buffer_size = 4 * 1024 * 1024;
-  options.write_buffer_size = 3 * 512 * 1024;
-  options.wal_bytes_per_sync = 256 * 1024;
-  options.manual_wal_flush = true;
-  Reopen(options);
-  mock_env->SetFilesystemActive(false, Status::IOError("Not active"));
-  Status s;
-  for (int i = 0; i < 4 * 512; ++i) {
-    s = Put(Key(i), RandomString(&rnd, 1024));
-    if (!s.ok()) {
-      break;
-    }
-  }
-  ASSERT_EQ(s.severity(), Status::Severity::kFatalError);
-
-  mock_env->SetFilesystemActive(true);
-  // Close before mock_env destruct.
-  Close();
-}
-
-// Test that db->LockWAL() flushes the WAL after locking.
-TEST_P(DBWriteTest, LockWalInEffect) {
-  Options options = GetOptions();
-  Reopen(options);
-  // try the 1st WAL created during open
-  ASSERT_OK(Put("key" + ToString(0), "value"));
-  ASSERT_TRUE(options.manual_wal_flush != dbfull()->TEST_WALBufferIsEmpty());
-  ASSERT_OK(dbfull()->LockWAL());
-  ASSERT_TRUE(dbfull()->TEST_WALBufferIsEmpty(false));
-  ASSERT_OK(dbfull()->UnlockWAL());
-  // try the 2nd wal created during SwitchWAL
-  dbfull()->TEST_SwitchWAL();
-  ASSERT_OK(Put("key" + ToString(0), "value"));
-  ASSERT_TRUE(options.manual_wal_flush != dbfull()->TEST_WALBufferIsEmpty());
-  ASSERT_OK(dbfull()->LockWAL());
-  ASSERT_TRUE(dbfull()->TEST_WALBufferIsEmpty(false));
-  ASSERT_OK(dbfull()->UnlockWAL());
-}
-
 INSTANTIATE_TEST_CASE_P(DBWriteTestInstance, DBWriteTest,
                        testing::Values(DBTestBase::kDefault,
                                        DBTestBase::kConcurrentWALWrites,
@@ -106,7 +106,9 @@ std::string InternalKey::DebugString(bool hex) const {
  return result;
 }

-const char* InternalKeyComparator::Name() const { return name_.c_str(); }
+const char* InternalKeyComparator::Name() const {
+  return name_.c_str();
+}

 int InternalKeyComparator::Compare(const ParsedInternalKey& a,
                                   const ParsedInternalKey& b) const {
@@ -114,7 +116,8 @@ int InternalKeyComparator::Compare(const ParsedInternalKey& a,
  //    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(a.user_key, b.user_key);
+  int r = user_comparator_->Compare(a.user_key, b.user_key);
+  PERF_COUNTER_ADD(user_key_comparison_count, 1);
  if (r == 0) {
    if (a.sequence > b.sequence) {
      r = -1;
@@ -129,19 +132,19 @@ int InternalKeyComparator::Compare(const ParsedInternalKey& a,
  return r;
 }

-void InternalKeyComparator::FindShortestSeparator(std::string* start,
-                                                  const Slice& limit) const {
+void InternalKeyComparator::FindShortestSeparator(
+      std::string* start,
+      const Slice& limit) const {
  // Attempt to shorten the user portion of the key
  Slice user_start = ExtractUserKey(*start);
  Slice user_limit = ExtractUserKey(limit);
  std::string tmp(user_start.data(), user_start.size());
-  user_comparator_.FindShortestSeparator(&tmp, user_limit);
+  user_comparator_->FindShortestSeparator(&tmp, user_limit);
  if (tmp.size() <= user_start.size() &&
-      user_comparator_.Compare(user_start, tmp) < 0) {
+      user_comparator_->Compare(user_start, tmp) < 0) {
    // User key has become shorter physically, but larger logically.
    // Tack on the earliest possible number to the shortened user key.
-    PutFixed64(&tmp,
-               PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
+    PutFixed64(&tmp, PackSequenceAndType(kMaxSequenceNumber,kValueTypeForSeek));
    assert(this->Compare(*start, tmp) < 0);
    assert(this->Compare(tmp, limit) < 0);
    start->swap(tmp);
@@ -151,13 +154,12 @@ void InternalKeyComparator::FindShortestSeparator(std::string* start,
 void InternalKeyComparator::FindShortSuccessor(std::string* key) const {
  Slice user_key = ExtractUserKey(*key);
  std::string tmp(user_key.data(), user_key.size());
-  user_comparator_.FindShortSuccessor(&tmp);
+  user_comparator_->FindShortSuccessor(&tmp);
  if (tmp.size() <= user_key.size() &&
-      user_comparator_.Compare(user_key, tmp) < 0) {
+      user_comparator_->Compare(user_key, tmp) < 0) {
    // User key has become shorter physically, but larger logically.
    // Tack on the earliest possible number to the shortened user key.
-    PutFixed64(&tmp,
-               PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
+    PutFixed64(&tmp, PackSequenceAndType(kMaxSequenceNumber,kValueTypeForSeek));
    assert(this->Compare(*key, tmp) < 0);
    key->swap(tmp);
  }
@@ -21,7 +21,6 @@
 #include "rocksdb/types.h"
 #include "util/coding.h"
 #include "util/logging.h"
-#include "util/user_comparator_wrapper.h"

 namespace rocksdb {

@@ -81,7 +80,8 @@ inline bool IsExtendedValueType(ValueType t) {

 // We leave eight bits empty at the bottom so a type and sequence#
 // can be packed together into 64-bits.
-static const SequenceNumber kMaxSequenceNumber = ((0x1ull << 56) - 1);
+static const SequenceNumber kMaxSequenceNumber =
+    ((0x1ull << 56) - 1);

 static const SequenceNumber kDisableGlobalSequenceNumber = port::kMaxUint64;

@@ -92,9 +92,9 @@ struct ParsedInternalKey {

  ParsedInternalKey()
      : sequence(kMaxSequenceNumber)  // Make code analyzer happy
-  {}  // Intentionally left uninitialized (for speed)
+        {} // Intentionally left uninitialized (for speed)
  ParsedInternalKey(const Slice& u, const SequenceNumber& seq, ValueType t)
-      : user_key(u), sequence(seq), type(t) {}
+      : user_key(u), sequence(seq), type(t) { }
  std::string DebugString(bool hex = false) const;

  void clear() {
@@ -160,14 +160,13 @@ class InternalKeyComparator
 #endif
    : public Comparator {
 private:
-  UserComparatorWrapper user_comparator_;
+  const Comparator* user_comparator_;
  std::string name_;
-
 public:
-  explicit InternalKeyComparator(const Comparator* c)
-      : user_comparator_(c),
-        name_("rocksdb.InternalKeyComparator:" +
-              std::string(user_comparator_.Name())) {}
+  explicit InternalKeyComparator(const Comparator* c) : user_comparator_(c),
+    name_("rocksdb.InternalKeyComparator:" +
+          std::string(user_comparator_->Name())) {
+  }
  virtual ~InternalKeyComparator() {}

  virtual const char* Name() const override;
@@ -178,14 +177,12 @@ class InternalKeyComparator
                                     const Slice& limit) const override;
  virtual void FindShortSuccessor(std::string* key) const override;

-  const Comparator* user_comparator() const {
-    return user_comparator_.user_comparator();
-  }
+  const Comparator* user_comparator() const { return user_comparator_; }

  int Compare(const InternalKey& a, const InternalKey& b) const;
  int Compare(const ParsedInternalKey& a, const ParsedInternalKey& b) const;
  virtual const Comparator* GetRootComparator() const override {
-    return user_comparator_.GetRootComparator();
+    return user_comparator_->GetRootComparator();
  }
 };

@@ -195,9 +192,8 @@ class InternalKeyComparator
 class InternalKey {
 private:
  std::string rep_;
-
 public:
-  InternalKey() {}  // Leave rep_ as empty to indicate it is invalid
+  InternalKey() { }   // Leave rep_ as empty to indicate it is invalid
  InternalKey(const Slice& _user_key, SequenceNumber s, ValueType t) {
    AppendInternalKey(&rep_, ParsedInternalKey(_user_key, s, t));
  }
@@ -254,8 +250,8 @@ class InternalKey {
  std::string DebugString(bool hex = false) const;
 };

-inline int InternalKeyComparator::Compare(const InternalKey& a,
-                                          const InternalKey& b) const {
+inline int InternalKeyComparator::Compare(
+    const InternalKey& a, const InternalKey& b) const {
  return Compare(a.Encode(), b.Encode());
 }

@@ -292,6 +288,7 @@ inline uint64_t GetInternalKeySeqno(const Slice& internal_key) {
  return num >> 8;
 }

+
 // A helper class useful for DBImpl::Get()
 class LookupKey {
 public:
@@ -327,7 +324,7 @@ class LookupKey {
  const char* start_;
  const char* kstart_;
  const char* end_;
-  char space_[200];  // Avoid allocation for short keys
+  char space_[200];      // Avoid allocation for short keys

  // No copying allowed
  LookupKey(const LookupKey&);
@@ -342,9 +339,9 @@ class IterKey {
 public:
  IterKey()
      : buf_(space_),
+        buf_size_(sizeof(space_)),
        key_(buf_),
        key_size_(0),
-        buf_size_(sizeof(space_)),
        is_user_key_(true) {}

  ~IterKey() { ResetBuffer(); }
@@ -499,9 +496,9 @@ class IterKey {

 private:
  char* buf_;
+  size_t buf_size_;
  const char* key_;
  size_t key_size_;
-  size_t buf_size_;
  char space_[32];  // Avoid allocation for short keys
  bool is_user_key_;

@@ -636,13 +633,14 @@ struct RangeTombstone {
  }
 };

-inline int InternalKeyComparator::Compare(const Slice& akey,
-                                          const Slice& bkey) const {
+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));
+  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);
@@ -655,12 +653,14 @@ inline int InternalKeyComparator::Compare(const Slice& akey,
  return r;
 }

-inline int InternalKeyComparator::CompareKeySeq(const Slice& akey,
-                                                const Slice& bkey) const {
+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));
+  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;
@@ -71,9 +71,7 @@ class DeleteFileTest : public testing::Test {
    }
    db_ = nullptr;
    options_.create_if_missing = create;
-    Status s = DB::Open(options_, dbname_, &db_);
-    assert(db_);
-    return s;
+    return DB::Open(options_, dbname_, &db_);
  }

  void CloseDB() {
@@ -243,7 +241,7 @@ TEST_F(DeleteFileTest, PurgeObsoleteFilesTest) {
  CloseDB();
 }

-TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
+TEST_F(DeleteFileTest, BackgroundPurgeTest) {
  std::string first("0"), last("999999");
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
@@ -281,53 +279,6 @@ TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
  CloseDB();
 }

-TEST_F(DeleteFileTest, BackgroundPurgeCFDropTest) {
-  auto do_test = [&](bool bg_purge) {
-    ColumnFamilyOptions co;
-    WriteOptions wo;
-    FlushOptions fo;
-    ColumnFamilyHandle* cfh = nullptr;
-
-    ASSERT_OK(db_->CreateColumnFamily(co, "dropme", &cfh));
-
-    ASSERT_OK(db_->Put(wo, cfh, "pika", "chu"));
-    ASSERT_OK(db_->Flush(fo, cfh));
-    // Expect 1 sst file.
-    CheckFileTypeCounts(dbname_, 0, 1, 1);
-
-    ASSERT_OK(db_->DropColumnFamily(cfh));
-    // Still 1 file, it won't be deleted while ColumnFamilyHandle is alive.
-    CheckFileTypeCounts(dbname_, 0, 1, 1);
-
-    delete cfh;
-    test::SleepingBackgroundTask sleeping_task_after;
-    env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask,
-                   &sleeping_task_after, Env::Priority::HIGH);
-    // If background purge is enabled, the file should still be there.
-    CheckFileTypeCounts(dbname_, 0, bg_purge ? 1 : 0, 1);
-
-    // Execute background purges.
-    sleeping_task_after.WakeUp();
-    sleeping_task_after.WaitUntilDone();
-    // The file should have been deleted.
-    CheckFileTypeCounts(dbname_, 0, 0, 1);
-  };
-
-  {
-    SCOPED_TRACE("avoid_unnecessary_blocking_io = false");
-    do_test(false);
-  }
-
-  options_.avoid_unnecessary_blocking_io = true;
-  ASSERT_OK(ReopenDB(false));
-  {
-    SCOPED_TRACE("avoid_unnecessary_blocking_io = true");
-    do_test(true);
-  }
-
-  CloseDB();
-}
-
 // This test is to reproduce a bug that read invalid ReadOption in iterator
 // cleanup function
 TEST_F(DeleteFileTest, BackgroundPurgeCopyOptions) {
@@ -134,9 +134,7 @@ class ExternalSSTFileBasicTest
        write_global_seqno, verify_checksums_before_ingest, true_data);
  }

-  ~ExternalSSTFileBasicTest() override {
-    test::DestroyDir(env_, sst_files_dir_);
-  }
+  ~ExternalSSTFileBasicTest() { test::DestroyDir(env_, sst_files_dir_); }

 protected:
  std::string sst_files_dir_;
@@ -861,66 +859,6 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithFirstByteTampered) {
  } while (ChangeOptionsForFileIngestionTest());
 }

-TEST_P(ExternalSSTFileBasicTest, IngestExternalFileWithCorruptedPropsBlock) {
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
-  if (!verify_checksums_before_ingest) {
-    return;
-  }
-  uint64_t props_block_offset = 0;
-  size_t props_block_size = 0;
-  const auto& get_props_block_offset = [&](void* arg) {
-    props_block_offset = *reinterpret_cast<uint64_t*>(arg);
-  };
-  const auto& get_props_block_size = [&](void* arg) {
-    props_block_size = *reinterpret_cast<uint64_t*>(arg);
-  };
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTableBuilder::WritePropertiesBlock:GetPropsBlockOffset",
-      get_props_block_offset);
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTableBuilder::WritePropertiesBlock:GetPropsBlockSize",
-      get_props_block_size);
-  SyncPoint::GetInstance()->EnableProcessing();
-  int file_id = 0;
-  Random64 rand(time(nullptr));
-  do {
-    std::string file_path = sst_files_dir_ + ToString(file_id++);
-    Options options = CurrentOptions();
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    Status s = sst_file_writer.Open(file_path);
-    ASSERT_OK(s);
-    for (int i = 0; i != 100; ++i) {
-      std::string key = Key(i);
-      std::string value = Key(i) + ToString(0);
-      ASSERT_OK(sst_file_writer.Put(key, value));
-    }
-    ASSERT_OK(sst_file_writer.Finish());
-
-    {
-      std::unique_ptr<RandomRWFile> rwfile;
-      ASSERT_OK(env_->NewRandomRWFile(file_path, &rwfile, EnvOptions()));
-      // Manually corrupt the file
-      ASSERT_GT(props_block_size, 8);
-      uint64_t offset =
-          props_block_offset + rand.Next() % (props_block_size - 8);
-      char scratch[8] = {0};
-      Slice buf;
-      ASSERT_OK(rwfile->Read(offset, sizeof(scratch), &buf, scratch));
-      scratch[0] ^= 0xff;  // flip one bit
-      ASSERT_OK(rwfile->Write(offset, buf));
-    }
-
-    // Ingest file.
-    IngestExternalFileOptions ifo;
-    ifo.write_global_seqno = std::get<0>(GetParam());
-    ifo.verify_checksums_before_ingest = true;
-    s = db_->IngestExternalFile({file_path}, ifo);
-    ASSERT_NOK(s);
-  } while (ChangeOptionsForFileIngestionTest());
-}
-
 INSTANTIATE_TEST_CASE_P(ExternalSSTFileBasicTest, ExternalSSTFileBasicTest,
                        testing::Values(std::make_tuple(true, true),
                                        std::make_tuple(true, false),
@@ -167,6 +167,7 @@ Status ExternalSstFileIngestionJob::Run() {
  assert(status.ok() && need_flush == false);
 #endif

+  bool consumed_seqno = false;
  bool force_global_seqno = false;

  if (ingestion_options_.snapshot_consistency && !db_snapshots_->empty()) {
@@ -196,7 +197,7 @@ Status ExternalSstFileIngestionJob::Run() {
    TEST_SYNC_POINT_CALLBACK("ExternalSstFileIngestionJob::Run",
                             &assigned_seqno);
    if (assigned_seqno == last_seqno + 1) {
-      consumed_seqno_ = true;
+      consumed_seqno = true;
    }
    if (!status.ok()) {
      return status;
@@ -206,6 +207,13 @@ Status ExternalSstFileIngestionJob::Run() {
                  f.largest_internal_key(), f.assigned_seqno, f.assigned_seqno,
                  false);
  }
+
+  if (consumed_seqno) {
+    versions_->SetLastAllocatedSequence(last_seqno + 1);
+    versions_->SetLastPublishedSequence(last_seqno + 1);
+    versions_->SetLastSequence(last_seqno + 1);
+  }
+
  return status;
 }

@@ -227,8 +235,7 @@ void ExternalSstFileIngestionJob::UpdateStats() {
      stats.bytes_moved = f.fd.GetFileSize();
    }
    stats.num_output_files = 1;
-    cfd_->internal_stats()->AddCompactionStats(f.picked_level,
-                                               Env::Priority::USER, stats);
+    cfd_->internal_stats()->AddCompactionStats(f.picked_level, stats);
    cfd_->internal_stats()->AddCFStats(InternalStats::BYTES_INGESTED_ADD_FILE,
                                       f.fd.GetFileSize());
    total_keys += f.num_entries;
@@ -262,7 +269,6 @@ void ExternalSstFileIngestionJob::Cleanup(const Status& status) {
                       f.internal_file_path.c_str(), s.ToString().c_str());
      }
    }
-    consumed_seqno_ = false;
  } else if (status.ok() && ingestion_options_.move_files) {
    // The files were moved and added successfully, remove original file links
    for (IngestedFileInfo& f : files_to_ingest_) {
@@ -85,8 +85,7 @@ class ExternalSstFileIngestionJob {
        env_options_(env_options),
        db_snapshots_(db_snapshots),
        ingestion_options_(ingestion_options),
-        job_start_time_(env_->NowMicros()),
-        consumed_seqno_(false) {}
+        job_start_time_(env_->NowMicros()) {}

  // Prepare the job by copying external files into the DB.
  Status Prepare(const std::vector<std::string>& external_files_paths,
@@ -119,9 +118,6 @@ class ExternalSstFileIngestionJob {
    return files_to_ingest_;
  }

-  // Whether to increment VersionSet's seqno after this job runs
-  bool ShouldIncrementLastSequence() const { return consumed_seqno_; }
-
 private:
  // Open the external file and populate `file_to_ingest` with all the
  // external information we need to ingest this file.
@@ -163,7 +159,6 @@ class ExternalSstFileIngestionJob {
  const IngestExternalFileOptions& ingestion_options_;
  VersionEdit edit_;
  uint64_t job_start_time_;
-  bool consumed_seqno_;
 };

 }  // namespace rocksdb
@@ -10,7 +10,6 @@
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/sst_file_writer.h"
-#include "util/fault_injection_test_env.h"
 #include "util/filename.h"
 #include "util/testutil.h"

@@ -30,61 +29,11 @@ class ExternalSSTFileTest
    env_->CreateDir(sst_files_dir_);
  }

-  Status GenerateOneExternalFile(
-      const Options& options, ColumnFamilyHandle* cfh,
-      std::vector<std::pair<std::string, std::string>>& data, int file_id,
-      bool sort_data, std::string* external_file_path,
-      std::map<std::string, std::string>* true_data) {
-    // Generate a file id if not provided
-    if (-1 == file_id) {
-      file_id = (++last_file_id_);
-    }
-    // Sort data if asked to do so
-    if (sort_data) {
-      std::sort(data.begin(), data.end(),
-                [&](const std::pair<std::string, std::string>& e1,
-                    const std::pair<std::string, std::string>& e2) {
-                  return options.comparator->Compare(e1.first, e2.first) < 0;
-                });
-      auto uniq_iter = std::unique(
-          data.begin(), data.end(),
-          [&](const std::pair<std::string, std::string>& e1,
-              const std::pair<std::string, std::string>& e2) {
-            return options.comparator->Compare(e1.first, e2.first) == 0;
-          });
-      data.resize(uniq_iter - data.begin());
-    }
-    std::string file_path = sst_files_dir_ + ToString(file_id);
-    SstFileWriter sst_file_writer(EnvOptions(), options, cfh);
-    Status s = sst_file_writer.Open(file_path);
-    if (!s.ok()) {
-      return s;
-    }
-    for (const auto& entry : data) {
-      s = sst_file_writer.Put(entry.first, entry.second);
-      if (!s.ok()) {
-        sst_file_writer.Finish();
-        return s;
-      }
-    }
-    s = sst_file_writer.Finish();
-    if (s.ok() && external_file_path != nullptr) {
-      *external_file_path = file_path;
-    }
-    if (s.ok() && nullptr != true_data) {
-      for (const auto& entry : data) {
-        true_data->insert({entry.first, entry.second});
-      }
-    }
-    return s;
-  }
-
  Status GenerateAndAddExternalFile(
      const Options options,
      std::vector<std::pair<std::string, std::string>> data, int file_id = -1,
      bool allow_global_seqno = false, bool write_global_seqno = false,
-      bool verify_checksums_before_ingest = true, bool ingest_behind = false,
-      bool sort_data = false,
+      bool verify_checksums_before_ingest = true, bool sort_data = false,
      std::map<std::string, std::string>* true_data = nullptr,
      ColumnFamilyHandle* cfh = nullptr) {
    // Generate a file id if not provided
@@ -129,7 +78,6 @@ class ExternalSSTFileTest
      ifo.allow_global_seqno = allow_global_seqno;
      ifo.write_global_seqno = allow_global_seqno ? write_global_seqno : false;
      ifo.verify_checksums_before_ingest = verify_checksums_before_ingest;
-      ifo.ingest_behind = ingest_behind;
      if (cfh) {
        s = db_->IngestExternalFile(cfh, {file_path}, ifo);
      } else {
@@ -146,38 +94,63 @@ class ExternalSSTFileTest
    return s;
  }

-  Status GenerateAndAddExternalFiles(
-      const Options& options,
-      const std::vector<ColumnFamilyHandle*>& column_families,
-      const std::vector<IngestExternalFileOptions>& ifos,
-      std::vector<std::vector<std::pair<std::string, std::string>>>& data,
-      int file_id, bool sort_data,
-      std::vector<std::map<std::string, std::string>>& true_data) {
-    if (-1 == file_id) {
-      file_id = (++last_file_id_);
+  Status GenerateAndAddExternalFileIngestBehind(
+      const Options options, const IngestExternalFileOptions ifo,
+      std::vector<std::pair<std::string, std::string>> data, int file_id = -1,
+      bool sort_data = false,
+      std::map<std::string, std::string>* true_data = nullptr,
+      ColumnFamilyHandle* cfh = nullptr) {
+    // Generate a file id if not provided
+    if (file_id == -1) {
+      file_id = last_file_id_ + 1;
+      last_file_id_++;
    }
-    // Generate external SST files, one for each column family
-    size_t num_cfs = column_families.size();
-    assert(ifos.size() == num_cfs);
-    assert(data.size() == num_cfs);
-    Status s;
-    std::vector<IngestExternalFileArg> args(num_cfs);
-    for (size_t i = 0; i != num_cfs; ++i) {
-      std::string external_file_path;
-      s = GenerateOneExternalFile(
-          options, column_families[i], data[i], file_id, sort_data,
-          &external_file_path,
-          true_data.size() == num_cfs ? &true_data[i] : nullptr);
+
+    // Sort data if asked to do so
+    if (sort_data) {
+      std::sort(data.begin(), data.end(),
+                [&](const std::pair<std::string, std::string>& e1,
+                    const std::pair<std::string, std::string>& e2) {
+                  return options.comparator->Compare(e1.first, e2.first) < 0;
+                });
+      auto uniq_iter = std::unique(
+          data.begin(), data.end(),
+          [&](const std::pair<std::string, std::string>& e1,
+              const std::pair<std::string, std::string>& e2) {
+            return options.comparator->Compare(e1.first, e2.first) == 0;
+          });
+      data.resize(uniq_iter - data.begin());
+    }
+    std::string file_path = sst_files_dir_ + ToString(file_id);
+    SstFileWriter sst_file_writer(EnvOptions(), options, cfh);
+
+    Status s = sst_file_writer.Open(file_path);
+    if (!s.ok()) {
+      return s;
+    }
+    for (auto& entry : data) {
+      s = sst_file_writer.Put(entry.first, entry.second);
      if (!s.ok()) {
+        sst_file_writer.Finish();
        return s;
      }
-      ++file_id;
-
-      args[i].column_family = column_families[i];
-      args[i].external_files.push_back(external_file_path);
-      args[i].options = ifos[i];
    }
-    s = db_->IngestExternalFiles(args);
+    s = sst_file_writer.Finish();
+
+    if (s.ok()) {
+      if (cfh) {
+        s = db_->IngestExternalFile(cfh, {file_path}, ifo);
+      } else {
+        s = db_->IngestExternalFile({file_path}, ifo);
+      }
+    }
+
+    if (s.ok() && true_data) {
+      for (auto& entry : data) {
+        (*true_data)[entry.first] = entry.second;
+      }
+    }
+
    return s;
  }

@@ -185,35 +158,31 @@ class ExternalSSTFileTest
      const Options options, std::vector<std::pair<int, std::string>> data,
      int file_id = -1, bool allow_global_seqno = false,
      bool write_global_seqno = false,
-      bool verify_checksums_before_ingest = true, bool ingest_behind = false,
-      bool sort_data = false,
+      bool verify_checksums_before_ingest = true, bool sort_data = false,
      std::map<std::string, std::string>* true_data = nullptr,
      ColumnFamilyHandle* cfh = nullptr) {
    std::vector<std::pair<std::string, std::string>> file_data;
    for (auto& entry : data) {
      file_data.emplace_back(Key(entry.first), entry.second);
    }
-    return GenerateAndAddExternalFile(options, file_data, file_id,
-                                      allow_global_seqno, write_global_seqno,
-                                      verify_checksums_before_ingest,
-                                      ingest_behind, sort_data, true_data, cfh);
+    return GenerateAndAddExternalFile(
+        options, file_data, file_id, allow_global_seqno, write_global_seqno,
+        verify_checksums_before_ingest, sort_data, true_data, cfh);
  }

  Status GenerateAndAddExternalFile(
      const Options options, std::vector<int> keys, int file_id = -1,
      bool allow_global_seqno = false, bool write_global_seqno = false,
-      bool verify_checksums_before_ingest = true, bool ingest_behind = false,
-      bool sort_data = false,
+      bool verify_checksums_before_ingest = true, bool sort_data = false,
      std::map<std::string, std::string>* true_data = nullptr,
      ColumnFamilyHandle* cfh = nullptr) {
    std::vector<std::pair<std::string, std::string>> file_data;
    for (auto& k : keys) {
      file_data.emplace_back(Key(k), Key(k) + ToString(file_id));
    }
-    return GenerateAndAddExternalFile(options, file_data, file_id,
-                                      allow_global_seqno, write_global_seqno,
-                                      verify_checksums_before_ingest,
-                                      ingest_behind, sort_data, true_data, cfh);
+    return GenerateAndAddExternalFile(
+        options, file_data, file_id, allow_global_seqno, write_global_seqno,
+        verify_checksums_before_ingest, sort_data, true_data, cfh);
  }

  Status DeprecatedAddFile(const std::vector<std::string>& files,
@@ -229,7 +198,7 @@ class ExternalSSTFileTest
    return db_->IngestExternalFile(files, opts);
  }

-  ~ExternalSSTFileTest() override { test::DestroyDir(env_, sst_files_dir_); }
+  ~ExternalSSTFileTest() { test::DestroyDir(env_, sst_files_dir_); }

 protected:
  int last_file_id_ = 0;
@@ -517,7 +486,7 @@ class SstFileWriterCollector : public TablePropertiesCollector {
    return Status::OK();
  }

-  UserCollectedProperties GetReadableProperties() const override {
+  virtual UserCollectedProperties GetReadableProperties() const override {
    return UserCollectedProperties{};
  }

@@ -531,7 +500,7 @@ class SstFileWriterCollectorFactory : public TablePropertiesCollectorFactory {
 public:
  explicit SstFileWriterCollectorFactory(std::string prefix)
      : prefix_(prefix), num_created_(0) {}
-  TablePropertiesCollector* CreateTablePropertiesCollector(
+  virtual TablePropertiesCollector* CreateTablePropertiesCollector(
      TablePropertiesCollectorFactory::Context /*context*/) override {
    num_created_++;
    return new SstFileWriterCollector(prefix_);
@@ -1192,12 +1161,12 @@ TEST_P(ExternalSSTFileTest, PickedLevel) {

  // File 0 will go to last level (L3)
  ASSERT_OK(GenerateAndAddExternalFile(options, {1, 10}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
  EXPECT_EQ(FilesPerLevel(), "0,0,0,1");

  // File 1 will go to level L2 (since it overlap with file 0 in L3)
  ASSERT_OK(GenerateAndAddExternalFile(options, {2, 9}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
  EXPECT_EQ(FilesPerLevel(), "0,0,1,1");

  rocksdb::SyncPoint::GetInstance()->LoadDependency({
@@ -1227,12 +1196,12 @@ TEST_P(ExternalSSTFileTest, PickedLevel) {
  // This file overlaps with file 0 (L3), file 1 (L2) and the
  // output of compaction going to L1
  ASSERT_OK(GenerateAndAddExternalFile(options, {4, 7}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
  EXPECT_EQ(FilesPerLevel(), "5,0,1,1");

  // This file does not overlap with any file or with the running compaction
  ASSERT_OK(GenerateAndAddExternalFile(options, {9000, 9001}, -1, false, false,
-                                       false, false, false, &true_data));
+                                       true, false, &true_data));
  EXPECT_EQ(FilesPerLevel(), "5,0,1,2");

  // Hold compaction from finishing
@@ -1463,12 +1432,12 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
  // This file overlaps with the output of the compaction (going to L3)
  // so the file will be added to L0 since L3 is the base level
  ASSERT_OK(GenerateAndAddExternalFile(options, {31, 32, 33, 34}, -1, false,
-                                       false, true, false, false, &true_data));
+                                       false, true, false, &true_data));
  EXPECT_EQ(FilesPerLevel(), "5");

  // This file does not overlap with the current running compactiong
  ASSERT_OK(GenerateAndAddExternalFile(options, {9000, 9001}, -1, false, false,
-                                       true, false, false, &true_data));
+                                       true, false, &true_data));
  EXPECT_EQ(FilesPerLevel(), "5,0,0,1");

  // Hold compaction from finishing
@@ -1483,25 +1452,25 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
  Reopen(options);

  ASSERT_OK(GenerateAndAddExternalFile(options, {1, 15, 19}, -1, false, false,
-                                       true, false, false, &true_data));
+                                       true, false, &true_data));
  ASSERT_EQ(FilesPerLevel(), "1,0,0,3");

  ASSERT_OK(GenerateAndAddExternalFile(options, {1000, 1001, 1002}, -1, false,
-                                       false, true, false, false, &true_data));
+                                       false, true, false, &true_data));
  ASSERT_EQ(FilesPerLevel(), "1,0,0,4");

  ASSERT_OK(GenerateAndAddExternalFile(options, {500, 600, 700}, -1, false,
-                                       false, true, false, false, &true_data));
+                                       false, true, false, &true_data));
  ASSERT_EQ(FilesPerLevel(), "1,0,0,5");

  // File 5 overlaps with file 2 (L3 / base level)
  ASSERT_OK(GenerateAndAddExternalFile(options, {2, 10}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
  ASSERT_EQ(FilesPerLevel(), "2,0,0,5");

  // File 6 overlaps with file 2 (L3 / base level) and file 5 (L0)
  ASSERT_OK(GenerateAndAddExternalFile(options, {3, 9}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
  ASSERT_EQ(FilesPerLevel(), "3,0,0,5");

  // Verify data in files
@@ -1520,7 +1489,7 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {

  // File 7 overlaps with file 4 (L3)
  ASSERT_OK(GenerateAndAddExternalFile(options, {650, 651, 652}, -1, false,
-                                       false, true, false, false, &true_data));
+                                       false, true, false, &true_data));
  ASSERT_EQ(FilesPerLevel(), "5,0,0,5");

  VerifyDBFromMap(true_data, &kcnt, false);
@@ -1687,7 +1656,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
      } else {
        ASSERT_OK(GenerateAndAddExternalFile(
            options, random_data, -1, true, write_global_seqno,
-            verify_checksums_before_ingest, false, true, &true_data));
+            verify_checksums_before_ingest, true, &true_data));
      }
    }
    size_t kcnt = 0;
@@ -1720,7 +1689,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
  bool verify_checksums_before_ingest = std::get<1>(GetParam());
  ASSERT_OK(GenerateAndAddExternalFile(
      options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));

  // This file dont overlap with anything in the DB, will go to L4
  ASSERT_EQ("0,0,0,0,1", FilesPerLevel());
@@ -1732,7 +1701,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
  }
  ASSERT_OK(GenerateAndAddExternalFile(
      options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));

  // This file overlap with the memtable, so it will flush it and add
  // it self to L0
@@ -1745,7 +1714,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
  }
  ASSERT_OK(GenerateAndAddExternalFile(
      options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));

  // This file dont overlap with anything in the DB and fit in L4 as well
  ASSERT_EQ("2,0,0,0,2", FilesPerLevel());
@@ -1757,7 +1726,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
  }
  ASSERT_OK(GenerateAndAddExternalFile(
      options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));

  // This file overlap with files in L4, we will ingest it in L3
  ASSERT_EQ("2,0,0,1,2", FilesPerLevel());
@@ -1785,7 +1754,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
  // No need for flush
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {90, 100, 110}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
  db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                      &entries_in_memtable);
  ASSERT_GE(entries_in_memtable, 1);
@@ -1793,7 +1762,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
  // This file will flush the memtable
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {19, 20, 21}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
  db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                      &entries_in_memtable);
  ASSERT_EQ(entries_in_memtable, 0);
@@ -1809,15 +1778,15 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
  // No need for flush, this file keys fit between the memtable keys
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {202, 203, 204}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
  db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                      &entries_in_memtable);
  ASSERT_GE(entries_in_memtable, 1);

  // This file will flush the memtable
  ASSERT_OK(GenerateAndAddExternalFile(
-      options, {206, 207}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      options, {206, 207}, -1, true, false, write_global_seqno,
+      verify_checksums_before_ingest, &true_data));
  db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                      &entries_in_memtable);
  ASSERT_EQ(entries_in_memtable, 0);
@@ -1838,13 +1807,13 @@ TEST_P(ExternalSSTFileTest, L0SortingIssue) {
  bool write_global_seqno = std::get<0>(GetParam());
  bool verify_checksums_before_ingest = std::get<1>(GetParam());
  // No Flush needed, No global seqno needed, Ingest in L1
-  ASSERT_OK(
-      GenerateAndAddExternalFile(options, {7, 8}, -1, true, write_global_seqno,
-                                 verify_checksums_before_ingest, false, false));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {7, 8}, -1, true,
+                                       write_global_seqno,
+                                       verify_checksums_before_ingest, false));
  // No Flush needed, but need a global seqno, Ingest in L0
-  ASSERT_OK(
-      GenerateAndAddExternalFile(options, {7, 8}, -1, true, write_global_seqno,
-                                 verify_checksums_before_ingest, false, false));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {7, 8}, -1, true,
+                                       write_global_seqno,
+                                       verify_checksums_before_ingest, false));
  printf("%s\n", FilesPerLevel().c_str());

  // Overwrite what we added using external files
@@ -2085,7 +2054,7 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
  // Ingest into default cf
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, true, nullptr, handles_[0]));
+      verify_checksums_before_ingest, true, nullptr, handles_[0]));
  ASSERT_EQ(listener->ingested_files.size(), 1);
  ASSERT_EQ(listener->ingested_files.back().cf_name, "default");
  ASSERT_EQ(listener->ingested_files.back().global_seqno, 0);
@@ -2097,7 +2066,7 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
  // Ingest into cf1
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, true, nullptr, handles_[1]));
+      verify_checksums_before_ingest, true, nullptr, handles_[1]));
  ASSERT_EQ(listener->ingested_files.size(), 2);
  ASSERT_EQ(listener->ingested_files.back().cf_name, "koko");
  ASSERT_EQ(listener->ingested_files.back().global_seqno, 0);
@@ -2109,7 +2078,7 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
  // Ingest into cf2
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, true, nullptr, handles_[2]));
+      verify_checksums_before_ingest, true, nullptr, handles_[2]));
  ASSERT_EQ(listener->ingested_files.size(), 3);
  ASSERT_EQ(listener->ingested_files.back().cf_name, "toto");
  ASSERT_EQ(listener->ingested_files.back().global_seqno, 0);
@@ -2172,16 +2141,16 @@ TEST_P(ExternalSSTFileTest, IngestBehind) {
    file_data.emplace_back(Key(i), "ingest_behind");
  }

-  bool allow_global_seqno = true;
-  bool ingest_behind = true;
-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  IngestExternalFileOptions ifo;
+  ifo.allow_global_seqno = true;
+  ifo.ingest_behind = true;
+  ifo.write_global_seqno = std::get<0>(GetParam());
+  ifo.verify_checksums_before_ingest = std::get<1>(GetParam());

  // Can't ingest behind since allow_ingest_behind isn't set to true
-  ASSERT_NOK(GenerateAndAddExternalFile(
-      options, file_data, -1, allow_global_seqno, write_global_seqno,
-      verify_checksums_before_ingest, ingest_behind, false /*sort_data*/,
-      &true_data));
+  ASSERT_NOK(GenerateAndAddExternalFileIngestBehind(options, ifo,
+                                                   file_data, -1, false,
+                                                   &true_data));

  options.allow_ingest_behind = true;
  // check that we still can open the DB, as num_levels should be
@@ -2199,16 +2168,14 @@ TEST_P(ExternalSSTFileTest, IngestBehind) {
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
  // Universal picker should go at second from the bottom level
  ASSERT_EQ("0,1", FilesPerLevel());
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, file_data, -1, allow_global_seqno, write_global_seqno,
-      verify_checksums_before_ingest, true /*ingest_behind*/,
-      false /*sort_data*/, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFileIngestBehind(options, ifo,
+                                                   file_data, -1, false,
+                                                   &true_data));
  ASSERT_EQ("0,1,1", FilesPerLevel());
  // this time ingest should fail as the file doesn't fit to the bottom level
-  ASSERT_NOK(GenerateAndAddExternalFile(
-      options, file_data, -1, allow_global_seqno, write_global_seqno,
-      verify_checksums_before_ingest, true /*ingest_behind*/,
-      false /*sort_data*/, &true_data));
+  ASSERT_NOK(GenerateAndAddExternalFileIngestBehind(options, ifo,
+                                                   file_data, -1, false,
+                                                   &true_data));
  ASSERT_EQ("0,1,1", FilesPerLevel());
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
  // bottom level should be empty
@@ -2266,400 +2233,6 @@ TEST_F(ExternalSSTFileTest, SkipBloomFilter) {
  }
 }

-TEST_F(ExternalSSTFileTest, IngestFileWrittenWithCompressionDictionary) {
-  if (!ZSTD_Supported()) {
-    return;
-  }
-  const int kNumEntries = 1 << 10;
-  const int kNumBytesPerEntry = 1 << 10;
-  Options options = CurrentOptions();
-  options.compression = kZSTD;
-  options.compression_opts.max_dict_bytes = 1 << 14;        // 16KB
-  options.compression_opts.zstd_max_train_bytes = 1 << 18;  // 256KB
-  DestroyAndReopen(options);
-
-  std::atomic<int> num_compression_dicts(0);
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTableBuilder::WriteCompressionDictBlock:RawDict",
-      [&](void* /* arg */) { ++num_compression_dicts; });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  Random rnd(301);
-  std::vector<std::pair<std::string, std::string>> random_data;
-  for (int i = 0; i < kNumEntries; i++) {
-    std::string val;
-    test::RandomString(&rnd, kNumBytesPerEntry, &val);
-    random_data.emplace_back(Key(i), std::move(val));
-  }
-  ASSERT_OK(GenerateAndAddExternalFile(options, std::move(random_data)));
-  ASSERT_EQ(1, num_compression_dicts);
-}
-
-TEST_P(ExternalSSTFileTest, IngestFilesIntoMultipleColumnFamilies_Success) {
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env(
-      new FaultInjectionTestEnv(env_));
-  Options options = CurrentOptions();
-  options.env = fault_injection_env.get();
-  CreateAndReopenWithCF({"pikachu"}, options);
-  std::vector<ColumnFamilyHandle*> column_families;
-  column_families.push_back(handles_[0]);
-  column_families.push_back(handles_[1]);
-  std::vector<IngestExternalFileOptions> ifos(column_families.size());
-  for (auto& ifo : ifos) {
-    ifo.allow_global_seqno = true;  // Always allow global_seqno
-    // May or may not write global_seqno
-    ifo.write_global_seqno = std::get<0>(GetParam());
-    // Whether to verify checksums before ingestion
-    ifo.verify_checksums_before_ingest = std::get<1>(GetParam());
-  }
-  std::vector<std::vector<std::pair<std::string, std::string>>> data;
-  data.push_back(
-      {std::make_pair("foo1", "fv1"), std::make_pair("foo2", "fv2")});
-  data.push_back(
-      {std::make_pair("bar1", "bv1"), std::make_pair("bar2", "bv2")});
-  // Resize the true_data vector upon construction to avoid re-alloc
-  std::vector<std::map<std::string, std::string>> true_data(
-      column_families.size());
-  Status s = GenerateAndAddExternalFiles(options, column_families, ifos, data,
-                                         -1, true, true_data);
-  ASSERT_OK(s);
-  Close();
-  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "pikachu"}, options);
-  ASSERT_EQ(2, handles_.size());
-  int cf = 0;
-  for (const auto& verify_map : true_data) {
-    for (const auto& elem : verify_map) {
-      const std::string& key = elem.first;
-      const std::string& value = elem.second;
-      ASSERT_EQ(value, Get(cf, key));
-    }
-    ++cf;
-  }
-  Close();
-  Destroy(options, true /* delete_cf_paths */);
-}
-
-TEST_P(ExternalSSTFileTest,
-       IngestFilesIntoMultipleColumnFamilies_NoMixedStateWithSnapshot) {
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env(
-      new FaultInjectionTestEnv(env_));
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImpl::IngestExternalFiles:InstallSVForFirstCF:0",
-       "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_MixedState:"
-       "BeforeRead"},
-      {"ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_MixedState:"
-       "AfterRead",
-       "DBImpl::IngestExternalFiles:InstallSVForFirstCF:1"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  Options options = CurrentOptions();
-  options.env = fault_injection_env.get();
-  CreateAndReopenWithCF({"pikachu"}, options);
-  const std::vector<std::map<std::string, std::string>> data_before_ingestion =
-      {{{"foo1", "fv1_0"}, {"foo2", "fv2_0"}, {"foo3", "fv3_0"}},
-       {{"bar1", "bv1_0"}, {"bar2", "bv2_0"}, {"bar3", "bv3_0"}}};
-  for (size_t i = 0; i != handles_.size(); ++i) {
-    int cf = static_cast<int>(i);
-    const auto& orig_data = data_before_ingestion[i];
-    for (const auto& kv : orig_data) {
-      ASSERT_OK(Put(cf, kv.first, kv.second));
-    }
-    ASSERT_OK(Flush(cf));
-  }
-
-  std::vector<ColumnFamilyHandle*> column_families;
-  column_families.push_back(handles_[0]);
-  column_families.push_back(handles_[1]);
-  std::vector<IngestExternalFileOptions> ifos(column_families.size());
-  for (auto& ifo : ifos) {
-    ifo.allow_global_seqno = true;  // Always allow global_seqno
-    // May or may not write global_seqno
-    ifo.write_global_seqno = std::get<0>(GetParam());
-    // Whether to verify checksums before ingestion
-    ifo.verify_checksums_before_ingest = std::get<1>(GetParam());
-  }
-  std::vector<std::vector<std::pair<std::string, std::string>>> data;
-  data.push_back(
-      {std::make_pair("foo1", "fv1"), std::make_pair("foo2", "fv2")});
-  data.push_back(
-      {std::make_pair("bar1", "bv1"), std::make_pair("bar2", "bv2")});
-  // Resize the true_data vector upon construction to avoid re-alloc
-  std::vector<std::map<std::string, std::string>> true_data(
-      column_families.size());
-  // Take snapshot before ingestion starts
-  ReadOptions read_opts;
-  read_opts.total_order_seek = true;
-  read_opts.snapshot = dbfull()->GetSnapshot();
-  std::vector<Iterator*> iters(handles_.size());
-
-  // Range scan checks first kv of each CF before ingestion starts.
-  for (size_t i = 0; i != handles_.size(); ++i) {
-    iters[i] = dbfull()->NewIterator(read_opts, handles_[i]);
-    iters[i]->SeekToFirst();
-    ASSERT_TRUE(iters[i]->Valid());
-    const std::string& key = iters[i]->key().ToString();
-    const std::string& value = iters[i]->value().ToString();
-    const std::map<std::string, std::string>& orig_data =
-        data_before_ingestion[i];
-    std::map<std::string, std::string>::const_iterator it = orig_data.find(key);
-    ASSERT_NE(orig_data.end(), it);
-    ASSERT_EQ(it->second, value);
-    iters[i]->Next();
-  }
-  port::Thread ingest_thread([&]() {
-    ASSERT_OK(GenerateAndAddExternalFiles(options, column_families, ifos, data,
-                                          -1, true, true_data));
-  });
-  TEST_SYNC_POINT(
-      "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_MixedState:"
-      "BeforeRead");
-  // Should see only data before ingestion
-  for (size_t i = 0; i != handles_.size(); ++i) {
-    const auto& orig_data = data_before_ingestion[i];
-    for (; iters[i]->Valid(); iters[i]->Next()) {
-      const std::string& key = iters[i]->key().ToString();
-      const std::string& value = iters[i]->value().ToString();
-      std::map<std::string, std::string>::const_iterator it =
-          orig_data.find(key);
-      ASSERT_NE(orig_data.end(), it);
-      ASSERT_EQ(it->second, value);
-    }
-  }
-  TEST_SYNC_POINT(
-      "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_MixedState:"
-      "AfterRead");
-  ingest_thread.join();
-  for (auto* iter : iters) {
-    delete iter;
-  }
-  iters.clear();
-  dbfull()->ReleaseSnapshot(read_opts.snapshot);
-
-  Close();
-  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "pikachu"}, options);
-  // Should see consistent state after ingestion for all column families even
-  // without snapshot.
-  ASSERT_EQ(2, handles_.size());
-  int cf = 0;
-  for (const auto& verify_map : true_data) {
-    for (const auto& elem : verify_map) {
-      const std::string& key = elem.first;
-      const std::string& value = elem.second;
-      ASSERT_EQ(value, Get(cf, key));
-    }
-    ++cf;
-  }
-  Close();
-  Destroy(options, true /* delete_cf_paths */);
-}
-
-TEST_P(ExternalSSTFileTest, IngestFilesIntoMultipleColumnFamilies_PrepareFail) {
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env(
-      new FaultInjectionTestEnv(env_));
-  Options options = CurrentOptions();
-  options.env = fault_injection_env.get();
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImpl::IngestExternalFiles:BeforeLastJobPrepare:0",
-       "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_PrepareFail:"
-       "0"},
-      {"ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies:PrepareFail:"
-       "1",
-       "DBImpl::IngestExternalFiles:BeforeLastJobPrepare:1"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-  CreateAndReopenWithCF({"pikachu"}, options);
-  std::vector<ColumnFamilyHandle*> column_families;
-  column_families.push_back(handles_[0]);
-  column_families.push_back(handles_[1]);
-  std::vector<IngestExternalFileOptions> ifos(column_families.size());
-  for (auto& ifo : ifos) {
-    ifo.allow_global_seqno = true;  // Always allow global_seqno
-    // May or may not write global_seqno
-    ifo.write_global_seqno = std::get<0>(GetParam());
-    // Whether to verify block checksums before ingest
-    ifo.verify_checksums_before_ingest = std::get<1>(GetParam());
-  }
-  std::vector<std::vector<std::pair<std::string, std::string>>> data;
-  data.push_back(
-      {std::make_pair("foo1", "fv1"), std::make_pair("foo2", "fv2")});
-  data.push_back(
-      {std::make_pair("bar1", "bv1"), std::make_pair("bar2", "bv2")});
-  // Resize the true_data vector upon construction to avoid re-alloc
-  std::vector<std::map<std::string, std::string>> true_data(
-      column_families.size());
-  port::Thread ingest_thread([&]() {
-    Status s = GenerateAndAddExternalFiles(options, column_families, ifos, data,
-                                           -1, true, true_data);
-    ASSERT_NOK(s);
-  });
-  TEST_SYNC_POINT(
-      "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_PrepareFail:"
-      "0");
-  fault_injection_env->SetFilesystemActive(false);
-  TEST_SYNC_POINT(
-      "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies:PrepareFail:"
-      "1");
-  ingest_thread.join();
-
-  fault_injection_env->SetFilesystemActive(true);
-  Close();
-  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "pikachu"}, options);
-  ASSERT_EQ(2, handles_.size());
-  int cf = 0;
-  for (const auto& verify_map : true_data) {
-    for (const auto& elem : verify_map) {
-      const std::string& key = elem.first;
-      ASSERT_EQ("NOT_FOUND", Get(cf, key));
-    }
-    ++cf;
-  }
-  Close();
-  Destroy(options, true /* delete_cf_paths */);
-}
-
-TEST_P(ExternalSSTFileTest, IngestFilesIntoMultipleColumnFamilies_CommitFail) {
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env(
-      new FaultInjectionTestEnv(env_));
-  Options options = CurrentOptions();
-  options.env = fault_injection_env.get();
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImpl::IngestExternalFiles:BeforeJobsRun:0",
-       "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_CommitFail:"
-       "0"},
-      {"ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_CommitFail:"
-       "1",
-       "DBImpl::IngestExternalFiles:BeforeJobsRun:1"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-  CreateAndReopenWithCF({"pikachu"}, options);
-  std::vector<ColumnFamilyHandle*> column_families;
-  column_families.push_back(handles_[0]);
-  column_families.push_back(handles_[1]);
-  std::vector<IngestExternalFileOptions> ifos(column_families.size());
-  for (auto& ifo : ifos) {
-    ifo.allow_global_seqno = true;  // Always allow global_seqno
-    // May or may not write global_seqno
-    ifo.write_global_seqno = std::get<0>(GetParam());
-    // Whether to verify block checksums before ingestion
-    ifo.verify_checksums_before_ingest = std::get<1>(GetParam());
-  }
-  std::vector<std::vector<std::pair<std::string, std::string>>> data;
-  data.push_back(
-      {std::make_pair("foo1", "fv1"), std::make_pair("foo2", "fv2")});
-  data.push_back(
-      {std::make_pair("bar1", "bv1"), std::make_pair("bar2", "bv2")});
-  // Resize the true_data vector upon construction to avoid re-alloc
-  std::vector<std::map<std::string, std::string>> true_data(
-      column_families.size());
-  port::Thread ingest_thread([&]() {
-    Status s = GenerateAndAddExternalFiles(options, column_families, ifos, data,
-                                           -1, true, true_data);
-    ASSERT_NOK(s);
-  });
-  TEST_SYNC_POINT(
-      "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_CommitFail:"
-      "0");
-  fault_injection_env->SetFilesystemActive(false);
-  TEST_SYNC_POINT(
-      "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_CommitFail:"
-      "1");
-  ingest_thread.join();
-
-  fault_injection_env->SetFilesystemActive(true);
-  Close();
-  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "pikachu"}, options);
-  ASSERT_EQ(2, handles_.size());
-  int cf = 0;
-  for (const auto& verify_map : true_data) {
-    for (const auto& elem : verify_map) {
-      const std::string& key = elem.first;
-      ASSERT_EQ("NOT_FOUND", Get(cf, key));
-    }
-    ++cf;
-  }
-  Close();
-  Destroy(options, true /* delete_cf_paths */);
-}
-
-TEST_P(ExternalSSTFileTest,
-       IngestFilesIntoMultipleColumnFamilies_PartialManifestWriteFail) {
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env(
-      new FaultInjectionTestEnv(env_));
-  Options options = CurrentOptions();
-  options.env = fault_injection_env.get();
-
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  SyncPoint::GetInstance()->ClearTrace();
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->LoadDependency({
-      {"VersionSet::ProcessManifestWrites:BeforeWriteLastVersionEdit:0",
-       "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_"
-       "PartialManifestWriteFail:0"},
-      {"ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_"
-       "PartialManifestWriteFail:1",
-       "VersionSet::ProcessManifestWrites:BeforeWriteLastVersionEdit:1"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  std::vector<ColumnFamilyHandle*> column_families;
-  column_families.push_back(handles_[0]);
-  column_families.push_back(handles_[1]);
-  std::vector<IngestExternalFileOptions> ifos(column_families.size());
-  for (auto& ifo : ifos) {
-    ifo.allow_global_seqno = true;  // Always allow global_seqno
-    // May or may not write global_seqno
-    ifo.write_global_seqno = std::get<0>(GetParam());
-    // Whether to verify block checksums before ingestion
-    ifo.verify_checksums_before_ingest = std::get<1>(GetParam());
-  }
-  std::vector<std::vector<std::pair<std::string, std::string>>> data;
-  data.push_back(
-      {std::make_pair("foo1", "fv1"), std::make_pair("foo2", "fv2")});
-  data.push_back(
-      {std::make_pair("bar1", "bv1"), std::make_pair("bar2", "bv2")});
-  // Resize the true_data vector upon construction to avoid re-alloc
-  std::vector<std::map<std::string, std::string>> true_data(
-      column_families.size());
-  port::Thread ingest_thread([&]() {
-    Status s = GenerateAndAddExternalFiles(options, column_families, ifos, data,
-                                           -1, true, true_data);
-    ASSERT_NOK(s);
-  });
-  TEST_SYNC_POINT(
-      "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_"
-      "PartialManifestWriteFail:0");
-  fault_injection_env->SetFilesystemActive(false);
-  TEST_SYNC_POINT(
-      "ExternalSSTFileTest::IngestFilesIntoMultipleColumnFamilies_"
-      "PartialManifestWriteFail:1");
-  ingest_thread.join();
-
-  fault_injection_env->DropUnsyncedFileData();
-  fault_injection_env->SetFilesystemActive(true);
-  Close();
-  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "pikachu"}, options);
-  ASSERT_EQ(2, handles_.size());
-  int cf = 0;
-  for (const auto& verify_map : true_data) {
-    for (const auto& elem : verify_map) {
-      const std::string& key = elem.first;
-      ASSERT_EQ("NOT_FOUND", Get(cf, key));
-    }
-    ++cf;
-  }
-  Close();
-  Destroy(options, true /* delete_cf_paths */);
-}
-
 INSTANTIATE_TEST_CASE_P(ExternalSSTFileTest, ExternalSSTFileTest,
                        testing::Values(std::make_tuple(false, false),
                                        std::make_tuple(false, true),
@@ -83,7 +83,7 @@ class FaultInjectionTest
        env_(nullptr),
        db_(nullptr) {}

-  ~FaultInjectionTest() override {
+  ~FaultInjectionTest() {
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
    rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
  }
@@ -47,7 +47,7 @@ class FileIndexerTest : public testing::Test {
  FileIndexerTest()
      : kNumLevels(4), files(new std::vector<FileMetaData*>[kNumLevels]) {}

-  ~FileIndexerTest() override {
+  ~FileIndexerTest() {
    ClearFiles();
    delete[] files;
  }
@@ -100,8 +100,7 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
                   Directory* output_file_directory,
                   CompressionType output_compression, Statistics* stats,
                   EventLogger* event_logger, bool measure_io_stats,
-                   const bool sync_output_directory, const bool write_manifest,
-                   Env::Priority thread_pri)
+                   const bool sync_output_directory, const bool write_manifest)
    : dbname_(dbname),
      cfd_(cfd),
      db_options_(db_options),
@@ -126,8 +125,7 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
      write_manifest_(write_manifest),
      edit_(nullptr),
      base_(nullptr),
-      pick_memtable_called(false),
-      thread_pri_(thread_pri) {
+      pick_memtable_called(false) {
  // Update the thread status to indicate flush.
  ReportStartedFlush();
  TEST_SYNC_POINT("FlushJob::FlushJob()");
@@ -313,7 +311,6 @@ Status FlushJob::WriteLevel0Table() {
    ro.total_order_seek = true;
    Arena arena;
    uint64_t total_num_entries = 0, total_num_deletes = 0;
-    uint64_t total_data_size = 0;
    size_t total_memory_usage = 0;
    for (MemTable* m : mems_) {
      ROCKS_LOG_INFO(
@@ -328,18 +325,16 @@ Status FlushJob::WriteLevel0Table() {
      }
      total_num_entries += m->num_entries();
      total_num_deletes += m->num_deletes();
-      total_data_size += m->get_data_size();
      total_memory_usage += m->ApproximateMemoryUsage();
    }

-    event_logger_->Log() << "job" << job_context_->job_id << "event"
-                         << "flush_started"
-                         << "num_memtables" << mems_.size() << "num_entries"
-                         << total_num_entries << "num_deletes"
-                         << total_num_deletes << "total_data_size"
-                         << total_data_size << "memory_usage"
-                         << total_memory_usage << "flush_reason"
-                         << GetFlushReasonString(cfd_->GetFlushReason());
+    event_logger_->Log()
+        << "job" << job_context_->job_id << "event"
+        << "flush_started"
+        << "num_memtables" << mems_.size() << "num_entries" << total_num_entries
+        << "num_deletes" << total_num_deletes << "memory_usage"
+        << total_memory_usage << "flush_reason"
+        << GetFlushReasonString(cfd_->GetFlushReason());

    {
      ScopedArenaIterator iter(
@@ -374,8 +369,7 @@ Status FlushJob::WriteLevel0Table() {
          cfd_->int_tbl_prop_collector_factories(), cfd_->GetID(),
          cfd_->GetName(), existing_snapshots_,
          earliest_write_conflict_snapshot_, snapshot_checker_,
-          output_compression_, mutable_cf_options_.sample_for_compression,
-          cfd_->ioptions()->compression_opts,
+          output_compression_, cfd_->ioptions()->compression_opts,
          mutable_cf_options_.paranoid_file_checks, cfd_->internal_stats(),
          TableFileCreationReason::kFlush, event_logger_, job_context_->job_id,
          Env::IO_HIGH, &table_properties_, 0 /* level */, current_time,
@@ -418,8 +412,8 @@ Status FlushJob::WriteLevel0Table() {
  stats.micros = db_options_.env->NowMicros() - start_micros;
  stats.cpu_micros = db_options_.env->NowCPUNanos() / 1000 - start_cpu_micros;
  stats.bytes_written = meta_.fd.GetFileSize();
-  RecordTimeToHistogram(stats_, FLUSH_TIME, stats.micros);
-  cfd_->internal_stats()->AddCompactionStats(0 /* level */, thread_pri_, stats);
+  MeasureTime(stats_, FLUSH_TIME, stats.micros);
+  cfd_->internal_stats()->AddCompactionStats(0 /* level */, stats);
  cfd_->internal_stats()->AddCFStats(InternalStats::BYTES_FLUSHED,
                                     meta_.fd.GetFileSize());
  RecordFlushIOStats();
@@ -68,8 +68,7 @@ class FlushJob {
           LogBuffer* log_buffer, Directory* db_directory,
           Directory* output_file_directory, CompressionType output_compression,
           Statistics* stats, EventLogger* event_logger, bool measure_io_stats,
-           const bool sync_output_directory, const bool write_manifest,
-           Env::Priority thread_pri);
+           const bool sync_output_directory, const bool write_manifest);

  ~FlushJob();

@@ -138,7 +137,6 @@ class FlushJob {
  VersionEdit* edit_;
  Version* base_;
  bool pick_memtable_called;
-  Env::Priority thread_pri_;
 };

 }  // namespace rocksdb
@@ -118,14 +118,13 @@ TEST_F(FlushJobTest, Empty) {
  auto cfd = versions_->GetColumnFamilySet()->GetDefault();
  EventLogger event_logger(db_options_.info_log.get());
  SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     nullptr /* memtable_id */, env_options_, versions_.get(),
-                     &mutex_, &shutting_down_, {}, kMaxSequenceNumber,
-                     snapshot_checker, &job_context, nullptr, nullptr, nullptr,
-                     kNoCompression, nullptr, &event_logger, false,
-                     true /* sync_output_directory */,
-                     true /* write_manifest */, Env::Priority::USER);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), nullptr /* memtable_id */,
+      env_options_, versions_.get(), &mutex_, &shutting_down_, {},
+      kMaxSequenceNumber, snapshot_checker, &job_context, nullptr, nullptr,
+      nullptr, kNoCompression, nullptr, &event_logger, false,
+      true /* sync_output_directory */, true /* write_manifest */);
  {
    InstrumentedMutexLock l(&mutex_);
    flush_job.PickMemTable();
@@ -166,14 +165,13 @@ TEST_F(FlushJobTest, NonEmpty) {

  EventLogger event_logger(db_options_.info_log.get());
  SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     nullptr /* memtable_id */, env_options_, versions_.get(),
-                     &mutex_, &shutting_down_, {}, kMaxSequenceNumber,
-                     snapshot_checker, &job_context, nullptr, nullptr, nullptr,
-                     kNoCompression, db_options_.statistics.get(),
-                     &event_logger, true, true /* sync_output_directory */,
-                     true /* write_manifest */, Env::Priority::USER);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), nullptr /* memtable_id */,
+      env_options_, versions_.get(), &mutex_, &shutting_down_, {},
+      kMaxSequenceNumber, snapshot_checker, &job_context, nullptr, nullptr,
+      nullptr, kNoCompression, db_options_.statistics.get(), &event_logger,
+      true, true /* sync_output_directory */, true /* write_manifest */);

  HistogramData hist;
  FileMetaData file_meta;
@@ -230,14 +228,13 @@ TEST_F(FlushJobTest, FlushMemTablesSingleColumnFamily) {
  uint64_t smallest_memtable_id = memtable_ids.front();
  uint64_t flush_memtable_id = smallest_memtable_id + num_mems_to_flush - 1;

-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     &flush_memtable_id, env_options_, versions_.get(), &mutex_,
-                     &shutting_down_, {}, kMaxSequenceNumber, snapshot_checker,
-                     &job_context, nullptr, nullptr, nullptr, kNoCompression,
-                     db_options_.statistics.get(), &event_logger, true,
-                     true /* sync_output_directory */,
-                     true /* write_manifest */, Env::Priority::USER);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), &flush_memtable_id, env_options_,
+      versions_.get(), &mutex_, &shutting_down_, {}, kMaxSequenceNumber,
+      snapshot_checker, &job_context, nullptr, nullptr, nullptr, kNoCompression,
+      db_options_.statistics.get(), &event_logger, true,
+      true /* sync_output_directory */, true /* write_manifest */);
  HistogramData hist;
  FileMetaData file_meta;
  mutex_.Lock();
@@ -307,14 +304,11 @@ TEST_F(FlushJobTest, FlushMemtablesMultipleColumnFamilies) {
        &shutting_down_, snapshot_seqs, kMaxSequenceNumber, snapshot_checker,
        &job_context, nullptr, nullptr, nullptr, kNoCompression,
        db_options_.statistics.get(), &event_logger, true,
-        false /* sync_output_directory */, false /* write_manifest */,
-        Env::Priority::USER);
+        false /* sync_output_directory */, false /* write_manifest */);
    k++;
  }
  HistogramData hist;
-  std::vector<FileMetaData> file_metas;
-  // Call reserve to avoid auto-resizing
-  file_metas.reserve(flush_jobs.size());
+  autovector<FileMetaData> file_metas;
  mutex_.Lock();
  for (auto& job : flush_jobs) {
    job.PickMemTable();
@@ -325,10 +319,6 @@ TEST_F(FlushJobTest, FlushMemtablesMultipleColumnFamilies) {
    ASSERT_OK(job.Run(nullptr /**/, &meta));
    file_metas.emplace_back(meta);
  }
-  autovector<FileMetaData*> file_meta_ptrs;
-  for (auto& meta : file_metas) {
-    file_meta_ptrs.push_back(&meta);
-  }
  autovector<const autovector<MemTable*>*> mems_list;
  for (size_t i = 0; i != all_cfds.size(); ++i) {
    const auto& mems = flush_jobs[i].GetMemTables();
@@ -341,7 +331,7 @@ TEST_F(FlushJobTest, FlushMemtablesMultipleColumnFamilies) {

  Status s = InstallMemtableAtomicFlushResults(
      nullptr /* imm_lists */, all_cfds, mutable_cf_options_list, mems_list,
-      versions_.get(), &mutex_, file_meta_ptrs, &job_context.memtables_to_free,
+      versions_.get(), &mutex_, file_metas, &job_context.memtables_to_free,
      nullptr /* db_directory */, nullptr /* log_buffer */);
  ASSERT_OK(s);

@@ -417,14 +407,13 @@ TEST_F(FlushJobTest, Snapshots) {

  EventLogger event_logger(db_options_.info_log.get());
  SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     nullptr /* memtable_id */, env_options_, versions_.get(),
-                     &mutex_, &shutting_down_, snapshots, kMaxSequenceNumber,
-                     snapshot_checker, &job_context, nullptr, nullptr, nullptr,
-                     kNoCompression, db_options_.statistics.get(),
-                     &event_logger, true, true /* sync_output_directory */,
-                     true /* write_manifest */, Env::Priority::USER);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), nullptr /* memtable_id */,
+      env_options_, versions_.get(), &mutex_, &shutting_down_, snapshots,
+      kMaxSequenceNumber, snapshot_checker, &job_context, nullptr, nullptr,
+      nullptr, kNoCompression, db_options_.statistics.get(), &event_logger,
+      true, true /* sync_output_directory */, true /* write_manifest */);
  mutex_.Lock();
  flush_job.PickMemTable();
  ASSERT_OK(flush_job.Run());
@@ -46,7 +46,7 @@ class ForwardLevelIterator : public InternalIterator {
        pinned_iters_mgr_(nullptr),
        prefix_extractor_(prefix_extractor) {}

-  ~ForwardLevelIterator() override {
+  ~ForwardLevelIterator() {
    // Reset current pointer
    if (pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled()) {
      pinned_iters_mgr_->PinIterator(file_iter_);
@@ -265,18 +265,16 @@ void ForwardIterator::SVCleanup() {
  if (sv_ == nullptr) {
    return;
  }
-  bool background_purge =
-      read_options_.background_purge_on_iterator_cleanup ||
-      db_->immutable_db_options().avoid_unnecessary_blocking_io;
  if (pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled()) {
    // pinned_iters_mgr_ tells us to make sure that all visited key-value slices
    // are alive until pinned_iters_mgr_->ReleasePinnedData() is called.
    // The slices may point into some memtables owned by sv_, so we need to keep
    // sv_ referenced until pinned_iters_mgr_ unpins everything.
-    auto p = new SVCleanupParams{db_, sv_, background_purge};
+    auto p = new SVCleanupParams{
+      db_, sv_, read_options_.background_purge_on_iterator_cleanup};
    pinned_iters_mgr_->PinPtr(p, &ForwardIterator::DeferredSVCleanup);
  } else {
-    SVCleanup(db_, sv_, background_purge);
+    SVCleanup(db_, sv_, read_options_.background_purge_on_iterator_cleanup);
  }
 }

@@ -1,45 +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.
-
-#include "db/db_impl.h"
-#include "db/in_memory_stats_history.h"
-
-namespace rocksdb {
-
-InMemoryStatsHistoryIterator::~InMemoryStatsHistoryIterator() {}
-
-bool InMemoryStatsHistoryIterator::Valid() const { return valid_; }
-
-Status InMemoryStatsHistoryIterator::status() const { return status_; }
-
-void InMemoryStatsHistoryIterator::Next() {
-  // increment start_time by 1 to avoid infinite loop
-  AdvanceIteratorByTime(GetStatsTime() + 1, end_time_);
-}
-
-uint64_t InMemoryStatsHistoryIterator::GetStatsTime() const { return time_; }
-
-const std::map<std::string, uint64_t>&
-InMemoryStatsHistoryIterator::GetStatsMap() const {
-  return stats_map_;
-}
-
-// advance the iterator to the next time between [start_time, end_time)
-// if success, update time_ and stats_map_ with new_time and stats_map
-void InMemoryStatsHistoryIterator::AdvanceIteratorByTime(uint64_t start_time,
-                                                         uint64_t end_time) {
-  // try to find next entry in stats_history_ map
-  if (db_impl_ != nullptr) {
-    valid_ =
-        db_impl_->FindStatsByTime(start_time, end_time, &time_, &stats_map_);
-  } else {
-    valid_ = false;
-  }
-}
-
-}  // namespace rocksdb
@@ -1,55 +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.
-
-#pragma once
-
-#include "rocksdb/stats_history.h"
-
-namespace rocksdb {
-
-class InMemoryStatsHistoryIterator final : public StatsHistoryIterator {
- public:
-  InMemoryStatsHistoryIterator(uint64_t start_time, uint64_t end_time,
-                               DBImpl* db_impl)
-      : start_time_(start_time),
-        end_time_(end_time),
-        valid_(true),
-        db_impl_(db_impl) {
-    AdvanceIteratorByTime(start_time_, end_time_);
-  }
-  ~InMemoryStatsHistoryIterator() override;
-  bool Valid() const override;
-  Status status() const override;
-
-  void Next() override;
-  uint64_t GetStatsTime() const override;
-
-  const std::map<std::string, uint64_t>& GetStatsMap() const override;
-
- private:
-  // advance the iterator to the next stats history record with timestamp
-  // between [start_time, end_time)
-  void AdvanceIteratorByTime(uint64_t start_time, uint64_t end_time);
-
-  // No copying allowed
-  InMemoryStatsHistoryIterator(const InMemoryStatsHistoryIterator&) = delete;
-  void operator=(const InMemoryStatsHistoryIterator&) = delete;
-  InMemoryStatsHistoryIterator(InMemoryStatsHistoryIterator&&) = delete;
-  InMemoryStatsHistoryIterator& operator=(InMemoryStatsHistoryIterator&&) =
-      delete;
-
-  uint64_t time_;
-  uint64_t start_time_;
-  uint64_t end_time_;
-  std::map<std::string, uint64_t> stats_map_;
-  Status status_;
-  bool valid_;
-  DBImpl* db_impl_;
-};
-
-}  // namespace rocksdb
@@ -58,8 +58,7 @@ const double kMB = 1048576.0;
 const double kGB = kMB * 1024;
 const double kMicrosInSec = 1000000.0;

-void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name,
-                           const std::string& group_by) {
+void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name) {
  int written_size =
      snprintf(buf, len, "\n** Compaction Stats [%s] **\n", cf_name.c_str());
  auto hdr = [](LevelStatType t) {
@@ -67,18 +66,17 @@ void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name,
  };
  int line_size = snprintf(
      buf + written_size, len - written_size,
-      "%s    %s   %s     %s %s  %s %s %s %s %s %s %s %s %s %s %s %s %s %s\n",
+      "Level    %s   %s     %s %s  %s %s %s %s %s %s %s %s %s %s %s %s %s %s\n",
      // Note that we skip COMPACTED_FILES and merge it with Files column
-      group_by.c_str(), hdr(LevelStatType::NUM_FILES),
-      hdr(LevelStatType::SIZE_BYTES), hdr(LevelStatType::SCORE),
-      hdr(LevelStatType::READ_GB), hdr(LevelStatType::RN_GB),
-      hdr(LevelStatType::RNP1_GB), hdr(LevelStatType::WRITE_GB),
-      hdr(LevelStatType::W_NEW_GB), hdr(LevelStatType::MOVED_GB),
-      hdr(LevelStatType::WRITE_AMP), hdr(LevelStatType::READ_MBPS),
-      hdr(LevelStatType::WRITE_MBPS), hdr(LevelStatType::COMP_SEC),
-      hdr(LevelStatType::COMP_CPU_SEC), hdr(LevelStatType::COMP_COUNT),
-      hdr(LevelStatType::AVG_SEC), hdr(LevelStatType::KEY_IN),
-      hdr(LevelStatType::KEY_DROP));
+      hdr(LevelStatType::NUM_FILES), hdr(LevelStatType::SIZE_BYTES),
+      hdr(LevelStatType::SCORE), hdr(LevelStatType::READ_GB),
+      hdr(LevelStatType::RN_GB), hdr(LevelStatType::RNP1_GB),
+      hdr(LevelStatType::WRITE_GB), hdr(LevelStatType::W_NEW_GB),
+      hdr(LevelStatType::MOVED_GB), hdr(LevelStatType::WRITE_AMP),
+      hdr(LevelStatType::READ_MBPS), hdr(LevelStatType::WRITE_MBPS),
+      hdr(LevelStatType::COMP_SEC), hdr(LevelStatType::COMP_CPU_SEC),
+      hdr(LevelStatType::COMP_COUNT), hdr(LevelStatType::AVG_SEC),
+      hdr(LevelStatType::KEY_IN), hdr(LevelStatType::KEY_DROP));

  written_size += line_size;
  snprintf(buf + written_size, len - written_size, "%s\n",
@@ -1154,20 +1152,6 @@ void InternalStats::DumpCFMapStats(
  (*levels_stats)[-1] = sum_stats;  //  -1 is for the Sum level
 }

-void InternalStats::DumpCFMapStatsByPriority(
-    std::map<int, std::map<LevelStatType, double>>* priorities_stats) {
-  for (size_t priority = 0; priority < comp_stats_by_pri_.size(); priority++) {
-    if (comp_stats_by_pri_[priority].micros > 0) {
-      std::map<LevelStatType, double> priority_stats;
-      PrepareLevelStats(&priority_stats, 0 /* num_files */,
-                        0 /* being_compacted */, 0 /* total_file_size */,
-                        0 /* compaction_score */, 0 /* w_amp */,
-                        comp_stats_by_pri_[priority]);
-      (*priorities_stats)[static_cast<int>(priority)] = priority_stats;
-    }
-  }
-}
-
 void InternalStats::DumpCFMapStatsIOStalls(
    std::map<std::string, std::string>* cf_stats) {
  (*cf_stats)["io_stalls.level0_slowdown"] =
@@ -1208,7 +1192,7 @@ void InternalStats::DumpCFStats(std::string* value) {
 void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {
  char buf[2000];
  // Per-ColumnFamily stats
-  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName(), "Level");
+  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName());
  value->append(buf);

  // Print stats for each level
@@ -1254,21 +1238,6 @@ void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {
  PrintLevelStats(buf, sizeof(buf), "Int", 0, 0, 0, 0, w_amp, interval_stats);
  value->append(buf);

-  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName(), "Priority");
-  value->append(buf);
-  std::map<int, std::map<LevelStatType, double>> priorities_stats;
-  DumpCFMapStatsByPriority(&priorities_stats);
-  for (size_t priority = 0; priority < comp_stats_by_pri_.size(); ++priority) {
-    if (priorities_stats.find(static_cast<int>(priority)) !=
-        priorities_stats.end()) {
-      PrintLevelStats(
-          buf, sizeof(buf),
-          Env::PriorityToString(static_cast<Env::Priority>(priority)),
-          priorities_stats[static_cast<int>(priority)]);
-      value->append(buf);
-    }
-  }
-
  double seconds_up = (env_->NowMicros() - started_at_ + 1) / kMicrosInSec;
  double interval_seconds_up = seconds_up - cf_stats_snapshot_.seconds_up;
  snprintf(buf, sizeof(buf), "Uptime(secs): %.1f total, %.1f interval\n",
@@ -125,7 +125,6 @@ class InternalStats {
        cf_stats_value_{},
        cf_stats_count_{},
        comp_stats_(num_levels),
-        comp_stats_by_pri_(Env::Priority::TOTAL),
        file_read_latency_(num_levels),
        bg_error_count_(0),
        number_levels_(num_levels),
@@ -319,10 +318,8 @@ class InternalStats {
    started_at_ = env_->NowMicros();
  }

-  void AddCompactionStats(int level, Env::Priority thread_pri,
-                          const CompactionStats& stats) {
+  void AddCompactionStats(int level, const CompactionStats& stats) {
    comp_stats_[level].Add(stats);
-    comp_stats_by_pri_[thread_pri].Add(stats);
  }

  void IncBytesMoved(int level, uint64_t amount) {
@@ -384,8 +381,6 @@ class InternalStats {
  void DumpCFMapStats(
      std::map<int, std::map<LevelStatType, double>>* level_stats,
      CompactionStats* compaction_stats_sum);
-  void DumpCFMapStatsByPriority(
-      std::map<int, std::map<LevelStatType, double>>* priorities_stats);
  void DumpCFMapStatsIOStalls(std::map<std::string, std::string>* cf_stats);
  void DumpCFStats(std::string* value);
  void DumpCFStatsNoFileHistogram(std::string* value);
@@ -400,7 +395,6 @@ class InternalStats {
  uint64_t cf_stats_count_[INTERNAL_CF_STATS_ENUM_MAX];
  // Per-ColumnFamily/level compaction stats
  std::vector<CompactionStats> comp_stats_;
-  std::vector<CompactionStats> comp_stats_by_pri_;
  std::vector<HistogramImpl> file_read_latency_;

  // Used to compute per-interval statistics
@@ -631,8 +625,7 @@ class InternalStats {
    void Subtract(const CompactionStats& /*c*/) {}
  };

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

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

@@ -46,20 +46,22 @@ class EventListenerTest : public DBTestBase {
 };

 struct TestPropertiesCollector : public rocksdb::TablePropertiesCollector {
-  rocksdb::Status AddUserKey(const rocksdb::Slice& /*key*/,
-                             const rocksdb::Slice& /*value*/,
-                             rocksdb::EntryType /*type*/,
-                             rocksdb::SequenceNumber /*seq*/,
-                             uint64_t /*file_size*/) override {
+  virtual rocksdb::Status AddUserKey(const rocksdb::Slice& /*key*/,
+                                     const rocksdb::Slice& /*value*/,
+                                     rocksdb::EntryType /*type*/,
+                                     rocksdb::SequenceNumber /*seq*/,
+                                     uint64_t /*file_size*/) override {
    return Status::OK();
  }
-  rocksdb::Status Finish(
+  virtual rocksdb::Status Finish(
      rocksdb::UserCollectedProperties* properties) override {
    properties->insert({"0", "1"});
    return Status::OK();
  }

-  const char* Name() const override { return "TestTablePropertiesCollector"; }
+  virtual const char* Name() const override {
+    return "TestTablePropertiesCollector";
+  }

  rocksdb::UserCollectedProperties GetReadableProperties() const override {
    rocksdb::UserCollectedProperties ret;
@@ -70,7 +72,7 @@ struct TestPropertiesCollector : public rocksdb::TablePropertiesCollector {

 class TestPropertiesCollectorFactory : public TablePropertiesCollectorFactory {
 public:
-  TablePropertiesCollector* CreateTablePropertiesCollector(
+  virtual TablePropertiesCollector* CreateTablePropertiesCollector(
      TablePropertiesCollectorFactory::Context /*context*/) override {
    return new TestPropertiesCollector;
  }
@@ -601,7 +603,7 @@ class TableFileCreationListener : public EventListener {

    Status NewWritableFile(const std::string& fname,
                           std::unique_ptr<WritableFile>* result,
-                           const EnvOptions& options) override {
+                           const EnvOptions& options) {
      if (fname.size() > 4 && fname.substr(fname.size() - 4) == ".sst") {
        if (!status_.ok()) {
          return status_;
@@ -24,7 +24,8 @@ Reader::Reporter::~Reporter() {

 Reader::Reader(std::shared_ptr<Logger> info_log,
               std::unique_ptr<SequentialFileReader>&& _file,
-               Reporter* reporter, bool checksum, uint64_t log_num)
+               Reporter* reporter, bool checksum, uint64_t log_num,
+               bool retry_after_eof)
    : info_log_(info_log),
      file_(std::move(_file)),
      reporter_(reporter),
@@ -37,7 +38,8 @@ Reader::Reader(std::shared_ptr<Logger> info_log,
      last_record_offset_(0),
      end_of_buffer_offset_(0),
      log_number_(log_num),
-      recycled_(false) {}
+      recycled_(false),
+      retry_after_eof_(retry_after_eof) {}

 Reader::~Reader() {
  delete[] backing_store_;
@@ -205,14 +207,14 @@ void Reader::UnmarkEOF() {
  if (read_error_) {
    return;
  }
+
  eof_ = false;
-  if (eof_offset_ == 0) {
+
+  // If retry_after_eof_ is true, we have to proceed to read anyway.
+  if (!retry_after_eof_ && eof_offset_ == 0) {
    return;
  }
-  UnmarkEOFInternal();
-}

-void Reader::UnmarkEOFInternal() {
  // If the EOF was in the middle of a block (a partial block was read) we have
  // to read the rest of the block as ReadPhysicalRecord can only read full
  // blocks and expects the file position indicator to be aligned to the start
@@ -290,8 +292,12 @@ bool Reader::ReadMore(size_t* drop_size, int *error) {
    } else if (buffer_.size() < static_cast<size_t>(kBlockSize)) {
      eof_ = true;
      eof_offset_ = buffer_.size();
+      TEST_SYNC_POINT("LogReader::ReadMore:FirstEOF");
    }
    return true;
+  } else if (retry_after_eof_ && !read_error_) {
+    UnmarkEOF();
+    return !read_error_;
  } else {
    // Note that if buffer_ is non-empty, we have a truncated header at the
    //  end of the file, which can be caused by the writer crashing in the
@@ -349,16 +355,24 @@ unsigned int Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size) {
      }
    }
    if (header_size + length > buffer_.size()) {
-      *drop_size = buffer_.size();
-      buffer_.clear();
-      if (!eof_) {
-        return kBadRecordLen;
-      }
-      // If the end of the file has been reached without reading |length|
-      // bytes of payload, assume the writer died in the middle of writing the
-      // record. Don't report a corruption unless requested.
-      if (*drop_size) {
-        return kBadHeader;
+      if (!retry_after_eof_) {
+        *drop_size = buffer_.size();
+        buffer_.clear();
+        if (!eof_) {
+          return kBadRecordLen;
+        }
+        // If the end of the file has been reached without reading |length|
+        // bytes of payload, assume the writer died in the middle of writing the
+        // record. Don't report a corruption unless requested.
+        if (*drop_size) {
+          return kBadHeader;
+        }
+      } else {
+        int r = kEof;
+        if (!ReadMore(drop_size, &r)) {
+          return r;
+        }
+        continue;
      }
      return kEof;
    }
@@ -395,229 +409,5 @@ unsigned int Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size) {
  }
 }

-bool FragmentBufferedReader::ReadRecord(Slice* record, std::string* scratch,
-                                        WALRecoveryMode /*unused*/) {
-  assert(record != nullptr);
-  assert(scratch != nullptr);
-  record->clear();
-  scratch->clear();
-
-  uint64_t prospective_record_offset = 0;
-  uint64_t physical_record_offset = end_of_buffer_offset_ - buffer_.size();
-  size_t drop_size = 0;
-  unsigned int fragment_type_or_err = 0;  // Initialize to make compiler happy
-  Slice fragment;
-  while (TryReadFragment(&fragment, &drop_size, &fragment_type_or_err)) {
-    switch (fragment_type_or_err) {
-      case kFullType:
-      case kRecyclableFullType:
-        if (in_fragmented_record_ && !fragments_.empty()) {
-          ReportCorruption(fragments_.size(), "partial record without end(1)");
-        }
-        fragments_.clear();
-        *record = fragment;
-        prospective_record_offset = physical_record_offset;
-        last_record_offset_ = prospective_record_offset;
-        in_fragmented_record_ = false;
-        return true;
-
-      case kFirstType:
-      case kRecyclableFirstType:
-        if (in_fragmented_record_ || !fragments_.empty()) {
-          ReportCorruption(fragments_.size(), "partial record without end(2)");
-        }
-        prospective_record_offset = physical_record_offset;
-        fragments_.assign(fragment.data(), fragment.size());
-        in_fragmented_record_ = true;
-        break;
-
-      case kMiddleType:
-      case kRecyclableMiddleType:
-        if (!in_fragmented_record_) {
-          ReportCorruption(fragment.size(),
-                           "missing start of fragmented record(1)");
-        } else {
-          fragments_.append(fragment.data(), fragment.size());
-        }
-        break;
-
-      case kLastType:
-      case kRecyclableLastType:
-        if (!in_fragmented_record_) {
-          ReportCorruption(fragment.size(),
-                           "missing start of fragmented record(2)");
-        } else {
-          fragments_.append(fragment.data(), fragment.size());
-          scratch->assign(fragments_.data(), fragments_.size());
-          fragments_.clear();
-          *record = Slice(*scratch);
-          last_record_offset_ = prospective_record_offset;
-          in_fragmented_record_ = false;
-          return true;
-        }
-        break;
-
-      case kBadHeader:
-      case kBadRecord:
-      case kEof:
-      case kOldRecord:
-        if (in_fragmented_record_) {
-          ReportCorruption(fragments_.size(), "error in middle of record");
-          in_fragmented_record_ = false;
-          fragments_.clear();
-        }
-        break;
-
-      case kBadRecordChecksum:
-        if (recycled_) {
-          fragments_.clear();
-          return false;
-        }
-        ReportCorruption(drop_size, "checksum mismatch");
-        if (in_fragmented_record_) {
-          ReportCorruption(fragments_.size(), "error in middle of record");
-          in_fragmented_record_ = false;
-          fragments_.clear();
-        }
-        break;
-
-      default: {
-        char buf[40];
-        snprintf(buf, sizeof(buf), "unknown record type %u",
-                 fragment_type_or_err);
-        ReportCorruption(
-            fragment.size() + (in_fragmented_record_ ? fragments_.size() : 0),
-            buf);
-        in_fragmented_record_ = false;
-        fragments_.clear();
-        break;
-      }
-    }
-  }
-  return false;
-}
-
-void FragmentBufferedReader::UnmarkEOF() {
-  if (read_error_) {
-    return;
-  }
-  eof_ = false;
-  UnmarkEOFInternal();
-}
-
-bool FragmentBufferedReader::TryReadMore(size_t* drop_size, int* error) {
-  if (!eof_ && !read_error_) {
-    // Last read was a full read, so this is a trailer to skip
-    buffer_.clear();
-    Status status = file_->Read(kBlockSize, &buffer_, backing_store_);
-    end_of_buffer_offset_ += buffer_.size();
-    if (!status.ok()) {
-      buffer_.clear();
-      ReportDrop(kBlockSize, status);
-      read_error_ = true;
-      *error = kEof;
-      return false;
-    } else if (buffer_.size() < static_cast<size_t>(kBlockSize)) {
-      eof_ = true;
-      eof_offset_ = buffer_.size();
-      TEST_SYNC_POINT_CALLBACK(
-          "FragmentBufferedLogReader::TryReadMore:FirstEOF", nullptr);
-    }
-    return true;
-  } else if (!read_error_) {
-    UnmarkEOF();
-  }
-  if (!read_error_) {
-    return true;
-  }
-  *error = kEof;
-  *drop_size = buffer_.size();
-  if (buffer_.size() > 0) {
-    *error = kBadHeader;
-  }
-  buffer_.clear();
-  return false;
-}
-
-// return true if the caller should process the fragment_type_or_err.
-bool FragmentBufferedReader::TryReadFragment(
-    Slice* fragment, size_t* drop_size, unsigned int* fragment_type_or_err) {
-  assert(fragment != nullptr);
-  assert(drop_size != nullptr);
-  assert(fragment_type_or_err != nullptr);
-
-  while (buffer_.size() < static_cast<size_t>(kHeaderSize)) {
-    size_t old_size = buffer_.size();
-    int error = kEof;
-    if (!TryReadMore(drop_size, &error)) {
-      *fragment_type_or_err = error;
-      return false;
-    } else if (old_size == buffer_.size()) {
-      return false;
-    }
-  }
-  const char* header = buffer_.data();
-  const uint32_t a = static_cast<uint32_t>(header[4]) & 0xff;
-  const uint32_t b = static_cast<uint32_t>(header[5]) & 0xff;
-  const unsigned int type = header[6];
-  const uint32_t length = a | (b << 8);
-  int header_size = kHeaderSize;
-  if (type >= kRecyclableFullType && type <= kRecyclableLastType) {
-    if (end_of_buffer_offset_ - buffer_.size() == 0) {
-      recycled_ = true;
-    }
-    header_size = kRecyclableHeaderSize;
-    while (buffer_.size() < static_cast<size_t>(kRecyclableHeaderSize)) {
-      size_t old_size = buffer_.size();
-      int error = kEof;
-      if (!TryReadMore(drop_size, &error)) {
-        *fragment_type_or_err = error;
-        return false;
-      } else if (old_size == buffer_.size()) {
-        return false;
-      }
-    }
-    const uint32_t log_num = DecodeFixed32(header + 7);
-    if (log_num != log_number_) {
-      *fragment_type_or_err = kOldRecord;
-      return true;
-    }
-  }
-
-  while (header_size + length > buffer_.size()) {
-    size_t old_size = buffer_.size();
-    int error = kEof;
-    if (!TryReadMore(drop_size, &error)) {
-      *fragment_type_or_err = error;
-      return false;
-    } else if (old_size == buffer_.size()) {
-      return false;
-    }
-  }
-
-  if (type == kZeroType && length == 0) {
-    buffer_.clear();
-    *fragment_type_or_err = kBadRecord;
-    return true;
-  }
-
-  if (checksum_) {
-    uint32_t expected_crc = crc32c::Unmask(DecodeFixed32(header));
-    uint32_t actual_crc = crc32c::Value(header + 6, length + header_size - 6);
-    if (actual_crc != expected_crc) {
-      *drop_size = buffer_.size();
-      buffer_.clear();
-      *fragment_type_or_err = kBadRecordChecksum;
-      return true;
-    }
-  }
-
-  buffer_.remove_prefix(header_size + length);
-
-  *fragment = Slice(header + header_size, length);
-  *fragment_type_or_err = type;
-  return true;
-}
-
 }  // namespace log
 }  // namespace rocksdb
@@ -20,6 +20,7 @@ namespace rocksdb {

 class SequentialFileReader;
 class Logger;
+using std::unique_ptr;

 namespace log {

@@ -52,18 +53,18 @@ class Reader {
  Reader(std::shared_ptr<Logger> info_log,
         // @lint-ignore TXT2 T25377293 Grandfathered in
         std::unique_ptr<SequentialFileReader>&& file, Reporter* reporter,
-         bool checksum, uint64_t log_num);
+         bool checksum, uint64_t log_num, bool retry_after_eof);

-  virtual ~Reader();
+  ~Reader();

  // Read the next record into *record.  Returns true if read
  // successfully, false if we hit end of the input.  May use
  // "*scratch" as temporary storage.  The contents filled in *record
  // will only be valid until the next mutating operation on this
  // reader or the next mutation to *scratch.
-  virtual bool ReadRecord(Slice* record, std::string* scratch,
-                          WALRecoveryMode wal_recovery_mode =
-                              WALRecoveryMode::kTolerateCorruptedTailRecords);
+  bool ReadRecord(Slice* record, std::string* scratch,
+                  WALRecoveryMode wal_recovery_mode =
+                      WALRecoveryMode::kTolerateCorruptedTailRecords);

  // Returns the physical offset of the last record returned by ReadRecord.
  //
@@ -75,28 +76,21 @@ class Reader {
    return eof_;
  }

-  // returns true if the reader has encountered read error.
-  bool hasReadError() const { return read_error_; }
-
  // when we know more data has been written to the file. we can use this
  // function to force the reader to look again in the file.
  // Also aligns the file position indicator to the start of the next block
  // by reading the rest of the data from the EOF position to the end of the
  // block that was partially read.
-  virtual void UnmarkEOF();
+  void UnmarkEOF();

  SequentialFileReader* file() { return file_.get(); }

-  Reporter* GetReporter() const { return reporter_; }
-
- protected:
+ private:
  std::shared_ptr<Logger> info_log_;
  const std::unique_ptr<SequentialFileReader> file_;
  Reporter* const reporter_;
  bool const checksum_;
  char* const backing_store_;
-
-  // Internal state variables used for reading records
  Slice buffer_;
  bool eof_;   // Last Read() indicated EOF by returning < kBlockSize
  bool read_error_;   // Error occurred while reading from file
@@ -116,6 +110,11 @@ class Reader {
  // Whether this is a recycled log file
  bool recycled_;

+  // Whether retry after encountering EOF
+  // TODO (yanqin) add support for retry policy, e.g. sleep, max retry limit,
+  // etc.
+  const bool retry_after_eof_;
+
  // Extend record types with the following special values
  enum {
    kEof = kMaxRecordType + 1,
@@ -140,47 +139,15 @@ class Reader {
  // Read some more
  bool ReadMore(size_t* drop_size, int *error);

-  void UnmarkEOFInternal();
-
  // Reports dropped bytes to the reporter.
  // buffer_ must be updated to remove the dropped bytes prior to invocation.
  void ReportCorruption(size_t bytes, const char* reason);
  void ReportDrop(size_t bytes, const Status& reason);

- private:
  // No copying allowed
  Reader(const Reader&);
  void operator=(const Reader&);
 };

-class FragmentBufferedReader : public Reader {
- public:
-  FragmentBufferedReader(std::shared_ptr<Logger> info_log,
-                         // @lint-ignore TXT2 T25377293 Grandfathered in
-                         std::unique_ptr<SequentialFileReader>&& _file,
-                         Reporter* reporter, bool checksum, uint64_t log_num)
-      : Reader(info_log, std::move(_file), reporter, checksum, log_num),
-        fragments_(),
-        in_fragmented_record_(false) {}
-  ~FragmentBufferedReader() override {}
-  bool ReadRecord(Slice* record, std::string* scratch,
-                  WALRecoveryMode wal_recovery_mode =
-                      WALRecoveryMode::kTolerateCorruptedTailRecords) override;
-  void UnmarkEOF() override;
-
- private:
-  std::string fragments_;
-  bool in_fragmented_record_;
-
-  bool TryReadFragment(Slice* result, size_t* drop_size,
-                       unsigned int* fragment_type_or_err);
-
-  bool TryReadMore(size_t* drop_size, int* error);
-
-  // No copy allowed
-  FragmentBufferedReader(const FragmentBufferedReader&);
-  void operator=(const FragmentBufferedReader&);
-};
-
 }  // namespace log
 }  // namespace rocksdb
@@ -43,10 +43,7 @@ static std::string RandomSkewedString(int i, Random* rnd) {
  return BigString(NumberString(i), rnd->Skewed(17));
 }

-// Param type is tuple<int, bool>
-// get<0>(tuple): non-zero if recycling log, zero if regular log
-// get<1>(tuple): true if allow retry after read EOF, false otherwise
-class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
+class LogTest : public ::testing::TestWithParam<int> {
 private:
  class StringSource : public SequentialFile {
   public:
@@ -56,20 +53,16 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
    bool force_eof_;
    size_t force_eof_position_;
    bool returned_partial_;
-    bool fail_after_read_partial_;
-    explicit StringSource(Slice& contents, bool fail_after_read_partial)
-        : contents_(contents),
-          force_error_(false),
-          force_error_position_(0),
-          force_eof_(false),
-          force_eof_position_(0),
-          returned_partial_(false),
-          fail_after_read_partial_(fail_after_read_partial) {}
+    explicit StringSource(Slice& contents) :
+      contents_(contents),
+      force_error_(false),
+      force_error_position_(0),
+      force_eof_(false),
+      force_eof_position_(0),
+      returned_partial_(false) { }

-    Status Read(size_t n, Slice* result, char* scratch) override {
-      if (fail_after_read_partial_) {
-        EXPECT_TRUE(!returned_partial_) << "must not Read() after eof/error";
-      }
+    virtual Status Read(size_t n, Slice* result, char* scratch) override {
+      EXPECT_TRUE(!returned_partial_) << "must not Read() after eof/error";

      if (force_error_) {
        if (force_error_position_ >= n) {
@@ -107,7 +100,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
      return Status::OK();
    }

-    Status Skip(uint64_t n) override {
+    virtual Status Skip(uint64_t n) override {
      if (n > contents_.size()) {
        contents_.clear();
        return Status::NotFound("in-memory file skipepd past end");
@@ -125,7 +118,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
    std::string message_;

    ReportCollector() : dropped_bytes_(0) { }
-    void Corruption(size_t bytes, const Status& status) override {
+    virtual void Corruption(size_t bytes, const Status& status) override {
      dropped_bytes_ += bytes;
      message_.append(status.ToString());
    }
@@ -146,7 +139,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
  }

  void reset_source_contents() {
-    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
+    auto src = dynamic_cast<StringSource*>(reader_.file()->file());
    assert(src);
    src->contents_ = dest_contents();
  }
@@ -156,10 +149,11 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
  std::unique_ptr<SequentialFileReader> source_holder_;
  ReportCollector report_;
  Writer writer_;
-  std::unique_ptr<Reader> reader_;
+  Reader reader_;

- protected:
-  bool allow_retry_read_;
+  // Record metadata for testing initial offset functionality
+  static size_t initial_offset_record_sizes_[];
+  uint64_t initial_offset_last_record_offsets_[4];

 public:
  LogTest()
@@ -167,18 +161,18 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
        dest_holder_(test::GetWritableFileWriter(
            new test::StringSink(&reader_contents_), "" /* don't care */)),
        source_holder_(test::GetSequentialFileReader(
-            new StringSource(reader_contents_, !std::get<1>(GetParam())),
-            "" /* file name */)),
-        writer_(std::move(dest_holder_), 123, std::get<0>(GetParam())),
-        allow_retry_read_(std::get<1>(GetParam())) {
-    if (allow_retry_read_) {
-      reader_.reset(new FragmentBufferedReader(
-          nullptr, std::move(source_holder_), &report_, true /* checksum */,
-          123 /* log_number */));
-    } else {
-      reader_.reset(new Reader(nullptr, std::move(source_holder_), &report_,
-                               true /* checksum */, 123 /* log_number */));
-    }
+            new StringSource(reader_contents_), "" /* file name */)),
+        writer_(std::move(dest_holder_), 123, GetParam()),
+        reader_(nullptr, std::move(source_holder_), &report_,
+                true /* checksum */, 123 /* log_number */,
+                false /* retry_after_eof */) {
+    int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
+    initial_offset_last_record_offsets_[0] = 0;
+    initial_offset_last_record_offsets_[1] = header_size + 10000;
+    initial_offset_last_record_offsets_[2] = 2 * (header_size + 10000);
+    initial_offset_last_record_offsets_[3] = 2 * (header_size + 10000) +
+                                             (2 * log::kBlockSize - 1000) +
+                                             3 * header_size;
  }

  Slice* get_reader_contents() { return &reader_contents_; }
@@ -195,9 +189,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
                       WALRecoveryMode::kTolerateCorruptedTailRecords) {
    std::string scratch;
    Slice record;
-    bool ret = false;
-    ret = reader_->ReadRecord(&record, &scratch, wal_recovery_mode);
-    if (ret) {
+    if (reader_.ReadRecord(&record, &scratch, wal_recovery_mode)) {
      return record.ToString();
    } else {
      return "EOF";
@@ -229,7 +221,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
  }

  void ForceError(size_t position = 0) {
-    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
+    auto src = dynamic_cast<StringSource*>(reader_.file()->file());
    src->force_error_ = true;
    src->force_error_position_ = position;
  }
@@ -243,18 +235,20 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
  }

  void ForceEOF(size_t position = 0) {
-    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
+    auto src = dynamic_cast<StringSource*>(reader_.file()->file());
    src->force_eof_ = true;
    src->force_eof_position_ = position;
  }

  void UnmarkEOF() {
-    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
+    auto src = dynamic_cast<StringSource*>(reader_.file()->file());
    src->returned_partial_ = false;
-    reader_->UnmarkEOF();
+    reader_.UnmarkEOF();
  }

-  bool IsEOF() { return reader_->IsEOF(); }
+  bool IsEOF() {
+    return reader_.IsEOF();
+  }

  // Returns OK iff recorded error message contains "msg"
  std::string MatchError(const std::string& msg) const {
@@ -264,8 +258,23 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
      return "OK";
    }
  }
+
+  void WriteInitialOffsetLog() {
+    for (int i = 0; i < 4; i++) {
+      std::string record(initial_offset_record_sizes_[i],
+                         static_cast<char>('a' + i));
+      Write(record);
+    }
+  }
+
 };

+size_t LogTest::initial_offset_record_sizes_[] =
+    {10000,  // Two sizable records in first block
+     10000,
+     2 * log::kBlockSize - 1000,  // Span three blocks
+     1};
+
 TEST_P(LogTest, Empty) { ASSERT_EQ("EOF", Read()); }

 TEST_P(LogTest, ReadWrite) {
@@ -303,8 +312,7 @@ TEST_P(LogTest, Fragmentation) {

 TEST_P(LogTest, MarginalTrailer) {
  // Make a trailer that is exactly the same length as an empty record.
-  int header_size =
-      std::get<0>(GetParam()) ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
  const int n = kBlockSize - 2 * header_size;
  Write(BigString("foo", n));
  ASSERT_EQ((unsigned int)(kBlockSize - header_size), WrittenBytes());
@@ -318,8 +326,7 @@ TEST_P(LogTest, MarginalTrailer) {

 TEST_P(LogTest, MarginalTrailer2) {
  // Make a trailer that is exactly the same length as an empty record.
-  int header_size =
-      std::get<0>(GetParam()) ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
  const int n = kBlockSize - 2 * header_size;
  Write(BigString("foo", n));
  ASSERT_EQ((unsigned int)(kBlockSize - header_size), WrittenBytes());
@@ -332,8 +339,7 @@ TEST_P(LogTest, MarginalTrailer2) {
 }

 TEST_P(LogTest, ShortTrailer) {
-  int header_size =
-      std::get<0>(GetParam()) ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
  const int n = kBlockSize - 2 * header_size + 4;
  Write(BigString("foo", n));
  ASSERT_EQ((unsigned int)(kBlockSize - header_size + 4), WrittenBytes());
@@ -346,8 +352,7 @@ TEST_P(LogTest, ShortTrailer) {
 }

 TEST_P(LogTest, AlignedEof) {
-  int header_size =
-      std::get<0>(GetParam()) ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
  const int n = kBlockSize - 2 * header_size + 4;
  Write(BigString("foo", n));
  ASSERT_EQ((unsigned int)(kBlockSize - header_size + 4), WrittenBytes());
@@ -398,11 +403,6 @@ TEST_P(LogTest, TruncatedTrailingRecordIsIgnored) {
 }

 TEST_P(LogTest, TruncatedTrailingRecordIsNotIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then truncated trailing record should not
-    // raise an error.
-    return;
-  }
  Write("foo");
  ShrinkSize(4);  // Drop all payload as well as a header byte
  ASSERT_EQ("EOF", Read(WALRecoveryMode::kAbsoluteConsistency));
@@ -412,20 +412,13 @@ TEST_P(LogTest, TruncatedTrailingRecordIsNotIgnored) {
 }

 TEST_P(LogTest, BadLength) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then we should not raise an error when the
-    // record length specified in header is longer than data currently
-    // available. It's possible that the body of the record is not written yet.
-    return;
-  }
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  int header_size = recyclable_log ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
  const int kPayloadSize = kBlockSize - header_size;
  Write(BigString("bar", kPayloadSize));
  Write("foo");
  // Least significant size byte is stored in header[4].
  IncrementByte(4, 1);
-  if (!recyclable_log) {
+  if (!GetParam()) {
    ASSERT_EQ("foo", Read());
    ASSERT_EQ(kBlockSize, DroppedBytes());
    ASSERT_EQ("OK", MatchError("bad record length"));
@@ -435,12 +428,6 @@ TEST_P(LogTest, BadLength) {
 }

 TEST_P(LogTest, BadLengthAtEndIsIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then we should not raise an error when the
-    // record length specified in header is longer than data currently
-    // available. It's possible that the body of the record is not written yet.
-    return;
-  }
  Write("foo");
  ShrinkSize(1);
  ASSERT_EQ("EOF", Read());
@@ -449,12 +436,6 @@ TEST_P(LogTest, BadLengthAtEndIsIgnored) {
 }

 TEST_P(LogTest, BadLengthAtEndIsNotIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then we should not raise an error when the
-    // record length specified in header is longer than data currently
-    // available. It's possible that the body of the record is not written yet.
-    return;
-  }
  Write("foo");
  ShrinkSize(1);
  ASSERT_EQ("EOF", Read(WALRecoveryMode::kAbsoluteConsistency));
@@ -466,8 +447,7 @@ TEST_P(LogTest, ChecksumMismatch) {
  Write("foooooo");
  IncrementByte(0, 14);
  ASSERT_EQ("EOF", Read());
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  if (!recyclable_log) {
+  if (!GetParam()) {
    ASSERT_EQ(14U, DroppedBytes());
    ASSERT_EQ("OK", MatchError("checksum mismatch"));
  } else {
@@ -478,10 +458,8 @@ TEST_P(LogTest, ChecksumMismatch) {

 TEST_P(LogTest, UnexpectedMiddleType) {
  Write("foo");
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  SetByte(6, static_cast<char>(recyclable_log ? kRecyclableMiddleType
-                                              : kMiddleType));
-  FixChecksum(0, 3, !!recyclable_log);
+  SetByte(6, static_cast<char>(GetParam() ? kRecyclableMiddleType : kMiddleType));
+  FixChecksum(0, 3, !!GetParam());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3U, DroppedBytes());
  ASSERT_EQ("OK", MatchError("missing start"));
@@ -489,10 +467,8 @@ TEST_P(LogTest, UnexpectedMiddleType) {

 TEST_P(LogTest, UnexpectedLastType) {
  Write("foo");
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  SetByte(6,
-          static_cast<char>(recyclable_log ? kRecyclableLastType : kLastType));
-  FixChecksum(0, 3, !!recyclable_log);
+  SetByte(6, static_cast<char>(GetParam() ? kRecyclableLastType : kLastType));
+  FixChecksum(0, 3, !!GetParam());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3U, DroppedBytes());
  ASSERT_EQ("OK", MatchError("missing start"));
@@ -501,10 +477,8 @@ TEST_P(LogTest, UnexpectedLastType) {
 TEST_P(LogTest, UnexpectedFullType) {
  Write("foo");
  Write("bar");
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  SetByte(
-      6, static_cast<char>(recyclable_log ? kRecyclableFirstType : kFirstType));
-  FixChecksum(0, 3, !!recyclable_log);
+  SetByte(6, static_cast<char>(GetParam() ? kRecyclableFirstType : kFirstType));
+  FixChecksum(0, 3, !!GetParam());
  ASSERT_EQ("bar", Read());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3U, DroppedBytes());
@@ -514,10 +488,8 @@ TEST_P(LogTest, UnexpectedFullType) {
 TEST_P(LogTest, UnexpectedFirstType) {
  Write("foo");
  Write(BigString("bar", 100000));
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  SetByte(
-      6, static_cast<char>(recyclable_log ? kRecyclableFirstType : kFirstType));
-  FixChecksum(0, 3, !!recyclable_log);
+  SetByte(6, static_cast<char>(GetParam() ? kRecyclableFirstType : kFirstType));
+  FixChecksum(0, 3, !!GetParam());
  ASSERT_EQ(BigString("bar", 100000), Read());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3U, DroppedBytes());
@@ -534,11 +506,6 @@ TEST_P(LogTest, MissingLastIsIgnored) {
 }

 TEST_P(LogTest, MissingLastIsNotIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then truncated trailing record should not
-    // raise an error.
-    return;
-  }
  Write(BigString("bar", kBlockSize));
  // Remove the LAST block, including header.
  ShrinkSize(14);
@@ -557,11 +524,6 @@ TEST_P(LogTest, PartialLastIsIgnored) {
 }

 TEST_P(LogTest, PartialLastIsNotIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then truncated trailing record should not
-    // raise an error.
-    return;
-  }
  Write(BigString("bar", kBlockSize));
  // Cause a bad record length in the LAST block.
  ShrinkSize(1);
@@ -588,8 +550,7 @@ TEST_P(LogTest, ErrorJoinsRecords) {
    SetByte(offset, 'x');
  }

-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  if (!recyclable_log) {
+  if (!GetParam()) {
    ASSERT_EQ("correct", Read());
    ASSERT_EQ("EOF", Read());
    size_t dropped = DroppedBytes();
@@ -603,8 +564,7 @@ TEST_P(LogTest, ErrorJoinsRecords) {
 TEST_P(LogTest, ClearEofSingleBlock) {
  Write("foo");
  Write("bar");
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  int header_size = recyclable_log ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
  ForceEOF(3 + header_size + 2);
  ASSERT_EQ("foo", Read());
  UnmarkEOF();
@@ -619,8 +579,7 @@ TEST_P(LogTest, ClearEofSingleBlock) {

 TEST_P(LogTest, ClearEofMultiBlock) {
  size_t num_full_blocks = 5;
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  int header_size = recyclable_log ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
  size_t n = (kBlockSize - header_size) * num_full_blocks + 25;
  Write(BigString("foo", n));
  Write(BigString("bar", n));
@@ -669,8 +628,7 @@ TEST_P(LogTest, ClearEofError2) {
 }

 TEST_P(LogTest, Recycle) {
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  if (!recyclable_log) {
+  if (!GetParam()) {
    return;  // test is only valid for recycled logs
  }
  Write("foo");
@@ -693,11 +651,7 @@ TEST_P(LogTest, Recycle) {
  ASSERT_EQ("EOF", Read());
 }

-INSTANTIATE_TEST_CASE_P(bool, LogTest,
-                        ::testing::Values(std::make_tuple(0, false),
-                                          std::make_tuple(0, true),
-                                          std::make_tuple(1, false),
-                                          std::make_tuple(1, true)));
+INSTANTIATE_TEST_CASE_P(bool, LogTest, ::testing::Values(0, 2));

 class RetriableLogTest : public ::testing::TestWithParam<int> {
 private:
@@ -707,7 +661,7 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
    std::string message_;

    ReportCollector() : dropped_bytes_(0) {}
-    void Corruption(size_t bytes, const Status& status) override {
+    virtual void Corruption(size_t bytes, const Status& status) override {
      dropped_bytes_ += bytes;
      message_.append(status.ToString());
    }
@@ -723,7 +677,7 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
  std::unique_ptr<WritableFileWriter> writer_;
  std::unique_ptr<SequentialFileReader> reader_;
  ReportCollector report_;
-  std::unique_ptr<FragmentBufferedReader> log_reader_;
+  std::unique_ptr<Reader> log_reader_;

 public:
  RetriableLogTest()
@@ -762,9 +716,9 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
    if (s.ok()) {
      reader_.reset(new SequentialFileReader(std::move(seq_file), log_file_));
      assert(reader_ != nullptr);
-      log_reader_.reset(new FragmentBufferedReader(
-          nullptr, std::move(reader_), &report_, true /* checksum */,
-          123 /* log_number */));
+      log_reader_.reset(new Reader(nullptr, std::move(reader_), &report_,
+                                   true /* checksum */, 123 /* log_number */,
+                                   true /* retry_after_eof */));
      assert(log_reader_ != nullptr);
    }
    return s;
@@ -784,17 +738,14 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
    writer_->Sync(true);
  }

-  bool TryRead(std::string* result) {
-    assert(result != nullptr);
-    result->clear();
+  std::string Read() {
+    auto wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
    std::string scratch;
    Slice record;
-    bool r = log_reader_->ReadRecord(&record, &scratch);
-    if (r) {
-      result->assign(record.data(), record.size());
-      return true;
+    if (log_reader_->ReadRecord(&record, &scratch, wal_recovery_mode)) {
+      return record.ToString();
    } else {
-      return false;
+      return "Read error";
    }
  }
 };
@@ -803,17 +754,12 @@ TEST_P(RetriableLogTest, TailLog_PartialHeader) {
  ASSERT_OK(SetupTestEnv());
  std::vector<int> remaining_bytes_in_last_record;
  size_t header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
-  bool eof = false;
  SyncPoint::GetInstance()->DisableProcessing();
  SyncPoint::GetInstance()->LoadDependency(
      {{"RetriableLogTest::TailLog:AfterPart1",
        "RetriableLogTest::TailLog:BeforeReadRecord"},
-       {"FragmentBufferedLogReader::TryReadMore:FirstEOF",
+       {"LogReader::ReadMore:FirstEOF",
        "RetriableLogTest::TailLog:BeforePart2"}});
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "FragmentBufferedLogReader::TryReadMore:FirstEOF",
-      [&](void* /*arg*/) { eof = true; });
  SyncPoint::GetInstance()->EnableProcessing();

  size_t delta = header_size - 1;
@@ -833,30 +779,23 @@ TEST_P(RetriableLogTest, TailLog_PartialHeader) {
  std::string record;
  port::Thread log_reader_thread([&]() {
    TEST_SYNC_POINT("RetriableLogTest::TailLog:BeforeReadRecord");
-    while (!TryRead(&record)) {
-    }
+    record = Read();
  });
  log_reader_thread.join();
  log_writer_thread.join();
  ASSERT_EQ("foo", record);
-  ASSERT_TRUE(eof);
 }

 TEST_P(RetriableLogTest, TailLog_FullHeader) {
  ASSERT_OK(SetupTestEnv());
  std::vector<int> remaining_bytes_in_last_record;
  size_t header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
-  bool eof = false;
  SyncPoint::GetInstance()->DisableProcessing();
  SyncPoint::GetInstance()->LoadDependency(
      {{"RetriableLogTest::TailLog:AfterPart1",
        "RetriableLogTest::TailLog:BeforeReadRecord"},
-       {"FragmentBufferedLogReader::TryReadMore:FirstEOF",
+       {"LogReader::ReadMore:FirstEOF",
        "RetriableLogTest::TailLog:BeforePart2"}});
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "FragmentBufferedLogReader::TryReadMore:FirstEOF",
-      [&](void* /*arg*/) { eof = true; });
  SyncPoint::GetInstance()->EnableProcessing();

  size_t delta = header_size + 1;
@@ -871,45 +810,18 @@ TEST_P(RetriableLogTest, TailLog_FullHeader) {
    TEST_SYNC_POINT("RetriableLogTest::TailLog:AfterPart1");
    TEST_SYNC_POINT("RetriableLogTest::TailLog:BeforePart2");
    Write(Slice(part2));
-    ASSERT_TRUE(eof);
  });

  std::string record;
  port::Thread log_reader_thread([&]() {
    TEST_SYNC_POINT("RetriableLogTest::TailLog:BeforeReadRecord");
-    while (!TryRead(&record)) {
-    }
+    record = Read();
  });
  log_reader_thread.join();
  log_writer_thread.join();
  ASSERT_EQ("foo", record);
 }

-TEST_P(RetriableLogTest, NonBlockingReadFullRecord) {
-  // Clear all sync point callbacks even if this test does not use sync point.
-  // It is necessary, otherwise the execute of this test may hit a sync point
-  // with which a callback is registered. The registered callback may access
-  // some dead variable, causing segfault.
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  ASSERT_OK(SetupTestEnv());
-  size_t header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
-  size_t delta = header_size - 1;
-  size_t old_sz = contents().size();
-  Encode("foo-bar");
-  size_t new_sz = contents().size();
-  std::string part1 = contents().substr(old_sz, delta);
-  std::string part2 =
-      contents().substr(old_sz + delta, new_sz - old_sz - delta);
-  Write(Slice(part1));
-  std::string record;
-  ASSERT_FALSE(TryRead(&record));
-  ASSERT_TRUE(record.empty());
-  Write(Slice(part2));
-  ASSERT_TRUE(TryRead(&record));
-  ASSERT_EQ("foo-bar", record);
-}
-
 INSTANTIATE_TEST_CASE_P(bool, RetriableLogTest, ::testing::Values(0, 2));

 }  // namespace log
@@ -18,7 +18,7 @@
 namespace rocksdb {
 namespace log {

-Writer::Writer(std::unique_ptr<WritableFileWriter>&& dest, uint64_t log_number,
+Writer::Writer(unique_ptr<WritableFileWriter>&& dest, uint64_t log_number,
               bool recycle_log_files, bool manual_flush)
    : dest_(std::move(dest)),
      block_offset_(0),
@@ -20,6 +20,8 @@ namespace rocksdb {

 class WritableFileWriter;

+using std::unique_ptr;
+
 namespace log {

 /**
@@ -70,9 +72,8 @@ class Writer {
  // Create a writer that will append data to "*dest".
  // "*dest" must be initially empty.
  // "*dest" must remain live while this Writer is in use.
-  explicit Writer(std::unique_ptr<WritableFileWriter>&& dest,
-                  uint64_t log_number, bool recycle_log_files,
-                  bool manual_flush = false);
+  explicit Writer(unique_ptr<WritableFileWriter>&& dest, uint64_t log_number,
+                  bool recycle_log_files, bool manual_flush = false);
  ~Writer();

  Status AddRecord(const Slice& slice);
@@ -51,13 +51,15 @@ class DestroyAllCompactionFilter : public CompactionFilter {
 public:
  DestroyAllCompactionFilter() {}

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

-  const char* Name() const override { return "DestroyAllCompactionFilter"; }
+  virtual const char* Name() const override {
+    return "DestroyAllCompactionFilter";
+  }
 };

 TEST_F(ManualCompactionTest, CompactTouchesAllKeys) {
@@ -35,6 +35,7 @@
 #include "util/autovector.h"
 #include "util/coding.h"
 #include "util/memory_usage.h"
+#include "util/murmurhash.h"
 #include "util/mutexlock.h"
 #include "util/util.h"

@@ -50,8 +51,6 @@ ImmutableMemTableOptions::ImmutableMemTableOptions(
              mutable_cf_options.memtable_prefix_bloom_size_ratio) *
          8u),
      memtable_huge_page_size(mutable_cf_options.memtable_huge_page_size),
-      memtable_whole_key_filtering(
-          mutable_cf_options.memtable_whole_key_filtering),
      inplace_update_support(ioptions.inplace_update_support),
      inplace_update_num_locks(mutable_cf_options.inplace_update_num_locks),
      inplace_callback(ioptions.inplace_callback),
@@ -110,10 +109,8 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
  // something went wrong if we need to flush before inserting anything
  assert(!ShouldScheduleFlush());

-  // use bloom_filter_ for both whole key and prefix bloom filter
-  if ((prefix_extractor_ || moptions_.memtable_whole_key_filtering) &&
-      moptions_.memtable_prefix_bloom_bits > 0) {
-    bloom_filter_.reset(
+  if (prefix_extractor_ && moptions_.memtable_prefix_bloom_bits > 0) {
+    prefix_bloom_.reset(
        new DynamicBloom(&arena_, moptions_.memtable_prefix_bloom_bits,
                         ioptions.bloom_locality, 6 /* hard coded 6 probes */,
                         moptions_.memtable_huge_page_size, ioptions.info_log));
@@ -285,14 +282,14 @@ class MemTableIterator : public InternalIterator {
    if (use_range_del_table) {
      iter_ = mem.range_del_table_->GetIterator(arena);
    } else if (prefix_extractor_ != nullptr && !read_options.total_order_seek) {
-      bloom_ = mem.bloom_filter_.get();
+      bloom_ = mem.prefix_bloom_.get();
      iter_ = mem.table_->GetDynamicPrefixIterator(arena);
    } else {
      iter_ = mem.table_->GetIterator(arena);
    }
  }

-  ~MemTableIterator() override {
+  ~MemTableIterator() {
 #ifndef NDEBUG
    // Assert that the MemTableIterator is never deleted while
    // Pinning is Enabled.
@@ -306,18 +303,18 @@ class MemTableIterator : public InternalIterator {
  }

 #ifndef NDEBUG
-  void SetPinnedItersMgr(PinnedIteratorsManager* pinned_iters_mgr) override {
+  virtual void SetPinnedItersMgr(
+      PinnedIteratorsManager* pinned_iters_mgr) override {
    pinned_iters_mgr_ = pinned_iters_mgr;
  }
  PinnedIteratorsManager* pinned_iters_mgr_ = nullptr;
 #endif

-  bool Valid() const override { return valid_; }
-  void Seek(const Slice& k) override {
+  virtual bool Valid() const override { return valid_; }
+  virtual void Seek(const Slice& k) override {
    PERF_TIMER_GUARD(seek_on_memtable_time);
    PERF_COUNTER_ADD(seek_on_memtable_count, 1);
-    if (bloom_) {
-      // iterator should only use prefix bloom filter
+    if (bloom_ != nullptr) {
      if (!bloom_->MayContain(
              prefix_extractor_->Transform(ExtractUserKey(k)))) {
        PERF_COUNTER_ADD(bloom_memtable_miss_count, 1);
@@ -330,10 +327,10 @@ class MemTableIterator : public InternalIterator {
    iter_->Seek(k, nullptr);
    valid_ = iter_->Valid();
  }
-  void SeekForPrev(const Slice& k) override {
+  virtual void SeekForPrev(const Slice& k) override {
    PERF_TIMER_GUARD(seek_on_memtable_time);
    PERF_COUNTER_ADD(seek_on_memtable_count, 1);
-    if (bloom_) {
+    if (bloom_ != nullptr) {
      if (!bloom_->MayContain(
              prefix_extractor_->Transform(ExtractUserKey(k)))) {
        PERF_COUNTER_ADD(bloom_memtable_miss_count, 1);
@@ -352,44 +349,44 @@ class MemTableIterator : public InternalIterator {
      Prev();
    }
  }
-  void SeekToFirst() override {
+  virtual void SeekToFirst() override {
    iter_->SeekToFirst();
    valid_ = iter_->Valid();
  }
-  void SeekToLast() override {
+  virtual void SeekToLast() override {
    iter_->SeekToLast();
    valid_ = iter_->Valid();
  }
-  void Next() override {
+  virtual void Next() override {
    PERF_COUNTER_ADD(next_on_memtable_count, 1);
    assert(Valid());
    iter_->Next();
    valid_ = iter_->Valid();
  }
-  void Prev() override {
+  virtual void Prev() override {
    PERF_COUNTER_ADD(prev_on_memtable_count, 1);
    assert(Valid());
    iter_->Prev();
    valid_ = iter_->Valid();
  }
-  Slice key() const override {
+  virtual Slice key() const override {
    assert(Valid());
    return GetLengthPrefixedSlice(iter_->key());
  }
-  Slice value() const override {
+  virtual Slice value() const override {
    assert(Valid());
    Slice key_slice = GetLengthPrefixedSlice(iter_->key());
    return GetLengthPrefixedSlice(key_slice.data() + key_slice.size());
  }

-  Status status() const override { return Status::OK(); }
+  virtual Status status() const override { return Status::OK(); }

-  bool IsKeyPinned() const override {
+  virtual bool IsKeyPinned() const override {
    // memtable data is always pinned
    return true;
  }

-  bool IsValuePinned() const override {
+  virtual bool IsValuePinned() const override {
    // memtable value is always pinned, except if we allow inplace update.
    return value_pinned_;
  }
@@ -437,7 +434,8 @@ FragmentedRangeTombstoneIterator* MemTable::NewRangeTombstoneIterator(
 }

 port::RWMutex* MemTable::GetLock(const Slice& key) {
-  return &locks_[static_cast<size_t>(GetSliceNPHash64(key)) % locks_.size()];
+  static murmur_hash hash;
+  return &locks_[hash(key) % locks_.size()];
 }

 MemTable::MemTableStats MemTable::ApproximateStats(const Slice& start_ikey,
@@ -518,11 +516,9 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
                         std::memory_order_relaxed);
    }

-    if (bloom_filter_ && prefix_extractor_) {
-      bloom_filter_->Add(prefix_extractor_->Transform(key));
-    }
-    if (bloom_filter_ && moptions_.memtable_whole_key_filtering) {
-      bloom_filter_->Add(key);
+    if (prefix_bloom_) {
+      assert(prefix_extractor_);
+      prefix_bloom_->Add(prefix_extractor_->Transform(key));
    }

    // The first sequence number inserted into the memtable
@@ -551,11 +547,9 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
      post_process_info->num_deletes++;
    }

-    if (bloom_filter_ && prefix_extractor_) {
-      bloom_filter_->AddConcurrently(prefix_extractor_->Transform(key));
-    }
-    if (bloom_filter_ && moptions_.memtable_whole_key_filtering) {
-      bloom_filter_->AddConcurrently(key);
+    if (prefix_bloom_) {
+      assert(prefix_extractor_);
+      prefix_bloom_->AddConcurrently(prefix_extractor_->Transform(key));
    }

    // atomically update first_seqno_ and earliest_seqno_.
@@ -762,24 +756,16 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
  Slice user_key = key.user_key();
  bool found_final_value = false;
  bool merge_in_progress = s->IsMergeInProgress();
-  bool may_contain = true;
-  if (bloom_filter_) {
-    // when both memtable_whole_key_filtering and prefix_extractor_ are set,
-    // only do whole key filtering for Get() to save CPU
-    if (moptions_.memtable_whole_key_filtering) {
-      may_contain = bloom_filter_->MayContain(user_key);
-    } else {
-      assert(prefix_extractor_);
-      may_contain =
-          bloom_filter_->MayContain(prefix_extractor_->Transform(user_key));
-    }
-  }
-  if (bloom_filter_ && !may_contain) {
+  bool const may_contain =
+      nullptr == prefix_bloom_
+          ? false
+          : prefix_bloom_->MayContain(prefix_extractor_->Transform(user_key));
+  if (prefix_bloom_ && !may_contain) {
    // iter is null if prefix bloom says the key does not exist
    PERF_COUNTER_ADD(bloom_memtable_miss_count, 1);
    *seq = kMaxSequenceNumber;
  } else {
-    if (bloom_filter_) {
+    if (prefix_bloom_) {
      PERF_COUNTER_ADD(bloom_memtable_hit_count, 1);
    }
    Saver saver;
@@ -41,7 +41,6 @@ struct ImmutableMemTableOptions {
  size_t arena_block_size;
  uint32_t memtable_prefix_bloom_bits;
  size_t memtable_huge_page_size;
-  bool memtable_whole_key_filtering;
  bool inplace_update_support;
  size_t inplace_update_num_locks;
  UpdateStatus (*inplace_callback)(char* existing_value,
@@ -266,16 +265,12 @@ class MemTable {
    return num_deletes_.load(std::memory_order_relaxed);
  }

-  uint64_t get_data_size() const {
-    return data_size_.load(std::memory_order_relaxed);
-  }
-
  // Dynamically change the memtable's capacity. If set below the current usage,
  // the next key added will trigger a flush. Can only increase size when
  // memtable prefix bloom is disabled, since we can't easily allocate more
  // space.
  void UpdateWriteBufferSize(size_t new_write_buffer_size) {
-    if (bloom_filter_ == nullptr ||
+    if (prefix_bloom_ == nullptr ||
        new_write_buffer_size < write_buffer_size_) {
      write_buffer_size_.store(new_write_buffer_size,
                               std::memory_order_relaxed);
@@ -455,7 +450,7 @@ class MemTable {
  std::vector<port::RWMutex> locks_;

  const SliceTransform* const prefix_extractor_;
-  std::unique_ptr<DynamicBloom> bloom_filter_;
+  std::unique_ptr<DynamicBloom> prefix_bloom_;

  std::atomic<FlushStateEnum> flush_state_;

@@ -533,7 +533,7 @@ Status InstallMemtableAtomicFlushResults(
    const autovector<ColumnFamilyData*>& cfds,
    const autovector<const MutableCFOptions*>& mutable_cf_options_list,
    const autovector<const autovector<MemTable*>*>& mems_list, VersionSet* vset,
-    InstrumentedMutex* mu, const autovector<FileMetaData*>& file_metas,
+    InstrumentedMutex* mu, const autovector<FileMetaData>& file_metas,
    autovector<MemTable*>* to_delete, Directory* db_directory,
    LogBuffer* log_buffer) {
  AutoThreadOperationStageUpdater stage_updater(
@@ -553,11 +553,10 @@ Status InstallMemtableAtomicFlushResults(
      assert((*mems_list[k])[0]->GetID() == imm->GetEarliestMemTableID());
    }
 #endif
-    assert(nullptr != file_metas[k]);
    for (size_t i = 0; i != mems_list[k]->size(); ++i) {
      assert(i == 0 || (*mems_list[k])[i]->GetEdits()->NumEntries() == 0);
      (*mems_list[k])[i]->SetFlushCompleted(true);
-      (*mems_list[k])[i]->SetFileNumber(file_metas[k]->fd.GetNumber());
+      (*mems_list[k])[i]->SetFileNumber(file_metas[k].fd.GetNumber());
    }
  }

@@ -573,15 +572,12 @@ Status InstallMemtableAtomicFlushResults(
    ++num_entries;
    edit_lists.emplace_back(edits);
  }
-  // Mark the version edits as an atomic group if the number of version edits
-  // exceeds 1.
-  if (cfds.size() > 1) {
-    for (auto& edits : edit_lists) {
-      assert(edits.size() == 1);
-      edits[0]->MarkAtomicGroup(--num_entries);
-    }
-    assert(0 == num_entries);
+  // Mark the version edits as an atomic group
+  for (auto& edits : edit_lists) {
+    assert(edits.size() == 1);
+    edits[0]->MarkAtomicGroup(--num_entries);
  }
+  assert(0 == num_entries);

  // this can release and reacquire the mutex.
  s = vset->LogAndApply(cfds, mutable_cf_options_list, edit_lists, mu,
@@ -123,7 +123,7 @@ class MemTableListVersion {
      const autovector<const MutableCFOptions*>& mutable_cf_options_list,
      const autovector<const autovector<MemTable*>*>& mems_list,
      VersionSet* vset, InstrumentedMutex* mu,
-      const autovector<FileMetaData*>& file_meta,
+      const autovector<FileMetaData>& file_meta,
      autovector<MemTable*>* to_delete, Directory* db_directory,
      LogBuffer* log_buffer);

@@ -301,7 +301,7 @@ class MemTableList {
      const autovector<const MutableCFOptions*>& mutable_cf_options_list,
      const autovector<const autovector<MemTable*>*>& mems_list,
      VersionSet* vset, InstrumentedMutex* mu,
-      const autovector<FileMetaData*>& file_meta,
+      const autovector<FileMetaData>& file_meta,
      autovector<MemTable*>* to_delete, Directory* db_directory,
      LogBuffer* log_buffer);

@@ -337,7 +337,7 @@ extern Status InstallMemtableAtomicFlushResults(
    const autovector<ColumnFamilyData*>& cfds,
    const autovector<const MutableCFOptions*>& mutable_cf_options_list,
    const autovector<const autovector<MemTable*>*>& mems_list, VersionSet* vset,
-    InstrumentedMutex* mu, const autovector<FileMetaData*>& file_meta,
+    InstrumentedMutex* mu, const autovector<FileMetaData>& file_meta,
    autovector<MemTable*>* to_delete, Directory* db_directory,
    LogBuffer* log_buffer);
 }  // namespace rocksdb
@@ -62,7 +62,7 @@ class MemTableListTest : public testing::Test {
    }
  }

-  ~MemTableListTest() override {
+  ~MemTableListTest() {
    if (db) {
      std::vector<ColumnFamilyDescriptor> cf_descs(handles.size());
      for (int i = 0; i != static_cast<int>(handles.size()); ++i) {
@@ -161,23 +161,18 @@ class MemTableListTest : public testing::Test {
      cfds.emplace_back(column_family_set->GetColumnFamily(cf_ids[i]));
      EXPECT_NE(nullptr, cfds[i]);
    }
-    std::vector<FileMetaData> file_metas;
-    file_metas.reserve(cf_ids.size());
+    autovector<FileMetaData> file_metas;
    for (size_t i = 0; i != cf_ids.size(); ++i) {
      FileMetaData meta;
      uint64_t file_num = file_number.fetch_add(1);
      meta.fd = FileDescriptor(file_num, 0, 0);
      file_metas.emplace_back(meta);
    }
-    autovector<FileMetaData*> file_meta_ptrs;
-    for (auto& meta : file_metas) {
-      file_meta_ptrs.push_back(&meta);
-    }
    InstrumentedMutex mutex;
    InstrumentedMutexLock l(&mutex);
    return InstallMemtableAtomicFlushResults(
        &lists, cfds, mutable_cf_options_list, mems_list, &versions, &mutex,
-        file_meta_ptrs, to_delete, nullptr, &log_buffer);
+        file_metas, to_delete, nullptr, &log_buffer);
  }
 };

--- a/Show More
+++ b/Show More