Fix GitHub issue #3716 : gcc-8 warnings

Summary: Fix the following gcc-8 warnings: - conflicting C language linkage declaration [-Werror] - writing to an object with no trivial copy-assignment [-Werror=class-memaccess] - array subscript -1 is below array bounds [-Werror=array-bounds] Solves https://github.com/facebook/rocksdb/issues/3716 Closes https://github.com/facebook/rocksdb/pull/3736 Differential Revision: D7684161 Pulled By: yiwu-arbug fbshipit-source-id: 47c0423d26b74add251f1d3595211eee1e41e54a
Making platform 007 (gcc 7) default in build_detect_platform.sh (#5947 )
2026-11-06 19:12:36 -05:00 · 2019-10-30 13:48:20 -07:00 · 2019-10-30 13:48:20 -07:00 · 2019-10-30 13:48:20 -07:00 · 2017-12-06 19:08:17 -08:00 · 2017-12-06 19:07:47 -08:00
318 changed files with 4047 additions and 14730 deletions
@@ -21,7 +21,6 @@ env:
  - TEST_GROUP=platform_dependent # 16-18 minutes
  - TEST_GROUP=1 # 33-35 minutes
  - TEST_GROUP=2 # 30-32 minutes
-  - TEST_GROUP=3 # ? minutes - under development
  # Run java tests
  - JOB_NAME=java_test # 4-11 minutes
  # Build ROCKSDB_LITE
@@ -37,8 +36,6 @@ matrix:
    env: TEST_GROUP=1
  - os: osx
    env: TEST_GROUP=2
-  - os: osx
-    env: TEST_GROUP=3
  - os : osx
    env: JOB_NAME=cmake-mingw
  - os : linux
@@ -60,11 +57,9 @@ before_script:

 script:
  - ${CXX} --version
-  - if [ `command -v ccache` ]; then ccache -C; fi
-  - if [ "${TEST_GROUP}" == 'platform_dependent' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_END=db_block_cache_test make -j4 all_but_some_tests check_some; fi
+  - if [ "${TEST_GROUP}" == 'platform_dependent' ]; then ccache -C && OPT=-DTRAVIS V=1 ROCKSDBTESTS_END=db_block_cache_test make -j4 all_but_some_tests check_some; fi
  - if [ "${TEST_GROUP}" == '1' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=db_block_cache_test ROCKSDBTESTS_END=comparator_db_test make -j4 check_some; fi
-  - if [ "${TEST_GROUP}" == '2' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=comparator_db_test ROCKSDBTESTS_END=write_prepared_transaction_test make -j4 check_some; fi
-  - if [ "${TEST_GROUP}" == '3' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=write_prepared_transaction_test make -j4 check_some; fi
+  - if [ "${TEST_GROUP}" == '2' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=comparator_db_test make -j4 check_some; fi
  - if [ "${JOB_NAME}" == 'java_test' ]; then OPT=-DTRAVIS V=1 make clean jclean && make rocksdbjava jtest; fi
  - if [ "${JOB_NAME}" == 'lite_build' ]; then OPT="-DTRAVIS -DROCKSDB_LITE" V=1 make -j4 static_lib tools; fi
  - if [ "${JOB_NAME}" == 'examples' ]; then OPT=-DTRAVIS V=1 make -j4 static_lib; cd examples; make -j4; fi
@@ -9,4 +9,3 @@ Sanjay Ghemawat <sanjay@google.com>
 # Partial list of contributors:
 Kevin Regan <kevin.d.regan@gmail.com>
 Johan Bilien <jobi@litl.com>
-Matthew Von-Maszewski <https://github.com/matthewvon> (Basho Technologies)
@@ -32,7 +32,7 @@
 # 3. cmake ..
 # 4. make -j

-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 2.6)
 project(rocksdb)

 if(POLICY CMP0042)
@@ -98,7 +98,17 @@ else()
  endif()
 endif()

-string(TIMESTAMP GIT_DATE_TIME "%Y/%m/%d %H:%M:%S" UTC)
+if(WIN32)
+  execute_process(COMMAND powershell -noprofile -Command "Get-Date -format MM_dd_yyyy" OUTPUT_VARIABLE DATE)
+  execute_process(COMMAND powershell -noprofile -Command "Get-Date -format HH:mm:ss" OUTPUT_VARIABLE TIME)
+  string(REGEX REPLACE "(..)_(..)_..(..).*" "\\1/\\2/\\3" DATE "${DATE}")
+  string(REGEX REPLACE "(..):(.....).*" " \\1:\\2" TIME "${TIME}")
+  set(GIT_DATE_TIME "${DATE} ${TIME}")
+else()
+  execute_process(COMMAND date "+%Y/%m/%d %H:%M:%S" OUTPUT_VARIABLE DATETIME)
+  string(REGEX REPLACE "\n" "" DATETIME ${DATETIME})
+  set(GIT_DATE_TIME "${DATETIME}")
+endif()

 find_package(Git)

@@ -145,10 +155,10 @@ target_include_directories(build_version PRIVATE
  ${CMAKE_CURRENT_SOURCE_DIR}/util)
 if(MSVC)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi /nologo /EHsc /GS /Gd /GR /GF /fp:precise /Zc:wchar_t /Zc:forScope /errorReport:queue")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W4 /wd4127 /wd4800 /wd4996 /wd4351 /wd4100 /wd4204 /wd4324")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W3 /wd4127 /wd4800 /wd4996 /wd4351")
 else()
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-compare -Wshadow -Wno-unused-parameter -Wno-unused-variable -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers -Wno-strict-aliasing")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-compare -Wshadow -Wno-unused-parameter -Wno-unused-variable -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers")
  if(MINGW)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-format")
  endif()
@@ -179,10 +189,8 @@ else()
  endif()
 endif()

+set(CMAKE_REQUIRED_FLAGS ${CMAKE_CXX_FLAGS})
 include(CheckCXXSourceCompiles)
-if(NOT MSVC)
-  set(CMAKE_REQUIRED_FLAGS "-msse4.2")
-endif()
 CHECK_CXX_SOURCE_COMPILES("
 #include <cstdint>
 #include <nmmintrin.h>
@@ -190,7 +198,6 @@ int main() {
  volatile uint32_t x = _mm_crc32_u32(0, 0);
 }
 " HAVE_SSE42)
-unset(CMAKE_REQUIRED_FLAGS)
 if(HAVE_SSE42)
  add_definitions(-DHAVE_SSE42)
 elseif(FORCE_SSE42)
@@ -546,28 +553,18 @@ set(SOURCES
        utilities/table_properties_collectors/compact_on_deletion_collector.cc
        utilities/transactions/optimistic_transaction_db_impl.cc
        utilities/transactions/optimistic_transaction.cc
-        utilities/transactions/pessimistic_transaction.cc
-        utilities/transactions/pessimistic_transaction_db.cc
-        utilities/transactions/snapshot_checker.cc
        utilities/transactions/transaction_base.cc
+        utilities/transactions/pessimistic_transaction_db.cc
        utilities/transactions/transaction_db_mutex_impl.cc
+        utilities/transactions/pessimistic_transaction.cc
        utilities/transactions/transaction_lock_mgr.cc
        utilities/transactions/transaction_util.cc
        utilities/transactions/write_prepared_txn.cc
-        utilities/transactions/write_prepared_txn_db.cc
        utilities/ttl/db_ttl_impl.cc
        utilities/write_batch_with_index/write_batch_with_index.cc
        utilities/write_batch_with_index/write_batch_with_index_internal.cc
        $<TARGET_OBJECTS:build_version>)

-if(HAVE_SSE42 AND NOT FORCE_SSE42)
-  if(NOT MSVC)
-set_source_files_properties(
-  util/crc32c.cc
-      PROPERTIES COMPILE_FLAGS "-msse4.2")
-  endif()
-endif()
-
 if(WIN32)
  list(APPEND SOURCES
    port/win/io_win.cc
@@ -577,12 +574,12 @@ if(WIN32)
    port/win/win_logger.cc
    port/win/win_thread.cc
    port/win/xpress_win.cc)
-
+	
 if(WITH_JEMALLOC)
  list(APPEND SOURCES
    port/win/win_jemalloc.cc)
 endif()
-
+	
 else()
  list(APPEND SOURCES
    port/port_posix.cc
@@ -841,7 +838,6 @@ if(WITH_TESTS)
        utilities/table_properties_collectors/compact_on_deletion_collector_test.cc
        utilities/transactions/optimistic_transaction_test.cc
        utilities/transactions/transaction_test.cc
-        utilities/transactions/write_prepared_transaction_test.cc
        utilities/ttl/ttl_test.cc
        utilities/write_batch_with_index/write_batch_with_index_test.cc
  )
@@ -1,40 +1,19 @@
 # Rocksdb Change Log
-## 5.9.3 (03/16/2018)
-### Bug Fixes
-* Fix WAL corruption caused by race condition between user write thread and backup/checkpoint thread.
-
-## 5.9.2 (12/6/2017)
+## 5.8.8 (12/6/2017)
 ### Bug Fixes
 * Fix possible corruption to LSM structure when `DeleteFilesInRange()` deletes a subset of files spanned by a `DeleteRange()` marker.

-## 5.9.1 (11/28/2017)
+## 5.8.7 (11/28/2017)
 ### Bug Fixes
 * Fix IOError on WAL write doesn't propagate to write group follower
-* Fix calculating filter partition target size
-
-## 5.9.0 (11/1/2017)
-### Public API Change
-* `BackupableDBOptions::max_valid_backups_to_open == 0` now means no backups will be opened during BackupEngine initialization. Previously this condition disabled limiting backups opened.
-* `DBOptions::preserve_deletes` is a new option that allows one to specify that DB should not drop tombstones for regular deletes if they have sequence number larger than what was set by the new API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)`. Disabled by default.
-* API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)` was added, users who wish to preserve deletes are expected to periodically call this function to advance the cutoff seqnum (all deletes made before this seqnum can be dropped by DB). It's user responsibility to figure out how to advance the seqnum in the way so the tombstones are kept for the desired period of time, yet are eventually processed in time and don't eat up too much space.
-* `ReadOptions::iter_start_seqnum` was added; if set to something > 0 user will see 2 changes in iterators behavior 1) only keys written with sequence larger than this parameter would be returned and 2) the `Slice` returned by iter->key() now points to the the memory that keep User-oriented representation of the internal key, rather than user key. New struct `FullKey` was added to represent internal keys, along with a new helper function `ParseFullKey(const Slice& internal_key, FullKey* result);`.
-* Deprecate trash_dir param in NewSstFileManager, right now we will rename deleted files to <name>.trash instead of moving them to trash directory
-* Return an error on write if write_options.sync = true and write_options.disableWAL = true to warn user of inconsistent options. Previously we will not write to WAL and not respecting the sync options in this case.
-
-### New Features
-* `DBOptions::writable_file_max_buffer_size` can now be changed dynamically.
-* `DBOptions::bytes_per_sync` and `DBOptions::wal_bytes_per_sync` can now be changed dynamically, `DBOptions::wal_bytes_per_sync` will flush all memtables and switch to a new WAL file.
-* Support dynamic adjustment of rate limit according to demand for background I/O. It can be enabled by passing `true` to the `auto_tuned` parameter in `NewGenericRateLimiter()`. The value passed as `rate_bytes_per_sec` will still be respected as an upper-bound.
-* Support dynamically changing `ColumnFamilyOptions::compaction_options_fifo`.
-* Introduce `EventListener::OnStallConditionsChanged()` callback. Users can implement it to be notified when user writes are stalled, stopped, or resumed.
-* Add a new db property "rocksdb.estimate-oldest-key-time" to return oldest data timestamp. The property is available only for FIFO compaction with compaction_options_fifo.allow_compaction = false.
-* Upon snapshot release, recompact bottommost files containing deleted/overwritten keys that previously could not be dropped due to the snapshot. This alleviates space-amp caused by long-held snapshots.
-* Support lower bound on iterators specified via `ReadOptions::iterate_lower_bound`.
-* Support for differential snapshots (via iterator emitting the sequence of key-values representing the difference between DB state at two different sequence numbers). Supports preserving and emitting puts and regular deletes, doesn't support SingleDeletes, MergeOperator, Blobs and Range Deletes.

+## 5.8.6 (11/20/2017)
 ### Bug Fixes
-* Fix a potential data inconsistency issue during point-in-time recovery. `DB:Open()` will abort if column family inconsistency is found during PIT recovery.
-* Fix possible metadata corruption in databases using `DeleteRange()`.
+* Fixed aligned_alloc issues with Windows.
+
+## 5.8.1 (10/23/2017)
+### New Features
+* Add a new db property "rocksdb.estimate-oldest-key-time" to return oldest data timestamp. The property is available only for FIFO compaction with compaction_options_fifo.allow_compaction = false.

 ## 5.8.0 (08/30/2017)
 ### Public API Change
@@ -114,7 +114,7 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
  * For building with MS Visual Studio 13 you will need Update 4 installed.
  * Read and follow the instructions at CMakeLists.txt
  * Or install via [vcpkg](https://github.com/microsoft/vcpkg) 
-       * run `vcpkg install rocksdb:x64-windows`
+       * run `vcpkg install rocksdb`

 * **AIX 6.1**
    * Install AIX Toolbox rpms with gcc
@@ -96,21 +96,11 @@ OPT += -momit-leaf-frame-pointer
 endif
 endif

-ifeq (,$(shell $(CXX) -fsyntax-only -maltivec -xc /dev/null 2>&1))
-CXXFLAGS += -DHAS_ALTIVEC
-CFLAGS += -DHAS_ALTIVEC
-HAS_ALTIVEC=1
-endif
-
-ifeq (,$(shell $(CXX) -fsyntax-only -mcpu=power8 -xc /dev/null 2>&1))
-CXXFLAGS += -DHAVE_POWER8
-CFLAGS +=  -DHAVE_POWER8
-HAVE_POWER8=1
-endif
-
-# if we're compiling for release, compile without debug code (-DNDEBUG)
+# if we're compiling for release, compile without debug code (-DNDEBUG) and
+# don't treat warnings as errors
 ifeq ($(DEBUG_LEVEL),0)
 OPT += -DNDEBUG
+DISABLE_WARNING_AS_ERROR=1

 ifneq ($(USE_RTTI), 1)
 	CXXFLAGS += -fno-rtti
@@ -332,14 +322,6 @@ util/build_version.cc: FORCE
 endif

 LIBOBJECTS = $(LIB_SOURCES:.cc=.o)
-ifeq ($(HAVE_POWER8),1)
-LIB_CC_OBJECTS = $(LIB_SOURCES:.cc=.o)
-LIBOBJECTS += $(LIB_SOURCES_C:.c=.o)
-LIBOBJECTS += $(LIB_SOURCES_ASM:.S=.o)
-else
-LIB_CC_OBJECTS = $(LIB_SOURCES:.cc=.o)
-endif
-
 LIBOBJECTS += $(TOOL_LIB_SOURCES:.cc=.o)
 MOCKOBJECTS = $(MOCK_LIB_SOURCES:.cc=.o)

@@ -495,7 +477,6 @@ TESTS = \
 	object_registry_test \
 	repair_test \
 	env_timed_test \
-	write_prepared_transaction_test \

 PARALLEL_TEST = \
 	backupable_db_test \
@@ -511,8 +492,7 @@ PARALLEL_TEST = \
 	manual_compaction_test \
 	persistent_cache_test \
 	table_test \
-	transaction_test \
-	write_prepared_transaction_test
+	transaction_test

 SUBSET := $(TESTS)
 ifdef ROCKSDBTESTS_START
@@ -592,35 +572,14 @@ $(SHARED2): $(SHARED4)
 $(SHARED3): $(SHARED4)
 	ln -fs $(SHARED4) $(SHARED3)
 endif
-ifeq ($(HAVE_POWER8),1)
-SHARED_C_OBJECTS = $(LIB_SOURCES_C:.c=.o)
-SHARED_ASM_OBJECTS = $(LIB_SOURCES_ASM:.S=.o)
-SHARED_C_LIBOBJECTS = $(patsubst %.o,shared-objects/%.o,$(SHARED_C_OBJECTS))
-SHARED_ASM_LIBOBJECTS = $(patsubst %.o,shared-objects/%.o,$(SHARED_ASM_OBJECTS))
-shared_libobjects = $(patsubst %,shared-objects/%,$(LIB_CC_OBJECTS))
-else
+
 shared_libobjects = $(patsubst %,shared-objects/%,$(LIBOBJECTS))
-endif
-
 CLEAN_FILES += shared-objects
-shared_all_libobjects = $(shared_libobjects)

-ifeq ($(HAVE_POWER8),1)
-shared-ppc-objects = $(SHARED_C_LIBOBJECTS) $(SHARED_ASM_LIBOBJECTS)
-
-shared-objects/util/crc32c_ppc.o: util/crc32c_ppc.c
-	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-
-shared-objects/util/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
-	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-endif
 $(shared_libobjects): shared-objects/%.o: %.cc
 	$(AM_V_CC)mkdir -p $(@D) && $(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) -c $< -o $@

-ifeq ($(HAVE_POWER8),1)
-shared_all_libobjects = $(shared_libobjects) $(shared-ppc-objects)
-endif
-$(SHARED4): $(shared_all_libobjects)
+$(SHARED4): $(shared_libobjects)
 	$(CXX) $(PLATFORM_SHARED_LDFLAGS)$(SHARED3) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) $(shared_libobjects) $(LDFLAGS) -o $@

 endif  # PLATFORM_SHARED_EXT
@@ -742,7 +701,7 @@ gen_parallel_tests:
 # 107.816 PASS t/DBTest.EncodeDecompressedBlockSizeTest
 #
 slow_test_regexp = \
-	^.*SnapshotConcurrentAccessTest.*$$|^t/run-table_test-HarnessTest.Randomized$$|^t/run-db_test-.*(?:FileCreationRandomFailure|EncodeDecompressedBlockSizeTest)$$|^.*RecoverFromCorruptedWALWithoutFlush$$
+	^t/run-table_test-HarnessTest.Randomized$$|^t/run-db_test-.*(?:FileCreationRandomFailure|EncodeDecompressedBlockSizeTest)$$|^.*RecoverFromCorruptedWALWithoutFlush$$
 prioritize_long_running_tests =						\
  perl -pe 's,($(slow_test_regexp)),100 $$1,'				\
    | sort -k1,1gr							\
@@ -1272,7 +1231,7 @@ env_test: env/env_test.o $(LIBOBJECTS) $(TESTHARNESS)
 fault_injection_test: db/fault_injection_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-rate_limiter_test: util/rate_limiter_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
+rate_limiter_test: util/rate_limiter_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

 delete_scheduler_test: util/delete_scheduler_test.o $(LIBOBJECTS) $(TESTHARNESS)
@@ -1437,9 +1396,6 @@ heap_test: util/heap_test.o $(GTEST)
 transaction_test: utilities/transactions/transaction_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-write_prepared_transaction_test: utilities/transactions/write_prepared_transaction_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 sst_dump: tools/sst_dump.o $(LIBOBJECTS)
 	$(AM_LINK)

@@ -1646,9 +1602,8 @@ libzstd.a:
 	cp zstd-$(ZSTD_VER)/lib/libzstd.a .

 # A version of each $(LIBOBJECTS) compiled with -fPIC and a fixed set of static compression libraries
-java_static_libobjects = $(patsubst %,jls/%,$(LIB_CC_OBJECTS))
+java_static_libobjects = $(patsubst %,jls/%,$(LIBOBJECTS))
 CLEAN_FILES += jls
-java_static_all_libobjects = $(java_static_libobjects)

 ifneq ($(ROCKSDB_JAVA_NO_COMPRESSION), 1)
 JAVA_COMPRESSIONS = libz.a libbz2.a libsnappy.a liblz4.a libzstd.a
@@ -1657,30 +1612,15 @@ endif
 JAVA_STATIC_FLAGS = -DZLIB -DBZIP2 -DSNAPPY -DLZ4 -DZSTD
 JAVA_STATIC_INCLUDES = -I./zlib-$(ZLIB_VER) -I./bzip2-$(BZIP2_VER) -I./snappy-$(SNAPPY_VER) -I./lz4-$(LZ4_VER)/lib -I./zstd-$(ZSTD_VER)/lib

-ifeq ($(HAVE_POWER8),1)
-JAVA_STATIC_C_LIBOBJECTS = $(patsubst %.c.o,jls/%.c.o,$(LIB_SOURCES_C:.c=.o))
-JAVA_STATIC_ASM_LIBOBJECTS = $(patsubst %.S.o,jls/%.S.o,$(LIB_SOURCES_ASM:.S=.o))
-
-java_static_ppc_libobjects = $(JAVA_STATIC_C_LIBOBJECTS) $(JAVA_STATIC_ASM_LIBOBJECTS)
-
-jls/util/crc32c_ppc.o: util/crc32c_ppc.c
-	$(AM_V_CC)$(CC) $(CFLAGS) $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES) -c $< -o $@
-
-jls/util/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
-	$(AM_V_CC)$(CC) $(CFLAGS) $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES) -c $< -o $@
-
-java_static_all_libobjects += $(java_static_ppc_libobjects)
-endif
-
 $(java_static_libobjects): jls/%.o: %.cc $(JAVA_COMPRESSIONS)
 	$(AM_V_CC)mkdir -p $(@D) && $(CXX) $(CXXFLAGS) $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES) -fPIC -c $< -o $@ $(COVERAGEFLAGS)

-rocksdbjavastatic: $(java_static_all_libobjects)
+rocksdbjavastatic: $(java_static_libobjects)
 	cd java;$(MAKE) javalib;
 	rm -f ./java/target/$(ROCKSDBJNILIB)
 	$(CXX) $(CXXFLAGS) -I./java/. $(JAVA_INCLUDE) -shared -fPIC \
 	  -o ./java/target/$(ROCKSDBJNILIB) $(JNI_NATIVE_SOURCES) \
-	  $(java_static_all_libobjects) $(COVERAGEFLAGS) \
+	  $(java_static_libobjects) $(COVERAGEFLAGS) \
 	  $(JAVA_COMPRESSIONS) $(JAVA_STATIC_LDFLAGS)
 	cd java/target;strip $(STRIPFLAGS) $(ROCKSDBJNILIB)
 	cd java;jar -cf target/$(ROCKSDB_JAR) HISTORY*.md
@@ -1710,14 +1650,6 @@ rocksdbjavastaticreleasedocker: rocksdbjavastatic
 	cd java/target;jar -uf $(ROCKSDB_JAR_ALL) librocksdbjni-*.so librocksdbjni-*.jnilib
 	cd java/target/classes;jar -uf ../$(ROCKSDB_JAR_ALL) org/rocksdb/*.class org/rocksdb/util/*.class

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

 rocksdbjavastaticpublishdocker: rocksdbjavastaticreleasedocker rocksdbjavastaticpublishcentral
@@ -1732,36 +1664,13 @@ rocksdbjavastaticpublishcentral:
 	mvn gpg:sign-and-deploy-file -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ -DrepositoryId=sonatype-nexus-staging -DpomFile=java/rocksjni.pom -Dfile=java/target/rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH).jar

 # A version of each $(LIBOBJECTS) compiled with -fPIC
-ifeq ($(HAVE_POWER8),1)
-JAVA_CC_OBJECTS = $(SHARED_CC_OBJECTS)
-JAVA_C_OBJECTS = $(SHARED_C_OBJECTS)
-JAVA_ASM_OBJECTS = $(SHARED_ASM_OBJECTS)
-
-JAVA_C_LIBOBJECTS = $(patsubst %.c.o,jl/%.c.o,$(JAVA_C_OBJECTS))
-JAVA_ASM_LIBOBJECTS = $(patsubst %.S.o,jl/%.S.o,$(JAVA_ASM_OBJECTS))
-endif
-
 java_libobjects = $(patsubst %,jl/%,$(LIBOBJECTS))
 CLEAN_FILES += jl
-java_all_libobjects = $(java_libobjects)
-
-ifeq ($(HAVE_POWER8),1)
-java_ppc_libobjects = $(JAVA_C_LIBOBJECTS) $(JAVA_ASM_LIBOBJECTS)
-
-jl/crc32c_ppc.o: util/crc32c_ppc.c
-	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-
-jl/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
-	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-java_all_libobjects += $(java_ppc_libobjects)
-endif

 $(java_libobjects): jl/%.o: %.cc
 	$(AM_V_CC)mkdir -p $(@D) && $(CXX) $(CXXFLAGS) -fPIC -c $< -o $@ $(COVERAGEFLAGS)

-
-
-rocksdbjava: $(java_all_libobjects)
+rocksdbjava: $(java_libobjects)
 	$(AM_V_GEN)cd java;$(MAKE) javalib;
 	$(AM_V_at)rm -f ./java/target/$(ROCKSDBJNILIB)
 	$(AM_V_at)$(CXX) $(CXXFLAGS) -I./java/. $(JAVA_INCLUDE) -shared -fPIC -o ./java/target/$(ROCKSDBJNILIB) $(JNI_NATIVE_SOURCES) $(java_libobjects) $(JAVA_LDFLAGS) $(COVERAGEFLAGS)
@@ -1816,54 +1725,30 @@ IOSVERSION=$(shell defaults read $(PLATFORMSROOT)/iPhoneOS.platform/version CFBu
 	lipo ios-x86/$@ ios-arm/$@ -create -output $@

 else
-ifeq ($(HAVE_POWER8),1)
-util/crc32c_ppc.o: util/crc32c_ppc.c
-	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-
-util/crc32c_ppc_asm.o: util/crc32c_ppc_asm.S
-	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
-endif
 .cc.o:
 	$(AM_V_CC)$(CXX) $(CXXFLAGS) -c $< -o $@ $(COVERAGEFLAGS)

 .c.o:
 	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
 endif
+
 # ---------------------------------------------------------------------------
 #  	Source files dependencies detection
 # ---------------------------------------------------------------------------

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

 # Add proper dependency support so changing a .h file forces a .cc file to
 # rebuild.

 # The .d file indicates .cc file's dependencies on .h files. We generate such
 # dependency by g++'s -MM option, whose output is a make dependency rule.
-%.cc.d: %.cc
+$(DEPFILES): %.d: %.cc
 	@$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) \
 	  -MM -MT'$@' -MT'$(<:.cc=.o)' "$<" -o '$@'

-ifeq ($(HAVE_POWER8),1)
-DEPFILES_C = $(LIB_SOURCES_C:.c=.c.d)
-DEPFILES_ASM = $(LIB_SOURCES_ASM:.S=.S.d)
-
-%.c.d: %.c
-	@$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) \
-	  -MM -MT'$@' -MT'$(<:.c=.o)' "$<" -o '$@'
-
-%.S.d: %.S
-	@$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) \
-	  -MM -MT'$@' -MT'$(<:.S=.o)' "$<" -o '$@'
-
-$(DEPFILES_C): %.c.d
-
-$(DEPFILES_ASM): %.S.d
-depend: $(DEPFILES) $(DEPFILES_C) $(DEPFILES_ASM)
-else
 depend: $(DEPFILES)
-endif

 # if the make goal is either "clean" or "format", we shouldn't
 # try to import the *.d files.
@@ -5,14 +5,12 @@ At Facebook, we use RocksDB as storage engines in multiple data management servi

 1. MyRocks -- https://github.com/MySQLOnRocksDB/mysql-5.6
 2. MongoRocks -- https://github.com/mongodb-partners/mongo-rocks
-3. ZippyDB --  Facebook's distributed key-value store with Paxos-style replication, built on top of RocksDB.[1] https://www.youtube.com/watch?v=DfiN7pG0D0khtt
-4. Laser -- Laser is a high query throughput, low (millisecond) latency, key-value storage service built on top of RocksDB.[1]
+3. ZippyDB --  Facebook's distributed key-value store with Paxos-style replication, built on top of RocksDB.[*] https://www.youtube.com/watch?v=DfiN7pG0D0khtt
+4. Laser -- Laser is a high query throughput, low (millisecond) latency, key-value storage service built on top of RocksDB.[*]
 4. Dragon -- a distributed graph query engine. https://code.facebook.com/posts/1737605303120405/dragon-a-distributed-graph-query-engine/
-5. Stylus -- a low-level stream processing framework writtenin C++.[1]
-6. LogDevice -- a distributed data store for logs [2]
+5. Stylus -- a low-level stream processing framework writtenin C++.[*]

-[1] https://research.facebook.com/publications/realtime-data-processing-at-facebook/
-[2] https://code.facebook.com/posts/357056558062811/logdevice-a-distributed-data-store-for-logs/
+[*] https://research.facebook.com/publications/realtime-data-processing-at-facebook/

 ## LinkedIn
 Two different use cases at Linkedin are using RocksDB as a storage engine:
@@ -8,7 +8,7 @@ before_build:
 build:
  project: build\rocksdb.sln
  parallel: true
-  verbosity: normal
+  verbosity: minimal
 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
@@ -3,17 +3,19 @@ from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
 import targets_cfg
+import pprint

-def pretty_list(lst, indent=8):
+# TODO(tec): replace this with PrettyPrinter
+def pretty_list(lst, indent=6):
    if lst is None or len(lst) == 0:
        return ""

    if len(lst) == 1:
        return "\"%s\"" % lst[0]
-    
+
    separator = "\",\n%s\"" % (" " * indent)
-    res = separator.join(sorted(lst))
-    res = "\n" + (" " * indent) + "\"" + res + "\",\n" + (" " * (indent - 4))
+    res = separator.join(lst)
+    res = "\n" + (" " * indent) + "\"" + res + "\",\n" + (" " * (indent - 2))
    return res


@@ -25,7 +27,7 @@ class TARGETSBuilder:
        self.total_lib = 0
        self.total_bin = 0
        self.total_test = 0
-        self.tests_cfg = ""
+        self.tests_cfg = []

    def __del__(self):
        self.targets_file.close()
@@ -35,8 +37,8 @@ class TARGETSBuilder:
            headers = "AutoHeaders.RECURSIVE_GLOB"
        self.targets_file.write(targets_cfg.library_template % (
            name,
-            pretty_list(srcs),
            headers,
+            pretty_list(srcs),
            pretty_list(deps)))
        self.total_lib = self.total_lib + 1

@@ -51,13 +53,13 @@ class TARGETSBuilder:
        exec_mode = "serial"
        if is_parallel:
            exec_mode = "parallel"
-        self.tests_cfg += targets_cfg.test_cfg_template % (
-            test_name,
-            str(src),
-            str(exec_mode))
+        self.tests_cfg.append([test_name, str(src), str(exec_mode)])

        self.total_test = self.total_test + 1

    def flush_tests(self):
-        self.targets_file.write(targets_cfg.unittests_template % self.tests_cfg)
-        self.tests_cfg = ""
+        self.targets_file.write(targets_cfg.unittests_template % (
+            pprint.PrettyPrinter().pformat(self.tests_cfg)
+        ))
+
+        self.tests_cfg = []
@@ -2,141 +2,123 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
-rocksdb_target_header = """REPO_PATH = package_name() + "/"
+rocksdb_target_header = """
+import os

+TARGETS_PATH = os.path.dirname(__file__)
+REPO_PATH = "rocksdb/src/"
 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",
-    "-DROCKSDB_FALLOCATE_PRESENT",
-    "-DROCKSDB_MALLOC_USABLE_SIZE",
-    "-DROCKSDB_RANGESYNC_PRESENT",
-    "-DROCKSDB_SCHED_GETCPU_PRESENT",
-    "-DROCKSDB_SUPPORT_THREAD_LOCAL",
-    "-DOS_LINUX",
-    # Flags to enable libs we include
-    "-DSNAPPY",
-    "-DZLIB",
-    "-DBZIP2",
-    "-DLZ4",
-    "-DZSTD",
-    "-DGFLAGS=gflags",
-    "-DNUMA",
-    "-DTBB",
-    # Needed to compile in fbcode
-    "-Wno-expansion-to-defined",
+  "-fno-builtin-memcmp",
+  "-DROCKSDB_PLATFORM_POSIX",
+  "-DROCKSDB_LIB_IO_POSIX",
+  "-DROCKSDB_FALLOCATE_PRESENT",
+  "-DROCKSDB_MALLOC_USABLE_SIZE",
+  "-DROCKSDB_RANGESYNC_PRESENT",
+  "-DROCKSDB_SCHED_GETCPU_PRESENT",
+  "-DROCKSDB_SUPPORT_THREAD_LOCAL",
+  "-DOS_LINUX",
+  # Flags to enable libs we include
+  "-DSNAPPY",
+  "-DZLIB",
+  "-DBZIP2",
+  "-DLZ4",
+  "-DZSTD",
+  "-DGFLAGS=gflags",
+  "-DNUMA",
+  "-DTBB",
+  # Needed to compile in fbcode
+  "-Wno-expansion-to-defined",
 ]

 rocksdb_external_deps = [
-    ("bzip2", None, "bz2"),
-    ("snappy", None, "snappy"),
-    ("zlib", None, "z"),
-    ("gflags", None, "gflags"),
-    ("lz4", None, "lz4"),
-    ("zstd", None),
-    ("tbb", None),
-    ("numa", None, "numa"),
-    ("googletest", None, "gtest"),
+  ('bzip2', None, 'bz2'),
+  ('snappy', None, "snappy"),
+  ('zlib', None, 'z'),
+  ('gflags', None, 'gflags'),
+  ('lz4', None, 'lz4'),
+  ('zstd', None),
+  ('tbb', None),
+  ("numa", None, "numa"),
+  ("googletest", None, "gtest"),
 ]

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

 rocksdb_arch_preprocessor_flags = {
-    "x86_64": ["-DHAVE_SSE42"],
+  "x86_64": ["-DHAVE_SSE42"],
 }
-
-build_mode = read_config("fbcode", "build_mode")
-
-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.
-if is_opt_mode:
-    rocksdb_compiler_flags.append("-DNDEBUG")
 """


 library_template = """
 cpp_library(
    name = "%s",
-    srcs = [%s],
    headers = %s,
+    srcs = [%s],
+    deps = [%s],
+    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,
 )
 """

 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,
-    deps = [%s],
-    external_deps = rocksdb_external_deps,
+  name = "%s",
+  srcs = [%s],
+  deps = [%s],
+  preprocessor_flags = rocksdb_preprocessor_flags,
+  arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+  compiler_flags = rocksdb_compiler_flags,
+  external_deps = rocksdb_external_deps,
 )
 """

-test_cfg_template = """    [
-        "%s",
-        "%s",
-        "%s",
-    ],
-"""
-
 unittests_template = """
 # [test_name, test_src, test_type]
-ROCKS_TESTS = [
-%s]
+ROCKS_TESTS = %s
+

 # 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.
-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"
+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],
-          deps = [":rocksdb_test_lib"],
-          preprocessor_flags = rocksdb_preprocessor_flags,
-          arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
-          compiler_flags = rocksdb_compiler_flags,
-          external_deps = rocksdb_external_deps,
-        )
+    cpp_binary (
+      name = test_bin,
+      srcs = [test_cc],
+      deps = [":rocksdb_test_lib"],
+      preprocessor_flags = rocksdb_preprocessor_flags,
+      arch_preprocessor_flags = rocksdb_arch_preprocessor_flags,
+      compiler_flags = rocksdb_compiler_flags,
+      external_deps = rocksdb_external_deps,
+    )

-        custom_unittest(
-          name = test_name,
-          type = ttype,
-          deps = [":" + test_bin],
-          command = [TEST_RUNNER, BUCK_BINS + test_bin]
-        )
+    custom_unittest(
+      name = test_name,
+      type = ttype,
+      deps = [":" + test_bin],
+      command = [TEST_RUNNER, BUCK_BINS + test_bin]
+    )

 custom_unittest(
    name = "make_rocksdbjavastatic",
-    command = ["internal_repo_rocksdb/make_rocksdbjavastatic.sh"],
    type = "simple",
+    command = ["internal_repo_rocksdb/make_rocksdbjavastatic.sh"],
 )

 custom_unittest(
    name = "make_rocksdb_lite_release",
-    command = ["internal_repo_rocksdb/make_rocksdb_lite_release.sh"],
    type = "simple",
+    command = ["internal_repo_rocksdb/make_rocksdb_lite_release.sh"],
 )
 """
@@ -1,18 +1,18 @@
-GCC_BASE=/mnt/gvfs/third-party2/gcc/8219ec1bcedf8ad9da05e121e193364de2cc4f61/5.x/centos6-native/c447969
-CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/64d8d58e3d84f8bde7a029763d4f5baf39d0d5b9/stable/centos6-native/6aaf4de
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/ba9be983c81de7299b59fe71950c664a84dcb5f8/5.x/gcc-5-glibc-2.23/339d858
-GLIBC_BASE=/mnt/gvfs/third-party2/glibc/f20197cf3d4bd50339c9777aaa0b2ccadad9e2cb/2.23/gcc-5-glibc-2.23/ca1d1c0
-SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/6427ce8c7496e4ab06c2da81543b94c0de8be3d0/1.1.3/gcc-5-glibc-2.23/9bc6787
-ZLIB_BASE=/mnt/gvfs/third-party2/zlib/8f1e8b867d26efef93eac2fabbdb2e1d512665d7/1.2.8/gcc-5-glibc-2.23/9bc6787
-BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/70471c0571559fe0af7db6d7e8860b93a7eadfe1/1.0.6/gcc-5-glibc-2.23/9bc6787
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/453c89d6f0e68cdf1c151c769197fabedad9cac8/r131/gcc-5-glibc-2.23/9bc6787
-ZSTD_BASE=/mnt/gvfs/third-party2/zstd/00a40fa5f8bd2cd0622f2e868552793aef37ccf4/1.3.0/gcc-5-glibc-2.23/03859b5
-GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/47eef08f9acb77de982fbda6047c26d330739538/2.2.0/gcc-5-glibc-2.23/9bc6787
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/4414ddc78df8008b35cc4adac23590ad29148584/master/gcc-5-glibc-2.23/d506c82
-NUMA_BASE=/mnt/gvfs/third-party2/numa/9d7ae2693d05d62f9a579cb21e6b717cf257a75d/2.0.11/gcc-5-glibc-2.23/9bc6787
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/2b2dd58e3a52ccf2c1d827def59e5f740de0ad15/1.2/gcc-5-glibc-2.23/b443de1
-TBB_BASE=/mnt/gvfs/third-party2/tbb/379addf7ab2468a2b4293b47456cfcd1c9cb318d/4.3/gcc-5-glibc-2.23/9bc6787
-KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/3f68f5fe65a85b7c2d3e66852268fbd1efdb3151/4.0.9-36_fbk5_2933_gd092e3f/gcc-5-glibc-2.23/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/b9fab0aec99d9c36408e810b2677e91c12807afd/2.28/centos6-native/da39a3e
-VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/423431d61786b20bcc3bde8972901130cb29e6b3/3.11.0/gcc-5-glibc-2.23/9bc6787
-LUA_BASE=/mnt/gvfs/third-party2/lua/3b0bb3bd9a0f690a069c479fcc0f7424fc7456d2/5.2.3/gcc-5-glibc-2.23/65372bd
+GCC_BASE=/mnt/gvfs/third-party2/gcc/2928bb3ed95bf64f5b388ee88c30dc74710c3b35/5.x/centos6-native/f4950a1
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/a5fea028cb7ba43498976e1f8054b0b2e790c295/stable/centos6-native/6aaf4de
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/7a9099f6587ee4378c0b1fa32bb8934019d30ca4/5.x/gcc-5-glibc-2.23/339d858
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/3b7c6469854dfc7832a1c3cc5b86919a84e5f865/2.23/gcc-5-glibc-2.23/ca1d1c0
+SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/8c38a4c1e52b4c2cc8a9cdc31b9c947ed7dbfcb4/1.1.3/gcc-5-glibc-2.23/9bc6787
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/d7861abe6f0e27ab98c9303b95a662f0e4cdedb5/1.2.8/gcc-5-glibc-2.23/9bc6787
+BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/740325875f6729f42d28deaa2147b0854f3a347e/1.0.6/gcc-5-glibc-2.23/9bc6787
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/0815d59804160c96caac5f27ca004f51af893dc6/r131/gcc-5-glibc-2.23/9bc6787
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/c15a4f5f619a2930478d01e2e34dc1e0652b0873/1.1.4/gcc-5-glibc-2.23/03859b5
+GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/f905a5e1032fb30c05db3d3752319857388c0c49/2.2.0/gcc-5-glibc-2.23/9bc6787
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/8d60633d822a2a55849c73db24e74a25e52b71db/master/gcc-5-glibc-2.23/1c32b4b
+NUMA_BASE=/mnt/gvfs/third-party2/numa/17c514c4d102a25ca15f4558be564eeed76f4b6a/2.0.8/gcc-5-glibc-2.23/9bc6787
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/8db74270cd6d0212ac92d69e7fc7beefe617d772/trunk/gcc-5-glibc-2.23/b1847cb
+TBB_BASE=/mnt/gvfs/third-party2/tbb/9d9a554877d0c5bef330fe818ab7178806dd316a/4.0_update2/gcc-5-glibc-2.23/9bc6787
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/90c9734afc5579c9d1db529fa788d09f97763b85/4.0.9-36_fbk5_2933_gd092e3f/gcc-5-glibc-2.23/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/9e829389ef61b92c62de8748c80169aaf25ce1f0/2.26.1/centos6-native/da39a3e
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d7f4d4d86674a57668e3a96f76f0e17dd0eb8765/3.11.0/gcc-5-glibc-2.23/9bc6787
+LUA_BASE=/mnt/gvfs/third-party2/lua/61e4abf5813bbc39bc4f548757ccfcadde175a48/5.2.3/gcc-5-glibc-2.23/65372bd
@@ -38,7 +38,6 @@ function get_lib_base()
    # platform is not provided, use latest gcc
    result=`ls -dr1v $result/gcc-*[^fb]/ | head -n1`
  else
-    echo $lib_platform
    result="$result/$lib_platform/"
  fi
  
@@ -111,22 +110,22 @@ log_variable GCC_BASE
 log_variable CLANG_BASE

 # Libraries locations
-get_lib_base libgcc     5.x     gcc-5-glibc-2.23
-get_lib_base glibc      2.23    gcc-5-glibc-2.23
-get_lib_base snappy     LATEST  gcc-5-glibc-2.23
-get_lib_base zlib       LATEST  gcc-5-glibc-2.23
-get_lib_base bzip2      LATEST  gcc-5-glibc-2.23
-get_lib_base lz4        LATEST  gcc-5-glibc-2.23
-get_lib_base zstd       LATEST  gcc-5-glibc-2.23
-get_lib_base gflags     LATEST  gcc-5-glibc-2.23
-get_lib_base jemalloc   LATEST  gcc-5-glibc-2.23
-get_lib_base numa       LATEST  gcc-5-glibc-2.23
-get_lib_base libunwind  LATEST  gcc-5-glibc-2.23
-get_lib_base tbb        LATEST  gcc-5-glibc-2.23
+get_lib_base libgcc     5.x
+get_lib_base glibc      2.23
+get_lib_base snappy     LATEST gcc-5-glibc-2.23
+get_lib_base zlib       LATEST
+get_lib_base bzip2      LATEST
+get_lib_base lz4        LATEST
+get_lib_base zstd       LATEST
+get_lib_base gflags     LATEST
+get_lib_base jemalloc   LATEST
+get_lib_base numa       LATEST
+get_lib_base libunwind  LATEST
+get_lib_base tbb        4.0_update2 gcc-5-glibc-2.23

-get_lib_base kernel-headers 4.0.9-36_fbk5_2933_gd092e3f gcc-5-glibc-2.23
+get_lib_base kernel-headers LATEST 
 get_lib_base binutils   LATEST centos6-native 
-get_lib_base valgrind   LATEST gcc-5-glibc-2.23
+get_lib_base valgrind   3.10.0 gcc-5-glibc-2.23
 get_lib_base lua        5.2.3 gcc-5-glibc-2.23

 git diff $OUTPUT
@@ -100,9 +100,7 @@ void LRUHandleTable::Resize() {
 }

 LRUCacheShard::LRUCacheShard()
-    : capacity_(0), high_pri_pool_usage_(0), strict_capacity_limit_(false),
-      high_pri_pool_ratio_(0), high_pri_pool_capacity_(0), usage_(0),
-      lru_usage_(0) {
+    : high_pri_pool_usage_(0), usage_(0), lru_usage_(0) {
  // Make empty circular linked list
  lru_.next = &lru_;
  lru_.prev = &lru_;
@@ -355,7 +353,6 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
  e->deleter = deleter;
  e->charge = charge;
  e->key_length = key.size();
-  e->flags = 0;
  e->hash = hash;
  e->refs = (handle == nullptr
                 ? 1
@@ -70,7 +70,7 @@ Status BuildTable(
    uint32_t column_family_id, const std::string& column_family_name,
    std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
-    SnapshotChecker* snapshot_checker, const CompressionType compression,
+    const CompressionType compression,
    const CompressionOptions& compression_opts, bool paranoid_file_checks,
    InternalStats* internal_stats, TableFileCreationReason reason,
    EventLogger* event_logger, int job_id, const Env::IOPriority io_priority,
@@ -134,7 +134,7 @@ Status BuildTable(

    CompactionIterator c_iter(
        iter, internal_comparator.user_comparator(), &merge, kMaxSequenceNumber,
-        &snapshots, earliest_write_conflict_snapshot, snapshot_checker, env,
+        &snapshots, earliest_write_conflict_snapshot, env,
        true /* internal key corruption is not ok */, range_del_agg.get());
    c_iter.SeekToFirst();
    for (; c_iter.Valid(); c_iter.Next()) {
@@ -29,7 +29,6 @@ struct FileMetaData;
 class Env;
 struct EnvOptions;
 class Iterator;
-class SnapshotChecker;
 class TableCache;
 class VersionEdit;
 class TableBuilder;
@@ -73,7 +72,7 @@ extern Status BuildTable(
    uint32_t column_family_id, const std::string& column_family_name,
    std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
-    SnapshotChecker* snapshot_checker, const CompressionType compression,
+    const CompressionType compression,
    const CompressionOptions& compression_opts, bool paranoid_file_checks,
    InternalStats* internal_stats, TableFileCreationReason reason,
    EventLogger* event_logger = nullptr, int job_id = 0,
@@ -21,23 +21,23 @@
 #include "rocksdb/env.h"
 #include "rocksdb/filter_policy.h"
 #include "rocksdb/iterator.h"
-#include "rocksdb/memtablerep.h"
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/options.h"
-#include "rocksdb/rate_limiter.h"
-#include "rocksdb/slice_transform.h"
-#include "rocksdb/statistics.h"
 #include "rocksdb/status.h"
-#include "rocksdb/table.h"
+#include "rocksdb/write_batch.h"
+#include "rocksdb/memtablerep.h"
 #include "rocksdb/universal_compaction.h"
+#include "rocksdb/statistics.h"
+#include "rocksdb/slice_transform.h"
+#include "rocksdb/table.h"
+#include "rocksdb/rate_limiter.h"
 #include "rocksdb/utilities/backupable_db.h"
-#include "rocksdb/utilities/checkpoint.h"
-#include "rocksdb/utilities/optimistic_transaction_db.h"
+#include "rocksdb/utilities/write_batch_with_index.h"
+#include "utilities/merge_operators.h"
 #include "rocksdb/utilities/transaction.h"
 #include "rocksdb/utilities/transaction_db.h"
-#include "rocksdb/utilities/write_batch_with_index.h"
-#include "rocksdb/write_batch.h"
-#include "utilities/merge_operators.h"
+#include "rocksdb/utilities/optimistic_transaction_db.h"
+#include "rocksdb/utilities/checkpoint.h"

 using rocksdb::BytewiseComparator;
 using rocksdb::Cache;
@@ -2012,8 +2012,8 @@ void rocksdb_options_set_paranoid_checks(
  opt->rep.paranoid_checks = v;
 }

-void rocksdb_options_set_db_paths(rocksdb_options_t* opt,
-                                  const rocksdb_dbpath_t** dbpath_values,
+void rocksdb_options_set_db_paths(rocksdb_options_t* opt, 
+                                  const rocksdb_dbpath_t** dbpath_values, 
                                  size_t num_paths) {
  std::vector<DbPath> db_paths(num_paths);
  for (size_t i = 0; i < num_paths; ++i) {
@@ -2100,8 +2100,7 @@ void rocksdb_options_enable_statistics(rocksdb_options_t* opt) {
  opt->rep.statistics = rocksdb::CreateDBStatistics();
 }

-void rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt,
-                                                      unsigned char val) {
+void rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt, unsigned char val) {
  opt->rep.skip_stats_update_on_db_open = val;
 }

@@ -2255,21 +2254,11 @@ void rocksdb_options_set_use_adaptive_mutex(
  opt->rep.use_adaptive_mutex = v;
 }

-void rocksdb_options_set_wal_bytes_per_sync(
-    rocksdb_options_t* opt, uint64_t v) {
-  opt->rep.wal_bytes_per_sync = v;
-}
-
 void rocksdb_options_set_bytes_per_sync(
    rocksdb_options_t* opt, uint64_t v) {
  opt->rep.bytes_per_sync = v;
 }

-void rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t* opt,
-                                                       uint64_t v) {
-  opt->rep.writable_file_max_buffer_size = v;
-}
-
 void rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t* opt,
                                                         unsigned char v) {
  opt->rep.allow_concurrent_memtable_write = v;
@@ -3327,14 +3316,6 @@ void rocksdb_transaction_rollback(rocksdb_transaction_t* txn, char** errptr) {
  SaveError(errptr, txn->rep->Rollback());
 }

-void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) {
-  txn->rep->SetSavePoint();
-}
-
-void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn, char** errptr) {
-  SaveError(errptr, txn->rep->RollbackToSavePoint());
-}
-
 void rocksdb_transaction_destroy(rocksdb_transaction_t* txn) {
  delete txn->rep;
  delete txn;
@@ -3472,8 +3453,8 @@ void rocksdb_transactiondb_put(rocksdb_transactiondb_t* txn_db,
                               const rocksdb_writeoptions_t* options,
                               const char* key, size_t klen, const char* val,
                               size_t vlen, char** errptr) {
-  SaveError(errptr,
-            txn_db->rep->Put(options->rep, Slice(key, klen), Slice(val, vlen)));
+  SaveError(errptr, txn_db->rep->Put(options->rep, Slice(key, klen), 
+                                     Slice(val, vlen)));
 }

 void rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t* txn_db,
@@ -3507,8 +3488,8 @@ void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db,
                                 const rocksdb_writeoptions_t* options,
                                 const char* key, size_t klen, const char* val,
                                 size_t vlen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Merge(options->rep, Slice(key, klen),
-                                       Slice(val, vlen)));
+  SaveError(errptr,
+    txn_db->rep->Merge(options->rep, Slice(key, klen), Slice(val, vlen)));
 }

 // Delete a key inside a transaction
@@ -3546,15 +3527,6 @@ rocksdb_iterator_t* rocksdb_transaction_create_iterator(
  return result;
 }

-// Create an iterator inside a transaction with column family
-rocksdb_iterator_t* rocksdb_transaction_create_iterator_cf(
-    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family) {
-  rocksdb_iterator_t* result = new rocksdb_iterator_t;
-  result->rep = txn->rep->GetIterator(options->rep, column_family->rep);
-  return result;
-}
-
 // Create an iterator outside a transaction
 rocksdb_iterator_t* rocksdb_transactiondb_create_iterator(
    rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options) {
@@ -3580,7 +3552,8 @@ rocksdb_checkpoint_t* rocksdb_transactiondb_checkpoint_object_create(
 }

 rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open(
-    const rocksdb_options_t* options, const char* name, char** errptr) {
+    const rocksdb_options_t* options, const char* name,
+    char** errptr) {
  OptimisticTransactionDB* otxn_db;
  if (SaveError(errptr, OptimisticTransactionDB::Open(
                            options->rep, std::string(name), &otxn_db))) {
@@ -3592,56 +3565,6 @@ rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open(
  return result;
 }

-rocksdb_optimistictransactiondb_t*
-rocksdb_optimistictransactiondb_open_column_families(
-    const rocksdb_options_t* db_options, const char* name,
-    int num_column_families, const char** column_family_names,
-    const rocksdb_options_t** column_family_options,
-    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
-  std::vector<ColumnFamilyDescriptor> column_families;
-  for (int i = 0; i < num_column_families; i++) {
-    column_families.push_back(ColumnFamilyDescriptor(
-        std::string(column_family_names[i]),
-        ColumnFamilyOptions(column_family_options[i]->rep)));
-  }
-
-  OptimisticTransactionDB* otxn_db;
-  std::vector<ColumnFamilyHandle*> handles;
-  if (SaveError(errptr, OptimisticTransactionDB::Open(
-                            DBOptions(db_options->rep), std::string(name),
-                            column_families, &handles, &otxn_db))) {
-    return nullptr;
-  }
-
-  for (size_t i = 0; i < handles.size(); i++) {
-    rocksdb_column_family_handle_t* c_handle =
-        new rocksdb_column_family_handle_t;
-    c_handle->rep = handles[i];
-    column_family_handles[i] = c_handle;
-  }
-  rocksdb_optimistictransactiondb_t* result =
-      new rocksdb_optimistictransactiondb_t;
-  result->rep = otxn_db;
-  return result;
-}
-
-rocksdb_t* rocksdb_optimistictransactiondb_get_base_db(
-    rocksdb_optimistictransactiondb_t* otxn_db) {
-  DB* base_db = otxn_db->rep->GetBaseDB();
-
-  if (base_db != nullptr) {
-    rocksdb_t* result = new rocksdb_t;
-    result->rep = base_db;
-    return result;
-  }
-
-  return nullptr;
-}
-
-void rocksdb_optimistictransactiondb_close_base_db(rocksdb_t* base_db) {
-  delete base_db;
-}
-
 rocksdb_transaction_t* rocksdb_optimistictransaction_begin(
    rocksdb_optimistictransactiondb_t* otxn_db,
    const rocksdb_writeoptions_t* write_options,
@@ -334,20 +334,6 @@ static void CheckTxnGet(
        Free(&val);
 }

-static void CheckTxnGetCF(rocksdb_transaction_t* txn,
-                          const rocksdb_readoptions_t* options,
-                          rocksdb_column_family_handle_t* column_family,
-                          const char* key, const char* expected) {
-  char* err = NULL;
-  size_t val_len;
-  char* val;
-  val = rocksdb_transaction_get_cf(txn, options, column_family, key,
-                                   strlen(key), &val_len, &err);
-  CheckNoError(err);
-  CheckEqual(expected, val, val_len);
-  Free(&val);
-}
-
 static void CheckTxnDBGet(
        rocksdb_transactiondb_t* txn_db,
        const rocksdb_readoptions_t* options,
@@ -392,8 +378,6 @@ int main(int argc, char** argv) {
  rocksdb_transactiondb_options_t* txn_db_options;
  rocksdb_transaction_t* txn;
  rocksdb_transaction_options_t* txn_options;
-  rocksdb_optimistictransactiondb_t* otxn_db;
-  rocksdb_optimistictransaction_options_t* otxn_options;
  char* err = NULL;
  int run = -1;

@@ -1463,25 +1447,6 @@ int main(int argc, char** argv) {
    CheckNoError(err);
    CheckTxnDBGet(txn_db, roptions, "bar", NULL);

-    // save point
-    rocksdb_transaction_put(txn, "foo1", 4, "hi1", 3, &err);
-    rocksdb_transaction_set_savepoint(txn);
-    CheckTxnGet(txn, roptions, "foo1", "hi1");
-    rocksdb_transaction_put(txn, "foo2", 4, "hi2", 3, &err);
-    CheckTxnGet(txn, roptions, "foo2", "hi2");
-
-    // rollback to savepoint
-    rocksdb_transaction_rollback_to_savepoint(txn, &err);
-    CheckNoError(err);
-    CheckTxnGet(txn, roptions, "foo2", NULL);
-    CheckTxnGet(txn, roptions, "foo1", "hi1");
-    CheckTxnDBGet(txn_db, roptions, "foo1", NULL);
-    CheckTxnDBGet(txn_db, roptions, "foo2", NULL);
-    rocksdb_transaction_commit(txn, &err);
-    CheckNoError(err);
-    CheckTxnDBGet(txn_db, roptions, "foo1", "hi1");
-    CheckTxnDBGet(txn_db, roptions, "foo2", NULL);
-
    // Column families.
    rocksdb_column_family_handle_t* cfh;
    cfh = rocksdb_transactiondb_create_column_family(txn_db, options,
@@ -1508,105 +1473,6 @@ int main(int argc, char** argv) {
    rocksdb_transactiondb_options_destroy(txn_db_options);
  }

-  StartPhase("optimistic_transactions");
-  {
-    rocksdb_options_t* db_options = rocksdb_options_create();
-    rocksdb_options_set_create_if_missing(db_options, 1);
-    rocksdb_options_set_allow_concurrent_memtable_write(db_options, 1);
-    otxn_db = rocksdb_optimistictransactiondb_open(db_options, dbname, &err);
-    otxn_options = rocksdb_optimistictransaction_options_create();
-    rocksdb_transaction_t* txn1 = rocksdb_optimistictransaction_begin(
-        otxn_db, woptions, otxn_options, NULL);
-    rocksdb_transaction_t* txn2 = rocksdb_optimistictransaction_begin(
-        otxn_db, woptions, otxn_options, NULL);
-    rocksdb_transaction_put(txn1, "key", 3, "value", 5, &err);
-    CheckNoError(err);
-    rocksdb_transaction_put(txn2, "key1", 4, "value1", 6, &err);
-    CheckNoError(err);
-    CheckTxnGet(txn1, roptions, "key", "value");
-    rocksdb_transaction_commit(txn1, &err);
-    CheckNoError(err);
-    rocksdb_transaction_commit(txn2, &err);
-    CheckNoError(err);
-    rocksdb_transaction_destroy(txn1);
-    rocksdb_transaction_destroy(txn2);
-
-    // Check column family
-    db = rocksdb_optimistictransactiondb_get_base_db(otxn_db);
-    rocksdb_put(db, woptions, "key", 3, "value", 5, &err);
-    CheckNoError(err);
-    rocksdb_column_family_handle_t *cfh1, *cfh2;
-    cfh1 = rocksdb_create_column_family(db, db_options, "txn_db_cf1", &err);
-    cfh2 = rocksdb_create_column_family(db, db_options, "txn_db_cf2", &err);
-    txn = rocksdb_optimistictransaction_begin(otxn_db, woptions, otxn_options,
-                                              NULL);
-    rocksdb_transaction_put_cf(txn, cfh1, "key_cf1", 7, "val_cf1", 7, &err);
-    CheckNoError(err);
-    rocksdb_transaction_put_cf(txn, cfh2, "key_cf2", 7, "val_cf2", 7, &err);
-    CheckNoError(err);
-    rocksdb_transaction_commit(txn, &err);
-    CheckNoError(err);
-    txn = rocksdb_optimistictransaction_begin(otxn_db, woptions, otxn_options,
-                                              txn);
-    CheckGetCF(db, roptions, cfh1, "key_cf1", "val_cf1");
-    CheckTxnGetCF(txn, roptions, cfh1, "key_cf1", "val_cf1");
-
-    // Check iterator with column family
-    rocksdb_transaction_put_cf(txn, cfh1, "key1_cf", 7, "val1_cf", 7, &err);
-    CheckNoError(err);
-    rocksdb_iterator_t* iter =
-        rocksdb_transaction_create_iterator_cf(txn, roptions, cfh1);
-    CheckCondition(!rocksdb_iter_valid(iter));
-    rocksdb_iter_seek_to_first(iter);
-    CheckCondition(rocksdb_iter_valid(iter));
-    CheckIter(iter, "key1_cf", "val1_cf");
-    rocksdb_iter_get_error(iter, &err);
-    CheckNoError(err);
-    rocksdb_iter_destroy(iter);
-
-    rocksdb_transaction_destroy(txn);
-    rocksdb_column_family_handle_destroy(cfh1);
-    rocksdb_column_family_handle_destroy(cfh2);
-    rocksdb_optimistictransactiondb_close_base_db(db);
-    rocksdb_optimistictransactiondb_close(otxn_db);
-
-    // Check open optimistic transaction db with column families
-    size_t cf_len;
-    char** column_fams =
-        rocksdb_list_column_families(db_options, dbname, &cf_len, &err);
-    CheckNoError(err);
-    CheckEqual("default", column_fams[0], 7);
-    CheckEqual("txn_db_cf1", column_fams[1], 10);
-    CheckEqual("txn_db_cf2", column_fams[2], 10);
-    CheckCondition(cf_len == 3);
-    rocksdb_list_column_families_destroy(column_fams, cf_len);
-
-    const char* cf_names[3] = {"default", "txn_db_cf1", "txn_db_cf2"};
-    rocksdb_options_t* cf_options = rocksdb_options_create();
-    const rocksdb_options_t* cf_opts[3] = {cf_options, cf_options, cf_options};
-
-    rocksdb_options_set_error_if_exists(cf_options, 0);
-    rocksdb_column_family_handle_t* cf_handles[3];
-    otxn_db = rocksdb_optimistictransactiondb_open_column_families(
-        db_options, dbname, 3, cf_names, cf_opts, cf_handles, &err);
-    CheckNoError(err);
-    rocksdb_transaction_t* txn_cf = rocksdb_optimistictransaction_begin(
-        otxn_db, woptions, otxn_options, NULL);
-    CheckTxnGetCF(txn_cf, roptions, cf_handles[0], "key", "value");
-    CheckTxnGetCF(txn_cf, roptions, cf_handles[1], "key_cf1", "val_cf1");
-    CheckTxnGetCF(txn_cf, roptions, cf_handles[2], "key_cf2", "val_cf2");
-    rocksdb_transaction_destroy(txn_cf);
-    rocksdb_options_destroy(cf_options);
-    rocksdb_column_family_handle_destroy(cf_handles[0]);
-    rocksdb_column_family_handle_destroy(cf_handles[1]);
-    rocksdb_column_family_handle_destroy(cf_handles[2]);
-    rocksdb_optimistictransactiondb_close(otxn_db);
-    rocksdb_destroy_db(db_options, dbname, &err);
-    rocksdb_options_destroy(db_options);
-    rocksdb_optimistictransaction_options_destroy(otxn_options);
-    CheckNoError(err);
-  }
-
  // Simple sanity check that setting memtable rep works.
  StartPhase("memtable_reps");
  {
@@ -463,8 +463,7 @@ ColumnFamilyData::~ColumnFamilyData() {
  if (dummy_versions_ != nullptr) {
    // List must be empty
    assert(dummy_versions_->TEST_Next() == dummy_versions_);
-    bool deleted __attribute__((unused));
-    deleted = dummy_versions_->Unref();
+    bool deleted __attribute__((unused)) = dummy_versions_->Unref();
    assert(deleted);
  }

@@ -614,9 +613,8 @@ int GetL0ThresholdSpeedupCompaction(int level0_file_num_compaction_trigger,
 }
 }  // namespace

-WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
+void ColumnFamilyData::RecalculateWriteStallConditions(
      const MutableCFOptions& mutable_cf_options) {
-  auto write_stall_condition = WriteStallCondition::kNormal;
  if (current_ != nullptr) {
    auto* vstorage = current_->storage_info();
    auto write_controller = column_family_set_->write_controller_;
@@ -628,8 +626,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(

    if (imm()->NumNotFlushed() >= mutable_cf_options.max_write_buffer_number) {
      write_controller_token_ = write_controller->GetStopToken();
-      internal_stats_->AddCFStats(InternalStats::MEMTABLE_LIMIT_STOPS, 1);
-      write_stall_condition = WriteStallCondition::kStopped;
+      internal_stats_->AddCFStats(InternalStats::MEMTABLE_COMPACTION, 1);
      ROCKS_LOG_WARN(
          ioptions_.info_log,
          "[%s] Stopping writes because we have %d immutable memtables "
@@ -640,11 +637,10 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
               vstorage->l0_delay_trigger_count() >=
                   mutable_cf_options.level0_stop_writes_trigger) {
      write_controller_token_ = write_controller->GetStopToken();
-      internal_stats_->AddCFStats(InternalStats::L0_FILE_COUNT_LIMIT_STOPS, 1);
-      write_stall_condition = WriteStallCondition::kStopped;
+      internal_stats_->AddCFStats(InternalStats::LEVEL0_NUM_FILES_TOTAL, 1);
      if (compaction_picker_->IsLevel0CompactionInProgress()) {
        internal_stats_->AddCFStats(
-            InternalStats::LOCKED_L0_FILE_COUNT_LIMIT_STOPS, 1);
+            InternalStats::LEVEL0_NUM_FILES_WITH_COMPACTION, 1);
      }
      ROCKS_LOG_WARN(ioptions_.info_log,
                     "[%s] Stopping writes because we have %d level-0 files",
@@ -655,8 +651,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
                   mutable_cf_options.hard_pending_compaction_bytes_limit) {
      write_controller_token_ = write_controller->GetStopToken();
      internal_stats_->AddCFStats(
-          InternalStats::PENDING_COMPACTION_BYTES_LIMIT_STOPS, 1);
-      write_stall_condition = WriteStallCondition::kStopped;
+          InternalStats::HARD_PENDING_COMPACTION_BYTES_LIMIT, 1);
      ROCKS_LOG_WARN(
          ioptions_.info_log,
          "[%s] Stopping writes because of estimated pending compaction "
@@ -669,8 +664,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
          SetupDelay(write_controller, compaction_needed_bytes,
                     prev_compaction_needed_bytes_, was_stopped,
                     mutable_cf_options.disable_auto_compactions);
-      internal_stats_->AddCFStats(InternalStats::MEMTABLE_LIMIT_SLOWDOWNS, 1);
-      write_stall_condition = WriteStallCondition::kDelayed;
+      internal_stats_->AddCFStats(InternalStats::MEMTABLE_SLOWDOWN, 1);
      ROCKS_LOG_WARN(
          ioptions_.info_log,
          "[%s] Stalling writes because we have %d immutable memtables "
@@ -690,12 +684,10 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
          SetupDelay(write_controller, compaction_needed_bytes,
                     prev_compaction_needed_bytes_, was_stopped || near_stop,
                     mutable_cf_options.disable_auto_compactions);
-      internal_stats_->AddCFStats(InternalStats::L0_FILE_COUNT_LIMIT_SLOWDOWNS,
-                                  1);
-      write_stall_condition = WriteStallCondition::kDelayed;
+      internal_stats_->AddCFStats(InternalStats::LEVEL0_SLOWDOWN_TOTAL, 1);
      if (compaction_picker_->IsLevel0CompactionInProgress()) {
        internal_stats_->AddCFStats(
-            InternalStats::LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS, 1);
+            InternalStats::LEVEL0_SLOWDOWN_WITH_COMPACTION, 1);
      }
      ROCKS_LOG_WARN(ioptions_.info_log,
                     "[%s] Stalling writes because we have %d level-0 files "
@@ -722,8 +714,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
                     prev_compaction_needed_bytes_, was_stopped || near_stop,
                     mutable_cf_options.disable_auto_compactions);
      internal_stats_->AddCFStats(
-          InternalStats::PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS, 1);
-      write_stall_condition = WriteStallCondition::kDelayed;
+          InternalStats::SOFT_PENDING_COMPACTION_BYTES_LIMIT, 1);
      ROCKS_LOG_WARN(
          ioptions_.info_log,
          "[%s] Stalling writes because of estimated pending compaction "
@@ -778,7 +769,6 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
    }
    prev_compaction_needed_bytes_ = compaction_needed_bytes;
  }
-  return write_stall_condition;
 }

 const EnvOptions* ColumnFamilyData::soptions() const {
@@ -855,10 +845,6 @@ SuperVersion* ColumnFamilyData::GetReferencedSuperVersion(
  sv = GetThreadLocalSuperVersion(db_mutex);
  sv->Ref();
  if (!ReturnThreadLocalSuperVersion(sv)) {
-    // This Unref() corresponds to the Ref() in GetThreadLocalSuperVersion()
-    // when the thread-local pointer was populated. So, the Ref() earlier in
-    // this function still prevents the returned SuperVersion* from being
-    // deleted out from under the caller.
    sv->Unref();
  }
  return sv;
@@ -928,16 +914,15 @@ bool ColumnFamilyData::ReturnThreadLocalSuperVersion(SuperVersion* sv) {
  return false;
 }

-void ColumnFamilyData::InstallSuperVersion(
-    SuperVersionContext* sv_context, InstrumentedMutex* db_mutex) {
+SuperVersion* ColumnFamilyData::InstallSuperVersion(
+    SuperVersion* new_superversion, InstrumentedMutex* db_mutex) {
  db_mutex->AssertHeld();
-  return InstallSuperVersion(sv_context, db_mutex, mutable_cf_options_);
+  return InstallSuperVersion(new_superversion, db_mutex, mutable_cf_options_);
 }

-void ColumnFamilyData::InstallSuperVersion(
-    SuperVersionContext* sv_context, InstrumentedMutex* db_mutex,
+SuperVersion* ColumnFamilyData::InstallSuperVersion(
+    SuperVersion* new_superversion, InstrumentedMutex* db_mutex,
    const MutableCFOptions& mutable_cf_options) {
-  SuperVersion* new_superversion = sv_context->new_superversion.release();
  new_superversion->db_mutex = db_mutex;
  new_superversion->mutable_cf_options = mutable_cf_options;
  new_superversion->Init(mem_, imm_.current(), current_);
@@ -945,28 +930,23 @@ void ColumnFamilyData::InstallSuperVersion(
  super_version_ = new_superversion;
  ++super_version_number_;
  super_version_->version_number = super_version_number_;
-  super_version_->write_stall_condition =
-      RecalculateWriteStallConditions(mutable_cf_options);
-
  if (old_superversion != nullptr) {
    if (old_superversion->mutable_cf_options.write_buffer_size !=
        mutable_cf_options.write_buffer_size) {
      mem_->UpdateWriteBufferSize(mutable_cf_options.write_buffer_size);
    }
-    if (old_superversion->write_stall_condition !=
-        new_superversion->write_stall_condition) {
-      sv_context->PushWriteStallNotification(
-          old_superversion->write_stall_condition,
-          new_superversion->write_stall_condition, GetName(), ioptions());
-    }
-    if (old_superversion->Unref()) {
-      old_superversion->Cleanup();
-      sv_context->superversions_to_free.push_back(old_superversion);
-    }
  }

  // Reset SuperVersions cached in thread local storage
  ResetThreadLocalSuperVersions();
+
+  RecalculateWriteStallConditions(mutable_cf_options);
+
+  if (old_superversion != nullptr && old_superversion->Unref()) {
+    old_superversion->Cleanup();
+    return old_superversion;  // will let caller delete outside of mutex
+  }
+  return nullptr;
 }

 void ColumnFamilyData::ResetThreadLocalSuperVersions() {
@@ -41,7 +41,6 @@ class DBImpl;
 class LogBuffer;
 class InstrumentedMutex;
 class InstrumentedMutexLock;
-struct SuperVersionContext;

 extern const double kIncSlowdownRatio;

@@ -77,7 +76,7 @@ class ColumnFamilyHandleImpl : public ColumnFamilyHandle {
 class ColumnFamilyHandleInternal : public ColumnFamilyHandleImpl {
 public:
  ColumnFamilyHandleInternal()
-      : ColumnFamilyHandleImpl(nullptr, nullptr, nullptr), internal_cfd_(nullptr) {}
+      : ColumnFamilyHandleImpl(nullptr, nullptr, nullptr) {}

  void SetCFD(ColumnFamilyData* _cfd) { internal_cfd_ = _cfd; }
  virtual ColumnFamilyData* cfd() const override { return internal_cfd_; }
@@ -96,7 +95,6 @@ struct SuperVersion {
  MutableCFOptions mutable_cf_options;
  // Version number of the current SuperVersion
  uint64_t version_number;
-  WriteStallCondition write_stall_condition;

  InstrumentedMutex* db_mutex;

@@ -266,7 +264,7 @@ class ColumnFamilyData {
                                  int level) const;

  // A flag to tell a manual compaction is to compact all levels together
-  // instead of a specific level.
+  // instad of for specific level.
  static const int kCompactAllLevels;
  // A flag to tell a manual compaction's output is base level.
  static const int kCompactToBaseLevel;
@@ -313,11 +311,11 @@ class ColumnFamilyData {
  // As argument takes a pointer to allocated SuperVersion to enable
  // the clients to allocate SuperVersion outside of mutex.
  // IMPORTANT: Only call this from DBImpl::InstallSuperVersion()
-  void InstallSuperVersion(SuperVersionContext* sv_context,
-                           InstrumentedMutex* db_mutex,
-                           const MutableCFOptions& mutable_cf_options);
-  void InstallSuperVersion(SuperVersionContext* sv_context,
-                           InstrumentedMutex* db_mutex);
+  SuperVersion* InstallSuperVersion(SuperVersion* new_superversion,
+                                    InstrumentedMutex* db_mutex,
+                                    const MutableCFOptions& mutable_cf_options);
+  SuperVersion* InstallSuperVersion(SuperVersion* new_superversion,
+                                    InstrumentedMutex* db_mutex);

  void ResetThreadLocalSuperVersions();

@@ -332,7 +330,7 @@ class ColumnFamilyData {
  // recalculation of compaction score. These values are used in
  // DBImpl::MakeRoomForWrite function to decide, if it need to make
  // a write stall
-  WriteStallCondition RecalculateWriteStallConditions(
+  void RecalculateWriteStallConditions(
      const MutableCFOptions& mutable_cf_options);

  void set_initialized() { initialized_.store(true); }
@@ -933,62 +933,62 @@ TEST_F(ColumnFamilyTest, FlushTest) {
 TEST_F(ColumnFamilyTest, LogDeletionTest) {
  db_options_.max_total_wal_size = std::numeric_limits<uint64_t>::max();
  column_family_options_.arena_block_size = 4 * 1024;
-  column_family_options_.write_buffer_size = 128000;  // 128KB
+  column_family_options_.write_buffer_size = 100000;  // 100KB
  Open();
  CreateColumnFamilies({"one", "two", "three", "four"});
  // Each bracket is one log file. if number is in (), it means
  // we don't need it anymore (it's been flushed)
  // []
  AssertCountLiveLogFiles(0);
-  PutRandomData(0, 1, 128);
+  PutRandomData(0, 1, 100);
  // [0]
-  PutRandomData(1, 1, 128);
+  PutRandomData(1, 1, 100);
  // [0, 1]
-  PutRandomData(1, 1000, 128);
+  PutRandomData(1, 1000, 100);
  WaitForFlush(1);
  // [0, (1)] [1]
  AssertCountLiveLogFiles(2);
-  PutRandomData(0, 1, 128);
+  PutRandomData(0, 1, 100);
  // [0, (1)] [0, 1]
  AssertCountLiveLogFiles(2);
-  PutRandomData(2, 1, 128);
+  PutRandomData(2, 1, 100);
  // [0, (1)] [0, 1, 2]
-  PutRandomData(2, 1000, 128);
+  PutRandomData(2, 1000, 100);
  WaitForFlush(2);
  // [0, (1)] [0, 1, (2)] [2]
  AssertCountLiveLogFiles(3);
-  PutRandomData(2, 1000, 128);
+  PutRandomData(2, 1000, 100);
  WaitForFlush(2);
  // [0, (1)] [0, 1, (2)] [(2)] [2]
  AssertCountLiveLogFiles(4);
-  PutRandomData(3, 1, 128);
+  PutRandomData(3, 1, 100);
  // [0, (1)] [0, 1, (2)] [(2)] [2, 3]
-  PutRandomData(1, 1, 128);
+  PutRandomData(1, 1, 100);
  // [0, (1)] [0, 1, (2)] [(2)] [1, 2, 3]
  AssertCountLiveLogFiles(4);
-  PutRandomData(1, 1000, 128);
+  PutRandomData(1, 1000, 100);
  WaitForFlush(1);
  // [0, (1)] [0, (1), (2)] [(2)] [(1), 2, 3] [1]
  AssertCountLiveLogFiles(5);
-  PutRandomData(0, 1000, 128);
+  PutRandomData(0, 1000, 100);
  WaitForFlush(0);
  // [(0), (1)] [(0), (1), (2)] [(2)] [(1), 2, 3] [1, (0)] [0]
  // delete obsolete logs -->
  // [(1), 2, 3] [1, (0)] [0]
  AssertCountLiveLogFiles(3);
-  PutRandomData(0, 1000, 128);
+  PutRandomData(0, 1000, 100);
  WaitForFlush(0);
  // [(1), 2, 3] [1, (0)], [(0)] [0]
  AssertCountLiveLogFiles(4);
-  PutRandomData(1, 1000, 128);
+  PutRandomData(1, 1000, 100);
  WaitForFlush(1);
  // [(1), 2, 3] [(1), (0)] [(0)] [0, (1)] [1]
  AssertCountLiveLogFiles(5);
-  PutRandomData(2, 1000, 128);
+  PutRandomData(2, 1000, 100);
  WaitForFlush(2);
  // [(1), (2), 3] [(1), (0)] [(0)] [0, (1)] [1, (2)], [2]
  AssertCountLiveLogFiles(6);
-  PutRandomData(3, 1000, 128);
+  PutRandomData(3, 1000, 100);
  WaitForFlush(3);
  // [(1), (2), (3)] [(1), (0)] [(0)] [0, (1)] [1, (2)], [2, (3)] [3]
  // delete obsolete logs -->
@@ -17,8 +17,7 @@ extern bool SaveValue(void* arg, const ParsedInternalKey& parsed_key,

 CompactedDBImpl::CompactedDBImpl(
  const DBOptions& options, const std::string& dbname)
-  : DBImpl(options, dbname), cfd_(nullptr), version_(nullptr),
-    user_comparator_(nullptr) {
+  : DBImpl(options, dbname) {
 }

 CompactedDBImpl::~CompactedDBImpl() {
@@ -94,7 +93,6 @@ std::vector<Status> CompactedDBImpl::MultiGet(const ReadOptions& options,
 }

 Status CompactedDBImpl::Init(const Options& options) {
-  SuperVersionContext sv_context(/* create_superversion */ true);
  mutex_.Lock();
  ColumnFamilyDescriptor cf(kDefaultColumnFamilyName,
                            ColumnFamilyOptions(options));
@@ -102,10 +100,9 @@ Status CompactedDBImpl::Init(const Options& options) {
  if (s.ok()) {
    cfd_ = reinterpret_cast<ColumnFamilyHandleImpl*>(
              DefaultColumnFamily())->cfd();
-    cfd_->InstallSuperVersion(&sv_context, &mutex_);
+    delete cfd_->InstallSuperVersion(new SuperVersion(), &mutex_);
  }
  mutex_.Unlock();
-  sv_context.Clean();
  if (!s.ok()) {
    return s;
  }
@@ -86,23 +86,35 @@ void Compaction::GetBoundaryKeys(
 bool Compaction::IsBottommostLevel(
    int output_level, VersionStorageInfo* vstorage,
    const std::vector<CompactionInputFiles>& inputs) {
-  int output_l0_idx;
-  if (output_level == 0) {
-    output_l0_idx = 0;
-    for (const auto* file : vstorage->LevelFiles(0)) {
-      if (inputs[0].files.back() == file) {
-        break;
-      }
-      ++output_l0_idx;
-    }
-    assert(static_cast<size_t>(output_l0_idx) < vstorage->LevelFiles(0).size());
-  } else {
-    output_l0_idx = -1;
+  if (inputs[0].level == 0 &&
+      inputs[0].files.back() != vstorage->LevelFiles(0).back()) {
+    return false;
  }
+
  Slice smallest_key, largest_key;
  GetBoundaryKeys(vstorage, inputs, &smallest_key, &largest_key);
-  return !vstorage->RangeMightExistAfterSortedRun(smallest_key, largest_key,
-                                                  output_level, output_l0_idx);
+
+  // Checks whether there are files living beyond the output_level.
+  // If lower levels have files, it checks for overlap between files
+  // if the compaction process and those files.
+  // Bottomlevel optimizations can be made if there are no files in
+  // lower levels or if there is no overlap with the files in
+  // the lower levels.
+  for (int i = output_level + 1; i < vstorage->num_levels(); i++) {
+    // It is not the bottommost level if there are files in higher
+    // levels when the output level is 0 or if there are files in
+    // higher levels which overlap with files to be compacted.
+    // output_level == 0 means that we want it to be considered
+    // s the bottommost level only if the last file on the level
+    // is a part of the files to be compacted - this is verified by
+    // the first if condition in this function
+    if (vstorage->NumLevelFiles(i) > 0 &&
+        (output_level == 0 ||
+         vstorage->OverlapInLevel(i, &smallest_key, &largest_key))) {
+      return false;
+    }
+  }
+  return true;
 }

 // test function to validate the functionality of IsBottommostLevel()
@@ -272,10 +284,10 @@ bool Compaction::KeyNotExistsBeyondOutputLevel(
  assert(input_version_ != nullptr);
  assert(level_ptrs != nullptr);
  assert(level_ptrs->size() == static_cast<size_t>(number_levels_));
-  if (bottommost_level_) {
-    return true;
-  } else if (output_level_ != 0 &&
-             cfd_->ioptions()->compaction_style == kCompactionStyleLevel) {
+  if (cfd_->ioptions()->compaction_style == kCompactionStyleLevel) {
+    if (output_level_ == 0) {
+      return false;
+    }
    // Maybe use binary search to find right entry instead of linear search?
    const Comparator* user_cmp = cfd_->user_comparator();
    for (int lvl = output_level_ + 1; lvl < number_levels_; lvl++) {
@@ -295,8 +307,9 @@ bool Compaction::KeyNotExistsBeyondOutputLevel(
      }
    }
    return true;
+  } else {
+    return bottommost_level_;
  }
-  return false;
 }

 // Mark (or clear) each file that is being compacted
@@ -4,9 +4,6 @@
 //  (found in the LICENSE.Apache file in the root directory).

 #include "db/compaction_iterator.h"
-
-#include "db/snapshot_checker.h"
-#include "port/likely.h"
 #include "rocksdb/listener.h"
 #include "table/internal_iterator.h"

@@ -40,40 +37,33 @@ CompactionEventListener::CompactionListenerValueType fromInternalValueType(
 CompactionIterator::CompactionIterator(
    InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
    SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-    SequenceNumber earliest_write_conflict_snapshot,
-    const SnapshotChecker* snapshot_checker, Env* env,
+    SequenceNumber earliest_write_conflict_snapshot, Env* env,
    bool expect_valid_internal_key, RangeDelAggregator* range_del_agg,
    const Compaction* compaction, const CompactionFilter* compaction_filter,
    CompactionEventListener* compaction_listener,
-    const std::atomic<bool>* shutting_down,
-    const SequenceNumber preserve_deletes_seqnum)
+    const std::atomic<bool>* shutting_down)
    : CompactionIterator(
          input, cmp, merge_helper, last_sequence, snapshots,
-          earliest_write_conflict_snapshot, snapshot_checker, env,
-          expect_valid_internal_key, range_del_agg,
+          earliest_write_conflict_snapshot, env, expect_valid_internal_key,
+          range_del_agg,
          std::unique_ptr<CompactionProxy>(
              compaction ? new CompactionProxy(compaction) : nullptr),
-          compaction_filter, compaction_listener, shutting_down,
-          preserve_deletes_seqnum) {}
+          compaction_filter, compaction_listener, shutting_down) {}

 CompactionIterator::CompactionIterator(
    InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
    SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-    SequenceNumber earliest_write_conflict_snapshot,
-    const SnapshotChecker* snapshot_checker, Env* env,
+    SequenceNumber earliest_write_conflict_snapshot, Env* env,
    bool expect_valid_internal_key, RangeDelAggregator* range_del_agg,
    std::unique_ptr<CompactionProxy> compaction,
    const CompactionFilter* compaction_filter,
    CompactionEventListener* compaction_listener,
-    const std::atomic<bool>* shutting_down,
-    const SequenceNumber preserve_deletes_seqnum
-  )
+    const std::atomic<bool>* shutting_down)
    : input_(input),
      cmp_(cmp),
      merge_helper_(merge_helper),
      snapshots_(snapshots),
      earliest_write_conflict_snapshot_(earliest_write_conflict_snapshot),
-      snapshot_checker_(snapshot_checker),
      env_(env),
      expect_valid_internal_key_(expect_valid_internal_key),
      range_del_agg_(range_del_agg),
@@ -83,12 +73,8 @@ CompactionIterator::CompactionIterator(
      compaction_listener_(compaction_listener),
 #endif  // ROCKSDB_LITE
      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) {
+      merge_out_iter_(merge_helper_) {
  assert(compaction_filter_ == nullptr || compaction_ != nullptr);
  bottommost_level_ =
      compaction_ == nullptr ? false : compaction_->bottommost_level();
@@ -145,8 +131,8 @@ void CompactionIterator::Next() {
    if (merge_out_iter_.Valid()) {
      key_ = merge_out_iter_.key();
      value_ = merge_out_iter_.value();
-      bool valid_key __attribute__((__unused__));
-      valid_key =  ParseInternalKey(key_, &ikey_);
+      bool valid_key __attribute__((__unused__)) =
+          ParseInternalKey(key_, &ikey_);
      // MergeUntil stops when it encounters a corrupt key and does not
      // include them in the result, so we expect the keys here to be valid.
      assert(valid_key);
@@ -180,58 +166,6 @@ void CompactionIterator::Next() {
  PrepareOutput();
 }

-void CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
-                                              Slice* skip_until) {
-  if (compaction_filter_ != nullptr &&
-      (ikey_.type == kTypeValue || ikey_.type == kTypeBlobIndex) &&
-      (visible_at_tip_ || ikey_.sequence > latest_snapshot_ ||
-       ignore_snapshots_)) {
-    // 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,
-    // replace the entry with a deletion marker.
-    CompactionFilter::Decision filter;
-    compaction_filter_value_.clear();
-    compaction_filter_skip_until_.Clear();
-    CompactionFilter::ValueType value_type =
-        ikey_.type == kTypeValue ? CompactionFilter::ValueType::kValue
-                                 : CompactionFilter::ValueType::kBlobIndex;
-    {
-      StopWatchNano timer(env_, true);
-      filter = compaction_filter_->FilterV2(
-          compaction_->level(), ikey_.user_key, value_type, value_,
-          &compaction_filter_value_, compaction_filter_skip_until_.rep());
-      iter_stats_.total_filter_time +=
-          env_ != nullptr ? timer.ElapsedNanos() : 0;
-    }
-
-    if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil &&
-        cmp_->Compare(*compaction_filter_skip_until_.rep(), ikey_.user_key) <=
-            0) {
-      // Can't skip to a key smaller than the current one.
-      // Keep the key as per FilterV2 documentation.
-      filter = CompactionFilter::Decision::kKeep;
-    }
-
-    if (filter == CompactionFilter::Decision::kRemove) {
-      // convert the current key to a delete; key_ is pointing into
-      // current_key_ at this point, so updating current_key_ updates key()
-      ikey_.type = kTypeDeletion;
-      current_key_.UpdateInternalKey(ikey_.sequence, kTypeDeletion);
-      // no value associated with delete
-      value_.clear();
-      iter_stats_.num_record_drop_user++;
-    } else if (filter == CompactionFilter::Decision::kChangeValue) {
-      value_ = compaction_filter_value_;
-    } else if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil) {
-      *need_skip = true;
-      compaction_filter_skip_until_.ConvertFromUserKey(kMaxSequenceNumber,
-                                                       kValueTypeForSeek);
-      *skip_until = compaction_filter_skip_until_.Encode();
-    }
-  }
-}
-
 void CompactionIterator::NextFromInput() {
  at_next_ = false;
  valid_ = false;
@@ -286,9 +220,6 @@ void CompactionIterator::NextFromInput() {
      has_outputted_key_ = false;
      current_user_key_sequence_ = kMaxSequenceNumber;
      current_user_key_snapshot_ = 0;
-      current_key_committed_ =
-          (snapshot_checker_ == nullptr ||
-           snapshot_checker_->IsInSnapshot(ikey_.sequence, kMaxSequenceNumber));

 #ifndef ROCKSDB_LITE
      if (compaction_listener_) {
@@ -296,12 +227,56 @@ void CompactionIterator::NextFromInput() {
                                           fromInternalValueType(ikey_.type),
                                           value_, ikey_.sequence, true);
      }
-#endif  // !ROCKSDB_LITE
+#endif  // ROCKSDB_LITE

-      // Apply the compaction filter to the first committed version of the user
-      // key.
-      if (current_key_committed_) {
-        InvokeFilterIfNeeded(&need_skip, &skip_until);
+      // apply the compaction filter to the first occurrence of the user key
+      if (compaction_filter_ != nullptr && 
+          (ikey_.type == kTypeValue || ikey_.type == kTypeBlobIndex) &&
+          (visible_at_tip_ || ikey_.sequence > latest_snapshot_ ||
+           ignore_snapshots_)) {
+        // 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,
+        // replace the entry with a deletion marker.
+        CompactionFilter::Decision filter;
+        compaction_filter_value_.clear();
+        compaction_filter_skip_until_.Clear();
+        CompactionFilter::ValueType value_type =
+            ikey_.type == kTypeValue ? CompactionFilter::ValueType::kValue
+                                     : CompactionFilter::ValueType::kBlobIndex;
+        {
+          StopWatchNano timer(env_, true);
+          filter = compaction_filter_->FilterV2(
+              compaction_->level(), ikey_.user_key, value_type, value_,
+              &compaction_filter_value_, compaction_filter_skip_until_.rep());
+          iter_stats_.total_filter_time +=
+              env_ != nullptr ? timer.ElapsedNanos() : 0;
+        }
+
+        if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil &&
+            cmp_->Compare(*compaction_filter_skip_until_.rep(),
+                          ikey_.user_key) <= 0) {
+          // Can't skip to a key smaller than the current one.
+          // Keep the key as per FilterV2 documentation.
+          filter = CompactionFilter::Decision::kKeep;
+        }
+
+        if (filter == CompactionFilter::Decision::kRemove) {
+          // convert the current key to a delete; key_ is pointing into
+          // current_key_ at this point, so updating current_key_ updates key()
+          ikey_.type = kTypeDeletion;
+          current_key_.UpdateInternalKey(ikey_.sequence, kTypeDeletion);
+          // no value associated with delete
+          value_.clear();
+          iter_stats_.num_record_drop_user++;
+        } else if (filter == CompactionFilter::Decision::kChangeValue) {
+          value_ = compaction_filter_value_;
+        } else if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil) {
+          need_skip = true;
+          compaction_filter_skip_until_.ConvertFromUserKey(kMaxSequenceNumber,
+                                                           kValueTypeForSeek);
+          skip_until = compaction_filter_skip_until_.Encode();
+        }
      }
    } else {
 #ifndef ROCKSDB_LITE
@@ -320,33 +295,13 @@ void CompactionIterator::NextFromInput() {
      current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
      key_ = current_key_.GetInternalKey();
      ikey_.user_key = current_key_.GetUserKey();
-
-      // Note that newer version of a key is ordered before older versions. If a
-      // newer version of a key is committed, so as the older version. No need
-      // to query snapshot_checker_ in that case.
-      if (UNLIKELY(!current_key_committed_)) {
-        assert(snapshot_checker_ != nullptr);
-        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_) {
-          InvokeFilterIfNeeded(&need_skip, &skip_until);
-        }
-      }
-    }
-
-    if (UNLIKELY(!current_key_committed_)) {
-      assert(snapshot_checker_ != nullptr);
-      valid_ = true;
-      break;
    }

    // If there are no snapshots, then this kv affect visibility at tip.
    // Otherwise, search though all existing snapshots to find the earliest
    // snapshot that is affected by this kv.
-    SequenceNumber last_sequence __attribute__((__unused__));
-    last_sequence = current_user_key_sequence_;
+    SequenceNumber last_sequence __attribute__((__unused__)) =
+        current_user_key_sequence_;
    current_user_key_sequence_ = ikey_.sequence;
    SequenceNumber last_snapshot = current_user_key_snapshot_;
    SequenceNumber prev_snapshot = 0;  // 0 means no previous snapshot
@@ -504,7 +459,6 @@ void CompactionIterator::NextFromInput() {
      input_->Next();
    } else if (compaction_ != nullptr && ikey_.type == kTypeDeletion &&
               ikey_.sequence <= earliest_snapshot_ &&
-               ikeyNotNeededForIncrementalSnapshot() &&
               compaction_->KeyNotExistsBeyondOutputLevel(ikey_.user_key,
                                                          &level_ptrs_)) {
      // TODO(noetzli): This is the only place where we use compaction_
@@ -550,8 +504,8 @@ void CompactionIterator::NextFromInput() {
        //       These will be correctly set below.
        key_ = merge_out_iter_.key();
        value_ = merge_out_iter_.value();
-        bool valid_key __attribute__((__unused__));
-        valid_key = ParseInternalKey(key_, &ikey_);
+        bool valid_key __attribute__((__unused__)) =
+            ParseInternalKey(key_, &ikey_);
        // MergeUntil stops when it encounters a corrupt key and does not
        // include them in the result, so we expect the keys here to valid.
        assert(valid_key);
@@ -604,12 +558,8 @@ void CompactionIterator::PrepareOutput() {

  // This is safe for TransactionDB write-conflict checking since transactions
  // only care about sequence number larger than any active snapshots.
-  if ((compaction_ != nullptr &&
-      !compaction_->allow_ingest_behind()) &&
-      ikeyNotNeededForIncrementalSnapshot() &&
+  if ((compaction_ != nullptr && !compaction_->allow_ingest_behind()) &&
      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);
@@ -621,11 +571,10 @@ void CompactionIterator::PrepareOutput() {
 inline SequenceNumber CompactionIterator::findEarliestVisibleSnapshot(
    SequenceNumber in, SequenceNumber* prev_snapshot) {
  assert(snapshots_->size());
-  SequenceNumber prev = kMaxSequenceNumber;
+  SequenceNumber prev __attribute__((__unused__)) = kMaxSequenceNumber;
  for (const auto cur : *snapshots_) {
    assert(prev == kMaxSequenceNumber || prev <= cur);
-    if (cur >= in && (snapshot_checker_ == nullptr ||
-                      snapshot_checker_->IsInSnapshot(in, cur))) {
+    if (cur >= in) {
      *prev_snapshot = prev == kMaxSequenceNumber ? 0 : prev;
      return cur;
    }
@@ -636,11 +585,4 @@ inline SequenceNumber CompactionIterator::findEarliestVisibleSnapshot(
  return kMaxSequenceNumber;
 }

-// used in 2 places - prevents deletion markers to be dropped if they may be
-// needed and disables seqnum zero-out in PrepareOutput for recent keys.
-inline bool CompactionIterator::ikeyNotNeededForIncrementalSnapshot() {
-  return (!compaction_->preserve_deletes()) ||
-         (ikey_.sequence < preserve_deletes_seqnum_);
-}
-
 }  // namespace rocksdb
@@ -14,7 +14,6 @@
 #include "db/merge_helper.h"
 #include "db/pinned_iterators_manager.h"
 #include "db/range_del_aggregator.h"
-#include "db/snapshot_checker.h"
 #include "options/cf_options.h"
 #include "rocksdb/compaction_filter.h"

@@ -49,9 +48,6 @@ class CompactionIterator {
    virtual bool allow_ingest_behind() const {
      return compaction_->immutable_cf_options()->allow_ingest_behind;
    }
-    virtual bool preserve_deletes() const {
-      return compaction_->immutable_cf_options()->preserve_deletes;
-    }

   protected:
    CompactionProxy() = default;
@@ -63,29 +59,25 @@ class CompactionIterator {
  CompactionIterator(InternalIterator* input, const Comparator* cmp,
                     MergeHelper* merge_helper, SequenceNumber last_sequence,
                     std::vector<SequenceNumber>* snapshots,
-                     SequenceNumber earliest_write_conflict_snapshot,
-                     const SnapshotChecker* snapshot_checker, Env* env,
+                     SequenceNumber earliest_write_conflict_snapshot, Env* env,
                     bool expect_valid_internal_key,
                     RangeDelAggregator* range_del_agg,
                     const Compaction* compaction = nullptr,
                     const CompactionFilter* compaction_filter = nullptr,
                     CompactionEventListener* compaction_listener = nullptr,
-                     const std::atomic<bool>* shutting_down = nullptr,
-                     const SequenceNumber preserve_deletes_seqnum = 0);
+                     const std::atomic<bool>* shutting_down = nullptr);

  // Constructor with custom CompactionProxy, used for tests.
  CompactionIterator(InternalIterator* input, const Comparator* cmp,
                     MergeHelper* merge_helper, SequenceNumber last_sequence,
                     std::vector<SequenceNumber>* snapshots,
-                     SequenceNumber earliest_write_conflict_snapshot,
-                     const SnapshotChecker* snapshot_checker, Env* env,
+                     SequenceNumber earliest_write_conflict_snapshot, Env* env,
                     bool expect_valid_internal_key,
                     RangeDelAggregator* range_del_agg,
                     std::unique_ptr<CompactionProxy> compaction,
                     const CompactionFilter* compaction_filter = nullptr,
                     CompactionEventListener* compaction_listener = nullptr,
-                     const std::atomic<bool>* shutting_down = nullptr,
-                     const SequenceNumber preserve_deletes_seqnum = 0);
+                     const std::atomic<bool>* shutting_down = nullptr);

  ~CompactionIterator();

@@ -119,9 +111,6 @@ class CompactionIterator {
  // compression.
  void PrepareOutput();

-  // Invoke compaction filter if needed.
-  void InvokeFilterIfNeeded(bool* need_skip, Slice* skip_until);
-
  // Given a sequence number, return the sequence number of the
  // earliest snapshot that this sequence number is visible in.
  // The snapshots themselves are arranged in ascending order of
@@ -131,17 +120,11 @@ class CompactionIterator {
  inline SequenceNumber findEarliestVisibleSnapshot(
      SequenceNumber in, SequenceNumber* prev_snapshot);

-  // Checks whether the currently seen ikey_ is needed for
-  // incremental (differential) snapshot and hence can't be dropped
-  // or seqnum be zero-ed out even if all other conditions for it are met.
-  inline bool ikeyNotNeededForIncrementalSnapshot();
-
  InternalIterator* input_;
  const Comparator* cmp_;
  MergeHelper* merge_helper_;
  const std::vector<SequenceNumber>* snapshots_;
  const SequenceNumber earliest_write_conflict_snapshot_;
-  const SnapshotChecker* const snapshot_checker_;
  Env* env_;
  bool expect_valid_internal_key_;
  RangeDelAggregator* range_del_agg_;
@@ -149,9 +132,8 @@ class CompactionIterator {
  const CompactionFilter* compaction_filter_;
 #ifndef ROCKSDB_LITE
  CompactionEventListener* compaction_listener_;
-#endif  // !ROCKSDB_LITE
+#endif  // ROCKSDB_LITE
  const std::atomic<bool>* shutting_down_;
-  const SequenceNumber preserve_deletes_seqnum_;
  bool bottommost_level_;
  bool valid_ = false;
  bool visible_at_tip_;
@@ -207,10 +189,6 @@ class CompactionIterator {
  std::vector<size_t> level_ptrs_;
  CompactionIterationStats iter_stats_;

-  // Used to avoid purging uncommitted values. The application can specify
-  // uncommitted values by providing a SnapshotChecker object.
-  bool current_key_committed_;
-
  bool IsShuttingDown() {
    // This is a best-effort facility, so memory_order_relaxed is sufficient.
    return shutting_down_ && shutting_down_->load(std::memory_order_relaxed);
@@ -156,8 +156,6 @@ class FakeCompaction : public CompactionIterator::CompactionProxy {
  }
  virtual bool allow_ingest_behind() const { return false; }

-  virtual bool preserve_deletes() const {return false; }
-
  bool key_not_exists_beyond_output_level = false;
 };

@@ -183,8 +181,6 @@ class CompactionIteratorTest : public testing::Test {
      compaction_proxy_ = new FakeCompaction();
      compaction.reset(compaction_proxy_);
    }
-    // TODO(yiwu) add a mock snapshot checker and add test for it.
-    SnapshotChecker* snapshot_checker = nullptr;

    merge_helper_.reset(new MergeHelper(Env::Default(), cmp_, merge_op, filter,
                                        nullptr, false, 0, 0, nullptr,
@@ -193,9 +189,8 @@ class CompactionIteratorTest : public testing::Test {
    iter_->SeekToFirst();
    c_iter_.reset(new CompactionIterator(
        iter_.get(), cmp_, merge_helper_.get(), last_sequence, &snapshots_,
-        kMaxSequenceNumber, snapshot_checker, Env::Default(), false,
-        range_del_agg_.get(), std::move(compaction), filter, nullptr,
-        &shutting_down_));
+        kMaxSequenceNumber, Env::Default(), false, range_del_agg_.get(),
+        std::move(compaction), filter, nullptr, &shutting_down_));
  }

  void AddSnapshot(SequenceNumber snapshot) { snapshots_.push_back(snapshot); }
@@ -38,6 +38,7 @@
 #include "monitoring/iostats_context_imp.h"
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/thread_status_util.h"
+#include "port/likely.h"
 #include "port/port.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
@@ -263,17 +264,15 @@ void CompactionJob::AggregateStatistics() {

 CompactionJob::CompactionJob(
    int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
-    const EnvOptions env_options, VersionSet* versions,
-    const std::atomic<bool>* shutting_down,
-    const SequenceNumber preserve_deletes_seqnum,
-    LogBuffer* log_buffer,
+    const EnvOptions& env_options, VersionSet* versions,
+    const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
    Directory* db_directory, Directory* output_directory, Statistics* stats,
    InstrumentedMutex* db_mutex, Status* db_bg_error,
    std::vector<SequenceNumber> existing_snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
-    const SnapshotChecker* snapshot_checker, std::shared_ptr<Cache> table_cache,
-    EventLogger* event_logger, bool paranoid_file_checks, bool measure_io_stats,
-    const std::string& dbname, CompactionJobStats* compaction_job_stats)
+    std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
+    bool paranoid_file_checks, bool measure_io_stats, const std::string& dbname,
+    CompactionJobStats* compaction_job_stats)
    : job_id_(job_id),
      compact_(new CompactionState(compaction)),
      compaction_job_stats_(compaction_job_stats),
@@ -284,7 +283,6 @@ CompactionJob::CompactionJob(
      env_(db_options.env),
      versions_(versions),
      shutting_down_(shutting_down),
-      preserve_deletes_seqnum_(preserve_deletes_seqnum),
      log_buffer_(log_buffer),
      db_directory_(db_directory),
      output_directory_(output_directory),
@@ -293,7 +291,6 @@ CompactionJob::CompactionJob(
      db_bg_error_(db_bg_error),
      existing_snapshots_(std::move(existing_snapshots)),
      earliest_write_conflict_snapshot_(earliest_write_conflict_snapshot),
-      snapshot_checker_(snapshot_checker),
      table_cache_(std::move(table_cache)),
      event_logger_(event_logger),
      paranoid_file_checks_(paranoid_file_checks),
@@ -764,10 +761,9 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  Status status;
  sub_compact->c_iter.reset(new CompactionIterator(
      input.get(), cfd->user_comparator(), &merge, versions_->LastSequence(),
-      &existing_snapshots_, earliest_write_conflict_snapshot_,
-      snapshot_checker_, env_, false, range_del_agg.get(),
-      sub_compact->compaction, compaction_filter, comp_event_listener,
-      shutting_down_, preserve_deletes_seqnum_));
+      &existing_snapshots_, earliest_write_conflict_snapshot_, env_, false,
+      range_del_agg.get(), sub_compact->compaction, compaction_filter,
+      comp_event_listener, shutting_down_));
  auto c_iter = sub_compact->c_iter.get();
  c_iter->SeekToFirst();
  if (c_iter->Valid() &&
@@ -1044,7 +1040,6 @@ Status CompactionJob::FinishCompactionOutputFile(
  auto meta = &sub_compact->current_output()->meta;
  if (s.ok()) {
    Slice lower_bound_guard, upper_bound_guard;
-    std::string smallest_user_key;
    const Slice *lower_bound, *upper_bound;
    if (sub_compact->outputs.size() == 1) {
      // For the first output table, include range tombstones before the min key
@@ -1054,8 +1049,7 @@ Status CompactionJob::FinishCompactionOutputFile(
      // For subsequent output tables, only include range tombstones from min
      // key onwards since the previous file was extended to contain range
      // tombstones falling before min key.
-      smallest_user_key = meta->smallest.user_key().ToString(false /*hex*/);
-      lower_bound_guard = Slice(smallest_user_key);
+      lower_bound_guard = meta->smallest.user_key();
      lower_bound = &lower_bound_guard;
    } else {
      lower_bound = nullptr;
@@ -1073,18 +1067,16 @@ Status CompactionJob::FinishCompactionOutputFile(
    range_del_agg->AddToBuilder(sub_compact->builder.get(), lower_bound,
                                upper_bound, meta, range_del_out_stats,
                                bottommost_level_);
-    meta->marked_for_compaction = sub_compact->builder->NeedCompact();
  }
  const uint64_t current_entries = sub_compact->builder->NumEntries();
+  meta->marked_for_compaction = sub_compact->builder->NeedCompact();
  if (s.ok()) {
    s = sub_compact->builder->Finish();
  } else {
    sub_compact->builder->Abandon();
  }
  const uint64_t current_bytes = sub_compact->builder->FileSize();
-  if (s.ok()) {
-    meta->fd.file_size = current_bytes;
-  }
+  meta->fd.file_size = current_bytes;
  sub_compact->current_output()->finished = true;
  sub_compact->total_bytes += current_bytes;

@@ -1129,8 +1121,7 @@ Status CompactionJob::FinishCompactionOutputFile(
        nullptr /* range_del_agg */, nullptr,
        cfd->internal_stats()->GetFileReadHist(
            compact_->compaction->output_level()),
-        false, nullptr /* arena */, false /* skip_filters */,
-        compact_->compaction->output_level());
+        false);
    s = iter->status();

    if (s.ok() && paranoid_file_checks_) {
@@ -1153,24 +1144,17 @@ Status CompactionJob::FinishCompactionOutputFile(
                     meta->marked_for_compaction ? " (need compaction)" : "");
    }
  }
-  std::string fname;
-  FileDescriptor output_fd;
-  if (meta != nullptr) {
-    fname = TableFileName(db_options_.db_paths, meta->fd.GetNumber(),
-                          meta->fd.GetPathId());
-    output_fd = meta->fd;
-  } else {
-    fname = "(nil)";
-  }
+  std::string fname = TableFileName(db_options_.db_paths, meta->fd.GetNumber(),
+                                    meta->fd.GetPathId());
  EventHelpers::LogAndNotifyTableFileCreationFinished(
      event_logger_, cfd->ioptions()->listeners, dbname_, cfd->GetName(), fname,
-      job_id_, output_fd, tp, TableFileCreationReason::kCompaction, s);
+      job_id_, meta->fd, tp, TableFileCreationReason::kCompaction, s);

 #ifndef ROCKSDB_LITE
  // Report new file to SstFileManagerImpl
  auto sfm =
      static_cast<SstFileManagerImpl*>(db_options_.sst_file_manager.get());
-  if (sfm && meta != nullptr && meta->fd.GetPathId() == 0) {
+  if (sfm && meta->fd.GetPathId() == 0) {
    auto fn = TableFileName(cfd->ioptions()->db_paths, meta->fd.GetNumber(),
                            meta->fd.GetPathId());
    sfm->OnAddFile(fn);
@@ -1268,12 +1252,11 @@ Status CompactionJob::OpenCompactionOutputFile(
 #endif  // !ROCKSDB_LITE
  // Make the output file
  unique_ptr<WritableFile> writable_file;
-#ifndef NDEBUG
-  bool syncpoint_arg = env_options_.use_direct_writes;
+  EnvOptions opt_env_opts =
+      env_->OptimizeForCompactionTableWrite(env_options_, db_options_);
  TEST_SYNC_POINT_CALLBACK("CompactionJob::OpenCompactionOutputFile",
-                           &syncpoint_arg);
-#endif
-  Status s = NewWritableFile(env_, fname, &writable_file, env_options_);
+                           &opt_env_opts.use_direct_writes);
+  Status s = NewWritableFile(env_, fname, &writable_file, opt_env_opts);
  if (!s.ok()) {
    ROCKS_LOG_ERROR(
        db_options_.info_log,
@@ -45,28 +45,24 @@

 namespace rocksdb {

-class Arena;
 class MemTable;
-class SnapshotChecker;
 class TableCache;
 class Version;
 class VersionEdit;
 class VersionSet;
+class Arena;

 class CompactionJob {
 public:
  CompactionJob(int job_id, Compaction* compaction,
                const ImmutableDBOptions& db_options,
-                const EnvOptions env_options, VersionSet* versions,
-                const std::atomic<bool>* shutting_down,
-                const SequenceNumber preserve_deletes_seqnum,
-                LogBuffer* log_buffer,
+                const EnvOptions& env_options, VersionSet* versions,
+                const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
                Directory* db_directory, Directory* output_directory,
                Statistics* stats, InstrumentedMutex* db_mutex,
                Status* db_bg_error,
                std::vector<SequenceNumber> existing_snapshots,
                SequenceNumber earliest_write_conflict_snapshot,
-                const SnapshotChecker* snapshot_checker,
                std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
                bool paranoid_file_checks, bool measure_io_stats,
                const std::string& dbname,
@@ -131,12 +127,11 @@ class CompactionJob {
  // DBImpl state
  const std::string& dbname_;
  const ImmutableDBOptions& db_options_;
-  const EnvOptions env_options_;
+  const EnvOptions& env_options_;

  Env* env_;
  VersionSet* versions_;
  const std::atomic<bool>* shutting_down_;
-  const SequenceNumber preserve_deletes_seqnum_;
  LogBuffer* log_buffer_;
  Directory* db_directory_;
  Directory* output_directory_;
@@ -154,8 +149,6 @@ class CompactionJob {
  // should make sure not to remove evidence that a write occurred.
  SequenceNumber earliest_write_conflict_snapshot_;

-  const SnapshotChecker* const snapshot_checker_;
-
  std::shared_ptr<Cache> table_cache_;

  EventLogger* event_logger_;
@@ -76,7 +76,6 @@ class CompactionJobTest : public testing::Test {
                                 table_cache_.get(), &write_buffer_manager_,
                                 &write_controller_)),
        shutting_down_(false),
-        preserve_deletes_seqnum_(0),
        mock_table_factory_(new mock::MockTableFactory()) {
    EXPECT_OK(env_->CreateDirIfMissing(dbname_));
    db_options_.db_paths.emplace_back(dbname_,
@@ -251,15 +250,12 @@ class CompactionJobTest : public testing::Test {
    LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, db_options_.info_log.get());
    mutex_.Lock();
    EventLogger event_logger(db_options_.info_log.get());
-    // TODO(yiwu) add a mock snapshot checker and add test for it.
-    SnapshotChecker* snapshot_checker = nullptr;
-    CompactionJob compaction_job(0, &compaction, db_options_, env_options_,
-                                 versions_.get(), &shutting_down_,
-                                 preserve_deletes_seqnum_, &log_buffer,
-                                 nullptr, nullptr, nullptr, &mutex_, &bg_error_,
-                                 snapshots, earliest_write_conflict_snapshot,
-                                 snapshot_checker, table_cache_, &event_logger,
-                                 false, false, dbname_, &compaction_job_stats_);
+    CompactionJob compaction_job(
+        0, &compaction, db_options_, env_options_, versions_.get(),
+        &shutting_down_, &log_buffer, nullptr, nullptr, nullptr, &mutex_,
+        &bg_error_, snapshots, earliest_write_conflict_snapshot, table_cache_,
+        &event_logger, false, false, dbname_, &compaction_job_stats_);
+
    VerifyInitializationOfCompactionJobStats(compaction_job_stats_);

    compaction_job.Prepare();
@@ -295,7 +291,6 @@ class CompactionJobTest : public testing::Test {
  std::unique_ptr<VersionSet> versions_;
  InstrumentedMutex mutex_;
  std::atomic<bool> shutting_down_;
-  SequenceNumber preserve_deletes_seqnum_;
  std::shared_ptr<mock::MockTableFactory> mock_table_factory_;
  CompactionJobStats compaction_job_stats_;
  ColumnFamilyData* cfd_;
@@ -292,16 +292,25 @@ Compaction* CompactionPicker::CompactFiles(
    VersionStorageInfo* vstorage, const MutableCFOptions& mutable_cf_options,
    uint32_t output_path_id) {
  assert(input_files.size());
-  // This compaction output should not overlap with a running compaction as
-  // `SanitizeCompactionInputFiles` should've checked earlier and db mutex
-  // shouldn't have been released since.
-  assert(!FilesRangeOverlapWithCompaction(input_files, output_level));

+  // TODO(rven ): we might be able to run concurrent level 0 compaction
+  // if the key ranges of the two compactions do not overlap, but for now
+  // we do not allow it.
+  if ((input_files[0].level == 0) && !level0_compactions_in_progress_.empty()) {
+    return nullptr;
+  }
+  // This compaction output could overlap with a running compaction
+  if (FilesRangeOverlapWithCompaction(input_files, output_level)) {
+    return nullptr;
+  }
  auto c =
      new Compaction(vstorage, ioptions_, mutable_cf_options, input_files,
                     output_level, compact_options.output_file_size_limit,
                     mutable_cf_options.max_compaction_bytes, output_path_id,
                     compact_options.compression, /* grandparents */ {}, true);
+
+  // If it's level 0 compaction, make sure we don't execute any other level 0
+  // compactions in parallel
  RegisterCompaction(c);
  return c;
 }
@@ -387,10 +396,7 @@ bool CompactionPicker::SetupOtherInputs(
  assert(output_level_inputs->empty());
  const int input_level = inputs->level;
  const int output_level = output_level_inputs->level;
-  if (input_level == output_level) {
-    // no possibility of conflict
-    return true;
-  }
+  assert(input_level != output_level);

  // For now, we only support merging two levels, start level and output level.
  // We need to assert other levels are empty.
@@ -724,6 +730,10 @@ Status CompactionPicker::SanitizeCompactionInputFilesForAllLevels(
  auto& levels = cf_meta.levels;
  auto comparator = icmp_->user_comparator();

+  // TODO(yhchiang): If there is any input files of L1 or up and there
+  // is at least one L0 files. All L0 files older than the L0 file needs
+  // to be included. Otherwise, it is a false conditoin
+
  // TODO(yhchiang): add is_adjustable to CompactionOptions

  // the smallest and largest key of the current compaction input
@@ -784,8 +794,6 @@ Status CompactionPicker::SanitizeCompactionInputFilesForAllLevels(
        }
        last_included++;
      }
-    } else if (output_level > 0) {
-      last_included = static_cast<int>(current_files.size() - 1);
    }

    // include all files between the first and the last compaction input files.
@@ -941,9 +949,6 @@ void CompactionPicker::UnregisterCompaction(Compaction* c) {

 bool LevelCompactionPicker::NeedsCompaction(
    const VersionStorageInfo* vstorage) const {
-  if (!vstorage->BottommostFilesMarkedForCompaction().empty()) {
-    return true;
-  }
  if (!vstorage->FilesMarkedForCompaction().empty()) {
    return true;
  }
@@ -1134,28 +1139,7 @@ void LevelCompactionBuilder::SetupInitialFiles() {
    is_manual_ = true;
    parent_index_ = base_index_ = -1;
    PickFilesMarkedForCompaction();
-    if (start_level_inputs_.empty()) {
-      size_t i;
-      for (i = 0; i < vstorage_->BottommostFilesMarkedForCompaction().size();
-           ++i) {
-        auto& level_and_file =
-            vstorage_->BottommostFilesMarkedForCompaction()[i];
-        assert(!level_and_file.second->being_compacted);
-        start_level_inputs_.level = output_level_ = start_level_ =
-            level_and_file.first;
-        start_level_inputs_.files = {level_and_file.second};
-        if (compaction_picker_->ExpandInputsToCleanCut(cf_name_, vstorage_,
-                                                       &start_level_inputs_)) {
-          break;
-        }
-      }
-      if (i == vstorage_->BottommostFilesMarkedForCompaction().size()) {
-        start_level_inputs_.clear();
-      } else {
-        assert(!start_level_inputs_.empty());
-        compaction_reason_ = CompactionReason::kBottommostFiles;
-      }
-    } else {
+    if (!start_level_inputs_.empty()) {
      compaction_reason_ = CompactionReason::kFilesMarkedForCompaction;
    }
  }
@@ -1295,8 +1279,6 @@ uint32_t LevelCompactionBuilder::GetPathId(
  uint64_t level_size;
  int cur_level = 0;

-  // max_bytes_for_level_base denotes L1 size.
-  // We estimate L0 size to be the same as L1.
  level_size = mutable_cf_options.max_bytes_for_level_base;

  // Last path is the fallback
@@ -1307,21 +1289,8 @@ uint32_t LevelCompactionBuilder::GetPathId(
        return p;
      } else {
        current_path_size -= level_size;
-        if (cur_level > 0) {
-          if (ioptions.level_compaction_dynamic_level_bytes) {
-            // Currently, level_compaction_dynamic_level_bytes is ignored when
-            // multiple db paths are specified. https://github.com/facebook/
-            // rocksdb/blob/master/db/column_family.cc.
-            // Still, adding this check to avoid accidentally using
-            // max_bytes_for_level_multiplier_additional
-            level_size = static_cast<uint64_t>(
-                level_size * mutable_cf_options.max_bytes_for_level_multiplier);
-          } else {
-            level_size = static_cast<uint64_t>(
-                level_size * mutable_cf_options.max_bytes_for_level_multiplier *
-                mutable_cf_options.MaxBytesMultiplerAdditional(cur_level));
-          }
-        }
+        level_size = static_cast<uint64_t>(
+            level_size * mutable_cf_options.max_bytes_for_level_multiplier);
        cur_level++;
        continue;
      }
@@ -1452,7 +1421,7 @@ uint64_t GetTotalFilesSize(
 Compaction* FIFOCompactionPicker::PickTTLCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
    VersionStorageInfo* vstorage, LogBuffer* log_buffer) {
-  assert(mutable_cf_options.compaction_options_fifo.ttl > 0);
+  assert(ioptions_.compaction_options_fifo.ttl > 0);

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

  // avoid underflow
-  if (current_time > mutable_cf_options.compaction_options_fifo.ttl) {
+  if (current_time > ioptions_.compaction_options_fifo.ttl) {
    for (auto ritr = level_files.rbegin(); ritr != level_files.rend(); ++ritr) {
      auto f = *ritr;
      if (f->fd.table_reader != nullptr &&
@@ -1482,8 +1451,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.compaction_options_fifo.ttl)) {
+            creation_time >=
+                (current_time - ioptions_.compaction_options_fifo.ttl)) {
          break;
        }
        total_size -= f->compensated_file_size;
@@ -1497,8 +1466,7 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
  // 2. there are a few files older than ttl, but deleting them will not bring
  //    the total size to be less than max_table_files_size threshold.
  if (inputs[0].files.empty() ||
-      total_size >
-          mutable_cf_options.compaction_options_fifo.max_table_files_size) {
+      total_size > ioptions_.compaction_options_fifo.max_table_files_size) {
    return nullptr;
  }

@@ -1524,11 +1492,10 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
  const std::vector<FileMetaData*>& level_files = vstorage->LevelFiles(kLevel0);
  uint64_t total_size = GetTotalFilesSize(level_files);

-  if (total_size <=
-          mutable_cf_options.compaction_options_fifo.max_table_files_size ||
+  if (total_size <= ioptions_.compaction_options_fifo.max_table_files_size ||
      level_files.size() == 0) {
    // total size not exceeded
-    if (mutable_cf_options.compaction_options_fifo.allow_compaction &&
+    if (ioptions_.compaction_options_fifo.allow_compaction &&
        level_files.size() > 0) {
      CompactionInputFiles comp_inputs;
      if (FindIntraL0Compaction(
@@ -1548,12 +1515,11 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
      }
    }

-    ROCKS_LOG_BUFFER(
-        log_buffer,
-        "[%s] FIFO compaction: nothing to do. Total size %" PRIu64
-        ", max size %" PRIu64 "\n",
-        cf_name.c_str(), total_size,
-        mutable_cf_options.compaction_options_fifo.max_table_files_size);
+    ROCKS_LOG_BUFFER(log_buffer,
+                     "[%s] FIFO compaction: nothing to do. Total size %" PRIu64
+                     ", max size %" PRIu64 "\n",
+                     cf_name.c_str(), total_size,
+                     ioptions_.compaction_options_fifo.max_table_files_size);
    return nullptr;
  }

@@ -1580,8 +1546,7 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
                     "[%s] FIFO compaction: picking file %" PRIu64
                     " with size %s for deletion",
                     cf_name.c_str(), f->fd.GetNumber(), tmp_fsize);
-    if (total_size <=
-        mutable_cf_options.compaction_options_fifo.max_table_files_size) {
+    if (total_size <= ioptions_.compaction_options_fifo.max_table_files_size) {
      break;
    }
  }
@@ -1599,7 +1564,7 @@ Compaction* FIFOCompactionPicker::PickCompaction(
  assert(vstorage->num_levels() == 1);

  Compaction* c = nullptr;
-  if (mutable_cf_options.compaction_options_fifo.ttl > 0) {
+  if (ioptions_.compaction_options_fifo.ttl > 0) {
    c = PickTTLCompaction(cf_name, mutable_cf_options, vstorage, log_buffer);
  }
  if (c == nullptr) {
@@ -88,10 +88,6 @@ class CompactionPicker {

  // Takes a list of CompactionInputFiles and returns a (manual) Compaction
  // object.
-  //
-  // Caller must provide a set of input files that has been passed through
-  // `SanitizeCompactionInputFiles` earlier. The lock should not be released
-  // between that call and this one.
  Compaction* CompactFiles(const CompactionOptions& compact_options,
                           const std::vector<CompactionInputFiles>& input_files,
                           int output_level, VersionStorageInfo* vstorage,
@@ -496,7 +496,7 @@ TEST_F(CompactionPickerTest, NeedsCompactionFIFO) {
  const uint64_t kMaxSize = kFileSize * kFileCount / 2;

  fifo_options_.max_table_files_size = kMaxSize;
-  mutable_cf_options_.compaction_options_fifo = fifo_options_;
+  ioptions_.compaction_options_fifo = fifo_options_;
  FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);
  UpdateVersionStorageInfo();
  // must return false when there's no files.
@@ -241,7 +241,7 @@ TEST_F(CuckooTableDBTest, CompactionIntoMultipleFiles) {

  // Write 28 values, each 10016 B ~ 10KB
  for (int idx = 0; idx < 28; ++idx) {
-    ASSERT_OK(Put(Key(idx), std::string(10000, 'a' + char(idx))));
+    ASSERT_OK(Put(Key(idx), std::string(10000, 'a' + idx)));
  }
  dbfull()->TEST_WaitForFlushMemTable();
  ASSERT_EQ("1", FilesPerLevel());
@@ -250,7 +250,7 @@ TEST_F(CuckooTableDBTest, CompactionIntoMultipleFiles) {
                              true /* disallow trivial move */);
  ASSERT_EQ("0,2", FilesPerLevel());
  for (int idx = 0; idx < 28; ++idx) {
-    ASSERT_EQ(std::string(10000, 'a' + char(idx)), Get(Key(idx)));
+    ASSERT_EQ(std::string(10000, 'a' + idx), Get(Key(idx)));
  }
 }

@@ -271,14 +271,14 @@ TEST_F(CuckooTableDBTest, SameKeyInsertedInTwoDifferentFilesAndCompacted) {

  // Generate one more file in level-0, and should trigger level-0 compaction
  for (int idx = 0; idx < 11; ++idx) {
-    ASSERT_OK(Put(Key(idx), std::string(10000, 'a' + char(idx))));
+    ASSERT_OK(Put(Key(idx), std::string(10000, 'a' + idx)));
  }
  dbfull()->TEST_WaitForFlushMemTable();
  dbfull()->TEST_CompactRange(0, nullptr, nullptr);

  ASSERT_EQ("0,1", FilesPerLevel());
  for (int idx = 0; idx < 11; ++idx) {
-    ASSERT_EQ(std::string(10000, 'a' + char(idx)), Get(Key(idx)));
+    ASSERT_EQ(std::string(10000, 'a' + idx), Get(Key(idx)));
  }
 }

@@ -41,7 +41,7 @@ TEST_F(DBBasicTest, ReadOnlyDB) {
  Close();

  auto options = CurrentOptions();
-  assert(options.env == env_);
+  assert(options.env = env_);
  ASSERT_OK(ReadOnlyReopen(options));
  ASSERT_EQ("v3", Get("foo"));
  ASSERT_EQ("v2", Get("bar"));
@@ -64,8 +64,7 @@ class DBBlobIndexTest : public DBTestBase {
    read_options.snapshot = snapshot;
    PinnableSlice value;
    auto s = dbfull()->GetImpl(read_options, cfh(), key, &value,
-                               nullptr /*value_found*/, nullptr /*callback*/,
-                               is_blob_index);
+                               nullptr /*value_found*/, is_blob_index);
    if (s.IsNotFound()) {
      return "NOT_FOUND";
    }
@@ -89,9 +88,9 @@ class DBBlobIndexTest : public DBTestBase {
  }

  ArenaWrappedDBIter* GetBlobIterator() {
-    return dbfull()->NewIteratorImpl(
-        ReadOptions(), cfd(), dbfull()->GetLatestSequenceNumber(),
-        nullptr /*read_callback*/, true /*allow_blob*/);
+    return dbfull()->NewIteratorImpl(ReadOptions(), cfd(),
+                                     dbfull()->GetLatestSequenceNumber(),
+                                     true /*allow_blob*/);
  }

  Options GetTestOptions() {
@@ -24,36 +24,6 @@ class DBTestCompactionFilter : public DBTestBase {
  DBTestCompactionFilter() : DBTestBase("/db_compaction_filter_test") {}
 };

-// Param variant of DBTestBase::ChangeCompactOptions
-class DBTestCompactionFilterWithCompactParam
-    : public DBTestCompactionFilter,
-      public ::testing::WithParamInterface<DBTestBase::OptionConfig> {
- public:
-  DBTestCompactionFilterWithCompactParam() : DBTestCompactionFilter() {
-    option_config_ = GetParam();
-    Destroy(last_options_);
-    auto options = CurrentOptions();
-    if (option_config_ == kDefault || option_config_ == kUniversalCompaction ||
-        option_config_ == kUniversalCompactionMultiLevel) {
-      options.create_if_missing = true;
-    }
-    if (option_config_ == kLevelSubcompactions ||
-        option_config_ == kUniversalSubcompactions) {
-      assert(options.max_subcompactions > 1);
-    }
-    TryReopen(options);
-  }
-};
-
-INSTANTIATE_TEST_CASE_P(
-    DBTestCompactionFilterWithCompactOption,
-    DBTestCompactionFilterWithCompactParam,
-    ::testing::Values(DBTestBase::OptionConfig::kDefault,
-                      DBTestBase::OptionConfig::kUniversalCompaction,
-                      DBTestBase::OptionConfig::kUniversalCompactionMultiLevel,
-                      DBTestBase::OptionConfig::kLevelSubcompactions,
-                      DBTestBase::OptionConfig::kUniversalSubcompactions));
-
 class KeepFilter : public CompactionFilter {
 public:
  virtual bool Filter(int level, const Slice& key, const Slice& value,
@@ -338,6 +308,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
    ASSERT_OK(iter->status());
    while (iter->Valid()) {
      ParsedInternalKey ikey(Slice(), 0, kTypeValue);
+      ikey.sequence = -1;
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
      total++;
      if (ikey.sequence != 0) {
@@ -469,63 +440,65 @@ TEST_F(DBTestCompactionFilter, CompactionFilterDeletesAll) {
 }
 #endif  // ROCKSDB_LITE

-TEST_P(DBTestCompactionFilterWithCompactParam,
-       CompactionFilterWithValueChange) {
-  Options options = CurrentOptions();
-  options.num_levels = 3;
-  options.compaction_filter_factory = std::make_shared<ChangeFilterFactory>();
-  CreateAndReopenWithCF({"pikachu"}, options);
+TEST_F(DBTestCompactionFilter, CompactionFilterWithValueChange) {
+  do {
+    Options options = CurrentOptions();
+    options.num_levels = 3;
+    options.compaction_filter_factory =
+      std::make_shared<ChangeFilterFactory>();
+    CreateAndReopenWithCF({"pikachu"}, options);

-  // Write 100K+1 keys, these are written to a few files
-  // in L0. We do this so that the current snapshot points
-  // to the 100001 key.The compaction filter is  not invoked
-  // on keys that are visible via a snapshot because we
-  // anyways cannot delete it.
-  const std::string value(10, 'x');
-  for (int i = 0; i < 100001; i++) {
-    char key[100];
-    snprintf(key, sizeof(key), "B%010d", i);
-    Put(1, key, value);
-  }
+    // Write 100K+1 keys, these are written to a few files
+    // in L0. We do this so that the current snapshot points
+    // to the 100001 key.The compaction filter is  not invoked
+    // on keys that are visible via a snapshot because we
+    // anyways cannot delete it.
+    const std::string value(10, 'x');
+    for (int i = 0; i < 100001; i++) {
+      char key[100];
+      snprintf(key, sizeof(key), "B%010d", i);
+      Put(1, key, value);
+    }

-  // push all files to  lower levels
-  ASSERT_OK(Flush(1));
-  if (option_config_ != kUniversalCompactionMultiLevel &&
-      option_config_ != kUniversalSubcompactions) {
-    dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
-    dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
-  } else {
-    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
-                           nullptr);
-  }
+    // push all files to  lower levels
+    ASSERT_OK(Flush(1));
+    if (option_config_ != kUniversalCompactionMultiLevel &&
+        option_config_ != kUniversalSubcompactions) {
+      dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
+      dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
+    } else {
+      dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                             nullptr);
+    }

-  // re-write all data again
-  for (int i = 0; i < 100001; i++) {
-    char key[100];
-    snprintf(key, sizeof(key), "B%010d", i);
-    Put(1, key, value);
-  }
+    // re-write all data again
+    for (int i = 0; i < 100001; i++) {
+      char key[100];
+      snprintf(key, sizeof(key), "B%010d", i);
+      Put(1, key, value);
+    }

-  // push all files to  lower levels. This should
-  // invoke the compaction filter for all 100000 keys.
-  ASSERT_OK(Flush(1));
-  if (option_config_ != kUniversalCompactionMultiLevel &&
-      option_config_ != kUniversalSubcompactions) {
-    dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
-    dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
-  } else {
-    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
-                           nullptr);
-  }
+    // push all files to  lower levels. This should
+    // invoke the compaction filter for all 100000 keys.
+    ASSERT_OK(Flush(1));
+    if (option_config_ != kUniversalCompactionMultiLevel &&
+        option_config_ != kUniversalSubcompactions) {
+      dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
+      dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
+    } else {
+      dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                             nullptr);
+    }

-  // verify that all keys now have the new value that
-  // was set by the compaction process.
-  for (int i = 0; i < 100001; i++) {
-    char key[100];
-    snprintf(key, sizeof(key), "B%010d", i);
-    std::string newvalue = Get(1, key);
-    ASSERT_EQ(newvalue.compare(NEW_VALUE), 0);
-  }
+    // verify that all keys now have the new value that
+    // was set by the compaction process.
+    for (int i = 0; i < 100001; i++) {
+      char key[100];
+      snprintf(key, sizeof(key), "B%010d", i);
+      std::string newvalue = Get(1, key);
+      ASSERT_EQ(newvalue.compare(NEW_VALUE), 0);
+    }
+  } while (ChangeCompactOptions());
 }

 TEST_F(DBTestCompactionFilter, CompactionFilterWithMergeOperator) {
@@ -644,6 +617,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextManual) {
    ASSERT_OK(iter->status());
    while (iter->Valid()) {
      ParsedInternalKey ikey(Slice(), 0, kTypeValue);
+      ikey.sequence = -1;
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
      total++;
      if (ikey.sequence != 0) {
@@ -218,84 +218,6 @@ TEST_P(DBCompactionTestWithParam, CompactionDeletionTrigger) {
  }
 }

-TEST_P(DBCompactionTestWithParam, CompactionsPreserveDeletes) {
-  //  For each options type we test following
-  //  - Enable preserve_deletes
-  //  - write bunch of keys and deletes
-  //  - Set start_seqnum to the beginning; compact; check that keys are present
-  //  - rewind start_seqnum way forward; compact; check that keys are gone
-
-  for (int tid = 0; tid < 3; ++tid) {
-    Options options = DeletionTriggerOptions(CurrentOptions());
-    options.max_subcompactions = max_subcompactions_;
-    options.preserve_deletes=true;
-    options.num_levels = 2;
-
-    if (tid == 1) {
-      options.skip_stats_update_on_db_open = true;
-    } else if (tid == 2) {
-      // third pass with universal compaction
-      options.compaction_style = kCompactionStyleUniversal;
-    }
-
-    DestroyAndReopen(options);
-    Random rnd(301);
-    // highlight the default; all deletes should be preserved
-    SetPreserveDeletesSequenceNumber(0);
-
-    const int kTestSize = kCDTKeysPerBuffer;
-    std::vector<std::string> values;
-    for (int k = 0; k < kTestSize; ++k) {
-      values.push_back(RandomString(&rnd, kCDTValueSize));
-      ASSERT_OK(Put(Key(k), values[k]));
-    }
-
-    for (int k = 0; k < kTestSize; ++k) {
-      ASSERT_OK(Delete(Key(k)));
-    }
-    // to ensure we tackle all tombstones
-    CompactRangeOptions cro;
-    cro.change_level = true;
-    cro.target_level = 2;
-    cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-
-    dbfull()->TEST_WaitForFlushMemTable();
-    dbfull()->CompactRange(cro, nullptr, nullptr);
-
-    // check that normal user iterator doesn't see anything
-    Iterator* db_iter = dbfull()->NewIterator(ReadOptions());
-    int i = 0;
-    for (db_iter->SeekToFirst(); db_iter->Valid(); db_iter->Next()) {
-      i++;
-    }
-    ASSERT_EQ(i, 0);
-    delete db_iter;
-
-    // check that iterator that sees internal keys sees tombstones
-    ReadOptions ro;
-    ro.iter_start_seqnum=1;
-    db_iter = dbfull()->NewIterator(ro);
-    i = 0;
-    for (db_iter->SeekToFirst(); db_iter->Valid(); db_iter->Next()) {
-      i++;
-    }
-    ASSERT_EQ(i, 4);
-    delete db_iter;
-
-    // now all deletes should be gone
-    SetPreserveDeletesSequenceNumber(100000000);
-    dbfull()->CompactRange(cro, nullptr, nullptr);
-
-    db_iter = dbfull()->NewIterator(ro);
-    i = 0;
-    for (db_iter->SeekToFirst(); db_iter->Valid(); db_iter->Next()) {
-      i++;
-    }
-    ASSERT_EQ(i, 0);
-    delete db_iter;
-  }
-}
-
 TEST_F(DBCompactionTest, SkipStatsUpdateTest) {
  // This test verify UpdateAccumulatedStats is not on
  // if options.skip_stats_update_on_db_open = true
@@ -1563,8 +1485,8 @@ TEST_F(DBCompactionTest, DeleteFileRangeFileEndpointsOverlapBug) {

  // Verify `DeleteFilesInRange` can't drop only file 0 which would cause
  // "1 -> vals[0]" to reappear.
-  std::string begin_str = Key(0), end_str = Key(1);
-  Slice begin = begin_str, end = end_str;
+  Slice begin = Key(0);
+  Slice end = Key(1);
  ASSERT_OK(DeleteFilesInRange(db_, db_->DefaultColumnFamily(), &begin, &end));
  ASSERT_EQ(vals[1], Get(Key(1)));

@@ -2856,139 +2778,6 @@ TEST_F(DBCompactionTest, OptimizedDeletionObsoleting) {
            options.statistics->getTickerCount(COMPACTION_KEY_DROP_OBSOLETE));
 }

-TEST_F(DBCompactionTest, CompactFilesPendingL0Bug) {
-  // https://www.facebook.com/groups/rocksdb.dev/permalink/1389452781153232/
-  // CompactFiles() had a bug where it failed to pick a compaction when an L0
-  // compaction existed, but marked it as scheduled anyways. It'd never be
-  // unmarked as scheduled, so future compactions or DB close could hang.
-  const int kNumL0Files = 5;
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = kNumL0Files - 1;
-  options.max_background_compactions = 2;
-  DestroyAndReopen(options);
-
-  rocksdb::SyncPoint::GetInstance()->LoadDependency(
-      {{"LevelCompactionPicker::PickCompaction:Return",
-        "DBCompactionTest::CompactFilesPendingL0Bug:Picked"},
-       {"DBCompactionTest::CompactFilesPendingL0Bug:ManualCompacted",
-        "DBImpl::BackgroundCompaction:NonTrivial:AfterRun"}});
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  auto schedule_multi_compaction_token =
-      dbfull()->TEST_write_controler().GetCompactionPressureToken();
-
-  // Files 0-3 will be included in an L0->L1 compaction.
-  //
-  // File 4 will be included in a call to CompactFiles() while the first
-  // compaction is running.
-  for (int i = 0; i < kNumL0Files - 1; ++i) {
-    ASSERT_OK(Put(Key(0), "val"));  // sentinel to prevent trivial move
-    ASSERT_OK(Put(Key(i + 1), "val"));
-    ASSERT_OK(Flush());
-  }
-  TEST_SYNC_POINT("DBCompactionTest::CompactFilesPendingL0Bug:Picked");
-  // file 4 flushed after 0-3 picked
-  ASSERT_OK(Put(Key(kNumL0Files), "val"));
-  ASSERT_OK(Flush());
-
-  // previously DB close would hang forever as this situation caused scheduled
-  // compactions count to never decrement to zero.
-  ColumnFamilyMetaData cf_meta;
-  dbfull()->GetColumnFamilyMetaData(dbfull()->DefaultColumnFamily(), &cf_meta);
-  ASSERT_EQ(kNumL0Files, cf_meta.levels[0].files.size());
-  std::vector<std::string> input_filenames;
-  input_filenames.push_back(cf_meta.levels[0].files.front().name);
-  ASSERT_OK(dbfull()
-                  ->CompactFiles(CompactionOptions(), input_filenames,
-                                 0 /* output_level */));
-  TEST_SYNC_POINT("DBCompactionTest::CompactFilesPendingL0Bug:ManualCompacted");
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_F(DBCompactionTest, CompactFilesOverlapInL0Bug) {
-  // Regression test for bug of not pulling in L0 files that overlap the user-
-  // specified input files in time- and key-ranges.
-  Put(Key(0), "old_val");
-  Flush();
-  Put(Key(0), "new_val");
-  Flush();
-
-  ColumnFamilyMetaData cf_meta;
-  dbfull()->GetColumnFamilyMetaData(dbfull()->DefaultColumnFamily(), &cf_meta);
-  ASSERT_GE(cf_meta.levels.size(), 2);
-  ASSERT_EQ(2, cf_meta.levels[0].files.size());
-
-  // Compacting {new L0 file, L1 file} should pull in the old L0 file since it
-  // overlaps in key-range and time-range.
-  std::vector<std::string> input_filenames;
-  input_filenames.push_back(cf_meta.levels[0].files.front().name);
-  ASSERT_OK(dbfull()->CompactFiles(CompactionOptions(), input_filenames,
-                                   1 /* output_level */));
-  ASSERT_EQ("new_val", Get(Key(0)));
-}
-
-TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
-  // bottom-level files may contain deletions due to snapshots protecting the
-  // deleted keys. Once the snapshot is released, we should see files with many
-  // such deletions undergo single-file compactions.
-  const int kNumKeysPerFile = 1024;
-  const int kNumLevelFiles = 4;
-  const int kValueSize = 128;
-  Options options = CurrentOptions();
-  options.compression = kNoCompression;
-  options.level0_file_num_compaction_trigger = kNumLevelFiles;
-  // inflate it a bit to account for key/metadata overhead
-  options.target_file_size_base = 120 * kNumKeysPerFile * kValueSize / 100;
-  Reopen(options);
-
-  Random rnd(301);
-  const Snapshot* snapshot = nullptr;
-  for (int i = 0; i < kNumLevelFiles; ++i) {
-    for (int j = 0; j < kNumKeysPerFile; ++j) {
-      ASSERT_OK(
-          Put(Key(i * kNumKeysPerFile + j), RandomString(&rnd, kValueSize)));
-    }
-    if (i == kNumLevelFiles - 1) {
-      snapshot = db_->GetSnapshot();
-      // delete every other key after grabbing a snapshot, so these deletions
-      // and the keys they cover can't be dropped until after the snapshot is
-      // released.
-      for (int j = 0; j < kNumLevelFiles * kNumKeysPerFile; j += 2) {
-        ASSERT_OK(Delete(Key(j)));
-      }
-    }
-    Flush();
-    if (i < kNumLevelFiles - 1) {
-      ASSERT_EQ(i + 1, NumTableFilesAtLevel(0));
-    }
-  }
-  dbfull()->TEST_WaitForCompact();
-  ASSERT_EQ(kNumLevelFiles, NumTableFilesAtLevel(1));
-
-  std::vector<LiveFileMetaData> pre_release_metadata, post_release_metadata;
-  db_->GetLiveFilesMetaData(&pre_release_metadata);
-  // just need to bump seqnum so ReleaseSnapshot knows the newest key in the SST
-  // files does not need to be preserved in case of a future snapshot.
-  ASSERT_OK(Put(Key(0), "val"));
-  // release snapshot and wait for compactions to finish. Single-file
-  // compactions should be triggered, which reduce the size of each bottom-level
-  // file without changing file count.
-  db_->ReleaseSnapshot(snapshot);
-  dbfull()->TEST_WaitForCompact();
-  db_->GetLiveFilesMetaData(&post_release_metadata);
-  ASSERT_EQ(pre_release_metadata.size(), post_release_metadata.size());
-
-  for (size_t i = 0; i < pre_release_metadata.size(); ++i) {
-    const auto& pre_file = pre_release_metadata[i];
-    const auto& post_file = post_release_metadata[i];
-    ASSERT_EQ(1, pre_file.level);
-    ASSERT_EQ(1, post_file.level);
-    // each file is smaller than it was before as it was rewritten without
-    // deletion markers/deleted keys.
-    ASSERT_LT(post_file.size, pre_file.size);
-  }
-}
-
 INSTANTIATE_TEST_CASE_P(DBCompactionTestWithParam, DBCompactionTestWithParam,
                        ::testing::Values(std::make_tuple(1, true),
                                          std::make_tuple(1, false),
@@ -11,12 +11,14 @@
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
 #endif
+#include <inttypes.h>
 #include <stdint.h>
 #ifdef OS_SOLARIS
 #include <alloca.h>
 #endif

 #include <algorithm>
+#include <climits>
 #include <cstdio>
 #include <map>
 #include <set>
@@ -61,6 +63,7 @@
 #include "options/cf_options.h"
 #include "options/options_helper.h"
 #include "options/options_parser.h"
+#include "port/likely.h"
 #include "port/port.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/compaction_filter.h"
@@ -71,6 +74,7 @@
 #include "rocksdb/statistics.h"
 #include "rocksdb/status.h"
 #include "rocksdb/table.h"
+#include "rocksdb/version.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/block.h"
 #include "table/block_based_table_factory.h"
@@ -126,11 +130,9 @@ void DumpSupportInfo(Logger* logger) {
  ROCKS_LOG_HEADER(logger, "\tZlib supported: %d", Zlib_Supported());
  ROCKS_LOG_HEADER(logger, "\tBzip supported: %d", BZip2_Supported());
  ROCKS_LOG_HEADER(logger, "\tLZ4 supported: %d", LZ4_Supported());
-  ROCKS_LOG_HEADER(logger, "\tZSTDNotFinal supported: %d",
-                   ZSTDNotFinal_Supported());
  ROCKS_LOG_HEADER(logger, "\tZSTD supported: %d", ZSTD_Supported());
-  ROCKS_LOG_HEADER(logger, "Fast CRC32 supported: %s",
-                   crc32c::IsFastCrc32Supported().c_str());
+  ROCKS_LOG_HEADER(logger, "Fast CRC32 supported: %d",
+                   crc32c::IsFastCrc32Supported());
 }

 int64_t kDefaultLowPriThrottledRate = 2 * 1024 * 1024;
@@ -181,8 +183,6 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
      has_unpersisted_data_(false),
      unable_to_flush_oldest_log_(false),
      env_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
-      env_options_for_compaction_(env_->OptimizeForCompactionTableWrite(
-          env_options_, immutable_db_options_)),
      num_running_ingest_file_(0),
 #ifndef ROCKSDB_LITE
      wal_manager_(immutable_db_options_, env_options_),
@@ -193,11 +193,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
      refitting_level_(false),
      opened_successfully_(false),
      concurrent_prepare_(options.concurrent_prepare),
-      manual_wal_flush_(options.manual_wal_flush),
-      seq_per_batch_(options.seq_per_batch),
-      // TODO(myabandeh): revise this when we change options.seq_per_batch
-      use_custom_gc_(options.seq_per_batch),
-      preserve_deletes_(options.preserve_deletes) {
+      manual_wal_flush_(options.manual_wal_flush) {
  env_->GetAbsolutePath(dbname, &db_absolute_path_);

  // Reserve ten files or so for other uses and give the rest to TableCache.
@@ -219,11 +215,6 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
  immutable_db_options_.Dump(immutable_db_options_.info_log.get());
  mutable_db_options_.Dump(immutable_db_options_.info_log.get());
  DumpSupportInfo(immutable_db_options_.info_log.get());
-
-  // always open the DB with 0 here, which means if preserve_deletes_==true
-  // we won't drop any deletion markers until SetPreserveDeletesSequenceNumber()
-  // is called by client and this seqnum is advanced.
-  preserve_deletes_seqnum_.store(0);
 }

 // Will lock the mutex_,  will wait for completion if wait is true
@@ -491,7 +482,6 @@ Status DBImpl::SetOptions(ColumnFamilyHandle* column_family,
  Status s;
  Status persist_options_status;
  WriteThread::Writer w;
-  SuperVersionContext sv_context(/* create_superversion */ true);
  {
    InstrumentedMutexLock l(&mutex_);
    s = cfd->SetOptions(options_map);
@@ -504,13 +494,14 @@ Status DBImpl::SetOptions(ColumnFamilyHandle* column_family,
      // Trigger possible flush/compactions. This has to be before we persist
      // options to file, otherwise there will be a deadlock with writer
      // thread.
-      InstallSuperVersionAndScheduleWork(cfd, &sv_context, new_options);
+      auto* old_sv =
+          InstallSuperVersionAndScheduleWork(cfd, nullptr, new_options);
+      delete old_sv;

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

  ROCKS_LOG_INFO(immutable_db_options_.info_log,
                 "SetOptions() on column family [%s], inputs:",
@@ -549,7 +540,6 @@ Status DBImpl::SetDBOptions(
  MutableDBOptions new_options;
  Status s;
  Status persist_options_status;
-  bool wal_changed = false;
  WriteThread::Writer w;
  WriteContext write_context;
  {
@@ -568,22 +558,12 @@ Status DBImpl::SetDBOptions(
      table_cache_.get()->SetCapacity(new_options.max_open_files == -1
                                          ? TableCache::kInfiniteCapacity
                                          : new_options.max_open_files - 10);
-      wal_changed = mutable_db_options_.wal_bytes_per_sync !=
-                    new_options.wal_bytes_per_sync;
-      if (new_options.bytes_per_sync == 0) {
-        new_options.bytes_per_sync = 1024 * 1024;
-      }
+
      mutable_db_options_ = new_options;
-      env_options_for_compaction_ = EnvOptions(BuildDBOptions(
-                                                immutable_db_options_,
-                                                mutable_db_options_));
-      env_options_for_compaction_ = env_->OptimizeForCompactionTableWrite(
-                                            env_options_for_compaction_,
-                                            immutable_db_options_);
-      versions_->ChangeEnvOptions(mutable_db_options_);
+
      write_thread_.EnterUnbatched(&w, &mutex_);
-      if (total_log_size_ > GetMaxTotalWalSize() || wal_changed) {
-        Status purge_wal_status = SwitchWAL(&write_context);
+      if (total_log_size_ > GetMaxTotalWalSize()) {
+        Status purge_wal_status = HandleWALFull(&write_context);
        if (!purge_wal_status.ok()) {
          ROCKS_LOG_WARN(immutable_db_options_.info_log,
                         "Unable to purge WAL files in SetDBOptions() -- %s",
@@ -750,19 +730,6 @@ SequenceNumber DBImpl::GetLatestSequenceNumber() const {
  return versions_->LastSequence();
 }

-SequenceNumber DBImpl::IncAndFetchSequenceNumber() {
-  return versions_->FetchAddLastToBeWrittenSequence(1ull) + 1ull;
-}
-
-bool DBImpl::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum) {
-  if (seqnum > preserve_deletes_seqnum_.load()) {
-    preserve_deletes_seqnum_.store(seqnum);
-    return true;
-  } else {
-    return false;
-  }
-}
-
 InternalIterator* DBImpl::NewInternalIterator(
    Arena* arena, RangeDelAggregator* range_del_agg,
    ColumnFamilyHandle* column_family) {
@@ -808,7 +775,9 @@ void DBImpl::BackgroundCallPurge() {
      purge_queue_.pop_front();

      mutex_.Unlock();
-      DeleteObsoleteFileImpl(job_id, fname, type, number, path_id);
+      Status file_deletion_status;
+      DeleteObsoleteFileImpl(file_deletion_status, job_id, fname, type, number,
+                             path_id);
      mutex_.Lock();
    } else {
      assert(!logs_to_free_queue_.empty());
@@ -911,7 +880,6 @@ InternalIterator* DBImpl::NewInternalIterator(
                                                         range_del_agg);
    }
  }
-  TEST_SYNC_POINT_CALLBACK("DBImpl::NewInternalIterator:StatusCallback", &s);
  if (s.ok()) {
    // Collect iterators for files in L0 - Ln
    if (read_options.read_tier != kMemtableTier) {
@@ -925,10 +893,8 @@ InternalIterator* DBImpl::NewInternalIterator(
    internal_iter->RegisterCleanup(CleanupIteratorState, cleanup, nullptr);

    return internal_iter;
-  } else {
-    CleanupSuperVersion(super_version);
  }
-  return NewErrorInternalIterator(s, arena);
+  return NewErrorInternalIterator(s);
 }

 ColumnFamilyHandle* DBImpl::DefaultColumnFamily() const {
@@ -944,7 +910,7 @@ Status DBImpl::Get(const ReadOptions& read_options,
 Status DBImpl::GetImpl(const ReadOptions& read_options,
                       ColumnFamilyHandle* column_family, const Slice& key,
                       PinnableSlice* pinnable_val, bool* value_found,
-                       ReadCallback* callback, bool* is_blob_index) {
+                       bool* is_blob_index) {
  assert(pinnable_val != nullptr);
  StopWatch sw(env_, stats_, DB_GET);
  PERF_TIMER_GUARD(get_snapshot_time);
@@ -960,10 +926,6 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,

  SequenceNumber snapshot;
  if (read_options.snapshot != nullptr) {
-    // Note: In WritePrepared txns this is not necessary but not harmful either.
-    // Because prep_seq > snapshot => commit_seq > snapshot so if a snapshot is
-    // specified we should be fine with skipping seq numbers that are greater
-    // than that.
    snapshot = reinterpret_cast<const SnapshotImpl*>(
        read_options.snapshot)->number_;
  } else {
@@ -977,9 +939,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
    // super versipon because a flush happening in between may compact
    // away data for the snapshot, but the snapshot is earlier than the
    // data overwriting it, so users may see wrong results.
-    snapshot = concurrent_prepare_ && seq_per_batch_
-                   ? versions_->LastToBeWrittenSequence()
-                   : versions_->LastSequence();
+    snapshot = versions_->LastSequence();
  }
  TEST_SYNC_POINT("DBImpl::GetImpl:3");
  TEST_SYNC_POINT("DBImpl::GetImpl:4");
@@ -1000,27 +960,25 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
  bool done = false;
  if (!skip_memtable) {
    if (sv->mem->Get(lkey, pinnable_val->GetSelf(), &s, &merge_context,
-                     &range_del_agg, read_options, callback, is_blob_index)) {
+                     &range_del_agg, read_options, is_blob_index)) {
      done = true;
      pinnable_val->PinSelf();
      RecordTick(stats_, MEMTABLE_HIT);
    } else if ((s.ok() || s.IsMergeInProgress()) &&
               sv->imm->Get(lkey, pinnable_val->GetSelf(), &s, &merge_context,
-                            &range_del_agg, read_options, callback,
-                            is_blob_index)) {
+                            &range_del_agg, read_options, is_blob_index)) {
      done = true;
      pinnable_val->PinSelf();
      RecordTick(stats_, MEMTABLE_HIT);
    }
    if (!done && !s.ok() && !s.IsMergeInProgress()) {
-      ReturnAndCleanupSuperVersion(cfd, sv);
      return s;
    }
  }
  if (!done) {
    PERF_TIMER_GUARD(get_from_output_files_time);
    sv->current->Get(read_options, lkey, pinnable_val, &s, &merge_context,
-                     &range_del_agg, value_found, nullptr, nullptr, callback,
+                     &range_del_agg, value_found, nullptr, nullptr,
                     is_blob_index);
    RecordTick(stats_, MEMTABLE_MISS);
  }
@@ -1070,9 +1028,7 @@ std::vector<Status> DBImpl::MultiGet(
    snapshot = reinterpret_cast<const SnapshotImpl*>(
        read_options.snapshot)->number_;
  } else {
-    snapshot = concurrent_prepare_ && seq_per_batch_
-                   ? versions_->LastToBeWrittenSequence()
-                   : versions_->LastSequence();
+    snapshot = versions_->LastSequence();
  }
  for (auto mgd_iter : multiget_cf_data) {
    mgd_iter.second->super_version =
@@ -1253,7 +1209,6 @@ Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
    return s;
  }

-  SuperVersionContext sv_context(/* create_superversion */ true);
  {
    InstrumentedMutexLock l(&mutex_);

@@ -1285,8 +1240,8 @@ Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
      auto* cfd =
          versions_->GetColumnFamilySet()->GetColumnFamily(column_family_name);
      assert(cfd != nullptr);
-      InstallSuperVersionAndScheduleWork(
-              cfd, &sv_context, *cfd->GetLatestMutableCFOptions());
+      delete InstallSuperVersionAndScheduleWork(
+          cfd, nullptr, *cfd->GetLatestMutableCFOptions());

      if (!cfd->mem()->IsSnapshotSupported()) {
        is_snapshot_supported_ = false;
@@ -1305,7 +1260,6 @@ Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
    }
  }  // InstrumentedMutexLock l(&mutex_)

-  sv_context.Clean();
  // this is outside the mutex
  if (s.ok()) {
    NewThreadStatusCfInfo(
@@ -1431,67 +1385,54 @@ bool DBImpl::KeyMayExist(const ReadOptions& read_options,

 Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
                              ColumnFamilyHandle* column_family) {
-  Iterator* result = nullptr;
  if (read_options.read_tier == kPersistedTier) {
    return NewErrorIterator(Status::NotSupported(
        "ReadTier::kPersistedData is not yet supported in iterators."));
  }
-  // if iterator wants internal keys, we can only proceed if
-  // we can guarantee the deletes haven't been processed yet
-  if (immutable_db_options_.preserve_deletes &&
-      read_options.iter_start_seqnum > 0 &&
-      read_options.iter_start_seqnum < preserve_deletes_seqnum_.load()) {
-        return NewErrorIterator(Status::InvalidArgument(
-          "Iterator requested internal keys which are too old and are not"
-          " guaranteed to be preserved, try larger iter_start_seqnum opt."));
-      }
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
  auto cfd = cfh->cfd();
-  ReadCallback* read_callback = nullptr;  // No read callback provided.
  if (read_options.managed) {
 #ifdef ROCKSDB_LITE
    // not supported in lite version
-    result =  NewErrorIterator(Status::InvalidArgument(
+    return NewErrorIterator(Status::InvalidArgument(
        "Managed Iterators not supported in RocksDBLite."));
 #else
    if ((read_options.tailing) || (read_options.snapshot != nullptr) ||
        (is_snapshot_supported_)) {
-      result = new ManagedIterator(this, read_options, cfd);
-    } else {
-      // Managed iter not supported
-      result = NewErrorIterator(Status::InvalidArgument(
-        "Managed Iterators not supported without snapshots."));
+      return new ManagedIterator(this, read_options, cfd);
    }
+    // Managed iter not supported
+    return NewErrorIterator(Status::InvalidArgument(
+        "Managed Iterators not supported without snapshots."));
 #endif
  } else if (read_options.tailing) {
 #ifdef ROCKSDB_LITE
    // not supported in lite version
-    result = nullptr;
-
+    return nullptr;
 #else
    SuperVersion* sv = cfd->GetReferencedSuperVersion(&mutex_);
    auto iter = new ForwardIterator(this, read_options, cfd, sv);
-    result = NewDBIterator(
+    return NewDBIterator(
        env_, read_options, *cfd->ioptions(), cfd->user_comparator(), iter,
        kMaxSequenceNumber,
-        sv->mutable_cf_options.max_sequential_skip_in_iterations,
-        read_callback);
+        sv->mutable_cf_options.max_sequential_skip_in_iterations);
 #endif
  } else {
-    // Note: no need to consider the special case of concurrent_prepare_ &&
-    // seq_per_batch_ since NewIterator is overridden in WritePreparedTxnDB
-    auto snapshot = read_options.snapshot != nullptr
-                        ? read_options.snapshot->GetSequenceNumber()
-                        : versions_->LastSequence();
-    result = NewIteratorImpl(read_options, cfd, snapshot, read_callback);
+    SequenceNumber latest_snapshot = versions_->LastSequence();
+    auto snapshot =
+        read_options.snapshot != nullptr
+            ? reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)
+                  ->number_
+            : latest_snapshot;
+    return NewIteratorImpl(read_options, cfd, snapshot);
  }
-  return result;
+  // To stop compiler from complaining
+  return nullptr;
 }

 ArenaWrappedDBIter* DBImpl::NewIteratorImpl(const ReadOptions& read_options,
                                            ColumnFamilyData* cfd,
                                            SequenceNumber snapshot,
-                                            ReadCallback* read_callback,
                                            bool allow_blob) {
  SuperVersion* sv = cfd->GetReferencedSuperVersion(&mutex_);

@@ -1540,8 +1481,8 @@ ArenaWrappedDBIter* DBImpl::NewIteratorImpl(const ReadOptions& read_options,
  ArenaWrappedDBIter* db_iter = NewArenaWrappedDbIterator(
      env_, read_options, *cfd->ioptions(), snapshot,
      sv->mutable_cf_options.max_sequential_skip_in_iterations,
-      sv->version_number, read_callback,
-      ((read_options.snapshot != nullptr) ? nullptr : this), cfd, allow_blob);
+      sv->version_number, ((read_options.snapshot != nullptr) ? nullptr : this),
+      cfd, allow_blob);

  InternalIterator* internal_iter =
      NewInternalIterator(read_options, cfd, sv, db_iter->GetArena(),
@@ -1559,7 +1500,6 @@ Status DBImpl::NewIterators(
    return Status::NotSupported(
        "ReadTier::kPersistedData is not yet supported in iterators.");
  }
-  ReadCallback* read_callback = nullptr;  // No read callback provided.
  iterators->clear();
  iterators->reserve(column_families.size());
  if (read_options.managed) {
@@ -1590,21 +1530,21 @@ Status DBImpl::NewIterators(
      iterators->push_back(NewDBIterator(
          env_, read_options, *cfd->ioptions(), cfd->user_comparator(), iter,
          kMaxSequenceNumber,
-          sv->mutable_cf_options.max_sequential_skip_in_iterations,
-          read_callback));
+          sv->mutable_cf_options.max_sequential_skip_in_iterations));
    }
 #endif
  } else {
-    // Note: no need to consider the special case of concurrent_prepare_ &&
-    // seq_per_batch_ since NewIterators is overridden in WritePreparedTxnDB
-    auto snapshot = read_options.snapshot != nullptr
-                        ? read_options.snapshot->GetSequenceNumber()
-                        : versions_->LastSequence();
+    SequenceNumber latest_snapshot = versions_->LastSequence();
+    auto snapshot =
+        read_options.snapshot != nullptr
+            ? reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)
+                  ->number_
+            : latest_snapshot;
+
    for (size_t i = 0; i < column_families.size(); ++i) {
      auto* cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(
          column_families[i])->cfd();
-      iterators->push_back(
-          NewIteratorImpl(read_options, cfd, snapshot, read_callback));
+      iterators->push_back(NewIteratorImpl(read_options, cfd, snapshot));
    }
  }

@@ -1630,10 +1570,8 @@ const Snapshot* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary) {
    delete s;
    return nullptr;
  }
-  auto snapshot_seq = concurrent_prepare_ && seq_per_batch_
-                          ? versions_->LastToBeWrittenSequence()
-                          : versions_->LastSequence();
-  return snapshots_.New(s, snapshot_seq, unix_time, is_write_conflict_boundary);
+  return snapshots_.New(s, versions_->LastSequence(), unix_time,
+                        is_write_conflict_boundary);
 }

 void DBImpl::ReleaseSnapshot(const Snapshot* s) {
@@ -1641,24 +1579,6 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
  {
    InstrumentedMutexLock l(&mutex_);
    snapshots_.Delete(casted_s);
-    uint64_t oldest_snapshot;
-    if (snapshots_.empty()) {
-      oldest_snapshot = concurrent_prepare_ && seq_per_batch_
-                            ? versions_->LastToBeWrittenSequence()
-                            : versions_->LastSequence();
-    } else {
-      oldest_snapshot = snapshots_.oldest()->number_;
-    }
-    for (auto* cfd : *versions_->GetColumnFamilySet()) {
-      cfd->current()->storage_info()->UpdateOldestSnapshot(oldest_snapshot);
-      if (!cfd->current()
-               ->storage_info()
-               ->BottommostFilesMarkedForCompaction()
-               .empty()) {
-        SchedulePendingCompaction(cfd);
-        MaybeScheduleFlushOrCompaction();
-      }
-    }
  }
  delete casted_s;
 }
@@ -1763,7 +1683,7 @@ bool DBImpl::GetProperty(ColumnFamilyHandle* column_family,

 bool DBImpl::GetMapProperty(ColumnFamilyHandle* column_family,
                            const Slice& property,
-                            std::map<std::string, std::string>* value) {
+                            std::map<std::string, double>* value) {
  const DBPropertyInfo* property_info = GetPropertyInfo(property);
  value->clear();
  auto cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family)->cfd();
@@ -1876,23 +1796,21 @@ SuperVersion* DBImpl::GetAndRefSuperVersion(uint32_t column_family_id) {
  return GetAndRefSuperVersion(cfd);
 }

-void DBImpl::CleanupSuperVersion(SuperVersion* sv) {
-  // Release SuperVersion
-  if (sv->Unref()) {
-    {
-      InstrumentedMutexLock l(&mutex_);
-      sv->Cleanup();
-    }
-    delete sv;
-    RecordTick(stats_, NUMBER_SUPERVERSION_CLEANUPS);
-  }
-  RecordTick(stats_, NUMBER_SUPERVERSION_RELEASES);
-}
-
 void DBImpl::ReturnAndCleanupSuperVersion(ColumnFamilyData* cfd,
                                          SuperVersion* sv) {
-  if (!cfd->ReturnThreadLocalSuperVersion(sv)) {
-    CleanupSuperVersion(sv);
+  bool unref_sv = !cfd->ReturnThreadLocalSuperVersion(sv);
+
+  if (unref_sv) {
+    // Release SuperVersion
+    if (sv->Unref()) {
+      {
+        InstrumentedMutexLock l(&mutex_);
+        sv->Cleanup();
+      }
+      delete sv;
+      RecordTick(stats_, NUMBER_SUPERVERSION_CLEANUPS);
+    }
+    RecordTick(stats_, NUMBER_SUPERVERSION_RELEASES);
  }
 }

@@ -2095,9 +2013,8 @@ Status DBImpl::DeleteFile(std::string name) {
    status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                    &edit, &mutex_, directories_.GetDbDir());
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(
-          cfd, &job_context.superversion_context,
-          *cfd->GetLatestMutableCFOptions());
+      InstallSuperVersionAndScheduleWorkWrapper(
+          cfd, &job_context, *cfd->GetLatestMutableCFOptions());
    }
    FindObsoleteFiles(&job_context, false);
  }  // lock released here
@@ -2135,13 +2052,13 @@ Status DBImpl::DeleteFilesInRange(ColumnFamilyHandle* column_family,
      if (begin == nullptr) {
        begin_key = nullptr;
      } else {
-        begin_storage.SetMinPossibleForUserKey(*begin);
+        begin_storage.SetMaxPossibleForUserKey(*begin);
        begin_key = &begin_storage;
      }
      if (end == nullptr) {
        end_key = nullptr;
      } else {
-        end_storage.SetMaxPossibleForUserKey(*end);
+        end_storage.SetMinPossibleForUserKey(*end);
        end_key = &end_storage;
      }

@@ -2168,9 +2085,8 @@ Status DBImpl::DeleteFilesInRange(ColumnFamilyHandle* column_family,
    status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                    &edit, &mutex_, directories_.GetDbDir());
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(
-          cfd, &job_context.superversion_context,
-          *cfd->GetLatestMutableCFOptions());
+      InstallSuperVersionAndScheduleWorkWrapper(
+          cfd, &job_context, *cfd->GetLatestMutableCFOptions());
    }
    for (auto* deleted_file : deleted_files) {
      deleted_file->being_compacted = false;
@@ -2620,7 +2536,7 @@ Status DBImpl::GetLatestSequenceForKey(SuperVersion* sv, const Slice& key,

  // Check if there is a record for this key in the latest memtable
  sv->mem->Get(lkey, nullptr, &s, &merge_context, &range_del_agg, seq,
-               read_options, nullptr /*read_callback*/, is_blob_index);
+               read_options, is_blob_index);

  if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
    // unexpected error reading memtable.
@@ -2639,7 +2555,7 @@ Status DBImpl::GetLatestSequenceForKey(SuperVersion* sv, const Slice& key,

  // Check if there is a record for this key in the immutable memtables
  sv->imm->Get(lkey, nullptr, &s, &merge_context, &range_del_agg, seq,
-               read_options, nullptr /*read_callback*/, is_blob_index);
+               read_options, is_blob_index);

  if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
    // unexpected error reading memtable.
@@ -2682,8 +2598,7 @@ Status DBImpl::GetLatestSequenceForKey(SuperVersion* sv, const Slice& key,
    // Check tables
    sv->current->Get(read_options, lkey, nullptr, &s, &merge_context,
                     &range_del_agg, nullptr /* value_found */,
-                     found_record_for_key, seq, nullptr /*read_callback*/,
-                     is_blob_index);
+                     found_record_for_key, seq, is_blob_index);

    if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
      // unexpected error reading SST files
@@ -2736,7 +2651,6 @@ Status DBImpl::IngestExternalFile(
    return status;
  }

-  SuperVersionContext sv_context(/* create_superversion */ true);
  TEST_SYNC_POINT("DBImpl::AddFile:Start");
  {
    // Lock db mutex
@@ -2785,8 +2699,8 @@ Status DBImpl::IngestExternalFile(
                                 &mutex_, directories_.GetDbDir());
    }
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd, &sv_context,
-                                         *mutable_cf_options);
+      delete InstallSuperVersionAndScheduleWork(cfd, nullptr,
+                                                *mutable_cf_options);
    }

    // Resume writes to the DB
@@ -2812,7 +2726,6 @@ Status DBImpl::IngestExternalFile(
  // mutex_ is unlocked here

  // Cleanup
-  sv_context.Clean();
  ingestion_job.Cleanup(status);

  if (status.ok()) {
@@ -28,8 +28,6 @@
 #include "db/flush_scheduler.h"
 #include "db/internal_stats.h"
 #include "db/log_writer.h"
-#include "db/read_callback.h"
-#include "db/snapshot_checker.h"
 #include "db/snapshot_impl.h"
 #include "db/version_edit.h"
 #include "db/wal_manager.h"
@@ -54,13 +52,13 @@

 namespace rocksdb {

-class Arena;
 class ArenaWrappedDBIter;
 class MemTable;
 class TableCache;
 class Version;
 class VersionEdit;
 class VersionSet;
+class Arena;
 class WriteCallback;
 struct JobContext;
 struct ExternalSstFileInfo;
@@ -101,8 +99,7 @@ class DBImpl : public DB {
  // Note: 'value_found' from KeyMayExist propagates here
  Status GetImpl(const ReadOptions& options, ColumnFamilyHandle* column_family,
                 const Slice& key, PinnableSlice* value,
-                 bool* value_found = nullptr, ReadCallback* callback = nullptr,
-                 bool* is_blob_index = nullptr);
+                 bool* value_found = nullptr, bool* is_blob_index = nullptr);

  using DB::MultiGet;
  virtual std::vector<Status> MultiGet(
@@ -145,7 +142,6 @@ class DBImpl : public DB {
  ArenaWrappedDBIter* NewIteratorImpl(const ReadOptions& options,
                                      ColumnFamilyData* cfd,
                                      SequenceNumber snapshot,
-                                      ReadCallback* read_callback,
                                      bool allow_blob = false);

  virtual const Snapshot* GetSnapshot() override;
@@ -154,9 +150,9 @@ class DBImpl : public DB {
  virtual bool GetProperty(ColumnFamilyHandle* column_family,
                           const Slice& property, std::string* value) override;
  using DB::GetMapProperty;
-  virtual 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, double>* value) override;
  using DB::GetIntProperty;
  virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
                              const Slice& property, uint64_t* value) override;
@@ -219,13 +215,6 @@ class DBImpl : public DB {
  virtual Status SyncWAL() override;

  virtual SequenceNumber GetLatestSequenceNumber() const override;
-  virtual SequenceNumber IncAndFetchSequenceNumber();
-  // Returns LastToBeWrittenSequence in concurrent_prepare_ && seq_per_batch_
-  // mode and LastSequence otherwise. This is useful when visiblility depends
-  // also on data written to the WAL but not to the memtable.
-  SequenceNumber TEST_GetLatestVisibleSequenceNumber() const;
-
-  virtual bool SetPreserveDeletesSequenceNumber(SequenceNumber seqnum) override;

  // Whether there is an active snapshot in range [lower_bound, upper_bound).
  bool HasActiveSnapshotInRange(SequenceNumber lower_bound,
@@ -359,7 +348,7 @@ class DBImpl : public DB {
                           ColumnFamilyHandle* column_family = nullptr,
                           bool disallow_trivial_move = false);

-  void TEST_SwitchWAL();
+  void TEST_HandleWALFull();

  bool TEST_UnableToFlushOldestLog() {
    return unable_to_flush_oldest_log_;
@@ -389,9 +378,6 @@ class DBImpl : public DB {
  // Return the current manifest file no.
  uint64_t TEST_Current_Manifest_FileNo();

-  // Returns the number that'll be assigned to the next file that's created.
-  uint64_t TEST_Current_Next_FileNo();
-
  // get total level0 file size. Only for testing.
  uint64_t TEST_GetLevel0TotalSize();

@@ -495,9 +481,6 @@ class DBImpl : public DB {
  // mutex is held.
  SuperVersion* GetAndRefSuperVersion(uint32_t column_family_id);

-  // Un-reference the super version and clean it up if it is the last reference.
-  void CleanupSuperVersion(SuperVersion* sv);
-
  // Un-reference the super version and return it to thread local cache if
  // needed. If it is the last reference of the super version. Clean it up
  // after un-referencing it.
@@ -545,11 +528,9 @@ class DBImpl : public DB {
    uint64_t log_number_;
    std::string name_;
    WriteBatch* batch_;
-    // The seq number of the first key in the batch
-    SequenceNumber seq_;
    explicit RecoveredTransaction(const uint64_t log, const std::string& name,
-                                  WriteBatch* batch, SequenceNumber seq)
-        : log_number_(log), name_(name), batch_(batch), seq_(seq) {}
+                                  WriteBatch* batch)
+        : log_number_(log), name_(name), batch_(batch) {}

    ~RecoveredTransaction() { delete batch_; }
  };
@@ -571,9 +552,8 @@ class DBImpl : public DB {
  }

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

@@ -599,9 +579,6 @@ class DBImpl : public DB {
  void AddToLogsToFreeQueue(log::Writer* log_writer) {
    logs_to_free_queue_.push_back(log_writer);
  }
-
-  void SetSnapshotChecker(SnapshotChecker* snapshot_checker);
-
  InstrumentedMutex* mutex() { return &mutex_; }

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

  uint64_t FindMinLogContainingOutstandingPrep();
  uint64_t FindMinPrepLogReferencedByMemTable();
-  // write cached_recoverable_state_ to memtable if it is not empty
-  // The writer must be the leader in write_thread_ and holding mutex_
-  Status WriteRecoverableState();

 private:
  friend class DB;
@@ -683,8 +657,6 @@ class DBImpl : public DB {
  friend class PessimisticTransaction;
  friend class WriteCommittedTxn;
  friend class WritePreparedTxn;
-  friend class WritePreparedTxnDB;
-  friend class WriteBatchWithIndex;
 #ifndef ROCKSDB_LITE
  friend class ForwardIterator;
 #endif
@@ -698,14 +670,13 @@ class DBImpl : public DB {
  struct CompactionState;

  struct WriteContext {
-    SuperVersionContext superversion_context;
+    autovector<SuperVersion*> superversions_to_free_;
    autovector<MemTable*> memtables_to_free_;

-    explicit WriteContext(bool create_superversion = false)
-        : superversion_context(create_superversion) {}
-
    ~WriteContext() {
-      superversion_context.Clean();
+      for (auto& sv : superversions_to_free_) {
+        delete sv;
+      }
      for (auto& m : memtables_to_free_) {
        delete m;
      }
@@ -735,8 +706,9 @@ class DBImpl : public DB {
  // Delete any unneeded files and stale in-memory entries.
  void DeleteObsoleteFiles();
  // Delete obsolete files and log status and information of file deletion
-  void DeleteObsoleteFileImpl(int job_id, const std::string& fname,
-                              FileType type, uint64_t number, uint32_t path_id);
+  void DeleteObsoleteFileImpl(Status file_deletion_status, int job_id,
+                              const std::string& fname, FileType type,
+                              uint64_t number, uint32_t path_id);

  // Background process needs to call
  //     auto x = CaptureCurrentFileNumberInPendingOutputs()
@@ -797,7 +769,7 @@ class DBImpl : public DB {
  Status WaitForFlushMemTable(ColumnFamilyData* cfd);

  // REQUIRES: mutex locked
-  Status SwitchWAL(WriteContext* write_context);
+  Status HandleWALFull(WriteContext* write_context);

  // REQUIRES: mutex locked
  Status HandleWriteBufferFull(WriteContext* write_context);
@@ -807,8 +779,7 @@ class DBImpl : public DB {
                         WriteContext* write_context);

  WriteBatch* MergeBatch(const WriteThread::WriteGroup& write_group,
-                         WriteBatch* tmp_batch, size_t* write_with_wal,
-                         WriteBatch** to_be_cached_state);
+                         WriteBatch* tmp_batch, size_t* write_with_wal);

  Status WriteToWAL(const WriteBatch& merged_batch, log::Writer* log_writer,
                    uint64_t* log_used, uint64_t* log_size);
@@ -820,7 +791,7 @@ class DBImpl : public DB {

  Status ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
                              uint64_t* log_used, SequenceNumber* last_sequence,
-                              size_t seq_inc);
+                              int total_count);

  // Used by WriteImpl to update bg_error_ if paranoid check is enabled.
  void WriteCallbackStatusCheck(const Status& status);
@@ -998,15 +969,6 @@ class DBImpl : public DB {
  std::deque<LogWriterNumber> logs_;
  // Signaled when getting_synced becomes false for some of the logs_.
  InstrumentedCondVar log_sync_cv_;
-  // This is the app-level state that is written to the WAL but will be used
-  // only during recovery. Using this feature enables not writing the state to
-  // memtable on normal writes and hence improving the throughput. Each new
-  // write of the state will replace the previous state entirely even if the
-  // keys in the two consecuitive states do not overlap.
-  // It is protected by log_write_mutex_ when concurrent_prepare_ is enabled.
-  // Otherwise only the heaad of write_thread_ can access it.
-  WriteBatch cached_recoverable_state_;
-  std::atomic<bool> cached_recoverable_state_empty_ = {true};
  std::atomic<uint64_t> total_log_size_;
  // only used for dynamically adjusting max_total_wal_size. it is a sum of
  // [write_buffer_size * max_write_buffer_number] over all column families
@@ -1225,9 +1187,6 @@ class DBImpl : public DB {
  // The options to access storage files
  const EnvOptions env_options_;

-  // Additonal options for compaction and flush
-  EnvOptions env_options_for_compaction_;
-
  // Number of running IngestExternalFile() calls.
  // REQUIRES: mutex held
  int num_running_ingest_file_;
@@ -1273,23 +1232,23 @@ class DBImpl : public DB {
  std::unordered_map<uint64_t, uint64_t> prepared_section_completed_;
  std::mutex prep_heap_mutex_;

-  // Callback for compaction to check if a key is visible to a snapshot.
-  // REQUIRES: mutex held
-  std::unique_ptr<SnapshotChecker> snapshot_checker_;
-
  // No copying allowed
  DBImpl(const DBImpl&);
  void operator=(const DBImpl&);

  // Background threads call this function, which is just a wrapper around
  // the InstallSuperVersion() function. Background threads carry
-  // sv_context which can have new_superversion already
+  // job_context which can have new_superversion already
  // allocated.
+  void InstallSuperVersionAndScheduleWorkWrapper(
+      ColumnFamilyData* cfd, JobContext* job_context,
+      const MutableCFOptions& mutable_cf_options);
+
  // All ColumnFamily state changes go through this function. Here we analyze
  // the new state and we schedule background work if we detect that the new
  // state needs flush or compaction.
-  void InstallSuperVersionAndScheduleWork(
-      ColumnFamilyData* cfd, SuperVersionContext* sv_context,
+  SuperVersion* InstallSuperVersionAndScheduleWork(
+      ColumnFamilyData* cfd, SuperVersion* new_sv,
      const MutableCFOptions& mutable_cf_options);

 #ifndef ROCKSDB_LITE
@@ -1321,15 +1280,6 @@ class DBImpl : public DB {
  // 2PC these are the writes at Prepare phase.
  const bool concurrent_prepare_;
  const bool manual_wal_flush_;
-  const bool seq_per_batch_;
-  const bool use_custom_gc_;
-
-  // Clients must periodically call SetPreserveDeletesSequenceNumber()
-  // to advance this seqnum. Default value is 0 which means ALL deletes are
-  // preserved. Note that this has no effect if DBOptions.preserve_deletes
-  // is set to false.
-  std::atomic<SequenceNumber> preserve_deletes_seqnum_;
-  const bool preserve_deletes_;
 };

 extern Options SanitizeOptions(const std::string& db,
@@ -86,16 +86,11 @@ Status DBImpl::FlushMemTableToOutputFile(
  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,
-      env_options_for_compaction_, versions_.get(), &mutex_, &shutting_down_,
-      snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
-      job_context, log_buffer, directories_.GetDbDir(),
-      directories_.GetDataDir(0U),
+      dbname_, cfd, immutable_db_options_, mutable_cf_options, env_options_,
+      versions_.get(), &mutex_, &shutting_down_, snapshot_seqs,
+      earliest_write_conflict_snapshot, job_context, log_buffer,
+      directories_.GetDbDir(), directories_.GetDataDir(0U),
      GetCompressionFlush(*cfd->ioptions(), mutable_cf_options), stats_,
      &event_logger_, mutable_cf_options.report_bg_io_stats);

@@ -134,8 +129,8 @@ Status DBImpl::FlushMemTableToOutputFile(
  }

  if (s.ok()) {
-    InstallSuperVersionAndScheduleWork(cfd, &job_context->superversion_context,
-                                       mutable_cf_options);
+    InstallSuperVersionAndScheduleWorkWrapper(cfd, job_context,
+                                              mutable_cf_options);
    if (made_progress) {
      *made_progress = 1;
    }
@@ -520,10 +515,9 @@ Status DBImpl::CompactFilesImpl(
  c.reset(cfd->compaction_picker()->CompactFiles(
      compact_options, input_files, output_level, version->storage_info(),
      *cfd->GetLatestMutableCFOptions(), output_path_id));
-  // we already sanitized the set of input files and checked for conflicts
-  // without releasing the lock, so we're guaranteed a compaction can be formed.
-  assert(c != nullptr);
-
+  if (!c) {
+    return Status::Aborted("Another Level 0 compaction is running");
+  }
  c->SetInputVersion(version);
  // deletion compaction currently not allowed in CompactFiles.
  assert(!c->deletion_compaction());
@@ -535,18 +529,12 @@ Status DBImpl::CompactFilesImpl(
  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());
  CompactionJob compaction_job(
-      job_context->job_id, c.get(), immutable_db_options_,
-      env_options_for_compaction_, versions_.get(), &shutting_down_,
-      preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
-      directories_.GetDataDir(c->output_path_id()),
-      stats_, &mutex_, &bg_error_, snapshot_seqs,
-      earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
+      job_context->job_id, c.get(), immutable_db_options_, env_options_,
+      versions_.get(), &shutting_down_, log_buffer, directories_.GetDbDir(),
+      directories_.GetDataDir(c->output_path_id()), stats_, &mutex_, &bg_error_,
+      snapshot_seqs, earliest_write_conflict_snapshot, table_cache_,
      &event_logger_, c->mutable_cf_options()->paranoid_file_checks,
      c->mutable_cf_options()->report_bg_io_stats, dbname_,
      nullptr);  // Here we pass a nullptr for CompactionJobStats because
@@ -582,9 +570,8 @@ Status DBImpl::CompactFilesImpl(

  Status status = compaction_job.Install(*c->mutable_cf_options());
  if (status.ok()) {
-    InstallSuperVersionAndScheduleWork(
-        c->column_family_data(), &job_context->superversion_context,
-       *c->mutable_cf_options());
+    InstallSuperVersionAndScheduleWorkWrapper(
+        c->column_family_data(), job_context, *c->mutable_cf_options());
  }
  c->ReleaseCompactionFiles(s);

@@ -662,8 +649,6 @@ void DBImpl::NotifyOnCompactionCompleted(
  if (shutting_down_.load(std::memory_order_acquire)) {
    return;
  }
-  Version* current = cfd->current();
-  current->Ref();
  // release lock while notifying events
  mutex_.Unlock();
  TEST_SYNC_POINT("DBImpl::NotifyOnCompactionCompleted::UnlockMutex");
@@ -686,7 +671,7 @@ void DBImpl::NotifyOnCompactionCompleted(
        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);
+          auto s = cfd->current()->GetTableProperties(&tp, fmd, &fn);
          if (s.ok()) {
            info.table_properties[fn] = tp;
          }
@@ -703,7 +688,6 @@ void DBImpl::NotifyOnCompactionCompleted(
    }
  }
  mutex_.Lock();
-  current->Unref();
  // no need to signal bg_cv_ as it will be signaled at the end of the
  // flush process.
 #endif  // ROCKSDB_LITE
@@ -717,7 +701,8 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
    return Status::InvalidArgument("Target level exceeds number of levels");
  }

-  SuperVersionContext sv_context(/* create_superversion */ true);
+  std::unique_ptr<SuperVersion> superversion_to_free;
+  std::unique_ptr<SuperVersion> new_superversion(new SuperVersion());

  Status status;

@@ -772,7 +757,8 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {

    status = versions_->LogAndApply(cfd, mutable_cf_options, &edit, &mutex_,
                                    directories_.GetDbDir());
-    InstallSuperVersionAndScheduleWork(cfd, &sv_context, mutable_cf_options);
+    superversion_to_free.reset(InstallSuperVersionAndScheduleWork(
+        cfd, new_superversion.release(), mutable_cf_options));

    ROCKS_LOG_DEBUG(immutable_db_options_.info_log, "[%s] LogAndApply: %s\n",
                    cfd->GetName().c_str(), status.ToString().data());
@@ -784,7 +770,6 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
    }
  }

-  sv_context.Clean();
  refitting_level_ = false;

  return status;
@@ -841,7 +826,7 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
      cfd->ioptions()->compaction_style == kCompactionStyleFIFO) {
    manual.begin = nullptr;
  } else {
-    begin_storage.SetMinPossibleForUserKey(*begin);
+    begin_storage.SetMaxPossibleForUserKey(*begin);
    manual.begin = &begin_storage;
  }
  if (end == nullptr ||
@@ -849,7 +834,7 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
      cfd->ioptions()->compaction_style == kCompactionStyleFIFO) {
    manual.end = nullptr;
  } else {
-    end_storage.SetMaxPossibleForUserKey(*end);
+    end_storage.SetMinPossibleForUserKey(*end);
    manual.end = &end_storage;
  }

@@ -895,15 +880,15 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
  while (!manual.done) {
    assert(HasPendingManualCompaction());
    manual_conflict = false;
-    Compaction* compaction = nullptr;
+    Compaction* compaction;
    if (ShouldntRunManualCompaction(&manual) || (manual.in_progress == true) ||
        scheduled ||
-        (((manual.manual_end = &manual.tmp_storage1) != nullptr) &&
-             ((compaction = manual.cfd->CompactRange(
-                  *manual.cfd->GetLatestMutableCFOptions(), manual.input_level,
-                  manual.output_level, manual.output_path_id, manual.begin,
-                  manual.end, &manual.manual_end, &manual_conflict)) == nullptr &&
-         manual_conflict))) {
+        ((manual.manual_end = &manual.tmp_storage1) &&
+         ((compaction = manual.cfd->CompactRange(
+               *manual.cfd->GetLatestMutableCFOptions(), manual.input_level,
+               manual.output_level, manual.output_path_id, manual.begin,
+               manual.end, &manual.manual_end, &manual_conflict)) == nullptr) &&
+         manual_conflict)) {
      // exclusive manual compactions should not see a conflict during
      // CompactRange
      assert(!exclusive || !manual_conflict);
@@ -948,8 +933,7 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
    WriteContext context;
    InstrumentedMutexLock guard_lock(&mutex_);

-    if (cfd->imm()->NumNotFlushed() == 0 && cfd->mem()->IsEmpty() &&
-        cached_recoverable_state_empty_.load()) {
+    if (cfd->imm()->NumNotFlushed() == 0 && cfd->mem()->IsEmpty()) {
      // Nothing to flush
      return Status::OK();
    }
@@ -959,7 +943,8 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
      write_thread_.EnterUnbatched(&w, &mutex_);
    }

-    // SwitchMemtable() will release and reacquire mutex during execution
+    // SwitchMemtable() will release and reacquire mutex
+    // during execution
    s = SwitchMemtable(cfd, &context);

    if (!writes_stopped) {
@@ -1585,9 +1570,8 @@ 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_context,
-        *c->mutable_cf_options());
+    InstallSuperVersionAndScheduleWorkWrapper(
+        c->column_family_data(), job_context, *c->mutable_cf_options());
    ROCKS_LOG_BUFFER(log_buffer, "[%s] Deleted %d files\n",
                     c->column_family_data()->GetName().c_str(),
                     c->num_input_files(0));
@@ -1632,9 +1616,8 @@ 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_context,
-        *c->mutable_cf_options());
+    InstallSuperVersionAndScheduleWorkWrapper(
+        c->column_family_data(), job_context, *c->mutable_cf_options());

    VersionStorageInfo::LevelSummaryStorage tmp;
    c->column_family_data()->internal_stats()->IncBytesMoved(c->output_level(),
@@ -1679,26 +1662,21 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    env_->Schedule(&DBImpl::BGWorkBottomCompaction, ca, Env::Priority::BOTTOM,
                   this, &DBImpl::UnscheduleCallback);
  } else {
-    int output_level  __attribute__((unused));
-    output_level = c->output_level();
+    int output_level  __attribute__((unused)) = c->output_level();
    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:NonTrivial",
                             &output_level);
+
    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();
-    }
    assert(is_snapshot_supported_ || snapshots_.empty());
    CompactionJob compaction_job(
-        job_context->job_id, c.get(), immutable_db_options_,
-        env_options_for_compaction_, versions_.get(), &shutting_down_,
-        preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
+        job_context->job_id, c.get(), immutable_db_options_, env_options_,
+        versions_.get(), &shutting_down_, log_buffer, directories_.GetDbDir(),
        directories_.GetDataDir(c->output_path_id()), stats_, &mutex_,
        &bg_error_, snapshot_seqs, earliest_write_conflict_snapshot,
-        snapshot_checker, table_cache_, &event_logger_,
+        table_cache_, &event_logger_,
        c->mutable_cf_options()->paranoid_file_checks,
        c->mutable_cf_options()->report_bg_io_stats, dbname_,
        &compaction_job_stats);
@@ -1711,9 +1689,8 @@ 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_context,
-          *c->mutable_cf_options());
+      InstallSuperVersionAndScheduleWorkWrapper(
+          c->column_family_data(), job_context, *c->mutable_cf_options());
    }
    *made_progress = true;
  }
@@ -1879,21 +1856,30 @@ bool DBImpl::MCOverlap(ManualCompactionState* m, ManualCompactionState* m1) {
  return true;
 }

-// SuperVersionContext gets created and destructed outside of the lock --
+// JobContext gets created and destructed outside of the lock --
 // we
 // use this convinently to:
 // * malloc one SuperVersion() outside of the lock -- new_superversion
 // * delete SuperVersion()s outside of the lock -- superversions_to_free
 //
 // However, if InstallSuperVersionAndScheduleWork() gets called twice with the
-// same sv_context, we can't reuse the SuperVersion() that got
+// same job_context, we can't reuse the SuperVersion() that got
 // malloced because
 // first call already used it. In that rare case, we take a hit and create a
 // new SuperVersion() inside of the mutex. We do similar thing
 // for superversion_to_free
+void DBImpl::InstallSuperVersionAndScheduleWorkWrapper(
+    ColumnFamilyData* cfd, JobContext* job_context,
+    const MutableCFOptions& mutable_cf_options) {
+  mutex_.AssertHeld();
+  SuperVersion* old_superversion = InstallSuperVersionAndScheduleWork(
+      cfd, job_context->new_superversion, mutable_cf_options);
+  job_context->new_superversion = nullptr;
+  job_context->superversions_to_free.push_back(old_superversion);
+}

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

@@ -1905,11 +1891,8 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
                        old_sv->mutable_cf_options.max_write_buffer_number;
  }

-  if (sv_context->new_superversion == nullptr) {
-    sv_context->NewSuperVersion();
-  }
-  cfd->InstallSuperVersion(sv_context, &mutex_,
-                           mutable_cf_options);
+  auto* old = cfd->InstallSuperVersion(
+      new_sv ? new_sv : new SuperVersion(), &mutex_, mutable_cf_options);

  // Whenever we install new SuperVersion, we might need to issue new flushes or
  // compactions.
@@ -1922,14 +1905,6 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
      max_total_in_memory_state_ - old_memtable_size +
      mutable_cf_options.write_buffer_size *
      mutable_cf_options.max_write_buffer_number;
-}
-
-void DBImpl::SetSnapshotChecker(SnapshotChecker* snapshot_checker) {
-  InstrumentedMutexLock l(&mutex_);
-  // snapshot_checker_ should only set once. If we need to set it multiple
-  // times, we need to make sure the old one is not deleted while it is still
-  // using by a compaction job.
-  assert(!snapshot_checker_);
-  snapshot_checker_.reset(snapshot_checker);
+  return old;
 }
 }  // namespace rocksdb
@@ -19,10 +19,10 @@ uint64_t DBImpl::TEST_GetLevel0TotalSize() {
  return default_cf_handle_->cfd()->current()->storage_info()->NumLevelBytes(0);
 }

-void DBImpl::TEST_SwitchWAL() {
+void DBImpl::TEST_HandleWALFull() {
  WriteContext write_context;
  InstrumentedMutexLock l(&mutex_);
-  SwitchWAL(&write_context);
+  HandleWALFull(&write_context);
 }

 int64_t DBImpl::TEST_MaxNextLevelOverlappingBytes(
@@ -60,10 +60,6 @@ uint64_t DBImpl::TEST_Current_Manifest_FileNo() {
  return versions_->manifest_file_number();
 }

-uint64_t DBImpl::TEST_Current_Next_FileNo() {
-  return versions_->current_next_file_number();
-}
-
 Status DBImpl::TEST_CompactRange(int level, const Slice* begin,
                                 const Slice* end,
                                 ColumnFamilyHandle* column_family,
@@ -209,13 +205,5 @@ int DBImpl::TEST_BGFlushesAllowed() const {
  return GetBGJobLimits().max_flushes;
 }

-SequenceNumber DBImpl::TEST_GetLatestVisibleSequenceNumber() const {
-  if (concurrent_prepare_ && seq_per_batch_) {
-    return versions_->LastToBeWrittenSequence();
-  } else {
-    return versions_->LastSequence();
-  }
-}
-
 }  // namespace rocksdb
 #endif  // NDEBUG
@@ -30,10 +30,10 @@ Status DBImpl::SuggestCompactRange(ColumnFamilyHandle* column_family,
  auto cfd = cfh->cfd();
  InternalKey start_key, end_key;
  if (begin != nullptr) {
-    start_key.SetMinPossibleForUserKey(*begin);
+    start_key.SetMaxPossibleForUserKey(*begin);
  }
  if (end != nullptr) {
-    end_key.SetMaxPossibleForUserKey(*end);
+    end_key.SetMinPossibleForUserKey(*end);
  }
  {
    InstrumentedMutexLock l(&mutex_);
@@ -138,9 +138,8 @@ Status DBImpl::PromoteL0(ColumnFamilyHandle* column_family, int target_level) {
    status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                    &edit, &mutex_, directories_.GetDbDir());
    if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(
-          cfd, &job_context.superversion_context,
-          *cfd->GetLatestMutableCFOptions());
+      InstallSuperVersionAndScheduleWorkWrapper(
+          cfd, &job_context, *cfd->GetLatestMutableCFOptions());
    }
  }  // lock released here
  LogFlush(immutable_db_options_.info_log);
@@ -48,7 +48,6 @@ uint64_t DBImpl::FindMinPrepLogReferencedByMemTable() {
  return min_log;
 }

-// TODO(myabandeh): Avoid using locks
 void DBImpl::MarkLogAsHavingPrepSectionFlushed(uint64_t log) {
  assert(log != 0);
  std::lock_guard<std::mutex> lock(prep_heap_mutex_);
@@ -57,7 +56,6 @@ void DBImpl::MarkLogAsHavingPrepSectionFlushed(uint64_t log) {
  it->second += 1;
 }

-// TODO(myabandeh): Avoid using locks
 void DBImpl::MarkLogAsContainingPrepSection(uint64_t log) {
  assert(log != 0);
  std::lock_guard<std::mutex> lock(prep_heap_mutex_);
@@ -302,10 +300,9 @@ bool CompareCandidateFile(const JobContext::CandidateFileInfo& first,
 };  // namespace

 // Delete obsolete files and log status and information of file deletion
-void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
-                                    FileType type, uint64_t number,
-                                    uint32_t path_id) {
-  Status file_deletion_status;
+void DBImpl::DeleteObsoleteFileImpl(Status file_deletion_status, int job_id,
+                                    const std::string& fname, FileType type,
+                                    uint64_t number, uint32_t path_id) {
  if (type == kTableFile) {
    file_deletion_status =
        DeleteSSTFile(&immutable_db_options_, fname, path_id);
@@ -491,7 +488,8 @@ void DBImpl::PurgeObsoleteFiles(const JobContext& state, bool schedule_only) {
      InstrumentedMutexLock guard_lock(&mutex_);
      SchedulePendingPurge(fname, type, number, path_id, state.job_id);
    } else {
-      DeleteObsoleteFileImpl(state.job_id, fname, type, number, path_id);
+      DeleteObsoleteFileImpl(file_deletion_status, state.job_id, fname, type,
+                             number, path_id);
    }
  }

@@ -124,17 +124,6 @@ DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src) {
    result.avoid_flush_during_recovery = false;
  }

-#ifndef ROCKSDB_LITE
-  // When the DB is stopped, it's possible that there are some .trash files that
-  // were not deleted yet, when we open the DB we will find these .trash files
-  // and schedule them to be deleted (or delete immediately if SstFileManager
-  // was not used)
-  auto sfm = static_cast<SstFileManagerImpl*>(result.sst_file_manager.get());
-  for (size_t i = 0; i < result.db_paths.size(); i++) {
-    DeleteScheduler::CleanupDirectory(result.env, sfm, result.db_paths[i].path);
-  }
-#endif
-
  return result;
 }

@@ -504,12 +493,11 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
  bool stop_replay_by_wal_filter = false;
  bool stop_replay_for_corruption = false;
  bool flushed = false;
-  uint64_t corrupted_log_number = kMaxSequenceNumber;
  for (auto log_number : log_numbers) {
    // The previous incarnation may not have written any MANIFEST
    // records after allocating this log number.  So we manually
    // update the file number allocation counter in VersionSet.
-    versions_->MarkFileNumberUsed(log_number);
+    versions_->MarkFileNumberUsedDuringRecovery(log_number);
    // Open the log file
    std::string fname = LogFileName(immutable_db_options_.wal_dir, log_number);

@@ -591,11 +579,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
        // consecutive, we continue recovery despite corruption. This could
        // happen when we open and write to a corrupted DB, where sequence id
        // will start from the last sequence id we recovered.
-        if (sequence == *next_sequence ||
-            // With seq_per_batch_, if previous run was with concurrent_prepare_
-            // then gap in the sequence numbers is expected by the commits
-            // without prepares.
-            (seq_per_batch_ && sequence >= *next_sequence)) {
+        if (sequence == *next_sequence) {
          stop_replay_for_corruption = false;
        }
        if (stop_replay_for_corruption) {
@@ -690,7 +674,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
      status = WriteBatchInternal::InsertInto(
          &batch, column_family_memtables_.get(), &flush_scheduler_, true,
          log_number, this, false /* concurrent_memtable_writes */,
-          next_sequence, &has_valid_writes, seq_per_batch_);
+          next_sequence, &has_valid_writes);
      MaybeIgnoreError(&status);
      if (!status.ok()) {
        // We are treating this as a failure while reading since we read valid
@@ -736,7 +720,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
        // We should ignore the error but not continue replaying
        status = Status::OK();
        stop_replay_for_corruption = true;
-        corrupted_log_number = log_number;
        ROCKS_LOG_INFO(immutable_db_options_.info_log,
                       "Point in time recovered to log #%" PRIu64
                       " seq #%" PRIu64,
@@ -758,25 +741,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
      versions_->SetLastSequence(last_sequence);
    }
  }
-  // Compare the corrupted log number to all columnfamily's current log number.
-  // Abort Open() if any column family's log number is greater than
-  // the corrupted log number, which means CF contains data beyond the point of
-  // corruption. This could during PIT recovery when the WAL is corrupted and
-  // some (but not all) CFs are flushed
-  if (stop_replay_for_corruption == true &&
-      (immutable_db_options_.wal_recovery_mode ==
-           WALRecoveryMode::kPointInTimeRecovery ||
-       immutable_db_options_.wal_recovery_mode ==
-           WALRecoveryMode::kTolerateCorruptedTailRecords)) {
-    for (auto cfd : *versions_->GetColumnFamilySet()) {
-      if (cfd->GetLogNumber() > corrupted_log_number) {
-        ROCKS_LOG_ERROR(immutable_db_options_.info_log,
-                        "Column family inconsistency: SST file contains data"
-                        " beyond the point of corruption.");
-        return Status::Corruption("SST file is ahead of WALs");
-      }
-    }
-  }

  // True if there's any data in the WALs; if not, we can skip re-processing
  // them later
@@ -832,7 +796,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
      // not actually used. that is because VersionSet assumes
      // VersionSet::next_file_number_ always to be strictly greater than any
      // log number
-      versions_->MarkFileNumberUsed(max_log_number + 1);
+      versions_->MarkFileNumberUsedDuringRecovery(max_log_number + 1);
      status = versions_->LogAndApply(
          cfd, *cfd->GetLatestMutableCFOptions(), edit, &mutex_);
      if (!status.ok()) {
@@ -898,17 +862,16 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
      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();
-      }
+
+      EnvOptions optimized_env_options =
+          env_->OptimizeForCompactionTableWrite(env_options_, immutable_db_options_);
      s = BuildTable(
          dbname_, env_, *cfd->ioptions(), mutable_cf_options,
-          env_options_for_compaction_, cfd->table_cache(), iter.get(),
+          optimized_env_options, cfd->table_cache(), iter.get(),
          std::unique_ptr<InternalIterator>(mem->NewRangeTombstoneIterator(ro)),
          &meta, cfd->internal_comparator(),
          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
-          snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
+          snapshot_seqs, earliest_write_conflict_snapshot,
          GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
          cfd->ioptions()->compression_opts, paranoid_file_checks,
          cfd->internal_stats(), TableFileCreationReason::kRecovery,
@@ -1064,12 +1027,10 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
      }
    }
    if (s.ok()) {
-      SuperVersionContext sv_context(/* create_superversion */ true);
      for (auto cfd : *impl->versions_->GetColumnFamilySet()) {
-        impl->InstallSuperVersionAndScheduleWork(
-            cfd, &sv_context, *cfd->GetLatestMutableCFOptions());
+        delete impl->InstallSuperVersionAndScheduleWork(
+            cfd, nullptr, *cfd->GetLatestMutableCFOptions());
      }
-      sv_context.Clean();
      if (impl->concurrent_prepare_) {
        impl->log_write_mutex_.Lock();
      }
@@ -57,7 +57,6 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& read_options,
  auto cfd = cfh->cfd();
  SuperVersion* super_version = cfd->GetSuperVersion()->Ref();
  SequenceNumber latest_snapshot = versions_->LastSequence();
-  ReadCallback* read_callback = nullptr;  // No read callback provided.
  auto db_iter = NewArenaWrappedDbIterator(
      env_, read_options, *cfd->ioptions(),
      (read_options.snapshot != nullptr
@@ -65,7 +64,7 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& read_options,
                 ->number_
           : latest_snapshot),
      super_version->mutable_cf_options.max_sequential_skip_in_iterations,
-      super_version->version_number, read_callback);
+      super_version->version_number);
  auto internal_iter =
      NewInternalIterator(read_options, cfd, super_version, db_iter->GetArena(),
                          db_iter->GetRangeDelAggregator());
@@ -77,7 +76,6 @@ Status DBImplReadOnly::NewIterators(
    const ReadOptions& read_options,
    const std::vector<ColumnFamilyHandle*>& column_families,
    std::vector<Iterator*>* iterators) {
-  ReadCallback* read_callback = nullptr;  // No read callback provided.
  if (iterators == nullptr) {
    return Status::InvalidArgument("iterators not allowed to be nullptr");
  }
@@ -95,7 +93,7 @@ Status DBImplReadOnly::NewIterators(
                   ->number_
             : latest_snapshot),
        sv->mutable_cf_options.max_sequential_skip_in_iterations,
-        sv->version_number, read_callback);
+        sv->version_number);
    auto* internal_iter =
        NewInternalIterator(read_options, cfd, sv, db_iter->GetArena(),
                            db_iter->GetRangeDelAggregator());
@@ -142,7 +140,6 @@ Status DB::OpenForReadOnly(
  *dbptr = nullptr;
  handles->clear();

-  SuperVersionContext sv_context(/* create_superversion */ true);
  DBImplReadOnly* impl = new DBImplReadOnly(db_options, dbname);
  impl->mutex_.Lock();
  Status s = impl->Recover(column_families, true /* read only */,
@@ -161,12 +158,10 @@ Status DB::OpenForReadOnly(
  }
  if (s.ok()) {
    for (auto cfd : *impl->versions_->GetColumnFamilySet()) {
-      sv_context.NewSuperVersion();
-      cfd->InstallSuperVersion(&sv_context, &impl->mutex_);
+      delete cfd->InstallSuperVersion(new SuperVersion(), &impl->mutex_);
    }
  }
  impl->mutex_.Unlock();
-  sv_context.Clean();
  if (s.ok()) {
    *dbptr = impl;
    for (auto* h : *handles) {
@@ -64,20 +64,10 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
  if (my_batch == nullptr) {
    return Status::Corruption("Batch is nullptr!");
  }
-  if (write_options.sync && write_options.disableWAL) {
-    return Status::InvalidArgument("Sync writes has to enable WAL.");
-  }
  if (concurrent_prepare_ && immutable_db_options_.enable_pipelined_write) {
    return Status::NotSupported(
        "pipelined_writes is not compatible with concurrent prepares");
  }
-  if (seq_per_batch_ && immutable_db_options_.enable_pipelined_write) {
-    return Status::NotSupported(
-        "pipelined_writes is not compatible with seq_per_batch");
-  }
-  // Otherwise IsLatestPersistentState optimization does not make sense
-  assert(!WriteBatchInternal::IsLatestPersistentState(my_batch) ||
-         disable_memtable);

  Status status;
  if (write_options.low_pri) {
@@ -118,7 +108,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
      w.status = WriteBatchInternal::InsertInto(
          &w, w.sequence, &column_family_memtables, &flush_scheduler_,
          write_options.ignore_missing_column_families, 0 /*log_number*/, this,
-          true /*concurrent_memtable_writes*/, seq_per_batch_);
+          true /*concurrent_memtable_writes*/);
    }

    if (write_thread_.CompleteParallelMemTableWriter(&w)) {
@@ -160,7 +150,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,

  mutex_.Lock();

-  bool need_log_sync = write_options.sync;
+  bool need_log_sync = !write_options.disableWAL && write_options.sync;
  bool need_log_dir_sync = need_log_sync && !log_dir_synced_;
  if (!concurrent_prepare_ || !disable_memtable) {
    // With concurrent writes we do preprocess only in the write thread that
@@ -194,7 +184,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // more than once to a particular key.
    bool parallel = immutable_db_options_.allow_concurrent_memtable_write &&
                    write_group.size > 1;
-    size_t total_count = 0;
+    int total_count = 0;
    uint64_t total_byte_size = 0;
    for (auto* writer : write_group) {
      if (writer->CheckCallback(this)) {
@@ -207,7 +197,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
            total_byte_size, WriteBatchInternal::ByteSize(writer->batch));
      }
    }
-    size_t seq_inc = seq_per_batch_ ? write_group.size : total_count;

    const bool concurrent_update = concurrent_prepare_;
    // Update stats while we are an exclusive group leader, so we know
@@ -249,15 +238,15 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
        // LastToBeWrittenSequence is increased inside WriteToWAL under
        // wal_write_mutex_ to ensure ordered events in WAL
        status = ConcurrentWriteToWAL(write_group, log_used, &last_sequence,
-                                      seq_inc);
+                                      total_count);
      } else {
        // Otherwise we inc seq number for memtable writes
-        last_sequence = versions_->FetchAddLastToBeWrittenSequence(seq_inc);
+        last_sequence = versions_->FetchAddLastToBeWrittenSequence(total_count);
      }
    }
    assert(last_sequence != kMaxSequenceNumber);
    const SequenceNumber current_sequence = last_sequence + 1;
-    last_sequence += seq_inc;
+    last_sequence += total_count;

    if (status.ok()) {
      PERF_TIMER_GUARD(write_memtable_time);
@@ -266,14 +255,12 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
        w.status = WriteBatchInternal::InsertInto(
            write_group, current_sequence, column_family_memtables_.get(),
            &flush_scheduler_, write_options.ignore_missing_column_families,
-            0 /*recovery_log_number*/, this, parallel, seq_per_batch_);
+            0 /*recovery_log_number*/, this);
      } else {
        SequenceNumber next_sequence = current_sequence;
        for (auto* writer : write_group) {
-          writer->sequence = next_sequence;
-          if (seq_per_batch_) {
-            next_sequence++;
-          } else if (writer->ShouldWriteToMemtable()) {
+          if (writer->ShouldWriteToMemtable()) {
+            writer->sequence = next_sequence;
            next_sequence += WriteBatchInternal::Count(writer->batch);
          }
        }
@@ -292,11 +279,11 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
          w.status = WriteBatchInternal::InsertInto(
              &w, w.sequence, &column_family_memtables, &flush_scheduler_,
              write_options.ignore_missing_column_families, 0 /*log_number*/,
-              this, true /*concurrent_memtable_writes*/, seq_per_batch_);
+              this, true /*concurrent_memtable_writes*/);
+        }
+        if (seq_used != nullptr) {
+          *seq_used = w.sequence;
        }
-      }
-      if (seq_used != nullptr) {
-        *seq_used = w.sequence;
      }
    }
  }
@@ -398,7 +385,6 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    RecordTick(stats_, NUMBER_KEYS_WRITTEN, total_count);
    stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size);
    RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
-    MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);

    PERF_TIMER_STOP(write_pre_and_post_process_time);

@@ -440,7 +426,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
      memtable_write_group.status = WriteBatchInternal::InsertInto(
          memtable_write_group, w.sequence, column_family_memtables_.get(),
          &flush_scheduler_, write_options.ignore_missing_column_families,
-          0 /*log_number*/, this, seq_per_batch_);
+          0 /*log_number*/, this);
      versions_->SetLastSequence(memtable_write_group.last_sequence);
      write_thread_.ExitAsMemTableWriter(&w, memtable_write_group);
    }
@@ -534,16 +520,12 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
  PERF_TIMER_GUARD(write_wal_time);
  // LastToBeWrittenSequence is increased inside WriteToWAL under
  // wal_write_mutex_ to ensure ordered events in WAL
-  size_t seq_inc = seq_per_batch_ ? write_group.size : 0 /*total_count*/;
-  status = ConcurrentWriteToWAL(write_group, log_used, &last_sequence, seq_inc);
+  status = ConcurrentWriteToWAL(write_group, log_used, &last_sequence,
+                                0 /*total_count*/);
  auto curr_seq = last_sequence + 1;
  for (auto* writer : write_group) {
    if (writer->CheckCallback(this)) {
      writer->sequence = curr_seq;
-    }
-    if (seq_per_batch_) {
-      curr_seq++;
-    } else if (writer->CheckCallback(this)) {
      curr_seq += WriteBatchInternal::Count(writer->batch);
    }
  }
@@ -623,7 +605,7 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
         versions_->GetColumnFamilySet()->NumberOfColumnFamilies() == 1);
  if (UNLIKELY(status.ok() && !single_column_family_mode_ &&
               total_log_size_ > GetMaxTotalWalSize())) {
-    status = SwitchWAL(write_context);
+    status = HandleWALFull(write_context);
  }

  if (UNLIKELY(status.ok() && write_buffer_manager_->ShouldFlush())) {
@@ -681,11 +663,9 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
 }

 WriteBatch* DBImpl::MergeBatch(const WriteThread::WriteGroup& write_group,
-                               WriteBatch* tmp_batch, size_t* write_with_wal,
-                               WriteBatch** to_be_cached_state) {
+                               WriteBatch* tmp_batch, size_t* write_with_wal) {
  assert(write_with_wal != nullptr);
  assert(tmp_batch != nullptr);
-  assert(*to_be_cached_state == nullptr);
  WriteBatch* merged_batch = nullptr;
  *write_with_wal = 0;
  auto* leader = write_group.leader;
@@ -695,9 +675,6 @@ WriteBatch* DBImpl::MergeBatch(const WriteThread::WriteGroup& write_group,
    // contains one batch, that batch should be written to the WAL,
    // and the batch is not wanting to be truncated
    merged_batch = leader->batch;
-    if (WriteBatchInternal::IsLatestPersistentState(merged_batch)) {
-      *to_be_cached_state = merged_batch;
-    }
    *write_with_wal = 1;
  } else {
    // WAL needs all of the batches flattened into a single batch.
@@ -708,10 +685,6 @@ WriteBatch* DBImpl::MergeBatch(const WriteThread::WriteGroup& write_group,
      if (writer->ShouldWriteToWAL()) {
        WriteBatchInternal::Append(merged_batch, writer->batch,
                                   /*WAL_only*/ true);
-        if (WriteBatchInternal::IsLatestPersistentState(writer->batch)) {
-          // We only need to cache the last of such write batch
-          *to_be_cached_state = writer->batch;
-        }
        (*write_with_wal)++;
      }
    }
@@ -746,9 +719,8 @@ Status DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
  Status status;

  size_t write_with_wal = 0;
-  WriteBatch* to_be_cached_state = nullptr;
-  WriteBatch* merged_batch = MergeBatch(write_group, &tmp_batch_,
-                                        &write_with_wal, &to_be_cached_state);
+  WriteBatch* merged_batch =
+      MergeBatch(write_group, &tmp_batch_, &write_with_wal);
  if (merged_batch == write_group.leader->batch) {
    write_group.leader->log_used = logfile_number_;
  } else if (write_with_wal > 1) {
@@ -761,10 +733,6 @@ Status DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,

  uint64_t log_size;
  status = WriteToWAL(*merged_batch, log_writer, log_used, &log_size);
-  if (to_be_cached_state) {
-    cached_recoverable_state_ = *to_be_cached_state;
-      cached_recoverable_state_empty_ = false;
-  }

  if (status.ok() && need_log_sync) {
    StopWatch sw(env_, stats_, WAL_FILE_SYNC_MICROS);
@@ -809,14 +777,13 @@ Status DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
 Status DBImpl::ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
                                    uint64_t* log_used,
                                    SequenceNumber* last_sequence,
-                                    size_t seq_inc) {
+                                    int total_count) {
  Status status;

  WriteBatch tmp_batch;
  size_t write_with_wal = 0;
-  WriteBatch* to_be_cached_state = nullptr;
  WriteBatch* merged_batch =
-      MergeBatch(write_group, &tmp_batch, &write_with_wal, &to_be_cached_state);
+      MergeBatch(write_group, &tmp_batch, &write_with_wal);

  // We need to lock log_write_mutex_ since logs_ and alive_log_files might be
  // pushed back concurrently
@@ -828,17 +795,13 @@ Status DBImpl::ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
      writer->log_used = logfile_number_;
    }
  }
-  *last_sequence = versions_->FetchAddLastToBeWrittenSequence(seq_inc);
+  *last_sequence = versions_->FetchAddLastToBeWrittenSequence(total_count);
  auto sequence = *last_sequence + 1;
  WriteBatchInternal::SetSequence(merged_batch, sequence);

  log::Writer* log_writer = logs_.back().writer;
  uint64_t log_size;
  status = WriteToWAL(*merged_batch, log_writer, log_used, &log_size);
-  if (to_be_cached_state) {
-    cached_recoverable_state_ = *to_be_cached_state;
-      cached_recoverable_state_empty_ = false;
-  }
  log_write_mutex_.Unlock();

  if (status.ok()) {
@@ -853,35 +816,7 @@ Status DBImpl::ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
  return status;
 }

-Status DBImpl::WriteRecoverableState() {
-  mutex_.AssertHeld();
-  if (!cached_recoverable_state_empty_) {
-    bool dont_care_bool;
-    SequenceNumber next_seq;
-    if (concurrent_prepare_) {
-      log_write_mutex_.Lock();
-    }
-    SequenceNumber seq = versions_->LastSequence();
-    WriteBatchInternal::SetSequence(&cached_recoverable_state_, ++seq);
-    auto status = WriteBatchInternal::InsertInto(
-        &cached_recoverable_state_, column_family_memtables_.get(),
-        &flush_scheduler_, true, 0 /*recovery_log_number*/, this,
-        false /* concurrent_memtable_writes */, &next_seq, &dont_care_bool,
-        seq_per_batch_);
-    versions_->SetLastSequence(--next_seq);
-    if (concurrent_prepare_) {
-      log_write_mutex_.Unlock();
-    }
-    if (status.ok()) {
-      cached_recoverable_state_.Clear();
-      cached_recoverable_state_empty_ = true;
-    }
-    return status;
-  }
-  return Status::OK();
-}
-
-Status DBImpl::SwitchWAL(WriteContext* write_context) {
+Status DBImpl::HandleWALFull(WriteContext* write_context) {
  mutex_.AssertHeld();
  assert(write_context != nullptr);
  Status status;
@@ -1119,13 +1054,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  log::Writer* new_log = nullptr;
  MemTable* new_mem = nullptr;

-  // Recoverable state is persisted in WAL. After memtable switch, WAL might
-  // be deleted, so we write the state to memtable to be persisted as well.
-  Status s = WriteRecoverableState();
-  if (!s.ok()) {
-    return s;
-  }
-
  // In case of pipelined write is enabled, wait for all pending memtable
  // writers.
  if (immutable_db_options_.enable_pipelined_write) {
@@ -1150,6 +1078,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  }
  uint64_t new_log_number =
      creating_new_log ? versions_->NewFileNumber() : logfile_number_;
+  SuperVersion* new_superversion = nullptr;
  const MutableCFOptions mutable_cf_options = *cfd->GetLatestMutableCFOptions();

  // Set memtable_info for memtable sealed callback
@@ -1169,6 +1098,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  const auto preallocate_block_size =
    GetWalPreallocateBlockSize(mutable_cf_options.write_buffer_size);
  mutex_.Unlock();
+  Status s;
  {
    if (creating_new_log) {
      EnvOptions opt_env_opt =
@@ -1204,7 +1134,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
    if (s.ok()) {
      SequenceNumber seq = versions_->LastSequence();
      new_mem = cfd->ConstructNewMemtable(mutable_cf_options, seq);
-      context->superversion_context.NewSuperVersion();
+      new_superversion = new SuperVersion();
    }

 #ifndef ROCKSDB_LITE
@@ -1262,8 +1192,8 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
  cfd->imm()->Add(cfd->mem(), &context->memtables_to_free_);
  new_mem->Ref();
  cfd->SetMemtable(new_mem);
-  InstallSuperVersionAndScheduleWork(cfd, &context->superversion_context,
-                                     mutable_cf_options);
+  context->superversions_to_free_.push_back(InstallSuperVersionAndScheduleWork(
+      cfd, new_superversion, mutable_cf_options));
  if (concurrent_prepare_) {
    nonmem_write_thread_.ExitUnbatched(&nonmem_w);
  }
@@ -9,7 +9,6 @@

 #include "db/db_iter.h"
 #include <string>
-#include <iostream>
 #include <limits>

 #include "db/dbformat.h"
@@ -48,7 +47,7 @@ static void DumpInternalIter(Iterator* iter) {
 // combines multiple entries for the same userkey found in the DB
 // representation into a single entry while accounting for sequence
 // numbers, deletion markers, overwrites, etc.
-class DBIter final: public Iterator {
+class DBIter: public Iterator {
 public:
  // The following is grossly complicated. TODO: clean it up
  // Which direction is the iterator currently moving?
@@ -103,8 +102,7 @@ class DBIter final: public Iterator {
  DBIter(Env* _env, const ReadOptions& read_options,
         const ImmutableCFOptions& cf_options, const Comparator* cmp,
         InternalIterator* iter, SequenceNumber s, bool arena_mode,
-         uint64_t max_sequential_skip_in_iterations,
-         ReadCallback* read_callback, bool allow_blob)
+         uint64_t max_sequential_skip_in_iterations, bool allow_blob)
      : arena_mode_(arena_mode),
        env_(_env),
        logger_(cf_options.info_log),
@@ -116,18 +114,13 @@ class DBIter final: public Iterator {
        valid_(false),
        current_entry_is_merged_(false),
        statistics_(cf_options.statistics),
-        num_internal_keys_skipped_(0),
-        iterate_lower_bound_(read_options.iterate_lower_bound),
        iterate_upper_bound_(read_options.iterate_upper_bound),
        prefix_same_as_start_(read_options.prefix_same_as_start),
        pin_thru_lifetime_(read_options.pin_data),
        total_order_seek_(read_options.total_order_seek),
        range_del_agg_(cf_options.internal_comparator, s,
                       true /* collapse_deletions */),
-        read_callback_(read_callback),
-        allow_blob_(allow_blob),
-        is_blob_(false),
-        start_seqnum_(read_options.iter_start_seqnum) {
+        allow_blob_(allow_blob) {
    RecordTick(statistics_, NO_ITERATORS);
    prefix_extractor_ = cf_options.prefix_extractor;
    max_skip_ = max_sequential_skip_in_iterations;
@@ -144,9 +137,7 @@ class DBIter final: public Iterator {
    if (pinned_iters_mgr_.PinningEnabled()) {
      pinned_iters_mgr_.ReleasePinnedData();
    }
-    // Compiler warning issue filed:
-    // https://github.com/facebook/rocksdb/issues/3013
-    RecordTick(statistics_, NO_ITERATORS, uint64_t(-1));
+    RecordTick(statistics_, NO_ITERATORS, -1);
    local_stats_.BumpGlobalStatistics(statistics_);
    if (!arena_mode_) {
      delete iter_;
@@ -166,12 +157,7 @@ class DBIter final: public Iterator {
  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();
-    }
-
+    return saved_key_.GetUserKey();
  }
  virtual Slice value() const override {
    assert(valid_);
@@ -240,7 +226,6 @@ class DBIter final: public Iterator {
  bool ParseKey(ParsedInternalKey* key);
  void MergeValuesNewToOld();
  bool TooManyInternalKeysSkipped(bool increment = true);
-  bool IsVisible(SequenceNumber sequence);

  // Temporarily pin the blocks that we encounter until ReleaseTempPinnedData()
  // is called
@@ -281,10 +266,6 @@ class DBIter final: public Iterator {

  Status status_;
  IterKey saved_key_;
-  // Reusable internal key data structure. This is only used inside one function
-  // and should not be used across functions. Reusing this object can reduce
-  // overhead of calling construction of the function if creating it each time.
-  ParsedInternalKey ikey_;
  std::string saved_value_;
  Slice pinned_value_;
  Direction direction_;
@@ -295,7 +276,6 @@ class DBIter final: public Iterator {
  uint64_t max_skip_;
  uint64_t max_skippable_internal_keys_;
  uint64_t num_internal_keys_skipped_;
-  const Slice* iterate_lower_bound_;
  const Slice* iterate_upper_bound_;
  IterKey prefix_start_buf_;
  Slice prefix_start_key_;
@@ -309,12 +289,8 @@ class DBIter final: public Iterator {
  RangeDelAggregator range_del_agg_;
  LocalStatistics local_stats_;
  PinnedIteratorsManager pinned_iters_mgr_;
-  ReadCallback* read_callback_;
  bool allow_blob_;
  bool is_blob_;
-  // for diff snapshots we want the lower bound on the seqnum;
-  // if this value > 0 iterator will return internal keys
-  SequenceNumber start_seqnum_;

  // No copying allowed
  DBIter(const DBIter&);
@@ -407,20 +383,22 @@ void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
  is_blob_ = false;

  do {
-    if (!ParseKey(&ikey_)) {
+    ParsedInternalKey ikey;
+
+    if (!ParseKey(&ikey)) {
      // Skip corrupted keys.
      iter_->Next();
      continue;
    }

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

    if (prefix_extractor_ && prefix_check &&
-        prefix_extractor_->Transform(ikey_.user_key)
-                .compare(prefix_start_key_) != 0) {
+        prefix_extractor_->Transform(ikey.user_key)
+          .compare(prefix_start_key_) != 0) {
      break;
    }

@@ -428,91 +406,62 @@ void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
      return;
    }

-    if (IsVisible(ikey_.sequence)) {
-      if (skipping && user_comparator_->Compare(ikey_.user_key,
-                                                saved_key_.GetUserKey()) <= 0) {
+    if (ikey.sequence <= sequence_) {
+      if (skipping &&
+          user_comparator_->Compare(ikey.user_key, saved_key_.GetUserKey()) <=
+              0) {
        num_skipped++;  // skip this entry
        PERF_COUNTER_ADD(internal_key_skipped_count, 1);
      } else {
        num_skipped = 0;
-        switch (ikey_.type) {
+        switch (ikey.type) {
          case kTypeDeletion:
          case kTypeSingleDeletion:
            // Arrange to skip all upcoming entries for this key since
            // they are hidden by this deletion.
-            // if iterartor specified start_seqnum we
-            // 1) return internal key, including the type
-            // 2) return ikey only if ikey.seqnum >= start_seqnum_
-            // not that if deletion seqnum is < start_seqnum_ we
-            // just skip it like in normal iterator.
-            if (start_seqnum_ > 0 && ikey_.sequence >= start_seqnum_)  {
-              saved_key_.SetInternalKey(ikey_);
-              valid_=true;
-              return;
-            } else {
-              saved_key_.SetUserKey(
-                ikey_.user_key,
-                !pin_thru_lifetime_ || !iter_->IsKeyPinned() /* copy */);
-                skipping = true;
-                PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-            }
+            saved_key_.SetUserKey(
+                ikey.user_key,
+                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
+            skipping = true;
+            PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
            break;
          case kTypeValue:
          case kTypeBlobIndex:
-            if (start_seqnum_ > 0) {
-              // we are taking incremental snapshot here
-              // incremental snapshots aren't supported on DB with range deletes
-              assert(!(
-                (ikey_.type == kTypeBlobIndex) && (start_seqnum_ > 0)
-              ));
-              if (ikey_.sequence >= start_seqnum_) {
-                saved_key_.SetInternalKey(ikey_);
-                valid_ = true;
-                return;
+            saved_key_.SetUserKey(
+                ikey.user_key,
+                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
+            if (range_del_agg_.ShouldDelete(
+                    ikey, RangeDelAggregator::RangePositioningMode::
+                              kForwardTraversal)) {
+              // Arrange to skip all upcoming entries for this key since
+              // they are hidden by this deletion.
+              skipping = true;
+              num_skipped = 0;
+              PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
+            } else if (ikey.type == kTypeBlobIndex) {
+              if (!allow_blob_) {
+                ROCKS_LOG_ERROR(logger_, "Encounter unexpected blob index.");
+                status_ = Status::NotSupported(
+                    "Encounter unexpected blob index. Please open DB with "
+                    "rocksdb::blob_db::BlobDB instead.");
+                valid_ = false;
              } else {
-                // this key and all previous versions shouldn't be included,
-                // skipping
-                saved_key_.SetUserKey(ikey_.user_key,
-                  !pin_thru_lifetime_ || !iter_->IsKeyPinned() /* copy */);
-                skipping = true;
+                is_blob_ = true;
+                valid_ = true;
              }
+              return;
            } else {
-              saved_key_.SetUserKey(
-                  ikey_.user_key,
-                  !pin_thru_lifetime_ || !iter_->IsKeyPinned() /* copy */);
-              if (range_del_agg_.ShouldDelete(
-                      ikey_, RangeDelAggregator::RangePositioningMode::
-                                 kForwardTraversal)) {
-                // Arrange to skip all upcoming entries for this key since
-                // they are hidden by this deletion.
-                skipping = true;
-                num_skipped = 0;
-                PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-              } else if (ikey_.type == kTypeBlobIndex) {
-                if (!allow_blob_) {
-                  ROCKS_LOG_ERROR(logger_, "Encounter unexpected blob index.");
-                  status_ = Status::NotSupported(
-                      "Encounter unexpected blob index. Please open DB with "
-                      "rocksdb::blob_db::BlobDB instead.");
-                  valid_ = false;
-                } else {
-                  is_blob_ = true;
-                  valid_ = true;
-                }
-                return;
-              } else {
-                valid_ = true;
-                return;
-              }
+              valid_ = true;
+              return;
            }
            break;
          case kTypeMerge:
            saved_key_.SetUserKey(
-                ikey_.user_key,
-                !pin_thru_lifetime_ || !iter_->IsKeyPinned() /* copy */);
+                ikey.user_key,
+                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
            if (range_del_agg_.ShouldDelete(
-                    ikey_, RangeDelAggregator::RangePositioningMode::
-                               kForwardTraversal)) {
+                    ikey, RangeDelAggregator::RangePositioningMode::
+                              kForwardTraversal)) {
              // Arrange to skip all upcoming entries for this key since
              // they are hidden by this deletion.
              skipping = true;
@@ -538,12 +487,12 @@ void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {

      // Here saved_key_ may contain some old key, or the default empty key, or
      // key assigned by some random other method. We don't care.
-      if (user_comparator_->Compare(ikey_.user_key, saved_key_.GetUserKey()) <=
+      if (user_comparator_->Compare(ikey.user_key, saved_key_.GetUserKey()) <=
          0) {
        num_skipped++;
      } else {
        saved_key_.SetUserKey(
-            ikey_.user_key,
+            ikey.user_key,
            !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
        skipping = false;
        num_skipped = 0;
@@ -724,7 +673,7 @@ void DBIter::ReverseToBackward() {
           user_comparator_->Compare(ikey.user_key, saved_key_.GetUserKey()) >
               0) {
      assert(ikey.sequence != kMaxSequenceNumber);
-      if (!IsVisible(ikey.sequence)) {
+      if (ikey.sequence > sequence_) {
        PERF_COUNTER_ADD(internal_recent_skipped_count, 1);
      } else {
        PERF_COUNTER_ADD(internal_key_skipped_count, 1);
@@ -759,22 +708,6 @@ void DBIter::PrevInternal() {
        ExtractUserKey(iter_->key()),
        !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);

-    if (prefix_extractor_ && prefix_same_as_start_ &&
-        prefix_extractor_->Transform(saved_key_.GetUserKey())
-                .compare(prefix_start_key_) != 0) {
-      // Current key does not have the same prefix as start
-      valid_ = false;
-      return;
-    }
-
-    if (iterate_lower_bound_ != nullptr &&
-        user_comparator_->Compare(saved_key_.GetUserKey(),
-                                  *iterate_lower_bound_) < 0) {
-      // We've iterated earlier than the user-specified lower bound.
-      valid_ = false;
-      return;
-    }
-
    if (FindValueForCurrentKey()) {
      if (!iter_->Valid()) {
        return;
@@ -783,6 +716,11 @@ void DBIter::PrevInternal() {
      if (user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
        FindPrevUserKey();
      }
+      if (valid_ && prefix_extractor_ && prefix_same_as_start_ &&
+          prefix_extractor_->Transform(saved_key_.GetUserKey())
+                  .compare(prefix_start_key_) != 0) {
+        valid_ = false;
+      }
      return;
    }

@@ -823,7 +761,7 @@ bool DBIter::FindValueForCurrentKey() {
  ReleaseTempPinnedData();
  TempPinData();
  size_t num_skipped = 0;
-  while (iter_->Valid() && IsVisible(ikey.sequence) &&
+  while (iter_->Valid() && ikey.sequence <= sequence_ &&
         user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
    if (TooManyInternalKeysSkipped()) {
      return false;
@@ -1062,7 +1000,7 @@ void DBIter::FindPrevUserKey() {
  while (iter_->Valid() &&
         ((cmp = user_comparator_->Compare(ikey.user_key,
                                           saved_key_.GetUserKey())) == 0 ||
-          (cmp > 0 && !IsVisible(ikey.sequence)))) {
+          (cmp > 0 && ikey.sequence > sequence_))) {
    if (TooManyInternalKeysSkipped()) {
      return;
    }
@@ -1080,7 +1018,7 @@ void DBIter::FindPrevUserKey() {
      }
    }
    assert(ikey.sequence != kMaxSequenceNumber);
-    if (!IsVisible(ikey.sequence)) {
+    if (ikey.sequence > sequence_) {
      PERF_COUNTER_ADD(internal_recent_skipped_count, 1);
    } else {
      PERF_COUNTER_ADD(internal_key_skipped_count, 1);
@@ -1102,11 +1040,6 @@ bool DBIter::TooManyInternalKeysSkipped(bool increment) {
  return false;
 }

-bool DBIter::IsVisible(SequenceNumber sequence) {
-  return sequence <= sequence_ &&
-         (read_callback_ == nullptr || read_callback_->IsCommitted(sequence));
-}
-
 // Skip all unparseable keys
 void DBIter::FindParseableKey(ParsedInternalKey* ikey, Direction direction) {
  while (iter_->Valid() && !ParseKey(ikey)) {
@@ -1206,10 +1139,6 @@ void DBIter::SeekToFirst() {
  if (prefix_extractor_ != nullptr) {
    max_skip_ = std::numeric_limits<uint64_t>::max();
  }
-  if (iterate_lower_bound_ != nullptr) {
-    Seek(*iterate_lower_bound_);
-    return;
-  }
  direction_ = kForward;
  ReleaseTempPinnedData();
  ResetInternalKeysSkippedCounter();
@@ -1295,11 +1224,10 @@ Iterator* NewDBIterator(Env* env, const ReadOptions& read_options,
                        InternalIterator* internal_iter,
                        const SequenceNumber& sequence,
                        uint64_t max_sequential_skip_in_iterations,
-                        ReadCallback* read_callback, bool allow_blob) {
-  DBIter* db_iter =
-      new DBIter(env, read_options, cf_options, user_key_comparator,
-                 internal_iter, sequence, false,
-                 max_sequential_skip_in_iterations, read_callback, allow_blob);
+                        bool allow_blob) {
+  DBIter* db_iter = new DBIter(
+      env, read_options, cf_options, user_key_comparator, internal_iter,
+      sequence, false, max_sequential_skip_in_iterations, allow_blob);
  return db_iter;
 }

@@ -1344,13 +1272,11 @@ void ArenaWrappedDBIter::Init(Env* env, const ReadOptions& read_options,
                              const ImmutableCFOptions& cf_options,
                              const SequenceNumber& sequence,
                              uint64_t max_sequential_skip_in_iteration,
-                              uint64_t version_number,
-                              ReadCallback* read_callback, bool allow_blob) {
+                              uint64_t version_number, bool allow_blob) {
  auto mem = arena_.AllocateAligned(sizeof(DBIter));
  db_iter_ = new (mem)
      DBIter(env, read_options, cf_options, cf_options.user_comparator, nullptr,
-             sequence, true, max_sequential_skip_in_iteration, read_callback,
-             allow_blob);
+             sequence, true, max_sequential_skip_in_iteration, allow_blob);
  sv_number_ = version_number;
 }

@@ -1370,7 +1296,7 @@ Status ArenaWrappedDBIter::Refresh() {
    SuperVersion* sv = cfd_->GetReferencedSuperVersion(db_impl_->mutex());
    Init(env, read_options_, *(cfd_->ioptions()), latest_seq,
         sv->mutable_cf_options.max_sequential_skip_in_iterations,
-         cur_sv_number, read_callback_, allow_blob_);
+         cur_sv_number, allow_blob_);

    InternalIterator* internal_iter = db_impl_->NewInternalIterator(
        read_options_, cfd_, sv, &arena_, db_iter_->GetRangeDelAggregator());
@@ -1386,15 +1312,12 @@ ArenaWrappedDBIter* NewArenaWrappedDbIterator(
    Env* env, const ReadOptions& read_options,
    const ImmutableCFOptions& cf_options, const SequenceNumber& sequence,
    uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
-    ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
-    bool allow_blob) {
+    DBImpl* db_impl, ColumnFamilyData* cfd, bool allow_blob) {
  ArenaWrappedDBIter* iter = new ArenaWrappedDBIter();
  iter->Init(env, read_options, cf_options, sequence,
-             max_sequential_skip_in_iterations, version_number, read_callback,
-             allow_blob);
+             max_sequential_skip_in_iterations, version_number, allow_blob);
  if (db_impl != nullptr && cfd != nullptr) {
-    iter->StoreRefreshInfo(read_options, db_impl, cfd, read_callback,
-                           allow_blob);
+    iter->StoreRefreshInfo(read_options, db_impl, cfd, allow_blob);
  }

  return iter;
@@ -34,7 +34,6 @@ extern Iterator* NewDBIterator(Env* env, const ReadOptions& read_options,
                               InternalIterator* internal_iter,
                               const SequenceNumber& sequence,
                               uint64_t max_sequential_skip_in_iterations,
-                               ReadCallback* read_callback,
                               bool allow_blob = false);

 // A wrapper iterator which wraps DB Iterator and the arena, with which the DB
@@ -73,15 +72,13 @@ class ArenaWrappedDBIter : public Iterator {
            const ImmutableCFOptions& cf_options,
            const SequenceNumber& sequence,
            uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
-            ReadCallback* read_callback, bool allow_blob);
+            bool allow_blob);

  void StoreRefreshInfo(const ReadOptions& read_options, DBImpl* db_impl,
-                        ColumnFamilyData* cfd, ReadCallback* read_callback,
-                        bool allow_blob) {
+                        ColumnFamilyData* cfd, bool allow_blob) {
    read_options_ = read_options;
    db_impl_ = db_impl;
    cfd_ = cfd;
-    read_callback_ = read_callback;
    allow_blob_ = allow_blob;
  }

@@ -92,7 +89,6 @@ class ArenaWrappedDBIter : public Iterator {
  ColumnFamilyData* cfd_ = nullptr;
  DBImpl* db_impl_ = nullptr;
  ReadOptions read_options_;
-  ReadCallback* read_callback_;
  bool allow_blob_ = false;
 };

@@ -103,7 +99,7 @@ extern ArenaWrappedDBIter* NewArenaWrappedDbIterator(
    Env* env, const ReadOptions& read_options,
    const ImmutableCFOptions& cf_options, const SequenceNumber& sequence,
    uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
-    ReadCallback* read_callback, DBImpl* db_impl = nullptr,
-    ColumnFamilyData* cfd = nullptr, bool allow_blob = false);
+    DBImpl* db_impl = nullptr, ColumnFamilyData* cfd = nullptr,
+    bool allow_blob = false);

 }  // namespace rocksdb
@@ -191,9 +191,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -223,9 +223,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -249,9 +249,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -281,9 +281,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -316,9 +316,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(!db_iter->Valid());
@@ -345,9 +345,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 7,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      7, options.max_sequential_skip_in_iterations));

    SetPerfLevel(kEnableCount);
    ASSERT_TRUE(GetPerfLevel() == kEnableCount);
@@ -382,9 +382,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 4,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      4, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -407,9 +407,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(!db_iter->Valid());
@@ -429,9 +429,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -464,9 +464,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 7,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      7, options.max_sequential_skip_in_iterations));

    SetPerfLevel(kEnableCount);
    ASSERT_TRUE(GetPerfLevel() == kEnableCount);
@@ -493,9 +493,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -535,9 +535,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 2,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      2, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "b");
@@ -566,9 +566,9 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "c");
@@ -595,9 +595,9 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) {
    TestIterator* internal_iter = new TestIterator(BytewiseComparator());
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 0,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      0, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(!db_iter->Valid());
  }
@@ -606,9 +606,9 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) {
    TestIterator* internal_iter = new TestIterator(BytewiseComparator());
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 0,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      0, options.max_sequential_skip_in_iterations));
    db_iter->SeekToFirst();
    ASSERT_TRUE(!db_iter->Valid());
  }
@@ -628,10 +628,9 @@ TEST_F(DBIteratorTest, DBIteratorUseSkipCountSkips) {
  }
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 2, options.max_sequential_skip_in_iterations,
-                    nullptr /*read_callback*/));
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
+      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
+      internal_iter, 2, options.max_sequential_skip_in_iterations));
  db_iter->SeekToLast();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "c");
@@ -674,8 +673,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
      options.statistics = rocksdb::CreateDBStatistics();
      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, cf_options, BytewiseComparator(), internal_iter, i + 2,
-          options.max_sequential_skip_in_iterations,
-          nullptr /*read_callback*/));
+          options.max_sequential_skip_in_iterations));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -710,8 +708,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {

      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, cf_options, BytewiseComparator(), internal_iter, i + 2,
-          options.max_sequential_skip_in_iterations,
-          nullptr /*read_callback*/));
+          options.max_sequential_skip_in_iterations));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -739,8 +736,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {

      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, cf_options, BytewiseComparator(), internal_iter, 202,
-          options.max_sequential_skip_in_iterations,
-          nullptr /*read_callback*/));
+          options.max_sequential_skip_in_iterations));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -772,8 +768,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
      internal_iter->Finish();
      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, cf_options, BytewiseComparator(), internal_iter, i,
-          options.max_sequential_skip_in_iterations,
-          nullptr /*read_callback*/));
+          options.max_sequential_skip_in_iterations));
      db_iter->SeekToLast();
      ASSERT_TRUE(!db_iter->Valid());

@@ -787,9 +782,9 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
    }
    internal_iter->AddPut("c", "200");
    internal_iter->Finish();
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 200,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      200, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "c");
@@ -823,8 +818,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {

      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, cf_options, BytewiseComparator(), internal_iter, i + 2,
-          options.max_sequential_skip_in_iterations,
-          nullptr /*read_callback*/));
+          options.max_sequential_skip_in_iterations));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -858,8 +852,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {

      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, cf_options, BytewiseComparator(), internal_iter, i + 2,
-          options.max_sequential_skip_in_iterations,
-          nullptr /*read_callback*/));
+          options.max_sequential_skip_in_iterations));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -905,9 +898,9 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 0;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -951,9 +944,9 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -995,9 +988,9 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1033,9 +1026,9 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1068,9 +1061,9 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -1098,9 +1091,9 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1135,9 +1128,9 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1174,8 +1167,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
      ro.max_skippable_internal_keys = i;
      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, cf_options, BytewiseComparator(), internal_iter, 2 * i + 1,
-          options.max_sequential_skip_in_iterations,
-          nullptr /*read_callback*/));
+          options.max_sequential_skip_in_iterations));

      db_iter->SeekToFirst();
      ASSERT_TRUE(db_iter->Valid());
@@ -1228,8 +1220,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
      ro.max_skippable_internal_keys = i;
      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, cf_options, BytewiseComparator(), internal_iter, 2 * i + 1,
-          options.max_sequential_skip_in_iterations,
-          nullptr /*read_callback*/));
+          options.max_sequential_skip_in_iterations));

      db_iter->SeekToFirst();
      ASSERT_TRUE(db_iter->Valid());
@@ -1265,10 +1256,9 @@ TEST_F(DBIteratorTest, DBIterator1) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 1, options.max_sequential_skip_in_iterations,
-                    nullptr /*read_callback*/));
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
+      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
+      internal_iter, 1, options.max_sequential_skip_in_iterations));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1293,10 +1283,9 @@ TEST_F(DBIteratorTest, DBIterator2) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 0, options.max_sequential_skip_in_iterations,
-                    nullptr /*read_callback*/));
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
+      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
+      internal_iter, 0, options.max_sequential_skip_in_iterations));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1318,10 +1307,9 @@ TEST_F(DBIteratorTest, DBIterator3) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 2, options.max_sequential_skip_in_iterations,
-                    nullptr /*read_callback*/));
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
+      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
+      internal_iter, 2, options.max_sequential_skip_in_iterations));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1343,10 +1331,9 @@ TEST_F(DBIteratorTest, DBIterator4) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 4, options.max_sequential_skip_in_iterations,
-                    nullptr /*read_callback*/));
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
+      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
+      internal_iter, 4, options.max_sequential_skip_in_iterations));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1376,9 +1363,9 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 0,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      0, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1398,9 +1385,9 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 1,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      1, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1420,9 +1407,9 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 2,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      2, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1442,9 +1429,9 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 3,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      3, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1464,9 +1451,9 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 4,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      4, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1486,9 +1473,9 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 5,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      5, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1508,9 +1495,9 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 6,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      6, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1528,9 +1515,9 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_2");
    internal_iter->AddPut("b", "val_b");
    internal_iter->Finish();
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 10,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      10, options.max_sequential_skip_in_iterations));
    db_iter->Seek("b");
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "b");
@@ -1557,9 +1544,9 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 0,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      0, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1579,9 +1566,9 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 1,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      1, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1601,9 +1588,9 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 2,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      2, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1623,9 +1610,9 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 3,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      3, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(!db_iter->Valid());
  }
@@ -1641,9 +1628,9 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 4,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      4, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1663,9 +1650,9 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 5,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      5, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1685,9 +1672,9 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 6,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      6, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1726,9 +1713,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 0,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      0, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1760,9 +1747,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 2,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      2, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -1800,9 +1787,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 4,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      4, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -1840,9 +1827,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 5,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      5, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -1885,9 +1872,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 6,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      6, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -1931,9 +1918,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 7,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      7, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -1971,9 +1958,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 9,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      9, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2017,9 +2004,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 13,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      13, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2064,9 +2051,9 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, cf_options, BytewiseComparator(), internal_iter, 14,
-        options.max_sequential_skip_in_iterations, nullptr /*read_callback*/));
+    std::unique_ptr<Iterator> db_iter(
+        NewDBIterator(env_, ro, cf_options, BytewiseComparator(), internal_iter,
+                      14, options.max_sequential_skip_in_iterations));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2096,8 +2083,7 @@ TEST_F(DBIteratorTest, DBIterator8) {

  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-      internal_iter, 10, options.max_sequential_skip_in_iterations,
-      nullptr /*read_callback*/));
+      internal_iter, 10, options.max_sequential_skip_in_iterations));
  db_iter->SeekToLast();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "b");
@@ -2127,8 +2113,7 @@ TEST_F(DBIteratorTest, DBIterator9) {

    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-        internal_iter, 10, options.max_sequential_skip_in_iterations,
-        nullptr /*read_callback*/));
+        internal_iter, 10, options.max_sequential_skip_in_iterations));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -2194,8 +2179,7 @@ TEST_F(DBIteratorTest, DBIterator10) {

  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-      internal_iter, 10, options.max_sequential_skip_in_iterations,
-      nullptr /*read_callback*/));
+      internal_iter, 10, options.max_sequential_skip_in_iterations));

  db_iter->Seek("c");
  ASSERT_TRUE(db_iter->Valid());
@@ -2232,9 +2216,9 @@ TEST_F(DBIteratorTest, SeekToLastOccurrenceSeq0) {
  internal_iter->AddPut("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(NewDBIterator(
-      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-      internal_iter, 10, 0 /* force seek */, nullptr /*read_callback*/));
+  std::unique_ptr<Iterator> db_iter(
+      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
+                    internal_iter, 10, 0 /* force seek */));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -2260,10 +2244,9 @@ TEST_F(DBIteratorTest, DBIterator11) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 1, options.max_sequential_skip_in_iterations,
-                    nullptr /*read_callback*/));
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
+      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
+      internal_iter, 1, options.max_sequential_skip_in_iterations));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -2289,7 +2272,7 @@ TEST_F(DBIteratorTest, DBIterator12) {

  std::unique_ptr<Iterator> db_iter(
      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 10, 0, nullptr /*read_callback*/));
+                    internal_iter, 10, 0));
  db_iter->SeekToLast();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "c");
@@ -2326,7 +2309,7 @@ TEST_F(DBIteratorTest, DBIterator13) {

  std::unique_ptr<Iterator> db_iter(
      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 2, 3, nullptr /*read_callback*/));
+                    internal_iter, 2, 3));
  db_iter->Seek("b");
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), key);
@@ -2354,7 +2337,7 @@ TEST_F(DBIteratorTest, DBIterator14) {

  std::unique_ptr<Iterator> db_iter(
      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 4, 1, nullptr /*read_callback*/));
+                    internal_iter, 4, 1));
  db_iter->Seek("b");
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "b");
@@ -2364,80 +2347,6 @@ TEST_F(DBIteratorTest, DBIterator14) {
  ASSERT_EQ(db_iter->value().ToString(), "4");
 }

-TEST_F(DBIteratorTest, DBIteratorTestDifferentialSnapshots) {
-  { // test that KVs earlier that iter_start_seqnum are filtered out
-    ReadOptions ro;
-    ro.iter_start_seqnum=5;
-    Options options;
-    options.statistics = rocksdb::CreateDBStatistics();
-
-    TestIterator* internal_iter = new TestIterator(BytewiseComparator());
-    for (size_t i = 0; i < 10; ++i) {
-      internal_iter->AddPut(std::to_string(i), std::to_string(i) + "a");
-      internal_iter->AddPut(std::to_string(i), std::to_string(i) + "b");
-      internal_iter->AddPut(std::to_string(i), std::to_string(i) + "c");
-    }
-    internal_iter->Finish();
-
-    std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 13,
-                    options.max_sequential_skip_in_iterations, nullptr));
-    // Expecting InternalKeys in [5,8] range with correct type
-    int seqnums[4] = {5,8,11,13};
-    std::string user_keys[4] = {"1","2","3","4"};
-    std::string values[4] = {"1c", "2c", "3c", "4b"};
-    int i = 0;
-    for (db_iter->SeekToFirst(); db_iter->Valid(); db_iter->Next()) {
-      FullKey fkey;
-      ParseFullKey(db_iter->key(), &fkey);
-      ASSERT_EQ(user_keys[i], fkey.user_key.ToString());
-      ASSERT_EQ(EntryType::kEntryPut, fkey.type);
-      ASSERT_EQ(seqnums[i], fkey.sequence);
-      ASSERT_EQ(values[i], db_iter->value().ToString());
-      i++;
-    }
-    ASSERT_EQ(i, 4);
-  }
-
-  { // Test that deletes are returned correctly as internal KVs
-    ReadOptions ro;
-    ro.iter_start_seqnum=5;
-    Options options;
-    options.statistics = rocksdb::CreateDBStatistics();
-
-    TestIterator* internal_iter = new TestIterator(BytewiseComparator());
-    for (size_t i = 0; i < 10; ++i) {
-      internal_iter->AddPut(std::to_string(i), std::to_string(i) + "a");
-      internal_iter->AddPut(std::to_string(i), std::to_string(i) + "b");
-      internal_iter->AddDeletion(std::to_string(i));
-    }
-    internal_iter->Finish();
-
-    std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 13,
-                    options.max_sequential_skip_in_iterations, nullptr));
-    // Expecting InternalKeys in [5,8] range with correct type
-    int seqnums[4] = {5,8,11,13};
-    EntryType key_types[4] = {EntryType::kEntryDelete,EntryType::kEntryDelete,
-      EntryType::kEntryDelete,EntryType::kEntryPut};
-    std::string user_keys[4] = {"1","2","3","4"};
-    std::string values[4] = {"", "", "", "4b"};
-    int i = 0;
-    for (db_iter->SeekToFirst(); db_iter->Valid(); db_iter->Next()) {
-      FullKey fkey;
-      ParseFullKey(db_iter->key(), &fkey);
-      ASSERT_EQ(user_keys[i], fkey.user_key.ToString());
-      ASSERT_EQ(key_types[i], fkey.type);
-      ASSERT_EQ(seqnums[i], fkey.sequence);
-      ASSERT_EQ(values[i], db_iter->value().ToString());
-      i++;
-    }
-    ASSERT_EQ(i, 4);
-  }
-}
-
 class DBIterWithMergeIterTest : public testing::Test {
 public:
  DBIterWithMergeIterTest()
@@ -2464,10 +2373,10 @@ class DBIterWithMergeIterTest : public testing::Test {
    InternalIterator* merge_iter =
        NewMergingIterator(&icomp_, &child_iters[0], 2u);

-    db_iter_.reset(NewDBIterator(
-        env_, ro_, ImmutableCFOptions(options_), BytewiseComparator(),
-        merge_iter, 8 /* read data earlier than seqId 8 */,
-        3 /* max iterators before reseek */, nullptr /*read_callback*/));
+    db_iter_.reset(NewDBIterator(env_, ro_, ImmutableCFOptions(options_),
+                                 BytewiseComparator(), merge_iter,
+                                 8 /* read data earlier than seqId 8 */,
+                                 3 /* max iterators before reseek */));
  }

  Env* env_;
@@ -2887,110 +2796,6 @@ TEST_F(DBIterWithMergeIterTest, InnerMergeIteratorDataRace8) {

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
-
-
-TEST_F(DBIteratorTest, SeekPrefixTombstones) {
-  ReadOptions ro;
-  Options options;
-  options.prefix_extractor.reset(NewNoopTransform());
-  TestIterator* internal_iter = new TestIterator(BytewiseComparator());
-  internal_iter->AddDeletion("b");
-  internal_iter->AddDeletion("c");
-  internal_iter->AddDeletion("d");
-  internal_iter->AddDeletion("e");
-  internal_iter->AddDeletion("f");
-  internal_iter->AddDeletion("g");
-  internal_iter->Finish();
-
-  ro.prefix_same_as_start = true;
-  std::unique_ptr<Iterator> db_iter(NewDBIterator(
-      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-      internal_iter, 10, options.max_sequential_skip_in_iterations,
-      nullptr /*read_callback*/));
-
-  int skipped_keys = 0;
-
-  get_perf_context()->Reset();
-  db_iter->SeekForPrev("z");
-  skipped_keys =
-      static_cast<int>(get_perf_context()->internal_key_skipped_count);
-  ASSERT_EQ(skipped_keys, 0);
-
-  get_perf_context()->Reset();
-  db_iter->Seek("a");
-  skipped_keys =
-      static_cast<int>(get_perf_context()->internal_key_skipped_count);
-  ASSERT_EQ(skipped_keys, 0);
-}
-
-TEST_F(DBIteratorTest, SeekToFirstLowerBound) {
-  const int kNumKeys = 3;
-  for (int i = 0; i < kNumKeys + 2; ++i) {
-    // + 2 for two special cases: lower bound before and lower bound after the
-    // internal iterator's keys
-    TestIterator* internal_iter = new TestIterator(BytewiseComparator());
-    for (int j = 1; j <= kNumKeys; ++j) {
-      internal_iter->AddPut(std::to_string(j), "val");
-    }
-    internal_iter->Finish();
-
-    ReadOptions ro;
-    auto lower_bound_str = std::to_string(i);
-    Slice lower_bound(lower_bound_str);
-    ro.iterate_lower_bound = &lower_bound;
-    Options options;
-    std::unique_ptr<Iterator> db_iter(NewDBIterator(
-        env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-        internal_iter, 10 /* sequence */,
-        options.max_sequential_skip_in_iterations, nullptr /* read_callback */));
-
-    db_iter->SeekToFirst();
-    if (i == kNumKeys + 1) {
-      // lower bound was beyond the last key
-      ASSERT_FALSE(db_iter->Valid());
-    } else {
-      ASSERT_TRUE(db_iter->Valid());
-      int expected;
-      if (i == 0) {
-        // lower bound was before the first key
-        expected = 1;
-      } else {
-        // lower bound was at the ith key
-        expected = i;
-      }
-      ASSERT_EQ(std::to_string(expected), db_iter->key().ToString());
-    }
-  }
-}
-
-TEST_F(DBIteratorTest, PrevLowerBound) {
-  const int kNumKeys = 3;
-  const int kLowerBound = 2;
-  TestIterator* internal_iter = new TestIterator(BytewiseComparator());
-  for (int j = 1; j <= kNumKeys; ++j) {
-    internal_iter->AddPut(std::to_string(j), "val");
-  }
-  internal_iter->Finish();
-
-  ReadOptions ro;
-  auto lower_bound_str = std::to_string(kLowerBound);
-  Slice lower_bound(lower_bound_str);
-  ro.iterate_lower_bound = &lower_bound;
-  Options options;
-  std::unique_ptr<Iterator> db_iter(NewDBIterator(
-      env_, ro, ImmutableCFOptions(options), BytewiseComparator(),
-      internal_iter, 10 /* sequence */,
-      options.max_sequential_skip_in_iterations, nullptr /* read_callback */));
-
-  db_iter->SeekToLast();
-  for (int i = kNumKeys; i >= kLowerBound; --i) {
-    ASSERT_TRUE(db_iter->Valid());
-    ASSERT_EQ(std::to_string(i), db_iter->key().ToString());
-    db_iter->Prev();
-  }
-  ASSERT_FALSE(db_iter->Valid());
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -1081,8 +1081,7 @@ TEST_F(DBIteratorTest, PrevAfterAndNextAfterMerge) {
  ASSERT_EQ("2", it->key().ToString());
 }

-class DBIteratorTestForPinnedData : public DBIteratorTest {
- public:
+TEST_F(DBIteratorTest, PinnedDataIteratorRandomized) {
  enum TestConfig {
    NORMAL,
    CLOSE_AND_OPEN,
@@ -1090,19 +1089,19 @@ class DBIteratorTestForPinnedData : public DBIteratorTest {
    FLUSH_EVERY_1000,
    MAX
  };
-  DBIteratorTestForPinnedData() : DBIteratorTest() {}
-  void PinnedDataIteratorRandomized(TestConfig run_config) {
-    // Generate Random data
-    Random rnd(301);

-    int puts = 100000;
-    int key_pool = static_cast<int>(puts * 0.7);
-    int key_size = 100;
-    int val_size = 1000;
-    int seeks_percentage = 20;   // 20% of keys will be used to test seek()
-    int delete_percentage = 20;  // 20% of keys will be deleted
-    int merge_percentage = 20;   // 20% of keys will be added using Merge()
+  // Generate Random data
+  Random rnd(301);

+  int puts = 100000;
+  int key_pool = static_cast<int>(puts * 0.7);
+  int key_size = 100;
+  int val_size = 1000;
+  int seeks_percentage = 20;   // 20% of keys will be used to test seek()
+  int delete_percentage = 20;  // 20% of keys will be deleted
+  int merge_percentage = 20;   // 20% of keys will be added using Merge()
+
+  for (int run_config = 0; run_config < TestConfig::MAX; run_config++) {
    Options options = CurrentOptions();
    BlockBasedTableOptions table_options;
    table_options.use_delta_encoding = false;
@@ -1247,24 +1246,7 @@ class DBIteratorTestForPinnedData : public DBIteratorTest {
    }

    delete iter;
-}
-};
-
-TEST_F(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedNormal) {
-  PinnedDataIteratorRandomized(TestConfig::NORMAL);
-}
-
-TEST_F(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedCLoseAndOpen) {
-  PinnedDataIteratorRandomized(TestConfig::CLOSE_AND_OPEN);
-}
-
-TEST_F(DBIteratorTestForPinnedData,
-       PinnedDataIteratorRandomizedCompactBeforeRead) {
-  PinnedDataIteratorRandomized(TestConfig::COMPACT_BEFORE_READ);
-}
-
-TEST_F(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedFlush) {
-  PinnedDataIteratorRandomized(TestConfig::FLUSH_EVERY_1000);
+  }
 }

 #ifndef ROCKSDB_LITE
@@ -1997,85 +1979,6 @@ TEST_F(DBIteratorTest, Refresh) {
  iter.reset();
 }

-TEST_F(DBIteratorTest, CreationFailure) {
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::NewInternalIterator:StatusCallback", [](void* arg) {
-        *(reinterpret_cast<Status*>(arg)) = Status::Corruption("test status");
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  Iterator* iter = db_->NewIterator(ReadOptions());
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_TRUE(iter->status().IsCorruption());
-  delete iter;
-}
-
-TEST_F(DBIteratorTest, TableFilter) {
-  ASSERT_OK(Put("a", "1"));
-  dbfull()->Flush(FlushOptions());
-  ASSERT_OK(Put("b", "2"));
-  ASSERT_OK(Put("c", "3"));
-  dbfull()->Flush(FlushOptions());
-  ASSERT_OK(Put("d", "4"));
-  ASSERT_OK(Put("e", "5"));
-  ASSERT_OK(Put("f", "6"));
-  dbfull()->Flush(FlushOptions());
-
-  // Ensure the table_filter callback is called once for each table.
-  {
-    std::set<uint64_t> unseen{1, 2, 3};
-    ReadOptions opts;
-    opts.table_filter = [&](const TableProperties& props) {
-      auto it = unseen.find(props.num_entries);
-      if (it == unseen.end()) {
-        ADD_FAILURE() << "saw table properties with an unexpected "
-                      << props.num_entries << " entries";
-      } else {
-        unseen.erase(it);
-      }
-      return true;
-    };
-    auto iter = db_->NewIterator(opts);
-    iter->SeekToFirst();
-    ASSERT_EQ(IterStatus(iter), "a->1");
-    iter->Next();
-    ASSERT_EQ(IterStatus(iter), "b->2");
-    iter->Next();
-    ASSERT_EQ(IterStatus(iter), "c->3");
-    iter->Next();
-    ASSERT_EQ(IterStatus(iter), "d->4");
-    iter->Next();
-    ASSERT_EQ(IterStatus(iter), "e->5");
-    iter->Next();
-    ASSERT_EQ(IterStatus(iter), "f->6");
-    iter->Next();
-    ASSERT_FALSE(iter->Valid());
-    ASSERT_TRUE(unseen.empty());
-    delete iter;
-  }
-
-  // Ensure returning false in the table_filter hides the keys from that table
-  // during iteration.
-  {
-    ReadOptions opts;
-    opts.table_filter = [](const TableProperties& props) {
-      return props.num_entries != 2;
-    };
-    auto iter = db_->NewIterator(opts);
-    iter->SeekToFirst();
-    ASSERT_EQ(IterStatus(iter), "a->1");
-    iter->Next();
-    ASSERT_EQ(IterStatus(iter), "d->4");
-    iter->Next();
-    ASSERT_EQ(IterStatus(iter), "e->5");
-    iter->Next();
-    ASSERT_EQ(IterStatus(iter), "f->6");
-    iter->Next();
-    ASSERT_FALSE(iter->Valid());
-    delete iter;
-  }
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -8,9 +8,7 @@
 #include "db/db_test_util.h"
 #include "db/forward_iterator.h"
 #include "port/stack_trace.h"
-#include "rocksdb/merge_operator.h"
 #include "utilities/merge_operators.h"
-#include "utilities/merge_operators/string_append/stringappend2.h"

 namespace rocksdb {

@@ -20,80 +18,6 @@ class DBMergeOperatorTest : public DBTestBase {
  DBMergeOperatorTest() : DBTestBase("/db_merge_operator_test") {}
 };

-TEST_F(DBMergeOperatorTest, LimitMergeOperands) {
-  class LimitedStringAppendMergeOp : public StringAppendTESTOperator {
-   public:
-    LimitedStringAppendMergeOp(int limit, char delim)
-        : StringAppendTESTOperator(delim), limit_(limit) {}
-
-    const char* Name() const override {
-      return "DBMergeOperatorTest::LimitedStringAppendMergeOp";
-    }
-
-    bool ShouldMerge(const std::vector<Slice>& operands) const override {
-      if (operands.size() > 0 && limit_ > 0 && operands.size() >= limit_) {
-        return true;
-      }
-      return false;
-    }
-
-   private:
-    size_t limit_ = 0;
-  };
-
-  Options options;
-  options.create_if_missing = true;
-  // Use only the latest two merge operands.
-  options.merge_operator =
-      std::make_shared<LimitedStringAppendMergeOp>(2, ',');
-  options.env = env_;
-  Reopen(options);
-  // All K1 values are in memtable.
-  ASSERT_OK(Merge("k1", "a"));
-  ASSERT_OK(Merge("k1", "b"));
-  ASSERT_OK(Merge("k1", "c"));
-  ASSERT_OK(Merge("k1", "d"));
-  std::string value;
-  ASSERT_TRUE(db_->Get(ReadOptions(), "k1", &value).ok());
-  // Make sure that only the latest two merge operands are used. If this was
-  // not the case the value would be "a,b,c,d".
-  ASSERT_EQ(value, "c,d");
-
-  // All K2 values are flushed to L0 into a single file.
-  ASSERT_OK(Merge("k2", "a"));
-  ASSERT_OK(Merge("k2", "b"));
-  ASSERT_OK(Merge("k2", "c"));
-  ASSERT_OK(Merge("k2", "d"));
-  ASSERT_OK(Flush());
-  ASSERT_TRUE(db_->Get(ReadOptions(), "k2", &value).ok());
-  ASSERT_EQ(value, "c,d");
-
-  // All K3 values are flushed and are in different files.
-  ASSERT_OK(Merge("k3", "ab"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3", "bc"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3", "cd"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3", "de"));
-  ASSERT_TRUE(db_->Get(ReadOptions(), "k3", &value).ok());
-  ASSERT_EQ(value, "cd,de");
-
-  // All K4 values are in different levels
-  ASSERT_OK(Merge("k4", "ab"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(4);
-  ASSERT_OK(Merge("k4", "bc"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(3);
-  ASSERT_OK(Merge("k4", "cd"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(1);
-  ASSERT_OK(Merge("k4", "de"));
-  ASSERT_TRUE(db_->Get(ReadOptions(), "k4", &value).ok());
-  ASSERT_EQ(value, "cd,de");
-}
-
 TEST_F(DBMergeOperatorTest, MergeErrorOnRead) {
  Options options;
  options.create_if_missing = true;
@@ -117,149 +117,6 @@ TEST_F(DBOptionsTest, GetLatestCFOptions) {
            GetMutableCFOptionsMap(dbfull()->GetOptions(handles_[1])));
 }

-TEST_F(DBOptionsTest, SetBytesPerSync) {
-  const size_t kValueSize = 1024 * 1024;  // 1MB
-  Options options;
-  options.create_if_missing = true;
-  options.bytes_per_sync = 1024 * 1024;
-  options.use_direct_reads = false;
-  options.write_buffer_size = 400 * kValueSize;
-  options.disable_auto_compactions = true;
-  options.compression = kNoCompression;
-  options.env = env_;
-  Reopen(options);
-  int counter = 0;
-  int low_bytes_per_sync = 0;
-  int i = 0;
-  const std::string kValue(kValueSize, 'v');
-  ASSERT_EQ(options.bytes_per_sync, dbfull()->GetDBOptions().bytes_per_sync);
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "WritableFileWriter::RangeSync:0", [&](void* arg) {
-        counter++;
-      });
-
-  WriteOptions write_opts;
-  // should sync approximately 40MB/1MB ~= 40 times.
-  for (i = 0; i < 40; i++) {
-    Put(Key(i), kValue, write_opts);
-  }
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  low_bytes_per_sync = counter;
-  ASSERT_GT(low_bytes_per_sync, 35);
-  ASSERT_LT(low_bytes_per_sync, 45);
-
-  counter = 0;
-  // 8388608 = 8 * 1024 * 1024
-  ASSERT_OK(dbfull()->SetDBOptions({{"bytes_per_sync", "8388608"}}));
-  ASSERT_EQ(8388608, dbfull()->GetDBOptions().bytes_per_sync);
-  // should sync approximately 40MB*2/8MB ~= 10 times.
-  // data will be 40*2MB because of previous Puts too.
-  for (i = 0; i < 40; i++) {
-    Put(Key(i), kValue, write_opts);
-  }
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_GT(counter, 5);
-  ASSERT_LT(counter, 15);
-
-  // Redundant assert. But leaving it here just to get the point across that
-  // low_bytes_per_sync > counter.
-  ASSERT_GT(low_bytes_per_sync, counter);
-}
-
-TEST_F(DBOptionsTest, SetWalBytesPerSync) {
-  const size_t kValueSize = 1024 * 1024 * 3;
-  Options options;
-  options.create_if_missing = true;
-  options.wal_bytes_per_sync = 512;
-  options.write_buffer_size = 100 * kValueSize;
-  options.disable_auto_compactions = true;
-  options.compression = kNoCompression;
-  options.env = env_;
-  Reopen(options);
-  ASSERT_EQ(512, dbfull()->GetDBOptions().wal_bytes_per_sync);
-  int counter = 0;
-  int low_bytes_per_sync = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "WritableFileWriter::RangeSync:0", [&](void* arg) {
-        counter++;
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  const std::string kValue(kValueSize, 'v');
-  int i = 0;
-  for (; i < 10; i++) {
-    Put(Key(i), kValue);
-  }
-  // Do not flush. If we flush here, SwitchWAL will reuse old WAL file since its
-  // empty and will not get the new wal_bytes_per_sync value.
-  low_bytes_per_sync = counter;
-  //5242880 = 1024 * 1024 * 5
-  ASSERT_OK(dbfull()->SetDBOptions({{"wal_bytes_per_sync", "5242880"}}));
-  ASSERT_EQ(5242880, dbfull()->GetDBOptions().wal_bytes_per_sync);
-  counter = 0;
-  i = 0;
-  for (; i < 10; i++) {
-    Put(Key(i), kValue);
-  }
-  ASSERT_GT(counter, 0);
-  ASSERT_GT(low_bytes_per_sync, 0);
-  ASSERT_GT(low_bytes_per_sync, counter);
-}
-
-TEST_F(DBOptionsTest, WritableFileMaxBufferSize) {
-  Options options;
-  options.create_if_missing = true;
-  options.writable_file_max_buffer_size = 1024 * 1024;
-  options.level0_file_num_compaction_trigger = 3;
-  options.max_manifest_file_size = 1;
-  options.env = env_;
-  int buffer_size = 1024 * 1024;
-  Reopen(options);
-  ASSERT_EQ(buffer_size,
-            dbfull()->GetDBOptions().writable_file_max_buffer_size);
-
-  std::atomic<int> match_cnt(0);
-  std::atomic<int> unmatch_cnt(0);
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "WritableFileWriter::WritableFileWriter:0", [&](void* arg) {
-        int value = static_cast<int>(reinterpret_cast<uintptr_t>(arg));
-        if (value == buffer_size) {
-          match_cnt++;
-        } else {
-          unmatch_cnt++;
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  int i = 0;
-  for (; i < 3; i++) {
-    ASSERT_OK(Put("foo", ToString(i)));
-    ASSERT_OK(Put("bar", ToString(i)));
-    Flush();
-  }
-  dbfull()->TEST_WaitForCompact();
-  ASSERT_EQ(unmatch_cnt, 0);
-  ASSERT_GE(match_cnt, 11);
-
-  buffer_size = 512 * 1024;
-  match_cnt = 0;
-  unmatch_cnt = 0;
-  ASSERT_OK(
-      dbfull()->SetDBOptions({{"writable_file_max_buffer_size", "524288"}}));
-  ASSERT_EQ(buffer_size,
-            dbfull()->GetDBOptions().writable_file_max_buffer_size);
-  i = 0;
-  for (; i < 3; i++) {
-    ASSERT_OK(Put("foo", ToString(i)));
-    ASSERT_OK(Put("bar", ToString(i)));
-    Flush();
-  }
-  dbfull()->TEST_WaitForCompact();
-  ASSERT_EQ(unmatch_cnt, 0);
-  ASSERT_GE(match_cnt, 11);
-}
-
 TEST_F(DBOptionsTest, SetOptionsAndReopen) {
  Random rnd(1044);
  auto rand_opts = GetRandomizedMutableCFOptionsMap(&rnd);
@@ -584,114 +441,6 @@ TEST_F(DBOptionsTest, SanitizeDelayedWriteRate) {
  ASSERT_EQ(31 * 1024 * 1024, dbfull()->GetDBOptions().delayed_write_rate);
 }

-TEST_F(DBOptionsTest, SetFIFOCompactionOptions) {
-  Options options;
-  options.compaction_style = kCompactionStyleFIFO;
-  options.write_buffer_size = 10 << 10;  // 10KB
-  options.arena_block_size = 4096;
-  options.compression = kNoCompression;
-  options.create_if_missing = true;
-  options.compaction_options_fifo.allow_compaction = false;
-  env_->time_elapse_only_sleep_ = false;
-  options.env = env_;
-
-  // Test dynamically changing compaction_options_fifo.ttl
-  env_->addon_time_.store(0);
-  options.compaction_options_fifo.ttl = 1 * 60 * 60;  // 1 hour
-  ASSERT_OK(TryReopen(options));
-
-  Random rnd(301);
-  for (int i = 0; i < 10; i++) {
-    // Generate and flush a file about 10KB.
-    for (int j = 0; j < 10; j++) {
-      ASSERT_OK(Put(ToString(i * 20 + j), RandomString(&rnd, 980)));
-    }
-    Flush();
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ(NumTableFilesAtLevel(0), 10);
-
-  // Add 61 seconds to the time.
-  env_->addon_time_.fetch_add(61);
-
-  // No files should be compacted as ttl is set to 1 hour.
-  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({{"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);
-
-  // 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.compaction_options_fifo.ttl = 0;
-  DestroyAndReopen(options);
-
-  for (int i = 0; i < 10; i++) {
-    // Generate and flush a file about 10KB.
-    for (int j = 0; j < 10; j++) {
-      ASSERT_OK(Put(ToString(i * 20 + j), RandomString(&rnd, 980)));
-    }
-    Flush();
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ(NumTableFilesAtLevel(0), 10);
-
-  // No files should be compacted as max_table_files_size is set to 500 KB.
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
-            500 << 10);
-  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_EQ(NumTableFilesAtLevel(0), 10);
-
-  // Set max_table_files_size to 12 KB. So only 1 file should remain now.
-  ASSERT_OK(dbfull()->SetOptions(
-      {{"compaction_options_fifo", "{max_table_files_size=12288;}"}}));
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
-            12 << 10);
-  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
-
-  // Test dynamically changing compaction_options_fifo.allow_compaction
-  options.compaction_options_fifo.max_table_files_size = 500 << 10;  // 500KB
-  options.compaction_options_fifo.ttl = 0;
-  options.compaction_options_fifo.allow_compaction = false;
-  options.level0_file_num_compaction_trigger = 6;
-  DestroyAndReopen(options);
-
-  for (int i = 0; i < 10; i++) {
-    // Generate and flush a file about 10KB.
-    for (int j = 0; j < 10; j++) {
-      ASSERT_OK(Put(ToString(i * 20 + j), RandomString(&rnd, 980)));
-    }
-    Flush();
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ(NumTableFilesAtLevel(0), 10);
-
-  // No files should be compacted as max_table_files_size is set to 500 KB and
-  // allow_compaction is false
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
-            false);
-  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_EQ(NumTableFilesAtLevel(0), 10);
-
-  // Set allow_compaction to true. So number of files should be between 1 and 5.
-  ASSERT_OK(dbfull()->SetOptions(
-      {{"compaction_options_fifo", "{allow_compaction=true;}"}}));
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
-            true);
-  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_GE(NumTableFilesAtLevel(0), 1);
-  ASSERT_LE(NumTableFilesAtLevel(0), 5);
-}
-
 #endif  // ROCKSDB_LITE

 }  // namespace rocksdb
@@ -327,10 +327,11 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
  options.disable_auto_compactions = true;
  options.env = env_;

+  std::string trash_dir = test::TmpDir(env_) + "/trash";
  int64_t rate_bytes_per_sec = 1024 * 10;  // 10 Kbs / Sec
  Status s;
  options.sst_file_manager.reset(
-      NewSstFileManager(env_, nullptr, "", 0, false, &s));
+      NewSstFileManager(env_, nullptr, trash_dir, 0, false, &s));
  ASSERT_OK(s);
  options.sst_file_manager->SetDeleteRateBytesPerSecond(rate_bytes_per_sec);
  auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());
@@ -393,10 +394,11 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
  options.db_paths.emplace_back(dbname_ + "_2", 1024 * 100);
  options.env = env_;

+  std::string trash_dir = test::TmpDir(env_) + "/trash";
  int64_t rate_bytes_per_sec = 1024 * 1024;  // 1 Mb / Sec
  Status s;
-  options.sst_file_manager.reset(
-      NewSstFileManager(env_, nullptr, "", rate_bytes_per_sec, false, &s));
+  options.sst_file_manager.reset(NewSstFileManager(
+      env_, nullptr, trash_dir, rate_bytes_per_sec, false, &s));
  ASSERT_OK(s);
  auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());
  sfm->delete_scheduler()->TEST_SetMaxTrashDBRatio(1.1);
@@ -458,8 +460,9 @@ TEST_F(DBSSTTest, DestroyDBWithRateLimitedDelete) {
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.env = env_;
+  std::string trash_dir = test::TmpDir(env_) + "/trash";
  options.sst_file_manager.reset(
-      NewSstFileManager(env_, nullptr, "", 0, false, &s));
+      NewSstFileManager(env_, nullptr, trash_dir, 0, false, &s));
  ASSERT_OK(s);
  DestroyAndReopen(options);

@@ -13,7 +13,6 @@
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "rocksdb/db.h"
-#include "rocksdb/utilities/table_properties_collectors.h"
 #include "util/testharness.h"
 #include "util/testutil.h"

@@ -251,37 +250,6 @@ TEST_F(DBTablePropertiesTest, GetColumnFamilyNameProperty) {
  }
 }

-TEST_F(DBTablePropertiesTest, DeletionTriggeredCompactionMarking) {
-  const int kNumKeys = 1000;
-  const int kWindowSize = 100;
-  const int kNumDelsTrigger = 90;
-
-  Options opts = CurrentOptions();
-  opts.table_properties_collector_factories.emplace_back(
-      NewCompactOnDeletionCollectorFactory(kWindowSize, kNumDelsTrigger));
-  Reopen(opts);
-
-  // add an L1 file to prevent tombstones from dropping due to obsolescence
-  // during flush
-  Put(Key(0), "val");
-  Flush();
-  MoveFilesToLevel(1);
-
-  for (int i = 0; i < kNumKeys; ++i) {
-    if (i >= kNumKeys - kWindowSize &&
-        i < kNumKeys - kWindowSize + kNumDelsTrigger) {
-      Delete(Key(i));
-    } else {
-      Put(Key(i), "val");
-    }
-  }
-  Flush();
-
-  dbfull()->TEST_WaitForCompact();
-  ASSERT_EQ(0, NumTableFilesAtLevel(0));
-  ASSERT_GT(NumTableFilesAtLevel(1), 0);
-}
-
 }  // namespace rocksdb

 #endif  // ROCKSDB_LITE
@@ -60,6 +60,7 @@
 #include "util/compression.h"
 #include "util/file_reader_writer.h"
 #include "util/filename.h"
+#include "util/hash.h"
 #include "util/mutexlock.h"
 #include "util/rate_limiter.h"
 #include "util/string_util.h"
@@ -222,10 +223,6 @@ TEST_F(DBTest, SkipDelay) {

  for (bool sync : {true, false}) {
    for (bool disableWAL : {true, false}) {
-      if (sync && disableWAL) {
-        // sync and disableWAL is incompatible.
-        continue;
-      }
      // Use a small number to ensure a large delay that is still effective
      // when we do Put
      // TODO(myabandeh): this is time dependent and could potentially make
@@ -2327,9 +2324,9 @@ class ModelDB : public DB {
    return false;
  }
  using DB::GetMapProperty;
-  virtual 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, double>* value) override {
    return false;
  }
  using DB::GetAggregatedIntProperty;
@@ -2462,10 +2459,6 @@ class ModelDB : public DB {

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

-  virtual bool SetPreserveDeletesSequenceNumber(SequenceNumber seqnum) override {
-    return true;
-  }
-
  virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
    return nullptr;
  }
@@ -4309,72 +4302,6 @@ TEST_F(DBTest, DynamicCompactionOptions) {
  dbfull()->TEST_WaitForCompact();
  ASSERT_LT(NumTableFilesAtLevel(0), 4);
 }
-
-// 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
-// as expected on dynamically changing the options.
-// Even more FIFOCompactionTests are at DBTest.FIFOCompaction* .
-TEST_F(DBTest, DynamicFIFOCompactionOptions) {
-  Options options;
-  options.create_if_missing = true;
-  DestroyAndReopen(options);
-
-  // Initial defaults
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
-            1024 * 1024 * 1024);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 0);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
-            false);
-
-  ASSERT_OK(dbfull()->SetOptions(
-      {{"compaction_options_fifo", "{max_table_files_size=23;}"}}));
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
-            23);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 0);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
-            false);
-
-  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().compaction_options_fifo.ttl, 97);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
-            false);
-
-  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().compaction_options_fifo.ttl, 203);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
-            false);
-
-  ASSERT_OK(dbfull()->SetOptions(
-      {{"compaction_options_fifo", "{allow_compaction=true;}"}}));
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
-            23);
-  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;ttl=19;}"}}));
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
-            31);
-  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;ttl=49;allow_compaction=true;}"}}));
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.max_table_files_size,
-            51);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.ttl, 49);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_fifo.allow_compaction,
-            true);
-}
 #endif  // ROCKSDB_LITE

 TEST_F(DBTest, FileCreationRandomFailure) {
@@ -4588,7 +4515,7 @@ TEST_F(DBTest, EncodeDecompressedBlockSizeTest) {
      options.compression = comp;
      DestroyAndReopen(options);

-      int kNumKeysWritten = 1000;
+      int kNumKeysWritten = 100000;

      Random rnd(301);
      for (int i = 0; i < kNumKeysWritten; ++i) {
@@ -5245,19 +5172,6 @@ TEST_F(DBTest, HardLimit) {
 }

 #ifndef ROCKSDB_LITE
-class WriteStallListener : public EventListener {
- public:
-  WriteStallListener() : condition_(WriteStallCondition::kNormal) {}
-  void OnStallConditionsChanged(const WriteStallInfo& info) override {
-    condition_ = info.condition.cur;
-  }
-  bool CheckCondition(WriteStallCondition expected) {
-    return expected == condition_;
-  }
- private:
-  WriteStallCondition condition_;
-};
-
 TEST_F(DBTest, SoftLimit) {
  Options options = CurrentOptions();
  options.env = env_;
@@ -5273,8 +5187,6 @@ TEST_F(DBTest, SoftLimit) {
  options.max_bytes_for_level_multiplier = 10;
  options.max_background_compactions = 1;
  options.compression = kNoCompression;
-  WriteStallListener* listener = new WriteStallListener();
-  options.listeners.emplace_back(listener);

  Reopen(options);

@@ -5314,7 +5226,6 @@ TEST_F(DBTest, SoftLimit) {
    Flush();
  }
  ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_TRUE(listener->CheckCondition(WriteStallCondition::kDelayed));

  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilDone();
@@ -5325,7 +5236,6 @@ TEST_F(DBTest, SoftLimit) {
  // The L1 file size is around 30KB.
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_TRUE(!dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_TRUE(listener->CheckCondition(WriteStallCondition::kNormal));

  // Only allow one compactin going through.
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
@@ -5360,7 +5270,6 @@ TEST_F(DBTest, SoftLimit) {
  // doesn't trigger soft_pending_compaction_bytes_limit
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_TRUE(!dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_TRUE(listener->CheckCondition(WriteStallCondition::kNormal));

  // Create 3 L0 files, making score of L0 to be 3, higher than L0.
  for (int i = 0; i < 3; i++) {
@@ -5381,13 +5290,11 @@ TEST_F(DBTest, SoftLimit) {
  // triggerring soft_pending_compaction_bytes_limit
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_TRUE(listener->CheckCondition(WriteStallCondition::kDelayed));

  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilSleeping();

  ASSERT_TRUE(!dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_TRUE(listener->CheckCondition(WriteStallCondition::kNormal));

  // shrink level base so L2 will hit soft limit easier.
  ASSERT_OK(dbfull()->SetOptions({
@@ -5397,7 +5304,6 @@ TEST_F(DBTest, SoftLimit) {
  Put("", "");
  Flush();
  ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_TRUE(listener->CheckCondition(WriteStallCondition::kDelayed));

  sleeping_task_low.WaitUntilSleeping();
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
@@ -11,7 +11,6 @@
 #include <functional>

 #include "db/db_test_util.h"
-#include "db/read_callback.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/persistent_cache.h"
@@ -1919,19 +1918,19 @@ TEST_F(DBTest2, AutomaticCompactionOverlapManualCompaction) {
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));

  auto get_stat = [](std::string level_str, LevelStatType type,
-                     std::map<std::string, std::string> props) {
+                     std::map<std::string, double> props) {
    auto prop_str =
-        "compaction." + level_str + "." +
+        level_str + "." +
        InternalStats::compaction_level_stats.at(type).property_name.c_str();
    auto prop_item = props.find(prop_str);
-    return prop_item == props.end() ? 0 : std::stod(prop_item->second);
+    return prop_item == props.end() ? 0 : prop_item->second;
  };

  // Trivial move 2 files to L2
  ASSERT_EQ("0,0,2", FilesPerLevel());
  // Also test that the stats GetMapProperty API reporting the same result
  {
-    std::map<std::string, std::string> prop;
+    std::map<std::string, double> prop;
    ASSERT_TRUE(dbfull()->GetMapProperty("rocksdb.cfstats", &prop));
    ASSERT_EQ(0, get_stat("L0", LevelStatType::NUM_FILES, prop));
    ASSERT_EQ(0, get_stat("L1", LevelStatType::NUM_FILES, prop));
@@ -1967,7 +1966,7 @@ TEST_F(DBTest2, AutomaticCompactionOverlapManualCompaction) {

  // Test that the stats GetMapProperty API reporting 1 file in L2
  {
-    std::map<std::string, std::string> prop;
+    std::map<std::string, double> prop;
    ASSERT_TRUE(dbfull()->GetMapProperty("rocksdb.cfstats", &prop));
    ASSERT_EQ(1, get_stat("L2", LevelStatType::NUM_FILES, prop));
  }
@@ -2332,86 +2331,6 @@ TEST_F(DBTest2, ReduceLevel) {
  ASSERT_EQ("0,1", FilesPerLevel());
 #endif  // !ROCKSDB_LITE
 }
-
-// Test that ReadCallback is actually used in both memtbale and sst tables
-TEST_F(DBTest2, ReadCallbackTest) {
-  Options options;
-  options.disable_auto_compactions = true;
-  options.num_levels = 7;
-  Reopen(options);
-  std::vector<const Snapshot*> snapshots;
-  // Try to create a db with multiple layers and a memtable
-  const std::string key = "foo";
-  const std::string value = "bar";
-  // This test assumes that the seq start with 1 and increased by 1 after each
-  // write batch of size 1. If that behavior changes, the test needs to be
-  // updated as well.
-  // TODO(myabandeh): update this test to use the seq number that is returned by
-  // the DB instead of assuming what seq the DB used.
-  int i = 1;
-  for (; i < 10; i++) {
-    Put(key, value + std::to_string(i));
-    // Take a snapshot to avoid the value being removed during compaction
-    auto snapshot = dbfull()->GetSnapshot();
-    snapshots.push_back(snapshot);
-  }
-  Flush();
-  for (; i < 20; i++) {
-    Put(key, value + std::to_string(i));
-    // Take a snapshot to avoid the value being removed during compaction
-    auto snapshot = dbfull()->GetSnapshot();
-    snapshots.push_back(snapshot);
-  }
-  Flush();
-  MoveFilesToLevel(6);
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("0,0,0,0,0,0,2", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
-  for (; i < 30; i++) {
-    Put(key, value + std::to_string(i));
-    auto snapshot = dbfull()->GetSnapshot();
-    snapshots.push_back(snapshot);
-  }
-  Flush();
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("1,0,0,0,0,0,2", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
-  // And also add some values to the memtable
-  for (; i < 40; i++) {
-    Put(key, value + std::to_string(i));
-    auto snapshot = dbfull()->GetSnapshot();
-    snapshots.push_back(snapshot);
-  }
-
-  class TestReadCallback : public ReadCallback {
-   public:
-    explicit TestReadCallback(SequenceNumber snapshot) : snapshot_(snapshot) {}
-    virtual bool IsCommitted(SequenceNumber seq) override {
-      return seq <= snapshot_;
-    }
-
-   private:
-    SequenceNumber snapshot_;
-  };
-
-  for (int seq = 1; seq < i; seq++) {
-    PinnableSlice pinnable_val;
-    ReadOptions roptions;
-    TestReadCallback callback(seq);
-    bool dont_care = true;
-    Status s = dbfull()->GetImpl(roptions, dbfull()->DefaultColumnFamily(), key,
-                                 &pinnable_val, &dont_care, &callback);
-    ASSERT_TRUE(s.ok());
-    // Assuming that after each Put the DB increased seq by one, the value and
-    // seq number must be equal since we also inc value by 1 after each Put.
-    ASSERT_EQ(value + std::to_string(seq), pinnable_val.ToString());
-  }
-
-  for (auto snapshot : snapshots) {
-    dbfull()->ReleaseSnapshot(snapshot);
-  }
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -288,11 +288,12 @@ Options DBTestBase::GetOptions(
  Options options = default_options;
  BlockBasedTableOptions table_options;
  bool set_block_based_table_factory = true;
-#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && \
-    !defined(OS_AIX)
+#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) &&  \
+  !defined(OS_AIX)
  rocksdb::SyncPoint::GetInstance()->ClearCallBack(
      "NewRandomAccessFile:O_DIRECT");
-  rocksdb::SyncPoint::GetInstance()->ClearCallBack("NewWritableFile:O_DIRECT");
+  rocksdb::SyncPoint::GetInstance()->ClearCallBack(
+      "NewWritableFile:O_DIRECT");
 #endif

  bool can_allow_mmap = IsMemoryMappedAccessSupported();
@@ -465,7 +466,7 @@ Options DBTestBase::GetOptions(
      options.use_direct_io_for_flush_and_compaction = true;
      options.compaction_readahead_size = 2 * 1024 * 1024;
 #if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && \
-    !defined(OS_AIX) && !defined(OS_OPENBSD)
+    !defined(OS_AIX)
      rocksdb::SyncPoint::GetInstance()->SetCallBack(
          "NewWritableFile:O_DIRECT", [&](void* arg) {
            int* val = static_cast<int*>(arg);
@@ -667,10 +668,6 @@ Status DBTestBase::SingleDelete(int cf, const std::string& k) {
  return db_->SingleDelete(WriteOptions(), handles_[cf], k);
 }

-bool DBTestBase::SetPreserveDeletesSequenceNumber(SequenceNumber sn) {
-  return db_->SetPreserveDeletesSequenceNumber(sn);
-}
-
 std::string DBTestBase::Get(const std::string& k, const Snapshot* snapshot) {
  ReadOptions options;
  options.verify_checksums = true;
@@ -1173,7 +1170,7 @@ void DBTestBase::validateNumberOfEntries(int numValues, int cf) {
  int seq = numValues;
  while (iter->Valid()) {
    ParsedInternalKey ikey;
-    ikey.clear();
+    ikey.sequence = -1;
    ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);

    // checks sequence number for updates
@@ -829,8 +829,6 @@ class DBTestBase : public testing::Test {

  Status SingleDelete(int cf, const std::string& k);

-  bool SetPreserveDeletesSequenceNumber(SequenceNumber sn);
-
  std::string Get(const std::string& k, const Snapshot* snapshot = nullptr);

  std::string Get(int cf, const std::string& k,
@@ -876,39 +876,6 @@ TEST_F(DBWALTest, kAbsoluteConsistency) {
  }
 }

-// Test scope:
-// We don't expect the data store to be opened if there is any inconsistency
-// between WAL and SST files
-TEST_F(DBWALTest, kPointInTimeRecoveryCFConsistency) {
-  Options options = CurrentOptions();
-  options.avoid_flush_during_recovery = true;
-
-  // Create DB with multiple column families.
-  CreateAndReopenWithCF({"one", "two"}, options);
-  ASSERT_OK(Put(1, "key1", "val1"));
-  ASSERT_OK(Put(2, "key2", "val2"));
-
-  // Record the offset at this point
-  Env* env = options.env;
-  int wal_file_id = RecoveryTestHelper::kWALFileOffset + 1;
-  std::string fname = LogFileName(dbname_, wal_file_id);
-  uint64_t offset_to_corrupt;
-  ASSERT_OK(env->GetFileSize(fname, &offset_to_corrupt));
-  ASSERT_GT(offset_to_corrupt, 0);
-
-  ASSERT_OK(Put(1, "key3", "val3"));
-  // Corrupt WAL at location of key3
-  RecoveryTestHelper::InduceCorruption(
-      fname, static_cast<size_t>(offset_to_corrupt), static_cast<size_t>(4));
-  ASSERT_OK(Put(2, "key4", "val4"));
-  ASSERT_OK(Put(1, "key5", "val5"));
-  Flush(2);
-
-  // PIT recovery & verify
-  options.wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
-  ASSERT_NOK(TryReopenWithColumnFamilies({"default", "one", "two"}, options));
-}
-
 // Test scope:
 // - We expect to open data store under all circumstances
 // - We expect only data upto the point where the first error was encountered
@@ -1040,7 +1007,7 @@ TEST_F(DBWALTest, AvoidFlushDuringRecovery) {
  Reopen(options);
  ASSERT_EQ("v11", Get("foo"));
  ASSERT_EQ("v12", Get("bar"));
-  ASSERT_EQ(3, TotalTableFiles());
+  ASSERT_EQ(2, TotalTableFiles());
 }

 TEST_F(DBWALTest, WalCleanupAfterAvoidFlushDuringRecovery) {
@@ -28,17 +28,6 @@ class DBWriteTest : public DBTestBase, public testing::WithParamInterface<int> {
  void Open() { DBTestBase::Reopen(GetOptions()); }
 };

-// It is invalid to do sync write while disabling WAL.
-TEST_P(DBWriteTest, SyncAndDisableWAL) {
-  WriteOptions write_options;
-  write_options.sync = true;
-  write_options.disableWAL = true;
-  ASSERT_TRUE(dbfull()->Put(write_options, "foo", "bar").IsInvalidArgument());
-  WriteBatch batch;
-  ASSERT_OK(batch.Put("foo", "bar"));
-  ASSERT_TRUE(dbfull()->Write(write_options, &batch).IsInvalidArgument());
-}
-
 // Sequence number should be return through input write batch.
 TEST_P(DBWriteTest, ReturnSeuqneceNumber) {
  Random rnd(4422);
@@ -36,32 +36,6 @@ uint64_t PackSequenceAndType(uint64_t seq, ValueType t) {
  return (seq << 8) | t;
 }

-EntryType GetEntryType(ValueType value_type) {
-  switch (value_type) {
-    case kTypeValue:
-      return kEntryPut;
-    case kTypeDeletion:
-      return kEntryDelete;
-    case kTypeSingleDeletion:
-      return kEntrySingleDelete;
-    case kTypeMerge:
-      return kEntryMerge;
-    default:
-      return kEntryOther;
-  }
-}
-
-bool ParseFullKey(const Slice& internal_key, FullKey* fkey) {
-  ParsedInternalKey ikey;
-  if (!ParseInternalKey(internal_key, &ikey)) {
-    return false;
-  }
-  fkey->user_key = ikey.user_key;
-  fkey->sequence = ikey.sequence;
-  fkey->type = GetEntryType(ikey.type);
-  return true;
-}
-
 void UnPackSequenceAndType(uint64_t packed, uint64_t* seq, ValueType* t) {
  *seq = packed >> 8;
  *t = static_cast<ValueType>(packed & 0xff);
@@ -200,13 +174,4 @@ LookupKey::LookupKey(const Slice& _user_key, SequenceNumber s) {
  end_ = dst;
 }

-void IterKey::EnlargeBuffer(size_t key_size) {
-  // If size is smaller than buffer size, continue using current buffer,
-  // or the static allocated one, as default
-  assert(key_size > buf_size_);
-  // Need to enlarge the buffer.
-  ResetBuffer();
-  buf_ = new char[key_size];
-  buf_size_ = key_size;
-}
 }  // namespace rocksdb
@@ -106,8 +106,6 @@ extern uint64_t PackSequenceAndType(uint64_t seq, ValueType t);
 // and the ValueType in *t.
 extern void UnPackSequenceAndType(uint64_t packed, uint64_t* seq, ValueType* t);

-EntryType GetEntryType(ValueType value_type);
-
 // Append the serialization of "key" to *result.
 extern void AppendInternalKey(std::string* result,
                              const ParsedInternalKey& key);
@@ -140,11 +138,7 @@ inline ValueType ExtractValueType(const Slice& internal_key) {

 // A comparator for internal keys that uses a specified comparator for
 // the user key portion and breaks ties by decreasing sequence number.
-class InternalKeyComparator
-#ifdef NDEBUG
-    final
-#endif
-    : public Comparator {
+class InternalKeyComparator : public Comparator {
 private:
  const Comparator* user_comparator_;
  std::string name_;
@@ -185,15 +179,15 @@ class InternalKey {
  // sets the internal key to be bigger or equal to all internal keys with this
  // user key
  void SetMaxPossibleForUserKey(const Slice& _user_key) {
-    AppendInternalKey(
-        &rep_, ParsedInternalKey(_user_key, 0, static_cast<ValueType>(0)));
+    AppendInternalKey(&rep_, ParsedInternalKey(_user_key, kMaxSequenceNumber,
+                                               kValueTypeForSeek));
  }

  // sets the internal key to be smaller or equal to all internal keys with this
  // user key
  void SetMinPossibleForUserKey(const Slice& _user_key) {
-    AppendInternalKey(&rep_, ParsedInternalKey(_user_key, kMaxSequenceNumber,
-                                               kValueTypeForSeek));
+    AppendInternalKey(
+        &rep_, ParsedInternalKey(_user_key, 0, static_cast<ValueType>(0)));
  }

  bool Valid() const {
@@ -508,12 +502,13 @@ class IterKey {
    // If size is smaller than buffer size, continue using current buffer,
    // or the static allocated one, as default
    if (key_size > buf_size_) {
-      EnlargeBuffer(key_size);
+      // Need to enlarge the buffer.
+      ResetBuffer();
+      buf_ = new char[key_size];
+      buf_size_ = key_size;
    }
  }

-  void EnlargeBuffer(size_t key_size);
-
  // No copying allowed
  IterKey(const IterKey&) = delete;
  void operator=(const IterKey&) = delete;
@@ -30,6 +30,7 @@
 #include "monitoring/iostats_context_imp.h"
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/thread_status_util.h"
+#include "port/likely.h"
 #include "port/port.h"
 #include "db/memtable.h"
 #include "rocksdb/db.h"
@@ -57,14 +58,13 @@ namespace rocksdb {
 FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
                   const ImmutableDBOptions& db_options,
                   const MutableCFOptions& mutable_cf_options,
-                   const EnvOptions env_options, VersionSet* versions,
+                   const EnvOptions& env_options, VersionSet* versions,
                   InstrumentedMutex* db_mutex,
                   std::atomic<bool>* shutting_down,
                   std::vector<SequenceNumber> existing_snapshots,
                   SequenceNumber earliest_write_conflict_snapshot,
-                   SnapshotChecker* snapshot_checker, JobContext* job_context,
-                   LogBuffer* log_buffer, Directory* db_directory,
-                   Directory* output_file_directory,
+                   JobContext* job_context, LogBuffer* log_buffer,
+                   Directory* db_directory, Directory* output_file_directory,
                   CompressionType output_compression, Statistics* stats,
                   EventLogger* event_logger, bool measure_io_stats)
    : dbname_(dbname),
@@ -77,7 +77,6 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
      shutting_down_(shutting_down),
      existing_snapshots_(std::move(existing_snapshots)),
      earliest_write_conflict_snapshot_(earliest_write_conflict_snapshot),
-      snapshot_checker_(snapshot_checker),
      job_context_(job_context),
      log_buffer_(log_buffer),
      db_directory_(db_directory),
@@ -86,8 +85,6 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
      stats_(stats),
      event_logger_(event_logger),
      measure_io_stats_(measure_io_stats),
-      edit_(nullptr),
-      base_(nullptr),
      pick_memtable_called(false) {
  // Update the thread status to indicate flush.
  ReportStartedFlush();
@@ -297,21 +294,23 @@ Status FlushJob::WriteLevel0Table() {

      TEST_SYNC_POINT_CALLBACK("FlushJob::WriteLevel0Table:output_compression",
                               &output_compression_);
+      EnvOptions optimized_env_options =
+          db_options_.env->OptimizeForCompactionTableWrite(env_options_, db_options_);
+
      int64_t _current_time = 0;
      db_options_.env->GetCurrentTime(&_current_time);  // ignore error
      const uint64_t current_time = static_cast<uint64_t>(_current_time);

-      uint64_t oldest_key_time =
-          mems_.front()->ApproximateOldestKeyTime();
+      uint64_t oldest_key_time = mems_.front()->ApproximateOldestKeyTime();

      s = BuildTable(
          dbname_, db_options_.env, *cfd_->ioptions(), mutable_cf_options_,
-          env_options_, cfd_->table_cache(), iter.get(),
+          optimized_env_options, cfd_->table_cache(), iter.get(),
          std::move(range_del_iter), &meta_, cfd_->internal_comparator(),
          cfd_->int_tbl_prop_collector_factories(), cfd_->GetID(),
          cfd_->GetName(), existing_snapshots_,
-          earliest_write_conflict_snapshot_, snapshot_checker_,
-          output_compression_, cfd_->ioptions()->compression_opts,
+          earliest_write_conflict_snapshot_, output_compression_,
+          cfd_->ioptions()->compression_opts,
          mutable_cf_options_.paranoid_file_checks, cfd_->internal_stats(),
          TableFileCreationReason::kFlush, event_logger_, job_context_->job_id,
          Env::IO_HIGH, &table_properties_, 0 /* level */, current_time,
@@ -43,7 +43,6 @@
 namespace rocksdb {

 class MemTable;
-class SnapshotChecker;
 class TableCache;
 class Version;
 class VersionEdit;
@@ -57,14 +56,14 @@ class FlushJob {
  FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
           const ImmutableDBOptions& db_options,
           const MutableCFOptions& mutable_cf_options,
-           const EnvOptions env_options, VersionSet* versions,
+           const EnvOptions& env_options, VersionSet* versions,
           InstrumentedMutex* db_mutex, std::atomic<bool>* shutting_down,
           std::vector<SequenceNumber> existing_snapshots,
           SequenceNumber earliest_write_conflict_snapshot,
-           SnapshotChecker* snapshot_checker, JobContext* job_context,
-           LogBuffer* log_buffer, Directory* db_directory,
-           Directory* output_file_directory, CompressionType output_compression,
-           Statistics* stats, EventLogger* event_logger, bool measure_io_stats);
+           JobContext* job_context, LogBuffer* log_buffer,
+           Directory* db_directory, Directory* output_file_directory,
+           CompressionType output_compression, Statistics* stats,
+           EventLogger* event_logger, bool measure_io_stats);

  ~FlushJob();

@@ -84,13 +83,12 @@ class FlushJob {
  ColumnFamilyData* cfd_;
  const ImmutableDBOptions& db_options_;
  const MutableCFOptions& mutable_cf_options_;
-  const EnvOptions env_options_;
+  const EnvOptions& env_options_;
  VersionSet* versions_;
  InstrumentedMutex* db_mutex_;
  std::atomic<bool>* shutting_down_;
  std::vector<SequenceNumber> existing_snapshots_;
  SequenceNumber earliest_write_conflict_snapshot_;
-  SnapshotChecker* snapshot_checker_;
  JobContext* job_context_;
  LogBuffer* log_buffer_;
  Directory* db_directory_;
@@ -92,12 +92,11 @@ TEST_F(FlushJobTest, Empty) {
  JobContext job_context(0);
  auto cfd = versions_->GetColumnFamilySet()->GetDefault();
  EventLogger event_logger(db_options_.info_log.get());
-  SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(
-      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
-      *cfd->GetLatestMutableCFOptions(), env_options_, versions_.get(), &mutex_,
-      &shutting_down_, {}, kMaxSequenceNumber, snapshot_checker, &job_context,
-      nullptr, nullptr, nullptr, kNoCompression, nullptr, &event_logger, false);
+  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
+                     db_options_, *cfd->GetLatestMutableCFOptions(),
+                     env_options_, versions_.get(), &mutex_, &shutting_down_,
+                     {}, kMaxSequenceNumber, &job_context, nullptr, nullptr,
+                     nullptr, kNoCompression, nullptr, &event_logger, false);
  {
    InstrumentedMutexLock l(&mutex_);
    flush_job.PickMemTable();
@@ -137,12 +136,11 @@ TEST_F(FlushJobTest, NonEmpty) {
  }

  EventLogger event_logger(db_options_.info_log.get());
-  SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(
-      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
-      *cfd->GetLatestMutableCFOptions(), env_options_, versions_.get(), &mutex_,
-      &shutting_down_, {}, kMaxSequenceNumber, snapshot_checker, &job_context,
-      nullptr, nullptr, nullptr, kNoCompression, nullptr, &event_logger, true);
+  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
+                     db_options_, *cfd->GetLatestMutableCFOptions(),
+                     env_options_, versions_.get(), &mutex_, &shutting_down_,
+                     {}, kMaxSequenceNumber, &job_context, nullptr, nullptr,
+                     nullptr, kNoCompression, nullptr, &event_logger, true);
  FileMetaData fd;
  mutex_.Lock();
  flush_job.PickMemTable();
@@ -204,13 +202,11 @@ TEST_F(FlushJobTest, Snapshots) {
  }

  EventLogger event_logger(db_options_.info_log.get());
-  SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     env_options_, versions_.get(), &mutex_, &shutting_down_,
-                     snapshots, kMaxSequenceNumber, snapshot_checker,
-                     &job_context, nullptr, nullptr, nullptr, kNoCompression,
-                     nullptr, &event_logger, true);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), env_options_, versions_.get(), &mutex_,
+      &shutting_down_, snapshots, kMaxSequenceNumber, &job_context, nullptr,
+      nullptr, nullptr, kNoCompression, nullptr, &event_logger, true);
  mutex_.Lock();
  flush_job.PickMemTable();
  ASSERT_OK(flush_job.Run());
@@ -626,8 +626,8 @@ void ForwardIterator::RenewIterators() {
    std::unique_ptr<InternalIterator> range_del_iter(
        svnew->mem->NewRangeTombstoneIterator(read_options_));
    range_del_agg.AddTombstones(std::move(range_del_iter));
-    svnew->imm->AddRangeTombstoneIterators(read_options_, &arena_,
-                                           &range_del_agg);
+    sv_->imm->AddRangeTombstoneIterators(read_options_, &arena_,
+                                         &range_del_agg);
  }

  const auto* vstorage = sv_->current->storage_info();
@@ -443,7 +443,7 @@ bool InternalStats::GetStringProperty(const DBPropertyInfo& property_info,

 bool InternalStats::GetMapProperty(const DBPropertyInfo& property_info,
                                   const Slice& property,
-                                   std::map<std::string, std::string>* value) {
+                                   std::map<std::string, double>* value) {
  assert(value != nullptr);
  assert(property_info.handle_map != nullptr);
  return (this->*(property_info.handle_map))(value);
@@ -521,8 +521,7 @@ bool InternalStats::HandleStats(std::string* value, Slice suffix) {
  return true;
 }

-bool InternalStats::HandleCFMapStats(
-    std::map<std::string, std::string>* cf_stats) {
+bool InternalStats::HandleCFMapStats(std::map<std::string, double>* cf_stats) {
  DumpCFMapStats(cf_stats);
  return true;
 }
@@ -789,8 +788,7 @@ bool InternalStats::HandleEstimateOldestKeyTime(uint64_t* value, DBImpl* /*db*/,
  // with allow_compaction = false. This is because we don't propagate
  // oldest_key_time on compaction.
  if (cfd_->ioptions()->compaction_style != kCompactionStyleFIFO ||
-      cfd_->GetCurrentMutableCFOptions()
-          ->compaction_options_fifo.allow_compaction) {
+      cfd_->ioptions()->compaction_options_fifo.allow_compaction) {
    return false;
  }

@@ -930,15 +928,12 @@ void InternalStats::DumpDBStats(std::string* value) {
 }

 /**
- * Dump Compaction Level stats to a map of stat name with "compaction." prefix
- * to value in double as string. The level in stat name is represented with
- * a prefix "Lx" where "x" is the level number. A special level "Sum"
- * represents the sum of a stat for all levels.
- * The result also contains IO stall counters which keys start with "io_stalls."
- * and values represent uint64 encoded as strings.
+ * Dump Compaction Level stats to a map of stat name to value in double.
+ * The level in stat name is represented with a prefix "Lx" where "x"
+ * is the level number. A special level "Sum" represents the sum of a stat
+ * for all levels.
 */
-void InternalStats::DumpCFMapStats(
-        std::map<std::string, std::string>* cf_stats) {
+void InternalStats::DumpCFMapStats(std::map<std::string, double>* cf_stats) {
  CompactionStats compaction_stats_sum(0);
  std::map<int, std::map<LevelStatType, double>> levels_stats;
  DumpCFMapStats(&levels_stats, &compaction_stats_sum);
@@ -948,13 +943,11 @@ void InternalStats::DumpCFMapStats(
    for (auto const& stat_ent : level_ent.second) {
      auto stat_type = stat_ent.first;
      auto key_str =
-          "compaction." + level_str + "." +
+          level_str + "." +
          InternalStats::compaction_level_stats.at(stat_type).property_name;
-      (*cf_stats)[key_str] = std::to_string(stat_ent.second);
+      (*cf_stats)[key_str] = stat_ent.second;
    }
  }
-
-  DumpCFMapStatsIOStalls(cf_stats);
 }

 void InternalStats::DumpCFMapStats(
@@ -1025,38 +1018,6 @@ void InternalStats::DumpCFMapStats(
  (*levels_stats)[-1] = sum_stats;  //  -1 is for the Sum level
 }

-void InternalStats::DumpCFMapStatsIOStalls(
-    std::map<std::string, std::string>* cf_stats) {
-  (*cf_stats)["io_stalls.level0_slowdown"] =
-      std::to_string(cf_stats_count_[L0_FILE_COUNT_LIMIT_SLOWDOWNS]);
-  (*cf_stats)["io_stalls.level0_slowdown_with_compaction"] =
-      std::to_string(cf_stats_count_[LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS]);
-  (*cf_stats)["io_stalls.level0_numfiles"] =
-      std::to_string(cf_stats_count_[L0_FILE_COUNT_LIMIT_STOPS]);
-  (*cf_stats)["io_stalls.level0_numfiles_with_compaction"] =
-      std::to_string(cf_stats_count_[LOCKED_L0_FILE_COUNT_LIMIT_STOPS]);
-  (*cf_stats)["io_stalls.stop_for_pending_compaction_bytes"] =
-      std::to_string(cf_stats_count_[PENDING_COMPACTION_BYTES_LIMIT_STOPS]);
-  (*cf_stats)["io_stalls.slowdown_for_pending_compaction_bytes"] =
-      std::to_string(cf_stats_count_[PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS]);
-  (*cf_stats)["io_stalls.memtable_compaction"] =
-      std::to_string(cf_stats_count_[MEMTABLE_LIMIT_STOPS]);
-  (*cf_stats)["io_stalls.memtable_slowdown"] =
-      std::to_string(cf_stats_count_[MEMTABLE_LIMIT_SLOWDOWNS]);
-
-  uint64_t total_stop = cf_stats_count_[L0_FILE_COUNT_LIMIT_STOPS] +
-                        cf_stats_count_[PENDING_COMPACTION_BYTES_LIMIT_STOPS] +
-                        cf_stats_count_[MEMTABLE_LIMIT_STOPS];
-
-  uint64_t total_slowdown =
-      cf_stats_count_[L0_FILE_COUNT_LIMIT_SLOWDOWNS] +
-      cf_stats_count_[PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS] +
-      cf_stats_count_[MEMTABLE_LIMIT_SLOWDOWNS];
-
-  (*cf_stats)["io_stalls.total_stop"] = std::to_string(total_stop);
-  (*cf_stats)["io_stalls.total_slowdown"] = std::to_string(total_slowdown);
-}
-
 void InternalStats::DumpCFStats(std::string* value) {
  DumpCFStatsNoFileHistogram(value);
  DumpCFFileHistogram(value);
@@ -1091,12 +1052,11 @@ void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {
  uint64_t ingest_keys_addfile = cf_stats_value_[INGESTED_NUM_KEYS_TOTAL];
  // Cumulative summary
  uint64_t total_stall_count =
-      cf_stats_count_[L0_FILE_COUNT_LIMIT_SLOWDOWNS] +
-      cf_stats_count_[L0_FILE_COUNT_LIMIT_STOPS] +
-      cf_stats_count_[PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS] +
-      cf_stats_count_[PENDING_COMPACTION_BYTES_LIMIT_STOPS] +
-      cf_stats_count_[MEMTABLE_LIMIT_STOPS] +
-      cf_stats_count_[MEMTABLE_LIMIT_SLOWDOWNS];
+      cf_stats_count_[LEVEL0_SLOWDOWN_TOTAL] +
+      cf_stats_count_[LEVEL0_NUM_FILES_TOTAL] +
+      cf_stats_count_[SOFT_PENDING_COMPACTION_BYTES_LIMIT] +
+      cf_stats_count_[HARD_PENDING_COMPACTION_BYTES_LIMIT] +
+      cf_stats_count_[MEMTABLE_COMPACTION] + cf_stats_count_[MEMTABLE_SLOWDOWN];
  // Interval summary
  uint64_t interval_flush_ingest =
      flush_ingest - cf_stats_snapshot_.ingest_bytes_flush;
@@ -1185,32 +1145,31 @@ void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {
  cf_stats_snapshot_.compact_bytes_read = compact_bytes_read;
  cf_stats_snapshot_.compact_micros = compact_micros;

-  snprintf(buf, sizeof(buf),
-           "Stalls(count): %" PRIu64
-           " level0_slowdown, "
-           "%" PRIu64
-           " level0_slowdown_with_compaction, "
-           "%" PRIu64
-           " level0_numfiles, "
-           "%" PRIu64
-           " level0_numfiles_with_compaction, "
-           "%" PRIu64
-           " stop for pending_compaction_bytes, "
-           "%" PRIu64
-           " slowdown for pending_compaction_bytes, "
-           "%" PRIu64
-           " memtable_compaction, "
-           "%" PRIu64
-           " memtable_slowdown, "
-           "interval %" PRIu64 " total count\n",
-           cf_stats_count_[L0_FILE_COUNT_LIMIT_SLOWDOWNS],
-           cf_stats_count_[LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS],
-           cf_stats_count_[L0_FILE_COUNT_LIMIT_STOPS],
-           cf_stats_count_[LOCKED_L0_FILE_COUNT_LIMIT_STOPS],
-           cf_stats_count_[PENDING_COMPACTION_BYTES_LIMIT_STOPS],
-           cf_stats_count_[PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS],
-           cf_stats_count_[MEMTABLE_LIMIT_STOPS],
-           cf_stats_count_[MEMTABLE_LIMIT_SLOWDOWNS],
+  snprintf(buf, sizeof(buf), "Stalls(count): %" PRIu64
+                             " level0_slowdown, "
+                             "%" PRIu64
+                             " level0_slowdown_with_compaction, "
+                             "%" PRIu64
+                             " level0_numfiles, "
+                             "%" PRIu64
+                             " level0_numfiles_with_compaction, "
+                             "%" PRIu64
+                             " stop for pending_compaction_bytes, "
+                             "%" PRIu64
+                             " slowdown for pending_compaction_bytes, "
+                             "%" PRIu64
+                             " memtable_compaction, "
+                             "%" PRIu64
+                             " memtable_slowdown, "
+                             "interval %" PRIu64 " total count\n",
+           cf_stats_count_[LEVEL0_SLOWDOWN_TOTAL],
+           cf_stats_count_[LEVEL0_SLOWDOWN_WITH_COMPACTION],
+           cf_stats_count_[LEVEL0_NUM_FILES_TOTAL],
+           cf_stats_count_[LEVEL0_NUM_FILES_WITH_COMPACTION],
+           cf_stats_count_[HARD_PENDING_COMPACTION_BYTES_LIMIT],
+           cf_stats_count_[SOFT_PENDING_COMPACTION_BYTES_LIMIT],
+           cf_stats_count_[MEMTABLE_COMPACTION],
+           cf_stats_count_[MEMTABLE_SLOWDOWN],
           total_stall_count - cf_stats_snapshot_.stall_count);
  value->append(buf);

@@ -42,9 +42,8 @@ struct DBPropertyInfo {
  //      holding db mutex, which is only supported for int properties.
  bool (InternalStats::*handle_int)(uint64_t* value, DBImpl* db,
                                    Version* version);
-
-  // @param props Map of general properties to populate
-  bool (InternalStats::*handle_map)(std::map<std::string, std::string>* props);
+  bool (InternalStats::*handle_map)(
+      std::map<std::string, double>* compaction_stats);
 };

 extern const DBPropertyInfo* GetPropertyInfo(const Slice& property);
@@ -86,14 +85,14 @@ class InternalStats {
  static const std::map<LevelStatType, LevelStat> compaction_level_stats;

  enum InternalCFStatsType {
-    L0_FILE_COUNT_LIMIT_SLOWDOWNS,
-    LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS,
-    MEMTABLE_LIMIT_STOPS,
-    MEMTABLE_LIMIT_SLOWDOWNS,
-    L0_FILE_COUNT_LIMIT_STOPS,
-    LOCKED_L0_FILE_COUNT_LIMIT_STOPS,
-    PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS,
-    PENDING_COMPACTION_BYTES_LIMIT_STOPS,
+    LEVEL0_SLOWDOWN_TOTAL,
+    LEVEL0_SLOWDOWN_WITH_COMPACTION,
+    MEMTABLE_COMPACTION,
+    MEMTABLE_SLOWDOWN,
+    LEVEL0_NUM_FILES_TOTAL,
+    LEVEL0_NUM_FILES_WITH_COMPACTION,
+    SOFT_PENDING_COMPACTION_BYTES_LIMIT,
+    HARD_PENDING_COMPACTION_BYTES_LIMIT,
    WRITE_STALLS_ENUM_MAX,
    BYTES_FLUSHED,
    BYTES_INGESTED_ADD_FILE,
@@ -299,7 +298,7 @@ class InternalStats {

  bool GetMapProperty(const DBPropertyInfo& property_info,
                      const Slice& property,
-                      std::map<std::string, std::string>* value);
+                      std::map<std::string, double>* value);

  bool GetIntProperty(const DBPropertyInfo& property_info, uint64_t* value,
                      DBImpl* db);
@@ -313,11 +312,10 @@ class InternalStats {

 private:
  void DumpDBStats(std::string* value);
-  void DumpCFMapStats(std::map<std::string, std::string>* cf_stats);
+  void DumpCFMapStats(std::map<std::string, double>* cf_stats);
  void DumpCFMapStats(
      std::map<int, std::map<LevelStatType, double>>* level_stats,
      CompactionStats* compaction_stats_sum);
-  void DumpCFMapStatsIOStalls(std::map<std::string, std::string>* cf_stats);
  void DumpCFStats(std::string* value);
  void DumpCFStatsNoFileHistogram(std::string* value);
  void DumpCFFileHistogram(std::string* value);
@@ -426,7 +424,7 @@ class InternalStats {
  bool HandleCompressionRatioAtLevelPrefix(std::string* value, Slice suffix);
  bool HandleLevelStats(std::string* value, Slice suffix);
  bool HandleStats(std::string* value, Slice suffix);
-  bool HandleCFMapStats(std::map<std::string, std::string>* compaction_stats);
+  bool HandleCFMapStats(std::map<std::string, double>* compaction_stats);
  bool HandleCFStats(std::string* value, Slice suffix);
  bool HandleCFStatsNoFileHistogram(std::string* value, Slice suffix);
  bool HandleCFFileHistogram(std::string* value, Slice suffix);
@@ -498,14 +496,14 @@ class InternalStats {
 class InternalStats {
 public:
  enum InternalCFStatsType {
-    L0_FILE_COUNT_LIMIT_SLOWDOWNS,
-    LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS,
-    MEMTABLE_LIMIT_STOPS,
-    MEMTABLE_LIMIT_SLOWDOWNS,
-    L0_FILE_COUNT_LIMIT_STOPS,
-    LOCKED_L0_FILE_COUNT_LIMIT_STOPS,
-    PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS,
-    PENDING_COMPACTION_BYTES_LIMIT_STOPS,
+    LEVEL0_SLOWDOWN_TOTAL,
+    LEVEL0_SLOWDOWN_WITH_COMPACTION,
+    MEMTABLE_COMPACTION,
+    MEMTABLE_SLOWDOWN,
+    LEVEL0_NUM_FILES_TOTAL,
+    LEVEL0_NUM_FILES_WITH_COMPACTION,
+    SOFT_PENDING_COMPACTION_BYTES_LIMIT,
+    HARD_PENDING_COMPACTION_BYTES_LIMIT,
    WRITE_STALLS_ENUM_MAX,
    BYTES_FLUSHED,
    BYTES_INGESTED_ADD_FILE,
@@ -573,7 +571,7 @@ class InternalStats {

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

@@ -13,77 +13,17 @@
 #include <vector>

 #include "db/log_writer.h"
-#include "db/column_family.h"

 namespace rocksdb {

 class MemTable;
-struct SuperVersion;
-
-struct SuperVersionContext {
-  struct WriteStallNotification {
-    WriteStallInfo write_stall_info;
-    const ImmutableCFOptions* immutable_cf_options;
-  };
-
-  autovector<SuperVersion*> superversions_to_free;
-  autovector<WriteStallNotification> write_stall_notifications;
-  unique_ptr<SuperVersion> new_superversion;  // if nullptr no new superversion
-
-  explicit SuperVersionContext(bool create_superversion = false)
-    : new_superversion(create_superversion ? new SuperVersion() : nullptr) {}
-
-  void NewSuperVersion() {
-    new_superversion = unique_ptr<SuperVersion>(new SuperVersion());
-  }
-
-  inline bool HaveSomethingToDelete() const {
-    return superversions_to_free.size() > 0 ||
-           write_stall_notifications.size() > 0;
-  }
-
-  void PushWriteStallNotification(
-      WriteStallCondition old_cond, WriteStallCondition new_cond,
-      const std::string& name, const ImmutableCFOptions* ioptions) {
-#ifndef ROCKSDB_LITE
-    WriteStallNotification notif;
-    notif.write_stall_info.cf_name = name;
-    notif.write_stall_info.condition.prev = old_cond;
-    notif.write_stall_info.condition.cur = new_cond;
-    notif.immutable_cf_options = ioptions;
-    write_stall_notifications.push_back(notif);
-#endif  // !ROCKSDB_LITE
-  }
-
-  void Clean() {
-#ifndef ROCKSDB_LITE
-    // notify listeners on changed write stall conditions
-    for (auto& notif : write_stall_notifications) {
-      for (auto listener : notif.immutable_cf_options->listeners) {
-        listener->OnStallConditionsChanged(notif.write_stall_info);
-      }
-    }
-    write_stall_notifications.clear();
-#endif  // !ROCKSDB_LITE
-    // free superversions
-    for (auto s : superversions_to_free) {
-      delete s;
-    }
-    superversions_to_free.clear();
-  }
-
-  ~SuperVersionContext() {
-    assert(write_stall_notifications.size() == 0);
-    assert(superversions_to_free.size() == 0);
-  }
-};

 struct JobContext {
  inline bool HaveSomethingToDelete() const {
    return full_scan_candidate_files.size() || sst_delete_files.size() ||
           log_delete_files.size() || manifest_delete_files.size() ||
-           memtables_to_free.size() > 0 || logs_to_free.size() > 0 ||
-           superversion_context.HaveSomethingToDelete();
+           new_superversion != nullptr || superversions_to_free.size() > 0 ||
+           memtables_to_free.size() > 0 || logs_to_free.size() > 0;
  }

  // Structure to store information for candidate files to delete.
@@ -125,10 +65,12 @@ struct JobContext {
  // a list of memtables to be free
  autovector<MemTable*> memtables_to_free;

-  SuperVersionContext superversion_context;
+  autovector<SuperVersion*> superversions_to_free;

  autovector<log::Writer*> logs_to_free;

+  SuperVersion* new_superversion;  // if nullptr no new superversion
+
  // the current manifest_file_number, log_number and prev_log_number
  // that corresponds to the set of files in 'live'.
  uint64_t manifest_file_number;
@@ -141,13 +83,13 @@ struct JobContext {
  size_t num_alive_log_files = 0;
  uint64_t size_log_to_delete = 0;

-  explicit JobContext(int _job_id, bool create_superversion = false)
-    : superversion_context(create_superversion) {
+  explicit JobContext(int _job_id, bool create_superversion = false) {
    job_id = _job_id;
    manifest_file_number = 0;
    pending_manifest_file_number = 0;
    log_number = 0;
    prev_log_number = 0;
+    new_superversion = create_superversion ? new SuperVersion() : nullptr;
  }

  // For non-empty JobContext Clean() has to be called at least once before
@@ -155,22 +97,31 @@ struct JobContext {
  // unlocked DB mutex. Destructor doesn't call Clean() to avoid accidentally
  // doing potentially slow Clean() with locked DB mutex.
  void Clean() {
-    // free superversions
-    superversion_context.Clean();
    // free pending memtables
    for (auto m : memtables_to_free) {
      delete m;
    }
+    // free superversions
+    for (auto s : superversions_to_free) {
+      delete s;
+    }
    for (auto l : logs_to_free) {
      delete l;
    }
+    // if new_superversion was not used, it will be non-nullptr and needs
+    // to be freed here
+    delete new_superversion;

    memtables_to_free.clear();
+    superversions_to_free.clear();
    logs_to_free.clear();
+    new_superversion = nullptr;
  }

  ~JobContext() {
    assert(memtables_to_free.size() == 0);
+    assert(superversions_to_free.size() == 0);
+    assert(new_superversion == nullptr);
    assert(logs_to_free.size() == 0);
  }
 };
@@ -195,7 +195,7 @@ class LogTest : public ::testing::TestWithParam<int> {
    }
  }

-  void IncrementByte(int offset, char delta) {
+  void IncrementByte(int offset, int delta) {
    dest_contents()[offset] += delta;
  }

@@ -487,7 +487,7 @@ TEST_P(LogTest, ChecksumMismatch) {

 TEST_P(LogTest, UnexpectedMiddleType) {
  Write("foo");
-  SetByte(6, static_cast<char>(GetParam() ? kRecyclableMiddleType : kMiddleType));
+  SetByte(6, GetParam() ? kRecyclableMiddleType : kMiddleType);
  FixChecksum(0, 3, !!GetParam());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3U, DroppedBytes());
@@ -496,7 +496,7 @@ TEST_P(LogTest, UnexpectedMiddleType) {

 TEST_P(LogTest, UnexpectedLastType) {
  Write("foo");
-  SetByte(6, static_cast<char>(GetParam() ? kRecyclableLastType : kLastType));
+  SetByte(6, GetParam() ? kRecyclableLastType : kLastType);
  FixChecksum(0, 3, !!GetParam());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3U, DroppedBytes());
@@ -506,7 +506,7 @@ TEST_P(LogTest, UnexpectedLastType) {
 TEST_P(LogTest, UnexpectedFullType) {
  Write("foo");
  Write("bar");
-  SetByte(6, static_cast<char>(GetParam() ? kRecyclableFirstType : kFirstType));
+  SetByte(6, GetParam() ? kRecyclableFirstType : kFirstType);
  FixChecksum(0, 3, !!GetParam());
  ASSERT_EQ("bar", Read());
  ASSERT_EQ("EOF", Read());
@@ -517,7 +517,7 @@ TEST_P(LogTest, UnexpectedFullType) {
 TEST_P(LogTest, UnexpectedFirstType) {
  Write("foo");
  Write(BigString("bar", 100000));
-  SetByte(6, static_cast<char>(GetParam() ? kRecyclableFirstType : kFirstType));
+  SetByte(6, GetParam() ? kRecyclableFirstType : kFirstType);
  FixChecksum(0, 3, !!GetParam());
  ASSERT_EQ(BigString("bar", 100000), Read());
  ASSERT_EQ("EOF", Read());
@@ -17,7 +17,6 @@
 #include "db/merge_context.h"
 #include "db/merge_helper.h"
 #include "db/pinned_iterators_manager.h"
-#include "db/read_callback.h"
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/statistics.h"
 #include "port/port.h"
@@ -493,7 +492,7 @@ void MemTable::Add(SequenceNumber s, ValueType type,
    }

    // The first sequence number inserted into the memtable
-    assert(first_seqno_ == 0 || s >= first_seqno_);
+    assert(first_seqno_ == 0 || s > first_seqno_);
    if (first_seqno_ == 0) {
      first_seqno_.store(s, std::memory_order_relaxed);

@@ -557,15 +556,7 @@ struct Saver {
  Statistics* statistics;
  bool inplace_update_support;
  Env* env_;
-  ReadCallback* callback_;
  bool* is_blob_index;
-
-  bool CheckCallback(SequenceNumber _seq) {
-    if (callback_) {
-      return callback_->IsCommitted(_seq);
-    }
-    return true;
-  }
 };
 }  // namespace

@@ -593,14 +584,7 @@ static bool SaveValue(void* arg, const char* entry) {
    // Correct user key
    const uint64_t tag = DecodeFixed64(key_ptr + key_length - 8);
    ValueType type;
-    SequenceNumber seq;
-    UnPackSequenceAndType(tag, &seq, &type);
-    // If the value is not in the snapshot, skip it
-    if (!s->CheckCallback(seq)) {
-      return true;  // to continue to the next seq
-    }
-
-    s->seq = seq;
+    UnPackSequenceAndType(tag, &s->seq, &type);

    if ((type == kTypeValue || type == kTypeMerge || type == kTypeBlobIndex) &&
        range_del_agg->ShouldDelete(Slice(key_ptr, key_length))) {
@@ -629,12 +613,10 @@ static bool SaveValue(void* arg, const char* entry) {
        Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
        *(s->status) = Status::OK();
        if (*(s->merge_in_progress)) {
-          if (s->value != nullptr) {
-            *(s->status) = MergeHelper::TimedFullMerge(
-                merge_operator, s->key->user_key(), &v,
-                merge_context->GetOperands(), s->value, s->logger,
-                s->statistics, s->env_, nullptr /* result_operand */, true);
-          }
+          *(s->status) = MergeHelper::TimedFullMerge(
+              merge_operator, s->key->user_key(), &v,
+              merge_context->GetOperands(), s->value, s->logger, s->statistics,
+              s->env_, nullptr /* result_operand */, true);
        } else if (s->value != nullptr) {
          s->value->assign(v.data(), v.size());
        }
@@ -651,12 +633,10 @@ static bool SaveValue(void* arg, const char* entry) {
      case kTypeSingleDeletion:
      case kTypeRangeDeletion: {
        if (*(s->merge_in_progress)) {
-          if (s->value != nullptr) {
-            *(s->status) = MergeHelper::TimedFullMerge(
-                merge_operator, s->key->user_key(), nullptr,
-                merge_context->GetOperands(), s->value, s->logger,
-                s->statistics, s->env_, nullptr /* result_operand */, true);
-          }
+          *(s->status) = MergeHelper::TimedFullMerge(
+              merge_operator, s->key->user_key(), nullptr,
+              merge_context->GetOperands(), s->value, s->logger, s->statistics,
+              s->env_, nullptr /* result_operand */, true);
        } else {
          *(s->status) = Status::NotFound();
        }
@@ -678,14 +658,6 @@ static bool SaveValue(void* arg, const char* entry) {
        *(s->merge_in_progress) = true;
        merge_context->PushOperand(
            v, s->inplace_update_support == false /* operand_pinned */);
-        if (merge_operator->ShouldMerge(merge_context->GetOperands())) {
-          *(s->status) = MergeHelper::TimedFullMerge(
-              merge_operator, s->key->user_key(), nullptr,
-              merge_context->GetOperands(), s->value, s->logger, s->statistics,
-              s->env_, nullptr /* result_operand */, true);
-          *(s->found_final_value) = true;
-          return false;
-        }
        return true;
      }
      default:
@@ -701,8 +673,7 @@ static bool SaveValue(void* arg, const char* entry) {
 bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
                   MergeContext* merge_context,
                   RangeDelAggregator* range_del_agg, SequenceNumber* seq,
-                   const ReadOptions& read_opts, ReadCallback* callback,
-                   bool* is_blob_index) {
+                   const ReadOptions& read_opts, bool* is_blob_index) {
  // The sequence number is updated synchronously in version_set.h
  if (IsEmpty()) {
    // Avoiding recording stats for speed.
@@ -748,7 +719,6 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
    saver.inplace_update_support = moptions_.inplace_update_support;
    saver.statistics = moptions_.statistics;
    saver.env_ = env_;
-    saver.callback_ = callback;
    saver.is_blob_index = is_blob_index;
    table_->Get(key, &saver, SaveValue);

@@ -807,7 +777,6 @@ void MemTable::Update(SequenceNumber seq,
          assert((unsigned)((p + value.size()) - entry) ==
                 (unsigned)(VarintLength(key_length) + key_length +
                            VarintLength(value.size()) + value.size()));
-          RecordTick(moptions_.statistics, NUMBER_KEYS_UPDATED);
          return;
        }
      }
@@ -17,7 +17,6 @@
 #include <vector>
 #include "db/dbformat.h"
 #include "db/range_del_aggregator.h"
-#include "db/read_callback.h"
 #include "db/version_edit.h"
 #include "monitoring/instrumented_mutex.h"
 #include "options/cf_options.h"
@@ -187,15 +186,14 @@ class MemTable {
  bool Get(const LookupKey& key, std::string* value, Status* s,
           MergeContext* merge_context, RangeDelAggregator* range_del_agg,
           SequenceNumber* seq, const ReadOptions& read_opts,
-           ReadCallback* callback = nullptr, bool* is_blob_index = nullptr);
+           bool* is_blob_index = nullptr);

  bool Get(const LookupKey& key, std::string* value, Status* s,
           MergeContext* merge_context, RangeDelAggregator* range_del_agg,
-           const ReadOptions& read_opts, ReadCallback* callback = nullptr,
-           bool* is_blob_index = nullptr) {
+           const ReadOptions& read_opts, bool* is_blob_index = nullptr) {
    SequenceNumber seq;
    return Get(key, value, s, merge_context, range_del_agg, &seq, read_opts,
-               callback, is_blob_index);
+               is_blob_index);
  }

  // Attempts to update the new_value inplace, else does normal Add
@@ -105,9 +105,9 @@ bool MemTableListVersion::Get(const LookupKey& key, std::string* value,
                              Status* s, MergeContext* merge_context,
                              RangeDelAggregator* range_del_agg,
                              SequenceNumber* seq, const ReadOptions& read_opts,
-                              ReadCallback* callback, bool* is_blob_index) {
+                              bool* is_blob_index) {
  return GetFromList(&memlist_, key, value, s, merge_context, range_del_agg,
-                     seq, read_opts, callback, is_blob_index);
+                     seq, read_opts, is_blob_index);
 }

 bool MemTableListVersion::GetFromHistory(
@@ -115,30 +115,25 @@ bool MemTableListVersion::GetFromHistory(
    MergeContext* merge_context, RangeDelAggregator* range_del_agg,
    SequenceNumber* seq, const ReadOptions& read_opts, bool* is_blob_index) {
  return GetFromList(&memlist_history_, key, value, s, merge_context,
-                     range_del_agg, seq, read_opts, nullptr /*read_callback*/,
-                     is_blob_index);
+                     range_del_agg, seq, read_opts, is_blob_index);
 }

 bool MemTableListVersion::GetFromList(
    std::list<MemTable*>* list, const LookupKey& key, std::string* value,
    Status* s, MergeContext* merge_context, RangeDelAggregator* range_del_agg,
-    SequenceNumber* seq, const ReadOptions& read_opts, ReadCallback* callback,
-    bool* is_blob_index) {
+    SequenceNumber* seq, const ReadOptions& read_opts, bool* is_blob_index) {
  *seq = kMaxSequenceNumber;

  for (auto& memtable : *list) {
    SequenceNumber current_seq = kMaxSequenceNumber;

    bool done = memtable->Get(key, value, s, merge_context, range_del_agg,
-                              &current_seq, read_opts, callback, is_blob_index);
+                              &current_seq, read_opts, is_blob_index);
    if (*seq == kMaxSequenceNumber) {
      // Store the most recent sequence number of any operation on this key.
      // Since we only care about the most recent change, we only need to
      // return the first operation found when searching memtables in
      // reverse-chronological order.
-      // current_seq would be equal to kMaxSequenceNumber if the value was to be
-      // skipped. This allows seq to be assigned again when the next value is
-      // read.
      *seq = current_seq;
    }

@@ -55,15 +55,14 @@ class MemTableListVersion {
  bool Get(const LookupKey& key, std::string* value, Status* s,
           MergeContext* merge_context, RangeDelAggregator* range_del_agg,
           SequenceNumber* seq, const ReadOptions& read_opts,
-           ReadCallback* callback = nullptr, bool* is_blob_index = nullptr);
+           bool* is_blob_index = nullptr);

  bool Get(const LookupKey& key, std::string* value, Status* s,
           MergeContext* merge_context, RangeDelAggregator* range_del_agg,
-           const ReadOptions& read_opts, ReadCallback* callback = nullptr,
-           bool* is_blob_index = nullptr) {
+           const ReadOptions& read_opts, bool* is_blob_index = nullptr) {
    SequenceNumber seq;
    return Get(key, value, s, merge_context, range_del_agg, &seq, read_opts,
-               callback, is_blob_index);
+               is_blob_index);
  }

  // Similar to Get(), but searches the Memtable history of memtables that
@@ -122,9 +121,7 @@ class MemTableListVersion {
  bool GetFromList(std::list<MemTable*>* list, const LookupKey& key,
                   std::string* value, Status* s, MergeContext* merge_context,
                   RangeDelAggregator* range_del_agg, SequenceNumber* seq,
-                   const ReadOptions& read_opts,
-                   ReadCallback* callback = nullptr,
-                   bool* is_blob_index = nullptr);
+                   const ReadOptions& read_opts, bool* is_blob_index = nullptr);

  void AddMemTable(MemTable* m);

@@ -43,9 +43,11 @@ void RangeDelAggregator::InitRep(const std::vector<SequenceNumber>& snapshots) {
  rep_->pinned_iters_mgr_.StartPinning();
 }

-bool RangeDelAggregator::ShouldDeleteImpl(
+bool RangeDelAggregator::ShouldDelete(
    const Slice& internal_key, RangeDelAggregator::RangePositioningMode mode) {
-  assert(rep_ != nullptr);
+  if (rep_ == nullptr) {
+    return false;
+  }
  ParsedInternalKey parsed;
  if (!ParseInternalKey(internal_key, &parsed)) {
    assert(false);
@@ -53,11 +55,13 @@ bool RangeDelAggregator::ShouldDeleteImpl(
  return ShouldDelete(parsed, mode);
 }

-bool RangeDelAggregator::ShouldDeleteImpl(
+bool RangeDelAggregator::ShouldDelete(
    const ParsedInternalKey& parsed,
    RangeDelAggregator::RangePositioningMode mode) {
  assert(IsValueType(parsed.type));
-  assert(rep_ != nullptr);
+  if (rep_ == nullptr) {
+    return false;
+  }
  auto& positional_tombstone_map = GetPositionalTombstoneMap(parsed.sequence);
  const auto& tombstone_map = positional_tombstone_map.raw_map;
  if (tombstone_map.empty()) {
@@ -74,24 +74,9 @@ class RangeDelAggregator {
  //             the deletion whose interval contains this key. Otherwise, its
  //             value must be kFullScan indicating linear scan from beginning..
  bool ShouldDelete(const ParsedInternalKey& parsed,
-                    RangePositioningMode mode = kFullScan) {
-    if (rep_ == nullptr) {
-      return false;
-    }
-    return ShouldDeleteImpl(parsed, mode);
-  }
+                    RangePositioningMode mode = kFullScan);
  bool ShouldDelete(const Slice& internal_key,
-                    RangePositioningMode mode = kFullScan) {
-    if (rep_ == nullptr) {
-      return false;
-    }
-    return ShouldDeleteImpl(internal_key, mode);
-  }
-  bool ShouldDeleteImpl(const ParsedInternalKey& parsed,
-                        RangePositioningMode mode = kFullScan);
-  bool ShouldDeleteImpl(const Slice& internal_key,
-                        RangePositioningMode mode = kFullScan);
-
+                    RangePositioningMode mode = kFullScan);
  bool ShouldAddTombstones(bool bottommost_level = false);

  // Adds tombstones to the tombstone aggregation structure maintained by this
@@ -1,21 +0,0 @@
-// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include "rocksdb/types.h"
-
-namespace rocksdb {
-
-class ReadCallback {
- public:
-  virtual ~ReadCallback() {}
-
-  // Will be called to see if the seq number accepted; if not it moves on to the
-  // next seq number.
-  virtual bool IsCommitted(SequenceNumber seq) = 0;
-};
-
-}  //  namespace rocksdb
@@ -99,7 +99,7 @@ class Repairer {
        env_(db_options.env),
        env_options_(),
        db_options_(SanitizeOptions(dbname_, db_options)),
-        immutable_db_options_(ImmutableDBOptions(db_options_)),
+        immutable_db_options_(db_options_),
        icmp_(default_cf_opts.comparator),
        default_cf_opts_(default_cf_opts),
        default_cf_iopts_(
@@ -254,21 +254,14 @@ class Repairer {
    }

    // search wal_dir if user uses a customize wal_dir
-    bool same = false;
-    Status status = env_->AreFilesSame(db_options_.wal_dir, dbname_, &same);
-    if (status.IsNotSupported()) {
-      same = db_options_.wal_dir == dbname_;
-      status = Status::OK();
-    } else if (!status.ok()) {
-      return status;
-    }
-
-    if (!same) {
-      to_search_paths.push_back(db_options_.wal_dir);
+    if (!db_options_.wal_dir.empty() && 
+        db_options_.wal_dir != dbname_) {
+        to_search_paths.push_back(db_options_.wal_dir);
    }

    for (size_t path_id = 0; path_id < to_search_paths.size(); path_id++) {
-      status = env_->GetChildren(to_search_paths[path_id], &filenames);
+      Status status =
+          env_->GetChildren(to_search_paths[path_id], &filenames);
      if (!status.ok()) {
        return status;
      }
@@ -397,21 +390,23 @@ class Repairer {
      ro.total_order_seek = true;
      Arena arena;
      ScopedArenaIterator iter(mem->NewIterator(ro, &arena));
+      EnvOptions optimized_env_options =
+          env_->OptimizeForCompactionTableWrite(env_options_, immutable_db_options_);
+
      int64_t _current_time = 0;
      status = env_->GetCurrentTime(&_current_time);  // ignore error
      const uint64_t current_time = static_cast<uint64_t>(_current_time);
-      SnapshotChecker* snapshot_checker = DisableGCSnapshotChecker::Instance();
+
      status = BuildTable(
          dbname_, env_, *cfd->ioptions(), *cfd->GetLatestMutableCFOptions(),
-          env_options_, table_cache_, iter.get(),
+          optimized_env_options, table_cache_, iter.get(),
          std::unique_ptr<InternalIterator>(mem->NewRangeTombstoneIterator(ro)),
          &meta, cfd->internal_comparator(),
          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
-          {}, kMaxSequenceNumber, snapshot_checker, kNoCompression,
-          CompressionOptions(), false, nullptr /* internal_stats */,
-          TableFileCreationReason::kRecovery, nullptr /* event_logger */,
-          0 /* job_id */, Env::IO_HIGH, nullptr /* table_properties */,
-          -1 /* level */, current_time);
+          {}, kMaxSequenceNumber, kNoCompression, CompressionOptions(), false,
+          nullptr /* internal_stats */, TableFileCreationReason::kRecovery,
+          nullptr /* event_logger */, 0 /* job_id */, Env::IO_HIGH,
+          nullptr /* table_properties */, -1 /* level */, current_time);
      ROCKS_LOG_INFO(db_options_.info_log,
                     "Log #%" PRIu64 ": %d ops saved to Table #%" PRIu64 " %s",
                     log, counter, meta.fd.GetNumber(),
@@ -565,8 +560,6 @@ class Repairer {
                     table->meta.largest, table->min_sequence,
                     table->max_sequence, table->meta.marked_for_compaction);
      }
-      assert(next_file_number_ > 0);
-      vset_.MarkFileNumberUsed(next_file_number_ - 1);
      mutex_.Lock();
      Status status = vset_.LogAndApply(
          cfd, *cfd->GetLatestMutableCFOptions(), &edit, &mutex_,
@@ -618,13 +611,11 @@ Status GetDefaultCFOptions(
 }  // anonymous namespace

 Status RepairDB(const std::string& dbname, const DBOptions& db_options,
-                const std::vector<ColumnFamilyDescriptor>& column_families
-                ) {
+                const std::vector<ColumnFamilyDescriptor>& column_families) {
  ColumnFamilyOptions default_cf_opts;
  Status status = GetDefaultCFOptions(column_families, &default_cf_opts);
  if (status.ok()) {
-    Repairer repairer(dbname, db_options, column_families,
-                      default_cf_opts,
+    Repairer repairer(dbname, db_options, column_families, default_cf_opts,
                      ColumnFamilyOptions() /* unknown_cf_opts */,
                      false /* create_unknown_cfs */);
    status = repairer.Run();
@@ -638,8 +629,7 @@ Status RepairDB(const std::string& dbname, const DBOptions& db_options,
  ColumnFamilyOptions default_cf_opts;
  Status status = GetDefaultCFOptions(column_families, &default_cf_opts);
  if (status.ok()) {
-    Repairer repairer(dbname, db_options,
-                      column_families, default_cf_opts,
+    Repairer repairer(dbname, db_options, column_families, default_cf_opts,
                      unknown_cf_opts, true /* create_unknown_cfs */);
    status = repairer.Run();
  }
@@ -649,8 +639,7 @@ Status RepairDB(const std::string& dbname, const DBOptions& db_options,
 Status RepairDB(const std::string& dbname, const Options& options) {
  DBOptions db_options(options);
  ColumnFamilyOptions cf_options(options);
-  Repairer repairer(dbname, db_options,
-                    {}, cf_options /* default_cf_opts */,
+  Repairer repairer(dbname, db_options, {}, cf_options /* default_cf_opts */,
                    cf_options /* unknown_cf_opts */,
                    true /* create_unknown_cfs */);
  return repairer.Run();
@@ -108,23 +108,6 @@ TEST_F(RepairTest, IncompleteManifest) {
  ASSERT_EQ(Get("key2"), "val2");
 }

-TEST_F(RepairTest, PostRepairSstFileNumbering) {
-  // Verify after a DB is repaired, new files will be assigned higher numbers
-  // than old files.
-  Put("key", "val");
-  Flush();
-  Put("key2", "val2");
-  Flush();
-  uint64_t pre_repair_file_num = dbfull()->TEST_Current_Next_FileNo();
-  Close();
-
-  ASSERT_OK(RepairDB(dbname_, CurrentOptions()));
-
-  Reopen(CurrentOptions());
-  uint64_t post_repair_file_num = dbfull()->TEST_Current_Next_FileNo();
-  ASSERT_GE(post_repair_file_num, pre_repair_file_num);
-}
-
 TEST_F(RepairTest, LostSst) {
  // Delete one of the SST files but preserve the manifest that refers to it,
  // then verify the DB is still usable for the intact SST.
@@ -326,25 +309,6 @@ TEST_F(RepairTest, RepairColumnFamilyOptions) {
  }
 }

-TEST_F(RepairTest, DbNameContainsTrailingSlash) {
-  {
-    bool tmp;
-    if (env_->AreFilesSame("", "", &tmp).IsNotSupported()) {
-      fprintf(stderr,
-              "skipping RepairTest.DbNameContainsTrailingSlash due to "
-              "unsupported Env::AreFilesSame\n");
-      return;
-    }
-  }
-
-  Put("key", "val");
-  Flush();
-  Close();
-
-  ASSERT_OK(RepairDB(dbname_ + "/", CurrentOptions()));
-  Reopen(CurrentOptions());
-  ASSERT_EQ(Get("key"), "val");
-}
 #endif  // ROCKSDB_LITE
 }  // namespace rocksdb

@@ -1,52 +0,0 @@
-// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-#include "rocksdb/types.h"
-
-namespace rocksdb {
-
-// Callback class that control GC of duplicate keys in flush/compaction
-class SnapshotChecker {
- public:
-  virtual ~SnapshotChecker() {}
-  virtual bool IsInSnapshot(SequenceNumber sequence,
-                            SequenceNumber snapshot_sequence) const = 0;
-};
-
-class DisableGCSnapshotChecker : public SnapshotChecker {
- public:
-  virtual ~DisableGCSnapshotChecker() {}
-  virtual bool IsInSnapshot(SequenceNumber sequence,
-                            SequenceNumber snapshot_sequence) const {
-    // By returning false, we prevent all the values from being GCed
-    return false;
-  }
-  static DisableGCSnapshotChecker* Instance() { return &instance_; }
-
- protected:
-  static DisableGCSnapshotChecker instance_;
-  explicit DisableGCSnapshotChecker() {}
-};
-
-class WritePreparedTxnDB;
-
-// Callback class created by WritePreparedTxnDB to check if a key
-// is visible by a snapshot.
-class WritePreparedSnapshotChecker : public SnapshotChecker {
- public:
-  explicit WritePreparedSnapshotChecker(WritePreparedTxnDB* txn_db);
-  virtual ~WritePreparedSnapshotChecker() {}
-
-  virtual bool IsInSnapshot(SequenceNumber sequence,
-                            SequenceNumber snapshot_sequence) const override;
-
- private:
-#ifndef ROCKSDB_LITE
-  const WritePreparedTxnDB* const txn_db_;
-#endif  // !ROCKSDB_LITE
-};
-
-}  // namespace rocksdb
@@ -225,12 +225,7 @@ InternalIterator* TableCache::NewIterator(
  }
  InternalIterator* result = nullptr;
  if (s.ok()) {
-    if (options.table_filter &&
-        !options.table_filter(*table_reader->GetTableProperties())) {
-      result = NewEmptyInternalIterator(arena);
-    } else {
-      result = table_reader->NewIterator(options, arena, skip_filters);
-    }
+    result = table_reader->NewIterator(options, arena, skip_filters);
    if (create_new_table_reader) {
      assert(handle == nullptr);
      result->RegisterCleanup(&DeleteTableReader, table_reader, nullptr);
@@ -59,6 +59,21 @@ InternalKeyPropertiesCollector::GetReadableProperties() const {

 namespace {

+EntryType GetEntryType(ValueType value_type) {
+  switch (value_type) {
+    case kTypeValue:
+      return kEntryPut;
+    case kTypeDeletion:
+      return kEntryDelete;
+    case kTypeSingleDeletion:
+      return kEntrySingleDelete;
+    case kTypeMerge:
+      return kEntryMerge;
+    default:
+      return kEntryOther;
+  }
+}
+
 uint64_t GetUint64Property(const UserCollectedProperties& props,
                           const std::string property_name,
                           bool* property_present) {
@@ -241,57 +241,13 @@ void TransactionLogIteratorImpl::UpdateCurrentWriteBatch(const Slice& record) {
    }
    startingSequenceNumber_ = expectedSeq;
    // currentStatus_ will be set to Ok if reseek succeeds
-    // Note: this is still ok in seq_pre_batch_ && concurrent_preparep_ mode
-    // that allows gaps in the WAL since it will still skip over the gap.
    currentStatus_ = Status::NotFound("Gap in sequence numbers");
-    // In seq_per_batch mode, gaps in the seq are possible so the strict mode
-    // should be disabled
-    return SeekToStartSequence(currentFileIndex_, !options_->seq_per_batch);
+    return SeekToStartSequence(currentFileIndex_, true);
  }

-  struct BatchCounter : public WriteBatch::Handler {
-    SequenceNumber sequence_;
-    BatchCounter(SequenceNumber sequence) : sequence_(sequence) {}
-    Status MarkNoop(bool empty_batch) override {
-      if (!empty_batch) {
-        sequence_++;
-      }
-      return Status::OK();
-    }
-    Status MarkEndPrepare(const Slice&) override {
-      sequence_++;
-      return Status::OK();
-    }
-    Status MarkCommit(const Slice&) override {
-      sequence_++;
-      return Status::OK();
-    }
-
-    Status PutCF(uint32_t cf, const Slice& key, const Slice& val) override {
-      return Status::OK();
-    }
-    Status DeleteCF(uint32_t cf, const Slice& key) override {
-      return Status::OK();
-    }
-    Status SingleDeleteCF(uint32_t cf, const Slice& key) override {
-      return Status::OK();
-    }
-    Status MergeCF(uint32_t cf, const Slice& key, const Slice& val) override {
-      return Status::OK();
-    }
-    Status MarkBeginPrepare() override { return Status::OK(); }
-    Status MarkRollback(const Slice&) override { return Status::OK(); }
-  };
-
  currentBatchSeq_ = WriteBatchInternal::Sequence(batch.get());
-  if (options_->seq_per_batch) {
-    BatchCounter counter(currentBatchSeq_);
-    batch->Iterate(&counter);
-    currentLastSeq_ = counter.sequence_;
-  } else {
-    currentLastSeq_ =
-        currentBatchSeq_ + WriteBatchInternal::Count(batch.get()) - 1;
-  }
+  currentLastSeq_ = currentBatchSeq_ +
+                    WriteBatchInternal::Count(batch.get()) - 1;
  // currentBatchSeq_ can only change here
  assert(currentLastSeq_ <= versions_->LastSequence());

@@ -274,12 +274,11 @@ class VersionBuilder::Rep {
        auto exising = levels_[level].added_files.find(number);
        if (exising != levels_[level].added_files.end()) {
          UnrefFile(exising->second);
-          levels_[level].added_files.erase(exising);
+          levels_[level].added_files.erase(number);
        }
      } else {
-        auto exising = invalid_levels_[level].find(number);
-        if (exising != invalid_levels_[level].end()) {
-          invalid_levels_[level].erase(exising);
+        if (invalid_levels_[level].count(number) > 0) {
+          invalid_levels_[level].erase(number);
        } else {
          // Deleting an non-existing file on invalid level.
          has_invalid_levels_ = true;
@@ -16,6 +16,7 @@
 #include <inttypes.h>
 #include <stdio.h>
 #include <algorithm>
+#include <climits>
 #include <map>
 #include <set>
 #include <string>
@@ -408,9 +409,9 @@ bool SomeFileOverlapsRange(
  // Binary search over file list
  uint32_t index = 0;
  if (smallest_user_key != nullptr) {
-    // Find the leftmost possible internal key for smallest_user_key
+    // Find the earliest possible internal key for smallest_user_key
    InternalKey small;
-    small.SetMinPossibleForUserKey(*smallest_user_key);
+    small.SetMaxPossibleForUserKey(*smallest_user_key);
    index = FindFile(icmp, file_level, small.Encode());
  }

@@ -576,7 +577,7 @@ Status Version::GetTableProperties(std::shared_ptr<const TableProperties>* tp,
  auto table_cache = cfd_->table_cache();
  auto ioptions = cfd_->ioptions();
  Status s = table_cache->GetTableProperties(
-      env_options_, cfd_->internal_comparator(), file_meta->fd,
+      vset_->env_options_, cfd_->internal_comparator(), file_meta->fd,
      tp, true /* no io */);
  if (s.ok()) {
    return s;
@@ -599,7 +600,7 @@ Status Version::GetTableProperties(std::shared_ptr<const TableProperties>* tp,
      TableFileName(vset_->db_options_->db_paths, file_meta->fd.GetNumber(),
                    file_meta->fd.GetPathId());
  }
-  s = ioptions->env->NewRandomAccessFile(file_name, &file, env_options_);
+  s = ioptions->env->NewRandomAccessFile(file_name, &file, vset_->env_options_);
  if (!s.ok()) {
    return s;
  }
@@ -711,7 +712,7 @@ size_t Version::GetMemoryUsageByTableReaders() {
  for (auto& file_level : storage_info_.level_files_brief_) {
    for (size_t i = 0; i < file_level.num_files; i++) {
      total_usage += cfd_->table_cache()->GetMemoryUsageByTableReader(
-          env_options_, cfd_->internal_comparator(),
+          vset_->env_options_, cfd_->internal_comparator(),
          file_level.files[i].fd);
    }
  }
@@ -931,12 +932,11 @@ VersionStorageInfo::VersionStorageInfo(
    current_num_non_deletions_ = ref_vstorage->current_num_non_deletions_;
    current_num_deletions_ = ref_vstorage->current_num_deletions_;
    current_num_samples_ = ref_vstorage->current_num_samples_;
-    oldest_snapshot_seqnum_ = ref_vstorage->oldest_snapshot_seqnum_;
  }
 }

 Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
-                 const EnvOptions& env_opt, uint64_t version_number)
+                 uint64_t version_number)
    : env_(vset->env_),
      cfd_(column_family_data),
      info_log_((cfd_ == nullptr) ? nullptr : cfd_->ioptions()->info_log),
@@ -959,15 +959,13 @@ Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
      next_(this),
      prev_(this),
      refs_(0),
-      env_options_(env_opt),
      version_number_(version_number) {}

 void Version::Get(const ReadOptions& read_options, const LookupKey& k,
                  PinnableSlice* value, Status* status,
                  MergeContext* merge_context,
                  RangeDelAggregator* range_del_agg, bool* value_found,
-                  bool* key_exists, SequenceNumber* seq, ReadCallback* callback,
-                  bool* is_blob) {
+                  bool* key_exists, SequenceNumber* seq, bool* is_blob) {
  Slice ikey = k.internal_key();
  Slice user_key = k.user_key();

@@ -983,7 +981,7 @@ void Version::Get(const ReadOptions& read_options, const LookupKey& k,
      user_comparator(), merge_operator_, info_log_, db_statistics_,
      status->ok() ? GetContext::kNotFound : GetContext::kMerge, user_key,
      value, value_found, merge_context, range_del_agg, this->env_, seq,
-      merge_operator_ ? &pinned_iters_mgr : nullptr, callback, is_blob);
+      merge_operator_ ? &pinned_iters_mgr : nullptr, is_blob);

  // Pin blocks that we read to hold merge operands
  if (merge_operator_) {
@@ -1092,7 +1090,6 @@ void Version::PrepareApply(
  storage_info_.GenerateFileIndexer();
  storage_info_.GenerateLevelFilesBrief();
  storage_info_.GenerateLevel0NonOverlapping();
-  storage_info_.GenerateBottommostFiles();
 }

 bool Version::MaybeInitializeFileMetaData(FileMetaData* file_meta) {
@@ -1331,7 +1328,6 @@ void VersionStorageInfo::EstimateCompactionBytesNeeded(

 namespace {
 uint32_t GetExpiredTtlFilesCount(const ImmutableCFOptions& ioptions,
-                                 const MutableCFOptions& mutable_cf_options,
                                 const std::vector<FileMetaData*>& files) {
  uint32_t ttl_expired_files_count = 0;

@@ -1345,8 +1341,8 @@ uint32_t GetExpiredTtlFilesCount(const ImmutableCFOptions& ioptions,
        auto creation_time =
            f->fd.table_reader->GetTableProperties()->creation_time;
        if (creation_time > 0 &&
-            creation_time < (current_time -
-                             mutable_cf_options.compaction_options_fifo.ttl)) {
+            creation_time <
+                (current_time - ioptions.compaction_options_fifo.ttl)) {
          ttl_expired_files_count++;
        }
      }
@@ -1393,19 +1389,19 @@ void VersionStorageInfo::ComputeCompactionScore(
      }

      if (compaction_style_ == kCompactionStyleFIFO) {
-        score = static_cast<double>(total_size) /
-                mutable_cf_options.compaction_options_fifo.max_table_files_size;
-        if (mutable_cf_options.compaction_options_fifo.allow_compaction) {
+        score =
+            static_cast<double>(total_size) /
+            immutable_cf_options.compaction_options_fifo.max_table_files_size;
+        if (immutable_cf_options.compaction_options_fifo.allow_compaction) {
          score = std::max(
              static_cast<double>(num_sorted_runs) /
                  mutable_cf_options.level0_file_num_compaction_trigger,
              score);
        }
-        if (mutable_cf_options.compaction_options_fifo.ttl > 0) {
-          score = std::max(
-              static_cast<double>(GetExpiredTtlFilesCount(
-                  immutable_cf_options, mutable_cf_options, files_[level])),
-              score);
+        if (immutable_cf_options.compaction_options_fifo.ttl > 0) {
+          score = std::max(static_cast<double>(GetExpiredTtlFilesCount(
+                               immutable_cf_options, files_[level])),
+                           score);
        }

      } else {
@@ -1450,7 +1446,6 @@ void VersionStorageInfo::ComputeCompactionScore(
    }
  }
  ComputeFilesMarkedForCompaction();
-  ComputeBottommostFilesMarkedForCompaction();
  EstimateCompactionBytesNeeded(mutable_cf_options);
 }

@@ -1526,7 +1521,6 @@ void VersionStorageInfo::AddFile(int level, FileMetaData* f, Logger* info_log) {
 // 4. GenerateFileIndexer();
 // 5. GenerateLevelFilesBrief();
 // 6. GenerateLevel0NonOverlapping();
-// 7. GenerateBottommostFiles();
 void VersionStorageInfo::SetFinalized() {
  finalized_ = true;
 #ifndef NDEBUG
@@ -1703,58 +1697,6 @@ void VersionStorageInfo::GenerateLevel0NonOverlapping() {
  }
 }

-void VersionStorageInfo::GenerateBottommostFiles() {
-  assert(!finalized_);
-  assert(bottommost_files_.empty());
-  for (size_t level = 0; level < level_files_brief_.size(); ++level) {
-    for (size_t file_idx = 0; file_idx < level_files_brief_[level].num_files;
-         ++file_idx) {
-      const FdWithKeyRange& f = level_files_brief_[level].files[file_idx];
-      int l0_file_idx;
-      if (level == 0) {
-        l0_file_idx = static_cast<int>(file_idx);
-      } else {
-        l0_file_idx = -1;
-      }
-      if (!RangeMightExistAfterSortedRun(f.smallest_key, f.largest_key,
-                                         static_cast<int>(level),
-                                         l0_file_idx)) {
-        bottommost_files_.emplace_back(static_cast<int>(level),
-                                       f.file_metadata);
-      }
-    }
-  }
-}
-
-void VersionStorageInfo::UpdateOldestSnapshot(SequenceNumber seqnum) {
-  assert(seqnum >= oldest_snapshot_seqnum_);
-  oldest_snapshot_seqnum_ = seqnum;
-  if (oldest_snapshot_seqnum_ > bottommost_files_mark_threshold_) {
-    ComputeBottommostFilesMarkedForCompaction();
-  }
-}
-
-void VersionStorageInfo::ComputeBottommostFilesMarkedForCompaction() {
-  bottommost_files_marked_for_compaction_.clear();
-  bottommost_files_mark_threshold_ = kMaxSequenceNumber;
-  for (auto& level_and_file : bottommost_files_) {
-    if (!level_and_file.second->being_compacted &&
-        level_and_file.second->largest_seqno != 0 &&
-        level_and_file.second->num_deletions > 1) {
-      // largest_seqno might be nonzero due to containing the final key in an
-      // earlier compaction, whose seqnum we didn't zero out. Multiple deletions
-      // ensures the file really contains deleted or overwritten keys.
-      if (level_and_file.second->largest_seqno < oldest_snapshot_seqnum_) {
-        bottommost_files_marked_for_compaction_.push_back(level_and_file);
-      } else {
-        bottommost_files_mark_threshold_ =
-            std::min(bottommost_files_mark_threshold_,
-                     level_and_file.second->largest_seqno);
-      }
-    }
-  }
-}
-
 void Version::Ref() {
  ++refs_;
 }
@@ -1975,8 +1917,7 @@ void VersionStorageInfo::ExtendFileRangeOverlappingInterval(
 #endif
  *start_index = mid_index + 1;
  *end_index = mid_index;
-  int count __attribute__((unused));
-  count = 0;
+  int count __attribute__((unused)) = 0;

  // check backwards from 'mid' to lower indices
  for (int i = mid_index; i >= 0 ; i--) {
@@ -2314,36 +2255,6 @@ uint64_t VersionStorageInfo::EstimateLiveDataSize() const {
  return size;
 }

-bool VersionStorageInfo::RangeMightExistAfterSortedRun(
-    const Slice& smallest_key, const Slice& largest_key, int last_level,
-    int last_l0_idx) {
-  assert((last_l0_idx != -1) == (last_level == 0));
-  // TODO(ajkr): this preserves earlier behavior where we considered an L0 file
-  // bottommost only if it's the oldest L0 file and there are no files on older
-  // levels. It'd be better to consider it bottommost if there's no overlap in
-  // older levels/files.
-  if (last_level == 0 &&
-      last_l0_idx != static_cast<int>(LevelFiles(0).size() - 1)) {
-    return true;
-  }
-
-  // Checks whether there are files living beyond the `last_level`. If lower
-  // levels have files, it checks for overlap between [`smallest_key`,
-  // `largest_key`] and those files. Bottomlevel optimizations can be made if
-  // there are no files in lower levels or if there is no overlap with the files
-  // in the lower levels.
-  for (int level = last_level + 1; level < num_levels(); level++) {
-    // The range is not in the bottommost level if there are files in lower
-    // levels when the `last_level` is 0 or if there are files in lower levels
-    // which overlap with [`smallest_key`, `largest_key`].
-    if (files_[level].size() > 0 &&
-        (last_level == 0 ||
-         OverlapInLevel(level, &smallest_key, &largest_key))) {
-      return true;
-    }
-  }
-  return false;
-}

 void Version::AddLiveFiles(std::vector<FileDescriptor>* live) {
  for (int level = 0; level < storage_info_.num_levels(); level++) {
@@ -2539,8 +2450,7 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
    LogAndApplyCFHelper(w.edit_list.front());
    batch_edits.push_back(w.edit_list.front());
  } else {
-    v = new Version(column_family_data, this, env_options_,
-                    current_version_number_++);
+    v = new Version(column_family_data, this, current_version_number_++);
    builder_guard.reset(new BaseReferencedVersionBuilder(column_family_data));
    auto* builder = builder_guard->version_builder();
    for (const auto& writer : manifest_writers_) {
@@ -2585,7 +2495,7 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
  // Unlock during expensive operations. New writes cannot get here
  // because &w is ensuring that all new writes get queued.
  {
-    EnvOptions opt_env_opts = env_->OptimizeForManifestWrite(env_options_);
+
    mu->Unlock();

    TEST_SYNC_POINT("VersionSet::LogAndApply:WriteManifest");
@@ -2607,6 +2517,7 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
      ROCKS_LOG_INFO(db_options_->info_log, "Creating manifest %" PRIu64 "\n",
                     pending_manifest_file_number_);
      unique_ptr<WritableFile> descriptor_file;
+      EnvOptions opt_env_opts = env_->OptimizeForManifestWrite(env_options_);
      s = NewWritableFile(
          env_, DescriptorFileName(dbname_, pending_manifest_file_number_),
          &descriptor_file, opt_env_opts);
@@ -2756,14 +2667,7 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
 void VersionSet::LogAndApplyCFHelper(VersionEdit* edit) {
  assert(edit->IsColumnFamilyManipulation());
  edit->SetNextFile(next_file_number_.load());
-  // The log might have data that is not visible to memtbale and hence have not
-  // updated the last_sequence_ yet. It is also possible that the log has is
-  // expecting some new data that is not written yet. Since LastSequence is an
-  // upper bound on the sequence, it is ok to record
-  // last_to_be_written_sequence_ as the last sequence.
-  edit->SetLastSequence(db_options_->concurrent_prepare
-                            ? last_to_be_written_sequence_
-                            : last_sequence_);
+  edit->SetLastSequence(last_sequence_);
  if (edit->is_column_family_drop_) {
    // if we drop column family, we have to make sure to save max column family,
    // so that we don't reuse existing ID
@@ -2786,14 +2690,7 @@ void VersionSet::LogAndApplyHelper(ColumnFamilyData* cfd,
    edit->SetPrevLogNumber(prev_log_number_);
  }
  edit->SetNextFile(next_file_number_.load());
-  // The log might have data that is not visible to memtbale and hence have not
-  // updated the last_sequence_ yet. It is also possible that the log has is
-  // expecting some new data that is not written yet. Since LastSequence is an
-  // upper bound on the sequence, it is ok to record
-  // last_to_be_written_sequence_ as the last sequence.
-  edit->SetLastSequence(db_options_->concurrent_prepare
-                            ? last_to_be_written_sequence_
-                            : last_sequence_);
+  edit->SetLastSequence(last_sequence_);

  builder->Apply(edit);
 }
@@ -3023,8 +2920,8 @@ Status VersionSet::Recover(

    column_family_set_->UpdateMaxColumnFamily(max_column_family);

-    MarkFileNumberUsed(previous_log_number);
-    MarkFileNumberUsed(log_number);
+    MarkFileNumberUsedDuringRecovery(previous_log_number);
+    MarkFileNumberUsedDuringRecovery(log_number);
  }

  // there were some column families in the MANIFEST that weren't specified
@@ -3071,8 +2968,7 @@ Status VersionSet::Recover(
            false /* prefetch_index_and_filter_in_cache */);
      }

-      Version* v =
-          new Version(cfd, this, env_options_, current_version_number_++);
+      Version* v = new Version(cfd, this, current_version_number_++);
      builder->SaveTo(v->storage_info());

      // Install recovered version
@@ -3430,8 +3326,7 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
      assert(builders_iter != builders.end());
      auto builder = builders_iter->second->version_builder();

-      Version* v =
-          new Version(cfd, this, env_options_, current_version_number_++);
+      Version* v = new Version(cfd, this, current_version_number_++);
      builder->SaveTo(v->storage_info());
      v->PrepareApply(*cfd->GetLatestMutableCFOptions(), false);

@@ -3470,9 +3365,9 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
 }
 #endif  // ROCKSDB_LITE

-void VersionSet::MarkFileNumberUsed(uint64_t number) {
-  // only called during recovery and repair which are single threaded, so this
-  // works because there can't be concurrent calls
+void VersionSet::MarkFileNumberUsedDuringRecovery(uint64_t number) {
+  // only called during recovery which is single threaded, so this works because
+  // there can't be concurrent calls
  if (next_file_number_.load(std::memory_order_relaxed) <= number) {
    next_file_number_.store(number + 1, std::memory_order_relaxed);
  }
@@ -3643,7 +3538,7 @@ uint64_t VersionSet::ApproximateSize(Version* v, const FdWithKeyRange& f,
    // approximate offset of "key" within the table.
    TableReader* table_reader_ptr;
    InternalIterator* iter = v->cfd_->table_cache()->NewIterator(
-        ReadOptions(), v->env_options_, v->cfd_->internal_comparator(), f.fd,
+        ReadOptions(), env_options_, v->cfd_->internal_comparator(), f.fd,
        nullptr /* range_del_agg */, &table_reader_ptr);
    if (table_reader_ptr != nullptr) {
      result = table_reader_ptr->ApproximateOffsetOf(key);
@@ -3874,7 +3769,7 @@ ColumnFamilyData* VersionSet::CreateColumnFamily(
    const ColumnFamilyOptions& cf_options, VersionEdit* edit) {
  assert(edit->is_column_family_add_);

-  Version* dummy_versions = new Version(nullptr, this, env_options_);
+  Version* dummy_versions = new Version(nullptr, this);
  // Ref() dummy version once so that later we can call Unref() to delete it
  // by avoiding calling "delete" explicitly (~Version is private)
  dummy_versions->Ref();
@@ -3882,8 +3777,7 @@ ColumnFamilyData* VersionSet::CreateColumnFamily(
      edit->column_family_name_, edit->column_family_, dummy_versions,
      cf_options);

-  Version* v =
-      new Version(new_cfd, this, env_options_, current_version_number_++);
+  Version* v = new Version(new_cfd, this, current_version_number_++);

  // Fill level target base information.
  v->storage_info()->CalculateBaseBytes(*new_cfd->ioptions(),
@@ -35,7 +35,6 @@
 #include "db/file_indexer.h"
 #include "db/log_reader.h"
 #include "db/range_del_aggregator.h"
-#include "db/read_callback.h"
 #include "db/table_cache.h"
 #include "db/version_builder.h"
 #include "db/version_edit.h"
@@ -135,18 +134,6 @@ class VersionStorageInfo {
  // ComputeCompactionScore()
  void ComputeFilesMarkedForCompaction();

-  // This computes bottommost_files_marked_for_compaction_ and is called by
-  // ComputeCompactionScore() or UpdateOldestSnapshot().
-  //
-  // Among bottommost files (assumes they've already been computed), marks the
-  // ones that have keys that would be eliminated if recompacted, according to
-  // the seqnum of the oldest existing snapshot. Must be called every time
-  // oldest snapshot changes as that is when bottom-level files can become
-  // eligible for compaction.
-  //
-  // REQUIRES: DB mutex held
-  void ComputeBottommostFilesMarkedForCompaction();
-
  // Generate level_files_brief_ from files_
  void GenerateLevelFilesBrief();
  // Sort all files for this version based on their file size and
@@ -159,16 +146,6 @@ class VersionStorageInfo {
    return level0_non_overlapping_;
  }

-  // Check whether each file in this version is bottommost (i.e., nothing in its
-  // key-range could possibly exist in an older file/level).
-  // REQUIRES: This version has not been saved
-  void GenerateBottommostFiles();
-
-  // Updates the oldest snapshot and related internal state, like the bottommost
-  // files marked for compaction.
-  // REQUIRES: DB mutex held
-  void UpdateOldestSnapshot(SequenceNumber oldest_snapshot_seqnum);
-
  int MaxInputLevel() const;
  int MaxOutputLevel(bool allow_ingest_behind) const;

@@ -286,14 +263,6 @@ class VersionStorageInfo {
    return files_marked_for_compaction_;
  }

-  // REQUIRES: This version has been saved (see VersionSet::SaveTo)
-  // REQUIRES: DB mutex held during access
-  const autovector<std::pair<int, FileMetaData*>>&
-  BottommostFilesMarkedForCompaction() const {
-    assert(finalized_);
-    return bottommost_files_marked_for_compaction_;
-  }
-
  int base_level() const { return base_level_; }

  // REQUIRES: lock is held
@@ -387,16 +356,6 @@ class VersionStorageInfo {

  bool force_consistency_checks() const { return force_consistency_checks_; }

-  // Returns whether any key in [`smallest_key`, `largest_key`] could appear in
-  // an older L0 file than `last_l0_idx` or in a greater level than `last_level`
-  //
-  // @param last_level Level after which we check for overlap
-  // @param last_l0_idx If `last_level == 0`, index of L0 file after which we
-  //    check for overlap; otherwise, must be -1
-  bool RangeMightExistAfterSortedRun(const Slice& smallest_key,
-                                     const Slice& largest_key, int last_level,
-                                     int last_l0_idx);
-
 private:
  const InternalKeyComparator* internal_comparator_;
  const Comparator* user_comparator_;
@@ -446,28 +405,6 @@ class VersionStorageInfo {
  // ComputeCompactionScore()
  autovector<std::pair<int, FileMetaData*>> files_marked_for_compaction_;

-  // These files are considered bottommost because none of their keys can exist
-  // at lower levels. They are not necessarily all in the same level. The marked
-  // ones are eligible for compaction because they contain duplicate key
-  // versions that are no longer protected by snapshot. These variables are
-  // protected by DB mutex and are calculated in `GenerateBottommostFiles()` and
-  // `ComputeBottommostFilesMarkedForCompaction()`.
-  autovector<std::pair<int, FileMetaData*>> bottommost_files_;
-  autovector<std::pair<int, FileMetaData*>>
-      bottommost_files_marked_for_compaction_;
-
-  // Threshold for needing to mark another bottommost file. Maintain it so we
-  // can quickly check when releasing a snapshot whether more bottommost files
-  // became eligible for compaction. It's defined as the min of the max nonzero
-  // seqnums of unmarked bottommost files.
-  SequenceNumber bottommost_files_mark_threshold_ = kMaxSequenceNumber;
-
-  // Monotonically increases as we release old snapshots. Zero indicates no
-  // snapshots have been released yet. When no snapshots remain we set it to the
-  // current seqnum, which needs to be protected as a snapshot can still be
-  // created that references it.
-  SequenceNumber oldest_snapshot_seqnum_ = 0;
-
  // Level that should be compacted next and its compaction score.
  // Score < 1 means compaction is not strictly needed.  These fields
  // are initialized by Finalize().
@@ -549,7 +486,7 @@ class Version {
           Status* status, MergeContext* merge_context,
           RangeDelAggregator* range_del_agg, bool* value_found = nullptr,
           bool* key_exists = nullptr, SequenceNumber* seq = nullptr,
-           ReadCallback* callback = nullptr, bool* is_blob = nullptr);
+           bool* is_blob = nullptr);

  // Loads some stats information from files. Call without mutex held. It needs
  // to be called before applying the version to the version set.
@@ -663,14 +600,12 @@ class Version {
  Version* next_;               // Next version in linked list
  Version* prev_;               // Previous version in linked list
  int refs_;                    // Number of live refs to this version
-  const EnvOptions env_options_;

  // A version number that uniquely represents this version. This is
  // used for debugging and logging purposes only.
  uint64_t version_number_;

-  Version(ColumnFamilyData* cfd, VersionSet* vset, const EnvOptions& env_opt,
-          uint64_t version_number = 0);
+  Version(ColumnFamilyData* cfd, VersionSet* vset, uint64_t version_number = 0);

  ~Version();

@@ -790,8 +725,8 @@ class VersionSet {
  }

  // Mark the specified file number as used.
-  // REQUIRED: this is only called during single-threaded recovery or repair.
-  void MarkFileNumberUsed(uint64_t number);
+  // REQUIRED: this is only called during single-threaded recovery
+  void MarkFileNumberUsedDuringRecovery(uint64_t number);

  // Return the log file number for the log file that is currently
  // being compacted, or zero if there is no such log file.
@@ -846,10 +781,6 @@ class VersionSet {

  ColumnFamilySet* GetColumnFamilySet() { return column_family_set_.get(); }
  const EnvOptions& env_options() { return env_options_; }
-  void ChangeEnvOptions(const MutableDBOptions& new_options) {
-    env_options_.writable_file_max_buffer_size =
-        new_options.writable_file_max_buffer_size;
-  }

  static uint64_t GetNumLiveVersions(Version* dummy_versions);

@@ -914,7 +845,7 @@ class VersionSet {
  std::vector<std::string> obsolete_manifests_;

  // env options for all reads and writes except compactions
-  EnvOptions env_options_;
+  const EnvOptions& env_options_;

  // env options used for compactions. This is a copy of
  // env_options_ but with readaheads set to readahead_compactions_.
@@ -150,7 +150,7 @@ WriteBatch::WriteBatch(const WriteBatch& src)
      max_bytes_(src.max_bytes_),
      rep_(src.rep_) {}

-WriteBatch::WriteBatch(WriteBatch&& src) noexcept
+WriteBatch::WriteBatch(WriteBatch&& src)
    : save_points_(std::move(src.save_points_)),
      wal_term_point_(std::move(src.wal_term_point_)),
      content_flags_(src.content_flags_.load(std::memory_order_relaxed)),
@@ -383,11 +383,6 @@ Status WriteBatch::Iterate(Handler* handler) const {

  input.remove_prefix(WriteBatchInternal::kHeader);
  Slice key, value, blob, xid;
-  // Sometimes a sub-batch starts with a Noop. We want to exclude such Noops as
-  // the batch boundry sybmols otherwise we would mis-count the number of
-  // batches. We do that by checking whether the accumulated batch is empty
-  // before seeing the next Noop.
-  bool empty_batch = true;
  int found = 0;
  Status s;
  while (s.ok() && !input.empty() && handler->Continue()) {
@@ -406,7 +401,6 @@ Status WriteBatch::Iterate(Handler* handler) const {
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_PUT));
        s = handler->PutCF(column_family, key, value);
-        empty_batch = false;
        found++;
        break;
      case kTypeColumnFamilyDeletion:
@@ -414,7 +408,6 @@ Status WriteBatch::Iterate(Handler* handler) const {
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_DELETE));
        s = handler->DeleteCF(column_family, key);
-        empty_batch = false;
        found++;
        break;
      case kTypeColumnFamilySingleDeletion:
@@ -422,7 +415,6 @@ Status WriteBatch::Iterate(Handler* handler) const {
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_SINGLE_DELETE));
        s = handler->SingleDeleteCF(column_family, key);
-        empty_batch = false;
        found++;
        break;
      case kTypeColumnFamilyRangeDeletion:
@@ -430,7 +422,6 @@ Status WriteBatch::Iterate(Handler* handler) const {
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_DELETE_RANGE));
        s = handler->DeleteRangeCF(column_family, key, value);
-        empty_batch = false;
        found++;
        break;
      case kTypeColumnFamilyMerge:
@@ -438,7 +429,6 @@ Status WriteBatch::Iterate(Handler* handler) const {
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_MERGE));
        s = handler->MergeCF(column_family, key, value);
-        empty_batch = false;
        found++;
        break;
      case kTypeColumnFamilyBlobIndex:
@@ -450,35 +440,28 @@ Status WriteBatch::Iterate(Handler* handler) const {
        break;
      case kTypeLogData:
        handler->LogData(blob);
-        empty_batch = true;
        break;
      case kTypeBeginPrepareXID:
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_BEGIN_PREPARE));
        handler->MarkBeginPrepare();
-        empty_batch = false;
        break;
      case kTypeEndPrepareXID:
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_END_PREPARE));
        handler->MarkEndPrepare(xid);
-        empty_batch = true;
        break;
      case kTypeCommitXID:
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_COMMIT));
        handler->MarkCommit(xid);
-        empty_batch = true;
        break;
      case kTypeRollbackXID:
        assert(content_flags_.load(std::memory_order_relaxed) &
               (ContentFlags::DEFERRED | ContentFlags::HAS_ROLLBACK));
        handler->MarkRollback(xid);
-        empty_batch = true;
        break;
      case kTypeNoop:
-        handler->MarkNoop(empty_batch);
-        empty_batch = true;
        break;
      default:
        return Status::Corruption("unknown WriteBatch tag");
@@ -494,14 +477,6 @@ Status WriteBatch::Iterate(Handler* handler) const {
  }
 }

-bool WriteBatchInternal::IsLatestPersistentState(const WriteBatch* b) {
-  return b->is_latest_persistent_state_;
-}
-
-void WriteBatchInternal::SetAsLastestPersistentState(WriteBatch* b) {
-  b->is_latest_persistent_state_ = true;
-}
-
 int WriteBatchInternal::Count(const WriteBatch* b) {
  return DecodeFixed32(b->rep_.data() + 8);
 }
@@ -899,17 +874,13 @@ class MemTableInserter : public WriteBatch::Handler {
  // cause memory allocations though unused.
  // Make creation optional but do not incur
  // unique_ptr additional allocation
-  using MemPostInfoMap = std::map<MemTable*, MemTablePostProcessInfo>;
-  using PostMapType = std::aligned_storage<sizeof(MemPostInfoMap)>::type;
+  using 
+  MemPostInfoMap = std::map<MemTable*, MemTablePostProcessInfo>;
+  using
+  PostMapType = std::aligned_storage<sizeof(MemPostInfoMap)>::type;
  PostMapType mem_post_info_map_;
  // current recovered transaction we are rebuilding (recovery)
  WriteBatch* rebuilding_trx_;
-  SequenceNumber rebuilding_trx_seq_;
-  // Increase seq number once per each write batch. Otherwise increase it once
-  // per key.
-  bool seq_per_batch_;
-  // Whether the memtable write will be done only after the commit
-  bool write_after_commit_;

  MemPostInfoMap& GetPostMap() {
    assert(concurrent_memtable_writes_);
@@ -920,31 +891,26 @@ class MemTableInserter : public WriteBatch::Handler {
    return *reinterpret_cast<MemPostInfoMap*>(&mem_post_info_map_);
  }

- public:
+public:
  // cf_mems should not be shared with concurrent inserters
-  MemTableInserter(SequenceNumber _sequence, ColumnFamilyMemTables* cf_mems,
-                   FlushScheduler* flush_scheduler,
-                   bool ignore_missing_column_families,
-                   uint64_t recovering_log_number, DB* db,
-                   bool concurrent_memtable_writes,
-                   bool* has_valid_writes = nullptr, bool seq_per_batch = false)
-      : sequence_(_sequence),
-        cf_mems_(cf_mems),
-        flush_scheduler_(flush_scheduler),
-        ignore_missing_column_families_(ignore_missing_column_families),
-        recovering_log_number_(recovering_log_number),
-        log_number_ref_(0),
-        db_(reinterpret_cast<DBImpl*>(db)),
-        concurrent_memtable_writes_(concurrent_memtable_writes),
-        post_info_created_(false),
-        has_valid_writes_(has_valid_writes),
-        rebuilding_trx_(nullptr),
-        seq_per_batch_(seq_per_batch),
-        // Write after commit currently uses one seq per key (instead of per
-        // batch). So seq_per_batch being false indicates write_after_commit
-        // approach.
-        write_after_commit_(!seq_per_batch) {
-    assert(cf_mems_);
+ MemTableInserter(SequenceNumber _sequence, ColumnFamilyMemTables* cf_mems,
+                  FlushScheduler* flush_scheduler,
+                  bool ignore_missing_column_families,
+                  uint64_t recovering_log_number, DB* db,
+                  bool concurrent_memtable_writes,
+                  bool* has_valid_writes = nullptr)
+     : sequence_(_sequence),
+       cf_mems_(cf_mems),
+       flush_scheduler_(flush_scheduler),
+       ignore_missing_column_families_(ignore_missing_column_families),
+       recovering_log_number_(recovering_log_number),
+       log_number_ref_(0),
+       db_(reinterpret_cast<DBImpl*>(db)),
+       concurrent_memtable_writes_(concurrent_memtable_writes),
+       post_info_created_(false),
+       has_valid_writes_(has_valid_writes),
+       rebuilding_trx_(nullptr) {
+   assert(cf_mems_);
  }

  ~MemTableInserter() {
@@ -957,12 +923,6 @@ class MemTableInserter : public WriteBatch::Handler {
  MemTableInserter(const MemTableInserter&) = delete;
  MemTableInserter& operator=(const MemTableInserter&) = delete;

-  void MaybeAdvanceSeq(bool batch_boundry = false) {
-    if (batch_boundry == seq_per_batch_) {
-      sequence_++;
-    }
-  }
-
  void set_log_number_ref(uint64_t log) { log_number_ref_ = log; }

  SequenceNumber sequence() const { return sequence_; }
@@ -1022,15 +982,12 @@ class MemTableInserter : public WriteBatch::Handler {
                   const Slice& value, ValueType value_type) {
    if (rebuilding_trx_ != nullptr) {
      WriteBatchInternal::Put(rebuilding_trx_, column_family_id, key, value);
-      if (write_after_commit_) {
-        return Status::OK();
-      }
-      // else insert the values to the memtable right away
+      return Status::OK();
    }

    Status seek_status;
    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
-      MaybeAdvanceSeq();
+      ++sequence_;
      return seek_status;
    }

@@ -1042,6 +999,7 @@ class MemTableInserter : public WriteBatch::Handler {
    } else if (moptions->inplace_callback == nullptr) {
      assert(!concurrent_memtable_writes_);
      mem->Update(sequence_, key, value);
+      RecordTick(moptions->statistics, NUMBER_KEYS_UPDATED);
    } else {
      assert(!concurrent_memtable_writes_);
      if (mem->UpdateCallback(sequence_, key, value)) {
@@ -1050,9 +1008,6 @@ class MemTableInserter : public WriteBatch::Handler {
        SnapshotImpl read_from_snapshot;
        read_from_snapshot.number_ = sequence_;
        ReadOptions ropts;
-        // it's going to be overwritten for sure, so no point caching data block
-        // containing the old version
-        ropts.fill_cache = false;
        ropts.snapshot = &read_from_snapshot;

        std::string prev_value;
@@ -1086,7 +1041,7 @@ class MemTableInserter : public WriteBatch::Handler {
    // Since all Puts are logged in trasaction logs (if enabled), always bump
    // sequence number. Even if the update eventually fails and does not result
    // in memtable add/update.
-    MaybeAdvanceSeq();
+    sequence_++;
    CheckMemtableFull();
    return Status::OK();
  }
@@ -1101,7 +1056,7 @@ class MemTableInserter : public WriteBatch::Handler {
    MemTable* mem = cf_mems_->GetMemTable();
    mem->Add(sequence_, delete_type, key, value, concurrent_memtable_writes_,
             get_post_process_info(mem));
-    MaybeAdvanceSeq();
+    sequence_++;
    CheckMemtableFull();
    return Status::OK();
  }
@@ -1110,15 +1065,12 @@ class MemTableInserter : public WriteBatch::Handler {
                          const Slice& key) override {
    if (rebuilding_trx_ != nullptr) {
      WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key);
-      if (write_after_commit_) {
-        return Status::OK();
-      }
-      // else insert the values to the memtable right away
+      return Status::OK();
    }

    Status seek_status;
    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
-      MaybeAdvanceSeq();
+      ++sequence_;
      return seek_status;
    }

@@ -1129,15 +1081,12 @@ class MemTableInserter : public WriteBatch::Handler {
                                const Slice& key) override {
    if (rebuilding_trx_ != nullptr) {
      WriteBatchInternal::SingleDelete(rebuilding_trx_, column_family_id, key);
-      if (write_after_commit_) {
-        return Status::OK();
-      }
-      // else insert the values to the memtable right away
+      return Status::OK();
    }

    Status seek_status;
    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
-      MaybeAdvanceSeq();
+      ++sequence_;
      return seek_status;
    }

@@ -1150,15 +1099,12 @@ class MemTableInserter : public WriteBatch::Handler {
    if (rebuilding_trx_ != nullptr) {
      WriteBatchInternal::DeleteRange(rebuilding_trx_, column_family_id,
                                      begin_key, end_key);
-      if (write_after_commit_) {
-        return Status::OK();
-      }
-      // else insert the values to the memtable right away
+      return Status::OK();
    }

    Status seek_status;
    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
-      MaybeAdvanceSeq();
+      ++sequence_;
      return seek_status;
    }
    if (db_ != nullptr) {
@@ -1183,15 +1129,12 @@ class MemTableInserter : public WriteBatch::Handler {
    assert(!concurrent_memtable_writes_);
    if (rebuilding_trx_ != nullptr) {
      WriteBatchInternal::Merge(rebuilding_trx_, column_family_id, key, value);
-      if (write_after_commit_) {
-        return Status::OK();
-      }
-      // else insert the values to the memtable right away
+      return Status::OK();
    }

    Status seek_status;
    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
-      MaybeAdvanceSeq();
+      ++sequence_;
      return seek_status;
    }

@@ -1259,7 +1202,7 @@ class MemTableInserter : public WriteBatch::Handler {
      mem->Add(sequence_, kTypeMerge, key, value);
    }

-    MaybeAdvanceSeq();
+    sequence_++;
    CheckMemtableFull();
    return Status::OK();
  }
@@ -1298,10 +1241,14 @@ class MemTableInserter : public WriteBatch::Handler {

      // we are now iterating through a prepared section
      rebuilding_trx_ = new WriteBatch();
-      rebuilding_trx_seq_ = sequence_;
      if (has_valid_writes_ != nullptr) {
        *has_valid_writes_ = true;
      }
+    } else {
+      // in non-recovery we ignore prepare markers
+      // and insert the values directly. making sure we have a
+      // log for each insertion to reference.
+      assert(log_number_ref_ > 0);
    }

    return Status::OK();
@@ -1314,30 +1261,16 @@ class MemTableInserter : public WriteBatch::Handler {
    if (recovering_log_number_ != 0) {
      assert(db_->allow_2pc());
      db_->InsertRecoveredTransaction(recovering_log_number_, name.ToString(),
-                                      rebuilding_trx_, rebuilding_trx_seq_);
+                                      rebuilding_trx_);
      rebuilding_trx_ = nullptr;
    } else {
      assert(rebuilding_trx_ == nullptr);
+      assert(log_number_ref_ > 0);
    }
-    const bool batch_boundry = true;
-    MaybeAdvanceSeq(batch_boundry);

    return Status::OK();
  }

-  Status MarkNoop(bool empty_batch) override {
-    // A hack in pessimistic transaction could result into a noop at the start
-    // of the write batch, that should be ignored.
-    if (!empty_batch) {
-      // In the absence of Prepare markers, a kTypeNoop tag indicates the end of
-      // a batch. This happens when write batch commits skipping the prepare
-      // phase.
-      const bool batch_boundry = true;
-      MaybeAdvanceSeq(batch_boundry);
-    }
-    return Status::OK();
-  }
-
  Status MarkCommit(const Slice& name) override {
    assert(db_);

@@ -1356,13 +1289,10 @@ class MemTableInserter : public WriteBatch::Handler {
        // at this point individual CF lognumbers will prevent
        // duplicate re-insertion of values.
        assert(log_number_ref_ == 0);
-        if (write_after_commit_) {
-          // all insertes must reference this trx log number
-          log_number_ref_ = trx->log_number_;
-          s = trx->batch_->Iterate(this);
-          log_number_ref_ = 0;
-        }
-        // else the values are already inserted before the commit
+        // all insertes must reference this trx log number
+        log_number_ref_ = trx->log_number_;
+        s = trx->batch_->Iterate(this);
+        log_number_ref_ = 0;

        if (s.ok()) {
          db_->DeleteRecoveredTransaction(name.ToString());
@@ -1372,13 +1302,8 @@ class MemTableInserter : public WriteBatch::Handler {
        }
      }
    } else {
-      // When writes are not delayed until commit, there is no disconnect
-      // between a memtable write and the WAL that supports it. So the commit
-      // need not reference any log as the only log to which it depends.
-      assert(!write_after_commit_ || log_number_ref_ > 0);
+      // in non recovery we simply ignore this tag
    }
-    const bool batch_boundry = true;
-    MaybeAdvanceSeq(batch_boundry);

    return s;
  }
@@ -1417,19 +1342,18 @@ class MemTableInserter : public WriteBatch::Handler {
 // 2) During Write(), in a single-threaded write thread
 // 3) During Write(), in a concurrent context where memtables has been cloned
 // The reason is that it calls memtables->Seek(), which has a stateful cache
-Status WriteBatchInternal::InsertInto(
-    WriteThread::WriteGroup& write_group, SequenceNumber sequence,
-    ColumnFamilyMemTables* memtables, FlushScheduler* flush_scheduler,
-    bool ignore_missing_column_families, uint64_t recovery_log_number, DB* db,
-    bool concurrent_memtable_writes, bool seq_per_batch) {
+Status WriteBatchInternal::InsertInto(WriteThread::WriteGroup& write_group,
+                                      SequenceNumber sequence,
+                                      ColumnFamilyMemTables* memtables,
+                                      FlushScheduler* flush_scheduler,
+                                      bool ignore_missing_column_families,
+                                      uint64_t recovery_log_number, DB* db,
+                                      bool concurrent_memtable_writes) {
  MemTableInserter inserter(sequence, memtables, flush_scheduler,
                            ignore_missing_column_families, recovery_log_number,
-                            db, concurrent_memtable_writes,
-                            nullptr /*has_valid_writes*/, seq_per_batch);
+                            db, concurrent_memtable_writes);
  for (auto w : write_group) {
    if (!w->ShouldWriteToMemtable()) {
-      w->sequence = inserter.sequence();
-      inserter.MaybeAdvanceSeq(true);
      continue;
    }
    SetSequence(w->batch, inserter.sequence());
@@ -1443,16 +1367,17 @@ Status WriteBatchInternal::InsertInto(
  return Status::OK();
 }

-Status WriteBatchInternal::InsertInto(
-    WriteThread::Writer* writer, SequenceNumber sequence,
-    ColumnFamilyMemTables* memtables, FlushScheduler* flush_scheduler,
-    bool ignore_missing_column_families, uint64_t log_number, DB* db,
-    bool concurrent_memtable_writes, bool seq_per_batch) {
+Status WriteBatchInternal::InsertInto(WriteThread::Writer* writer,
+                                      SequenceNumber sequence,
+                                      ColumnFamilyMemTables* memtables,
+                                      FlushScheduler* flush_scheduler,
+                                      bool ignore_missing_column_families,
+                                      uint64_t log_number, DB* db,
+                                      bool concurrent_memtable_writes) {
  assert(writer->ShouldWriteToMemtable());
  MemTableInserter inserter(sequence, memtables, flush_scheduler,
                            ignore_missing_column_families, log_number, db,
-                            concurrent_memtable_writes,
-                            nullptr /*has_valid_writes*/, seq_per_batch);
+                            concurrent_memtable_writes);
  SetSequence(writer->batch, sequence);
  inserter.set_log_number_ref(writer->log_ref);
  Status s = writer->batch->Iterate(&inserter);
@@ -1466,14 +1391,13 @@ Status WriteBatchInternal::InsertInto(
    const WriteBatch* batch, ColumnFamilyMemTables* memtables,
    FlushScheduler* flush_scheduler, bool ignore_missing_column_families,
    uint64_t log_number, DB* db, bool concurrent_memtable_writes,
-    SequenceNumber* next_seq, bool* has_valid_writes, bool seq_per_batch) {
+    SequenceNumber* last_seq_used, bool* has_valid_writes) {
  MemTableInserter inserter(Sequence(batch), memtables, flush_scheduler,
                            ignore_missing_column_families, log_number, db,
-                            concurrent_memtable_writes, has_valid_writes,
-                            seq_per_batch);
+                            concurrent_memtable_writes, has_valid_writes);
  Status s = batch->Iterate(&inserter);
-  if (next_seq != nullptr) {
-    *next_seq = inserter.sequence();
+  if (last_seq_used != nullptr) {
+    *last_seq_used = inserter.sequence();
  }
  if (concurrent_memtable_writes) {
    inserter.PostProcess();
@@ -160,28 +160,25 @@ class WriteBatchInternal {
                           FlushScheduler* flush_scheduler,
                           bool ignore_missing_column_families = false,
                           uint64_t log_number = 0, DB* db = nullptr,
-                           bool concurrent_memtable_writes = false,
-                           bool seq_per_batch = false);
+                           bool concurrent_memtable_writes = false);

  // Convenience form of InsertInto when you have only one batch
-  // next_seq returns the seq after last sequnce number used in MemTable insert
+  // last_seq_used returns the last sequnce number used in a MemTable insert
  static Status InsertInto(const WriteBatch* batch,
                           ColumnFamilyMemTables* memtables,
                           FlushScheduler* flush_scheduler,
                           bool ignore_missing_column_families = false,
                           uint64_t log_number = 0, DB* db = nullptr,
                           bool concurrent_memtable_writes = false,
-                           SequenceNumber* next_seq = nullptr,
-                           bool* has_valid_writes = nullptr,
-                           bool seq_per_batch = false);
+                           SequenceNumber* last_seq_used = nullptr,
+                           bool* has_valid_writes = nullptr);

  static Status InsertInto(WriteThread::Writer* writer, SequenceNumber sequence,
                           ColumnFamilyMemTables* memtables,
                           FlushScheduler* flush_scheduler,
                           bool ignore_missing_column_families = false,
                           uint64_t log_number = 0, DB* db = nullptr,
-                           bool concurrent_memtable_writes = false,
-                           bool seq_per_batch = false);
+                           bool concurrent_memtable_writes = false);

  static Status Append(WriteBatch* dst, const WriteBatch* src,
                       const bool WAL_only = false);
@@ -189,11 +186,6 @@ class WriteBatchInternal {
  // Returns the byte size of appending a WriteBatch with ByteSize
  // leftByteSize and a WriteBatch with ByteSize rightByteSize
  static size_t AppendedByteSize(size_t leftByteSize, size_t rightByteSize);
-
-  // This write batch includes the latest state that should be persisted. Such
-  // state meant to be used only during recovery.
-  static void SetAsLastestPersistentState(WriteBatch* b);
-  static bool IsLatestPersistentState(const WriteBatch* b);
 };

 // LocalSavePoint is similar to a scope guard
@@ -18,6 +18,7 @@
 #include "rocksdb/utilities/write_batch_with_index.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/scoped_arena_iterator.h"
+#include "util/logging.h"
 #include "util/string_util.h"
 #include "util/testharness.h"

@@ -298,10 +299,6 @@ namespace {
      seen += "MarkEndPrepare(" + xid.ToString() + ")";
      return Status::OK();
    }
-    virtual Status MarkNoop(bool empty_batch) override {
-      seen += "MarkNoop(" + std::string(empty_batch ? "true" : "false") + ")";
-      return Status::OK();
-    }
    virtual Status MarkCommit(const Slice& xid) override {
      seen += "MarkCommit(" + xid.ToString() + ")";
      return Status::OK();
@@ -418,7 +415,7 @@ TEST_F(WriteBatchTest, PrepareCommit) {
 TEST_F(WriteBatchTest, DISABLED_ManyUpdates) {
  // Insert key and value of 3GB and push total batch size to 12GB.
  static const size_t kKeyValueSize = 4u;
-  static const uint32_t kNumUpdates = uint32_t(3 << 30);
+  static const uint32_t kNumUpdates = 3 << 30;
  std::string raw(kKeyValueSize, 'A');
  WriteBatch batch(kNumUpdates * (4 + kKeyValueSize * 2) + 1024u);
  char c = 'A';
@@ -137,11 +137,6 @@ TEST_F(WriteCallbackTest, WriteWithCallbackTest) {
              options.allow_concurrent_memtable_write = allow_parallel;
              options.enable_pipelined_write = enable_pipelined_write;
              options.concurrent_prepare = two_queues;
-              if (options.enable_pipelined_write &&
-                  options.concurrent_prepare) {
-                // This combination is not supported
-                continue;
-              }

              ReadOptions read_options;
              DB* db;
@@ -394,7 +394,6 @@ size_t WriteThread::EnterAsBatchGroupLeader(Writer* leader,
    write_group->last_writer = w;
    write_group->size++;
  }
-  TEST_SYNC_POINT_CALLBACK("WriteThread::EnterAsBatchGroupLeader:End", w);
  return size;
 }

@@ -14,7 +14,6 @@
 #include <type_traits>
 #include <vector>

-#include "db/dbformat.h"
 #include "db/write_callback.h"
 #include "monitoring/instrumented_mutex.h"
 #include "rocksdb/options.h"
@@ -143,7 +142,6 @@ class WriteThread {
          made_waitable(false),
          state(STATE_INIT),
          write_group(nullptr),
-          sequence(kMaxSequenceNumber),
          link_older(nullptr),
          link_newer(nullptr) {}

@@ -160,7 +158,6 @@ class WriteThread {
          made_waitable(false),
          state(STATE_INIT),
          write_group(nullptr),
-          sequence(kMaxSequenceNumber),
          link_older(nullptr),
          link_newer(nullptr) {}

@@ -1,25 +0,0 @@
---
-title: RocksDB 5.8 Released!
-layout: post
-author: maysamyabandeh
-category: blog
---
-
-### Public API Change
-* Users of `Statistics::getHistogramString()` will see fewer histogram buckets and different bucket endpoints.
-* `Slice::compare` and BytewiseComparator `Compare` no longer accept `Slice`s containing nullptr.
-* `Transaction::Get` and `Transaction::GetForUpdate` variants with `PinnableSlice` added.
-
-### New Features
-* Add Iterator::Refresh(), which allows users to update the iterator state so that they can avoid some initialization costs of recreating iterators.
-* Replace dynamic_cast<> (except unit test) so people can choose to build with RTTI off. With make, release mode is by default built with -fno-rtti and debug mode is built without it. Users can override it by setting USE_RTTI=0 or 1.
-* Universal compactions including the bottom level can be executed in a dedicated thread pool. This alleviates head-of-line blocking in the compaction queue, which cause write stalling, particularly in multi-instance use cases. Users can enable this feature via `Env::SetBackgroundThreads(N, Env::Priority::BOTTOM)`, where `N > 0`.
-* Allow merge operator to be called even with a single merge operand during compactions, by appropriately overriding `MergeOperator::AllowSingleOperand`.
-* Add `DB::VerifyChecksum()`, which verifies the checksums in all SST files in a running DB.
-* Block-based table support for disabling checksums by setting `BlockBasedTableOptions::checksum = kNoChecksum`.
-
-### Bug Fixes
-* Fix wrong latencies in `rocksdb.db.get.micros`, `rocksdb.db.write.micros`, and `rocksdb.sst.read.micros`.
-* Fix incorrect dropping of deletions during intra-L0 compaction.
-* Fix transient reappearance of keys covered by range deletions when memtable prefix bloom filter is enabled.
-* Fix potentially wrong file smallest key when range deletions separated by snapshot are written together.
@@ -333,8 +333,6 @@ EnvOptions Env::OptimizeForLogWrite(const EnvOptions& env_options,
                                    const DBOptions& db_options) const {
  EnvOptions optimized_env_options(env_options);
  optimized_env_options.bytes_per_sync = db_options.wal_bytes_per_sync;
-  optimized_env_options.writable_file_max_buffer_size =
-      db_options.writable_file_max_buffer_size;
  return optimized_env_options;
 }

@@ -23,7 +23,6 @@
 #ifdef OS_LINUX
 #include <sys/statfs.h>
 #include <sys/syscall.h>
-#include <sys/sysmacros.h>
 #endif
 #include <sys/time.h>
 #include <sys/types.h>
@@ -428,6 +427,8 @@ class PosixEnv : public Env {
      result->reset(new PosixWritableFile(fname, fd, no_mmap_writes_options));
    }
    return s;
+
+    return s;
  }

  virtual Status NewRandomRWFile(const std::string& fname,
@@ -591,26 +592,6 @@ class PosixEnv : public Env {
    return result;
  }

-  virtual Status AreFilesSame(const std::string& first,
-                              const std::string& second, bool* res) override {
-    struct stat statbuf[2];
-    if (stat(first.c_str(), &statbuf[0]) != 0) {
-      return IOError("stat file", first, errno);
-    }
-    if (stat(second.c_str(), &statbuf[1]) != 0) {
-      return IOError("stat file", second, errno);
-    }
-
-    if (major(statbuf[0].st_dev) != major(statbuf[1].st_dev) ||
-        minor(statbuf[0].st_dev) != minor(statbuf[1].st_dev) ||
-        statbuf[0].st_ino != statbuf[1].st_ino) {
-      *res = false;
-    } else {
-      *res = true;
-    }
-    return Status::OK();
-  }
-
  virtual Status LockFile(const std::string& fname, FileLock** lock) override {
    *lock = nullptr;
    Status result;
@@ -832,8 +813,6 @@ class PosixEnv : public Env {
    // breaks TransactionLogIteratorStallAtLastRecord unit test. Fix the unit
    // test and make this false
    optimized.fallocate_with_keep_size = true;
-    optimized.writable_file_max_buffer_size =
-        db_options.writable_file_max_buffer_size;
    return optimized;
  }

@@ -73,7 +73,7 @@ struct Deleter {
 std::unique_ptr<char, Deleter> NewAligned(const size_t size, const char ch) {
  char* ptr = nullptr;
 #ifdef OS_WIN
-  if (nullptr == (ptr = reinterpret_cast<char*>(_aligned_malloc(size, kPageSize)))) {
+  if (!(ptr = reinterpret_cast<char*>(_aligned_malloc(size, kPageSize)))) {
    return std::unique_ptr<char, Deleter>(nullptr, Deleter(_aligned_free));
  }
  std::unique_ptr<char, Deleter> uptr(ptr, Deleter(_aligned_free));
@@ -701,6 +701,7 @@ TEST_F(EnvPosixTest, PositionedAppend) {
  IoctlFriendlyTmpdir ift;
  ASSERT_OK(env_->NewWritableFile(ift.name() + "/f", &writable_file, options));
  const size_t kBlockSize = 4096;
+  const size_t kPageSize = 4096;
  const size_t kDataSize = kPageSize;
  // Write a page worth of 'a'
  auto data_ptr = NewAligned(kDataSize, 'a');
@@ -1137,7 +1138,7 @@ TEST_P(EnvPosixTestWithParam, Preallocation) {
    unique_ptr<WritableFile> srcfile;
    EnvOptions soptions;
    soptions.use_direct_reads = soptions.use_direct_writes = direct_io_;
-#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX) && !defined(OS_OPENBSD)
+#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX)
    if (soptions.use_direct_writes) {
      rocksdb::SyncPoint::GetInstance()->SetCallBack(
          "NewWritableFile:O_DIRECT", [&](void* arg) {
@@ -1199,7 +1200,7 @@ TEST_P(EnvPosixTestWithParam, ConsistentChildrenAttributes) {
      oss << test::TmpDir(env_) << "/testfile_" << i;
      const std::string path = oss.str();
      unique_ptr<WritableFile> file;
-#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX) && !defined(OS_OPENBSD)
+#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX)
      if (soptions.use_direct_writes) {
        rocksdb::SyncPoint::GetInstance()->SetCallBack(
            "NewWritableFile:O_DIRECT", [&](void* arg) {
@@ -379,8 +379,7 @@ class TestMemLogger : public Logger {
      const time_t seconds = now_tv.tv_sec;
      struct tm t;
      memset(&t, 0, sizeof(t));
-      struct tm* ret __attribute__((__unused__));
-      ret = localtime_r(&seconds, &t);
+      auto ret __attribute__((__unused__)) = localtime_r(&seconds, &t);
      assert(ret);
      p += snprintf(p, limit - p,
                    "%04d/%02d/%02d-%02d:%02d:%02d.%06d ",
@@ -411,6 +411,8 @@ struct AdvancedColumnFamilyOptions {
  // Turning this feature on or off for an existing DB can cause unexpected
  // LSM tree structure so it's not recommended.
  //
+  // NOTE: this option is experimental
+  //
  // Default: false
  bool level_compaction_dynamic_level_bytes = false;

@@ -460,10 +462,6 @@ struct AdvancedColumnFamilyOptions {
  CompactionOptionsUniversal compaction_options_universal;

  // The options for FIFO compaction style
-  //
-  // Dynamically changeable through SetOptions() API
-  // Dynamic change example:
-  // SetOption("compaction_options_fifo", "{max_table_files_size=100;ttl=2;}")
  CompactionOptionsFIFO compaction_options_fifo;

  // An iteration->Next() sequentially skips over keys with the same
@@ -117,10 +117,8 @@ typedef struct rocksdb_pinnableslice_t rocksdb_pinnableslice_t;
 typedef struct rocksdb_transactiondb_options_t rocksdb_transactiondb_options_t;
 typedef struct rocksdb_transactiondb_t rocksdb_transactiondb_t;
 typedef struct rocksdb_transaction_options_t rocksdb_transaction_options_t;
-typedef struct rocksdb_optimistictransactiondb_t
-    rocksdb_optimistictransactiondb_t;
-typedef struct rocksdb_optimistictransaction_options_t
-    rocksdb_optimistictransaction_options_t;
+typedef struct rocksdb_optimistictransactiondb_t rocksdb_optimistictransactiondb_t;
+typedef struct rocksdb_optimistictransaction_options_t rocksdb_optimistictransaction_options_t;
 typedef struct rocksdb_transaction_t rocksdb_transaction_t;
 typedef struct rocksdb_checkpoint_t rocksdb_checkpoint_t;

@@ -767,9 +765,8 @@ rocksdb_options_set_max_bytes_for_level_multiplier_additional(
    rocksdb_options_t*, int* level_values, size_t num_levels);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_enable_statistics(
    rocksdb_options_t*);
-extern ROCKSDB_LIBRARY_API void
-rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt,
-                                                 unsigned char val);
+extern ROCKSDB_LIBRARY_API void rocksdb_options_set_skip_stats_update_on_db_open(
+    rocksdb_options_t* opt, unsigned char val);

 /* returns a pointer to a malloc()-ed, null terminated string */
 extern ROCKSDB_LIBRARY_API char* rocksdb_options_statistics_get_string(
@@ -854,10 +851,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_adaptive_mutex(
    rocksdb_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_bytes_per_sync(
    rocksdb_options_t*, uint64_t);
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_bytes_per_sync(
-        rocksdb_options_t*, uint64_t);
-extern ROCKSDB_LIBRARY_API void
-rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t*, uint64_t);
 extern ROCKSDB_LIBRARY_API void
 rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t*,
                                                    unsigned char);
@@ -1296,12 +1289,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_transaction_commit(
 extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback(
    rocksdb_transaction_t* txn, char** errptr);

-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_set_savepoint(
-    rocksdb_transaction_t* txn);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback_to_savepoint(
-    rocksdb_transaction_t* txn, char** errptr);
-
 extern ROCKSDB_LIBRARY_API void rocksdb_transaction_destroy(
    rocksdb_transaction_t* txn);

@@ -1381,11 +1368,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_iterator_t*
 rocksdb_transaction_create_iterator(rocksdb_transaction_t* txn,
                                    const rocksdb_readoptions_t* options);

-extern ROCKSDB_LIBRARY_API rocksdb_iterator_t*
-rocksdb_transaction_create_iterator_cf(
-    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family);
-
 extern ROCKSDB_LIBRARY_API rocksdb_iterator_t*
 rocksdb_transactiondb_create_iterator(rocksdb_transactiondb_t* txn_db,
                                      const rocksdb_readoptions_t* options);
@@ -1401,20 +1383,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t*
 rocksdb_optimistictransactiondb_open(const rocksdb_options_t* options,
                                     const char* name, char** errptr);

-extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t*
-rocksdb_optimistictransactiondb_open_column_families(
-    const rocksdb_options_t* options, const char* name, int num_column_families,
-    const char** column_family_names,
-    const rocksdb_options_t** column_family_options,
-    rocksdb_column_family_handle_t** column_family_handles, char** errptr);
-
-extern ROCKSDB_LIBRARY_API rocksdb_t*
-rocksdb_optimistictransactiondb_get_base_db(
-    rocksdb_optimistictransactiondb_t* otxn_db);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransactiondb_close_base_db(
-    rocksdb_t* base_db);
-
 extern ROCKSDB_LIBRARY_API rocksdb_transaction_t*
 rocksdb_optimistictransaction_begin(
    rocksdb_optimistictransactiondb_t* otxn_db,
@@ -1473,6 +1441,7 @@ extern ROCKSDB_LIBRARY_API void
 rocksdb_transaction_options_set_max_write_batch_size(
    rocksdb_transaction_options_t* opt, size_t size);

+
 extern ROCKSDB_LIBRARY_API rocksdb_optimistictransaction_options_t*
 rocksdb_optimistictransaction_options_create();

@@ -21,7 +21,7 @@ class Slice;
 // from multiple threads.
 class Comparator {
 public:
-  virtual ~Comparator() {}
+  virtual ~Comparator();

  // Three-way comparison.  Returns value:
  //   < 0 iff "a" < "b",