Fix build on MSVC

Snappy must be built with position independent code for static linking
RocksJava must compile on JDK7 (#4768 )
2026-11-07 11:32:34 -05:00 · 2020-03-07 17:58:42 +01:00 · 2020-03-07 13:56:13 +01:00 · 2020-03-07 13:31:52 +01:00 · 2020-03-07 13:08:19 +01:00 · 2020-03-06 22:29:05 +01:00
487 changed files with 24419 additions and 32173 deletions
@@ -71,7 +71,10 @@ install:
      CC=gcc-8 && CXX=g++-8;
    fi
  - if [[ "${JOB_NAME}" == cmake* ]] && [ "${TRAVIS_OS_NAME}" == linux ]; then
-      mkdir cmake-dist && curl -sfSL https://cmake.org/files/v3.8/cmake-3.8.1-Linux-x86_64.tar.gz | tar --strip-components=1 -C cmake-dist -xz && export PATH=$PWD/cmake-dist/bin:$PATH;
+      mkdir cmake-dist && curl --silent --fail --show-error --location https://github.com/Kitware/CMake/releases/download/v3.14.5/cmake-3.14.5-Linux-x86_64.tar.gz | tar --strip-components=1 -C cmake-dist -xz && export PATH=$PWD/cmake-dist/bin:$PATH;
+    fi
+  - if [[ "${JOB_NAME}" == java_test ]]; then
+      java -version && echo "JAVA_HOME=${JAVA_HOME}";
    fi

 before_script:
@@ -94,13 +94,7 @@ else()
  if(WITH_ZLIB)
    find_package(zlib REQUIRED)
    add_definitions(-DZLIB)
-    if(ZLIB_INCLUDE_DIRS)
-      # CMake 3
-      include_directories(${ZLIB_INCLUDE_DIRS})
-    else()
-      # CMake 2
-      include_directories(${ZLIB_INCLUDE_DIR})
-    endif()
+    include_directories(${ZLIB_INCLUDE_DIR})
    list(APPEND THIRDPARTY_LIBS ${ZLIB_LIBRARIES})
  endif()

@@ -501,7 +495,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
@@ -531,6 +524,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
@@ -602,7 +596,6 @@ set(SOURCES
        util/comparator.cc
        util/compression_context_cache.cc
        util/concurrent_arena.cc
-        util/concurrent_task_limiter_impl.cc
        util/crc32c.cc
        util/delete_scheduler.cc
        util/dynamic_bloom.cc
@@ -643,11 +636,20 @@ set(SOURCES
        utilities/cassandra/format.cc
        utilities/cassandra/merge_operator.cc
        utilities/checkpoint/checkpoint_impl.cc
+        utilities/col_buf_decoder.cc
+        utilities/col_buf_encoder.cc
+        utilities/column_aware_encoding_util.cc
        utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc
+        utilities/date_tiered/date_tiered_db_impl.cc
        utilities/debug.cc
+        utilities/document/document_db.cc
+        utilities/document/json_document.cc
+        utilities/document/json_document_builder.cc
        utilities/env_mirror.cc
        utilities/env_timed.cc
+        utilities/geodb/geodb_impl.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
@@ -662,7 +664,9 @@ set(SOURCES
        utilities/persistent_cache/block_cache_tier_metadata.cc
        utilities/persistent_cache/persistent_cache_tier.cc
        utilities/persistent_cache/volatile_tier_impl.cc
+        utilities/redis/redis_lists.cc
        utilities/simulator_cache/sim_cache.cc
+        utilities/spatialdb/spatial_db.cc
        utilities/table_properties_collectors/compact_on_deletion_collector.cc
        utilities/trace/file_trace_reader_writer.cc
        utilities/transactions/optimistic_transaction_db_impl.cc
@@ -818,7 +822,6 @@ if(NOT WIN32 OR ROCKSDB_INSTALL_ON_WINDOWS)
    TARGETS ${ROCKSDB_SHARED_LIB}
    EXPORT RocksDBTargets
    COMPONENT runtime
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
@@ -964,6 +967,12 @@ if(WITH_TESTS)
        utilities/cassandra/cassandra_row_merge_test.cc
        utilities/cassandra/cassandra_serialize_test.cc
        utilities/checkpoint/checkpoint_test.cc
+        utilities/column_aware_encoding_test.cc
+        utilities/date_tiered/date_tiered_test.cc
+        utilities/document/document_db_test.cc
+        utilities/document/json_document_test.cc
+        utilities/geodb/geodb_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
@@ -971,6 +980,8 @@ if(WITH_TESTS)
        utilities/options/options_util_test.cc
        utilities/persistent_cache/hash_table_test.cc
        utilities/persistent_cache/persistent_cache_test.cc
+        utilities/redis/redis_lists_test.cc
+        utilities/spatialdb/spatial_db_test.cc
        utilities/simulator_cache/sim_cache_test.cc
        utilities/table_properties_collectors/compact_on_deletion_collector_test.cc
        utilities/transactions/optimistic_transaction_test.cc
@@ -990,6 +1001,7 @@ if(WITH_TESTS)
    db/range_del_aggregator_bench.cc
    tools/db_bench.cc
    table/table_reader_bench.cc
+    utilities/column_aware_encoding_exp.cc
    utilities/persistent_cache/hash_table_bench.cc)
  add_library(testharness OBJECT util/testharness.cc)
  foreach(sourcefile ${BENCHMARKS})
@@ -1,64 +1,17 @@
 # Rocksdb Change Log
-
-## 6.0.2 (4/23/2019)
-## Bug Fixes
-* Fix build failures due to missing JEMALLOC_CXX_THROW macro (#5053)
-* Fix compilation on db_bench_tool.cc on Windows (#5227)
-
-## 6.0.1 (3/26/2019)
-### New Features
-### Public API Change
-* Added many new features to the Java API to bring it closer to the C++ API.
-
-### Bug Fixes
-* Make BlobDB wait for all background tasks on shutdown.
-* Fixed a BlobDB issue where some trash files are not tracked causing them to remain forever.
-
-### Bug Fixes
+## 5.18.4 (3/3/2020)
+* Various fixes for ARM64 support (#6250)
 * Fix JEMALLOC_CXX_THROW macro missing from older Jemalloc versions, causing build failures on some platforms.

+## 5.18.3 (2/11/2019)
+### Bug Fixes
+* Fix possible LSM corruption when both range deletions and subcompactions are used. The symptom of this corruption is L1+ files overlapping in the user key space.

-## 6.0.0 (2/19/2019)
-### New Features
-* Enabled checkpoint on readonly db (DBImplReadOnly).
-* Make DB ignore dropped column families while committing results of atomic flush.
-* RocksDB may choose to preopen some files even if options.max_open_files != -1. This may make DB open slightly longer.
-* 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`.
+## 5.18.2 (01/31/2019)

 ### 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.
-* Remove geodb, spatial_db, document_db, json_document, date_tiered_db, and redis_lists.
-* 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.
-
-### Bug Fixes
-* Fix a deadlock caused by compaction and file ingestion waiting for each other in the event of write stalls.
-* Fix a memory leak when files with range tombstones are read in mmap mode and block cache is enabled
-* Fix handling of corrupt range tombstone blocks such that corruptions cannot cause deleted keys to reappear
-* Lock free MultiGet
-* Fix incorrect `NotFound` point lookup result when querying the endpoint of a file that has been extended by a range tombstone.
-* Fix with pipelined write, write leaders's callback failure lead to the whole write group fail.
-
-### Change Default Options
-* Change options.compaction_pri's default to kMinOverlappingRatio

 ## 5.18.0 (11/30/2018)
 ### New Features
@@ -71,6 +24,7 @@
 * Add xxhash64 checksum support
 * Introduced `MemoryAllocator`, which lets the user specify custom memory allocator for block based table.
 * Improved `DeleteRange` to prevent read performance degradation. The feature is no longer marked as experimental.
+* Enabled checkpoint on readonly db (DBImplReadOnly).

 ### Public API Change
 * `DBOptions::use_direct_reads` now affects reads issued by `BackupEngine` on the database's SSTs.
@@ -87,6 +41,8 @@
 * Fixed Get correctness bug in the presence of range tombstones where merge operands covered by a range tombstone always result in NotFound.
 * Start populating `NO_FILE_CLOSES` ticker statistic, which was always zero previously.
 * The default value of NewBloomFilterPolicy()'s argument use_block_based_builder is changed to false. Note that this new default may cause large temp memory usage when building very large SST files.
+* Fix a deadlock caused by compaction and file ingestion waiting for each other in the event of write stalls.
+* Make DB ignore dropped column families while committing results of atomic flush.

 ## 5.17.0 (10/05/2018)
 ### Public API Change
@@ -137,6 +137,12 @@ CFLAGS +=  -DHAVE_POWER8
 HAVE_POWER8=1
 endif

+ifeq (,$(shell $(CXX) -fsyntax-only -march=armv8-a+crc -xc /dev/null 2>&1))
+CXXFLAGS += -march=armv8-a+crc
+CFLAGS += -march=armv8-a+crc
+ARMCRC_SOURCE=1
+endif
+
 # if we're compiling for release, compile without debug code (-DNDEBUG)
 ifeq ($(DEBUG_LEVEL),0)
 OPT += -DNDEBUG
@@ -198,7 +204,7 @@ include make_config.mk
 CLEAN_FILES += make_config.mk

 missing_make_config_paths := $(shell				\
-	grep "\./\S*\|/\S*" -o $(CURDIR)/make_config.mk | 	\
+	grep "\/\S*" -o $(CURDIR)/make_config.mk | 		\
 	while read path;					\
 		do [ -e $$path ] || echo $$path; 		\
 	done | sort | uniq)
@@ -403,7 +409,7 @@ BENCHTOOLOBJECTS = $(BENCH_LIB_SOURCES:.cc=.o) $(LIBOBJECTS) $(TESTUTIL)

 ANALYZETOOLOBJECTS = $(ANALYZER_LIB_SOURCES:.cc=.o)

-EXPOBJECTS = $(LIBOBJECTS) $(TESTUTIL)
+EXPOBJECTS = $(EXP_LIB_SOURCES:.cc=.o) $(LIBOBJECTS) $(TESTUTIL)

 TESTS = \
 	db_basic_test \
@@ -482,6 +488,7 @@ TESTS = \
 	merger_test \
 	util_merge_operators_test \
 	options_file_test \
+	redis_test \
 	reduce_levels_test \
 	plain_table_db_test \
 	comparator_db_test \
@@ -495,8 +502,12 @@ TESTS = \
 	cassandra_row_merge_test \
 	cassandra_serialize_test \
 	ttl_test \
+	date_tiered_test \
 	backupable_db_test \
+	document_db_test \
+	json_document_test \
 	sim_cache_test \
+	spatial_db_test \
 	version_edit_test \
 	version_set_test \
 	compaction_picker_test \
@@ -508,6 +519,7 @@ TESTS = \
 	deletefile_test \
 	obsolete_files_test \
 	table_test \
+	geodb_test \
 	delete_scheduler_test \
 	options_test \
 	options_settable_test \
@@ -524,6 +536,7 @@ TESTS = \
 	compaction_job_test \
 	thread_list_test \
 	sst_dump_test \
+	column_aware_encoding_test \
 	compact_files_test \
 	optimistic_transaction_test \
 	write_callback_test \
@@ -535,6 +548,7 @@ TESTS = \
 	ldb_cmd_test \
 	persistent_cache_test \
 	statistics_test \
+	lua_test \
 	lru_cache_test \
 	object_registry_test \
 	repair_test \
@@ -596,7 +610,7 @@ TEST_LIBS = \
 	librocksdb_env_basic_test.a

 # TODO: add back forward_iterator_bench, after making it build in all environemnts.
-BENCHMARKS = db_bench table_reader_bench cache_bench memtablerep_bench persistent_cache_bench range_del_aggregator_bench
+BENCHMARKS = db_bench table_reader_bench cache_bench memtablerep_bench column_aware_encoding_exp persistent_cache_bench range_del_aggregator_bench

 # if user didn't config LIBNAME, set the default
 ifeq ($(LIBNAME),)
@@ -686,8 +700,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)
@@ -817,6 +830,7 @@ J ?= 100%
 # Use this regexp to select the subset of tests whose names match.
 tests-regexp = .

+t_run = $(wildcard t/run-*)
 .PHONY: check_0
 check_0:
 	$(AM_V_GEN)export TEST_TMPDIR=$(TMPD); \
@@ -826,7 +840,7 @@ check_0:
 	test -t 1 && eta=--eta || eta=; \
 	{ \
 		printf './%s\n' $(filter-out $(PARALLEL_TEST),$(TESTS)); \
-		find t -name 'run-*' -print; \
+		printf '%s\n' $(t_run); \
 	} \
 	  | $(prioritize_long_running_tests)				\
 	  | grep -E '$(tests-regexp)'					\
@@ -843,7 +857,7 @@ valgrind_check_0:
 	test -t 1 && eta=--eta || eta=;					\
 	{								\
 	  printf './%s\n' $(filter-out $(PARALLEL_TEST) %skiplist_test options_settable_test, $(TESTS));		\
-	  find t -name 'run-*' -print; \
+	  printf '%s\n' $(t_run);					\
 	}								\
 	  | $(prioritize_long_running_tests)				\
 	  | grep -E '$(tests-regexp)'					\
@@ -895,14 +909,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
@@ -911,12 +921,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
@@ -928,11 +936,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
@@ -943,11 +946,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

@@ -1161,6 +1159,9 @@ cassandra_row_merge_test: utilities/cassandra/cassandra_row_merge_test.o utiliti
 cassandra_serialize_test: utilities/cassandra/cassandra_serialize_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

+redis_test: utilities/redis/redis_lists_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(AM_LINK)
+
 hash_table_test: utilities/persistent_cache/hash_table_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1299,9 +1300,18 @@ backupable_db_test: utilities/backupable/backupable_db_test.o $(LIBOBJECTS) $(TE
 checkpoint_test: utilities/checkpoint/checkpoint_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

+document_db_test: utilities/document/document_db_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(AM_LINK)
+
+json_document_test: utilities/document/json_document_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(AM_LINK)
+
 sim_cache_test: utilities/simulator_cache/sim_cache_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

+spatial_db_test: utilities/spatialdb/spatial_db_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(AM_LINK)
+
 env_mirror_test: utilities/env_mirror_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1319,6 +1329,9 @@ object_registry_test: utilities/object_registry_test.o $(LIBOBJECTS) $(TESTHARNE
 ttl_test: utilities/ttl/ttl_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

+date_tiered_test: utilities/date_tiered/date_tiered_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(AM_LINK)
+
 write_batch_with_index_test: utilities/write_batch_with_index/write_batch_with_index_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1445,6 +1458,9 @@ deletefile_test: db/deletefile_test.o $(LIBOBJECTS) $(TESTHARNESS)
 obsolete_files_test: db/obsolete_files_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

+geodb_test: utilities/geodb/geodb_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(AM_LINK)
+
 rocksdb_dump: tools/dump/rocksdb_dump.o $(LIBOBJECTS)
 	$(AM_LINK)

@@ -1493,6 +1509,9 @@ timer_queue_test: util/timer_queue_test.o $(LIBOBJECTS) $(TESTHARNESS)
 sst_dump_test: tools/sst_dump_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

+column_aware_encoding_test: utilities/column_aware_encoding_test.o $(TESTHARNESS) $(EXPOBJECTS)
+	$(AM_LINK)
+
 optimistic_transaction_test: utilities/transactions/optimistic_transaction_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1532,6 +1551,9 @@ sst_dump: tools/sst_dump.o $(LIBOBJECTS)
 blob_dump: tools/blob_dump.o $(LIBOBJECTS)
 	$(AM_LINK)

+column_aware_encoding_exp: utilities/column_aware_encoding_exp.o $(EXPOBJECTS)
+	$(AM_LINK)
+
 repair_test: db/repair_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1553,6 +1575,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)

@@ -1616,7 +1641,7 @@ JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/linux
 ifeq ($(PLATFORM), OS_SOLARIS)
 	ARCH := $(shell isainfo -b)
 else ifeq ($(PLATFORM), OS_OPENBSD)
-	ifneq (,$(filter $(MACHINE), amd64 arm64 sparc64))
+	ifneq (,$(filter amd64 ppc64 ppc64le arm64 aarch64 sparc64, $(MACHINE)))
 		ARCH := 64
 	else
 		ARCH := 32
@@ -1625,10 +1650,10 @@ else
 	ARCH := $(shell getconf LONG_BIT)
 endif

-ifeq (,$(findstring ppc,$(MACHINE)))
-        ROCKSDBJNILIB = librocksdbjni-linux$(ARCH).so
+ifneq (,$(filter ppc% arm64 aarch64 sparc64, $(MACHINE)))
+	ROCKSDBJNILIB = librocksdbjni-linux-$(MACHINE).so
 else
-        ROCKSDBJNILIB = librocksdbjni-linux-$(MACHINE).so
+	ROCKSDBJNILIB = librocksdbjni-linux$(ARCH).so
 endif
 ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-linux$(ARCH).jar
 ROCKSDB_JAR_ALL = rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH).jar
@@ -1641,15 +1666,15 @@ ZLIB_SHA256 ?= c3e5e9fdd5004dcb542feda5ee4f0ff0744628baf8ed2dd5d66f8ca1197cb1a1
 ZLIB_DOWNLOAD_BASE ?= http://zlib.net
 BZIP2_VER ?= 1.0.6
 BZIP2_SHA256 ?= a2848f34fcd5d6cf47def00461fcb528a0484d8edef8208d6d2e2909dc61d9cd
-BZIP2_DOWNLOAD_BASE ?= https://web.archive.org/web/20180624184835/http://www.bzip.org
-SNAPPY_VER ?= 1.1.7
-SNAPPY_SHA256 ?= 3dfa02e873ff51a11ee02b9ca391807f0c8ea0529a4924afa645fbf97163f9d4
+BZIP2_DOWNLOAD_BASE ?= https://downloads.sourceforge.net/project/bzip2
+SNAPPY_VER ?= 1.1.8
+SNAPPY_SHA256 ?= 16b677f07832a612b0836178db7f374e414f94657c138e6993cbfc5dcc58651f
 SNAPPY_DOWNLOAD_BASE ?= https://github.com/google/snappy/archive
-LZ4_VER ?= 1.8.3
-LZ4_SHA256 ?= 33af5936ac06536805f9745e0b6d61da606a1f8b4cc5c04dd3cbaca3b9b4fc43
+LZ4_VER ?= 1.9.2
+LZ4_SHA256 ?= 658ba6191fa44c92280d4aa2c271b0f4fbc0e34d249578dd05e50e76d0e5efcc
 LZ4_DOWNLOAD_BASE ?= https://github.com/lz4/lz4/archive
-ZSTD_VER ?= 1.3.7
-ZSTD_SHA256 ?= 5dd1e90eb16c25425880c8a91327f63de22891ffed082fcc17e5ae84fce0d5fb
+ZSTD_VER ?= 1.4.4
+ZSTD_SHA256 ?= a364f5162c7d1a455cc915e8e3cf5f4bd8b75d09bc0f53965b0c9ca1383c52c8
 ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive
 CURL_SSL_OPTS ?= --tlsv1

@@ -1689,7 +1714,7 @@ endif
 libz.a:
 	-rm -rf zlib-$(ZLIB_VER)
 ifeq (,$(wildcard ./zlib-$(ZLIB_VER).tar.gz))
-	curl --output zlib-$(ZLIB_VER).tar.gz -L ${ZLIB_DOWNLOAD_BASE}/zlib-$(ZLIB_VER).tar.gz
+	curl --fail --output zlib-$(ZLIB_VER).tar.gz --location ${ZLIB_DOWNLOAD_BASE}/zlib-$(ZLIB_VER).tar.gz
 endif
 	ZLIB_SHA256_ACTUAL=`$(SHA256_CMD) zlib-$(ZLIB_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(ZLIB_SHA256)" != "$$ZLIB_SHA256_ACTUAL" ]; then \
@@ -1703,7 +1728,7 @@ endif
 libbz2.a:
 	-rm -rf bzip2-$(BZIP2_VER)
 ifeq (,$(wildcard ./bzip2-$(BZIP2_VER).tar.gz))
-	curl --output bzip2-$(BZIP2_VER).tar.gz -L ${BZIP2_DOWNLOAD_BASE}/$(BZIP2_VER)/bzip2-$(BZIP2_VER).tar.gz
+	curl --fail --output bzip2-$(BZIP2_VER).tar.gz --location ${CURL_SSL_OPTS} ${BZIP2_DOWNLOAD_BASE}/bzip2-$(BZIP2_VER).tar.gz
 endif
 	BZIP2_SHA256_ACTUAL=`$(SHA256_CMD) bzip2-$(BZIP2_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(BZIP2_SHA256)" != "$$BZIP2_SHA256_ACTUAL" ]; then \
@@ -1717,7 +1742,7 @@ endif
 libsnappy.a:
 	-rm -rf snappy-$(SNAPPY_VER)
 ifeq (,$(wildcard ./snappy-$(SNAPPY_VER).tar.gz))
-	curl --output snappy-$(SNAPPY_VER).tar.gz -L ${CURL_SSL_OPTS} ${SNAPPY_DOWNLOAD_BASE}/$(SNAPPY_VER).tar.gz
+	curl --fail --output snappy-$(SNAPPY_VER).tar.gz --location ${CURL_SSL_OPTS} ${SNAPPY_DOWNLOAD_BASE}/$(SNAPPY_VER).tar.gz
 endif
 	SNAPPY_SHA256_ACTUAL=`$(SHA256_CMD) snappy-$(SNAPPY_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(SNAPPY_SHA256)" != "$$SNAPPY_SHA256_ACTUAL" ]; then \
@@ -1732,7 +1757,7 @@ endif
 liblz4.a:
 	-rm -rf lz4-$(LZ4_VER)
 ifeq (,$(wildcard ./lz4-$(LZ4_VER).tar.gz))
-	curl --output lz4-$(LZ4_VER).tar.gz -L ${CURL_SSL_OPTS} ${LZ4_DOWNLOAD_BASE}/v$(LZ4_VER).tar.gz
+	curl --fail --output lz4-$(LZ4_VER).tar.gz --location ${CURL_SSL_OPTS} ${LZ4_DOWNLOAD_BASE}/v$(LZ4_VER).tar.gz
 endif
 	LZ4_SHA256_ACTUAL=`$(SHA256_CMD) lz4-$(LZ4_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(LZ4_SHA256)" != "$$LZ4_SHA256_ACTUAL" ]; then \
@@ -1746,7 +1771,7 @@ endif
 libzstd.a:
 	-rm -rf zstd-$(ZSTD_VER)
 ifeq (,$(wildcard ./zstd-$(ZSTD_VER).tar.gz))
-	curl --output zstd-$(ZSTD_VER).tar.gz -L ${CURL_SSL_OPTS} ${ZSTD_DOWNLOAD_BASE}/v$(ZSTD_VER).tar.gz
+	curl --fail --output zstd-$(ZSTD_VER).tar.gz --location ${CURL_SSL_OPTS} ${ZSTD_DOWNLOAD_BASE}/v$(ZSTD_VER).tar.gz
 endif
 	ZSTD_SHA256_ACTUAL=`$(SHA256_CMD) zstd-$(ZSTD_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(ZSTD_SHA256)" != "$$ZSTD_SHA256_ACTUAL" ]; then \
@@ -1838,6 +1863,14 @@ rocksdbjavastaticdockerppc64le:
 	fi
 	docker start -a rocksdb_linux_ppc64le-be

+rocksdbjavastaticdockerarm64v8:
+	mkdir -p java/target
+	DOCKER_LINUX_ARM64V8_CONTAINER=`docker ps -aqf name=rocksdb_linux_arm64v8-be`; \
+	if [ -z "$$DOCKER_LINUX_ARM64V8_CONTAINER" ]; then \
+		docker container create --attach stdin --attach stdout --attach stderr --volume `pwd`:/rocksdb-host --name rocksdb_linux_arm64v8-be evolvedbinary/rocksjava:centos7_arm64v8-be /rocksdb-host/java/crossbuild/docker-build-linux-centos.sh; \
+	fi
+	docker start -a rocksdb_linux_arm64v8-be
+
 rocksdbjavastaticpublish: rocksdbjavastaticrelease rocksdbjavastaticpublishcentral

 rocksdbjavastaticpublishdocker: rocksdbjavastaticreleasedocker rocksdbjavastaticpublishcentral
@@ -1916,8 +1949,7 @@ commit_prereq: build_tools/rocksdb-lego-determinator \
 ifeq ($(PLATFORM), IOS)
 # For iOS, create universal object files to be used on both the simulator and
 # a device.
-XCODEROOT=$(shell xcode-select -print-path)
-PLATFORMSROOT=$(XCODEROOT)/Platforms
+PLATFORMSROOT=/Applications/Xcode.app/Contents/Developer/Platforms
 SIMULATORROOT=$(PLATFORMSROOT)/iPhoneSimulator.platform/Developer
 DEVICEROOT=$(PLATFORMSROOT)/iPhoneOS.platform/Developer
 IOSVERSION=$(shell defaults read $(PLATFORMSROOT)/iPhoneOS.platform/version CFBundleShortVersionString)
@@ -1954,7 +1986,7 @@ endif
 #  	Source files dependencies detection
 # ---------------------------------------------------------------------------

-all_sources = $(LIB_SOURCES) $(MAIN_SOURCES) $(MOCK_LIB_SOURCES) $(TOOL_LIB_SOURCES) $(BENCH_LIB_SOURCES) $(TEST_LIB_SOURCES) $(ANALYZER_LIB_SOURCES)
+all_sources = $(LIB_SOURCES) $(MAIN_SOURCES) $(MOCK_LIB_SOURCES) $(TOOL_LIB_SOURCES) $(BENCH_LIB_SOURCES) $(TEST_LIB_SOURCES) $(EXP_LIB_SOURCES) $(ANALYZER_LIB_SOURCES)
 DEPFILES = $(all_sources:.cc=.cc.d)

 # Add proper dependency support so changing a .h file forces a .cc file to
@@ -1,10 +1,12 @@
 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() + "/"

-ROCKSDB_COMPILER_FLAGS = [
+BUCK_BINS = "buck-out/gen/" + REPO_PATH
+
+TEST_RUNNER = REPO_PATH + "buckifier/rocks_test_runner.sh"
+
+rocksdb_compiler_flags = [
    "-fno-builtin-memcmp",
    "-DROCKSDB_PLATFORM_POSIX",
    "-DROCKSDB_LIB_IO_POSIX",
@@ -20,7 +22,6 @@ ROCKSDB_COMPILER_FLAGS = [
    "-DBZIP2",
    "-DLZ4",
    "-DZSTD",
-    "-DZSTD_STATIC_LINKING_ONLY",
    "-DGFLAGS=gflags",
    "-DNUMA",
    "-DTBB",
@@ -32,7 +33,7 @@ ROCKSDB_COMPILER_FLAGS = [
    "-Wnarrowing",
 ]

-ROCKSDB_EXTERNAL_DEPS = [
+rocksdb_external_deps = [
    ("bzip2", None, "bz2"),
    ("snappy", None, "snappy"),
    ("zlib", None, "z"),
@@ -44,13 +45,13 @@ ROCKSDB_EXTERNAL_DEPS = [
    ("googletest", None, "gtest"),
 ]

-ROCKSDB_PREPROCESSOR_FLAGS = [
+rocksdb_preprocessor_flags = [
    # Directories with files for #include
    "-I" + REPO_PATH + "include/",
    "-I" + REPO_PATH,
 ]

-ROCKSDB_ARCH_PREPROCESSOR_FLAGS = {
+rocksdb_arch_preprocessor_flags = {
    "x86_64": [
        "-DHAVE_SSE42",
        "-DHAVE_PCLMUL",
@@ -63,15 +64,16 @@ is_opt_mode = build_mode.startswith("opt")

 # -DNDEBUG is added by default in opt mode in fbcode. But adding it twice
 # doesn't harm and avoid forgetting to add it.
-ROCKSDB_COMPILER_FLAGS += (["-DNDEBUG"] if is_opt_mode else [])
+if is_opt_mode:
+    rocksdb_compiler_flags.append("-DNDEBUG")

 sanitizer = read_config("fbcode", "sanitizer")

 # Do not enable jemalloc if sanitizer presents. RocksDB will further detect
 # whether the binary is linked with jemalloc at runtime.
-ROCKSDB_COMPILER_FLAGS += (["-DROCKSDB_JEMALLOC"] if sanitizer == "" else [])
-
-ROCKSDB_EXTERNAL_DEPS += ([("jemalloc", None, "headers")] if sanitizer == "" else [])
+if sanitizer == "":
+    rocksdb_compiler_flags.append("-DROCKSDB_JEMALLOC")
+    rocksdb_external_deps.append(("jemalloc", None, "headers"))

 cpp_library(
    name = "rocksdb_lib",
@@ -110,7 +112,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",
@@ -143,6 +144,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",
@@ -215,7 +217,6 @@ cpp_library(
        "util/comparator.cc",
        "util/compression_context_cache.cc",
        "util/concurrent_arena.cc",
-        "util/concurrent_task_limiter_impl.cc",
        "util/crc32c.cc",
        "util/delete_scheduler.cc",
        "util/dynamic_bloom.cc",
@@ -257,10 +258,16 @@ cpp_library(
        "utilities/checkpoint/checkpoint_impl.cc",
        "utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc",
        "utilities/convenience/info_log_finder.cc",
+        "utilities/date_tiered/date_tiered_db_impl.cc",
        "utilities/debug.cc",
+        "utilities/document/document_db.cc",
+        "utilities/document/json_document.cc",
+        "utilities/document/json_document_builder.cc",
        "utilities/env_mirror.cc",
        "utilities/env_timed.cc",
+        "utilities/geodb/geodb_impl.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",
@@ -275,7 +282,9 @@ cpp_library(
        "utilities/persistent_cache/block_cache_tier_metadata.cc",
        "utilities/persistent_cache/persistent_cache_tier.cc",
        "utilities/persistent_cache/volatile_tier_impl.cc",
+        "utilities/redis/redis_lists.cc",
        "utilities/simulator_cache/sim_cache.cc",
+        "utilities/spatialdb/spatial_db.cc",
        "utilities/table_properties_collectors/compact_on_deletion_collector.cc",
        "utilities/trace/file_trace_reader_writer.cc",
        "utilities/transactions/optimistic_transaction.cc",
@@ -296,11 +305,11 @@ cpp_library(
        "utilities/write_batch_with_index/write_batch_with_index_internal.cc",
    ],
    auto_headers = AutoHeaders.RECURSIVE_GLOB,
-    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+    compiler_flags = rocksdb_compiler_flags,
+    preprocessor_flags = rocksdb_preprocessor_flags,
    deps = [],
-    external_deps = ROCKSDB_EXTERNAL_DEPS,
+    external_deps = rocksdb_external_deps,
 )

 cpp_library(
@@ -313,13 +322,16 @@ cpp_library(
        "util/testharness.cc",
        "util/testutil.cc",
        "utilities/cassandra/test_utils.cc",
+        "utilities/col_buf_decoder.cc",
+        "utilities/col_buf_encoder.cc",
+        "utilities/column_aware_encoding_util.cc",
    ],
    auto_headers = AutoHeaders.RECURSIVE_GLOB,
-    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+    compiler_flags = rocksdb_compiler_flags,
+    preprocessor_flags = rocksdb_preprocessor_flags,
    deps = [":rocksdb_lib"],
-    external_deps = ROCKSDB_EXTERNAL_DEPS,
+    external_deps = rocksdb_external_deps,
 )

 cpp_library(
@@ -330,22 +342,22 @@ cpp_library(
        "util/testutil.cc",
    ],
    auto_headers = AutoHeaders.RECURSIVE_GLOB,
-    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+    compiler_flags = rocksdb_compiler_flags,
+    preprocessor_flags = rocksdb_preprocessor_flags,
    deps = [":rocksdb_lib"],
-    external_deps = ROCKSDB_EXTERNAL_DEPS,
+    external_deps = rocksdb_external_deps,
 )

 cpp_library(
    name = "env_basic_test_lib",
    srcs = ["env/env_basic_test.cc"],
    auto_headers = AutoHeaders.RECURSIVE_GLOB,
-    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+    compiler_flags = rocksdb_compiler_flags,
+    preprocessor_flags = rocksdb_preprocessor_flags,
    deps = [":rocksdb_test_lib"],
-    external_deps = ROCKSDB_EXTERNAL_DEPS,
+    external_deps = rocksdb_external_deps,
 )

 # [test_name, test_src, test_type]
@@ -435,6 +447,11 @@ ROCKS_TESTS = [
        "util/coding_test.cc",
        "serial",
    ],
+    [
+        "column_aware_encoding_test",
+        "utilities/column_aware_encoding_test.cc",
+        "serial",
+    ],
    [
        "column_family_test",
        "db/column_family_test.cc",
@@ -505,6 +522,11 @@ ROCKS_TESTS = [
        "table/data_block_hash_index_test.cc",
        "serial",
    ],
+    [
+        "date_tiered_test",
+        "utilities/date_tiered/date_tiered_test.cc",
+        "serial",
+    ],
    [
        "db_basic_test",
        "db/db_basic_test.cc",
@@ -665,6 +687,11 @@ ROCKS_TESTS = [
        "db/deletefile_test.cc",
        "serial",
    ],
+    [
+        "document_db_test",
+        "utilities/document/document_db_test.cc",
+        "serial",
+    ],
    [
        "dynamic_bloom_test",
        "util/dynamic_bloom_test.cc",
@@ -740,6 +767,11 @@ ROCKS_TESTS = [
        "table/full_filter_block_test.cc",
        "serial",
    ],
+    [
+        "geodb_test",
+        "utilities/geodb/geodb_test.cc",
+        "serial",
+    ],
    [
        "hash_table_test",
        "utilities/persistent_cache/hash_table_test.cc",
@@ -770,6 +802,11 @@ ROCKS_TESTS = [
        "monitoring/iostats_context_test.cc",
        "serial",
    ],
+    [
+        "json_document_test",
+        "utilities/document/json_document_test.cc",
+        "serial",
+    ],
    [
        "ldb_cmd_test",
        "tools/ldb_cmd_test.cc",
@@ -935,6 +972,11 @@ ROCKS_TESTS = [
        "util/slice_transform_test.cc",
        "serial",
    ],
+    [
+        "spatial_db_test",
+        "utilities/spatialdb/spatial_db_test.cc",
+        "serial",
+    ],
    [
        "sst_dump_test",
        "tools/sst_dump_test.cc",
@@ -1060,16 +1102,26 @@ ROCKS_TESTS = [
 # Generate a test rule for each entry in ROCKS_TESTS
 # Do not build the tests in opt mode, since SyncPoint and other test code
 # will not be included.
-[
-    test_binary(
-        parallelism = parallelism,
-        rocksdb_arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-        rocksdb_compiler_flags = ROCKSDB_COMPILER_FLAGS,
-        rocksdb_external_deps = ROCKSDB_EXTERNAL_DEPS,
-        rocksdb_preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
-        test_cc = test_cc,
-        test_name = test_name,
-    )
-    for test_name, test_cc, parallelism in ROCKS_TESTS
-    if not is_opt_mode
-]
+if not is_opt_mode:
+    for test_cfg in ROCKS_TESTS:
+        test_name = test_cfg[0]
+        test_cc = test_cfg[1]
+        ttype = "gtest" if test_cfg[2] == "parallel" else "simple"
+        test_bin = test_name + "_bin"
+
+        cpp_binary(
+            name = test_bin,
+            srcs = [test_cc],
+            arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+            compiler_flags = rocksdb_compiler_flags,
+            preprocessor_flags = rocksdb_preprocessor_flags,
+            deps = [":rocksdb_test_lib"],
+            external_deps = rocksdb_external_deps,
+        )
+
+        custom_unittest(
+            name = test_name,
+            command = [TEST_RUNNER, BUCK_BINS + test_bin],
+            type = ttype,
+            deps = [":" + test_bin],
+        )
@@ -1,15 +1,75 @@
 version: 1.0.{build}
+
 image: Visual Studio 2017
+
+environment:
+  JAVA_HOME: C:\Program Files\Java\jdk1.8.0
+  THIRDPARTY_HOME: $(APPVEYOR_BUILD_FOLDER)\thirdparty
+  SNAPPY_HOME: $(THIRDPARTY_HOME)\snappy-1.1.7
+  SNAPPY_INCLUDE: $(SNAPPY_HOME);$(SNAPPY_HOME)\build
+  SNAPPY_LIB_DEBUG: $(SNAPPY_HOME)\build\Debug\snappy.lib
+  SNAPPY_LIB_RELEASE: $(SNAPPY_HOME)\build\Release\snappy.lib
+  LZ4_HOME: $(THIRDPARTY_HOME)\lz4-1.8.3
+  LZ4_INCLUDE: $(LZ4_HOME)\lib
+  LZ4_LIB_DEBUG: $(LZ4_HOME)\visual\VS2010\bin\x64_Debug\liblz4_static.lib
+  LZ4_LIB_RELEASE: $(LZ4_HOME)\visual\VS2010\bin\x64_Release\liblz4_static.lib
+  ZSTD_HOME: $(THIRDPARTY_HOME)\zstd-1.4.0
+  ZSTD_INCLUDE: $(ZSTD_HOME)\lib;$(ZSTD_HOME)\lib\dictBuilder
+  ZSTD_LIB_DEBUG: $(ZSTD_HOME)\build\VS2010\bin\x64_Debug\libzstd_static.lib
+  ZSTD_LIB_RELEASE: $(ZSTD_HOME)\build\VS2010\bin\x64_Release\libzstd_static.lib
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE_GENERATOR: Visual Studio 14 Win64
+      DEV_ENV: C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.com
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      CMAKE_GENERATOR: Visual Studio 15 Win64
+      DEV_ENV: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE\devenv.com
+
+install:
+  - md %THIRDPARTY_HOME%
+  - echo "Building Snappy dependency..."
+  - cd %THIRDPARTY_HOME%
+  - curl --fail --silent --show-error --output snappy-1.1.7.zip --location https://github.com/google/snappy/archive/1.1.7.zip
+  - unzip snappy-1.1.7.zip
+  - cd snappy-1.1.7
+  - mkdir build
+  - cd build
+  - cmake -G "%CMAKE_GENERATOR%" ..
+  - msbuild Snappy.sln /p:Configuration=Debug /p:Platform=x64
+  - msbuild Snappy.sln /p:Configuration=Release /p:Platform=x64
+  - echo "Building LZ4 dependency..."
+  - cd %THIRDPARTY_HOME%
+  - curl --fail --silent --show-error --output lz4-1.8.3.zip --location https://github.com/lz4/lz4/archive/v1.8.3.zip
+  - unzip lz4-1.8.3.zip
+  - cd lz4-1.8.3\visual\VS2010
+  - ps: $CMD="$Env:DEV_ENV"; & $CMD lz4.sln /upgrade
+  - msbuild lz4.sln /p:Configuration=Debug /p:Platform=x64
+  - msbuild lz4.sln /p:Configuration=Release /p:Platform=x64
+  - echo "Building ZStd dependency..."
+  - cd %THIRDPARTY_HOME%
+  - curl --fail --silent --show-error --output zstd-1.4.0.zip --location https://github.com/facebook/zstd/archive/v1.4.0.zip
+  - unzip zstd-1.4.0.zip
+  - cd zstd-1.4.0\build\VS2010
+  - ps: $CMD="$Env:DEV_ENV"; & $CMD zstd.sln /upgrade
+  - msbuild zstd.sln /p:Configuration=Debug /p:Platform=x64
+  - msbuild zstd.sln /p:Configuration=Release /p:Platform=x64
+
 before_build:
- md %APPVEYOR_BUILD_FOLDER%\build
- cd %APPVEYOR_BUILD_FOLDER%\build
- cmake -G "Visual Studio 15 Win64" -DOPTDBG=1 -DWITH_XPRESS=1 -DPORTABLE=1 -DJNI=1 ..
- cd ..
+  - md %APPVEYOR_BUILD_FOLDER%\build
+  - cd %APPVEYOR_BUILD_FOLDER%\build
+  - cmake -G "%CMAKE_GENERATOR%" -DCMAKE_BUILD_TYPE=Debug -DOPTDBG=1 -DPORTABLE=1 -DSNAPPY=1 -DLZ4=1 -DZSTD=1 -DXPRESS=1 -DJNI=1 ..
+  - cd ..
+
 build:
  project: build\rocksdb.sln
  parallel: true
  verbosity: normal
-test:
-test_script:
- ps: build_tools\run_ci_db_test.ps1 -SuiteRun db_basic_test,db_test2,db_test,env_basic_test,env_test -Concurrency 8
+
+test:
+
+test_script:
+  - ps: build_tools\run_ci_db_test.ps1 -SuiteRun db_basic_test,db_test2,db_test,env_basic_test,env_test,db_merge_operand_test -Concurrency 8
+
+on_failure:
+  - cmd: 7z a build-failed.zip %APPVEYOR_BUILD_FOLDER%\build\ && appveyor PushArtifact build-failed.zip

@@ -3,12 +3,14 @@ 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() + "/"

-ROCKSDB_COMPILER_FLAGS = [
+BUCK_BINS = "buck-out/gen/" + REPO_PATH
+
+TEST_RUNNER = REPO_PATH + "buckifier/rocks_test_runner.sh"
+
+rocksdb_compiler_flags = [
    "-fno-builtin-memcmp",
    "-DROCKSDB_PLATFORM_POSIX",
    "-DROCKSDB_LIB_IO_POSIX",
@@ -24,7 +26,6 @@ ROCKSDB_COMPILER_FLAGS = [
    "-DBZIP2",
    "-DLZ4",
    "-DZSTD",
-    "-DZSTD_STATIC_LINKING_ONLY",
    "-DGFLAGS=gflags",
    "-DNUMA",
    "-DTBB",
@@ -36,7 +37,7 @@ ROCKSDB_COMPILER_FLAGS = [
    "-Wnarrowing",
 ]

-ROCKSDB_EXTERNAL_DEPS = [
+rocksdb_external_deps = [
    ("bzip2", None, "bz2"),
    ("snappy", None, "snappy"),
    ("zlib", None, "z"),
@@ -48,13 +49,13 @@ ROCKSDB_EXTERNAL_DEPS = [
    ("googletest", None, "gtest"),
 ]

-ROCKSDB_PREPROCESSOR_FLAGS = [
+rocksdb_preprocessor_flags = [
    # Directories with files for #include
    "-I" + REPO_PATH + "include/",
    "-I" + REPO_PATH,
 ]

-ROCKSDB_ARCH_PREPROCESSOR_FLAGS = {
+rocksdb_arch_preprocessor_flags = {
    "x86_64": [
        "-DHAVE_SSE42",
        "-DHAVE_PCLMUL",
@@ -67,15 +68,16 @@ is_opt_mode = build_mode.startswith("opt")

 # -DNDEBUG is added by default in opt mode in fbcode. But adding it twice
 # doesn't harm and avoid forgetting to add it.
-ROCKSDB_COMPILER_FLAGS += (["-DNDEBUG"] if is_opt_mode else [])
+if is_opt_mode:
+    rocksdb_compiler_flags.append("-DNDEBUG")

 sanitizer = read_config("fbcode", "sanitizer")

 # Do not enable jemalloc if sanitizer presents. RocksDB will further detect
 # whether the binary is linked with jemalloc at runtime.
-ROCKSDB_COMPILER_FLAGS += (["-DROCKSDB_JEMALLOC"] if sanitizer == "" else [])
-
-ROCKSDB_EXTERNAL_DEPS += ([("jemalloc", None, "headers")] if sanitizer == "" else [])
+if sanitizer == "":
+    rocksdb_compiler_flags.append("-DROCKSDB_JEMALLOC")
+    rocksdb_external_deps.append(("jemalloc", None, "headers"))
 """


@@ -84,11 +86,11 @@ cpp_library(
    name = "{name}",
    srcs = [{srcs}],
    {headers_attr_prefix}headers = {headers},
-    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+    compiler_flags = rocksdb_compiler_flags,
+    preprocessor_flags = rocksdb_preprocessor_flags,
    deps = [{deps}],
-    external_deps = ROCKSDB_EXTERNAL_DEPS,
+    external_deps = rocksdb_external_deps,
 )
 """

@@ -96,11 +98,11 @@ binary_template = """
 cpp_binary(
    name = "%s",
    srcs = [%s],
-    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+    compiler_flags = rocksdb_compiler_flags,
+    preprocessor_flags = rocksdb_preprocessor_flags,
    deps = [%s],
-    external_deps = ROCKSDB_EXTERNAL_DEPS,
+    external_deps = rocksdb_external_deps,
 )
 """

@@ -119,17 +121,27 @@ ROCKS_TESTS = [
 # Generate a test rule for each entry in ROCKS_TESTS
 # Do not build the tests in opt mode, since SyncPoint and other test code
 # will not be included.
-[
-    test_binary(
-        parallelism = parallelism,
-        rocksdb_arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
-        rocksdb_compiler_flags = ROCKSDB_COMPILER_FLAGS,
-        rocksdb_external_deps = ROCKSDB_EXTERNAL_DEPS,
-        rocksdb_preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
-        test_cc = test_cc,
-        test_name = test_name,
-    )
-    for test_name, test_cc, parallelism in ROCKS_TESTS
-    if not is_opt_mode
-]
+if not is_opt_mode:
+    for test_cfg in ROCKS_TESTS:
+        test_name = test_cfg[0]
+        test_cc = test_cfg[1]
+        ttype = "gtest" if test_cfg[2] == "parallel" else "simple"
+        test_bin = test_name + "_bin"
+
+        cpp_binary(
+            name = test_bin,
+            srcs = [test_cc],
+            arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+            compiler_flags = rocksdb_compiler_flags,
+            preprocessor_flags = rocksdb_preprocessor_flags,
+            deps = [":rocksdb_test_lib"],
+            external_deps = rocksdb_external_deps,
+        )
+
+        custom_unittest(
+            name = test_name,
+            command = [TEST_RUNNER, BUCK_BINS + test_bin],
+            type = ttype,
+            deps = [":" + test_bin],
+        )
 """
@@ -97,7 +97,7 @@ function getSteps($applyDiff, $diffID, $username, $test) {
  }

  // fbcode is a sub-repo. We cannot patch until we add it to ignore otherwise
-  // Git thinks it is an uncommitted change.
+  // Git thinks it is an uncommited change.
  $fix_git_ignore = array(
    "name" => "Fix git ignore",
    "shell" => "echo fbcode >> .git/info/exclude",
@@ -56,10 +56,10 @@ if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then
    if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then
      # we need this to build with MySQL. Don't use for other purposes.
      source "$PWD/build_tools/fbcode_config4.8.1.sh"
-    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007" ]; then
-      source "$PWD/build_tools/fbcode_config_platform007.sh"
-    else
+    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_5xx" ]; then
      source "$PWD/build_tools/fbcode_config.sh"
+    else
+      source "$PWD/build_tools/fbcode_config_platform007.sh"
    fi
 fi

@@ -370,16 +370,6 @@ EOF
            # JEMALLOC can be enabled either using the flag (like here) or by
            # providing direct link to the jemalloc library
            WITH_JEMALLOC_FLAG=1
-            # check for JEMALLOC installed with HomeBrew
-            if [ "$PLATFORM" == "OS_MACOSX" ]; then
-                if hash brew 2>/dev/null && brew ls --versions jemalloc > /dev/null; then
-                    JEMALLOC_VER=$(brew ls --versions jemalloc | tail -n 1 | cut -f 2 -d ' ')
-                    JEMALLOC_INCLUDE="-I/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/include"
-                    JEMALLOC_LIB="/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/lib/libjemalloc_pic.a"
-                    PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS $JEMALLOC_LIB"
-                    JAVA_STATIC_LDFLAGS="$JAVA_STATIC_LDFLAGS $JEMALLOC_LIB"
-                fi
-            fi
        fi
    fi
    if ! test $JEMALLOC && ! test $ROCKSDB_DISABLE_TCMALLOC; then
@@ -537,6 +527,8 @@ if test -z "$PORTABLE"; then
  elif test -n "`echo $TARGET_ARCHITECTURE | grep ^arm`"; then
    # TODO: Handle this with approprite options.
    COMMON_FLAGS="$COMMON_FLAGS"
+  elif test -n "`echo $TARGET_ARCHITECTURE | grep ^aarch64`"; then
+    COMMON_FLAGS="$COMMON_FLAGS"
  elif [ "$TARGET_OS" == "IOS" ]; then
    COMMON_FLAGS="$COMMON_FLAGS"
  elif [ "$TARGET_OS" != "AIX" ] && [ "$TARGET_OS" != "SunOS" ]; then
@@ -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],
@@ -51,7 +51,7 @@ if test -z $PIC_BUILD; then
 else
  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd_pic.a"
 fi
-CFLAGS+=" -DZSTD -DZSTD_STATIC_LINKING_ONLY"
+CFLAGS+=" -DZSTD"

 # location of gflags headers and libraries
 GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
@@ -377,7 +377,7 @@ function send_to_ods {
    echo >&2 "ERROR: Key $key doesn't have a value."
    return
  fi
-  curl -s "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build$git_br&key=$key&value=$value" \
+  curl --silent "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build$git_br&key=$key&value=$value" \
    --connect-timeout 60
 }

@@ -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
@@ -741,7 +646,7 @@ run_regression()

  # parameters: $1 -- key, $2 -- value
  function send_size_to_ods {
-    curl -s "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=rocksdb.build_size.$1&value=$2" \
+    curl --silent "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=rocksdb.build_size.$1&value=$2" \
      --connect-timeout 60
  }

@@ -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();
@@ -240,29 +240,32 @@ class ClockCacheShard : public CacheShard {
  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;
@@ -682,31 +685,31 @@ class ClockCache : 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_;
@@ -15,7 +15,7 @@ namespace rocksdb {
 class LRUCacheTest : public testing::Test {
 public:
  LRUCacheTest() {}
-  ~LRUCacheTest() override { DeleteCache(); }
+  ~LRUCacheTest() { DeleteCache(); }

  void DeleteCache() {
    if (cache_ != nullptr) {
@@ -0,0 +1,21 @@
+# - Find zlib
+# Find the zlib compression library and includes
+#
+# ZLIB_INCLUDE_DIR - where to find zlib.h, etc.
+# ZLIB_LIBRARIES - List of libraries when using zlib.
+# ZLIB_FOUND - True if zlib found.
+
+find_path(ZLIB_INCLUDE_DIR
+  NAMES zlib.h
+  HINTS ${ZLIB_ROOT_DIR}/include)
+
+find_library(ZLIB_LIBRARIES
+  NAMES z
+  HINTS ${ZLIB_ROOT_DIR}/lib)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(zlib DEFAULT_MSG ZLIB_LIBRARIES ZLIB_INCLUDE_DIR)
+
+mark_as_advanced(
+  ZLIB_LIBRARIES
+  ZLIB_INCLUDE_DIR)
@@ -48,17 +48,17 @@ TableBuilder* NewTableBuilder(
    uint32_t column_family_id, const std::string& column_family_name,
    WritableFileWriter* file, const CompressionType compression_type,
    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 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,
-                          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);
 }

@@ -105,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
@@ -126,14 +121,14 @@ Status BuildTable(
      file->SetIOPriority(io_priority);
      file->SetWriteLifeTimeHint(write_hint);

-      file_writer.reset(
-          new WritableFileWriter(std::move(file), fname, env_options, env,
-                                 ioptions.statistics, ioptions.listeners));
+      file_writer.reset(new WritableFileWriter(std::move(file), fname,
+                                               env_options, ioptions.statistics,
+                                               ioptions.listeners));
      builder = NewTableBuilder(
          ioptions, mutable_cf_options, internal_comparator,
          int_tbl_prop_collector_factories, column_family_id,
-          column_family_name, file_writer.get(), compression,
-          compression_opts_for_flush, level, false /* skip_filters */,
+          column_family_name, file_writer.get(), compression, compression_opts,
+          level, nullptr /* compression_dict */, false /* skip_filters */,
          creation_time, oldest_key_time);
    }

@@ -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,
@@ -48,8 +50,9 @@ TableBuilder* NewTableBuilder(
    uint32_t column_family_id, const std::string& column_family_name,
    WritableFileWriter* file, const CompressionType compression_type,
    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
@@ -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());
  }
 };
@@ -1770,11 +1784,11 @@ rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base(
 }

 rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf(
-    rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator,
+    rocksdb_writebatch_wi_t* wbwi,
+    rocksdb_iterator_t* base_iterator,
    rocksdb_column_family_handle_t* column_family) {
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
-  result->rep =
-      wbwi->rep->NewIteratorWithBase(column_family->rep, base_iterator->rep);
+  result->rep = wbwi->rep->NewIteratorWithBase(column_family->rep, base_iterator->rep);
  delete base_iterator;
  return result;
 }
@@ -2053,15 +2067,6 @@ void rocksdb_set_options(
            db->rep->SetOptions(options_map));
    }

-void rocksdb_set_options_cf(
-    rocksdb_t* db, rocksdb_column_family_handle_t* handle, int count, const char* const keys[], const char* const values[], char** errptr) {
-        std::unordered_map<std::string, std::string> options_map;
-        for (int i=0; i<count; i++)
-            options_map[keys[i]] = values[i];
-        SaveError(errptr,
-            db->rep->SetOptions(handle->rep, options_map));
-    }
-
 rocksdb_options_t* rocksdb_options_create() {
  return new rocksdb_options_t;
 }
@@ -2852,7 +2857,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 +2957,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 +3412,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);
@@ -917,8 +917,7 @@ int main(int argc, char** argv) {
    rocksdb_writebatch_wi_t* wbi = rocksdb_writebatch_wi_create(0, 1);
    rocksdb_writebatch_wi_put(wbi, "bar", 3, "b", 1);
    rocksdb_writebatch_wi_delete(wbi, "foo", 3);
-    rocksdb_iterator_t* iter =
-        rocksdb_writebatch_wi_create_iterator_with_base(wbi, base_iter);
+    rocksdb_iterator_t* iter = rocksdb_writebatch_wi_create_iterator_with_base(wbi, base_iter);
    CheckCondition(!rocksdb_iter_valid(iter));
    rocksdb_iter_seek_to_first(iter);
    CheckCondition(rocksdb_iter_valid(iter));
@@ -1528,7 +1527,7 @@ int main(int argc, char** argv) {
    const rocksdb_snapshot_t* snapshot;
    snapshot = rocksdb_transactiondb_create_snapshot(txn_db);
    rocksdb_readoptions_set_snapshot(roptions, snapshot);
-
+  
    rocksdb_transactiondb_put(txn_db, woptions, "foo", 3, "hey", 3,  &err);
    CheckNoError(err);

@@ -129,10 +129,14 @@ Status CheckCompressionSupported(const ColumnFamilyOptions& cf_options) {
    }
  }
  if (cf_options.compression_opts.zstd_max_train_bytes > 0) {
-    if (!ZSTD_TrainDictionarySupported()) {
+    if (!CompressionTypeSupported(CompressionType::kZSTD)) {
+      // Dictionary trainer is available since v0.6.1, but ZSTD was marked
+      // stable only since v0.8.0. For now we enable the feature in stable
+      // versions only.
      return Status::InvalidArgument(
-          "zstd dictionary trainer cannot be used because ZSTD 1.1.3+ "
-          "is not linked with the binary.");
+          "zstd dictionary trainer cannot be used because " +
+          CompressionTypeToString(CompressionType::kZSTD) +
+          " is not linked with the binary.");
    }
    if (cf_options.compression_opts.max_dict_bytes == 0) {
      return Status::InvalidArgument(
@@ -383,8 +383,6 @@ class ColumnFamilyData {

  Directory* GetDataDir(size_t path_id) const;

-  ThreadLocalPtr* TEST_GetLocalSV() { return local_sv_.get(); }
-
 private:
  friend class ColumnFamilySet;
  ColumnFamilyData(uint32_t id, const std::string& name,
@@ -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*/,
@@ -2046,7 +2042,7 @@ TEST_P(ColumnFamilyTest, SameCFAutomaticManualCompactions) {
 }
 #endif  // !ROCKSDB_LITE

-#ifndef ROCKSDB_LITE  // Tailing iterator not supported
+#ifndef ROCKSDB_LITE  // Tailing interator not supported
 namespace {
 std::string IterStatus(Iterator* iter) {
  std::string result;
@@ -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_;
@@ -357,51 +357,6 @@ TEST_F(CompactFilesTest, SentinelCompressionType) {
  }
 }

-TEST_F(CompactFilesTest, GetCompactionJobInfo) {
-  Options options;
-  options.create_if_missing = true;
-  // Disable RocksDB background compaction.
-  options.compaction_style = kCompactionStyleNone;
-  options.level0_slowdown_writes_trigger = 1000;
-  options.level0_stop_writes_trigger = 1000;
-  options.write_buffer_size = 65536;
-  options.max_write_buffer_number = 2;
-  options.compression = kNoCompression;
-  options.max_compaction_bytes = 5000;
-
-  // Add listener
-  FlushedFileCollector* collector = new FlushedFileCollector();
-  options.listeners.emplace_back(collector);
-
-  DB* db = nullptr;
-  DestroyDB(db_name_, options);
-  Status s = DB::Open(options, db_name_, &db);
-  assert(s.ok());
-  assert(db);
-
-  // create couple files
-  for (int i = 0; i < 500; ++i) {
-    db->Put(WriteOptions(), ToString(i), std::string(1000, 'a' + (i % 26)));
-  }
-  reinterpret_cast<DBImpl*>(db)->TEST_WaitForFlushMemTable();
-  auto l0_files_1 = collector->GetFlushedFiles();
-  CompactionOptions co;
-  co.compression = CompressionType::kLZ4Compression;
-  CompactionJobInfo compaction_job_info;
-  ASSERT_OK(
-      db->CompactFiles(co, l0_files_1, 0, -1, nullptr, &compaction_job_info));
-  ASSERT_EQ(compaction_job_info.base_input_level, 0);
-  ASSERT_EQ(compaction_job_info.cf_id, db->DefaultColumnFamily()->GetID());
-  ASSERT_EQ(compaction_job_info.cf_name, db->DefaultColumnFamily()->GetName());
-  ASSERT_EQ(compaction_job_info.compaction_reason,
-            CompactionReason::kManualCompaction);
-  ASSERT_EQ(compaction_job_info.compression, CompressionType::kLZ4Compression);
-  ASSERT_EQ(compaction_job_info.output_level, 0);
-  ASSERT_OK(compaction_job_info.status);
-  // no assertion failure
-  delete db;
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -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) {
@@ -379,8 +373,8 @@ bool Compaction::KeyNotExistsBeyondOutputLevel(
        if (user_cmp->Compare(user_key, f->largest.user_key()) <= 0) {
          // We've advanced far enough
          if (user_cmp->Compare(user_key, f->smallest.user_key()) >= 0) {
-            // Key falls in this file's range, so it may
-            // exist beyond output level
+            // Key falls in this file's range, so definitely
+            // exists beyond output level
            return false;
          }
          break;
@@ -9,23 +9,6 @@
 #include "port/likely.h"
 #include "rocksdb/listener.h"
 #include "table/internal_iterator.h"
-#include "util/sync_point.h"
-
-#define DEFINITELY_IN_SNAPSHOT(seq, snapshot)                       \
-  ((seq) <= (snapshot) &&                                           \
-   (snapshot_checker_ == nullptr ||                                 \
-    LIKELY(snapshot_checker_->CheckInSnapshot((seq), (snapshot)) == \
-           SnapshotCheckerResult::kInSnapshot)))
-
-#define DEFINITELY_NOT_IN_SNAPSHOT(seq, snapshot)                     \
-  ((seq) > (snapshot) ||                                              \
-   (snapshot_checker_ != nullptr &&                                   \
-    UNLIKELY(snapshot_checker_->CheckInSnapshot((seq), (snapshot)) == \
-             SnapshotCheckerResult::kNotInSnapshot)))
-
-#define IN_EARLIEST_SNAPSHOT(seq) \
-  ((seq) <= earliest_snapshot_ && \
-   (snapshot_checker_ == nullptr || LIKELY(IsInEarliestSnapshot(seq))))

 namespace rocksdb {

@@ -72,37 +55,42 @@ 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_),
      current_key_committed_(false) {
  assert(compaction_filter_ == nullptr || compaction_ != nullptr);
-  assert(snapshots_ != nullptr);
  bottommost_level_ =
      compaction_ == nullptr ? false : compaction_->bottommost_level();
  if (compaction_ != nullptr) {
    level_ptrs_ = std::vector<size_t>(compaction_->number_levels(), 0);
  }
+
  if (snapshots_->size() == 0) {
    // optimize for fast path if there are no snapshots
    visible_at_tip_ = true;
-    earliest_snapshot_iter_ = snapshots_->end();
    earliest_snapshot_ = kMaxSequenceNumber;
    latest_snapshot_ = 0;
  } else {
    visible_at_tip_ = false;
-    earliest_snapshot_iter_ = snapshots_->begin();
    earliest_snapshot_ = snapshots_->at(0);
    latest_snapshot_ = snapshots_->back();
  }
 #ifndef NDEBUG
  // findEarliestVisibleSnapshot assumes this ordering.
  for (size_t i = 1; i < snapshots_->size(); ++i) {
-    assert(snapshots_->at(i - 1) < snapshots_->at(i));
+    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());
 }

 CompactionIterator::~CompactionIterator() {
@@ -172,7 +160,12 @@ 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_ ||
+       ikey_.sequence > latest_snapshot_ ||
+       (snapshot_checker_ != nullptr &&
+        UNLIKELY(!snapshot_checker_->IsInSnapshot(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,
@@ -248,7 +241,6 @@ void CompactionIterator::NextFromInput() {
      valid_ = true;
      break;
    }
-    TEST_SYNC_POINT_CALLBACK("CompactionIterator:ProcessKV", &ikey_);

    // Update input statistics
    if (ikey_.type == kTypeDeletion || ikey_.type == kTypeSingleDeletion) {
@@ -277,7 +269,9 @@ void CompactionIterator::NextFromInput() {
      has_outputted_key_ = false;
      current_user_key_sequence_ = kMaxSequenceNumber;
      current_user_key_snapshot_ = 0;
-      current_key_committed_ = KeyCommitted(ikey_.sequence);
+      current_key_committed_ =
+          (snapshot_checker_ == nullptr ||
+           snapshot_checker_->IsInSnapshot(ikey_.sequence, kMaxSequenceNumber));

      // Apply the compaction filter to the first committed version of the user
      // key.
@@ -299,7 +293,8 @@ void CompactionIterator::NextFromInput() {
      // to query snapshot_checker_ in that case.
      if (UNLIKELY(!current_key_committed_)) {
        assert(snapshot_checker_ != nullptr);
-        current_key_committed_ = KeyCommitted(ikey_.sequence);
+        current_key_committed_ =
+            snapshot_checker_->IsInSnapshot(ikey_.sequence, kMaxSequenceNumber);
        // Apply the compaction filter to the first committed version of the
        // user key.
        if (current_key_committed_) {
@@ -383,8 +378,10 @@ void CompactionIterator::NextFromInput() {
          cmp_->Equal(ikey_.user_key, next_ikey.user_key)) {
        // Check whether the next key belongs to the same snapshot as the
        // SingleDelete.
-        if (prev_snapshot == 0 ||
-            DEFINITELY_NOT_IN_SNAPSHOT(next_ikey.sequence, prev_snapshot)) {
+        if (prev_snapshot == 0 || next_ikey.sequence > prev_snapshot ||
+            (snapshot_checker_ != nullptr &&
+             UNLIKELY(!snapshot_checker_->IsInSnapshot(next_ikey.sequence,
+                                                       prev_snapshot)))) {
          if (next_ikey.type == kTypeSingleDeletion) {
            // We encountered two SingleDeletes in a row.  This could be due to
            // unexpected user input.
@@ -396,8 +393,11 @@ void CompactionIterator::NextFromInput() {
            ++iter_stats_.num_record_drop_obsolete;
            ++iter_stats_.num_single_del_mismatch;
          } else if (has_outputted_key_ ||
-                     DEFINITELY_IN_SNAPSHOT(
-                         ikey_.sequence, earliest_write_conflict_snapshot_)) {
+                     (ikey_.sequence <= earliest_write_conflict_snapshot_ &&
+                      (snapshot_checker_ == nullptr ||
+                       LIKELY(snapshot_checker_->IsInSnapshot(
+                           ikey_.sequence,
+                           earliest_write_conflict_snapshot_))))) {
            // Found a matching value, we can drop the single delete and the
            // value.  It is safe to drop both records since we've already
            // outputted a key in this snapshot, or there is no earlier
@@ -407,8 +407,7 @@ void CompactionIterator::NextFromInput() {
            // is an unexpected Merge or Delete.  We will compact it out
            // either way. We will maintain counts of how many mismatches
            // happened
-            if (next_ikey.type != kTypeValue &&
-                next_ikey.type != kTypeBlobIndex) {
+            if (next_ikey.type != kTypeValue) {
              ++iter_stats_.num_single_del_mismatch;
            }

@@ -445,7 +444,10 @@ void CompactionIterator::NextFromInput() {
        // iteration. If the next key is corrupt, we return before the
        // comparison, so the value of has_current_user_key does not matter.
        has_current_user_key_ = false;
-        if (compaction_ != nullptr && IN_EARLIEST_SNAPSHOT(ikey_.sequence) &&
+        if (compaction_ != nullptr && ikey_.sequence <= earliest_snapshot_ &&
+            (snapshot_checker_ == nullptr ||
+             LIKELY(snapshot_checker_->IsInSnapshot(ikey_.sequence,
+                                                    earliest_snapshot_))) &&
            compaction_->KeyNotExistsBeyondOutputLevel(ikey_.user_key,
                                                       &level_ptrs_)) {
          // Key doesn't exist outside of this range.
@@ -464,37 +466,24 @@ void CompactionIterator::NextFromInput() {
      if (valid_) {
        at_next_ = true;
      }
-    } else if (last_snapshot == current_user_key_snapshot_ ||
-               (last_snapshot > 0 &&
-                last_snapshot < current_user_key_snapshot_)) {
+    } else if (last_snapshot == current_user_key_snapshot_) {
      // If the earliest snapshot is which this key is visible in
      // is the same as the visibility of a previous instance of the
      // same key, then this kv is not visible in any snapshot.
      // Hidden by an newer entry for same user key
+      // TODO(noetzli): why not > ?
      //
      // Note: Dropping this key will not affect TransactionDB write-conflict
      // checking since there has already been a record returned for this key
      // in this snapshot.
      assert(last_sequence >= current_user_key_sequence_);
-
-      // Note2: if last_snapshot < current_user_key_snapshot, it can only
-      // mean last_snapshot is released between we process last value and
-      // 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));
-
      ++iter_stats_.num_record_drop_hidden;  // (A)
      input_->Next();
    } else if (compaction_ != nullptr && ikey_.type == kTypeDeletion &&
-               IN_EARLIEST_SNAPSHOT(ikey_.sequence) &&
+               ikey_.sequence <= earliest_snapshot_ &&
+               (snapshot_checker_ == nullptr ||
+                LIKELY(snapshot_checker_->IsInSnapshot(ikey_.sequence,
+                                                       earliest_snapshot_))) &&
               ikeyNotNeededForIncrementalSnapshot() &&
               compaction_->KeyNotExistsBeyondOutputLevel(ikey_.user_key,
                                                          &level_ptrs_)) {
@@ -531,10 +520,13 @@ void CompactionIterator::NextFromInput() {
      input_->Next();
      // Skip over all versions of this key that happen to occur in the same snapshot
      // range as the delete
-      while (input_->Valid() && ParseInternalKey(input_->key(), &next_ikey) &&
+      while (input_->Valid() &&
+             ParseInternalKey(input_->key(), &next_ikey) &&
             cmp_->Equal(ikey_.user_key, next_ikey.user_key) &&
-             (prev_snapshot == 0 ||
-              DEFINITELY_NOT_IN_SNAPSHOT(next_ikey.sequence, prev_snapshot))) {
+             (prev_snapshot == 0 || next_ikey.sequence > prev_snapshot ||
+              (snapshot_checker_ != nullptr &&
+               UNLIKELY(!snapshot_checker_->IsInSnapshot(next_ikey.sequence,
+                                                         prev_snapshot))))) {
        input_->Next();
      }
      // If you find you still need to output a row with this key, we need to output the
@@ -625,9 +617,14 @@ void CompactionIterator::PrepareOutput() {
  //
  // Can we do the same for levels above bottom level as long as
  // KeyNotExistsBeyondOutputLevel() return true?
-  if ((compaction_ != nullptr && !compaction_->allow_ingest_behind()) &&
-      ikeyNotNeededForIncrementalSnapshot() && bottommost_level_ && valid_ &&
-      IN_EARLIEST_SNAPSHOT(ikey_.sequence) && ikey_.type != kTypeMerge) {
+  if ((compaction_ != nullptr &&
+      !compaction_->allow_ingest_behind()) &&
+      ikeyNotNeededForIncrementalSnapshot() &&
+      bottommost_level_ && valid_ && ikey_.sequence <= earliest_snapshot_ &&
+      (snapshot_checker_ == nullptr || LIKELY(snapshot_checker_->IsInSnapshot(
+        ikey_.sequence, earliest_snapshot_))) &&
+      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);
@@ -645,23 +642,12 @@ inline SequenceNumber CompactionIterator::findEarliestVisibleSnapshot(
    *prev_snapshot = *std::prev(snapshots_iter);
    assert(*prev_snapshot < in);
  }
-  if (snapshot_checker_ == nullptr) {
-    return snapshots_iter != snapshots_->end()
-      ? *snapshots_iter : kMaxSequenceNumber;
-  }
-  bool has_released_snapshot = !released_snapshots_.empty();
  for (; snapshots_iter != snapshots_->end(); ++snapshots_iter) {
    auto cur = *snapshots_iter;
    assert(in <= cur);
-    // Skip if cur is in released_snapshots.
-    if (has_released_snapshot && released_snapshots_.count(cur) > 0) {
-      continue;
-    }
-    auto res = snapshot_checker_->CheckInSnapshot(in, cur);
-    if (res == SnapshotCheckerResult::kInSnapshot) {
+    if (snapshot_checker_ == nullptr ||
+        snapshot_checker_->IsInSnapshot(in, cur)) {
      return cur;
-    } else if (res == SnapshotCheckerResult::kSnapshotReleased) {
-      released_snapshots_.insert(cur);
    }
    *prev_snapshot = cur;
  }
@@ -675,30 +661,4 @@ inline bool CompactionIterator::ikeyNotNeededForIncrementalSnapshot() {
         (ikey_.sequence < preserve_deletes_seqnum_);
 }

-bool CompactionIterator::IsInEarliestSnapshot(SequenceNumber sequence) {
-  assert(snapshot_checker_ != nullptr);
-  assert(earliest_snapshot_ == kMaxSequenceNumber ||
-         (earliest_snapshot_iter_ != snapshots_->end() &&
-          *earliest_snapshot_iter_ == earliest_snapshot_));
-  auto in_snapshot =
-      snapshot_checker_->CheckInSnapshot(sequence, earliest_snapshot_);
-  while (UNLIKELY(in_snapshot == SnapshotCheckerResult::kSnapshotReleased)) {
-    // Avoid the the current earliest_snapshot_ being return as
-    // earliest visible snapshot for the next value. So if a value's sequence
-    // is zero-ed out by PrepareOutput(), the next value will be compact out.
-    released_snapshots_.insert(earliest_snapshot_);
-    earliest_snapshot_iter_++;
-
-    if (earliest_snapshot_iter_ == snapshots_->end()) {
-      earliest_snapshot_ = kMaxSequenceNumber;
-    } else {
-      earliest_snapshot_ = *earliest_snapshot_iter_;
-    }
-    in_snapshot =
-        snapshot_checker_->CheckInSnapshot(sequence, earliest_snapshot_);
-  }
-  assert(in_snapshot != SnapshotCheckerResult::kSnapshotReleased);
-  return in_snapshot == SnapshotCheckerResult::kInSnapshot;
-}
-
 }  // namespace rocksdb
@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <deque>
 #include <string>
-#include <unordered_set>
 #include <vector>

 #include "db/compaction.h"
@@ -133,25 +132,10 @@ class CompactionIterator {
  // or seqnum be zero-ed out even if all other conditions for it are met.
  inline bool ikeyNotNeededForIncrementalSnapshot();

-  inline bool KeyCommitted(SequenceNumber sequence) {
-    return snapshot_checker_ == nullptr ||
-           snapshot_checker_->CheckInSnapshot(sequence, kMaxSequenceNumber) ==
-               SnapshotCheckerResult::kInSnapshot;
-  }
-
-  bool IsInEarliestSnapshot(SequenceNumber sequence);
-
  InternalIterator* input_;
  const Comparator* cmp_;
  MergeHelper* merge_helper_;
  const std::vector<SequenceNumber>* snapshots_;
-  // List of snapshots released during compaction.
-  // findEarliestVisibleSnapshot() find them out from return of
-  // snapshot_checker, and make sure they will not be returned as
-  // earliest visible snapshot of an older value.
-  // See WritePreparedTransactionTest::ReleaseSnapshotDuringCompaction3.
-  std::unordered_set<SequenceNumber> released_snapshots_;
-  std::vector<SequenceNumber>::const_iterator earliest_snapshot_iter_;
  const SequenceNumber earliest_write_conflict_snapshot_;
  const SnapshotChecker* const snapshot_checker_;
  Env* env_;
@@ -167,6 +151,7 @@ class CompactionIterator {
  bool visible_at_tip_;
  SequenceNumber earliest_snapshot_;
  SequenceNumber latest_snapshot_;
+  bool ignore_snapshots_;

  // State
  //
@@ -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;

@@ -188,17 +190,13 @@ class TestSnapshotChecker : public SnapshotChecker {
      : last_committed_sequence_(last_committed_sequence),
        snapshots_(snapshots) {}

-  SnapshotCheckerResult CheckInSnapshot(
-      SequenceNumber seq, SequenceNumber snapshot_seq) const override {
+  bool IsInSnapshot(SequenceNumber seq,
+                    SequenceNumber snapshot_seq) const override {
    if (snapshot_seq == kMaxSequenceNumber) {
-      return seq <= last_committed_sequence_
-                 ? SnapshotCheckerResult::kInSnapshot
-                 : SnapshotCheckerResult::kNotInSnapshot;
+      return seq <= last_committed_sequence_;
    }
    assert(snapshots_.count(snapshot_seq) > 0);
-    return seq <= snapshots_.at(snapshot_seq)
-               ? SnapshotCheckerResult::kInSnapshot
-               : SnapshotCheckerResult::kNotInSnapshot;
+    return seq <= snapshots_.at(snapshot_seq);
  }

 private:
@@ -375,9 +373,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 +556,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;
  }

@@ -601,14 +604,7 @@ Status CompactionJob::Run() {
  }

  compaction_stats_.micros = env_->NowMicros() - start_micros;
-  compaction_stats_.cpu_micros = 0;
-  for (size_t i = 0; i < compact_->sub_compact_states.size(); i++) {
-    compaction_stats_.cpu_micros +=
-        compact_->sub_compact_states[i].compaction_job_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");

@@ -771,7 +767,6 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
  stream << "job" << job_id_ << "event"
         << "compaction_finished"
         << "compaction_time_micros" << compaction_stats_.micros
-         << "compaction_time_cpu_micros" << compaction_stats_.cpu_micros
         << "output_level" << compact_->compaction->output_level()
         << "num_output_files" << compact_->NumOutputFiles()
         << "total_output_size" << compact_->total_bytes << "num_input_records"
@@ -809,28 +804,7 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {

 void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  assert(sub_compact != nullptr);
-
-  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_);

@@ -849,19 +823,58 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  uint64_t prev_fsync_nanos = 0;
  uint64_t prev_range_sync_nanos = 0;
  uint64_t prev_prepare_write_nanos = 0;
-  uint64_t prev_cpu_write_nanos = 0;
-  uint64_t prev_cpu_read_nanos = 0;
  if (measure_io_stats_) {
    prev_perf_level = GetPerfLevel();
-    SetPerfLevel(PerfLevel::kEnableTimeAndCPUTimeExceptForMutex);
+    SetPerfLevel(PerfLevel::kEnableTime);
    prev_write_nanos = IOSTATS(write_nanos);
    prev_fsync_nanos = IOSTATS(fsync_nanos);
    prev_range_sync_nanos = IOSTATS(range_sync_nanos);
    prev_prepare_write_nanos = IOSTATS(prepare_write_nanos);
-    prev_cpu_write_nanos = IOSTATS(cpu_write_nanos);
-    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(),
@@ -899,6 +912,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()
@@ -934,6 +953,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.
@@ -975,6 +1043,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);
+        }
+      }
    }
  }

@@ -1027,9 +1107,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    RecordDroppedKeys(range_del_out_stats, &sub_compact->compaction_job_stats);
  }

-  sub_compact->compaction_job_stats.cpu_micros =
-      env_->NowCPUNanos() / 1000 - prev_cpu_micros;
-
  if (measure_io_stats_) {
    sub_compact->compaction_job_stats.file_write_nanos +=
        IOSTATS(write_nanos) - prev_write_nanos;
@@ -1039,11 +1116,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
        IOSTATS(range_sync_nanos) - prev_range_sync_nanos;
    sub_compact->compaction_job_stats.file_prepare_write_nanos +=
        IOSTATS(prepare_write_nanos) - prev_prepare_write_nanos;
-    sub_compact->compaction_job_stats.cpu_micros -=
-        (IOSTATS(cpu_write_nanos) - prev_cpu_write_nanos +
-         IOSTATS(cpu_read_nanos) - prev_cpu_read_nanos) /
-        1000;
-    if (prev_perf_level != PerfLevel::kEnableTimeAndCPUTimeExceptForMutex) {
+    if (prev_perf_level != PerfLevel::kEnableTime) {
      SetPerfLevel(prev_perf_level);
    }
  }
@@ -1116,12 +1189,10 @@ Status CompactionJob::FinishCompactionOutputFile(
    Slice lower_bound_guard, upper_bound_guard;
    std::string smallest_user_key;
    const Slice *lower_bound, *upper_bound;
-    bool lower_bound_from_sub_compact = false;
    if (sub_compact->outputs.size() == 1) {
      // For the first output table, include range tombstones before the min key
      // but after the subcompaction boundary.
      lower_bound = sub_compact->start;
-      lower_bound_from_sub_compact = true;
    } else if (meta->smallest.size() > 0) {
      // For subsequent output tables, only include range tombstones from min
      // key onwards since the previous file was extended to contain range
@@ -1215,24 +1286,11 @@ Status CompactionJob::FinishCompactionOutputFile(
        // (the max key in the previous table or subcompaction) in order for
        // files to appear key-space partitioned.
        //
-        // When lower_bound is chosen by a subcompaction, we know that
-        // subcompactions over smaller keys cannot contain any keys at
-        // lower_bound. We also know that smaller subcompactions exist, because
-        // otherwise the subcompaction woud be unbounded on the left. As a
-        // result, we know that no other files on the output level will contain
-        // actual keys at lower_bound (an output file may have a largest key of
-        // lower_bound@kMaxSequenceNumber, but this only indicates a large range
-        // tombstone was truncated). Therefore, it is safe to use the
-        // tombstone's sequence number, to ensure that keys at lower_bound at
-        // lower levels are covered by truncated tombstones.
-        //
-        // If lower_bound was chosen by the smallest data key in the file,
-        // choose lowest seqnum so this file's smallest internal key comes after
-        // the previous file's largest. The fake seqnum is OK because the read
-        // path's file-picking code only considers user key.
-        smallest_candidate = InternalKey(
-            *lower_bound, lower_bound_from_sub_compact ? tombstone.seq_ : 0,
-            kTypeRangeDeletion);
+        // Choose lowest seqnum so this file's smallest internal key comes
+        // after the previous file's/subcompaction's largest. The fake seqnum
+        // is OK because the read path's file-picking code only considers user
+        // key.
+        smallest_candidate = InternalKey(*lower_bound, 0, kTypeRangeDeletion);
      }
      InternalKey largest_candidate = tombstone.SerializeEndKey();
      if (upper_bound != nullptr &&
@@ -1254,23 +1312,9 @@ Status CompactionJob::FinishCompactionOutputFile(
        largest_candidate =
            InternalKey(*upper_bound, kMaxSequenceNumber, kTypeRangeDeletion);
      }
-#ifndef NDEBUG
-      SequenceNumber smallest_ikey_seqnum = kMaxSequenceNumber;
-      if (meta->smallest.size() > 0) {
-        smallest_ikey_seqnum = GetInternalKeySeqno(meta->smallest.Encode());
-      }
-#endif
      meta->UpdateBoundariesForRange(smallest_candidate, largest_candidate,
                                     tombstone.seq_,
                                     cfd->internal_comparator());
-
-      // The smallest key in a file is used for range tombstone truncation, so
-      // it cannot have a seqnum of 0 (unless the smallest data key in a file
-      // has a seqnum of 0). Otherwise, the truncated tombstone may expose
-      // deleted keys at lower levels.
-      assert(smallest_ikey_seqnum == 0 ||
-             ExtractInternalKeyFooter(meta->smallest.Encode()) !=
-                 PackSequenceAndType(0, kTypeRangeDeletion));
    }
    meta->marked_for_compaction = sub_compact->builder->NeedCompact();
  }
@@ -1348,7 +1392,10 @@ Status CompactionJob::FinishCompactionOutputFile(
  auto sfm =
      static_cast<SstFileManagerImpl*>(db_options_.sst_file_manager.get());
  if (sfm && meta != nullptr && meta->fd.GetPathId() == 0) {
-    sfm->OnAddFile(fname);
+    auto fn =
+        TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
+                      meta->fd.GetNumber(), meta->fd.GetPathId());
+    sfm->OnAddFile(fn);
    if (sfm->IsMaxAllowedSpaceReached()) {
      // TODO(ajkr): should we return OK() if max space was reached by the final
      // compaction output file (similarly to how flush works when full)?
@@ -1470,7 +1517,7 @@ Status CompactionJob::OpenCompactionOutputFile(
      sub_compact->compaction->immutable_cf_options()->listeners;
  sub_compact->outfile.reset(
      new WritableFileWriter(std::move(writable_file), fname, env_options_,
-                             env_, db_options_.statistics.get(), listeners));
+                             db_options_.statistics.get(), listeners));

  // If the Column family flag is to only optimize filters for hits,
  // we can skip creating filters if this is the bottommost_level where
@@ -1500,9 +1547,8 @@ Status CompactionJob::OpenCompactionOutputFile(
      cfd->GetID(), cfd->GetName(), sub_compact->outfile.get(),
      sub_compact->compaction->output_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;
 }
@@ -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);
@@ -379,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);
@@ -432,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);
@@ -456,7 +456,8 @@ 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, kTypeMerge), "2"},
+                          {KeyStr("b", 1U, kTypeMerge), "1"}});

  SetLastSequence(5U);
  auto files = cfd_->current()->storage_info()->LevelFiles(0);
@@ -483,7 +484,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, kTypeMerge), test::EncodeInt(2U)}});

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

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

  SetLastSequence(22U);
@@ -930,7 +931,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;
 };

@@ -57,16 +59,14 @@ class CompactionPickerTest : public testing::Test {
        log_buffer_(InfoLogLevel::INFO_LEVEL, &logger_),
        file_num_(1),
        vstorage_(nullptr) {
-    // ioptions_.compaction_pri = kMinOverlappingRatio has its own set of
-    // tests to cover.
-    ioptions_.compaction_pri = kByCompensatedSize;
    fifo_options_.max_table_files_size = 1;
    mutable_cf_options_.RefreshDerivedOptions(ioptions_);
    ioptions_.cf_paths.emplace_back("dummy",
                                    std::numeric_limits<uint64_t>::max());
  }

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

  void NewVersionStorage(int num_levels, CompactionStyle style) {
    DeleteVersionStorage();
@@ -85,8 +85,8 @@ class CompactionPickerTest : public testing::Test {

  void Add(int level, uint32_t file_number, const char* smallest,
           const char* largest, uint64_t file_size = 1, uint32_t path_id = 0,
-           SequenceNumber smallest_seq = 100, SequenceNumber largest_seq = 100,
-           size_t compensated_file_size = 0) {
+           SequenceNumber smallest_seq = 100,
+           SequenceNumber largest_seq = 100) {
    assert(level < vstorage_->num_levels());
    FileMetaData* f = new FileMetaData;
    f->fd = FileDescriptor(file_number, path_id, file_size);
@@ -94,8 +94,7 @@ class CompactionPickerTest : public testing::Test {
    f->largest = InternalKey(largest, largest_seq, kTypeValue);
    f->fd.smallest_seqno = smallest_seq;
    f->fd.largest_seqno = largest_seq;
-    f->compensated_file_size =
-        (compensated_file_size != 0) ? compensated_file_size : file_size;
+    f->compensated_file_size = file_size;
    f->refs = 0;
    vstorage_->AddFile(level, f);
    files_.emplace_back(f);
@@ -618,35 +617,6 @@ TEST_F(CompactionPickerTest, CompactionPriMinOverlapping3) {
  ASSERT_EQ(8U, compaction->input(0, 0)->fd.GetNumber());
 }

-TEST_F(CompactionPickerTest, CompactionPriMinOverlapping4) {
-  NewVersionStorage(6, kCompactionStyleLevel);
-  ioptions_.compaction_pri = kMinOverlappingRatio;
-  mutable_cf_options_.max_bytes_for_level_base = 10000000;
-  mutable_cf_options_.max_bytes_for_level_multiplier = 10;
-
-  // file 7 and 8 over lap with the same file, but file 8 is smaller so
-  // it will be picked.
-  // Overlaps with file 26, 27. And the file is compensated so will be
-  // picked up.
-  Add(2, 6U, "150", "167", 60000000U, 0, 100, 100, 180000000U);
-  Add(2, 7U, "168", "169", 60000000U);  // Overlaps with file 27
-  Add(2, 8U, "201", "300", 61000000U);  // Overlaps with file 28
-
-  Add(3, 26U, "160", "165", 60000000U);
-  // Boosted file size in output level is not considered.
-  Add(3, 27U, "166", "170", 60000000U, 0, 100, 100, 260000000U);
-  Add(3, 28U, "180", "400", 60000000U);
-  Add(3, 29U, "401", "500", 60000000U);
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(level_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, vstorage_.get(), &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_EQ(1U, compaction->num_input_files(0));
-  // Picking file 8 because overlapping ratio is the biggest.
-  ASSERT_EQ(6U, compaction->input(0, 0)->fd.GetNumber());
-}
-
 // This test exhibits the bug where we don't properly reset parent_index in
 // PickCompaction()
 TEST_F(CompactionPickerTest, ParentIndexResetBug) {
@@ -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();
@@ -24,8 +24,6 @@
 #include "rocksdb/env.h"
 #include "rocksdb/table.h"
 #include "rocksdb/write_batch.h"
-#include "table/block_based_table_builder.h"
-#include "table/meta_blocks.h"
 #include "util/filename.h"
 #include "util/string_util.h"
 #include "util/testharness.h"
@@ -62,9 +60,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() {
@@ -469,39 +467,6 @@ TEST_F(CorruptionTest, UnrelatedKeys) {
  ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
 }

-TEST_F(CorruptionTest, RangeDeletionCorrupted) {
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "b"));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  std::vector<LiveFileMetaData> metadata;
-  db_->GetLiveFilesMetaData(&metadata);
-  ASSERT_EQ(static_cast<size_t>(1), metadata.size());
-  std::string filename = dbname_ + metadata[0].name;
-
-  std::unique_ptr<RandomAccessFile> file;
-  ASSERT_OK(options_.env->NewRandomAccessFile(filename, &file, EnvOptions()));
-  std::unique_ptr<RandomAccessFileReader> file_reader(
-      new RandomAccessFileReader(std::move(file), filename));
-
-  uint64_t file_size;
-  ASSERT_OK(options_.env->GetFileSize(filename, &file_size));
-
-  BlockHandle range_del_handle;
-  ASSERT_OK(FindMetaBlock(
-      file_reader.get(), file_size, kBlockBasedTableMagicNumber,
-      ImmutableCFOptions(options_), kRangeDelBlock, &range_del_handle));
-
-  ASSERT_OK(TryReopen());
-  CorruptFile(filename, static_cast<int>(range_del_handle.offset()), 1);
-  // The test case does not fail on TryReopen because failure to preload table
-  // handlers is not considered critical.
-  ASSERT_OK(TryReopen());
-  std::string val;
-  // However, it does fail on any read involving that file since that file
-  // cannot be opened with a corrupt range deletion meta-block.
-  ASSERT_TRUE(db_->Get(ReadOptions(), "a", &val).IsCorruption());
-}
-
 TEST_F(CorruptionTest, FileSystemStateCorrupted) {
  for (int iter = 0; iter < 2; ++iter) {
    Options options;
@@ -31,7 +31,7 @@ class CuckooTableDBTest : public testing::Test {
    Reopen();
  }

-  ~CuckooTableDBTest() override {
+  ~CuckooTableDBTest() {
    delete db_;
    EXPECT_OK(DestroyDB(dbname_, Options()));
  }
@@ -6,7 +6,6 @@
 // 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 <iostream>
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "rocksdb/perf_context.h"
@@ -215,11 +214,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 +236,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 +264,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 +509,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 +565,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 +857,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 +880,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();
    }
@@ -950,184 +956,6 @@ TEST_F(DBBasicTest, DBCloseFlushError) {
  Destroy(options);
 }

-TEST_F(DBBasicTest, MultiGetMultiCF) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"pikachu", "ilya", "muromec", "dobrynia", "nikitich",
-                         "alyosha", "popovich"},
-                        options);
-
-  for (int i = 0; i < 8; ++i) {
-    ASSERT_OK(Put(i, "cf" + std::to_string(i) + "_key",
-                  "cf" + std::to_string(i) + "_val"));
-  }
-
-  int get_sv_count = 0;
-  rocksdb::DBImpl* db = reinterpret_cast<DBImpl*>(db_);
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::MultiGet::AfterRefSV", [&](void* /*arg*/) {
-        if (++get_sv_count == 2) {
-          // After MultiGet refs a couple of CFs, flush all CFs so MultiGet
-          // is forced to repeat the process
-          for (int i = 0; i < 8; ++i) {
-            ASSERT_OK(Flush(i));
-            ASSERT_OK(Put(i, "cf" + std::to_string(i) + "_key",
-                          "cf" + std::to_string(i) + "_val2"));
-          }
-        }
-        if (get_sv_count == 11) {
-          for (int i = 0; i < 8; ++i) {
-            auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(
-                            db->GetColumnFamilyHandle(i))
-                            ->cfd();
-            ASSERT_EQ(cfd->TEST_GetLocalSV()->Get(), SuperVersion::kSVInUse);
-          }
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  std::vector<int> cfs;
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  for (int i = 0; i < 8; ++i) {
-    cfs.push_back(i);
-    keys.push_back("cf" + std::to_string(i) + "_key");
-  }
-
-  values = MultiGet(cfs, keys);
-  ASSERT_EQ(values.size(), 8);
-  for (unsigned int j = 0; j < values.size(); ++j) {
-    ASSERT_EQ(values[j], "cf" + std::to_string(j) + "_val2");
-  }
-  for (int i = 0; i < 8; ++i) {
-    auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(
-                    reinterpret_cast<DBImpl*>(db_)->GetColumnFamilyHandle(i))
-                    ->cfd();
-    ASSERT_NE(cfd->TEST_GetLocalSV()->Get(), SuperVersion::kSVInUse);
-    ASSERT_NE(cfd->TEST_GetLocalSV()->Get(), SuperVersion::kSVObsolete);
-  }
-}
-
-TEST_F(DBBasicTest, MultiGetMultiCFMutex) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"pikachu", "ilya", "muromec", "dobrynia", "nikitich",
-                         "alyosha", "popovich"},
-                        options);
-
-  for (int i = 0; i < 8; ++i) {
-    ASSERT_OK(Put(i, "cf" + std::to_string(i) + "_key",
-                  "cf" + std::to_string(i) + "_val"));
-  }
-
-  int get_sv_count = 0;
-  int retries = 0;
-  bool last_try = false;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::MultiGet::LastTry", [&](void* /*arg*/) {
-        last_try = true;
-        rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-      });
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::MultiGet::AfterRefSV", [&](void* /*arg*/) {
-        if (last_try) {
-          return;
-        }
-        if (++get_sv_count == 2) {
-          ++retries;
-          get_sv_count = 0;
-          for (int i = 0; i < 8; ++i) {
-            ASSERT_OK(Flush(i));
-            ASSERT_OK(Put(
-                i, "cf" + std::to_string(i) + "_key",
-                "cf" + std::to_string(i) + "_val" + std::to_string(retries)));
-          }
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  std::vector<int> cfs;
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  for (int i = 0; i < 8; ++i) {
-    cfs.push_back(i);
-    keys.push_back("cf" + std::to_string(i) + "_key");
-  }
-
-  values = MultiGet(cfs, keys);
-  ASSERT_TRUE(last_try);
-  ASSERT_EQ(values.size(), 8);
-  for (unsigned int j = 0; j < values.size(); ++j) {
-    ASSERT_EQ(values[j],
-              "cf" + std::to_string(j) + "_val" + std::to_string(retries));
-  }
-  for (int i = 0; i < 8; ++i) {
-    auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(
-                    reinterpret_cast<DBImpl*>(db_)->GetColumnFamilyHandle(i))
-                    ->cfd();
-    ASSERT_NE(cfd->TEST_GetLocalSV()->Get(), SuperVersion::kSVInUse);
-  }
-}
-
-TEST_F(DBBasicTest, MultiGetMultiCFSnapshot) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"pikachu", "ilya", "muromec", "dobrynia", "nikitich",
-                         "alyosha", "popovich"},
-                        options);
-
-  for (int i = 0; i < 8; ++i) {
-    ASSERT_OK(Put(i, "cf" + std::to_string(i) + "_key",
-                  "cf" + std::to_string(i) + "_val"));
-  }
-
-  int get_sv_count = 0;
-  rocksdb::DBImpl* db = reinterpret_cast<DBImpl*>(db_);
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::MultiGet::AfterRefSV", [&](void* /*arg*/) {
-        if (++get_sv_count == 2) {
-          for (int i = 0; i < 8; ++i) {
-            ASSERT_OK(Flush(i));
-            ASSERT_OK(Put(i, "cf" + std::to_string(i) + "_key",
-                          "cf" + std::to_string(i) + "_val2"));
-          }
-        }
-        if (get_sv_count == 8) {
-          for (int i = 0; i < 8; ++i) {
-            auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(
-                            db->GetColumnFamilyHandle(i))
-                            ->cfd();
-            ASSERT_TRUE(
-                (cfd->TEST_GetLocalSV()->Get() == SuperVersion::kSVInUse) ||
-                (cfd->TEST_GetLocalSV()->Get() == SuperVersion::kSVObsolete));
-          }
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  std::vector<int> cfs;
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  for (int i = 0; i < 8; ++i) {
-    cfs.push_back(i);
-    keys.push_back("cf" + std::to_string(i) + "_key");
-  }
-
-  const Snapshot* snapshot = db_->GetSnapshot();
-  values = MultiGet(cfs, keys, snapshot);
-  db_->ReleaseSnapshot(snapshot);
-  ASSERT_EQ(values.size(), 8);
-  for (unsigned int j = 0; j < values.size(); ++j) {
-    ASSERT_EQ(values[j], "cf" + std::to_string(j) + "_val");
-  }
-  for (int i = 0; i < 8; ++i) {
-    auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(
-                    reinterpret_cast<DBImpl*>(db_)->GetColumnFamilyHandle(i))
-                    ->cfd();
-    ASSERT_NE(cfd->TEST_GetLocalSV()->Get(), SuperVersion::kSVInUse);
-  }
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -173,7 +173,7 @@ TEST_F(DBBlockCacheTest, TestWithoutCompressedBlockCache) {
  delete iter;
  iter = nullptr;

-  // Release iterators and access cache again.
+  // Release interators and access cache again.
  for (size_t i = 0; i < kNumBlocks - 1; i++) {
    iterators[i].reset();
    CheckCacheCounters(options, 0, 0, 0, 0);
@@ -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 {
@@ -631,74 +631,6 @@ TEST_F(DBBlockCacheTest, CompressedCache) {
  }
 }

-TEST_F(DBBlockCacheTest, CacheCompressionDict) {
-  const int kNumFiles = 4;
-  const int kNumEntriesPerFile = 128;
-  const int kNumBytesPerEntry = 1024;
-
-  // Try all the available libraries that support dictionary compression
-  std::vector<CompressionType> compression_types;
-#ifdef ZLIB
-  compression_types.push_back(kZlibCompression);
-#endif  // ZLIB
-#if LZ4_VERSION_NUMBER >= 10400
-  compression_types.push_back(kLZ4Compression);
-  compression_types.push_back(kLZ4HCCompression);
-#endif  // LZ4_VERSION_NUMBER >= 10400
-#if ZSTD_VERSION_NUMBER >= 500
-  compression_types.push_back(kZSTD);
-#endif  // ZSTD_VERSION_NUMBER >= 500
-  Random rnd(301);
-  for (auto compression_type : compression_types) {
-    Options options = CurrentOptions();
-    options.compression = compression_type;
-    options.compression_opts.max_dict_bytes = 4096;
-    options.create_if_missing = true;
-    options.num_levels = 2;
-    options.statistics = rocksdb::CreateDBStatistics();
-    options.target_file_size_base = kNumEntriesPerFile * kNumBytesPerEntry;
-    BlockBasedTableOptions table_options;
-    table_options.cache_index_and_filter_blocks = true;
-    table_options.block_cache.reset(new MockCache());
-    options.table_factory.reset(new BlockBasedTableFactory(table_options));
-    DestroyAndReopen(options);
-
-    for (int i = 0; i < kNumFiles; ++i) {
-      ASSERT_EQ(i, NumTableFilesAtLevel(0, 0));
-      for (int j = 0; j < kNumEntriesPerFile; ++j) {
-        std::string value = RandomString(&rnd, kNumBytesPerEntry);
-        ASSERT_OK(Put(Key(j * kNumFiles + i), value.c_str()));
-      }
-      ASSERT_OK(Flush());
-    }
-    dbfull()->TEST_WaitForCompact();
-    ASSERT_EQ(0, NumTableFilesAtLevel(0));
-    ASSERT_EQ(kNumFiles, NumTableFilesAtLevel(1));
-
-    // Seek to a key in a file. It should cause the SST's dictionary meta-block
-    // to be read.
-    RecordCacheCounters(options);
-    ASSERT_EQ(0,
-              TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
-    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_ADD));
-    ASSERT_EQ(
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
-        0);
-    ReadOptions read_options;
-    ASSERT_NE("NOT_FOUND", Get(Key(kNumFiles * kNumEntriesPerFile - 1)));
-    // Two blocks missed/added: dictionary and data block
-    // One block hit: index since it's prefetched
-    CheckCacheCounters(options, 2 /* expected_misses */, 1 /* expected_hits */,
-                       2 /* expected_inserts */, 0 /* expected_failures */);
-    ASSERT_EQ(1,
-              TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
-    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_ADD));
-    ASSERT_GT(
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
-        0);
-  }
-}
-
 #endif  // ROCKSDB_LITE

 }  // namespace rocksdb
@@ -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) {
@@ -10,10 +10,8 @@
 #include "db/db_test_util.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
-#include "rocksdb/concurrent_task_limiter.h"
 #include "rocksdb/experimental.h"
 #include "rocksdb/utilities/convenience.h"
-#include "util/concurrent_task_limiter_impl.h"
 #include "util/fault_injection_test_env.h"
 #include "util/sync_point.h"

@@ -55,9 +53,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 +85,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]++;
  }
@@ -413,7 +412,6 @@ TEST_F(DBCompactionTest, SkipStatsUpdateTest) {

  // Reopen the DB with stats-update disabled
  options.skip_stats_update_on_db_open = true;
-  options.max_open_files = 20;
  env_->random_file_open_counter_.store(0);
  Reopen(options);

@@ -439,7 +437,7 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
  Options options = CurrentOptions();
  options.env = env_;
  options.new_table_reader_for_compaction_inputs = true;
-  options.max_open_files = 20;
+  options.max_open_files = 100;
  options.level0_file_num_compaction_trigger = 3;
  DestroyAndReopen(options);
  Random rnd(301);
@@ -468,16 +466,15 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
      Flush();
      dbfull()->TEST_WaitForCompact();
      // preloading iterator issues one table cache lookup and create
-      // a new table reader, if not preloaded.
-      int old_num_table_cache_lookup = num_table_cache_lookup;
-      ASSERT_GE(num_table_cache_lookup, 1);
+      // a new table reader.
+      ASSERT_EQ(num_table_cache_lookup, 1);
      ASSERT_EQ(num_new_table_reader, 1);

      num_table_cache_lookup = 0;
      num_new_table_reader = 0;
      ASSERT_EQ(Key(k), Get(Key(k)));
      // lookup iterator from table cache and no need to create a new one.
-      ASSERT_EQ(old_num_table_cache_lookup + num_table_cache_lookup, 2);
+      ASSERT_EQ(num_table_cache_lookup, 1);
      ASSERT_EQ(num_new_table_reader, 0);
    }
  }
@@ -490,10 +487,7 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
  // a new table reader. One file is created for flush and one for compaction.
  // Compaction inputs make no table cache look-up for data/range deletion
  // iterators
-  // May preload table cache too.
-  ASSERT_GE(num_table_cache_lookup, 2);
-  int old_num_table_cache_lookup2 = num_table_cache_lookup;
-
+  ASSERT_EQ(num_table_cache_lookup, 2);
  // Create new iterator for:
  // (1) 1 for verifying flush results
  // (2) 3 for compaction input files
@@ -503,7 +497,7 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
  num_table_cache_lookup = 0;
  num_new_table_reader = 0;
  ASSERT_EQ(Key(1), Get(Key(1)));
-  ASSERT_EQ(num_table_cache_lookup + old_num_table_cache_lookup2, 3);
+  ASSERT_EQ(num_table_cache_lookup, 1);
  ASSERT_EQ(num_new_table_reader, 0);

  num_table_cache_lookup = 0;
@@ -515,16 +509,14 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
  db_->CompactRange(cro, nullptr, nullptr);
  // Only verifying compaction outputs issues one table cache lookup
  // for both data block and range deletion block).
-  // May preload table cache too.
-  ASSERT_GE(num_table_cache_lookup, 1);
-  old_num_table_cache_lookup2 = num_table_cache_lookup;
+  ASSERT_EQ(num_table_cache_lookup, 1);
  // One for compaction input, one for verifying compaction results.
  ASSERT_EQ(num_new_table_reader, 2);

  num_table_cache_lookup = 0;
  num_new_table_reader = 0;
  ASSERT_EQ(Key(1), Get(Key(1)));
-  ASSERT_EQ(num_table_cache_lookup + old_num_table_cache_lookup2, 2);
+  ASSERT_EQ(num_table_cache_lookup, 1);
  ASSERT_EQ(num_new_table_reader, 0);

  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
@@ -1602,8 +1594,7 @@ TEST_F(DBCompactionTest, DeleteFileRange) {
  // Note that we don't delete level 0 files
  compact_options.change_level = true;
  compact_options.target_level = 1;
-  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
-  dbfull()->TEST_WaitForCompact();
+  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));

  ASSERT_OK(
      DeleteFilesInRange(db_, db_->DefaultColumnFamily(), nullptr, nullptr));
@@ -3899,192 +3890,6 @@ TEST_F(DBCompactionTest, CompactionHasEmptyOutput) {
  ASSERT_EQ(2, collector->num_ssts_creation_started());
 }

-TEST_F(DBCompactionTest, CompactionLimiter) {
-  const int kNumKeysPerFile = 10;
-  const int kMaxBackgroundThreads = 64;
-
-  struct CompactionLimiter {
-    std::string name;
-    int limit_tasks;
-    int max_tasks;
-    int tasks;
-    std::shared_ptr<ConcurrentTaskLimiter> limiter;
-  };
-
-  std::vector<CompactionLimiter> limiter_settings;
-  limiter_settings.push_back({"limiter_1", 1, 0, 0, nullptr});
-  limiter_settings.push_back({"limiter_2", 2, 0, 0, nullptr});
-  limiter_settings.push_back({"limiter_3", 3, 0, 0, nullptr});
-
-  for (auto& ls : limiter_settings) {
-    ls.limiter.reset(NewConcurrentTaskLimiter(ls.name, ls.limit_tasks));
-  }
-
-  std::shared_ptr<ConcurrentTaskLimiter> unique_limiter(
-    NewConcurrentTaskLimiter("unique_limiter", -1));
-
-  const char* cf_names[] = {"default", "0", "1", "2", "3", "4", "5",
-    "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
-  const int cf_count = sizeof cf_names / sizeof cf_names[0];
-
-  std::unordered_map<std::string, CompactionLimiter*> cf_to_limiter;
-
-  Options options = CurrentOptions();
-  options.write_buffer_size = 110 * 1024;  // 110KB
-  options.arena_block_size = 4096;
-  options.num_levels = 3;
-  options.level0_file_num_compaction_trigger = 4;
-  options.level0_slowdown_writes_trigger = 64;
-  options.level0_stop_writes_trigger = 64;
-  options.max_background_jobs = kMaxBackgroundThreads; // Enough threads
-  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));
-  options.max_write_buffer_number = 10; // Enough memtables
-  DestroyAndReopen(options);
-
-  std::vector<Options> option_vector;
-  option_vector.reserve(cf_count);
-
-  for (int cf = 0; cf < cf_count; cf++) {
-    ColumnFamilyOptions cf_opt(options);
-    if (cf == 0) {
-      // "Default" CF does't use compaction limiter
-      cf_opt.compaction_thread_limiter = nullptr;
-    } else if (cf == 1) {
-      // "1" CF uses bypass compaction limiter
-      unique_limiter->SetMaxOutstandingTask(-1);
-      cf_opt.compaction_thread_limiter = unique_limiter;
-    } else {
-      // Assign limiter by mod
-      auto& ls = limiter_settings[cf % 3];
-      cf_opt.compaction_thread_limiter = ls.limiter;
-      cf_to_limiter[cf_names[cf]] = &ls;
-    }
-    option_vector.emplace_back(DBOptions(options), cf_opt);
-  }
-
-  for (int cf = 1; cf < cf_count; cf++) {
-    CreateColumnFamilies({cf_names[cf]}, option_vector[cf]);
-  }
-
-  ReopenWithColumnFamilies(std::vector<std::string>(cf_names,
-                                                    cf_names + cf_count),
-                           option_vector);
-
-  port::Mutex mutex;
-
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-    "DBImpl::BackgroundCompaction:BeforeCompaction", [&](void* arg) {
-      const auto& cf_name = static_cast<ColumnFamilyData*>(arg)->GetName();
-      auto iter = cf_to_limiter.find(cf_name);
-      if (iter != cf_to_limiter.end()) {
-        MutexLock l(&mutex);
-        ASSERT_GE(iter->second->limit_tasks, ++iter->second->tasks);
-        iter->second->max_tasks = std::max(iter->second->max_tasks,
-              iter->second->limit_tasks);
-      }
-    });
-
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-    "DBImpl::BackgroundCompaction:AfterCompaction", [&](void* arg) {
-      const auto& cf_name = static_cast<ColumnFamilyData*>(arg)->GetName();
-      auto iter = cf_to_limiter.find(cf_name);
-      if (iter != cf_to_limiter.end()) {
-        MutexLock l(&mutex);
-        ASSERT_GE(--iter->second->tasks, 0);
-      }
-    });
-
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  // Block all compact threads in thread pool.
-  const size_t kTotalFlushTasks = kMaxBackgroundThreads / 4;
-  const size_t kTotalCompactTasks = kMaxBackgroundThreads - kTotalFlushTasks;
-  env_->SetBackgroundThreads((int)kTotalFlushTasks, Env::HIGH);
-  env_->SetBackgroundThreads((int)kTotalCompactTasks, Env::LOW);
-
-  test::SleepingBackgroundTask sleeping_compact_tasks[kTotalCompactTasks];
-
-  // Block all compaction threads in thread pool.
-  for (size_t i = 0; i < kTotalCompactTasks; i++) {
-    env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask,
-                   &sleeping_compact_tasks[i], Env::LOW);
-    sleeping_compact_tasks[i].WaitUntilSleeping();
-  }
-
-  int keyIndex = 0;
-
-  for (int n = 0; n < options.level0_file_num_compaction_trigger; n++) {
-    for (int cf = 0; cf < cf_count; cf++) {
-      for (int i = 0; i < kNumKeysPerFile; i++) {
-        ASSERT_OK(Put(cf, Key(keyIndex++), ""));
-      }
-      // put extra key to trigger flush
-      ASSERT_OK(Put(cf, "", ""));
-    }
-
-    for (int cf = 0; cf < cf_count; cf++) {
-      dbfull()->TEST_WaitForFlushMemTable(handles_[cf]);
-    }
-  }
-
-  // Enough L0 files to trigger compaction
-  for (int cf = 0; cf < cf_count; cf++) {
-    ASSERT_EQ(NumTableFilesAtLevel(0, cf),
-      options.level0_file_num_compaction_trigger);
-  }
-
-  // Create more files for one column family, which triggers speed up
-  // condition, all compactions will be scheduled.
-  for (int num = 0; num < options.level0_file_num_compaction_trigger; num++) {
-    for (int i = 0; i < kNumKeysPerFile; i++) {
-      ASSERT_OK(Put(0, Key(i), ""));
-    }
-    // put extra key to trigger flush
-    ASSERT_OK(Put(0, "", ""));
-    dbfull()->TEST_WaitForFlushMemTable(handles_[0]);
-    ASSERT_EQ(options.level0_file_num_compaction_trigger + num + 1,
-              NumTableFilesAtLevel(0, 0));
-  }
-
-  // All CFs are pending compaction
-  ASSERT_EQ(cf_count, env_->GetThreadPoolQueueLen(Env::LOW));
-
-  // Unblock all compaction threads
-  for (size_t i = 0; i < kTotalCompactTasks; i++) {
-    sleeping_compact_tasks[i].WakeUp();
-    sleeping_compact_tasks[i].WaitUntilDone();
-  }
-
-  for (int cf = 0; cf < cf_count; cf++) {
-    dbfull()->TEST_WaitForFlushMemTable(handles_[cf]);
-  }
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  // Max outstanding compact tasks reached limit
-  for (auto& ls : limiter_settings) {
-    ASSERT_EQ(ls.limit_tasks, ls.max_tasks);
-    ASSERT_EQ(0, ls.limiter->GetOutstandingTask());
-  }
-
-  // test manual compaction under a fully throttled limiter
-  int cf_test = 1;
-  unique_limiter->SetMaxOutstandingTask(0);
-
-  // flush one more file to cf 1
-  for (int i = 0; i < kNumKeysPerFile; i++) {
-      ASSERT_OK(Put(cf_test, Key(keyIndex++), ""));
-  }
-  // put extra key to trigger flush
-  ASSERT_OK(Put(cf_test, "", ""));
-
-  dbfull()->TEST_WaitForFlushMemTable(handles_[cf_test]);
-  ASSERT_EQ(1, NumTableFilesAtLevel(0, cf_test));
-
-  Compact(cf_test, Key(0), Key(keyIndex));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-}
-
 INSTANTIATE_TEST_CASE_P(DBCompactionTestWithParam, DBCompactionTestWithParam,
                        ::testing::Values(std::make_tuple(1, true),
                                          std::make_tuple(1, false),
@@ -4186,14 +3991,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"
@@ -389,15 +387,16 @@ 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) {
@@ -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,114 +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
@@ -772,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
@@ -926,21 +819,6 @@ Status DBImpl::SetDBOptions(
            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();
-        }
-      }
      write_controller_.set_max_delayed_write_rate(
          new_options.delayed_write_rate);
      table_cache_.get()->SetCapacity(new_options.max_open_files == -1
@@ -1338,7 +1216,6 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
                       PinnableSlice* pinnable_val, bool* value_found,
                       ReadCallback* callback, bool* is_blob_index) {
  assert(pinnable_val != nullptr);
-  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
  StopWatch sw(env_, stats_, DB_GET);
  PERF_TIMER_GUARD(get_snapshot_time);

@@ -1441,13 +1318,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);
-    }
+    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;
 }
@@ -1456,7 +1330,6 @@ std::vector<Status> DBImpl::MultiGet(
    const ReadOptions& read_options,
    const std::vector<ColumnFamilyHandle*>& column_family,
    const std::vector<Slice>& keys, std::vector<std::string>* values) {
-  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
  StopWatch sw(env_, stats_, DB_MULTIGET);
  PERF_TIMER_GUARD(get_snapshot_time);

@@ -1465,96 +1338,33 @@ std::vector<Status> DBImpl::MultiGet(
  struct MultiGetColumnFamilyData {
    ColumnFamilyData* cfd;
    SuperVersion* super_version;
-    MultiGetColumnFamilyData(ColumnFamilyData* cf, SuperVersion* sv)
-        : cfd(cf), super_version(sv) {}
  };
-  std::unordered_map<uint32_t, MultiGetColumnFamilyData> multiget_cf_data(
-      column_family.size());
+  std::unordered_map<uint32_t, MultiGetColumnFamilyData*> multiget_cf_data;
+  // fill up and allocate outside of mutex
  for (auto cf : column_family) {
    auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(cf);
    auto cfd = cfh->cfd();
    if (multiget_cf_data.find(cfd->GetID()) == multiget_cf_data.end()) {
-      multiget_cf_data.emplace(cfd->GetID(),
-                               MultiGetColumnFamilyData(cfd, nullptr));
+      auto mgcfd = new MultiGetColumnFamilyData();
+      mgcfd->cfd = cfd;
+      multiget_cf_data.insert({cfd->GetID(), mgcfd});
    }
  }

-  bool last_try = false;
-  {
-    // If we end up with the same issue of memtable geting sealed during 2
-    // consecutive retries, it means the write rate is very high. In that case
-    // its probably ok to take the mutex on the 3rd try so we can succeed for
-    // sure
-    static const int num_retries = 3;
-    for (auto i = 0; i < num_retries; ++i) {
-      last_try = (i == num_retries - 1);
-      bool retry = false;
-
-      if (i > 0) {
-        for (auto mgd_iter = multiget_cf_data.begin();
-             mgd_iter != multiget_cf_data.end(); ++mgd_iter) {
-          auto super_version = mgd_iter->second.super_version;
-          auto cfd = mgd_iter->second.cfd;
-          if (super_version != nullptr) {
-            ReturnAndCleanupSuperVersion(cfd, super_version);
-          }
-          mgd_iter->second.super_version = nullptr;
-        }
-      }
-
-      if (read_options.snapshot == nullptr) {
-        if (last_try) {
-          TEST_SYNC_POINT("DBImpl::MultiGet::LastTry");
-          // We're close to max number of retries. For the last retry,
-          // acquire the lock so we're sure to succeed
-          mutex_.Lock();
-        }
-        snapshot = last_seq_same_as_publish_seq_
-                       ? versions_->LastSequence()
-                       : versions_->LastPublishedSequence();
-      } else {
-        snapshot = reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)
-                       ->number_;
-      }
-
-      for (auto mgd_iter = multiget_cf_data.begin();
-           mgd_iter != multiget_cf_data.end(); ++mgd_iter) {
-        if (!last_try) {
-          mgd_iter->second.super_version =
-              GetAndRefSuperVersion(mgd_iter->second.cfd);
-        } else {
-          mgd_iter->second.super_version =
-              mgd_iter->second.cfd->GetSuperVersion()->Ref();
-        }
-        TEST_SYNC_POINT("DBImpl::MultiGet::AfterRefSV");
-        if (read_options.snapshot != nullptr || last_try) {
-          // If user passed a snapshot, then we don't care if a memtable is
-          // sealed or compaction happens because the snapshot would ensure
-          // that older key versions are kept around. If this is the last
-          // retry, then we have the lock so nothing bad can happen
-          continue;
-        }
-        // We could get the earliest sequence number for the whole list of
-        // memtables, which will include immutable memtables as well, but that
-        // might be tricky to maintain in case we decide, in future, to do
-        // memtable compaction.
-        if (!last_try) {
-          auto seq =
-              mgd_iter->second.super_version->mem->GetEarliestSequenceNumber();
-          if (seq > snapshot) {
-            retry = true;
-            break;
-          }
-        }
-      }
-      if (!retry) {
-        if (last_try) {
-          mutex_.Unlock();
-        }
-        break;
-      }
-    }
+  mutex_.Lock();
+  if (read_options.snapshot != nullptr) {
+    snapshot =
+        reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)->number_;
+  } else {
+    snapshot = last_seq_same_as_publish_seq_
+                   ? versions_->LastSequence()
+                   : versions_->LastPublishedSequence();
  }
+  for (auto mgd_iter : multiget_cf_data) {
+    mgd_iter.second->super_version =
+        mgd_iter.second->cfd->GetSuperVersion()->Ref();
+  }
+  mutex_.Unlock();

  // Contain a list of merge operations if merge occurs.
  MergeContext merge_context;
@@ -1584,7 +1394,7 @@ std::vector<Status> DBImpl::MultiGet(
    auto mgd_iter = multiget_cf_data.find(cfh->cfd()->GetID());
    assert(mgd_iter != multiget_cf_data.end());
    auto mgd = mgd_iter->second;
-    auto super_version = mgd.super_version;
+    auto super_version = mgd->super_version;
    bool skip_memtable =
        (read_options.read_tier == kPersistedTier &&
         has_unpersisted_data_.load(std::memory_order_relaxed));
@@ -1620,14 +1430,24 @@ std::vector<Status> DBImpl::MultiGet(
  PERF_TIMER_GUARD(get_post_process_time);
  autovector<SuperVersion*> superversions_to_delete;

+  // TODO(icanadi) do we need lock here or just around Cleanup()?
+  mutex_.Lock();
  for (auto mgd_iter : multiget_cf_data) {
    auto mgd = mgd_iter.second;
-    if (!last_try) {
-      ReturnAndCleanupSuperVersion(mgd.cfd, mgd.super_version);
-    } else {
-      mgd.cfd->GetSuperVersion()->Unref();
+    if (mgd->super_version->Unref()) {
+      mgd->super_version->Cleanup();
+      superversions_to_delete.push_back(mgd->super_version);
    }
  }
+  mutex_.Unlock();
+
+  for (auto td : superversions_to_delete) {
+    delete td;
+  }
+  for (auto mgd : multiget_cf_data) {
+    delete mgd.second;
+  }
+
  RecordTick(stats_, NUMBER_MULTIGET_CALLS);
  RecordTick(stats_, NUMBER_MULTIGET_KEYS_READ, num_keys);
  RecordTick(stats_, NUMBER_MULTIGET_KEYS_FOUND, num_found);
@@ -2046,7 +1866,7 @@ Status DBImpl::NewIterators(
  if (read_options.tailing) {
 #ifdef ROCKSDB_LITE
    return Status::InvalidArgument(
-        "Tailing iterator not supported in RocksDB lite");
+        "Tailing interator not supported in RocksDB lite");
 #else
    for (auto cfh : column_families) {
      auto cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(cfh)->cfd();
@@ -2085,32 +1905,21 @@ const Snapshot* DBImpl::GetSnapshotForWriteConflictBoundary() {
 }
 #endif  // ROCKSDB_LITE

-SnapshotImpl* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary,
-                                      bool lock) {
+SnapshotImpl* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary) {
  int64_t unix_time = 0;
  env_->GetCurrentTime(&unix_time);  // Ignore error
  SnapshotImpl* s = new SnapshotImpl;

-  if (lock) {
-    mutex_.Lock();
-  }
+  InstrumentedMutexLock l(&mutex_);
  // returns null if the underlying memtable does not support snapshot.
  if (!is_snapshot_supported_) {
-    if (lock) {
-      mutex_.Unlock();
-    }
    delete s;
    return nullptr;
  }
  auto snapshot_seq = last_seq_same_as_publish_seq_
                          ? versions_->LastSequence()
                          : versions_->LastPublishedSequence();
-  SnapshotImpl* snapshot =
-      snapshots_.New(s, snapshot_seq, unix_time, is_write_conflict_boundary);
-  if (lock) {
-    mutex_.Unlock();
-  }
-  return snapshot;
+  return snapshots_.New(s, snapshot_seq, unix_time, is_write_conflict_boundary);
 }

 void DBImpl::ReleaseSnapshot(const Snapshot* s) {
@@ -2578,9 +2387,9 @@ Status DBImpl::DeleteFile(std::string name) {
    status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                    &edit, &mutex_, directories_.GetDbDir());
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd,
-                                         &job_context.superversion_contexts[0],
-                                         *cfd->GetLatestMutableCFOptions());
+      InstallSuperVersionAndScheduleWork(
+          cfd, &job_context.superversion_contexts[0],
+          *cfd->GetLatestMutableCFOptions(), FlushReason::kDeleteFiles);
    }
    FindObsoleteFiles(&job_context, false);
  }  // lock released here
@@ -2663,9 +2472,9 @@ Status DBImpl::DeleteFilesInRanges(ColumnFamilyHandle* column_family,
    status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                    &edit, &mutex_, directories_.GetDbDir());
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd,
-                                         &job_context.superversion_contexts[0],
-                                         *cfd->GetLatestMutableCFOptions());
+      InstallSuperVersionAndScheduleWork(
+          cfd, &job_context.superversion_contexts[0],
+          *cfd->GetLatestMutableCFOptions(), FlushReason::kDeleteFiles);
    }
    for (auto* deleted_file : deleted_files) {
      deleted_file->being_compacted = false;
@@ -3055,15 +2864,11 @@ Status DBImpl::RenameTempFileToOptionsFile(const std::string& file_name) {
 #ifndef ROCKSDB_LITE
  Status s;

-  uint64_t options_file_number = versions_->NewFileNumber();
+  versions_->options_file_number_ = versions_->NewFileNumber();
  std::string options_file_name =
-      OptionsFileName(GetName(), options_file_number);
+      OptionsFileName(GetName(), versions_->options_file_number_);
  // Retry if the file name happen to conflict with an existing one.
  s = GetEnv()->RenameFile(file_name, options_file_name);
-  if (s.ok()) {
-    InstrumentedMutexLock l(&mutex_);
-    versions_->options_file_number_ = options_file_number;
-  }

  if (0 == disable_delete_obsolete_files_) {
    DeleteObsoleteOptionsFiles();
@@ -3114,8 +2919,6 @@ void DumpRocksDBBuildVersion(Logger* log) {
                   ROCKSDB_MINOR, ROCKSDB_PATCH);
  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"
 #endif
 }

@@ -3234,124 +3037,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");

@@ -3363,133 +3116,56 @@ 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,
+                                         FlushReason::kExternalFileIngestion);
    }

    // Resume writes to the DB
@@ -3498,36 +3174,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;
 }

@@ -3647,35 +3317,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,10 +63,8 @@ namespace rocksdb {

 class Arena;
 class ArenaWrappedDBIter;
-class InMemoryStatsHistoryIterator;
 class MemTable;
 class TableCache;
-class TaskLimiterToken;
 class Version;
 class VersionEdit;
 class VersionSet;
@@ -193,13 +191,13 @@ class DBImpl : public DB {
                              const Slice* begin, const Slice* end) override;

  using DB::CompactFiles;
-  virtual Status CompactFiles(
-      const CompactionOptions& compact_options,
-      ColumnFamilyHandle* column_family,
-      const std::vector<std::string>& input_file_names, const int output_level,
-      const int output_path_id = -1,
-      std::vector<std::string>* const output_file_names = nullptr,
-      CompactionJobInfo* compaction_job_info = nullptr) override;
+  virtual Status CompactFiles(const CompactionOptions& compact_options,
+                              ColumnFamilyHandle* column_family,
+                              const std::vector<std::string>& input_file_names,
+                              const int output_level,
+                              const int output_path_id = -1,
+                              std::vector<std::string>* const output_file_names
+                              = nullptr) override;

  virtual Status PauseBackgroundWork() override;
  virtual Status ContinueBackgroundWork() override;
@@ -239,13 +237,6 @@ class DBImpl : public DB {
  virtual Status SyncWAL() override;

  virtual SequenceNumber GetLatestSequenceNumber() const override;
-  virtual SequenceNumber GetLastPublishedSequence() const {
-    if (last_seq_same_as_publish_seq_) {
-      return versions_->LastSequence();
-    } else {
-      return versions_->LastPublishedSequence();
-    }
-  }
  // REQUIRES: joined the main write queue if two_write_queues is disabled, and
  // the second write queue otherwise.
  virtual void SetLastPublishedSequence(SequenceNumber seq);
@@ -347,10 +338,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;
@@ -483,10 +470,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

@@ -708,12 +692,6 @@ class DBImpl : public DB {

  void SetSnapshotChecker(SnapshotChecker* snapshot_checker);

-  // Fill JobContext with snapshot information needed by flush and compaction.
-  void GetSnapshotContext(JobContext* job_context,
-                          std::vector<SequenceNumber>* snapshot_seqs,
-                          SequenceNumber* earliest_write_conflict_snapshot,
-                          SnapshotChecker** snapshot_checker);
-
  // Not thread-safe.
  void SetRecoverableStatePreReleaseCallback(PreReleaseCallback* callback);

@@ -732,17 +710,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_;
@@ -942,13 +909,11 @@ class DBImpl : public DB {
  // Flush the in-memory write buffer to storage.  Switches to a new
  // log-file/memtable and writes a new descriptor iff successful. Then
  // installs a new super version for the column family.
-  Status FlushMemTableToOutputFile(
-      ColumnFamilyData* cfd, const MutableCFOptions& mutable_cf_options,
-      bool* madeProgress, JobContext* job_context,
-      SuperVersionContext* superversion_context,
-      std::vector<SequenceNumber>& snapshot_seqs,
-      SequenceNumber earliest_write_conflict_snapshot,
-      SnapshotChecker* snapshot_checker, LogBuffer* log_buffer);
+  Status FlushMemTableToOutputFile(ColumnFamilyData* cfd,
+                                   const MutableCFOptions& mutable_cf_options,
+                                   bool* madeProgress, JobContext* job_context,
+                                   SuperVersionContext* superversion_context,
+                                   LogBuffer* log_buffer);

  // Argument required by background flush thread.
  struct BGFlushArg {
@@ -1085,8 +1050,7 @@ class DBImpl : public DB {
                          const std::vector<std::string>& input_file_names,
                          std::vector<std::string>* const output_file_names,
                          const int output_level, int output_path_id,
-                          JobContext* job_context, LogBuffer* log_buffer,
-                          CompactionJobInfo* compaction_job_info);
+                          JobContext* job_context, LogBuffer* log_buffer);

  // Wait for current IngestExternalFile() calls to finish.
  // REQUIRES: mutex_ held
@@ -1139,22 +1103,11 @@ class DBImpl : public DB {
                               const std::vector<CompactionInputFiles>& inputs,
                               bool* sfm_bookkeeping, LogBuffer* log_buffer);

-  // Request compaction tasks token from compaction thread limiter.
-  // It always succeeds if force = true or limiter is disable.
-  bool RequestCompactionToken(ColumnFamilyData* cfd, bool force,
-                              std::unique_ptr<TaskLimiterToken>* token,
-                              LogBuffer* log_buffer);
-
  // Schedule background tasks
  void StartTimedTasks();

  void PrintStatistics();

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

@@ -1173,15 +1126,10 @@ class DBImpl : public DB {
  ColumnFamilyData* PopFirstFromCompactionQueue();
  FlushRequest PopFirstFromFlushQueue();

-  // Pick the first unthrottled compaction with task token from queue.
-  ColumnFamilyData* PickCompactionFromQueue(
-      std::unique_ptr<TaskLimiterToken>* token, LogBuffer* log_buffer);
-
  // helper function to call after some of the logs_ were synced
  void MarkLogsSynced(uint64_t up_to, bool synced_dir, const Status& status);

-  SnapshotImpl* GetSnapshotImpl(bool is_write_conflict_boundary,
-                                bool lock = true);
+  SnapshotImpl* GetSnapshotImpl(bool is_write_conflict_boundary);

  uint64_t GetMaxTotalWalSize() const;

@@ -1197,8 +1145,6 @@ 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
@@ -1321,12 +1267,6 @@ class DBImpl : public DB {

  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:
@@ -1412,7 +1352,7 @@ class DBImpl : public DB {
  // compacted. Consumers of these queues are flush and compaction threads. When
  // column family is put on this queue, we increase unscheduled_flushes_ and
  // unscheduled_compactions_. When these variables are bigger than zero, that
-  // means we need to schedule background threads for flush and compaction.
+  // means we need to schedule background threads for compaction and thread.
  // Once the background threads are scheduled, we decrease unscheduled_flushes_
  // and unscheduled_compactions_. That way we keep track of number of
  // compaction and flush threads we need to schedule. This scheduling is done
@@ -1479,8 +1419,6 @@ class DBImpl : public DB {
    // caller retains ownership of `manual_compaction_state` as it is reused
    // across background compactions.
    ManualCompactionState* manual_compaction_state;  // nullptr if non-manual
-    // task limiter token is requested during compaction picking.
-    std::unique_ptr<TaskLimiterToken> task_token;
  };
  std::deque<ManualCompactionState*> manual_compaction_dequeue_;

@@ -1520,7 +1458,7 @@ class DBImpl : public DB {
  std::atomic<bool> has_unpersisted_data_;

  // if an attempt was made to flush all column families that
-  // the oldest log depends on but uncommitted data in the oldest
+  // the oldest log depends on but uncommited data in the oldest
  // log prevents the log from being released.
  // We must attempt to free the dependent memtables again
  // at a later time after the transaction in the oldest
@@ -1572,14 +1510,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&);
@@ -1593,7 +1527,8 @@ class DBImpl : public DB {
  // state needs flush or compaction.
  void InstallSuperVersionAndScheduleWork(
      ColumnFamilyData* cfd, SuperVersionContext* sv_context,
-      const MutableCFOptions& mutable_cf_options);
+      const MutableCFOptions& mutable_cf_options,
+      FlushReason flush_reason = FlushReason::kOthers);

 #ifndef ROCKSDB_LITE
  using DB::GetPropertiesOfAllTables;
@@ -1618,20 +1553,6 @@ class DBImpl : public DB {
  bool ShouldntRunManualCompaction(ManualCompactionState* m);
  bool HaveManualCompaction(ColumnFamilyData* cfd);
  bool MCOverlap(ManualCompactionState* m, ManualCompactionState* m1);
-#ifndef ROCKSDB_LITE
-  void BuildCompactionJobInfo(const ColumnFamilyData* cfd, Compaction* c,
-                              const Status& st,
-                              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

  bool ShouldPurge(uint64_t file_number) const;
  void MarkAsGrabbedForPurge(uint64_t file_number);
@@ -20,7 +20,6 @@
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/thread_status_updater.h"
 #include "monitoring/thread_status_util.h"
-#include "util/concurrent_task_limiter_impl.h"
 #include "util/sst_file_manager_impl.h"
 #include "util/sync_point.h"

@@ -60,27 +59,6 @@ bool DBImpl::EnoughRoomForCompaction(
  return enough_room;
 }

-bool DBImpl::RequestCompactionToken(ColumnFamilyData* cfd, bool force,
-                                    std::unique_ptr<TaskLimiterToken>* token,
-                                    LogBuffer* log_buffer) {
-  assert(*token == nullptr);
-  auto limiter = static_cast<ConcurrentTaskLimiterImpl*>(
-      cfd->ioptions()->compaction_thread_limiter.get());
-  if (limiter == nullptr) {
-    return true;
-  }
-  *token = limiter->GetToken(force);
-  if (*token != nullptr) {
-    ROCKS_LOG_BUFFER(log_buffer,
-                     "Thread limiter [%s] increase [%s] compaction task, "
-                     "force: %s, tasks after: %d",
-                     limiter->GetName().c_str(), cfd->GetName().c_str(),
-                     force ? "true" : "false", limiter->GetOutstandingTask());
-    return true;
-  }
-  return false;
-}
-
 Status DBImpl::SyncClosedLogs(JobContext* job_context) {
  TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Start");
  mutex_.AssertHeld();
@@ -132,15 +110,19 @@ Status DBImpl::SyncClosedLogs(JobContext* job_context) {
 Status DBImpl::FlushMemTableToOutputFile(
    ColumnFamilyData* cfd, const MutableCFOptions& mutable_cf_options,
    bool* made_progress, JobContext* job_context,
-    SuperVersionContext* superversion_context,
-    std::vector<SequenceNumber>& snapshot_seqs,
-    SequenceNumber earliest_write_conflict_snapshot,
-    SnapshotChecker* snapshot_checker, LogBuffer* log_buffer) {
+    SuperVersionContext* superversion_context, LogBuffer* log_buffer) {
  mutex_.AssertHeld();
  assert(cfd->imm()->NumNotFlushed() != 0);
  assert(cfd->imm()->IsFlushPending());

+  SequenceNumber earliest_write_conflict_snapshot;
+  std::vector<SequenceNumber> snapshot_seqs =
+      snapshots_.GetAll(&earliest_write_conflict_snapshot);

+  auto snapshot_checker = snapshot_checker_.get();
+  if (use_custom_gc_ && snapshot_checker == nullptr) {
+    snapshot_checker = DisableGCSnapshotChecker::Instance();
+  }
  FlushJob flush_job(
      dbname_, cfd, immutable_db_options_, mutable_cf_options,
      nullptr /* memtable_id */, env_options_for_compaction_, versions_.get(),
@@ -237,20 +219,14 @@ Status DBImpl::FlushMemTablesToOutputFiles(
    return AtomicFlushMemTablesToOutputFiles(bg_flush_args, made_progress,
                                             job_context, log_buffer);
  }
-  std::vector<SequenceNumber> snapshot_seqs;
-  SequenceNumber earliest_write_conflict_snapshot;
-  SnapshotChecker* snapshot_checker;
-  GetSnapshotContext(job_context, &snapshot_seqs,
-                     &earliest_write_conflict_snapshot, &snapshot_checker);
  Status status;
  for (auto& arg : bg_flush_args) {
    ColumnFamilyData* cfd = arg.cfd_;
    MutableCFOptions mutable_cf_options = *cfd->GetLatestMutableCFOptions();
    SuperVersionContext* superversion_context = arg.superversion_context_;
-    Status s = FlushMemTableToOutputFile(
-        cfd, mutable_cf_options, made_progress, job_context,
-        superversion_context, snapshot_seqs, earliest_write_conflict_snapshot,
-        snapshot_checker, log_buffer);
+    Status s = FlushMemTableToOutputFile(cfd, mutable_cf_options, made_progress,
+                                         job_context, superversion_context,
+                                         log_buffer);
    if (!s.ok()) {
      status = s;
      if (!s.IsShutdownInProgress()) {
@@ -289,14 +265,15 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
  }
 #endif /* !NDEBUG */

-  std::vector<SequenceNumber> snapshot_seqs;
  SequenceNumber earliest_write_conflict_snapshot;
-  SnapshotChecker* snapshot_checker;
-  GetSnapshotContext(job_context, &snapshot_seqs,
-                     &earliest_write_conflict_snapshot, &snapshot_checker);
+  std::vector<SequenceNumber> snapshot_seqs =
+      snapshots_.GetAll(&earliest_write_conflict_snapshot);

+  auto snapshot_checker = snapshot_checker_.get();
+  if (use_custom_gc_ && snapshot_checker == nullptr) {
+    snapshot_checker = DisableGCSnapshotChecker::Instance();
+  }
  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());
@@ -304,20 +281,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);
    }

@@ -325,7 +300,7 @@ 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(),
@@ -555,7 +530,6 @@ void DBImpl::NotifyOnFlushBegin(ColumnFamilyData* cfd, FileMetaData* file_meta,
  mutex_.Unlock();
  {
    FlushJobInfo info;
-    info.cf_id = cfd->GetID();
    info.cf_name = cfd->GetName();
    // TODO(yhchiang): make db_paths dynamic in case flush does not
    //                 go to L0 in the future.
@@ -607,7 +581,6 @@ void DBImpl::NotifyOnFlushCompleted(ColumnFamilyData* cfd,
  mutex_.Unlock();
  {
    FlushJobInfo info;
-    info.cf_id = cfd->GetID();
    info.cf_name = cfd->GetName();
    // TODO(yhchiang): make db_paths dynamic in case flush does not
    //                 go to L0 in the future.
@@ -781,8 +754,7 @@ Status DBImpl::CompactFiles(const CompactionOptions& compact_options,
                            ColumnFamilyHandle* column_family,
                            const std::vector<std::string>& input_file_names,
                            const int output_level, const int output_path_id,
-                            std::vector<std::string>* const output_file_names,
-                            CompactionJobInfo* compaction_job_info) {
+                            std::vector<std::string>* const output_file_names) {
 #ifdef ROCKSDB_LITE
  (void)compact_options;
  (void)column_family;
@@ -790,7 +762,6 @@ Status DBImpl::CompactFiles(const CompactionOptions& compact_options,
  (void)output_level;
  (void)output_path_id;
  (void)output_file_names;
-  (void)compaction_job_info;
  // not supported in lite version
  return Status::NotSupported("Not supported in ROCKSDB LITE");
 #else
@@ -822,7 +793,7 @@ Status DBImpl::CompactFiles(const CompactionOptions& compact_options,

    s = CompactFilesImpl(compact_options, cfd, current, input_file_names,
                         output_file_names, output_level, output_path_id,
-                         &job_context, &log_buffer, compaction_job_info);
+                         &job_context, &log_buffer);

    current->Unref();
  }
@@ -862,8 +833,7 @@ Status DBImpl::CompactFilesImpl(
    const CompactionOptions& compact_options, ColumnFamilyData* cfd,
    Version* version, const std::vector<std::string>& input_file_names,
    std::vector<std::string>* const output_file_names, const int output_level,
-    int output_path_id, JobContext* job_context, LogBuffer* log_buffer,
-    CompactionJobInfo* compaction_job_info) {
+    int output_path_id, JobContext* job_context, LogBuffer* log_buffer) {
  mutex_.AssertHeld();

  if (shutting_down_.load(std::memory_order_acquire)) {
@@ -937,17 +907,18 @@ Status DBImpl::CompactFilesImpl(
  // deletion compaction currently not allowed in CompactFiles.
  assert(!c->deletion_compaction());

-  std::vector<SequenceNumber> snapshot_seqs;
  SequenceNumber earliest_write_conflict_snapshot;
-  SnapshotChecker* snapshot_checker;
-  GetSnapshotContext(job_context, &snapshot_seqs,
-                     &earliest_write_conflict_snapshot, &snapshot_checker);
+  std::vector<SequenceNumber> snapshot_seqs =
+      snapshots_.GetAll(&earliest_write_conflict_snapshot);

  auto pending_outputs_inserted_elem =
      CaptureCurrentFileNumberInPendingOutputs();

+  auto snapshot_checker = snapshot_checker_.get();
+  if (use_custom_gc_ && snapshot_checker == nullptr) {
+    snapshot_checker = DisableGCSnapshotChecker::Instance();
+  }
  assert(is_snapshot_supported_ || snapshots_.empty());
-  CompactionJobStats compaction_job_stats;
  CompactionJob compaction_job(
      job_context->job_id, c.get(), immutable_db_options_,
      env_options_for_compaction_, versions_.get(), &shutting_down_,
@@ -957,7 +928,19 @@ 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);
+      nullptr);  // Here we pass a nullptr for CompactionJobStats because
+                 // CompactFiles does not trigger OnCompactionCompleted(),
+                 // which is the only place where CompactionJobStats is
+                 // returned.  The idea of not triggering OnCompationCompleted()
+                 // is that CompactFiles runs in the caller thread, so the user
+                 // should always know when it completes.  As a result, it makes
+                 // less sense to notify the users something they should already
+                 // know.
+                 //
+                 // In the future, if we would like to add CompactionJobStats
+                 // support for CompactFiles, we should have CompactFiles API
+                 // pass a pointer of CompactionJobStats as the out-value
+                 // instead of using EventListener.

  // Creating a compaction influences the compaction score because the score
  // takes running compactions into account (by skipping files that are already
@@ -978,9 +961,9 @@ Status DBImpl::CompactFilesImpl(

  Status status = compaction_job.Install(*c->mutable_cf_options());
  if (status.ok()) {
-    InstallSuperVersionAndScheduleWork(c->column_family_data(),
-                                       &job_context->superversion_contexts[0],
-                                       *c->mutable_cf_options());
+    InstallSuperVersionAndScheduleWork(
+        c->column_family_data(), &job_context->superversion_contexts[0],
+        *c->mutable_cf_options(), FlushReason::kManualCompaction);
  }
  c->ReleaseCompactionFiles(s);
 #ifndef ROCKSDB_LITE
@@ -994,11 +977,6 @@ Status DBImpl::CompactFilesImpl(

  ReleaseFileNumberFromPendingOutputs(pending_outputs_inserted_elem);

-  if (compaction_job_info != nullptr) {
-    BuildCompactionJobInfo(cfd, c.get(), s, compaction_job_stats,
-                           job_context->job_id, version, compaction_job_info);
-  }
-
  if (status.ok()) {
    // Done
  } else if (status.IsShutdownInProgress()) {
@@ -1026,7 +1004,6 @@ Status DBImpl::CompactFilesImpl(
  if (bg_compaction_scheduled_ == 0) {
    bg_cv_.SignalAll();
  }
-  MaybeScheduleFlushOrCompaction();
  TEST_SYNC_POINT("CompactFilesImpl:End");

  return status;
@@ -1142,8 +1119,36 @@ void DBImpl::NotifyOnCompactionCompleted(
  TEST_SYNC_POINT("DBImpl::NotifyOnCompactionCompleted::UnlockMutex");
  {
    CompactionJobInfo info;
-    BuildCompactionJobInfo(cfd, c, st, compaction_job_stats, job_id, current,
-                           &info);
+    info.cf_id = cfd->GetID();
+    info.cf_name = cfd->GetName();
+    info.status = st;
+    info.thread_id = env_->GetThreadID();
+    info.job_id = job_id;
+    info.base_input_level = c->start_level();
+    info.output_level = c->output_level();
+    info.stats = compaction_job_stats;
+    info.table_properties = c->GetOutputTableProperties();
+    info.compaction_reason = c->compaction_reason();
+    info.compression = c->output_compression();
+    for (size_t i = 0; i < c->num_input_levels(); ++i) {
+      for (const auto fmd : *c->inputs(i)) {
+        auto fn = TableFileName(c->immutable_cf_options()->cf_paths,
+                                fmd->fd.GetNumber(), fmd->fd.GetPathId());
+        info.input_files.push_back(fn);
+        if (info.table_properties.count(fn) == 0) {
+          std::shared_ptr<const TableProperties> tp;
+          auto s = current->GetTableProperties(&tp, fmd, &fn);
+          if (s.ok()) {
+            info.table_properties[fn] = tp;
+          }
+        }
+      }
+    }
+    for (const auto newf : c->edit()->GetNewFiles()) {
+      info.output_files.push_back(TableFileName(
+          c->immutable_cf_options()->cf_paths, newf.second.fd.GetNumber(),
+          newf.second.fd.GetPathId()));
+    }
    for (auto listener : immutable_db_options_.listeners) {
      listener->OnCompactionCompleted(this, info);
    }
@@ -1398,8 +1403,6 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
  ROCKS_LOG_INFO(immutable_db_options_.info_log,
                 "[%s] Manual compaction starting", cfd->GetName().c_str());

-  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL,
-                       immutable_db_options_.info_log.get());
  // We don't check bg_error_ here, because if we get the error in compaction,
  // the compaction will set manual.status to bg_error_ and set manual.done to
  // true.
@@ -1437,11 +1440,6 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
      ca->prepicked_compaction = new PrepickedCompaction;
      ca->prepicked_compaction->manual_compaction_state = &manual;
      ca->prepicked_compaction->compaction = compaction;
-      if (!RequestCompactionToken(
-              cfd, true, &ca->prepicked_compaction->task_token, &log_buffer)) {
-        // Don't throttle manual compaction, only count outstanding tasks.
-        assert(false);
-      }
      manual.incomplete = false;
      bg_compaction_scheduled_++;
      env_->Schedule(&DBImpl::BGWorkCompaction, ca, Env::Priority::LOW, this,
@@ -1450,7 +1448,6 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
    }
  }

-  log_buffer.FlushBufferToLog();
  assert(!manual.in_progress);
  assert(HasPendingManualCompaction());
  RemoveManualCompaction(&manual);
@@ -1886,32 +1883,6 @@ DBImpl::FlushRequest DBImpl::PopFirstFromFlushQueue() {
  return flush_req;
 }

-ColumnFamilyData* DBImpl::PickCompactionFromQueue(
-    std::unique_ptr<TaskLimiterToken>* token, LogBuffer* log_buffer) {
-  assert(!compaction_queue_.empty());
-  assert(*token == nullptr);
-  autovector<ColumnFamilyData*> throttled_candidates;
-  ColumnFamilyData* cfd = nullptr;
-  while (!compaction_queue_.empty()) {
-    auto first_cfd = *compaction_queue_.begin();
-    compaction_queue_.pop_front();
-    assert(first_cfd->queued_for_compaction());
-    if (!RequestCompactionToken(first_cfd, false, token, log_buffer)) {
-      throttled_candidates.push_back(first_cfd);
-      continue;
-    }
-    cfd = first_cfd;
-    cfd->set_queued_for_compaction(false);
-    break;
-  }
-  // Add throttled compaction candidates back to queue in the original order.
-  for (auto iter = throttled_candidates.rbegin();
-       iter != throttled_candidates.rend(); ++iter) {
-    compaction_queue_.push_front(*iter);
-  }
-  return cfd;
-}
-
 void DBImpl::SchedulePendingFlush(const FlushRequest& flush_req,
                                  FlushReason flush_reason) {
  if (flush_req.empty()) {
@@ -2170,12 +2141,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
    Status s = BackgroundCompaction(&made_progress, &job_context, &log_buffer,
                                    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
-      mutex_.Lock();
-    } else if (!s.ok() && !s.IsShutdownInProgress()) {
+    if (!s.ok() && !s.IsShutdownInProgress()) {
      // Wait a little bit before retrying background compaction in
      // case this is an environmental problem and we do not want to
      // chew up resources for failed compactions for the duration of
@@ -2310,8 +2276,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    manual_compaction->in_progress = true;
  }

-  std::unique_ptr<TaskLimiterToken> task_token;
-
  // InternalKey manual_end_storage;
  // InternalKey* manual_end = &manual_end_storage;
  bool sfm_reserved_compact_space = false;
@@ -2363,23 +2327,17 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
      return Status::OK();
    }

-    auto cfd = PickCompactionFromQueue(&task_token, log_buffer);
-    if (cfd == nullptr) {
-      // Can't find any executable task from the compaction queue.
-      // All tasks have been throttled by compaction thread limiter.
-      ++unscheduled_compactions_;
-      return Status::Busy();
-    }
-
+    // cfd is referenced here
+    auto cfd = PopFirstFromCompactionQueue();
    // We unreference here because the following code will take a Ref() on
    // this cfd if it is going to use it (Compaction class holds a
    // reference).
    // This will all happen under a mutex so we don't have to be afraid of
    // somebody else deleting it.
    if (cfd->Unref()) {
+      delete cfd;
      // This was the last reference of the column family, so no need to
      // compact.
-      delete cfd;
      return Status::OK();
    }

@@ -2449,8 +2407,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
  } else if (c->deletion_compaction()) {
    // TODO(icanadi) Do we want to honor snapshots here? i.e. not delete old
    // file if there is alive snapshot pointing to it
-    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:BeforeCompaction",
-                             c->column_family_data());
    assert(c->num_input_files(1) == 0);
    assert(c->level() == 0);
    assert(c->column_family_data()->ioptions()->compaction_style ==
@@ -2467,19 +2423,15 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    status = versions_->LogAndApply(c->column_family_data(),
                                    *c->mutable_cf_options(), c->edit(),
                                    &mutex_, directories_.GetDbDir());
-    InstallSuperVersionAndScheduleWork(c->column_family_data(),
-                                       &job_context->superversion_contexts[0],
-                                       *c->mutable_cf_options());
+    InstallSuperVersionAndScheduleWork(
+        c->column_family_data(), &job_context->superversion_contexts[0],
+        *c->mutable_cf_options(), FlushReason::kAutoCompaction);
    ROCKS_LOG_BUFFER(log_buffer, "[%s] Deleted %d files\n",
                     c->column_family_data()->GetName().c_str(),
                     c->num_input_files(0));
    *made_progress = true;
-    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:AfterCompaction",
-                             c->column_family_data());
  } else if (!trivial_move_disallowed && c->IsTrivialMove()) {
    TEST_SYNC_POINT("DBImpl::BackgroundCompaction:TrivialMove");
-    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:BeforeCompaction",
-                             c->column_family_data());
    // Instrument for event update
    // TODO(yhchiang): add op details for showing trivial-move.
    ThreadStatusUtil::SetColumnFamily(
@@ -2521,9 +2473,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                                    *c->mutable_cf_options(), c->edit(),
                                    &mutex_, directories_.GetDbDir());
    // Use latest MutableCFOptions
-    InstallSuperVersionAndScheduleWork(c->column_family_data(),
-                                       &job_context->superversion_contexts[0],
-                                       *c->mutable_cf_options());
+    InstallSuperVersionAndScheduleWork(
+        c->column_family_data(), &job_context->superversion_contexts[0],
+        *c->mutable_cf_options(), FlushReason::kAutoCompaction);

    VersionStorageInfo::LevelSummaryStorage tmp;
    c->column_family_data()->internal_stats()->IncBytesMoved(c->output_level(),
@@ -2545,8 +2497,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,

    // Clear Instrument
    ThreadStatusUtil::ResetThreadStatus();
-    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:AfterCompaction",
-                             c->column_family_data());
  } else if (!is_prepicked && c->output_level() > 0 &&
             c->output_level() ==
                 c->column_family_data()
@@ -2564,23 +2514,22 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    ca->prepicked_compaction = new PrepickedCompaction;
    ca->prepicked_compaction->compaction = c.release();
    ca->prepicked_compaction->manual_compaction_state = nullptr;
-    // Transfer requested token, so it doesn't need to do it again.
-    ca->prepicked_compaction->task_token = std::move(task_token);
    ++bg_bottom_compaction_scheduled_;
    env_->Schedule(&DBImpl::BGWorkBottomCompaction, ca, Env::Priority::BOTTOM,
                   this, &DBImpl::UnscheduleCallback);
  } else {
-    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:BeforeCompaction",
-                             c->column_family_data());
    int output_level __attribute__((__unused__));
    output_level = c->output_level();
    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:NonTrivial",
                             &output_level);
-    std::vector<SequenceNumber> snapshot_seqs;
    SequenceNumber earliest_write_conflict_snapshot;
-    SnapshotChecker* snapshot_checker;
-    GetSnapshotContext(job_context, &snapshot_seqs,
-                       &earliest_write_conflict_snapshot, &snapshot_checker);
+    std::vector<SequenceNumber> snapshot_seqs =
+        snapshots_.GetAll(&earliest_write_conflict_snapshot);
+
+    auto snapshot_checker = snapshot_checker_.get();
+    if (use_custom_gc_ && snapshot_checker == nullptr) {
+      snapshot_checker = DisableGCSnapshotChecker::Instance();
+    }
    assert(is_snapshot_supported_ || snapshots_.empty());
    CompactionJob compaction_job(
        job_context->job_id, c.get(), immutable_db_options_,
@@ -2604,13 +2553,11 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,

    status = compaction_job.Install(*c->mutable_cf_options());
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(c->column_family_data(),
-                                         &job_context->superversion_contexts[0],
-                                         *c->mutable_cf_options());
+      InstallSuperVersionAndScheduleWork(
+          c->column_family_data(), &job_context->superversion_contexts[0],
+          *c->mutable_cf_options(), FlushReason::kAutoCompaction);
    }
    *made_progress = true;
-    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:AfterCompaction",
-                             c->column_family_data());
  }
  if (c != nullptr) {
    c->ReleaseCompactionFiles(status);
@@ -2791,45 +2738,6 @@ bool DBImpl::MCOverlap(ManualCompactionState* m, ManualCompactionState* m1) {
  return true;
 }

-#ifndef ROCKSDB_LITE
-void DBImpl::BuildCompactionJobInfo(
-    const ColumnFamilyData* cfd, Compaction* c, const Status& st,
-    const CompactionJobStats& compaction_job_stats, const int job_id,
-    const Version* current, CompactionJobInfo* compaction_job_info) const {
-  assert(compaction_job_info != nullptr);
-  compaction_job_info->cf_id = cfd->GetID();
-  compaction_job_info->cf_name = cfd->GetName();
-  compaction_job_info->status = st;
-  compaction_job_info->thread_id = env_->GetThreadID();
-  compaction_job_info->job_id = job_id;
-  compaction_job_info->base_input_level = c->start_level();
-  compaction_job_info->output_level = c->output_level();
-  compaction_job_info->stats = compaction_job_stats;
-  compaction_job_info->table_properties = c->GetOutputTableProperties();
-  compaction_job_info->compaction_reason = c->compaction_reason();
-  compaction_job_info->compression = c->output_compression();
-  for (size_t i = 0; i < c->num_input_levels(); ++i) {
-    for (const auto fmd : *c->inputs(i)) {
-      auto fn = TableFileName(c->immutable_cf_options()->cf_paths,
-                              fmd->fd.GetNumber(), fmd->fd.GetPathId());
-      compaction_job_info->input_files.push_back(fn);
-      if (compaction_job_info->table_properties.count(fn) == 0) {
-        shared_ptr<const TableProperties> tp;
-        auto s = current->GetTableProperties(&tp, fmd, &fn);
-        if (s.ok()) {
-          compaction_job_info->table_properties[fn] = tp;
-        }
-      }
-    }
-  }
-  for (const auto& newf : c->edit()->GetNewFiles()) {
-    compaction_job_info->output_files.push_back(
-        TableFileName(c->immutable_cf_options()->cf_paths,
-                      newf.second.fd.GetNumber(), newf.second.fd.GetPathId()));
-  }
-}
-#endif
-
 // SuperVersionContext gets created and destructed outside of the lock --
 // we use this conveniently to:
 // * malloc one SuperVersion() outside of the lock -- new_superversion
@@ -2844,7 +2752,10 @@ void DBImpl::BuildCompactionJobInfo(

 void DBImpl::InstallSuperVersionAndScheduleWork(
    ColumnFamilyData* cfd, SuperVersionContext* sv_context,
-    const MutableCFOptions& mutable_cf_options) {
+    const MutableCFOptions& mutable_cf_options,
+    FlushReason /* flush_reason */) {
+  // TODO(yanqin) investigate if 'flush_reason' can be removed since it's not
+  // used.
  mutex_.AssertHeld();

  // Update max_total_in_memory_state_
@@ -2911,31 +2822,4 @@ void DBImpl::SetSnapshotChecker(SnapshotChecker* snapshot_checker) {
  assert(!snapshot_checker_);
  snapshot_checker_.reset(snapshot_checker);
 }
-
-void DBImpl::GetSnapshotContext(
-    JobContext* job_context, std::vector<SequenceNumber>* snapshot_seqs,
-    SequenceNumber* earliest_write_conflict_snapshot,
-    SnapshotChecker** snapshot_checker_ptr) {
-  mutex_.AssertHeld();
-  assert(job_context != nullptr);
-  assert(snapshot_seqs != nullptr);
-  assert(earliest_write_conflict_snapshot != nullptr);
-  assert(snapshot_checker_ptr != nullptr);
-
-  *snapshot_checker_ptr = snapshot_checker_.get();
-  if (use_custom_gc_ && *snapshot_checker_ptr == nullptr) {
-    *snapshot_checker_ptr = DisableGCSnapshotChecker::Instance();
-  }
-  if (*snapshot_checker_ptr != nullptr) {
-    // If snapshot_checker is used, that means the flush/compaction may
-    // contain values not visible to snapshot taken after
-    // flush/compaction job starts. Take a snapshot and it will appear
-    // in snapshot_seqs and force compaction iterator to consider such
-    // snapshots.
-    const Snapshot* job_snapshot =
-        GetSnapshotImpl(false /*write_conflict_boundary*/, false /*lock*/);
-    job_context->job_snapshot.reset(new ManagedSnapshot(this, job_snapshot));
-  }
-  *snapshot_seqs = snapshots_.GetAll(earliest_write_conflict_snapshot);
-}
 }  // namespace rocksdb
@@ -243,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
@@ -41,8 +41,6 @@ DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src) {
      max_max_open_files = 0x400000;
    }
    ClipToRange(&result.max_open_files, 20, max_max_open_files);
-    TEST_SYNC_POINT_CALLBACK("SanitizeOptions::AfterChangeMaxOpenFiles",
-                             &result.max_open_files);
  }

  if (result.info_log == nullptr) {
@@ -176,7 +174,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 "
@@ -237,7 +235,7 @@ Status DBImpl::NewDB() {
    file->SetPreallocationBlockSize(
        immutable_db_options_.manifest_preallocation_size);
    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-        std::move(file), manifest, env_options, env_, nullptr /* stats */,
+        std::move(file), manifest, env_options, nullptr /* stats */,
        immutable_db_options_.listeners));
    log::Writer log(std::move(file_writer), 0, false);
    std::string record;
@@ -421,10 +419,7 @@ Status DBImpl::Recover(
    // produced by an older version of rocksdb.
    std::vector<std::string> filenames;
    s = env_->GetChildren(immutable_db_options_.wal_dir, &filenames);
-    if (s.IsNotFound()) {
-      return Status::InvalidArgument("wal_dir not found",
-                                     immutable_db_options_.wal_dir);
-    } else if (!s.ok()) {
+    if (!s.ok()) {
      return s;
    }

@@ -512,7 +507,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());
@@ -1176,7 +1171,7 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
        const auto& listeners = impl->immutable_db_options_.listeners;
        std::unique_ptr<WritableFileWriter> file_writer(
            new WritableFileWriter(std::move(lfile), log_fname, opt_env_options,
-                                   impl->env_, nullptr /* stats */, listeners));
+                                   nullptr /* stats */, listeners));
        impl->logs_.emplace_back(
            new_log_number,
            new log::Writer(
@@ -1316,8 +1311,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
@@ -77,8 +77,8 @@ class DBImplReadOnly : public DBImpl {
      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 {
+      std::vector<std::string>* const /*output_file_names*/ = nullptr
+      ) override {
    return Status::NotSupported("Not supported operation in read only mode.");
  }

@@ -265,18 +265,19 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // We're optimistic, updating the stats before we successfully
    // commit.  That lets us release our leader status early.
    auto stats = default_cf_internal_stats_;
-    stats->AddDBStats(InternalStats::NUMBER_KEYS_WRITTEN, total_count,
+    stats->AddDBStats(InternalStats::kIntStatsNumKeysWritten, total_count,
                      concurrent_update);
    RecordTick(stats_, NUMBER_KEYS_WRITTEN, total_count);
-    stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size,
+    stats->AddDBStats(InternalStats::kIntStatsBytesWritten, total_byte_size,
                      concurrent_update);
    RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
-    stats->AddDBStats(InternalStats::WRITE_DONE_BY_SELF, 1, concurrent_update);
+    stats->AddDBStats(InternalStats::kIntStatsWriteDoneBySelf, 1,
+                      concurrent_update);
    RecordTick(stats_, WRITE_DONE_BY_SELF);
    auto write_done_by_other = write_group.size - 1;
    if (write_done_by_other > 0) {
-      stats->AddDBStats(InternalStats::WRITE_DONE_BY_OTHER, write_done_by_other,
-                        concurrent_update);
+      stats->AddDBStats(InternalStats::kIntStatsWriteDoneByOther,
+                        write_done_by_other, concurrent_update);
      RecordTick(stats_, WRITE_DONE_BY_OTHER, write_done_by_other);
    }
    MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);
@@ -467,20 +468,20 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    }

    auto stats = default_cf_internal_stats_;
-    stats->AddDBStats(InternalStats::NUMBER_KEYS_WRITTEN, total_count);
+    stats->AddDBStats(InternalStats::kIntStatsNumKeysWritten, total_count);
    RecordTick(stats_, NUMBER_KEYS_WRITTEN, total_count);
-    stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size);
+    stats->AddDBStats(InternalStats::kIntStatsBytesWritten, total_byte_size);
    RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
    MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);

    PERF_TIMER_STOP(write_pre_and_post_process_time);

-    if (w.status.ok() && !write_options.disableWAL) {
+    if (w.ShouldWriteToWAL()) {
      PERF_TIMER_GUARD(write_wal_time);
-      stats->AddDBStats(InternalStats::WRITE_DONE_BY_SELF, 1);
+      stats->AddDBStats(InternalStats::kIntStatsWriteDoneBySelf, 1);
      RecordTick(stats_, WRITE_DONE_BY_SELF, 1);
      if (wal_write_group.size > 1) {
-        stats->AddDBStats(InternalStats::WRITE_DONE_BY_OTHER,
+        stats->AddDBStats(InternalStats::kIntStatsWriteDoneByOther,
                          wal_write_group.size - 1);
        RecordTick(stats_, WRITE_DONE_BY_OTHER, wal_write_group.size - 1);
      }
@@ -504,7 +505,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
  WriteThread::WriteGroup memtable_write_group;
  if (w.state == WriteThread::STATE_MEMTABLE_WRITER_LEADER) {
    PERF_TIMER_GUARD(write_memtable_time);
-    assert(w.ShouldWriteToMemtable());
+    assert(w.status.ok());
    write_thread_.EnterAsMemTableWriter(&w, &memtable_write_group);
    if (memtable_write_group.size > 1 &&
        immutable_db_options_.allow_concurrent_memtable_write) {
@@ -591,15 +592,16 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
  // We're optimistic, updating the stats before we successfully
  // commit.  That lets us release our leader status early.
  auto stats = default_cf_internal_stats_;
-  stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size,
+  stats->AddDBStats(InternalStats::kIntStatsBytesWritten, total_byte_size,
                    concurrent_update);
  RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
-  stats->AddDBStats(InternalStats::WRITE_DONE_BY_SELF, 1, concurrent_update);
+  stats->AddDBStats(InternalStats::kIntStatsWriteDoneBySelf, 1,
+                    concurrent_update);
  RecordTick(stats_, WRITE_DONE_BY_SELF);
  auto write_done_by_other = write_group.size - 1;
  if (write_done_by_other > 0) {
-    stats->AddDBStats(InternalStats::WRITE_DONE_BY_OTHER, write_done_by_other,
-                      concurrent_update);
+    stats->AddDBStats(InternalStats::kIntStatsWriteDoneByOther,
+                      write_done_by_other, concurrent_update);
    RecordTick(stats_, WRITE_DONE_BY_OTHER, write_done_by_other);
  }
  MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);
@@ -908,12 +910,12 @@ Status DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
  if (status.ok()) {
    auto stats = default_cf_internal_stats_;
    if (need_log_sync) {
-      stats->AddDBStats(InternalStats::WAL_FILE_SYNCED, 1);
+      stats->AddDBStats(InternalStats::kIntStatsWalFileSynced, 1);
      RecordTick(stats_, WAL_FILE_SYNCED);
    }
-    stats->AddDBStats(InternalStats::WAL_FILE_BYTES, log_size);
+    stats->AddDBStats(InternalStats::kIntStatsWalFileBytes, log_size);
    RecordTick(stats_, WAL_FILE_BYTES, log_size);
-    stats->AddDBStats(InternalStats::WRITE_WITH_WAL, write_with_wal);
+    stats->AddDBStats(InternalStats::kIntStatsWriteWithWal, write_with_wal);
    RecordTick(stats_, WRITE_WITH_WAL, write_with_wal);
  }
  return status;
@@ -959,9 +961,10 @@ Status DBImpl::ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
  if (status.ok()) {
    const bool concurrent = true;
    auto stats = default_cf_internal_stats_;
-    stats->AddDBStats(InternalStats::WAL_FILE_BYTES, log_size, concurrent);
+    stats->AddDBStats(InternalStats::kIntStatsWalFileBytes, log_size,
+                      concurrent);
    RecordTick(stats_, WAL_FILE_BYTES, log_size);
-    stats->AddDBStats(InternalStats::WRITE_WITH_WAL, write_with_wal,
+    stats->AddDBStats(InternalStats::kIntStatsWriteWithWal, write_with_wal,
                      concurrent);
    RecordTick(stats_, WRITE_WITH_WAL, write_with_wal);
  }
@@ -1048,22 +1051,22 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
  auto oldest_alive_log = alive_log_files_.begin()->number;
  bool flush_wont_release_oldest_log = false;
  if (allow_2pc()) {
-    auto oldest_log_with_uncommitted_prep =
+    auto oldest_log_with_uncommited_prep =
        logs_with_prep_tracker_.FindMinLogContainingOutstandingPrep();

-    assert(oldest_log_with_uncommitted_prep == 0 ||
-           oldest_log_with_uncommitted_prep >= oldest_alive_log);
-    if (oldest_log_with_uncommitted_prep > 0 &&
-        oldest_log_with_uncommitted_prep == oldest_alive_log) {
+    assert(oldest_log_with_uncommited_prep == 0 ||
+           oldest_log_with_uncommited_prep >= oldest_alive_log);
+    if (oldest_log_with_uncommited_prep > 0 &&
+        oldest_log_with_uncommited_prep == oldest_alive_log) {
      if (unable_to_release_oldest_log_) {
        // we already attempted to flush all column families dependent on
-        // the oldest alive log but the log still contained uncommitted
+        // the oldest alive log but the log still contained uncommited
        // transactions so there is still nothing that we can do.
        return status;
      } else {
        ROCKS_LOG_WARN(
            immutable_db_options_.info_log,
-            "Unable to release oldest log due to uncommitted transaction");
+            "Unable to release oldest log due to uncommited transaction");
        unable_to_release_oldest_log_ = true;
        flush_wont_release_oldest_log = true;
      }
@@ -1255,8 +1258,8 @@ Status DBImpl::DelayWrite(uint64_t num_bytes,
  }
  assert(!delayed || !write_options.no_slowdown);
  if (delayed) {
-    default_cf_internal_stats_->AddDBStats(InternalStats::WRITE_STALL_MICROS,
-                                           time_delayed);
+    default_cf_internal_stats_->AddDBStats(
+        InternalStats::kIntStatsWriteStallMicros, time_delayed);
    RecordTick(stats_, STALL_MICROS, time_delayed);
  }

@@ -1456,7 +1459,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
        lfile->SetPreallocationBlockSize(preallocate_block_size);
        lfile->SetWriteLifeTimeHint(write_hint);
        std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-            std::move(lfile), log_fname, opt_env_opt, env_, nullptr /* stats */,
+            std::move(lfile), log_fname, opt_env_opt, nullptr /* stats */,
            immutable_db_options_.listeners));
        new_log = new log::Writer(
            std::move(file_writer), new_log_number,
@@ -152,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();
@@ -175,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
@@ -196,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 {
@@ -209,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");
    }
@@ -230,12 +232,12 @@ 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; }
  void set_valid(bool v) { valid_ = v; }
@@ -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_;
@@ -50,14 +50,13 @@ class DBIteratorTest : public DBTestBase,

 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;
 };
@@ -180,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) {
@@ -764,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) {
@@ -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 {
@@ -21,8 +21,7 @@ class TestReadCallback : public ReadCallback {
      : snapshot_checker_(snapshot_checker), snapshot_seq_(snapshot_seq) {}

  bool IsVisible(SequenceNumber seq) override {
-    return snapshot_checker_->CheckInSnapshot(seq, snapshot_seq_) ==
-           SnapshotCheckerResult::kInSnapshot;
+    return snapshot_checker_->IsInSnapshot(seq, snapshot_seq_);
  }

 private:
@@ -332,7 +331,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 {
@@ -340,15 +340,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_ = []() {};
@@ -547,15 +547,8 @@ TEST_F(DBMergeOperatorTest, SnapshotCheckerAndReadCallback) {
  DestroyAndReopen(options);

  class TestSnapshotChecker : public SnapshotChecker {
-   public:
-    SnapshotCheckerResult CheckInSnapshot(
-        SequenceNumber seq, SequenceNumber snapshot_seq) const override {
-      return IsInSnapshot(seq, snapshot_seq)
-                 ? SnapshotCheckerResult::kInSnapshot
-                 : SnapshotCheckerResult::kNotInSnapshot;
-    }
-
-    bool IsInSnapshot(SequenceNumber seq, SequenceNumber snapshot_seq) const {
+    bool IsInSnapshot(SequenceNumber seq,
+                      SequenceNumber snapshot_seq) const override {
      switch (snapshot_seq) {
        case 0:
          return seq == 0;
@@ -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) {
@@ -534,210 +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();
-  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();
-  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();
-  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();
-  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);
@@ -825,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);
@@ -845,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);
@@ -859,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++) {
@@ -889,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);
@@ -245,14 +245,15 @@ void GetExpectedTableProperties(
  const int kDeletionCount = kTableCount * kDeletionsPerTable;
  const int kMergeCount = kTableCount * kMergeOperandsPerTable;
  const int kRangeDeletionCount = kTableCount * kRangeDeletionsPerTable;
-  const int kKeyCount = kPutCount + kDeletionCount + kMergeCount + kRangeDeletionCount;
+  const int kKeyCount = kPutCount + kDeletionCount + kMergeCount;
  const int kAvgSuccessorSize = kKeySize / 5;
  const int kEncodingSavePerKey = kKeySize / 4;
-  expected_tp->raw_key_size = kKeyCount * (kKeySize + 8);
+  expected_tp->raw_key_size =
+      (kKeyCount + kRangeDeletionCount) * (kKeySize + 8);
  expected_tp->raw_value_size =
      (kPutCount + kMergeCount + kRangeDeletionCount) * kValueSize;
  expected_tp->num_entries = kKeyCount;
-  expected_tp->num_deletions = kDeletionCount + kRangeDeletionCount;
+  expected_tp->num_deletions = kDeletionCount;
  expected_tp->num_merge_operands = kMergeCount;
  expected_tp->num_range_deletions = kRangeDeletionCount;
  expected_tp->num_data_blocks =
@@ -392,15 +393,7 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
  options.target_file_size_base = 98 << 10;
  options.max_write_buffer_number = 2;
  options.statistics = rocksdb::CreateDBStatistics();
-  options.max_open_files = 11;  // Make sure no proloading of table readers
-
-  // RocksDB sanitize max open files to at least 20. Modify it back.
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "SanitizeOptions::AfterChangeMaxOpenFiles", [&](void* arg) {
-        int* max_open_files = static_cast<int*>(arg);
-        *max_open_files = 11;
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
+  options.max_open_files = 100;

  BlockBasedTableOptions table_options;
  table_options.no_block_cache = true;
@@ -448,7 +441,6 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {

  // Reopen and issue iterating. See thee latency tracked
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.cf-file-histogram", &prop));
  ASSERT_EQ(std::string::npos, prop.find("** Level 0 read latency histogram"));
  ASSERT_EQ(std::string::npos, prop.find("** Level 1 read latency histogram"));
@@ -1094,7 +1086,7 @@ class CountingUserTblPropCollector : public TablePropertiesCollector {
    return Status::OK();
  }

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

@@ -1110,7 +1102,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 +1150,7 @@ class CountingDeleteTabPropCollector : public TablePropertiesCollector {
 class CountingDeleteTabPropCollectorFactory
    : public TablePropertiesCollectorFactory {
 public:
-  TablePropertiesCollector* CreateTablePropertiesCollector(
+  virtual TablePropertiesCollector* CreateTablePropertiesCollector(
      TablePropertiesCollectorFactory::Context /*context*/) override {
    return new CountingDeleteTabPropCollector();
  }
@@ -1432,7 +1424,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) {
@@ -1137,14 +1138,6 @@ TEST_F(DBRangeDelTest, KeyAtOverlappingEndpointReappears) {
  options.target_file_size_base = kFileBytes;
  Reopen(options);

-  // Push dummy data to L3 so that our actual test files on L0-L2
-  // will not be considered "bottommost" level, otherwise compaction
-  // may prevent us from creating overlapping user keys
-  // as on the bottommost layer MergeHelper
-  ASSERT_OK(db_->Merge(WriteOptions(), "key", "dummy"));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  MoveFilesToLevel(3);
-
  Random rnd(301);
  const Snapshot* snapshot = nullptr;
  for (int i = 0; i < kNumFiles; ++i) {
@@ -1166,9 +1159,8 @@ TEST_F(DBRangeDelTest, KeyAtOverlappingEndpointReappears) {
  std::string value;
  ASSERT_TRUE(db_->Get(ReadOptions(), "key", &value).IsNotFound());

-  dbfull()->TEST_CompactRange(0 /* level */, nullptr /* begin */,
-                              nullptr /* end */, nullptr /* column_family */,
-                              true /* disallow_trivial_move */);
+  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr /* begin_key */,
+                              nullptr /* end_key */));
  ASSERT_EQ(0, NumTableFilesAtLevel(0));
  // Now we have multiple files at L1 all containing a single user key, thus
  // guaranteeing overlap in the file endpoints.
@@ -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);
  }
@@ -385,7 +385,6 @@ TEST_F(DBSSTTest, RateLimitedDelete) {

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

  uint64_t delete_start_time = env_->NowMicros();
@@ -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,64 +2547,67 @@ 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*/,
      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 {
+      std::vector<std::string>* const /*output_file_names*/ = nullptr
+      ) override {
    return Status::NotSupported("Not supported operation.");
  }

@@ -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) {
@@ -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_;
 };

@@ -342,7 +342,6 @@ TEST_P(DBTestSharedWriteBufferAcrossCFs, SharedWriteBufferAcrossCFs) {
    ASSERT_GE(cache->GetUsage(), 1024 * 1024);
    Close();
    options.write_buffer_manager.reset();
-    last_options_.write_buffer_manager.reset();
    ASSERT_LT(cache->GetUsage(), 1024 * 1024);
  }
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
@@ -515,9 +514,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 +534,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 +686,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 +710,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 +728,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 +808,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 +883,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 +907,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 +926,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 +1037,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 +1090,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 +1109,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 +1137,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 +1148,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)
@@ -1412,49 +1345,11 @@ TEST_F(DBTest2, FirstSnapshotTest) {
  db_->ReleaseSnapshot(s1);
 }

-#ifndef ROCKSDB_LITE
-TEST_F(DBTest2, DuplicateSnapshot) {
-  Options options;
-  options = CurrentOptions(options);
-  std::vector<const Snapshot*> snapshots;
-  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
-  SequenceNumber oldest_ww_snap, first_ww_snap;
-
-  Put("k", "v");  // inc seq
-  snapshots.push_back(db_->GetSnapshot());
-  snapshots.push_back(db_->GetSnapshot());
-  Put("k", "v");  // inc seq
-  snapshots.push_back(db_->GetSnapshot());
-  snapshots.push_back(dbi->GetSnapshotForWriteConflictBoundary());
-  first_ww_snap = snapshots.back()->GetSequenceNumber();
-  Put("k", "v");  // inc seq
-  snapshots.push_back(dbi->GetSnapshotForWriteConflictBoundary());
-  snapshots.push_back(db_->GetSnapshot());
-  Put("k", "v");  // inc seq
-  snapshots.push_back(db_->GetSnapshot());
-
-  {
-    InstrumentedMutexLock l(dbi->mutex());
-    auto seqs = dbi->snapshots().GetAll(&oldest_ww_snap);
-    ASSERT_EQ(seqs.size(), 4);  // duplicates are not counted
-    ASSERT_EQ(oldest_ww_snap, first_ww_snap);
-  }
-
-  for (auto s : snapshots) {
-    db_->ReleaseSnapshot(s);
-  }
-}
-#endif  // ROCKSDB_LITE
-
-class PinL0IndexAndFilterBlocksTest
-    : public DBTestBase,
-      public testing::WithParamInterface<std::tuple<bool, bool>> {
+class PinL0IndexAndFilterBlocksTest : public DBTestBase,
+                                      public testing::WithParamInterface<bool> {
 public:
  PinL0IndexAndFilterBlocksTest() : DBTestBase("/db_pin_l0_index_bloom_test") {}
-  void SetUp() override {
-    infinite_max_files_ = std::get<0>(GetParam());
-    disallow_preload_ = std::get<1>(GetParam());
-  }
+  virtual void SetUp() override { infinite_max_files_ = GetParam(); }

  void CreateTwoLevels(Options* options, bool close_afterwards) {
    if (infinite_max_files_) {
@@ -1491,7 +1386,6 @@ class PinL0IndexAndFilterBlocksTest
  }

  bool infinite_max_files_;
-  bool disallow_preload_;
 };

 TEST_P(PinL0IndexAndFilterBlocksTest,
@@ -1582,27 +1476,12 @@ TEST_P(PinL0IndexAndFilterBlocksTest, DisablePrefetchingNonL0IndexAndFilter) {
  uint64_t im = TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS);
  uint64_t ih = TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT);

-  if (disallow_preload_) {
-    // Now we have two files. We narrow the max open files to allow 3 entries
-    // so that preloading SST files won't happen.
-    options.max_open_files = 13;
-    // RocksDB sanitize max open files to at least 20. Modify it back.
-    rocksdb::SyncPoint::GetInstance()->SetCallBack(
-        "SanitizeOptions::AfterChangeMaxOpenFiles", [&](void* arg) {
-          int* max_open_files = static_cast<int*>(arg);
-          *max_open_files = 13;
-        });
-  }
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
  // Reopen database. If max_open_files is set as -1, table readers will be
  // preloaded. This will trigger a BlockBasedTable::Open() and prefetch
  // L0 index and filter. Level 1's prefetching is disabled in DB::Open()
  TryReopenWithColumnFamilies({"default", "pikachu"}, options);

-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-
-  if (!disallow_preload_) {
+  if (infinite_max_files_) {
    // After reopen, cache miss are increased by one because we read (and only
    // read) filter and index on L0
    ASSERT_EQ(fm + 1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
@@ -1630,7 +1509,7 @@ TEST_P(PinL0IndexAndFilterBlocksTest, DisablePrefetchingNonL0IndexAndFilter) {

  // this should be read from L1
  value = Get(1, "a");
-  if (!disallow_preload_) {
+  if (infinite_max_files_) {
    // In inifinite max files case, there's a cache miss in executing Get()
    // because index and filter are not prefetched before.
    ASSERT_EQ(fm + 2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
@@ -1648,45 +1527,10 @@ TEST_P(PinL0IndexAndFilterBlocksTest, DisablePrefetchingNonL0IndexAndFilter) {
    ASSERT_EQ(im + 2, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
    ASSERT_EQ(ih + 1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
  }
-
-  // Force a full compaction to one single file. There will be a block
-  // cache read for both of index and filter. If prefetch doesn't explicitly
-  // happen, it will happen when verifying the file.
-  Compact(1, "a", "zzzzz");
-  dbfull()->TEST_WaitForCompact();
-
-  if (!disallow_preload_) {
-    ASSERT_EQ(fm + 3, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-    ASSERT_EQ(fh, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-    ASSERT_EQ(im + 3, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-    ASSERT_EQ(ih + 2, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
-  } else {
-    ASSERT_EQ(fm + 3, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-    ASSERT_EQ(fh + 1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-    ASSERT_EQ(im + 3, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-    ASSERT_EQ(ih + 3, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
-  }
-
-  // Bloom and index hit will happen when a Get() happens.
-  value = Get(1, "a");
-  if (!disallow_preload_) {
-    ASSERT_EQ(fm + 3, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-    ASSERT_EQ(fh + 1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-    ASSERT_EQ(im + 3, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-    ASSERT_EQ(ih + 3, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
-  } else {
-    ASSERT_EQ(fm + 3, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-    ASSERT_EQ(fh + 2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-    ASSERT_EQ(im + 3, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-    ASSERT_EQ(ih + 4, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
-  }
 }

 INSTANTIATE_TEST_CASE_P(PinL0IndexAndFilterBlocksTest,
-                        PinL0IndexAndFilterBlocksTest,
-                        ::testing::Values(std::make_tuple(true, false),
-                                          std::make_tuple(false, false),
-                                          std::make_tuple(false, true)));
+                        PinL0IndexAndFilterBlocksTest, ::testing::Bool());

 #ifndef ROCKSDB_LITE
 TEST_F(DBTest2, MaxCompactionBytesTest) {
@@ -1754,7 +1598,7 @@ class MockPersistentCache : public PersistentCache {
        "GetUniqueIdFromFile:FS_IOC_GETVERSION", UniqueIdCallback);
  }

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

  PersistentCache::StatsType Stats() override {
    return PersistentCache::StatsType();
@@ -1802,42 +1646,6 @@ class MockPersistentCache : public PersistentCache {
  const size_t max_size_ = 10 * 1024;  // 10KiB
 };

-#ifdef OS_LINUX
-// Make sure that in CPU time perf context counters, Env::NowCPUNanos()
-// is used, rather than Env::CPUNanos();
-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);
-  ASSERT_OK(Put("foo", "bar"));
-  ASSERT_OK(Flush());
-  env_->now_cpu_count_.store(0);
-
-  // CPU timing is not enabled with kEnableTimeExceptForMutex
-  SetPerfLevel(PerfLevel::kEnableTimeExceptForMutex);
-  ASSERT_EQ("bar", Get("foo"));
-  ASSERT_EQ(0, get_perf_context()->get_cpu_nanos);
-  ASSERT_EQ(0, env_->now_cpu_count_.load());
-
-  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);
-  ASSERT_EQ("bar", Get("foo"));
-  ASSERT_GT(env_->now_cpu_count_.load(), 2);
-  ASSERT_LT(get_perf_context()->get_cpu_nanos, kDummyAddonTime);
-  ASSERT_GT(get_perf_context()->find_table_nanos, kDummyAddonTime);
-
-  SetPerfLevel(PerfLevel::kDisable);
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-#endif  // OS_LINUX
-
 #ifndef OS_SOLARIS // GetUniqueIdFromFile is not implemented
 TEST_F(DBTest2, PersistentCache) {
  int num_iter = 80;
@@ -2645,7 +2453,9 @@ TEST_F(DBTest2, ReadCallbackTest) {
  class TestReadCallback : public ReadCallback {
   public:
    explicit TestReadCallback(SequenceNumber snapshot) : snapshot_(snapshot) {}
-    bool IsVisible(SequenceNumber seq) override { return seq <= snapshot_; }
+    virtual bool IsVisible(SequenceNumber seq) override {
+      return seq <= snapshot_;
+    }

   private:
    SequenceNumber snapshot_;
@@ -2946,77 +2756,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));
-}
-
 #endif  // ROCKSDB_LITE

 TEST_F(DBTest2, PinnableSliceAndMmapReads) {
@@ -3349,57 +3088,6 @@ TEST_F(DBTest2, TestCompactFiles) {
 }
 #endif  // ROCKSDB_LITE

-// TODO: figure out why this test fails in appveyor
-#ifndef OS_WIN
-TEST_F(DBTest2, MultiDBParallelOpenTest) {
-  const int kNumDbs = 2;
-  Options options = CurrentOptions();
-  std::vector<std::string> dbnames;
-  for (int i = 0; i < kNumDbs; ++i) {
-    dbnames.emplace_back(test::TmpDir(env_) + "/db" + ToString(i));
-    ASSERT_OK(DestroyDB(dbnames.back(), options));
-  }
-
-  // Verify empty DBs can be created in parallel
-  std::vector<std::thread> open_threads;
-  std::vector<DB*> dbs{static_cast<unsigned int>(kNumDbs), nullptr};
-  options.create_if_missing = true;
-  for (int i = 0; i < kNumDbs; ++i) {
-    open_threads.emplace_back(
-        [&](int dbnum) {
-          ASSERT_OK(DB::Open(options, dbnames[dbnum], &dbs[dbnum]));
-        },
-        i);
-  }
-
-  // Now add some data and close, so next we can verify non-empty DBs can be
-  // recovered in parallel
-  for (int i = 0; i < kNumDbs; ++i) {
-    open_threads[i].join();
-    ASSERT_OK(dbs[i]->Put(WriteOptions(), "xi", "gua"));
-    delete dbs[i];
-  }
-
-  // Verify non-empty DBs can be recovered in parallel
-  dbs.clear();
-  open_threads.clear();
-  for (int i = 0; i < kNumDbs; ++i) {
-    open_threads.emplace_back(
-        [&](int dbnum) {
-          ASSERT_OK(DB::Open(options, dbnames[dbnum], &dbs[dbnum]));
-        },
-        i);
-  }
-
-  // Wait and cleanup
-  for (int i = 0; i < kNumDbs; ++i) {
-    open_threads[i].join();
-    delete dbs[i];
-    ASSERT_OK(DestroyDB(dbnames[i], options));
-  }
-}
-#endif  // OS_WIN
-
 }  // 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;
@@ -596,7 +604,6 @@ Status DBTestBase::TryReopenWithColumnFamilies(
    column_families.push_back(ColumnFamilyDescriptor(cfs[i], options[i]));
  }
  DBOptions db_opts = DBOptions(options[0]);
-  last_options_ = options[0];
  return DB::Open(db_opts, dbname_, column_families, &handles_, &db_);
 }

@@ -755,31 +762,6 @@ std::string DBTestBase::Get(int cf, const std::string& k,
  return result;
 }

-std::vector<std::string> DBTestBase::MultiGet(std::vector<int> cfs,
-                                              const std::vector<std::string>& k,
-                                              const Snapshot* snapshot) {
-  ReadOptions options;
-  options.verify_checksums = true;
-  options.snapshot = snapshot;
-  std::vector<ColumnFamilyHandle*> handles;
-  std::vector<Slice> keys;
-  std::vector<std::string> result;
-
-  for (unsigned int i = 0; i < cfs.size(); ++i) {
-    handles.push_back(handles_[cfs[i]]);
-    keys.push_back(k[i]);
-  }
-  std::vector<Status> s = db_->MultiGet(options, handles, keys, &result);
-  for (unsigned int i = 0; i < s.size(); ++i) {
-    if (s[i].IsNotFound()) {
-      result[i] = "NOT_FOUND";
-    } else if (!s[i].ok()) {
-      result[i] = s[i].ToString();
-    }
-  }
-  return result;
-}
-
 Status DBTestBase::Get(const std::string& k, PinnableSlice* v) {
  ReadOptions options;
  options.verify_checksums = true;
@@ -503,11 +503,6 @@ class SpecialEnv : public EnvWrapper {
    return s;
  }

-  virtual uint64_t NowCPUNanos() override {
-    now_cpu_count_.fetch_add(1);
-    return target()->NowCPUNanos();
-  }
-
  virtual uint64_t NowNanos() override {
    return (time_elapse_only_sleep_ ? 0 : target()->NowNanos()) +
           addon_time_.load() * 1000;
@@ -577,8 +572,6 @@ class SpecialEnv : public EnvWrapper {

  std::atomic<int64_t> addon_time_;

-  std::atomic<int> now_cpu_count_;
-
  std::atomic<int> delete_count_;

  std::atomic<bool> time_elapse_only_sleep_;
@@ -652,28 +645,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 +703,7 @@ class DBTestBase : public testing::Test {
    kSkipPlainTable = 8,
    kSkipHashIndex = 16,
    kSkipNoSeekToLast = 32,
+    kSkipHashCuckoo = 64,
    kSkipFIFOCompaction = 128,
    kSkipMmapReads = 256,
  };
@@ -838,10 +833,6 @@ class DBTestBase : public testing::Test {

  Status Get(const std::string& k, PinnableSlice* v);

-  std::vector<std::string> MultiGet(std::vector<int> cfs,
-                                    const std::vector<std::string>& k,
-                                    const Snapshot* snapshot = nullptr);
-
  uint64_t GetNumSnapshots();

  uint64_t GetTimeOldestSnapshots();
@@ -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;
@@ -283,31 +283,7 @@ TEST_F(DBWALTest, RecoverWithTableHandle) {
    ASSERT_OK(Put(1, "bar", "v4"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(Put(1, "big", std::string(100, 'a')));
-
-    options = CurrentOptions();
-    const int kSmallMaxOpenFiles = 13;
-    if (option_config_ == kDBLogDir) {
-      // Use this option to check not preloading files
-      // Set the max open files to be small enough so no preload will
-      // happen.
-      options.max_open_files = kSmallMaxOpenFiles;
-      // RocksDB sanitize max open files to at least 20. Modify it back.
-      rocksdb::SyncPoint::GetInstance()->SetCallBack(
-          "SanitizeOptions::AfterChangeMaxOpenFiles", [&](void* arg) {
-            int* max_open_files = static_cast<int*>(arg);
-            *max_open_files = kSmallMaxOpenFiles;
-          });
-
-    } else if (option_config_ == kWalDirAndMmapReads) {
-      // Use this option to check always loading all files.
-      options.max_open_files = 100;
-    } else {
-      options.max_open_files = -1;
-    }
-    rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-    ReopenWithColumnFamilies({"default", "pikachu"}, options);
-    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-    rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
+    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());

    std::vector<std::vector<FileMetaData>> files;
    dbfull()->TEST_GetFilesMetaData(handles_[1], &files);
@@ -318,10 +294,10 @@ TEST_F(DBWALTest, RecoverWithTableHandle) {
    ASSERT_EQ(total_files, 3);
    for (const auto& level : files) {
      for (const auto& file : level) {
-        if (options.max_open_files == kSmallMaxOpenFiles) {
-          ASSERT_TRUE(file.table_reader_handle == nullptr);
-        } else {
+        if (kInfiniteMaxOpenFiles == option_config_) {
          ASSERT_TRUE(file.table_reader_handle != nullptr);
+        } else {
+          ASSERT_TRUE(file.table_reader_handle == nullptr);
        }
      }
    }
@@ -14,11 +14,10 @@
 namespace rocksdb {

 #ifndef ROCKSDB_LITE
-class ExternalSSTFileBasicTest
-    : public DBTestBase,
-      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
+class ExternalSSTFileBasicTest : public DBTestBase,
+                                 public ::testing::WithParamInterface<bool> {
 public:
-  ExternalSSTFileBasicTest() : DBTestBase("/external_sst_file_basic_test") {
+  ExternalSSTFileBasicTest() : DBTestBase("/external_sst_file_test") {
    sst_files_dir_ = dbname_ + "/sst_files/";
    DestroyAndRecreateExternalSSTFilesDir();
  }
@@ -43,8 +42,7 @@ class ExternalSSTFileBasicTest
      const Options options, std::vector<int> keys,
      const std::vector<ValueType>& value_types,
      std::vector<std::pair<int, int>> range_deletions, int file_id,
-      bool write_global_seqno, bool verify_checksums_before_ingest,
-      std::map<std::string, std::string>* true_data) {
+      bool write_global_seqno, std::map<std::string, std::string>* true_data) {
    assert(value_types.size() == 1 || keys.size() == value_types.size());
    std::string file_path = sst_files_dir_ + ToString(file_id);
    SstFileWriter sst_file_writer(EnvOptions(), options);
@@ -109,7 +107,6 @@ class ExternalSSTFileBasicTest
      IngestExternalFileOptions ifo;
      ifo.allow_global_seqno = true;
      ifo.write_global_seqno = write_global_seqno;
-      ifo.verify_checksums_before_ingest = verify_checksums_before_ingest;
      s = db_->IngestExternalFile({file_path}, ifo);
    }
    return s;
@@ -118,25 +115,21 @@ class ExternalSSTFileBasicTest
  Status GenerateAndAddExternalFile(
      const Options options, std::vector<int> keys,
      const std::vector<ValueType>& value_types, int file_id,
-      bool write_global_seqno, bool verify_checksums_before_ingest,
-      std::map<std::string, std::string>* true_data) {
-    return GenerateAndAddExternalFile(
-        options, keys, value_types, {}, file_id, write_global_seqno,
-        verify_checksums_before_ingest, true_data);
+      bool write_global_seqno, std::map<std::string, std::string>* true_data) {
+    return GenerateAndAddExternalFile(options, keys, value_types, {}, file_id,
+                                      write_global_seqno, true_data);
  }

  Status GenerateAndAddExternalFile(
      const Options options, std::vector<int> keys, const ValueType value_type,
-      int file_id, bool write_global_seqno, bool verify_checksums_before_ingest,
+      int file_id, bool write_global_seqno,
      std::map<std::string, std::string>* true_data) {
-    return GenerateAndAddExternalFile(
-        options, keys, std::vector<ValueType>(1, value_type), file_id,
-        write_global_seqno, verify_checksums_before_ingest, true_data);
+    return GenerateAndAddExternalFile(options, keys,
+                                      std::vector<ValueType>(1, value_type),
+                                      file_id, write_global_seqno, true_data);
  }

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

 protected:
  std::string sst_files_dir_;
@@ -256,8 +249,7 @@ TEST_F(ExternalSSTFileBasicTest, NoCopy) {
 }

 TEST_P(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {
-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  bool write_global_seqno = GetParam();
  do {
    Options options = CurrentOptions();
    DestroyAndReopen(options);
@@ -265,39 +257,39 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {

    int file_id = 1;

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1, 2, 3, 4, 5, 6}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2, 3, 4, 5, 6},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {10, 11, 12, 13}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {10, 11, 12, 13},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1, 4, 6}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1, 4, 6},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {11, 15, 19}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {11, 15, 19},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {120, 130}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {120, 130},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1, 130}, ValueType::kTypeValue, file_id++, write_global_seqno,
-        verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1, 130},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3);

@@ -308,21 +300,21 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {
    }
    SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber();

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {60, 61, 62}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {60, 61, 62},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {40, 41, 42}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {40, 41, 42},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {20, 30, 40}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {20, 30, 40},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2);

@@ -330,29 +322,29 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {

    // We will need a seqno for the file regardless if the file overwrite
    // keys in the DB or not because we have a snapshot
-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1000, 1002}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1000, 1002},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {2000, 3002}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {2000, 3002},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1, 20, 40, 100, 150}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1, 20, 40, 100, 150},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);

    db_->ReleaseSnapshot(snapshot);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {5000, 5001}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {5000, 5001},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // No snapshot anymore, no need to assign a seqno
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);

@@ -362,8 +354,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithGlobalSeqnoPickedSeqno) {
 }

 TEST_P(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {
-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  bool write_global_seqno = GetParam();
  do {
    Options options = CurrentOptions();
    options.merge_operator.reset(new TestPutOperator());
@@ -372,59 +363,59 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {

    int file_id = 1;

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1, 2, 3, 4, 5, 6}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2, 3, 4, 5, 6},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {10, 11, 12, 13}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {10, 11, 12, 13},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1, 4, 6}, ValueType::kTypeMerge, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1, 4, 6},
+                                         ValueType::kTypeMerge, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {11, 15, 19}, ValueType::kTypeDeletion, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {11, 15, 19},
+                                         ValueType::kTypeDeletion, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {120, 130}, ValueType::kTypeMerge, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {120, 130},
+                                         ValueType::kTypeMerge, file_id++,
+                                         write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1, 130}, ValueType::kTypeDeletion, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1, 130},
+                                         ValueType::kTypeDeletion, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3);

    ASSERT_OK(GenerateAndAddExternalFile(
        options, {120}, {ValueType::kTypeValue}, {{120, 135}}, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+        write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 4);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {}, {}, {{110, 120}}, file_id++, write_global_seqno,
-        verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{110, 120}},
+                                         file_id++, write_global_seqno,
+                                         &true_data));
    // The range deletion ends on a key, but it doesn't actually delete
    // this key because the largest key in the range is exclusive. Still,
    // it counts as an overlap so a new seqno will be assigned.
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {}, {}, {{100, 109}}, file_id++, write_global_seqno,
-        verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{100, 109}},
+                                         file_id++, write_global_seqno,
+                                         &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5);

@@ -435,21 +426,21 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {
    }
    SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber();

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {60, 61, 62}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {60, 61, 62},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {40, 41, 42}, ValueType::kTypeMerge, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {40, 41, 42},
+                                         ValueType::kTypeMerge, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {20, 30, 40}, ValueType::kTypeDeletion, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {20, 30, 40},
+                                         ValueType::kTypeDeletion, file_id++,
+                                         write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2);

@@ -457,29 +448,29 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {

    // We will need a seqno for the file regardless if the file overwrite
    // keys in the DB or not because we have a snapshot
-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1000, 1002}, ValueType::kTypeMerge, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1000, 1002},
+                                         ValueType::kTypeMerge, file_id++,
+                                         write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {2000, 3002}, ValueType::kTypeMerge, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {2000, 3002},
+                                         ValueType::kTypeMerge, file_id++,
+                                         write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {1, 20, 40, 100, 150}, ValueType::kTypeMerge, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {1, 20, 40, 100, 150},
+                                         ValueType::kTypeMerge, file_id++,
+                                         write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);

    db_->ReleaseSnapshot(snapshot);

-    ASSERT_OK(GenerateAndAddExternalFile(
-        options, {5000, 5001}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data));
+    ASSERT_OK(GenerateAndAddExternalFile(options, {5000, 5001},
+                                         ValueType::kTypeValue, file_id++,
+                                         write_global_seqno, &true_data));
    // No snapshot anymore, no need to assign a seqno
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);

@@ -489,8 +480,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMultipleValueType) {
 }

 TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  bool write_global_seqno = GetParam();
  do {
    Options options = CurrentOptions();
    options.merge_operator.reset(new TestPutOperator());
@@ -503,8 +493,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {1, 2, 3, 4, 5, 6},
        {ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue,
         ValueType::kTypeMerge, ValueType::kTypeValue, ValueType::kTypeMerge},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);

@@ -512,8 +501,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {10, 11, 12, 13},
        {ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue,
         ValueType::kTypeMerge},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 0);

@@ -521,8 +509,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {1, 4, 6},
        {ValueType::kTypeDeletion, ValueType::kTypeValue,
         ValueType::kTypeMerge},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 1);

@@ -530,22 +517,19 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {11, 15, 19},
        {ValueType::kTypeDeletion, ValueType::kTypeMerge,
         ValueType::kTypeValue},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);

    ASSERT_OK(GenerateAndAddExternalFile(
        options, {120, 130}, {ValueType::kTypeValue, ValueType::kTypeMerge},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 2);

    ASSERT_OK(GenerateAndAddExternalFile(
        options, {1, 130}, {ValueType::kTypeMerge, ValueType::kTypeDeletion},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3);

@@ -553,16 +537,14 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {150, 151, 152},
        {ValueType::kTypeValue, ValueType::kTypeMerge,
         ValueType::kTypeDeletion},
-        {{150, 160}, {180, 190}}, file_id++, write_global_seqno,
-        verify_checksums_before_ingest, &true_data));
+        {{150, 160}, {180, 190}}, file_id++, write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3);

    ASSERT_OK(GenerateAndAddExternalFile(
        options, {150, 151, 152},
        {ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue},
-        {{200, 250}}, file_id++, write_global_seqno,
-        verify_checksums_before_ingest, &true_data));
+        {{200, 250}}, file_id++, write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 4);

@@ -570,8 +552,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {300, 301, 302},
        {ValueType::kTypeValue, ValueType::kTypeMerge,
         ValueType::kTypeDeletion},
-        {{1, 2}, {152, 154}}, file_id++, write_global_seqno,
-        verify_checksums_before_ingest, &true_data));
+        {{1, 2}, {152, 154}}, file_id++, write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 5);

@@ -585,8 +566,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
    ASSERT_OK(GenerateAndAddExternalFile(
        options, {60, 61, 62},
        {ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeValue},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File doesn't overwrite any keys, no seqno needed
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno);

@@ -594,8 +574,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {40, 41, 42},
        {ValueType::kTypeValue, ValueType::kTypeDeletion,
         ValueType::kTypeDeletion},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 1);

@@ -603,8 +582,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {20, 30, 40},
        {ValueType::kTypeDeletion, ValueType::kTypeDeletion,
         ValueType::kTypeDeletion},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // File overwrites some keys, a seqno will be assigned
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 2);

@@ -614,15 +592,13 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
    // keys in the DB or not because we have a snapshot
    ASSERT_OK(GenerateAndAddExternalFile(
        options, {1000, 1002}, {ValueType::kTypeValue, ValueType::kTypeMerge},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 3);

    ASSERT_OK(GenerateAndAddExternalFile(
        options, {2000, 3002}, {ValueType::kTypeValue, ValueType::kTypeMerge},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 4);

@@ -630,8 +606,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {
        options, {1, 20, 40, 100, 150},
        {ValueType::kTypeDeletion, ValueType::kTypeDeletion,
         ValueType::kTypeValue, ValueType::kTypeMerge, ValueType::kTypeMerge},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // A global seqno will be assigned anyway because of the snapshot
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);

@@ -639,8 +614,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestFileWithMixedValueType) {

    ASSERT_OK(GenerateAndAddExternalFile(
        options, {5000, 5001}, {ValueType::kTypeValue, ValueType::kTypeMerge},
-        file_id++, write_global_seqno, verify_checksums_before_ingest,
-        &true_data));
+        file_id++, write_global_seqno, &true_data));
    // No snapshot anymore, no need to assign a seqno
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno + 5);

@@ -716,15 +690,13 @@ TEST_P(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
  ASSERT_EQ(0, NumTableFilesAtLevel(kNumLevels - 2));
  ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 1));

-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  bool write_global_seqno = GetParam();
  // overlaps with L0 file but not memtable, so flush is skipped and file is
  // ingested into L0
  SequenceNumber last_seqno = dbfull()->GetLatestSequenceNumber();
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {60, 90}, {ValueType::kTypeValue, ValueType::kTypeValue},
-      {{65, 70}, {70, 85}}, file_id++, write_global_seqno,
-      verify_checksums_before_ingest, &true_data));
+      {{65, 70}, {70, 85}}, file_id++, write_global_seqno, &true_data));
  ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno);
  ASSERT_EQ(2, NumTableFilesAtLevel(0));
  ASSERT_EQ(0, NumTableFilesAtLevel(kNumLevels - 2));
@@ -734,8 +706,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
  // file is ingested into L5
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {10, 40}, {ValueType::kTypeValue, ValueType::kTypeValue},
-      file_id++, write_global_seqno, verify_checksums_before_ingest,
-      &true_data));
+      file_id++, write_global_seqno, &true_data));
  ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno);
  ASSERT_EQ(2, NumTableFilesAtLevel(0));
  ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2));
@@ -743,9 +714,8 @@ TEST_P(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {

  // overlaps with L5 file but not memtable or L0 file, so flush is skipped and
  // file is ingested into L4
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, {}, {}, {{5, 15}}, file_id++, write_global_seqno,
-      verify_checksums_before_ingest, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {}, {}, {{5, 15}}, file_id++,
+                                       write_global_seqno, &true_data));
  ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno);
  ASSERT_EQ(2, NumTableFilesAtLevel(0));
  ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2));
@@ -757,8 +727,7 @@ TEST_P(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
  // count increases by two.
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {100, 140}, {ValueType::kTypeValue, ValueType::kTypeValue},
-      file_id++, write_global_seqno, verify_checksums_before_ingest,
-      &true_data));
+      file_id++, write_global_seqno, &true_data));
  ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), ++last_seqno);
  ASSERT_EQ(4, NumTableFilesAtLevel(0));
  ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2));
@@ -771,161 +740,15 @@ TEST_P(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
  // seqnum.
  ASSERT_OK(GenerateAndAddExternalFile(
      options, {151, 175}, {ValueType::kTypeValue, ValueType::kTypeValue},
-      {{160, 200}}, file_id++, write_global_seqno,
-      verify_checksums_before_ingest, &true_data));
+      {{160, 200}}, file_id++, write_global_seqno, &true_data));
  ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), last_seqno);
  ASSERT_EQ(4, NumTableFilesAtLevel(0));
  ASSERT_EQ(1, NumTableFilesAtLevel(kNumLevels - 2));
  ASSERT_EQ(2, NumTableFilesAtLevel(options.num_levels - 1));
 }

-TEST_P(ExternalSSTFileBasicTest, IngestFileWithBadBlockChecksum) {
-  bool change_checksum_called = false;
-  const auto& change_checksum = [&](void* arg) {
-    if (!change_checksum_called) {
-      char* buf = reinterpret_cast<char*>(arg);
-      assert(nullptr != buf);
-      buf[0] ^= 0x1;
-      change_checksum_called = true;
-    }
-  };
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTableBuilder::WriteRawBlock:TamperWithChecksum",
-      change_checksum);
-  SyncPoint::GetInstance()->EnableProcessing();
-  int file_id = 0;
-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
-  do {
-    Options options = CurrentOptions();
-    DestroyAndReopen(options);
-    std::map<std::string, std::string> true_data;
-    Status s = GenerateAndAddExternalFile(
-        options, {1, 2, 3, 4, 5, 6}, ValueType::kTypeValue, file_id++,
-        write_global_seqno, verify_checksums_before_ingest, &true_data);
-    if (verify_checksums_before_ingest) {
-      ASSERT_NOK(s);
-    } else {
-      ASSERT_OK(s);
-    }
-    change_checksum_called = false;
-  } while (ChangeOptionsForFileIngestionTest());
-}
-
-TEST_P(ExternalSSTFileBasicTest, IngestFileWithFirstByteTampered) {
-  SyncPoint::GetInstance()->DisableProcessing();
-  int file_id = 0;
-  EnvOptions env_options;
-  do {
-    Options options = CurrentOptions();
-    std::string file_path = sst_files_dir_ + ToString(file_id++);
-    SstFileWriter sst_file_writer(env_options, 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());
-    {
-      // Get file size
-      uint64_t file_size = 0;
-      ASSERT_OK(env_->GetFileSize(file_path, &file_size));
-      ASSERT_GT(file_size, 8);
-      std::unique_ptr<RandomRWFile> rwfile;
-      ASSERT_OK(env_->NewRandomRWFile(file_path, &rwfile, EnvOptions()));
-      // Manually corrupt the file
-      // We deterministically corrupt the first byte because we currently
-      // cannot choose a random offset. The reason for this limitation is that
-      // we do not checksum property block at present.
-      const uint64_t offset = 0;
-      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 = std::get<1>(GetParam());
-    s = db_->IngestExternalFile({file_path}, ifo);
-    if (ifo.verify_checksums_before_ingest) {
-      ASSERT_NOK(s);
-    } else {
-      ASSERT_OK(s);
-    }
-  } 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),
-                                        std::make_tuple(false, true),
-                                        std::make_tuple(false, false)));
+                        testing::Bool());

 #endif  // ROCKSDB_LITE

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

@@ -261,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_) {
@@ -309,13 +316,6 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
    return status;
  }

-  if (ingestion_options_.verify_checksums_before_ingest) {
-    status = table_reader->VerifyChecksum();
-  }
-  if (!status.ok()) {
-    return status;
-  }
-
  // Get the external file properties
  auto props = table_reader->GetTableProperties();
  const auto& uprops = props->user_collected_properties;
@@ -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,15 +10,13 @@
 #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"

 namespace rocksdb {

-class ExternalSSTFileTest
-    : public DBTestBase,
-      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
+class ExternalSSTFileTest : public DBTestBase,
+                            public ::testing::WithParamInterface<bool> {
 public:
  ExternalSSTFileTest() : DBTestBase("/external_sst_file_test") {
    sst_files_dir_ = dbname_ + "/sst_files/";
@@ -30,60 +28,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 sort_data = false,
+      bool sort_data = false,
      std::map<std::string, std::string>* true_data = nullptr,
      ColumnFamilyHandle* cfh = nullptr) {
    // Generate a file id if not provided
@@ -127,7 +76,6 @@ class ExternalSSTFileTest
      IngestExternalFileOptions ifo;
      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;
      if (cfh) {
        s = db_->IngestExternalFile(cfh, {file_path}, ifo);
      } else {
@@ -204,70 +152,34 @@ 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_);
-    }
-    // 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);
-      if (!s.ok()) {
-        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);
-    return s;
-  }
-
  Status GenerateAndAddExternalFile(
      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 sort_data = false,
+      bool write_global_seqno = false, 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, sort_data, true_data, cfh);
+    return GenerateAndAddExternalFile(options, file_data, file_id,
+                                      allow_global_seqno, write_global_seqno,
+                                      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 sort_data = false,
+      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, sort_data, true_data, cfh);
+    return GenerateAndAddExternalFile(options, file_data, file_id,
+                                      allow_global_seqno, write_global_seqno,
+                                      sort_data, true_data, cfh);
  }

  Status DeprecatedAddFile(const std::vector<std::string>& files,
@@ -283,7 +195,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;
@@ -571,7 +483,7 @@ class SstFileWriterCollector : public TablePropertiesCollector {
    return Status::OK();
  }

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

@@ -585,7 +497,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_);
@@ -1245,13 +1157,13 @@ TEST_P(ExternalSSTFileTest, PickedLevel) {
  std::map<std::string, std::string> true_data;

  // File 0 will go to last level (L3)
-  ASSERT_OK(GenerateAndAddExternalFile(options, {1, 10}, -1, false, false, true,
+  ASSERT_OK(GenerateAndAddExternalFile(options, {1, 10}, -1, false, false,
                                       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, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {2, 9}, -1, false, false, false,
+                                       &true_data));
  EXPECT_EQ(FilesPerLevel(), "0,0,1,1");

  rocksdb::SyncPoint::GetInstance()->LoadDependency({
@@ -1280,13 +1192,13 @@ 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, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {4, 7}, -1, false, false, 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,
-                                       true, false, &true_data));
+                                       false, &true_data));
  EXPECT_EQ(FilesPerLevel(), "5,0,1,2");

  // Hold compaction from finishing
@@ -1406,7 +1318,7 @@ TEST_F(ExternalSSTFileTest, IngestNonExistingFile) {

  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
  ASSERT_OK(dbfull()->TEST_WaitForCompact(true));
-
+  
  // After full compaction, there should be only 1 file.
  std::vector<std::string> files;
  env_->GetChildren(dbname_, &files);
@@ -1517,12 +1429,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, &true_data));
+                                       false, 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, &true_data));
+                                       false, &true_data));
  EXPECT_EQ(FilesPerLevel(), "5,0,0,1");

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

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

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

  ASSERT_OK(GenerateAndAddExternalFile(options, {500, 600, 700}, -1, false,
-                                       false, true, false, &true_data));
+                                       false, 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,
+  ASSERT_OK(GenerateAndAddExternalFile(options, {2, 10}, -1, false, false,
                                       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, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {3, 9}, -1, false, false, false,
+                                       &true_data));
  ASSERT_EQ(FilesPerLevel(), "3,0,0,5");

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

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

  VerifyDBFromMap(true_data, &kcnt, false);
@@ -1714,8 +1626,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
  options.level0_slowdown_writes_trigger = 256;
  options.level0_stop_writes_trigger = 256;

-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  bool write_global_seqno = GetParam();
  for (int iter = 0; iter < 2; iter++) {
    bool write_to_memtable = (iter == 0);
    DestroyAndReopen(options);
@@ -1739,9 +1650,9 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
          true_data[entry.first] = entry.second;
        }
      } else {
-        ASSERT_OK(GenerateAndAddExternalFile(
-            options, random_data, -1, true, write_global_seqno,
-            verify_checksums_before_ingest, true, &true_data));
+        ASSERT_OK(GenerateAndAddExternalFile(options, random_data, -1, true,
+                                             write_global_seqno, true,
+                                             &true_data));
      }
    }
    size_t kcnt = 0;
@@ -1770,11 +1681,9 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
  for (int i = 0; i <= 20; i++) {
    file_data.emplace_back(Key(i), "L4");
  }
-  bool write_global_seqno = std::get<0>(GetParam());
-  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, &true_data));
+  bool write_global_seqno = GetParam();
+  ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true,
+                                       write_global_seqno, false, &true_data));

  // This file dont overlap with anything in the DB, will go to L4
  ASSERT_EQ("0,0,0,0,1", FilesPerLevel());
@@ -1784,9 +1693,8 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
  for (int i = 80; i <= 130; i++) {
    file_data.emplace_back(Key(i), "L0");
  }
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true,
+                                       write_global_seqno, false, &true_data));

  // This file overlap with the memtable, so it will flush it and add
  // it self to L0
@@ -1797,9 +1705,8 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
  for (int i = 30; i <= 50; i++) {
    file_data.emplace_back(Key(i), "L4");
  }
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true,
+                                       write_global_seqno, 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());
@@ -1809,9 +1716,8 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
  for (int i = 10; i <= 40; i++) {
    file_data.emplace_back(Key(i), "L3");
  }
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, file_data, -1, true,
+                                       write_global_seqno, false, &true_data));

  // This file overlap with files in L4, we will ingest it in L3
  ASSERT_EQ("2,0,0,1,2", FilesPerLevel());
@@ -1834,20 +1740,17 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
                      &entries_in_memtable);
  ASSERT_GE(entries_in_memtable, 1);

-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  bool write_global_seqno = GetParam();
  // No need for flush
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, {90, 100, 110}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {90, 100, 110}, -1, true,
+                                       write_global_seqno, 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, {19, 20, 21}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {19, 20, 21}, -1, true,
+                                       write_global_seqno, false, &true_data));
  db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                      &entries_in_memtable);
  ASSERT_EQ(entries_in_memtable, 0);
@@ -1861,17 +1764,15 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
  ASSERT_GE(entries_in_memtable, 1);

  // 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, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {202, 203, 204}, -1, true,
+                                       write_global_seqno, 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, false, write_global_seqno,
-      verify_checksums_before_ingest, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {206, 207}, -1, true, false,
+                                       write_global_seqno, &true_data));
  db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                      &entries_in_memtable);
  ASSERT_EQ(entries_in_memtable, 0);
@@ -1889,16 +1790,13 @@ TEST_P(ExternalSSTFileTest, L0SortingIssue) {
  ASSERT_OK(Put(Key(1), "memtable"));
  ASSERT_OK(Put(Key(10), "memtable"));

-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  bool write_global_seqno = 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));
+                                       write_global_seqno, 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));
+                                       write_global_seqno, false));
  printf("%s\n", FilesPerLevel().c_str());

  // Overwrite what we added using external files
@@ -2134,12 +2032,11 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
  options.listeners.emplace_back(listener);
  CreateAndReopenWithCF({"koko", "toto"}, options);

-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  bool write_global_seqno = GetParam();
  // Ingest into default cf
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, true, nullptr, handles_[0]));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true,
+                                       write_global_seqno, 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);
@@ -2149,9 +2046,9 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
            "default");

  // Ingest into cf1
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, true, nullptr, handles_[1]));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true,
+                                       write_global_seqno, 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);
@@ -2161,9 +2058,9 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
            "koko");

  // Ingest into cf2
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, true, nullptr, handles_[2]));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {1, 2}, -1, true,
+                                       write_global_seqno, 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);
@@ -2229,8 +2126,7 @@ TEST_P(ExternalSSTFileTest, IngestBehind) {
  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());
+  ifo.write_global_seqno = GetParam();

  // Can't ingest behind since allow_ingest_behind isn't set to true
  ASSERT_NOK(GenerateAndAddExternalFileIngestBehind(options, ifo,
@@ -2318,405 +2214,8 @@ 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),
-                                        std::make_tuple(true, false),
-                                        std::make_tuple(true, true)));
+                        testing::Bool());

 }  // namespace rocksdb

@@ -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;
  }
@@ -211,8 +211,6 @@ Status FlushJob::Run(LogsWithPrepTracker* prep_tracker,
  uint64_t prev_fsync_nanos = 0;
  uint64_t prev_range_sync_nanos = 0;
  uint64_t prev_prepare_write_nanos = 0;
-  uint64_t prev_cpu_write_nanos = 0;
-  uint64_t prev_cpu_read_nanos = 0;
  if (measure_io_stats_) {
    prev_perf_level = GetPerfLevel();
    SetPerfLevel(PerfLevel::kEnableTime);
@@ -220,8 +218,6 @@ Status FlushJob::Run(LogsWithPrepTracker* prep_tracker,
    prev_fsync_nanos = IOSTATS(fsync_nanos);
    prev_range_sync_nanos = IOSTATS(range_sync_nanos);
    prev_prepare_write_nanos = IOSTATS(prepare_write_nanos);
-    prev_cpu_write_nanos = IOSTATS(cpu_write_nanos);
-    prev_cpu_read_nanos = IOSTATS(cpu_read_nanos);
  }

  // This will release and re-acquire the mutex.
@@ -273,10 +269,6 @@ Status FlushJob::Run(LogsWithPrepTracker* prep_tracker,
    stream << "file_fsync_nanos" << (IOSTATS(fsync_nanos) - prev_fsync_nanos);
    stream << "file_prepare_write_nanos"
           << (IOSTATS(prepare_write_nanos) - prev_prepare_write_nanos);
-    stream << "file_cpu_write_nanos"
-           << (IOSTATS(cpu_write_nanos) - prev_cpu_write_nanos);
-    stream << "file_cpu_read_nanos"
-           << (IOSTATS(cpu_read_nanos) - prev_cpu_read_nanos);
  }

  return s;
@@ -293,7 +285,6 @@ Status FlushJob::WriteLevel0Table() {
      ThreadStatus::STAGE_FLUSH_WRITE_L0);
  db_mutex_->AssertHeld();
  const uint64_t start_micros = db_options_.env->NowMicros();
-  const uint64_t start_cpu_micros = db_options_.env->NowCPUNanos() / 1000;
  Status s;
  {
    auto write_hint = cfd_->CalculateSSTWriteHint(0);
@@ -311,7 +302,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(
@@ -326,18 +316,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(
@@ -413,7 +401,6 @@ Status FlushJob::WriteLevel0Table() {
  // Note that here we treat flush as level 0 compaction in internal stats
  InternalStats::CompactionStats stats(CompactionReason::kFlush, 1);
  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();
  MeasureTime(stats_, FLUSH_TIME, stats.micros);
  cfd_->internal_stats()->AddCompactionStats(0 /* level */, stats);
@@ -371,17 +371,17 @@ TEST_F(FlushJobTest, Snapshots) {
  auto new_mem = cfd->ConstructNewMemtable(*cfd->GetLatestMutableCFOptions(),
                                           kMaxSequenceNumber);

+  std::vector<SequenceNumber> snapshots;
  std::set<SequenceNumber> snapshots_set;
  int keys = 10000;
  int max_inserts_per_keys = 8;

  Random rnd(301);
  for (int i = 0; i < keys / 2; ++i) {
-    snapshots_set.insert(rnd.Uniform(keys * (max_inserts_per_keys / 2)) + 1);
+    snapshots.push_back(rnd.Uniform(keys * (max_inserts_per_keys / 2)) + 1);
+    snapshots_set.insert(snapshots.back());
  }
-  // set has already removed the duplicate snapshots
-  std::vector<SequenceNumber> snapshots(snapshots_set.begin(),
-                                        snapshots_set.end());
+  std::sort(snapshots.begin(), snapshots.end());

  new_mem->Ref();
  SequenceNumber current_seqno = 0;
@@ -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_);
@@ -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
@@ -45,8 +45,6 @@ const std::map<LevelStatType, LevelStat> InternalStats::compaction_level_stats =
        {LevelStatType::READ_MBPS, LevelStat{"ReadMBps", "Rd(MB/s)"}},
        {LevelStatType::WRITE_MBPS, LevelStat{"WriteMBps", "Wr(MB/s)"}},
        {LevelStatType::COMP_SEC, LevelStat{"CompSec", "Comp(sec)"}},
-        {LevelStatType::COMP_CPU_SEC,
-         LevelStat{"CompMergeCPU", "CompMergeCPU(sec)"}},
        {LevelStatType::COMP_COUNT, LevelStat{"CompCount", "Comp(cnt)"}},
        {LevelStatType::AVG_SEC, LevelStat{"AvgSec", "Avg(sec)"}},
        {LevelStatType::KEY_IN, LevelStat{"KeyIn", "KeyIn"}},
@@ -66,7 +64,7 @@ void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name) {
  };
  int line_size = snprintf(
      buf + written_size, len - written_size,
-      "Level    %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\n",
      // Note that we skip COMPACTED_FILES and merge it with Files column
      hdr(LevelStatType::NUM_FILES), hdr(LevelStatType::SIZE_BYTES),
      hdr(LevelStatType::SCORE), hdr(LevelStatType::READ_GB),
@@ -74,9 +72,9 @@ void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name) {
      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::COMP_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",
@@ -108,7 +106,6 @@ void PrepareLevelStats(std::map<LevelStatType, double>* level_stats,
  (*level_stats)[LevelStatType::WRITE_MBPS] =
      stats.bytes_written / kMB / elapsed;
  (*level_stats)[LevelStatType::COMP_SEC] = stats.micros / kMicrosInSec;
-  (*level_stats)[LevelStatType::COMP_CPU_SEC] = stats.cpu_micros / kMicrosInSec;
  (*level_stats)[LevelStatType::COMP_COUNT] = stats.count;
  (*level_stats)[LevelStatType::AVG_SEC] =
      stats.count == 0 ? 0 : stats.micros / kMicrosInSec / stats.count;
@@ -135,8 +132,7 @@ void PrintLevelStats(char* buf, size_t len, const std::string& name,
      "%5.1f "    /*  W-Amp */
      "%8.1f "    /*  Rd(MB/s) */
      "%8.1f "    /*  Wr(MB/s) */
-      "%9.2f "    /*  Comp(sec) */
-      "%17.2f "   /*  CompMergeCPU(sec) */
+      "%9.0f "    /*  Comp(sec) */
      "%9d "      /*  Comp(cnt) */
      "%8.3f "    /*  Avg(sec) */
      "%7s "      /*  KeyIn */
@@ -157,7 +153,6 @@ void PrintLevelStats(char* buf, size_t len, const std::string& name,
      stat_value.at(LevelStatType::READ_MBPS),
      stat_value.at(LevelStatType::WRITE_MBPS),
      stat_value.at(LevelStatType::COMP_SEC),
-      stat_value.at(LevelStatType::COMP_CPU_SEC),
      static_cast<int>(stat_value.at(LevelStatType::COMP_COUNT)),
      stat_value.at(LevelStatType::AVG_SEC),
      NumberToHumanString(
@@ -954,14 +949,17 @@ void InternalStats::DumpDBStats(std::string* value) {
           seconds_up, interval_seconds_up);
  value->append(buf);
  // Cumulative
-  uint64_t user_bytes_written = GetDBStats(InternalStats::BYTES_WRITTEN);
-  uint64_t num_keys_written = GetDBStats(InternalStats::NUMBER_KEYS_WRITTEN);
-  uint64_t write_other = GetDBStats(InternalStats::WRITE_DONE_BY_OTHER);
-  uint64_t write_self = GetDBStats(InternalStats::WRITE_DONE_BY_SELF);
-  uint64_t wal_bytes = GetDBStats(InternalStats::WAL_FILE_BYTES);
-  uint64_t wal_synced = GetDBStats(InternalStats::WAL_FILE_SYNCED);
-  uint64_t write_with_wal = GetDBStats(InternalStats::WRITE_WITH_WAL);
-  uint64_t write_stall_micros = GetDBStats(InternalStats::WRITE_STALL_MICROS);
+  uint64_t user_bytes_written =
+      GetDBStats(InternalStats::kIntStatsBytesWritten);
+  uint64_t num_keys_written =
+      GetDBStats(InternalStats::kIntStatsNumKeysWritten);
+  uint64_t write_other = GetDBStats(InternalStats::kIntStatsWriteDoneByOther);
+  uint64_t write_self = GetDBStats(InternalStats::kIntStatsWriteDoneBySelf);
+  uint64_t wal_bytes = GetDBStats(InternalStats::kIntStatsWalFileBytes);
+  uint64_t wal_synced = GetDBStats(InternalStats::kIntStatsWalFileSynced);
+  uint64_t write_with_wal = GetDBStats(InternalStats::kIntStatsWriteWithWal);
+  uint64_t write_stall_micros =
+      GetDBStats(InternalStats::kIntStatsWriteStallMicros);

  const int kHumanMicrosLen = 32;
  char human_micros[kHumanMicrosLen];
@@ -71,7 +71,6 @@ enum class LevelStatType {
  READ_MBPS,
  WRITE_MBPS,
  COMP_SEC,
-  COMP_CPU_SEC,
  COMP_COUNT,
  AVG_SEC,
  KEY_IN,
@@ -109,15 +108,15 @@ class InternalStats {
  };

  enum InternalDBStatsType {
-    WAL_FILE_BYTES,
-    WAL_FILE_SYNCED,
-    BYTES_WRITTEN,
-    NUMBER_KEYS_WRITTEN,
-    WRITE_DONE_BY_OTHER,
-    WRITE_DONE_BY_SELF,
-    WRITE_WITH_WAL,
-    WRITE_STALL_MICROS,
-    INTERNAL_DB_STATS_ENUM_MAX,
+    kIntStatsWalFileBytes,
+    kIntStatsWalFileSynced,
+    kIntStatsBytesWritten,
+    kIntStatsNumKeysWritten,
+    kIntStatsWriteDoneByOther,
+    kIntStatsWriteDoneBySelf,
+    kIntStatsWriteWithWal,
+    kIntStatsWriteStallMicros,
+    kIntStatsNumMax,
  };

  InternalStats(int num_levels, Env* env, ColumnFamilyData* cfd)
@@ -136,7 +135,6 @@ class InternalStats {
  // compactions that produced data for the specified "level".
  struct CompactionStats {
    uint64_t micros;
-    uint64_t cpu_micros;

    // The number of bytes read from all non-output levels
    uint64_t bytes_read_non_output_levels;
@@ -174,7 +172,6 @@ class InternalStats {

    explicit CompactionStats()
        : micros(0),
-          cpu_micros(0),
          bytes_read_non_output_levels(0),
          bytes_read_output_level(0),
          bytes_written(0),
@@ -193,7 +190,6 @@ class InternalStats {

    explicit CompactionStats(CompactionReason reason, int c)
        : micros(0),
-          cpu_micros(0),
          bytes_read_non_output_levels(0),
          bytes_read_output_level(0),
          bytes_written(0),
@@ -218,14 +214,14 @@ class InternalStats {

    explicit CompactionStats(const CompactionStats& c)
        : micros(c.micros),
-          cpu_micros(c.cpu_micros),
          bytes_read_non_output_levels(c.bytes_read_non_output_levels),
          bytes_read_output_level(c.bytes_read_output_level),
          bytes_written(c.bytes_written),
          bytes_moved(c.bytes_moved),
          num_input_files_in_non_output_levels(
              c.num_input_files_in_non_output_levels),
-          num_input_files_in_output_level(c.num_input_files_in_output_level),
+          num_input_files_in_output_level(
+              c.num_input_files_in_output_level),
          num_output_files(c.num_output_files),
          num_input_records(c.num_input_records),
          num_dropped_records(c.num_dropped_records),
@@ -238,7 +234,6 @@ class InternalStats {

    void Clear() {
      this->micros = 0;
-      this->cpu_micros = 0;
      this->bytes_read_non_output_levels = 0;
      this->bytes_read_output_level = 0;
      this->bytes_written = 0;
@@ -257,7 +252,6 @@ class InternalStats {

    void Add(const CompactionStats& c) {
      this->micros += c.micros;
-      this->cpu_micros += c.cpu_micros;
      this->bytes_read_non_output_levels += c.bytes_read_non_output_levels;
      this->bytes_read_output_level += c.bytes_read_output_level;
      this->bytes_written += c.bytes_written;
@@ -278,7 +272,6 @@ class InternalStats {

    void Subtract(const CompactionStats& c) {
      this->micros -= c.micros;
-      this->cpu_micros -= c.cpu_micros;
      this->bytes_read_non_output_levels -= c.bytes_read_non_output_levels;
      this->bytes_read_output_level -= c.bytes_read_output_level;
      this->bytes_written -= c.bytes_written;
@@ -299,7 +292,7 @@ class InternalStats {
  };

  void Clear() {
-    for (int i = 0; i < INTERNAL_DB_STATS_ENUM_MAX; i++) {
+    for (int i = 0; i < kIntStatsNumMax; i++) {
      db_stats_[i].store(0);
    }
    for (int i = 0; i < INTERNAL_CF_STATS_ENUM_MAX; i++) {
@@ -389,7 +382,7 @@ class InternalStats {
  bool HandleBlockCacheStat(Cache** block_cache);

  // Per-DB stats
-  std::atomic<uint64_t> db_stats_[INTERNAL_DB_STATS_ENUM_MAX];
+  std::atomic<uint64_t> db_stats_[kIntStatsNumMax];
  // Per-ColumnFamily stats
  uint64_t cf_stats_value_[INTERNAL_CF_STATS_ENUM_MAX];
  uint64_t cf_stats_count_[INTERNAL_CF_STATS_ENUM_MAX];
@@ -587,22 +580,21 @@ class InternalStats {
  };

  enum InternalDBStatsType {
-    WAL_FILE_BYTES,
-    WAL_FILE_SYNCED,
-    BYTES_WRITTEN,
-    NUMBER_KEYS_WRITTEN,
-    WRITE_DONE_BY_OTHER,
-    WRITE_DONE_BY_SELF,
-    WRITE_WITH_WAL,
-    WRITE_STALL_MICROS,
-    INTERNAL_DB_STATS_ENUM_MAX,
+    kIntStatsWalFileBytes,
+    kIntStatsWalFileSynced,
+    kIntStatsBytesWritten,
+    kIntStatsNumKeysWritten,
+    kIntStatsWriteDoneByOther,
+    kIntStatsWriteDoneBySelf,
+    kIntStatsWriteWithWal,
+    kIntStatsWriteStallMicros,
+    kIntStatsNumMax,
  };

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

  struct CompactionStats {
    uint64_t micros;
-    uint64_t cpu_micros;
    uint64_t bytes_read_non_output_levels;
    uint64_t bytes_read_output_level;
    uint64_t bytes_written;
@@ -175,9 +175,6 @@ struct JobContext {
  size_t num_alive_log_files = 0;
  uint64_t size_log_to_delete = 0;

-  // Snapshot taken before flush/compaction job.
-  std::unique_ptr<ManagedSnapshot> job_snapshot;
-
  explicit JobContext(int _job_id, bool create_superversion = false) {
    job_id = _job_id;
    manifest_file_number = 0;
@@ -207,7 +204,6 @@ struct JobContext {

    memtables_to_free.clear();
    logs_to_free.clear();
-    job_snapshot.reset();
  }

  ~JobContext() {
@@ -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_;
@@ -61,7 +61,7 @@ class LogTest : public ::testing::TestWithParam<int> {
      force_eof_position_(0),
      returned_partial_(false) { }

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

      if (force_error_) {
@@ -100,7 +100,7 @@ class LogTest : public ::testing::TestWithParam<int> {
      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");
@@ -118,7 +118,7 @@ class LogTest : 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());
    }
@@ -661,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());
    }
@@ -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) {
@@ -51,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),
@@ -111,13 +109,11 @@ 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(
-        new DynamicBloom(&arena_, moptions_.memtable_prefix_bloom_bits,
-                         ioptions.bloom_locality, 6 /* hard coded 6 probes */,
-                         moptions_.memtable_huge_page_size, ioptions.info_log));
+  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 */, nullptr, moptions_.memtable_huge_page_size,
+        ioptions.info_log));
  }
 }

@@ -286,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.
@@ -307,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);
@@ -331,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);
@@ -353,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_;
  }
@@ -418,8 +414,7 @@ InternalIterator* MemTable::NewIterator(const ReadOptions& read_options,

 FragmentedRangeTombstoneIterator* MemTable::NewRangeTombstoneIterator(
    const ReadOptions& read_options, SequenceNumber read_seq) {
-  if (read_options.ignore_range_deletions ||
-      is_range_del_table_empty_.load(std::memory_order_relaxed)) {
+  if (read_options.ignore_range_deletions || is_range_del_table_empty_) {
    return nullptr;
  }
  auto* unfragmented_iter = new MemTableIterator(
@@ -520,11 +515,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
@@ -553,11 +546,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_.
@@ -572,8 +563,8 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
        !first_seqno_.compare_exchange_weak(cur_earliest_seqno, s)) {
    }
  }
-  if (type == kTypeRangeDeletion) {
-    is_range_del_table_empty_.store(false, std::memory_order_relaxed);
+  if (is_range_del_table_empty_ && type == kTypeRangeDeletion) {
+    is_range_del_table_empty_ = false;
  }
  UpdateOldestKeyTime();
  return true;
@@ -764,24 +755,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);
@@ -416,7 +411,7 @@ class MemTable {
  ConcurrentArena arena_;
  std::unique_ptr<MemTableRep> table_;
  std::unique_ptr<MemTableRep> range_del_table_;
-  std::atomic_bool is_range_del_table_empty_;
+  bool is_range_del_table_empty_;

  // Total data size of all data inserted
  std::atomic<uint64_t> data_size_;
@@ -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_;

@@ -573,15 +573,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,
@@ -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) {
@@ -138,11 +138,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
  // orig_ikey is backed by original_key if keys_.empty()
  // orig_ikey is backed by keys_.back() if !keys_.empty()
  ParsedInternalKey orig_ikey;
-  bool succ = ParseInternalKey(original_key, &orig_ikey);
-  assert(succ);
-  if (!succ) {
-    return Status::Corruption("Cannot parse key in MergeUntil");
-  }
+  ParseInternalKey(original_key, &orig_ikey);

  Status s;
  bool hit_the_next_user_key = false;
@@ -170,11 +166,9 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
      break;
    } else if (stop_before > 0 && ikey.sequence <= stop_before &&
               LIKELY(snapshot_checker_ == nullptr ||
-                      snapshot_checker_->CheckInSnapshot(ikey.sequence,
-                                                         stop_before) !=
-                          SnapshotCheckerResult::kNotInSnapshot)) {
-      // hit an entry that's possibly visible by the previous snapshot, can't
-      // touch that
+                      snapshot_checker_->IsInSnapshot(ikey.sequence,
+                                                      stop_before))) {
+      // hit an entry that's visible by the previous snapshot, can't touch that
      break;
    }

@@ -286,24 +280,22 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
    return Status::OK();
  }

-  // We are sure we have seen this key's entire history if:
-  // at_bottom == true (this does not necessarily mean it is the bottommost
-  // layer, but rather that we are confident the key does not appear on any of
-  // the lower layers, at_bottom == false doesn't mean it does appear, just
-  // that we can't be sure, see Compaction::IsBottommostLevel for details)
-  // AND
-  // we have either encountered another key or end of key history on this
-  // layer.
+  // We are sure we have seen this key's entire history if we are at the
+  // last level and exhausted all internal keys of this user key.
+  // NOTE: !iter->Valid() does not necessarily mean we hit the
+  // beginning of a user key, as versions of a user key might be
+  // split into multiple files (even files on the same level)
+  // and some files might not be included in the compaction/merge.
  //
-  // When these conditions are true we are able to merge all the keys
-  // using full merge.
-  //
-  // For these cases we are not sure about, we simply miss the opportunity
+  // There are also cases where we have seen the root of history of this
+  // key without being sure of it. Then, we simply miss the opportunity
  // to combine the keys. Since VersionSet::SetupOtherInputs() always makes
  // sure that all merge-operands on the same level get compacted together,
  // this will simply lead to these merge operands moving to the next level.
-  bool surely_seen_the_beginning =
-      (hit_the_next_user_key || !iter->Valid()) && at_bottom;
+  //
+  // So, we only perform the following logic (to merge all operands together
+  // without a Put/Delete) if we are certain that we have seen the end of key.
+  bool surely_seen_the_beginning = hit_the_next_user_key && at_bottom;
  if (surely_seen_the_beginning) {
    // do a final merge with nullptr as the existing value and say
    // bye to the merge type (it's now converted to a Put)
@@ -20,7 +20,7 @@ class MergeHelperTest : public testing::Test {
 public:
  MergeHelperTest() { env_ = Env::Default(); }

-  ~MergeHelperTest() override = default;
+  ~MergeHelperTest() = default;

  Status Run(SequenceNumber stop_before, bool at_bottom,
             SequenceNumber latest_snapshot = 0) {
@@ -130,7 +130,7 @@ TEST_F(MergeHelperTest, SingleOperand) {

  AddKeyVal("a", 50, kTypeMerge, test::EncodeInt(1U));

-  ASSERT_TRUE(Run(31, false).IsMergeInProgress());
+  ASSERT_TRUE(Run(31, true).IsMergeInProgress());
  ASSERT_FALSE(iter_->Valid());
  ASSERT_EQ(test::KeyStr("a", 50, kTypeMerge), merge_helper_->keys()[0]);
  ASSERT_EQ(test::EncodeInt(1U), merge_helper_->values()[0]);
@@ -38,8 +38,11 @@ class CountMergeOperator : public AssociativeMergeOperator {
    mergeOperator_ = MergeOperators::CreateUInt64AddOperator();
  }

-  bool Merge(const Slice& key, const Slice* existing_value, const Slice& value,
-             std::string* new_value, Logger* logger) const override {
+  virtual bool Merge(const Slice& key,
+                     const Slice* existing_value,
+                     const Slice& value,
+                     std::string* new_value,
+                     Logger* logger) const override {
    assert(new_value->empty());
    ++num_merge_operator_calls;
    if (existing_value == nullptr) {
@@ -55,17 +58,19 @@ class CountMergeOperator : public AssociativeMergeOperator {
        logger);
  }

-  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 {
    assert(new_value->empty());
    ++num_partial_merge_calls;
    return mergeOperator_->PartialMergeMulti(key, operand_list, new_value,
                                             logger);
  }

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

 private:
  std::shared_ptr<MergeOperator> mergeOperator_;
@@ -225,7 +230,7 @@ class MergeBasedCounters : public Counters {
  }

  // mapped to a rocksdb Merge operation
-  bool add(const std::string& key, uint64_t value) override {
+  virtual bool add(const std::string& key, uint64_t value) override {
    char encoded[sizeof(uint64_t)];
    EncodeFixed64(encoded, value);
    Slice slice(encoded, sizeof(uint64_t));
@@ -688,89 +688,6 @@ TEST_F(PerfContextTest, MergeOperatorTime) {
  delete db;
 }

-TEST_F(PerfContextTest, CopyAndMove) {
-  // Assignment operator
-  {
-    get_perf_context()->Reset();
-    get_perf_context()->EnablePerLevelPerfContext();
-    PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5);
-    ASSERT_EQ(
-        1,
-        (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful);
-    PerfContext perf_context_assign;
-    perf_context_assign = *get_perf_context();
-    ASSERT_EQ(
-        1,
-        (*(perf_context_assign.level_to_perf_context))[5].bloom_filter_useful);
-    get_perf_context()->ClearPerLevelPerfContext();
-    get_perf_context()->Reset();
-    ASSERT_EQ(
-        1,
-        (*(perf_context_assign.level_to_perf_context))[5].bloom_filter_useful);
-    perf_context_assign.ClearPerLevelPerfContext();
-    perf_context_assign.Reset();
-  }
-  // Copy constructor
-  {
-    get_perf_context()->Reset();
-    get_perf_context()->EnablePerLevelPerfContext();
-    PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5);
-    ASSERT_EQ(
-        1,
-        (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful);
-    PerfContext perf_context_copy(*get_perf_context());
-    ASSERT_EQ(
-        1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful);
-    get_perf_context()->ClearPerLevelPerfContext();
-    get_perf_context()->Reset();
-    ASSERT_EQ(
-        1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful);
-    perf_context_copy.ClearPerLevelPerfContext();
-    perf_context_copy.Reset();
-  }
-  // Move constructor
-  {
-    get_perf_context()->Reset();
-    get_perf_context()->EnablePerLevelPerfContext();
-    PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5);
-    ASSERT_EQ(
-        1,
-        (*(get_perf_context()->level_to_perf_context))[5].bloom_filter_useful);
-    PerfContext perf_context_move = std::move(*get_perf_context());
-    ASSERT_EQ(
-        1, (*(perf_context_move.level_to_perf_context))[5].bloom_filter_useful);
-    get_perf_context()->ClearPerLevelPerfContext();
-    get_perf_context()->Reset();
-    ASSERT_EQ(
-        1, (*(perf_context_move.level_to_perf_context))[5].bloom_filter_useful);
-    perf_context_move.ClearPerLevelPerfContext();
-    perf_context_move.Reset();
-  }
-}
-
-TEST_F(PerfContextTest, PerfContextDisableEnable) {
-  get_perf_context()->Reset();
-  get_perf_context()->EnablePerLevelPerfContext();
-  PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_positive, 1, 0);
-  get_perf_context()->DisablePerLevelPerfContext();
-  PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 5);
-  get_perf_context()->EnablePerLevelPerfContext();
-  PERF_COUNTER_BY_LEVEL_ADD(block_cache_hit_count, 1, 0);
-  get_perf_context()->DisablePerLevelPerfContext();
-  PerfContext perf_context_copy(*get_perf_context());
-  ASSERT_EQ(1, (*(perf_context_copy.level_to_perf_context))[0]
-                   .bloom_filter_full_positive);
-  // this was set when per level perf context is disabled, should not be copied
-  ASSERT_NE(
-      1, (*(perf_context_copy.level_to_perf_context))[5].bloom_filter_useful);
-  ASSERT_EQ(
-      1, (*(perf_context_copy.level_to_perf_context))[0].block_cache_hit_count);
-  perf_context_copy.ClearPerLevelPerfContext();
-  perf_context_copy.Reset();
-  get_perf_context()->ClearPerLevelPerfContext();
-  get_perf_context()->Reset();
-}
-
 TEST_F(PerfContextTest, PerfContextByLevelGetSet) {
  get_perf_context()->Reset();
  get_perf_context()->EnablePerLevelPerfContext();
@@ -779,10 +696,6 @@ TEST_F(PerfContextTest, PerfContextByLevelGetSet) {
  PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 7);
  PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, 7);
  PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_true_positive, 1, 2);
-  PERF_COUNTER_BY_LEVEL_ADD(block_cache_hit_count, 1, 0);
-  PERF_COUNTER_BY_LEVEL_ADD(block_cache_hit_count, 5, 2);
-  PERF_COUNTER_BY_LEVEL_ADD(block_cache_miss_count, 2, 3);
-  PERF_COUNTER_BY_LEVEL_ADD(block_cache_miss_count, 4, 1);
  ASSERT_EQ(
      0, (*(get_perf_context()->level_to_perf_context))[0].bloom_filter_useful);
  ASSERT_EQ(
@@ -793,14 +706,6 @@ TEST_F(PerfContextTest, PerfContextByLevelGetSet) {
                   .bloom_filter_full_positive);
  ASSERT_EQ(1, (*(get_perf_context()->level_to_perf_context))[2]
                   .bloom_filter_full_true_positive);
-  ASSERT_EQ(1, (*(get_perf_context()->level_to_perf_context))[0]
-                  .block_cache_hit_count);
-  ASSERT_EQ(5, (*(get_perf_context()->level_to_perf_context))[2]
-                  .block_cache_hit_count);
-  ASSERT_EQ(2, (*(get_perf_context()->level_to_perf_context))[3]
-                  .block_cache_miss_count);
-  ASSERT_EQ(4, (*(get_perf_context()->level_to_perf_context))[1]
-                  .block_cache_miss_count);
  std::string zero_excluded = get_perf_context()->ToString(true);
  ASSERT_NE(std::string::npos,
            zero_excluded.find("bloom_filter_useful = 1@level5, 2@level7"));
@@ -808,10 +713,6 @@ TEST_F(PerfContextTest, PerfContextByLevelGetSet) {
            zero_excluded.find("bloom_filter_full_positive = 1@level0"));
  ASSERT_NE(std::string::npos,
            zero_excluded.find("bloom_filter_full_true_positive = 1@level2"));
-  ASSERT_NE(std::string::npos,
-            zero_excluded.find("block_cache_hit_count = 1@level0, 5@level2"));
-  ASSERT_NE(std::string::npos,
-            zero_excluded.find("block_cache_miss_count = 4@level1, 2@level3"));
 }
 }  // namespace rocksdb

@@ -109,7 +109,7 @@ class PlainTableDBTest : public testing::Test,
 public:
  PlainTableDBTest() : env_(Env::Default()) {}

-  ~PlainTableDBTest() override {
+  ~PlainTableDBTest() {
    delete db_;
    EXPECT_OK(DestroyDB(dbname_, Options()));
  }
@@ -158,8 +158,6 @@ class PlainTableDBTest : public testing::Test,
    db_ = nullptr;
  }

-  bool mmap_mode() const { return mmap_mode_; }
-
  void DestroyAndReopen(Options* options = nullptr) {
    //Destroy using last options
    Destroy(&last_options_);
@@ -176,12 +174,6 @@ class PlainTableDBTest : public testing::Test,
    return DB::Open(*options, dbname_, db);
  }

-  Status ReopenForReadOnly(Options* options) {
-    delete db_;
-    db_ = nullptr;
-    return DB::OpenForReadOnly(*options, dbname_, &db_);
-  }
-
  Status TryReopen(Options* options = nullptr) {
    delete db_;
    db_ = nullptr;
@@ -303,10 +295,10 @@ class TestPlainTableReader : public PlainTableReader {
    }
  }

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

 private:
-  bool MatchBloom(uint32_t hash) const override {
+  virtual bool MatchBloom(uint32_t hash) const override {
    bool ret = PlainTableReader::MatchBloom(hash);
    if (*expect_bloom_not_match_) {
      EXPECT_TRUE(!ret);
@@ -555,50 +547,6 @@ TEST_P(PlainTableDBTest, Flush2) {
  }
 }

-TEST_P(PlainTableDBTest, Immortal) {
-  for (EncodingType encoding_type : {kPlain, kPrefix}) {
-    Options options = CurrentOptions();
-    options.create_if_missing = true;
-    options.max_open_files = -1;
-    // Set only one bucket to force bucket conflict.
-    // Test index interval for the same prefix to be 1, 2 and 4
-    PlainTableOptions plain_table_options;
-    plain_table_options.hash_table_ratio = 0.75;
-    plain_table_options.index_sparseness = 16;
-    plain_table_options.user_key_len = kPlainTableVariableLength;
-    plain_table_options.bloom_bits_per_key = 10;
-    plain_table_options.encoding_type = encoding_type;
-    options.table_factory.reset(NewPlainTableFactory(plain_table_options));
-
-    DestroyAndReopen(&options);
-    ASSERT_OK(Put("0000000000000bar", "b"));
-    ASSERT_OK(Put("1000000000000foo", "v1"));
-    dbfull()->TEST_FlushMemTable();
-
-    int copied = 0;
-    rocksdb::SyncPoint::GetInstance()->SetCallBack(
-        "GetContext::SaveValue::PinSelf", [&](void* /*arg*/) { copied++; });
-    rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-    ASSERT_EQ("b", Get("0000000000000bar"));
-    ASSERT_EQ("v1", Get("1000000000000foo"));
-    ASSERT_EQ(2, copied);
-    copied = 0;
-
-    Close();
-    ASSERT_OK(ReopenForReadOnly(&options));
-
-    ASSERT_EQ("b", Get("0000000000000bar"));
-    ASSERT_EQ("v1", Get("1000000000000foo"));
-    ASSERT_EQ("NOT_FOUND", Get("1000000000000bar"));
-    if (mmap_mode()) {
-      ASSERT_EQ(0, copied);
-    } else {
-      ASSERT_EQ(2, copied);
-    }
-    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  }
-}
-
 TEST_P(PlainTableDBTest, Iterator) {
  for (size_t huge_page_tlb_size = 0; huge_page_tlb_size <= 2 * 1024 * 1024;
       huge_page_tlb_size += 2 * 1024 * 1024) {
@@ -83,7 +83,7 @@ class TestKeyComparator : public Comparator {

  // Compare needs to be aware of the possibility of a and/or b is
  // prefix only
-  int Compare(const Slice& a, const Slice& b) const override {
+  virtual int Compare(const Slice& a, const Slice& b) const override {
    const TestKey kkey_a = SliceToTestKey(a);
    const TestKey kkey_b = SliceToTestKey(b);
    const TestKey *key_a = &kkey_a;
@@ -122,12 +122,14 @@ class TestKeyComparator : public Comparator {
    return Compare(TestKeyToSlice(sa, a), TestKeyToSlice(sb, b)) < 0;
  }

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

-  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 {
@@ -193,23 +195,27 @@ class SamePrefixTransform : public SliceTransform {
  explicit SamePrefixTransform(const Slice& prefix)
      : prefix_(prefix), name_("rocksdb.SamePrefix." + prefix.ToString()) {}

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

-  Slice Transform(const Slice& src) const override {
+  virtual Slice Transform(const Slice& src) const override {
    assert(InDomain(src));
    return prefix_;
  }

-  bool InDomain(const Slice& src) const override {
+  virtual bool InDomain(const Slice& src) const override {
    if (src.size() >= prefix_.size()) {
      return Slice(src.data(), prefix_.size()) == prefix_;
    }
    return false;
  }

-  bool InRange(const Slice& dst) const override { return dst == prefix_; }
+  virtual bool InRange(const Slice& dst) const override {
+    return dst == prefix_;
+  }

-  bool FullLengthEnabled(size_t* /*len*/) const override { return false; }
+  virtual bool FullLengthEnabled(size_t* /*len*/) const override {
+    return false;
+  }
 };

 }  // namespace
@@ -277,8 +283,9 @@ class PrefixTest : public testing::Test {
  PrefixTest() : option_config_(kBegin) {
    options.comparator = new TestKeyComparator();
  }
-  ~PrefixTest() override { delete options.comparator; }
-
+  ~PrefixTest() {
+    delete options.comparator;
+  }
 protected:
  enum OptionConfig {
    kBegin,
@@ -470,6 +470,8 @@ CompactionRangeDelAggregator::NewIterator(const Slice* lower_bound,
      new TruncatedRangeDelMergingIter(icmp_, lower_bound, upper_bound,
                                       upper_bound_inclusive, parent_iters_));

+  // TODO: add tests where tombstone fragments can be outside of upper and lower
+  // bound range
  auto fragmented_tombstone_list =
      std::make_shared<FragmentedRangeTombstoneList>(
          std::move(merging_iter), *icmp_, true /* for_compaction */,
@@ -197,8 +197,7 @@ int main(int argc, char** argv) {
      // real workloads.
      for (int j = 0; j < FLAGS_num_range_tombstones; j++) {
        uint64_t start = rnd.Uniform(FLAGS_tombstone_start_upper_bound);
-        uint64_t end = static_cast<uint64_t>(
-            std::round(start + std::max(1.0, normal_dist(random_gen))));
+        uint64_t end = start + static_cast<uint64_t>(std::max(1.0, normal_dist(random_gen)));
        persistent_range_tombstones[j] = rocksdb::PersistentRangeTombstone(
            rocksdb::Key(start), rocksdb::Key(end), j);
      }
@@ -336,7 +336,7 @@ class Repairer {
      Env* env;
      std::shared_ptr<Logger> info_log;
      uint64_t lognum;
-      void Corruption(size_t bytes, const Status& s) override {
+      virtual void Corruption(size_t bytes, const Status& s) override {
        // We print error messages for corruption, but continue repairing.
        ROCKS_LOG_ERROR(info_log, "Log #%" PRIu64 ": dropping %d bytes; %s",
                        lognum, static_cast<int>(bytes), s.ToString().c_str());
@@ -8,30 +8,22 @@

 namespace rocksdb {

-enum class SnapshotCheckerResult : int {
-  kInSnapshot = 0,
-  kNotInSnapshot = 1,
-  // In case snapshot is released and the checker has no clue whether
-  // the given sequence is visible to the snapshot.
-  kSnapshotReleased = 2,
-};
-
-// Callback class that control GC of duplicate keys in flush/compaction.
+// Callback class that control GC of duplicate keys in flush/compaction
 class SnapshotChecker {
 public:
  virtual ~SnapshotChecker() {}
-  virtual SnapshotCheckerResult CheckInSnapshot(
-      SequenceNumber sequence, SequenceNumber snapshot_sequence) const = 0;
+  virtual bool IsInSnapshot(SequenceNumber sequence,
+                            SequenceNumber snapshot_sequence) const = 0;
 };

 class DisableGCSnapshotChecker : public SnapshotChecker {
 public:
  virtual ~DisableGCSnapshotChecker() {}
-  virtual SnapshotCheckerResult CheckInSnapshot(
+  virtual bool IsInSnapshot(
      SequenceNumber /*sequence*/,
      SequenceNumber /*snapshot_sequence*/) const override {
-    // By returning kNotInSnapshot, we prevent all the values from being GCed
-    return SnapshotCheckerResult::kNotInSnapshot;
+    // By returning false, we prevent all the values from being GCed
+    return false;
  }
  static DisableGCSnapshotChecker* Instance() { return &instance_; }

@@ -49,8 +41,8 @@ class WritePreparedSnapshotChecker : public SnapshotChecker {
  explicit WritePreparedSnapshotChecker(WritePreparedTxnDB* txn_db);
  virtual ~WritePreparedSnapshotChecker() {}

-  virtual SnapshotCheckerResult CheckInSnapshot(
-      SequenceNumber sequence, SequenceNumber snapshot_sequence) const override;
+  virtual bool IsInSnapshot(SequenceNumber sequence,
+                            SequenceNumber snapshot_sequence) const override;

 private:
 #ifndef ROCKSDB_LITE
@@ -86,7 +86,7 @@ class SnapshotList {
  }

  // retrieve all snapshot numbers up until max_seq. They are sorted in
-  // ascending order (with no duplicates).
+  // ascending order.
  std::vector<SequenceNumber> GetAll(
      SequenceNumber* oldest_write_conflict_snapshot = nullptr,
      const SequenceNumber& max_seq = kMaxSequenceNumber) const {
@@ -104,10 +104,7 @@ class SnapshotList {
      if (s->next_->number_ > max_seq) {
        break;
      }
-      // Avoid duplicates
-      if (ret.empty() || ret.back() != s->next_->number_) {
-        ret.push_back(s->next_->number_);
-      }
+      ret.push_back(s->next_->number_);

      if (oldest_write_conflict_snapshot != nullptr &&
          *oldest_write_conflict_snapshot == kMaxSequenceNumber &&
@@ -147,7 +147,7 @@ Status TableCache::FindTable(const EnvOptions& env_options,
                             HistogramImpl* file_read_hist, bool skip_filters,
                             int level,
                             bool prefetch_index_and_filter_in_cache) {
-  PERF_TIMER_GUARD_WITH_ENV(find_table_nanos, ioptions_.env);
+  PERF_TIMER_GUARD(find_table_nanos);
  Status s;
  uint64_t number = fd.GetNumber();
  Slice key = GetSliceForFileNumber(&number);
@@ -122,8 +122,6 @@ class TableCache {
  // Release the handle from a cache
  void ReleaseHandle(Cache::Handle* handle);

-  Cache* get_cache() const { return cache_; }
-
  // Capacity of the backing Cache that indicates inifinite TableCache capacity.
  // For example when max_open_files is -1 we set the backing Cache to this.
  static const int kInfiniteCapacity = 0x400000;
@@ -28,7 +28,7 @@ namespace rocksdb {
 class TablePropertiesTest : public testing::Test,
                            public testing::WithParamInterface<bool> {
 public:
-  void SetUp() override { backward_mode_ = GetParam(); }
+  virtual void SetUp() override { backward_mode_ = GetParam(); }

  bool backward_mode_;
 };
@@ -106,7 +106,7 @@ class RegularKeysStartWithA: public TablePropertiesCollector {
    return Status::OK();
  }

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

@@ -143,7 +143,7 @@ class RegularKeysStartWithABackwardCompatible
    return Status::OK();
  }

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

@@ -172,7 +172,7 @@ class RegularKeysStartWithAInternal : public IntTblPropCollector {
    return Status::OK();
  }

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

@@ -185,7 +185,7 @@ class RegularKeysStartWithAFactory : public IntTblPropCollectorFactory,
 public:
  explicit RegularKeysStartWithAFactory(bool backward_mode)
      : backward_mode_(backward_mode) {}
-  TablePropertiesCollector* CreateTablePropertiesCollector(
+  virtual TablePropertiesCollector* CreateTablePropertiesCollector(
      TablePropertiesCollectorFactory::Context context) override {
    EXPECT_EQ(kTestColumnFamilyId, context.column_family_id);
    if (!backward_mode_) {
@@ -194,7 +194,7 @@ class RegularKeysStartWithAFactory : public IntTblPropCollectorFactory,
      return new RegularKeysStartWithABackwardCompatible();
    }
  }
-  IntTblPropCollector* CreateIntTblPropCollector(
+  virtual IntTblPropCollector* CreateIntTblPropCollector(
      uint32_t /*column_family_id*/) override {
    return new RegularKeysStartWithAInternal();
  }
@@ -205,7 +205,7 @@ class RegularKeysStartWithAFactory : public IntTblPropCollectorFactory,

 class FlushBlockEveryThreePolicy : public FlushBlockPolicy {
 public:
-  bool Update(const Slice& /*key*/, const Slice& /*value*/) override {
+  virtual bool Update(const Slice& /*key*/, const Slice& /*value*/) override {
    return (++count_ % 3U == 0);
  }
Author	SHA1	Message	Date
Adam Retter	b9a4a10659	Fix build on MSVC	2020-03-07 17:58:42 +01:00
Adam Retter	1c63b82b9a	Snappy must be built with position independent code for static linking	2020-03-07 13:56:13 +01:00
Adam Retter	64dbc7813e	RocksJava must compile on JDK7 (#4768 ) Summary: Fixes some RocksJava regressions recently introduced, whereby RocksJava would not build on JDK 7. These should have been visible on Travis-CI! Pull Request resolved: https://github.com/facebook/rocksdb/pull/4768 Differential Revision: D13418173 Pulled By: sagar0 fbshipit-source-id: 57bf223188887f84d9e072031af2e0d2c8a69c30	2020-03-07 13:31:52 +01:00
Adam Retter	466af89356	Update to latest Snappy to fix compilation issue on latest MacOS XCode	2020-03-07 13:08:19 +01:00
Peter Dillinger	614c6d453e	Don't download from (unreliable) maven.org (#6348 ) Summary: I set up a mirror of our Java deps on github so we can download them through github URLs rather than maven.org, which is proving terribly unreliable from Travis builds. Also sanitized calls to curl, so they are easier to read and appropriately fail on download failure. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6348 Test Plan: CI Differential Revision: D19633621 Pulled By: pdillinger fbshipit-source-id: 7eb3f730953db2ead758dc94039c040f406790f3	2020-03-06 22:29:05 +01:00
Adam Retter	03492d61d4	Update 3rd-party libraries used by RocksJava (#6084 ) Summary: * LZ4 1.8.3 -> 1.9.2 * ZSTD 1.4.0 -> 1.4.4 Pull Request resolved: https://github.com/facebook/rocksdb/pull/6084 Differential Revision: D18710224 fbshipit-source-id: a461ef19a473d3480acdc027f627ec3048730692	2020-03-06 22:27:09 +01:00
Yun Tang	49f97dc93e	Download bzip2 packages from sourceforge (#5995 ) Summary: From bzip2's official [download page](http://www.bzip.org/downloads.html), we could download it from sourceforge. This source would be more credible than previous web archive. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5995 Differential Revision: D18377662 fbshipit-source-id: e8353f83d5d6ea6067f78208b7bfb7f0d5b49c05	2020-03-06 22:25:09 +01:00
sdong	fc38b0d5fe	Rename InternalDBStatsType enum names (#5779 ) Summary: When building with clang 9, warning is reported for InternalDBStatsType type names shadowed the one for statistics. Rename them. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5779 Test Plan: Build with clang 9 and see it passes. Differential Revision: D17239378 fbshipit-source-id: af28fb42066c738cd1b841f9fe21ab4671dafd18	2020-03-06 22:23:24 +01:00
Harry Wong	3598e1a9a9	Removed const fields in copyable classes (#5095 ) Summary: This fixed the compile error in Clang-8: ``` error: explicitly defaulted copy assignment operator is implicitly deleted [-Werror,-Wdefaulted-function-deleted] ``` Pull Request resolved: https://github.com/facebook/rocksdb/pull/5095 Differential Revision: D14811961 Pulled By: riversand963 fbshipit-source-id: d935d1f85a4e8694dca10033fb5af92d8777eca0	2020-03-06 22:22:59 +01:00
Yi Wu	d07167c9a3	Fix build failures due to missing JEMALLOC_CXX_THROW macro (#5053 ) Summary: JEMALLOC_CXX_THROW is not defined for earlier versions of jemalloc (e.g. 3.6), causing builds to fail on some platforms. Fixing it. Closes #4869 Pull Request resolved: https://github.com/facebook/rocksdb/pull/5053 Differential Revision: D14390034 Pulled By: sagar0 fbshipit-source-id: b2b7a03cd377201ef385eb521f65bae85c558055	2020-03-06 22:22:57 +01:00
Adam Retter	931e6704af	Update the version of the dependencies used by the RocksJava static build (#4761 ) Summary: Note that Snappy now requires CMake to build it, so I added a note about RocksJava to the README.md file. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4761 Differential Revision: D13403811 Pulled By: ajkr fbshipit-source-id: 8fcd7e3dc7f7152080364a374d3065472f417eff	2020-03-06 22:21:26 +01:00
Peter Dillinger	e8e81bc39f	Update version.h and HISTORY.md for 5.18.4	2020-03-03 08:21:13 -08:00
Adam Retter Yuqi Patrick Zhang Yikun Jiang	689c15523f	ARM64 commits to 5.18.3 to create 5.18.4 (#6250 ) * RocksDB CRC32c optimization with ARMv8 Intrinsic (#5221) Summary: 1. Add Arm linear crc32c implemtation for RocksDB. 2. Arm runtime check for crc32 Pull Request resolved: https://github.com/facebook/rocksdb/pull/5221 Differential Revision: D15013685 Pulled By: siying fbshipit-source-id: 2c2983743d26656d93f212dc7c1a3cf66a1acf12 * Support rocksdbjava aarch64 build and test (#5258) Summary: Verified with an Ampere Computing eMAG aarch64 system. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5258 Differential Revision: D15807309 Pulled By: maysamyabandeh fbshipit-source-id: ab85d2fd3fe40e6094430ab0eba557b1e979510d * Cleanup the Arm64 CRC32 unused warning (#5565) Summary: When 'HAVE_ARM64_CRC' is set, the blew methods: - bool rocksdb::crc32c::isSSE42() - bool rocksdb::crc32c::isPCLMULQDQ() are defined but not used, the unused-function is raised when do rocksdb build. This patch try to cleanup these warnings by add ifndef, if it build under the HAVE_ARM64_CRC, we will not define `isSSE42` and `isPCLMULQDQ`. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5565 Differential Revision: D16233654 fbshipit-source-id: c32a9dda7465dbf65f9ccafef159124db92cdffd * Fixes for building RocksJava releases on arm64v8 Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/5674 Differential Revision: D16870338 fbshipit-source-id: c8dac644b1479fa734b491f3a8d50151772290f7 * Remove invalid comparison of va_list and nullptr (#5836) Summary: The comparison of va_list and nullptr is always False under any arch, and will raise invalid operands of types error in aarch64 env (`error: invalid operands of types ‘va_list {aka __va_list}’ and ‘std::nullptr_t’ to binary ‘operator!=’`). This patch removes this invalid assert. Closes: https://github.com/facebook/rocksdb/issues/4277 Pull Request resolved: https://github.com/facebook/rocksdb/pull/5836 Differential Revision: D17532470 fbshipit-source-id: ca98078ecbc6a9416c69de3bd6ffcfa33a0f0185 * Fix naming of library on PPC64LE (#6080) Summary: NOTE: This also needs to be back-ported to be 6.4.6 Fix a regression introduced in `f2bf0b2` by https://github.com/facebook/rocksdb/pull/5674 whereby the compiled library would get the wrong name on PPC64LE platforms. On PPC64LE, the regression caused the library to be named `librocksdbjni-linux64.so` instead of `librocksdbjni-linux-ppc64le.so`. This PR corrects the name back to `librocksdbjni-linux-ppc64le.so` and also corrects the ordering of conditional arguments in the Makefile to match the expected order as defined in the documentation for Make. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6080 Differential Revision: D18710351 fbshipit-source-id: d4db87ef378263b57de7f9edce1b7d15644cf9de Co-authored-by: Yuqi <yuqi.gu@arm.com> Co-authored-by: Patrick Zhang <cnqpzhang@163.com> Co-authored-by: Yikun Jiang <yikunkero@gmail.com>	2020-01-06 10:39:50 -08:00
Vijay Nadimpalli	1369736b18	Making platform 007 (gcc 7) default in build_detect_platform.sh (#5947 ) Summary: Making platform 007 (gcc 7) default in build_detect_platform.sh. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5947 Differential Revision: D18038837 Pulled By: vjnadimpalli fbshipit-source-id: 9ac2ddaa93bf328a416faec028970e039886378e	2019-10-30 10:16:03 -07:00
Andrew Kryczka	95dc6cd6ed	Add latest toolchain (gcc-8, etc.) build support for fbcode users (#4923 ) Summary: - When building with internal dependencies, specify this toolchain by setting `ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007=1` - It is not enabled by default. However, it is enabled for TSAN builds in CI since there is a known problem with TSAN in gcc-5: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71090 - I did not add support for Lua since (1) we agreed to deprecate it, and (2) we only have an internal build for v5.3 with this toolchain while that has breaking changes compared to our current version (v5.2). Pull Request resolved: https://github.com/facebook/rocksdb/pull/4923 Differential Revision: D13827226 Pulled By: ajkr fbshipit-source-id: 9aa3388ed3679777cfb15ef8cbcb83c07f62f947	2019-10-30 10:15:48 -07:00
Andrew Kryczka	641fae60f6	update history and bump version	2019-02-11 14:02:52 -08:00
yangzhijia	b7434c29d2	Properly set upper bound of subcompaction output (#4879 ) (#4898 ) Summary: Fix the ouput overlap bug when using subcompactions, the upper bound of output file was extended incorrectly. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4898 Differential Revision: D13736107 Pulled By: ajkr fbshipit-source-id: 21dca09f81d5f07bf2766bf566f9b50dcab7d8e3	2019-02-11 14:01:38 -08:00
Sagar Vemuri	a1774dde9a	Bump version to 5.18.2	2019-01-31 15:49:35 -08:00
Yanqin Jin	65b2298510	Use correct FileMeta for atomic flush result install (#4932 ) Summary: 1. this commit fixes our handling of a combination of two separate edge cases. If a flush job does not pick any memtable to flush (because another flush job has already picked the same memtables), and the column family assigned to the flush job is dropped right before RocksDB calls rocksdb::InstallMemtableAtomicFlushResults, our original code passes a FileMetaData object whose file number is 0, failing the assertion in rocksdb::InstallMemtableAtomicFlushResults (assert(m->GetFileNumber() > 0)). 2. Also piggyback a small change: since we already create a local copy of column family's mutable CF options to eliminate potential race condition with `SetOptions` call, we might as well use the local copy in other function calls in the same scope. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4932 Differential Revision: D13901322 Pulled By: riversand963 fbshipit-source-id: b936580af7c127ea0c6c19ea10cd5fcede9fb0f9	2019-01-31 15:06:26 -08:00
Yanqin Jin	acba14b3d9	Make a copy of MutableCFOptions to avoid race condition (#4876 ) Summary: If we do not do this, then reading MutableCFOptions may have a race condition with SetOptions which modifies MutableCFOptions. Also reserve space in advance for vectors to avoid reallocation changing the address of its elements. Test plan ``` $make clean && make -j32 all check $make clean && COMPILE_WITH_TSAN=1 make -j32 all check $make clean && COMPILE_WITH_ASAN=1 make -j32 all check ``` Pull Request resolved: https://github.com/facebook/rocksdb/pull/4876 Differential Revision: D13644500 Pulled By: riversand963 fbshipit-source-id: 4b8112c5c819d5a2922bb61ad1521b3d2fb2fd47	2019-01-31 15:06:08 -08:00
anand76	53f760b8a8	Always delete Blob DB files in the background (#4928 ) Summary: Blob DB files are not tracked by the SFM, so they currently don't get deleted in the background. Force them to be deleted in background so rate limiting can be applied Pull Request resolved: https://github.com/facebook/rocksdb/pull/4928 Differential Revision: D13854649 Pulled By: anand1976 fbshipit-source-id: 8031ce66842ff0af440c715d886b377983dad7d8	2019-01-31 14:19:04 -08:00
Siying Dong	35c05bca0f	Deleting Blob files also goes through SstFileManager (#4904 ) Summary: Right now, deleting blob files is not rate limited, even if SstFileManger is specified. On the other hand, rate limiting blob deletion is not supported. With this change, Blob file deletion will go through SstFileManager too. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4904 Differential Revision: D13772545 Pulled By: siying fbshipit-source-id: bd1b1d0beb26d5167385e00b7ecb8b94b879de84	2019-01-31 14:18:21 -08:00
Yanqin Jin	9ae0528dc4	Use chrono::time_point instead of time_t (#4868 ) Summary: By convention, time_t almost always stores the integral number of seconds since 00:00 hours, Jan 1, 1970 UTC, according to http://www.cplusplus.com/reference/ctime/time_t/. We surely want more precision than seconds. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4868 Differential Revision: D13633046 Pulled By: riversand963 fbshipit-source-id: 4e01e23a22e8838023c51a91247a286dbf3a5396	2019-01-23 11:11:13 -08:00
Yanqin Jin	4eeb1bf0a6	Bump version to 5.18.1	2019-01-09 16:15:59 -08:00
Yanqin Jin	3bcc31295a	Initialize two members in PerfContext (#4859 ) Summary: as titled. Currently it's possible to create a local object of type PerfContext since it's part of public API. Then it's safe to initialize the two members to 0. If PerfContext is created as thread-local object, then all members are zero-initialized according to C++ standard. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4859 Differential Revision: D13614504 Pulled By: riversand963 fbshipit-source-id: 406ff548e105a074f379ad1054d56fece5f524a0	2019-01-09 16:15:31 -08:00
Andrew Kryczka	e78f5cfba7	Fix point lookup on range tombstone sentinel endpoint (#4829 ) Summary: Previously for point lookup we decided which file to look into based on user key overlap only. We also did not truncate range tombstones in the point lookup code path. These two ideas did not interact well in cases like this: - L1 has range tombstone [a, c)#1 and point key b#2. The data is split between file1 with range [a#1,1, b#72057594037927935,15], and file2 with range [b#2, c#1]. - L1's file2 gets compacted to L2. - User issues `Get()` for b#3. - L1's file1 is opened and the range tombstone [a, c)#1 is found for b, while no point-key for b is found in L1. - `Get()` assumes that the range tombstone must cover all data in that range in lower levels, so short circuits and returns `NotFound`. The solution to this problem is to not look into files that only overlap with the point lookup at a range tombstone sentinel endpoint. In the above example, this would mean not opening L1's file1 or its tombstones during the `Get()`. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4829 Differential Revision: D13561355 Pulled By: ajkr fbshipit-source-id: a13c21c816870a2f5d32a48af6dbd719a7d9d19f	2019-01-08 17:50:02 -08:00
Yanqin Jin	97773d0967	Update HISTORY.md	2019-01-07 10:18:58 -08:00
Yanqin Jin	35c950a94e	Refactor atomic flush result installation to MANIFEST (#4791 ) Summary: as titled. Since different bg flush threads can flush different sets of column families (due to column family creation and drop), we decide not to let one thread perform atomic flush result installation for other threads. Bg flush threads will install their atomic flush results sequentially to MANIFEST, using a conditional variable, i.e. atomic_flush_install_cv_ to coordinate. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4791 Differential Revision: D13498930 Pulled By: riversand963 fbshipit-source-id: dd7482fc41f4bd22dad1e1ef7d4764ef424688d7	2019-01-07 10:12:51 -08:00
Yanqin Jin	e265e08a02	Avoid switching empty memtable in certain cases (#4792 ) Summary: in certain cases, we do not perform memtable switching if the active memtable of the column family is empty. Two exceptions: 1. In manual flush, if cached_recoverable_state_empty_ is false, then we need to switch memtable due to requirement of transaction. 2. In switch WAL, we need to switch memtable anyway because we have to seal the memtable if the WAL on which it depends will be closed. This change can potentially delay the occurence of write stalls because number of memtables increase more slowly. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4792 Differential Revision: D13499501 Pulled By: riversand963 fbshipit-source-id: 91c9b17ae753578578039f3851667d93610005e1	2019-01-07 10:06:49 -08:00
Yanqin Jin	663d24f467	Improve flushing multiple column families (#4708 ) Summary: If one column family is dropped, we should simply skip it and continue to flush other active ones. Currently we use Status::ShutdownInProgress to notify caller of column families being dropped. In the future, we should consider using a different Status code. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4708 Differential Revision: D13378954 Pulled By: riversand963 fbshipit-source-id: 42f248cdf2d32d4c0f677cd39012694b8f1328ca	2019-01-07 10:02:59 -08:00
Yanqin Jin	ec43385bf3	Enable checkpoint of read-only db (#4681 ) Summary: 1. DBImplReadOnly::GetLiveFiles should not return NotSupported. Instead, it should call DBImpl::GetLiveFiles(flush_memtable=false). 2. In DBImp::Recover, we should also recover the OPTIONS file name and/or number so that an immediate subsequent GetLiveFiles will get the correct OPTIONS name. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4681 Differential Revision: D13069205 Pulled By: riversand963 fbshipit-source-id: 3e6a0174307d06db5a01feb099b306cea1f7f88a	2019-01-07 09:54:42 -08:00
Yi Wu	8a643b70fd	Detect if Jemalloc is linked with the binary (#4844 ) Summary: Declare Jemalloc non-standard APIs as weak symbols, so that if Jemalloc is linked with the binary, these symbols will be replaced by Jemalloc's, otherwise they will be nullptr. This is similar to how folly detect jemalloc, but we assume the main program use jemalloc as long as jemalloc is linked: https://github.com/facebook/folly/blob/master/folly/memory/Malloc.h#L147 Pull Request resolved: https://github.com/facebook/rocksdb/pull/4844 Differential Revision: D13574934 Pulled By: yiwu-arbug fbshipit-source-id: 7ea871beb1be7d5a1259cc38f9b78078793db2db	2019-01-04 11:08:52 -08:00
Abhishek Madan	de0891ec01	Fix unused member compile error Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/4793 Differential Revision: D13509363 Pulled By: abhimadan fbshipit-source-id: 530b4765e3335d6ecd016bfaa89645f8aa98c61f	2018-12-18 15:23:20 -08:00
Abhishek Madan	33564d2c10	Remove v1 RangeDelAggregator (#4778 ) Summary: Now that v2 is fully functional, the v1 aggregator is removed. The v2 aggregator has been renamed. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4778 Differential Revision: D13495930 Pulled By: abhimadan fbshipit-source-id: 9d69500a60a283e79b6c4fa938fc68a8aa4d40d6	2018-12-18 15:23:20 -08:00
Abhishek Madan	96de211f4c	Add compaction logic to RangeDelAggregatorV2 (#4758 ) Summary: RangeDelAggregatorV2 now supports ShouldDelete calls on snapshot stripes and creation of range tombstone compaction iterators. RangeDelAggregator is no longer used on any non-test code path, and will be removed in a future commit. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4758 Differential Revision: D13439254 Pulled By: abhimadan fbshipit-source-id: fe105bcf8e3d4a2df37a622d5510843cd71b0401	2018-12-17 15:33:11 -08:00
Abhishek Madan	8522d9c74d	Prepare FragmentedRangeTombstoneIterator for use in compaction (#4740 ) Summary: To support the flush/compaction use cases of RangeDelAggregator in v2, FragmentedRangeTombstoneIterator now supports dropping tombstones that cannot be read in the compaction output file. Furthermore, FragmentedRangeTombstoneIterator supports the "snapshot striping" use case by allowing an iterator to be split by a list of snapshots. RangeDelAggregatorV2 will use these changes in a follow-up change. In the process of making these changes, other miscellaneous cleanups were also done in these files. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4740 Differential Revision: D13287382 Pulled By: abhimadan fbshipit-source-id: f5aeb03e1b3058049b80c02a558ee48f723fa48c	2018-12-17 15:33:11 -08:00