update HISTORY.md and bump version for 6.19.4

Fix the false positive alert of CF consistency check in WAL recovery (#8207 )
Summary: In current RocksDB, in recover the information form WAL, we do the consistency check for each column family when one WAL file is corrupted and PointInTimeRecovery is set. However, it will report a false positive alert on "SST file is ahead of WALs" when one of the CF current log number is greater than the corrupted WAL number (CF contains the data beyond the corrupted WAl) due to a new column family creation during flush. In this case, a new WAL is created (it is empty) during a flush. Also, due to some reason (e.g., storage issue or crash happens before SyncCloseLog is called), the old WAL is corrupted. The new CF has no data, therefore, it does not have the consistency issue. Fix: when checking cfd->GetLogNumber() > corrupted_wal_number also check cfd->GetLiveSstFilesSize() > 0. So the CFs with no SST file data will skip the check here. Note potential ignored inconsistency caused due to fix: empty CF can also be caused by write+delete. In this case, after flush, there is no SST files being generated. However, this CF still have the log in the WAL. When the WAL is corrupted, the DB might be inconsistent. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8207 Test Plan: added unit test, make crash_test Reviewed By: riversand963 Differential Revision: D27898839 Pulled By: zhichao-cao fbshipit-source-id: 931fc2d8b92dd00b4169bf84b94e712fd688a83e
2026-11-06 02:52:35 -05:00 · 2021-04-23 15:42:04 -07:00 · 2021-04-23 15:39:35 -07:00 · 2021-04-23 15:37:41 -07:00 · 2021-04-20 15:24:25 -07:00 · 2021-04-19 19:57:42 -07:00
243 changed files with 3165 additions and 8515 deletions
@@ -178,7 +178,7 @@ jobs:
    steps:
      - pre-steps
      - install-gflags
-      - run: ASSERT_STATUS_CHECKED=1 TEST_UINT128_COMPAT=1 ROCKSDB_MODIFY_NPHASH=1 LIB_MODE=shared OPT="-DROCKSDB_NAMESPACE=alternative_rocksdb_ns" make V=1 -j32 check | .circleci/cat_ignore_eagain
+      - run: ASSERT_STATUS_CHECKED=1 TEST_UINT128_COMPAT=1 ROCKSDB_MODIFY_NPHASH=1 LIB_MODE=shared OPT="-DROCKSDB_NAMESPACE=alternative_rocksdb_ns" make V=1 -j32 all check_some | .circleci/cat_ignore_eagain
      - post-steps

  build-linux-release:
@@ -572,58 +572,6 @@ jobs:
            gtest-parallel $(</tmp/test_list) --output_dir=/tmp | cat  # pipe to cat to continuously output status on circleci UI. Otherwise, no status will be printed while the job is running.
      - post-steps

-  build-linux-arm-test-full:
-    machine:
-      image: ubuntu-2004:202101-01
-    resource_class: arm.large
-    steps:
-      - pre-steps
-      - install-gflags
-      - run: make V=1 J=4 -j4 check | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-linux-arm:
-    machine:
-      image: ubuntu-2004:202101-01
-    resource_class: arm.large
-    steps:
-      - pre-steps
-      - install-gflags
-      - run: ROCKSDBTESTS_PLATFORM_DEPENDENT=only make V=1 J=4 -j4 all_but_some_tests check_some | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-linux-arm-cmake-no_test_run:
-    machine:
-      image: ubuntu-2004:202101-01
-    resource_class: arm.large
-    environment:
-      JAVA_HOME: /usr/lib/jvm/java-8-openjdk-arm64
-    steps:
-      - pre-steps
-      - run:
-          name: "Set Java Environment"
-          command: |
-            echo "JAVA_HOME=${JAVA_HOME}"
-            echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV
-            which java && java -version
-            which javac && javac -version
-      - run:
-          name: "Build with cmake"
-          command: |
-            mkdir build
-            cd build
-            cmake -DCMAKE_BUILD_TYPE=Release -DWITH_TESTS=0 -DWITH_GFLAGS=0 -DWITH_BENCHMARK_TOOLS=0 -DWITH_TOOLS=0 -DWITH_CORE_TOOLS=1 ..
-            make -j4
-      - run:
-          name: "Build Java with cmake"
-          command: |
-            rm -rf build
-            mkdir build
-            cd build
-            cmake -DJNI=1 -DCMAKE_BUILD_TYPE=Release -DWITH_GFLAGS=0 ..
-            make -j4 rocksdb rocksdbjni
-      - post-steps
-
  build-format-compatible:
    machine:
      image: ubuntu-1604:202007-01
@@ -734,7 +682,6 @@ workflows:
      - build-linux-gcc-8-no_test_run
      - build-linux-gcc-9-no_test_run
      - build-linux-gcc-10-cxx20-no_test_run
-      - build-linux-arm-cmake-no_test_run
  build-macos:
    jobs:
      - build-macos
@@ -744,9 +691,6 @@ workflows:
  build-cmake-mingw:
    jobs:
      - build-cmake-mingw
-  build-linux-arm:
-    jobs:
-      - build-linux-arm
  nightly:
    triggers:
      - schedule:
@@ -757,4 +701,3 @@ workflows:
                - master
    jobs:
      - build-format-compatible
-      - build-linux-arm-test-full
@@ -61,10 +61,6 @@ matrix:
    env: JOB_NAME=make-gcc4.8
  - os: linux
    compiler: clang
-  - if: type = pull_request AND commit_message !~ /FULL_CI/
-    os: linux
-    arch: arm64
-    env: TEST_GROUP=platform_dependent
  - if: type = pull_request AND commit_message !~ /FULL_CI/
    os : linux
    arch: arm64
@@ -97,10 +93,6 @@ matrix:
    os: linux
    arch: ppc64le
    env: TEST_GROUP=4
-  - if: type = pull_request AND commit_message !~ /FULL_CI/
-    os : linux
-    arch: arm64
-    env: JOB_NAME=cmake
  - if: type = pull_request AND commit_message !~ /FULL_CI/ AND commit_message !~ /java/
    os : linux
    arch: arm64
@@ -296,7 +296,6 @@ else()
 endif()

 include(CheckCXXSourceCompiles)
-set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
 if(NOT MSVC)
  set(CMAKE_REQUIRED_FLAGS "-msse4.2 -mpclmul")
 endif()
@@ -313,6 +312,7 @@ int main() {
  auto d = _mm_cvtsi128_si64(c);
 }
 " HAVE_SSE42)
+unset(CMAKE_REQUIRED_FLAGS)
 if(HAVE_SSE42)
  add_definitions(-DHAVE_SSE42)
  add_definitions(-DHAVE_PCLMUL)
@@ -320,50 +320,18 @@ elseif(FORCE_SSE42)
  message(FATAL_ERROR "FORCE_SSE42=ON but unable to compile with SSE4.2 enabled")
 endif()

-# Check if -latomic is required or not
-if (NOT MSVC)
-  set(CMAKE_REQUIRED_FLAGS "--std=c++11")
-  CHECK_CXX_SOURCE_COMPILES("
-#include <atomic>
-std::atomic<uint64_t> x(0);
-int main() {
-  uint64_t i = x.load(std::memory_order_relaxed);
-  bool b = x.is_lock_free();
-  return 0;
-}
-" BUILTIN_ATOMIC)
-if (NOT BUILTIN_ATOMIC)
-  #TODO: Check if -latomic exists
-  list(APPEND THIRDPARTY_LIBS atomic)
-endif()
-endif()
-
-# Reset the required flags
-set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
-
 CHECK_CXX_SOURCE_COMPILES("
 #if defined(_MSC_VER) && !defined(__thread)
 #define __thread __declspec(thread)
 #endif
 int main() {
  static __thread int tls;
-  (void)tls;
 }
 " HAVE_THREAD_LOCAL)
 if(HAVE_THREAD_LOCAL)
  add_definitions(-DROCKSDB_SUPPORT_THREAD_LOCAL)
 endif()

-option(WITH_IOSTATS_CONTEXT "Enable IO stats context" ON)
-if (NOT WITH_IOSTATS_CONTEXT)
-  add_definitions(-DNIOSTATS_CONTEXT)
-endif()
-
-option(WITH_PERF_CONTEXT "Enable perf context" ON)
-if (NOT WITH_PERF_CONTEXT)
-  add_definitions(-DNPERF_CONTEXT)
-endif()
-
 option(FAIL_ON_WARNINGS "Treat compile warnings as errors" ON)
 if(FAIL_ON_WARNINGS)
  if(MSVC)
@@ -615,6 +583,7 @@ set(SOURCES
        db/builder.cc
        db/c.cc
        db/column_family.cc
+        db/compacted_db_impl.cc
        db/compaction/compaction.cc
        db/compaction/compaction_iterator.cc
        db/compaction/compaction_picker.cc
@@ -625,7 +594,6 @@ set(SOURCES
        db/compaction/sst_partitioner.cc
        db/convenience.cc
        db/db_filesnapshot.cc
-        db/db_impl/compacted_db_impl.cc
        db/db_impl/db_impl.cc
        db/db_impl/db_impl_write.cc
        db/db_impl/db_impl_compaction_flush.cc
@@ -683,7 +651,6 @@ set(SOURCES
        env/env_hdfs.cc
        env/file_system.cc
        env/file_system_tracer.cc
-        env/fs_remap.cc
        env/mock_env.cc
        file/delete_scheduler.cc
        file/file_prefetch_buffer.cc
@@ -1348,8 +1315,7 @@ if(WITH_BENCHMARK_TOOLS)
    ${ROCKSDB_LIB} ${THIRDPARTY_LIBS})

  add_executable(cache_bench${ARTIFACT_SUFFIX}
-    cache/cache_bench.cc
-    cache/cache_bench_tool.cc)
+    cache/cache_bench.cc)
  target_link_libraries(cache_bench${ARTIFACT_SUFFIX}
    ${ROCKSDB_LIB} ${GFLAGS_LIB})

@@ -1,48 +1,23 @@
 # Rocksdb Change Log
-## Unreleased
+## 6.19.4 (04/23/2021)
 ### Bug Fixes
-* Fixed a bug in handling file rename error in distributed/network file systems when the server succeeds but client returns error. The bug can cause CURRENT file to point to non-existing MANIFEST file, thus DB cannot be opened.
 * Fixed a bug where ingested files were written with incorrect boundary key metadata. In rare cases this could have led to a level's files being wrongly ordered and queries for the boundary keys returning wrong results.
-* Fixed a data race between insertion into memtables and the retrieval of the DB properties `rocksdb.cur-size-active-mem-table`, `rocksdb.cur-size-all-mem-tables`, and `rocksdb.size-all-mem-tables`.
 * Fixed the false-positive alert when recovering from the WAL file. Avoid reporting "SST file is ahead of WAL" on a newly created empty column family, if the previous WAL file is corrupted.

 ### Behavior Changes
 * Due to the fix of false-postive alert of "SST file is ahead of WAL", all the CFs with no SST file (CF empty) will bypass the consistency check. We fixed a false-positive, but introduced a very rare true-negative which will be triggered in the following conditions: A CF with some delete operations in the last a few queries which will result in an empty CF (those are flushed to SST file and a compaction triggered which combines this file and all other SST files and generates an empty CF, or there is another reason to write a manifest entry for this CF after a flush that generates no SST file from an empty CF). The deletion entries are logged in a WAL and this WAL was corrupted, while the CF's log number points to the next WAL (due to the flush). Therefore, the DB can only recover to the point without these trailing deletions and cause the inconsistent DB status.

-### New Features
-* Add new option allow_stall passed during instance creation of WriteBufferManager. When allow_stall is set, WriteBufferManager will stall all writers shared across multiple DBs and columns if memory usage goes beyond specified WriteBufferManager::buffer_size (soft limit). Stall will be cleared when memory is freed after flush and memory usage goes down below buffer_size.
-
-## 6.20.0 (04/16/2021)
-### Behavior Changes
-* `ColumnFamilyOptions::sample_for_compression` now takes effect for creation of all block-based tables. Previously it only took effect for block-based tables created by flush.
-* `CompactFiles()` can no longer compact files from lower level to up level, which has the risk to corrupt DB (details: #8063). The validation is also added to all compactions.
-* Fixed some cases in which DB::OpenForReadOnly() could write to the filesystem. If you want a Logger with a read-only DB, you must now set DBOptions::info_log yourself, such as using CreateLoggerFromOptions().
-* get_iostats_context() will never return nullptr. If thread-local support is not available, and user does not opt-out iostats context, then compilation will fail. The same applies to perf context as well.
-
+## 6.19.3 (04/19/2021)
+### Bug Fixes
+* Fixed a bug in handling file rename error in distributed/network file systems when the server succeeds but client returns error. The bug can cause CURRENT file to point to non-existing MANIFEST file, thus DB cannot be opened.
+
+## 6.19.2 (04/08/2021)
 ### Bug Fixes
-* Use thread-safe `strerror_r()` to get error messages.
-* Fixed a potential hang in shutdown for a DB whose `Env` has high-pri thread pool disabled (`Env::GetBackgroundThreads(Env::Priority::HIGH) == 0`)
-* Made BackupEngine thread-safe and added documentation comments to clarify what is safe for multiple BackupEngine objects accessing the same backup directory.
-* Fixed crash (divide by zero) when compression dictionary is applied to a file containing only range tombstones.
 * Fixed a backward iteration bug with partitioned filter enabled: not including the prefix of the last key of the previous filter partition in current filter partition can cause wrong iteration result.
-* Fixed a bug that allowed `DBOptions::max_open_files` to be set with a non-negative integer with `ColumnFamilyOptions::compaction_style = kCompactionStyleFIFO`.
-
-### Performance Improvements
-* On ARM platform, use `yield` instead of `wfe` to relax cpu to gain better performance.
-
-### Public API change
-* Added `TableProperties::slow_compression_estimated_data_size` and `TableProperties::fast_compression_estimated_data_size`. When `ColumnFamilyOptions::sample_for_compression > 0`, they estimate what `TableProperties::data_size` would have been if the "fast" or "slow" (see `ColumnFamilyOptions::sample_for_compression` API doc for definitions) compression had been used instead.
-* Update DB::StartIOTrace and remove Env object from the arguments as its redundant and DB already has Env object that is passed down to IOTracer::StartIOTrace
-* Added `FlushReason::kWalFull`, which is reported when a memtable is flushed due to the WAL reaching its size limit; those flushes were previously reported as `FlushReason::kWriteBufferManager`. Also, changed the reason for flushes triggered by the write buffer manager to `FlushReason::kWriteBufferManager`; they were previously reported as `FlushReason::kWriteBufferFull`.
-* Extend file_checksum_dump ldb command and DB::GetLiveFilesChecksumInfo API for IntegratedBlobDB and get checksum of blob files along with SST files.
-
-### New Features
-* Added the ability to open BackupEngine backups as read-only DBs, using BackupInfo::name_for_open and env_for_open provided by BackupEngine::GetBackupInfo() with include_file_details=true.
-* Added BackupEngine support for integrated BlobDB, with blob files shared between backups when table files are shared. Because of current limitations, blob files always use the kLegacyCrc32cAndFileSize naming scheme, and incremental backups must read and checksum all blob files in a DB, even for files that are already backed up.
-* Added an optional output parameter to BackupEngine::CreateNewBackup(WithMetadata) to return the BackupID of the new backup.
-* Added BackupEngine::GetBackupInfo / GetLatestBackupInfo for querying individual backups.
-* Made the Ribbon filter a long-term supported feature in terms of the SST schema(compatible with version >= 6.15.0) though the API for enabling it is expected to change.

+## 6.19.1 (04/01/2021)
+### Bug Fixes
+* Fixed crash (divide by zero) when compression dictionary is applied to a file containing only range tombstones.

 ## 6.19.0 (03/21/2021)
 ### Bug Fixes
@@ -181,7 +156,6 @@
 * The settings of the DBOptions and ColumnFamilyOptions are now managed by Configurable objects (see New Features).  The same convenience methods to configure these options still exist but the backend implementation has been unified under a common implementation.

 ### New Features
-
 * Methods to configure serialize, and compare -- such as TableFactory -- are exposed directly through the Configurable base class (from which these objects inherit).  This change will allow for better and more thorough configuration management and retrieval in the future.  The options for a Configurable object can be set via the ConfigureFromMap, ConfigureFromString, or ConfigureOption method.  The serialized version of the options of an object can be retrieved via the GetOptionString, ToString, or GetOption methods.  The list of options supported by an object can be obtained via the GetOptionNames method.  The "raw" object (such as the BlockBasedTableOption) for an option may be retrieved via the GetOptions method.  Configurable options can be compared via the AreEquivalent method.  The settings within a Configurable object may be validated via the ValidateOptions method.  The object may be intialized (at which point only mutable options may be updated) via the PrepareOptions method.
 * Introduce options.check_flush_compaction_key_order with default value to be true. With this option, during flush and compaction, key order will be checked when writing to each SST file. If the order is violated, the flush or compaction will fail.
 * Added is_full_compaction to CompactionJobStats, so that the information is available through the EventListener interface.
@@ -43,8 +43,6 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
      command line flags processing. You can compile rocksdb library even
      if you don't have gflags installed.

-* `make check` will also check code formatting, which requires [clang-format](https://clang.llvm.org/docs/ClangFormat.html)
-
 * If you wish to build the RocksJava static target, then cmake is required for building Snappy.

 ## Supported platforms
@@ -96,21 +94,12 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
              sudo yum install libasan

    * Install zstandard:
-        * With [EPEL](https://fedoraproject.org/wiki/EPEL):

-              sudo yum install libzstd-devel
-
-        * With CentOS 8:
-
-              sudo dnf install libzstd-devel
-
-        * From source:
-
-              wget https://github.com/facebook/zstd/archive/v1.1.3.tar.gz
-              mv v1.1.3.tar.gz zstd-1.1.3.tar.gz
-              tar zxvf zstd-1.1.3.tar.gz
-              cd zstd-1.1.3
-              make && sudo make install
+             wget https://github.com/facebook/zstd/archive/v1.1.3.tar.gz
+             mv v1.1.3.tar.gz zstd-1.1.3.tar.gz
+             tar zxvf zstd-1.1.3.tar.gz
+             cd zstd-1.1.3
+             make && sudo make install

 * **OS X**:
    * Install latest C++ compiler that supports C++ 11:
@@ -55,25 +55,50 @@ DEBUG_LEVEL?=1
 # Set the default LIB_MODE to static
 LIB_MODE?=static

-# OBJ_DIR is where the object files reside.  Default to the current directory
-OBJ_DIR?=.
+ifeq ($(MAKECMDGOALS),dbg)
+	DEBUG_LEVEL=2
+endif

-# Check the MAKECMDGOALS to set the DEBUG_LEVEL and LIB_MODE appropriately
-
-ifneq ($(filter clean release install, $(MAKECMDGOALS)),)
+ifeq ($(MAKECMDGOALS),clean)
 	DEBUG_LEVEL=0
 endif
-ifneq ($(filter dbg, $(MAKECMDGOALS)),)
-	DEBUG_LEVEL=2
-else ifneq ($(filter shared_lib install-shared, $(MAKECMDGOALS)),)
+
+ifeq ($(MAKECMDGOALS),release)
 	DEBUG_LEVEL=0
+endif
+
+ifeq ($(MAKECMDGOALS),shared_lib)
 	LIB_MODE=shared
-else ifneq ($(filter static_lib install-static, $(MAKECMDGOALS)),)
+	DEBUG_LEVEL=0
+endif
+
+ifeq ($(MAKECMDGOALS),install-shared)
+	LIB_MODE=shared
+	DEBUG_LEVEL=0
+endif
+
+ifeq ($(MAKECMDGOALS),static_lib)
 	DEBUG_LEVEL=0
 	LIB_MODE=static
-else ifneq ($(filter jtest rocksdbjava%, $(MAKECMDGOALS)),)
+endif
+
+ifeq ($(MAKECMDGOALS),install-static)
+	DEBUG_LEVEL=0
+	LIB_MODE=static
+endif
+
+ifeq ($(MAKECMDGOALS),install)
+	DEBUG_LEVEL=0
+endif
+
+
+ifneq ($(findstring jtest, $(MAKECMDGOALS)),)
 	OBJ_DIR=jl
 	LIB_MODE=shared
+endif
+
+ifneq ($(findstring rocksdbjava, $(MAKECMDGOALS)),)
+	LIB_MODE=shared
 	ifneq ($(findstring rocksdbjavastatic, $(MAKECMDGOALS)),)
 		OBJ_DIR=jls
 		ifneq ($(DEBUG_LEVEL),2)
@@ -82,6 +107,8 @@ else ifneq ($(filter jtest rocksdbjava%, $(MAKECMDGOALS)),)
 		ifeq ($(MAKECMDGOALS),rocksdbjavastaticpublish)
 			DEBUG_LEVEL=0
 		endif
+	else
+		OBJ_DIR=jl
 	endif
 endif

@@ -232,8 +259,6 @@ AM_SHARE = $(AM_V_CCLD) $(CXX) $(PLATFORM_SHARED_LDFLAGS)$@ -L. $(patsubst lib%.
 # Export some common variables that might have been passed as Make variables
 # instead of environment variables.
 dummy := $(shell (export ROCKSDB_ROOT="$(CURDIR)"; \
-                  export CXXFLAGS="$(EXTRA_CXXFLAGS)"; \
-                  export LDFLAGS="$(EXTRA_LDFLAGS)"; \
                  export COMPILE_WITH_ASAN="$(COMPILE_WITH_ASAN)"; \
                  export COMPILE_WITH_TSAN="$(COMPILE_WITH_TSAN)"; \
                  export COMPILE_WITH_UBSAN="$(COMPILE_WITH_UBSAN)"; \
@@ -464,6 +489,7 @@ CXXFLAGS += $(WARNING_FLAGS) -I. -I./include $(PLATFORM_CXXFLAGS) $(OPT) -Woverl

 LDFLAGS += $(PLATFORM_LDFLAGS)

+OBJ_DIR?=.
 LIB_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(LIB_SOURCES))
 LIB_OBJECTS += $(patsubst %.cc, $(OBJ_DIR)/%.o, $(ROCKSDB_PLUGIN_SOURCES))
 ifeq ($(HAVE_POWER8),1)
@@ -491,14 +517,12 @@ VALGRIND_OPTS = --error-exitcode=$(VALGRIND_ERROR) --leak-check=full

 TEST_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(TEST_LIB_SOURCES) $(MOCK_LIB_SOURCES)) $(GTEST)
 BENCH_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(BENCH_LIB_SOURCES))
-CACHE_BENCH_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(CACHE_BENCH_LIB_SOURCES))
 TOOL_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(TOOL_LIB_SOURCES))
 ANALYZE_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(ANALYZER_LIB_SOURCES))
 STRESS_OBJECTS =  $(patsubst %.cc, $(OBJ_DIR)/%.o, $(STRESS_LIB_SOURCES))

-# Exclude build_version.cc -- a generated source file -- from all sources.  Not needed for dependencies
 ALL_SOURCES  = $(LIB_SOURCES) $(TEST_LIB_SOURCES) $(MOCK_LIB_SOURCES) $(GTEST_DIR)/gtest/gtest-all.cc
-ALL_SOURCES += $(TOOL_LIB_SOURCES) $(BENCH_LIB_SOURCES) $(CACHE_BENCH_LIB_SOURCES) $(ANALYZER_LIB_SOURCES) $(STRESS_LIB_SOURCES)
+ALL_SOURCES += $(TOOL_LIB_SOURCES) $(BENCH_LIB_SOURCES) $(ANALYZER_LIB_SOURCES) $(STRESS_LIB_SOURCES)
 ALL_SOURCES += $(TEST_MAIN_SOURCES) $(TOOL_MAIN_SOURCES) $(BENCH_MAIN_SOURCES)

 TESTS = $(patsubst %.cc, %, $(notdir $(TEST_MAIN_SOURCES)))
@@ -509,34 +533,236 @@ ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
 	ALL_SOURCES += third-party/folly/folly/synchronization/test/DistributedMutexTest.cc
 endif

+PARALLEL_TEST = \
+	backupable_db_test \
+	db_bloom_filter_test \
+	db_compaction_filter_test \
+	db_compaction_test \
+	db_merge_operator_test \
+	db_sst_test \
+	db_test \
+	db_test2 \
+	db_universal_compaction_test \
+	db_wal_test \
+	column_family_test \
+	external_sst_file_test \
+	import_column_family_test \
+	fault_injection_test \
+	file_reader_writer_test \
+	inlineskiplist_test \
+	manual_compaction_test \
+	persistent_cache_test \
+	table_test \
+	transaction_test \
+	point_lock_manager_test \
+	range_locking_test \
+	write_prepared_transaction_test \
+	write_unprepared_transaction_test \
+
+ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
+	TESTS += folly_synchronization_distributed_mutex_test
+	PARALLEL_TEST += folly_synchronization_distributed_mutex_test
+	TESTS_PASSING_ASC = folly_synchronization_distributed_mutex_test
+endif
+
 # options_settable_test doesn't pass with UBSAN as we use hack in the test
 ifdef COMPILE_WITH_UBSAN
        TESTS := $(shell echo $(TESTS) | sed 's/\boptions_settable_test\b//g')
 endif
 ifdef ASSERT_STATUS_CHECKED
-	# TODO: finish fixing all tests to pass this check
-	TESTS_FAILING_ASC = \
-		db_test \
-		db_test2 \
-		range_locking_test \
-		testutil_test \
+# This is a new check for which we will add support incrementally. This
+# list can be removed once support is fully added.
+	TESTS_PASSING_ASC = \
+		arena_test \
+		autovector_test \
+		cache_test \
+		lru_cache_test \
+		blob_file_addition_test \
+		blob_file_builder_test \
+		blob_file_cache_test \
+		blob_file_garbage_test \
+		blob_file_reader_test \
+		bloom_test \
+		cassandra_format_test \
+		cassandra_functional_test \
+		cassandra_row_merge_test \
+		cassandra_serialize_test \
+		cleanable_test \
+		checkpoint_test \
+		coding_test \
+		crc32c_test \
+		dbformat_test \
+		db_basic_test \
+		compact_files_test \
+		compaction_picker_test \
+		comparator_db_test \
+		db_encryption_test \
+		db_iter_test \
+		db_iter_stress_test \
+		db_log_iter_test \
+		db_bloom_filter_test \
+		db_blob_basic_test \
+		db_blob_compaction_test \
+		db_blob_corruption_test \
+		db_blob_index_test \
+		db_block_cache_test \
+		db_compaction_test \
+		db_compaction_filter_test \
+		db_dynamic_level_test \
+		db_flush_test \
+		db_inplace_update_test \
+		db_io_failure_test \
+		db_iterator_test \
+		db_kv_checksum_test \
+		db_logical_block_size_cache_test \
+		db_memtable_test \
+		db_merge_operand_test \
+		db_merge_operator_test \
+		db_wal_test \
+		db_with_timestamp_basic_test \
+		db_with_timestamp_compaction_test \
+		db_write_test \
+		db_options_test \
+		db_properties_test \
+		db_range_del_test \
+		db_secondary_test \
+		deletefile_test \
+		external_sst_file_test \
+		options_file_test \
+		db_sst_test \
+		db_statistics_test \
+		db_table_properties_test \
+		db_tailing_iter_test \
+		fault_injection_test \
+		listener_test \
+		log_test \
+		manual_compaction_test \
+		obsolete_files_test \
+		perf_context_test \
+		periodic_work_scheduler_test \
+		perf_context_test \
+		version_set_test \
+		wal_manager_test \
+		defer_test \
+		filename_test \
+		dynamic_bloom_test \
+		env_basic_test \
+		env_test \
+		env_logger_test \
+		event_logger_test \
+		error_handler_fs_test \
+		external_sst_file_basic_test \
+		auto_roll_logger_test \
+		file_indexer_test \
+		delete_scheduler_test \
+		flush_job_test \
+		hash_table_test \
+		hash_test \
+		heap_test \
+		histogram_test \
+		inlineskiplist_test \
+		io_posix_test \
+		iostats_context_test \
+		ldb_cmd_test \
+		memkind_kmem_allocator_test \
+		merge_test \
+		merger_test \
+		mock_env_test \
+		object_registry_test \
+		optimistic_transaction_test \
+		prefix_test \
+		plain_table_db_test \
+		repair_test \
+		configurable_test \
+		customizable_test \
+		options_settable_test \
+		options_test \
+		point_lock_manager_test \
+		random_access_file_reader_test \
+		random_test \
+		range_del_aggregator_test \
+		sst_file_reader_test \
+		range_tombstone_fragmenter_test \
+		repeatable_thread_test \
+		ribbon_test \
+		skiplist_test \
+		slice_test \
+		slice_transform_test \
+		sst_dump_test \
+		statistics_test \
+		stats_history_test \
+		stringappend_test \
+		thread_local_test \
+		trace_analyzer_test \
+		transaction_test \
+		env_timed_test \
+		filelock_test \
+		timer_queue_test \
+		timer_test \
+		options_util_test \
+		persistent_cache_test \
+		util_merge_operators_test \
+		block_cache_trace_analyzer_test \
+		block_cache_tracer_test \
+		cache_simulator_test \
+		sim_cache_test \
+		version_builder_test \
+		version_edit_test \
+		work_queue_test \
+		write_buffer_manager_test \
+		write_controller_test \
+		write_prepared_transaction_test \
+		write_unprepared_transaction_test \
+		compaction_iterator_test \
+		compaction_job_test \
+		compaction_job_stats_test \
+		io_tracer_test \
+		io_tracer_parser_test \
+		prefetch_test \
+		merge_helper_test \
+		memtable_list_test \
+		flush_job_test \
+		block_based_filter_block_test \
+		block_fetcher_test \
+		block_test \
+		data_block_hash_index_test \
+		full_filter_block_test \
+		partitioned_filter_block_test \
+		column_family_test \
+		file_reader_writer_test \
+		rate_limiter_test \
+		corruption_test \
+		reduce_levels_test \
+		thread_list_test \
+		compact_on_deletion_collector_test \
+		db_universal_compaction_test \
+		import_column_family_test \
+		option_change_migration_test \
+		cuckoo_table_builder_test \
+		cuckoo_table_db_test \
+		cuckoo_table_reader_test \
+		memory_test \
+		table_test \
+		backupable_db_test \
+		blob_db_test \
+		ttl_test \
+		write_batch_test \
+		write_batch_with_index_test \

-	# Since we have very few ASC exclusions left, excluding them from
-	# the build is the most convenient way to exclude them from testing
-	TESTS := $(filter-out $(TESTS_FAILING_ASC),$(TESTS))
+ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
+TESTS_PASSING_ASC += folly_synchronization_distributed_mutex_test
 endif

-ROCKSDBTESTS_SUBSET ?= $(TESTS)
-
-# env_test - suspicious use of test::TmpDir
-# deletefile_test - serial because it generates giant temporary files in
-#   its various tests. Parallel can fill up your /dev/shm
-NON_PARALLEL_TEST = \
-	env_test \
-	deletefile_test \
-
-PARALLEL_TEST = $(filter-out $(NON_PARALLEL_TEST), $(TESTS))
-
+	# Enable building all unit tests, but use check_some to run only tests
+	# known to pass ASC (ASSERT_STATUS_CHECKED)
+	ROCKSDBTESTS_SUBSET ?= $(TESTS_PASSING_ASC)
+	# Alternate: only build unit tests known to pass ASC, and run them
+	# with make check
+	#TESTS := $(filter $(TESTS_PASSING_ASC),$(TESTS))
+	#PARALLEL_TEST := $(filter $(TESTS_PASSING_ASC),$(PARALLEL_TEST))
+else
+	ROCKSDBTESTS_SUBSET ?= $(TESTS)
+endif
 # Not necessarily well thought out or up-to-date, but matches old list
 TESTS_PLATFORM_DEPENDENT := \
 	db_basic_test \
@@ -624,8 +850,8 @@ else
 LIBRARY=$(STATIC_LIBRARY)
 TEST_LIBRARY=$(STATIC_TEST_LIBRARY)
 TOOLS_LIBRARY=$(STATIC_TOOLS_LIBRARY)
-endif
 STRESS_LIBRARY=$(STATIC_STRESS_LIBRARY)
+endif

 ROCKSDB_MAJOR = $(shell egrep "ROCKSDB_MAJOR.[0-9]" include/rocksdb/version.h | cut -d ' ' -f 3)
 ROCKSDB_MINOR = $(shell egrep "ROCKSDB_MINOR.[0-9]" include/rocksdb/version.h | cut -d ' ' -f 3)
@@ -709,8 +935,7 @@ endif  # PLATFORM_SHARED_EXT
 	analyze tools tools_lib \
 	blackbox_crash_test_with_atomic_flush whitebox_crash_test_with_atomic_flush  \
 	blackbox_crash_test_with_txn whitebox_crash_test_with_txn \
-	blackbox_crash_test_with_best_efforts_recovery \
-	blackbox_crash_test_with_ts whitebox_crash_test_with_ts
+	blackbox_crash_test_with_best_efforts_recovery


 all: $(LIBRARY) $(BENCHMARKS) tools tools_lib test_libs $(TESTS)
@@ -948,8 +1173,6 @@ crash_test_with_txn: whitebox_crash_test_with_txn blackbox_crash_test_with_txn

 crash_test_with_best_efforts_recovery: blackbox_crash_test_with_best_efforts_recovery

-crash_test_with_ts: whitebox_crash_test_with_ts blackbox_crash_test_with_ts
-
 blackbox_crash_test: db_stress
 	$(PYTHON) -u tools/db_crashtest.py --simple blackbox $(CRASH_TEST_EXT_ARGS)
 	$(PYTHON) -u tools/db_crashtest.py blackbox $(CRASH_TEST_EXT_ARGS)
@@ -963,9 +1186,6 @@ blackbox_crash_test_with_txn: db_stress
 blackbox_crash_test_with_best_efforts_recovery: db_stress
 	$(PYTHON) -u tools/db_crashtest.py --test_best_efforts_recovery blackbox $(CRASH_TEST_EXT_ARGS)

-blackbox_crash_test_with_ts: db_stress
-	$(PYTHON) -u tools/db_crashtest.py --enable_ts blackbox $(CRASH_TEST_EXT_ARGS)
-
 ifeq ($(CRASH_TEST_KILL_ODD),)
  CRASH_TEST_KILL_ODD=888887
 endif
@@ -984,10 +1204,6 @@ whitebox_crash_test_with_txn: db_stress
 	$(PYTHON) -u tools/db_crashtest.py --txn whitebox --random_kill_odd \
      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

-whitebox_crash_test_with_ts: db_stress
-	$(PYTHON) -u tools/db_crashtest.py --enable_ts whitebox --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
 asan_check: clean
 	COMPILE_WITH_ASAN=1 $(MAKE) check -j32
 	$(MAKE) clean
@@ -1133,9 +1349,8 @@ analyze_incremental:
 		$(MAKE) dbg

 CLEAN_FILES += unity.cc
-unity.cc: Makefile util/build_version.cc.in
+unity.cc: Makefile
 	rm -f $@ $@-t
-	$(AM_V_at)$(gen_build_version) > util/build_version.cc
 	for source_file in $(LIB_SOURCES); do \
 		echo "#include \"$$source_file\"" >> $@-t; \
 	done
@@ -1219,7 +1434,7 @@ $(STATIC_TOOLS_LIBRARY): $(TOOL_OBJECTS)
 	$(AM_V_AR)rm -f $@ $(SHARED_TOOLS_LIBRARY)
 	$(AM_V_at)$(AR) $(ARFLAGS) $@ $^

-$(STATIC_STRESS_LIBRARY): $(ANALYZE_OBJECTS) $(STRESS_OBJECTS) $(TESTUTIL)
+$(STATIC_STRESS_LIBRARY): $(ANALYZE_OBJECTS) $(STRESS_OBJECTS)
 	$(AM_V_AR)rm -f $@ $(SHARED_STRESS_LIBRARY)
 	$(AM_V_at)$(AR) $(ARFLAGS) $@ $^

@@ -1231,7 +1446,7 @@ $(SHARED_TOOLS_LIBRARY): $(TOOL_OBJECTS) $(SHARED1)
 	$(AM_V_AR)rm -f $@ $(STATIC_TOOLS_LIBRARY)
 	$(AM_SHARE)

-$(SHARED_STRESS_LIBRARY): $(ANALYZE_OBJECTS) $(STRESS_OBJECTS) $(TESTUTIL) $(SHARED_TOOLS_LIBRARY) $(SHARED1)
+$(SHARED_STRESS_LIBRARY): $(ANALYZE_OBJECTS) $(STRESS_OBJECTS) $(SHARED_TOOLS_LIBRARY) $(SHARED1)
 	$(AM_V_AR)rm -f $@ $(STATIC_STRESS_LIBRARY)
 	$(AM_SHARE)

@@ -1253,7 +1468,7 @@ folly_synchronization_distributed_mutex_test: $(OBJ_DIR)/third-party/folly/folly
 	$(AM_LINK)
 endif

-cache_bench: $(OBJ_DIR)/cache/cache_bench.o $(CACHE_BENCH_OBJECTS) $(LIBRARY)
+cache_bench: $(OBJ_DIR)/cache/cache_bench.o $(LIBRARY)
 	$(AM_LINK)

 persistent_cache_bench: $(OBJ_DIR)/utilities/persistent_cache/persistent_cache_bench.o $(LIBRARY)
@@ -1860,9 +2075,6 @@ io_tracer_parser: $(OBJ_DIR)/tools/io_tracer_parser.o $(TOOLS_LIBRARY) $(LIBRARY

 db_blob_corruption_test: $(OBJ_DIR)/db/blob/db_blob_corruption_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
-
-db_write_buffer_manager_test: $(OBJ_DIR)/db/db_write_buffer_manager_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
 #-------------------------------------------------
 # make install related stuff
 PREFIX ?= /usr/local
@@ -2278,14 +2490,12 @@ endif
 # ---------------------------------------------------------------------------
 #  	Source files dependencies detection
 # ---------------------------------------------------------------------------
-# If skip dependencies is ON, skip including the dep files
-ifneq ($(SKIP_DEPENDS), 1)
+
 DEPFILES = $(patsubst %.cc, $(OBJ_DIR)/%.cc.d, $(ALL_SOURCES))
 DEPFILES+ = $(patsubst %.c, $(OBJ_DIR)/%.c.d, $(LIB_SOURCES_C) $(TEST_MAIN_SOURCES_C))
 ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
  DEPFILES +=$(patsubst %.cpp, $(OBJ_DIR)/%.cpp.d, $(FOLLY_SOURCES))
 endif
-endif

 # Add proper dependency support so changing a .h file forces a .cc file to
 # rebuild.
@@ -2325,9 +2535,28 @@ endif
 build_subset_tests: $(ROCKSDBTESTS_SUBSET)
 	$(AM_V_GEN)if [ -n "$${ROCKSDBTESTS_SUBSET_TESTS_TO_FILE}" ]; then echo "$(ROCKSDBTESTS_SUBSET)" > "$${ROCKSDBTESTS_SUBSET_TESTS_TO_FILE}"; else echo "$(ROCKSDBTESTS_SUBSET)"; fi

-# Remove the rules for which dependencies should not be generated and see if any are left.
-#If so, include the dependencies; if not, do not include the dependency files
-ROCKS_DEP_RULES=$(filter-out clean format check-format check-buck-targets jclean jtest package analyze tags rocksdbjavastatic% unity.% unity_test, $(MAKECMDGOALS))
-ifneq ("$(ROCKS_DEP_RULES)", "")
+# if the make goal is either "clean" or "format", we shouldn't
+# try to import the *.d files.
+# TODO(kailiu) The unfamiliarity of Make's conditions leads to the ugly
+# working solution.
+ifneq ($(MAKECMDGOALS),clean)
+ifneq ($(MAKECMDGOALS),format)
+ifneq ($(MAKECMDGOALS),check-format)
+ifneq ($(MAKECMDGOALS),check-buck-targets)
+ifneq ($(MAKECMDGOALS),jclean)
+ifneq ($(MAKECMDGOALS),jtest)
+ifneq ($(MAKECMDGOALS),rocksdbjavastatic)
+ifneq ($(MAKECMDGOALS),rocksdbjavastatic_deps)
+ifneq ($(MAKECMDGOALS),package)
+ifneq ($(MAKECMDGOALS),analyze)
 -include $(DEPFILES)
 endif
+endif
+endif
+endif
+endif
+endif
+endif
+endif
+endif
+endif
@@ -1,4 +1,3 @@
 This is the list of all known third-party plugins for RocksDB. If something is missing, please open a pull request to add it.

 * [Dedupfs](https://github.com/ajkr/dedupfs): an example for plugin developers to reference
-* [ZenFS](https://github.com/westerndigitalcorporation/zenfs): a file system for zoned block devices
@@ -69,25 +69,25 @@ def get_cc_files(repo_path):
    return cc_files


-# Get non_parallel tests from Makefile
-def get_non_parallel_tests(repo_path):
+# Get parallel tests from Makefile
+def get_parallel_tests(repo_path):
    Makefile = repo_path + "/Makefile"

    s = set({})

-    found_non_parallel_tests = False
+    found_parallel_tests = False
    for line in open(Makefile):
        line = line.strip()
-        if line.startswith("NON_PARALLEL_TEST ="):
-            found_non_parallel_tests = True
-        elif found_non_parallel_tests:
+        if line.startswith("PARALLEL_TEST ="):
+            found_parallel_tests = True
+        elif found_parallel_tests:
            if line.endswith("\\"):
                # remove the trailing \
                line = line[:-1]
                line = line.strip()
                s.add(line)
            else:
-                # we consumed all the non_parallel tests
+                # we consumed all the parallel tests
                break

    return s
@@ -123,10 +123,10 @@ def generate_targets(repo_path, deps_map):
    src_mk = parse_src_mk(repo_path)
    # get all .cc files
    cc_files = get_cc_files(repo_path)
-    # get non_parallel tests from Makefile
-    non_parallel_tests = get_non_parallel_tests(repo_path)
+    # get parallel tests from Makefile
+    parallel_tests = get_parallel_tests(repo_path)

-    if src_mk is None or cc_files is None or non_parallel_tests is None:
+    if src_mk is None or cc_files is None or parallel_tests is None:
        return False

    extra_argv = ""
@@ -173,11 +173,6 @@ def generate_targets(repo_path, deps_map):
        src_mk.get("ANALYZER_LIB_SOURCES", []) +
        ["test_util/testutil.cc"],
        [":rocksdb_lib"])
-    # rocksdb_cache_bench_tools_lib
-    TARGETS.add_library(
-        "rocksdb_cache_bench_tools_lib",
-        src_mk.get("CACHE_BENCH_LIB_SOURCES", []),
-        [":rocksdb_lib"])
    # rocksdb_stress_lib
    TARGETS.add_rocksdb_library(
        "rocksdb_stress_lib",
@@ -216,7 +211,7 @@ def generate_targets(repo_path, deps_map):
            TARGETS.register_test(
                test_target_name,
                test_src,
-                test not in non_parallel_tests,
+                test in parallel_tests,
                json.dumps(deps['extra_deps']),
                json.dumps(deps['extra_compiler_flags']))

@@ -177,7 +177,7 @@ case "$TARGET_OS" in
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -ldl"
        if test $ROCKSDB_USE_IO_URING; then
            # check for liburing
-            $CXX $PLATFORM_CXXFLAGS -x c++ - -luring -o /dev/null 2>/dev/null  <<EOF
+            $CXX $CFLAGS -x c++ - -luring -o /dev/null 2>/dev/null  <<EOF
              #include <liburing.h>
              int main() {
                struct io_uring ring;
@@ -288,7 +288,7 @@ if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then
 else
    if ! test $ROCKSDB_DISABLE_FALLOCATE; then
        # Test whether fallocate is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <fcntl.h>
          #include <linux/falloc.h>
          int main() {
@@ -304,7 +304,7 @@ EOF
    if ! test $ROCKSDB_DISABLE_SNAPPY; then
        # Test whether Snappy library is installed
        # http://code.google.com/p/snappy/
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <snappy.h>
          int main() {}
 EOF
@@ -319,7 +319,7 @@ EOF
        # Test whether gflags library is installed
        # http://gflags.github.io/gflags/
        # check if the namespace is gflags
-        if $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
+        if $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
          #include <gflags/gflags.h>
          using namespace GFLAGS_NAMESPACE;
          int main() {}
@@ -328,7 +328,7 @@ EOF
          COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1"
          PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
        # check if namespace is gflags
-        elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
+        elif $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
            #include <gflags/gflags.h>
            using namespace gflags;
            int main() {}
@@ -337,7 +337,7 @@ EOF
          COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1 -DGFLAGS_NAMESPACE=gflags"
          PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
        # check if namespace is google
-        elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
+        elif $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
            #include <gflags/gflags.h>
            using namespace google;
            int main() {}
@@ -350,7 +350,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_ZLIB; then
        # Test whether zlib library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <zlib.h>
          int main() {}
 EOF
@@ -363,7 +363,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_BZIP; then
        # Test whether bzip library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <bzlib.h>
          int main() {}
 EOF
@@ -376,7 +376,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_LZ4; then
        # Test whether lz4 library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <lz4.h>
          #include <lz4hc.h>
          int main() {}
@@ -390,7 +390,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_ZSTD; then
        # Test whether zstd library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <zstd.h>
          int main() {}
 EOF
@@ -403,7 +403,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_NUMA; then
        # Test whether numa is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -lnuma 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null -lnuma 2>/dev/null  <<EOF
          #include <numa.h>
          #include <numaif.h>
          int main() {}
@@ -417,7 +417,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_TBB; then
        # Test whether tbb is available
-        $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o /dev/null -ltbb 2>/dev/null  <<EOF
+        $CXX $CFLAGS $LDFLAGS -x c++ - -o /dev/null -ltbb 2>/dev/null  <<EOF
          #include <tbb/tbb.h>
          int main() {}
 EOF
@@ -430,7 +430,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_JEMALLOC; then
        # Test whether jemalloc is available
-        if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -ljemalloc \
+        if echo 'int main() {}' | $CXX $CFLAGS -x c++ - -o /dev/null -ljemalloc \
          2>/dev/null; then
            # This will enable some preprocessor identifiers in the Makefile
            JEMALLOC=1
@@ -451,7 +451,7 @@ EOF
    fi
    if ! test $JEMALLOC && ! test $ROCKSDB_DISABLE_TCMALLOC; then
        # jemalloc is not available. Let's try tcmalloc
-        if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null \
+        if echo 'int main() {}' | $CXX $CFLAGS -x c++ - -o /dev/null \
          -ltcmalloc 2>/dev/null; then
            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltcmalloc"
            JAVA_LDFLAGS="$JAVA_LDFLAGS -ltcmalloc"
@@ -460,7 +460,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_MALLOC_USABLE_SIZE; then
        # Test whether malloc_usable_size is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <malloc.h>
          int main() {
            size_t res = malloc_usable_size(0);
@@ -475,7 +475,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_MEMKIND; then
        # Test whether memkind library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -lmemkind -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS $COMMON_FLAGS -lmemkind -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <memkind.h>
          int main() {
            memkind_malloc(MEMKIND_DAX_KMEM, 1024);
@@ -491,7 +491,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_PTHREAD_MUTEX_ADAPTIVE_NP; then
        # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <pthread.h>
          int main() {
            int x = PTHREAD_MUTEX_ADAPTIVE_NP;
@@ -506,7 +506,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_BACKTRACE; then
        # Test whether backtrace is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <execinfo.h>
          int main() {
            void* frames[1];
@@ -518,7 +518,7 @@ EOF
            COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
        else
            # Test whether execinfo library is installed
-            $CXX $PLATFORM_CXXFLAGS -lexecinfo -x c++ - -o /dev/null 2>/dev/null  <<EOF
+            $CXX $CFLAGS -lexecinfo -x c++ - -o /dev/null 2>/dev/null  <<EOF
              #include <execinfo.h>
              int main() {
                void* frames[1];
@@ -535,7 +535,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_PG; then
        # Test if -pg is supported
-        $CXX $PLATFORM_CXXFLAGS -pg -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -pg -x c++ - -o /dev/null 2>/dev/null  <<EOF
          int main() {
            return 0;
          }
@@ -547,7 +547,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_SYNC_FILE_RANGE; then
        # Test whether sync_file_range is supported for compatibility with an old glibc
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <fcntl.h>
          int main() {
            int fd = open("/dev/null", 0);
@@ -561,7 +561,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_SCHED_GETCPU; then
        # Test whether sched_getcpu is supported
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <sched.h>
          int main() {
            int cpuid = sched_getcpu();
@@ -575,7 +575,7 @@ EOF

    if ! test $ROCKSDB_DISABLE_AUXV_GETAUXVAL; then
        # Test whether getauxval is supported
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
+        $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
          #include <sys/auxv.h>
          int main() {
            uint64_t auxv = getauxval(AT_HWCAP);
@@ -603,7 +603,7 @@ fi
 # -Wshorten-64-to-32 breaks compilation on FreeBSD i386
 if ! [ "$TARGET_OS" = FreeBSD -a "$TARGET_ARCHITECTURE" = i386 ]; then
  # Test whether -Wshorten-64-to-32 is available
-  $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -Wshorten-64-to-32 2>/dev/null  <<EOF
+  $CXX $CFLAGS -x c++ - -o /dev/null -Wshorten-64-to-32 2>/dev/null  <<EOF
    int main() {}
 EOF
  if [ "$?" = 0 ]; then
@@ -136,11 +136,9 @@ then
  FORMAT_UPSTREAM_MERGE_BASE="$(git merge-base "$FORMAT_UPSTREAM" HEAD)"
  # Get the differences
  diffs=$(git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" | $CLANG_FORMAT_DIFF -p 1)
-  echo "Checking format of changes not yet in $FORMAT_UPSTREAM..."
 else
  # Check the format of uncommitted lines,
  diffs=$(git diff -U0 HEAD | $CLANG_FORMAT_DIFF -p 1)
-  echo "Checking format of uncommitted changes..."
 fi

 if [ -z "$diffs" ]
@@ -548,36 +548,6 @@ STRESS_CRASH_TEST_WITH_TXN_COMMANDS="[
    }
 ]"

-#
-# RocksDB stress/crash test with timestamp
-#
-STRESS_CRASH_TEST_WITH_TS_COMMANDS="[
-    {
-        'name':'Rocksdb Stress and Crash Test with ts',
-        'oncall':'$ONCALL',
-        'executeLocal': 'true',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build and run RocksDB debug stress tests',
-                'shell':'cd $WORKING_DIR; $SHM $DEBUG $NON_TSAN_CRASH make J=1 db_stress || $CONTRUN_NAME=db_stress $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            {
-                'name':'Build and run RocksDB debug crash tests with ts',
-                'timeout': 86400,
-                'shell':'cd $WORKING_DIR; $SHM $DEBUG $NON_TSAN_CRASH make J=1 crash_test_with_ts || $CONTRUN_NAME=crash_test_with_ts $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            $UPLOAD_DB_DIR,
-        ],
-        $REPORT
-    }
-]"
-
 # RocksDB write stress test.
 # We run on disk device on purpose (i.e. no $SHM)
 # because we want to add some randomness to fsync commands
@@ -1250,9 +1220,6 @@ case $1 in
  stress_crash_with_txn)
    echo $STRESS_CRASH_TEST_WITH_TXN_COMMANDS
    ;;
-  stress_crash_with_ts)
-    echo $STRESS_CRASH_TEST_WITH_TS_COMMANDS
-    ;;
  write_stress)
    echo $WRITE_STRESS_COMMANDS
    ;;
@@ -1,11 +1,7 @@
-//  Copyright (c) 2013-present, Facebook, Inc.  All rights reserved.
+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
 //  This source code is licensed under both the GPLv2 (found in the
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.

 #ifndef GFLAGS
 #include <cstdio>
@@ -14,8 +10,375 @@ int main() {
  return 1;
 }
 #else
-#include <rocksdb/cache_bench_tool.h>
-int main(int argc, char** argv) {
-  return ROCKSDB_NAMESPACE::cache_bench_tool(argc, argv);
+
+#include <sys/types.h>
+
+#include <cinttypes>
+#include <cstdio>
+#include <limits>
+
+#include "port/port.h"
+#include "rocksdb/cache.h"
+#include "rocksdb/db.h"
+#include "rocksdb/env.h"
+#include "rocksdb/system_clock.h"
+#include "util/coding.h"
+#include "util/gflags_compat.h"
+#include "util/hash.h"
+#include "util/mutexlock.h"
+#include "util/random.h"
+
+using GFLAGS_NAMESPACE::ParseCommandLineFlags;
+
+static constexpr uint32_t KiB = uint32_t{1} << 10;
+static constexpr uint32_t MiB = KiB << 10;
+static constexpr uint64_t GiB = MiB << 10;
+
+DEFINE_uint32(threads, 16, "Number of concurrent threads to run.");
+DEFINE_uint64(cache_size, 1 * GiB,
+              "Number of bytes to use as a cache of uncompressed data.");
+DEFINE_uint32(num_shard_bits, 6, "shard_bits.");
+
+DEFINE_double(resident_ratio, 0.25,
+              "Ratio of keys fitting in cache to keyspace.");
+DEFINE_uint64(ops_per_thread, 0,
+              "Number of operations per thread. (Default: 5 * keyspace size)");
+DEFINE_uint32(value_bytes, 8 * KiB, "Size of each value added.");
+
+DEFINE_uint32(skew, 5, "Degree of skew in key selection");
+DEFINE_bool(populate_cache, true, "Populate cache before operations");
+
+DEFINE_uint32(lookup_insert_percent, 87,
+              "Ratio of lookup (+ insert on not found) to total workload "
+              "(expressed as a percentage)");
+DEFINE_uint32(insert_percent, 2,
+              "Ratio of insert to total workload (expressed as a percentage)");
+DEFINE_uint32(lookup_percent, 10,
+              "Ratio of lookup to total workload (expressed as a percentage)");
+DEFINE_uint32(erase_percent, 1,
+              "Ratio of erase to total workload (expressed as a percentage)");
+
+DEFINE_bool(use_clock_cache, false, "");
+
+namespace ROCKSDB_NAMESPACE {
+
+class CacheBench;
+namespace {
+// State shared by all concurrent executions of the same benchmark.
+class SharedState {
+ public:
+  explicit SharedState(CacheBench* cache_bench)
+      : cv_(&mu_),
+        num_initialized_(0),
+        start_(false),
+        num_done_(0),
+        cache_bench_(cache_bench) {}
+
+  ~SharedState() {}
+
+  port::Mutex* GetMutex() {
+    return &mu_;
+  }
+
+  port::CondVar* GetCondVar() {
+    return &cv_;
+  }
+
+  CacheBench* GetCacheBench() const {
+    return cache_bench_;
+  }
+
+  void IncInitialized() {
+    num_initialized_++;
+  }
+
+  void IncDone() {
+    num_done_++;
+  }
+
+  bool AllInitialized() const { return num_initialized_ >= FLAGS_threads; }
+
+  bool AllDone() const { return num_done_ >= FLAGS_threads; }
+
+  void SetStart() {
+    start_ = true;
+  }
+
+  bool Started() const {
+    return start_;
+  }
+
+ private:
+  port::Mutex mu_;
+  port::CondVar cv_;
+
+  uint64_t num_initialized_;
+  bool start_;
+  uint64_t num_done_;
+
+  CacheBench* cache_bench_;
+};
+
+// Per-thread state for concurrent executions of the same benchmark.
+struct ThreadState {
+  uint32_t tid;
+  Random64 rnd;
+  SharedState* shared;
+
+  ThreadState(uint32_t index, SharedState* _shared)
+      : tid(index), rnd(1000 + index), shared(_shared) {}
+};
+
+struct KeyGen {
+  char key_data[27];
+
+  Slice GetRand(Random64& rnd, uint64_t max_key) {
+    uint64_t raw = rnd.Next();
+    // Skew according to setting
+    for (uint32_t i = 0; i < FLAGS_skew; ++i) {
+      raw = std::min(raw, rnd.Next());
+    }
+    uint64_t key = FastRange64(raw, max_key);
+    // Variable size and alignment
+    size_t off = key % 8;
+    key_data[0] = char{42};
+    EncodeFixed64(key_data + 1, key);
+    key_data[9] = char{11};
+    EncodeFixed64(key_data + 10, key);
+    key_data[18] = char{4};
+    EncodeFixed64(key_data + 19, key);
+    return Slice(&key_data[off], sizeof(key_data) - off);
+  }
+};
+
+char* createValue(Random64& rnd) {
+  char* rv = new char[FLAGS_value_bytes];
+  // Fill with some filler data, and take some CPU time
+  for (uint32_t i = 0; i < FLAGS_value_bytes; i += 8) {
+    EncodeFixed64(rv + i, rnd.Next());
+  }
+  return rv;
 }
+
+void deleter(const Slice& /*key*/, void* value) {
+  delete[] static_cast<char*>(value);
+}
+}  // namespace
+
+class CacheBench {
+  static constexpr uint64_t kHundredthUint64 =
+      std::numeric_limits<uint64_t>::max() / 100U;
+
+ public:
+  CacheBench()
+      : max_key_(static_cast<uint64_t>(FLAGS_cache_size / FLAGS_resident_ratio /
+                                       FLAGS_value_bytes)),
+        lookup_insert_threshold_(kHundredthUint64 *
+                                 FLAGS_lookup_insert_percent),
+        insert_threshold_(lookup_insert_threshold_ +
+                          kHundredthUint64 * FLAGS_insert_percent),
+        lookup_threshold_(insert_threshold_ +
+                          kHundredthUint64 * FLAGS_lookup_percent),
+        erase_threshold_(lookup_threshold_ +
+                         kHundredthUint64 * FLAGS_erase_percent) {
+    if (erase_threshold_ != 100U * kHundredthUint64) {
+      fprintf(stderr, "Percentages must add to 100.\n");
+      exit(1);
+    }
+    if (FLAGS_use_clock_cache) {
+      cache_ = NewClockCache(FLAGS_cache_size, FLAGS_num_shard_bits);
+      if (!cache_) {
+        fprintf(stderr, "Clock cache not supported.\n");
+        exit(1);
+      }
+    } else {
+      cache_ = NewLRUCache(FLAGS_cache_size, FLAGS_num_shard_bits);
+    }
+    if (FLAGS_ops_per_thread == 0) {
+      FLAGS_ops_per_thread = 5 * max_key_;
+    }
+  }
+
+  ~CacheBench() {}
+
+  void PopulateCache() {
+    Random64 rnd(1);
+    KeyGen keygen;
+    for (uint64_t i = 0; i < 2 * FLAGS_cache_size; i += FLAGS_value_bytes) {
+      cache_->Insert(keygen.GetRand(rnd, max_key_), createValue(rnd),
+                     FLAGS_value_bytes, &deleter);
+    }
+  }
+
+  bool Run() {
+    ROCKSDB_NAMESPACE::Env* env = ROCKSDB_NAMESPACE::Env::Default();
+    const auto& clock = env->GetSystemClock();
+
+    PrintEnv();
+    SharedState shared(this);
+    std::vector<std::unique_ptr<ThreadState> > threads(FLAGS_threads);
+    for (uint32_t i = 0; i < FLAGS_threads; i++) {
+      threads[i].reset(new ThreadState(i, &shared));
+      env->StartThread(ThreadBody, threads[i].get());
+    }
+    {
+      MutexLock l(shared.GetMutex());
+      while (!shared.AllInitialized()) {
+        shared.GetCondVar()->Wait();
+      }
+      // Record start time
+      uint64_t start_time = clock->NowMicros();
+
+      // Start all threads
+      shared.SetStart();
+      shared.GetCondVar()->SignalAll();
+
+      // Wait threads to complete
+      while (!shared.AllDone()) {
+        shared.GetCondVar()->Wait();
+      }
+
+      // Record end time
+      uint64_t end_time = clock->NowMicros();
+      double elapsed = static_cast<double>(end_time - start_time) * 1e-6;
+      uint32_t qps = static_cast<uint32_t>(
+          static_cast<double>(FLAGS_threads * FLAGS_ops_per_thread) / elapsed);
+      fprintf(stdout, "Complete in %.3f s; QPS = %u\n", elapsed, qps);
+    }
+    return true;
+  }
+
+ private:
+  std::shared_ptr<Cache> cache_;
+  const uint64_t max_key_;
+  // Cumulative thresholds in the space of a random uint64_t
+  const uint64_t lookup_insert_threshold_;
+  const uint64_t insert_threshold_;
+  const uint64_t lookup_threshold_;
+  const uint64_t erase_threshold_;
+
+  static void ThreadBody(void* v) {
+    ThreadState* thread = static_cast<ThreadState*>(v);
+    SharedState* shared = thread->shared;
+
+    {
+      MutexLock l(shared->GetMutex());
+      shared->IncInitialized();
+      if (shared->AllInitialized()) {
+        shared->GetCondVar()->SignalAll();
+      }
+      while (!shared->Started()) {
+        shared->GetCondVar()->Wait();
+      }
+    }
+    thread->shared->GetCacheBench()->OperateCache(thread);
+
+    {
+      MutexLock l(shared->GetMutex());
+      shared->IncDone();
+      if (shared->AllDone()) {
+        shared->GetCondVar()->SignalAll();
+      }
+    }
+  }
+
+  void OperateCache(ThreadState* thread) {
+    // To use looked-up values
+    uint64_t result = 0;
+    // To hold handles for a non-trivial amount of time
+    Cache::Handle* handle = nullptr;
+    KeyGen gen;
+    for (uint64_t i = 0; i < FLAGS_ops_per_thread; i++) {
+      Slice key = gen.GetRand(thread->rnd, max_key_);
+      uint64_t random_op = thread->rnd.Next();
+      if (random_op < lookup_insert_threshold_) {
+        if (handle) {
+          cache_->Release(handle);
+          handle = nullptr;
+        }
+        // do lookup
+        handle = cache_->Lookup(key);
+        if (handle) {
+          // do something with the data
+          result += NPHash64(static_cast<char*>(cache_->Value(handle)),
+                             FLAGS_value_bytes);
+        } else {
+          // do insert
+          cache_->Insert(key, createValue(thread->rnd), FLAGS_value_bytes,
+                         &deleter, &handle);
+        }
+      } else if (random_op < insert_threshold_) {
+        if (handle) {
+          cache_->Release(handle);
+          handle = nullptr;
+        }
+        // do insert
+        cache_->Insert(key, createValue(thread->rnd), FLAGS_value_bytes,
+                       &deleter, &handle);
+      } else if (random_op < lookup_threshold_) {
+        if (handle) {
+          cache_->Release(handle);
+          handle = nullptr;
+        }
+        // do lookup
+        handle = cache_->Lookup(key);
+        if (handle) {
+          // do something with the data
+          result += NPHash64(static_cast<char*>(cache_->Value(handle)),
+                             FLAGS_value_bytes);
+        }
+      } else if (random_op < erase_threshold_) {
+        // do erase
+        cache_->Erase(key);
+      } else {
+        // Should be extremely unlikely (noop)
+        assert(random_op >= kHundredthUint64 * 100U);
+      }
+    }
+    if (handle) {
+      cache_->Release(handle);
+      handle = nullptr;
+    }
+  }
+
+  void PrintEnv() const {
+    printf("RocksDB version     : %d.%d\n", kMajorVersion, kMinorVersion);
+    printf("Number of threads   : %u\n", FLAGS_threads);
+    printf("Ops per thread      : %" PRIu64 "\n", FLAGS_ops_per_thread);
+    printf("Cache size          : %" PRIu64 "\n", FLAGS_cache_size);
+    printf("Num shard bits      : %u\n", FLAGS_num_shard_bits);
+    printf("Max key             : %" PRIu64 "\n", max_key_);
+    printf("Resident ratio      : %g\n", FLAGS_resident_ratio);
+    printf("Skew degree         : %u\n", FLAGS_skew);
+    printf("Populate cache      : %d\n", int{FLAGS_populate_cache});
+    printf("Lookup+Insert pct   : %u%%\n", FLAGS_lookup_insert_percent);
+    printf("Insert percentage   : %u%%\n", FLAGS_insert_percent);
+    printf("Lookup percentage   : %u%%\n", FLAGS_lookup_percent);
+    printf("Erase percentage    : %u%%\n", FLAGS_erase_percent);
+    printf("----------------------------\n");
+  }
+};
+}  // namespace ROCKSDB_NAMESPACE
+
+int main(int argc, char** argv) {
+  ParseCommandLineFlags(&argc, &argv, true);
+
+  if (FLAGS_threads <= 0) {
+    fprintf(stderr, "threads number <= 0\n");
+    exit(1);
+  }
+
+  ROCKSDB_NAMESPACE::CacheBench bench;
+  if (FLAGS_populate_cache) {
+    bench.PopulateCache();
+    printf("Population complete\n");
+    printf("----------------------------\n");
+  }
+  if (bench.Run()) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
 #endif  // GFLAGS
@@ -1,504 +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).
-
-#ifdef GFLAGS
-#include "rocksdb/cache_bench_tool.h"
-
-#include <sys/types.h>
-
-#include <cinttypes>
-#include <cstdio>
-#include <limits>
-
-#include "options/configurable_helper.h"
-#include "port/port.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/db.h"
-#include "rocksdb/env.h"
-#include "rocksdb/system_clock.h"
-#include "rocksdb/tiered_cache.h"
-#include "rocksdb/utilities/object_registry.h"
-#include "rocksdb/utilities/options_type.h"
-#include "util/coding.h"
-#include "util/gflags_compat.h"
-#include "util/hash.h"
-#include "util/mutexlock.h"
-#include "util/random.h"
-#include "util/stop_watch.h"
-
-using GFLAGS_NAMESPACE::ParseCommandLineFlags;
-
-static constexpr uint32_t KiB = uint32_t{1} << 10;
-static constexpr uint32_t MiB = KiB << 10;
-static constexpr uint64_t GiB = MiB << 10;
-
-DEFINE_uint32(threads, 16, "Number of concurrent threads to run.");
-DEFINE_uint64(cache_size, 1 * GiB,
-              "Number of bytes to use as a cache of uncompressed data.");
-DEFINE_uint32(num_shard_bits, 6, "shard_bits.");
-
-DEFINE_double(resident_ratio, 0.25,
-              "Ratio of keys fitting in cache to keyspace.");
-DEFINE_uint64(ops_per_thread, 0,
-              "Number of operations per thread. (Default: 5 * keyspace size)");
-DEFINE_uint32(value_bytes, 8 * KiB, "Size of each value added.");
-
-DEFINE_uint32(skew, 5, "Degree of skew in key selection");
-DEFINE_bool(populate_cache, true, "Populate cache before operations");
-
-DEFINE_uint32(lookup_insert_percent, 87,
-              "Ratio of lookup (+ insert on not found) to total workload "
-              "(expressed as a percentage)");
-DEFINE_uint32(insert_percent, 2,
-              "Ratio of insert to total workload (expressed as a percentage)");
-DEFINE_uint32(lookup_percent, 10,
-              "Ratio of lookup to total workload (expressed as a percentage)");
-DEFINE_uint32(erase_percent, 1,
-              "Ratio of erase to total workload (expressed as a percentage)");
-
-DEFINE_bool(use_clock_cache, false, "");
-
-DEFINE_bool(skewed, false, "If true, skew the key access distribution");
-#ifndef ROCKSDB_LITE
-DEFINE_string(tiered_cache_uri, "",
-              "Full URI for creating a custom NVM cache object");
-static class std::shared_ptr<ROCKSDB_NAMESPACE::TieredCache> tiered_cache;
-#endif
-
-namespace ROCKSDB_NAMESPACE {
-class CacheBench;
-
-namespace {
-// State shared by all concurrent executions of the same benchmark.
-class SharedState {
- public:
-  explicit SharedState(CacheBench* cache_bench)
-      : cv_(&mu_),
-        num_initialized_(0),
-        start_(false),
-        num_done_(0),
-        cache_bench_(cache_bench) {}
-
-  ~SharedState() {}
-
-  port::Mutex* GetMutex() { return &mu_; }
-
-  port::CondVar* GetCondVar() { return &cv_; }
-
-  CacheBench* GetCacheBench() const { return cache_bench_; }
-
-  void IncInitialized() { num_initialized_++; }
-
-  void IncDone() { num_done_++; }
-
-  bool AllInitialized() const { return num_initialized_ >= FLAGS_threads; }
-
-  bool AllDone() const { return num_done_ >= FLAGS_threads; }
-
-  void SetStart() { start_ = true; }
-
-  bool Started() const { return start_; }
-
- private:
-  port::Mutex mu_;
-  port::CondVar cv_;
-
-  uint64_t num_initialized_;
-  bool start_;
-  uint64_t num_done_;
-
-  CacheBench* cache_bench_;
-};
-
-class Stats {
- private:
-  uint64_t hits;
-  uint64_t misses;
-  uint64_t lookup_us;
-  uint64_t insert_us;
-
- public:
-  Stats() : hits(0), misses(0), lookup_us(0), insert_us(0) {}
-
-  void AddHits(uint64_t inc) { hits += inc; }
-  void AddMisses(uint64_t inc) { misses += inc; }
-  void AddLookupUs(uint64_t lookup) { lookup_us += lookup; }
-  void AddInsertUs(uint64_t insert) { insert_us += insert; }
-  void Merge(const Stats& other) {
-    hits += other.hits;
-    misses += other.misses;
-    lookup_us += other.lookup_us;
-    insert_us += other.insert_us;
-  }
-  void Report() {
-    fprintf(stdout, "%llu hits, %llu misses, %llu lookup_us, %llu insert_us\n",
-            (unsigned long long)hits, (unsigned long long)misses,
-            (unsigned long long)lookup_us, (unsigned long long)insert_us);
-    fflush(stdout);
-  }
-};
-
-// Per-thread state for concurrent executions of the same benchmark.
-struct ThreadState {
-  uint32_t tid;
-  Random64 rnd;
-  Stats stats;
-  SharedState* shared;
-
-  ThreadState(uint32_t index, SharedState* _shared)
-      : tid(index), rnd(1000 + index), shared(_shared) {}
-};
-
-struct KeyGen {
-  char key_data[27];
-
-  Slice GetRand(Random64& rnd, uint64_t max_key, int max_log) {
-    uint64_t key = 0;
-    if (!FLAGS_skewed) {
-      uint64_t raw = rnd.Next();
-      // Skew according to setting
-      for (uint32_t i = 0; i < FLAGS_skew; ++i) {
-        raw = std::min(raw, rnd.Next());
-      }
-      key = FastRange64(raw, max_key);
-    } else {
-      key = rnd.Skewed(max_log);
-      if (key > max_key) {
-        key -= max_key;
-      }
-    }
-    // Variable size and alignment
-    size_t off = key % 8;
-    key_data[0] = char{42};
-    EncodeFixed64(key_data + 1, key);
-    key_data[9] = char{11};
-    EncodeFixed64(key_data + 10, key);
-    key_data[18] = char{4};
-    EncodeFixed64(key_data + 19, key);
-    return Slice(&key_data[off], sizeof(key_data) - off);
-  }
-};
-
-char* createValue(Random64& rnd) {
-  char* rv = new char[FLAGS_value_bytes];
-  // Fill with some filler data, and take some CPU time
-  for (uint32_t i = 0; i < FLAGS_value_bytes; i += 8) {
-    EncodeFixed64(rv + i, rnd.Next());
-  }
-  return rv;
-}
-
-void helperCallback(Cache::SizeCallback* size_cb,
-                    Cache::SaveToCallback* save_cb,
-                    Cache::DeletionCallback* del_cb) {
-  if (size_cb) {
-    *size_cb = [](void* /*obj*/) -> size_t { return FLAGS_value_bytes; };
-  }
-  if (save_cb) {
-    *save_cb = [](void* obj, size_t /*offset*/, size_t size,
-                  void* out) -> Status {
-      memcpy(out, obj, size);
-      return Status::OK();
-    };
-  }
-  if (del_cb) {
-    *del_cb = [](const Slice& /*key*/, void* obj) -> void {
-      delete[] static_cast<char*>(obj);
-    };
-  }
-}
-}  // namespace
-
-class CacheBench {
-  static constexpr uint64_t kHundredthUint64 =
-      std::numeric_limits<uint64_t>::max() / 100U;
-
- public:
-  CacheBench()
-      : max_key_(static_cast<uint64_t>(FLAGS_cache_size / FLAGS_resident_ratio /
-                                       FLAGS_value_bytes)),
-        lookup_insert_threshold_(kHundredthUint64 *
-                                 FLAGS_lookup_insert_percent),
-        insert_threshold_(lookup_insert_threshold_ +
-                          kHundredthUint64 * FLAGS_insert_percent),
-        lookup_threshold_(insert_threshold_ +
-                          kHundredthUint64 * FLAGS_lookup_percent),
-        erase_threshold_(lookup_threshold_ +
-                         kHundredthUint64 * FLAGS_erase_percent),
-        skewed_(FLAGS_skewed) {
-    if (erase_threshold_ != 100U * kHundredthUint64) {
-      fprintf(stderr, "Percentages must add to 100.\n");
-      exit(1);
-    }
-
-    max_log_ = 0;
-    if (skewed_) {
-      uint64_t max_key = max_key_;
-      while (max_key >>= 1) max_log_++;
-      if (max_key > (1u << max_log_)) max_log_++;
-    }
-
-    if (FLAGS_use_clock_cache) {
-      cache_ = NewClockCache(FLAGS_cache_size, FLAGS_num_shard_bits);
-      if (!cache_) {
-        fprintf(stderr, "Clock cache not supported.\n");
-        exit(1);
-      }
-    } else {
-      LRUCacheOptions opts(FLAGS_cache_size, FLAGS_num_shard_bits, false, 0.5);
-#ifndef ROCKSDB_LITE
-      if (!FLAGS_tiered_cache_uri.empty()) {
-        Status s = ObjectRegistry::NewInstance()->NewSharedObject<TieredCache>(
-            FLAGS_tiered_cache_uri, &tiered_cache);
-        if (tiered_cache == nullptr) {
-          fprintf(stderr,
-                  "No tiered cache registered matching string: %s status=%s\n",
-                  FLAGS_tiered_cache_uri.c_str(), s.ToString().c_str());
-          exit(1);
-        }
-        opts.tiered_cache = tiered_cache;
-      }
-#endif
-
-      cache_ = NewLRUCache(opts);
-    }
-    if (FLAGS_ops_per_thread == 0) {
-      FLAGS_ops_per_thread = 5 * max_key_;
-    }
-  }
-
-  ~CacheBench() {}
-
-  void PopulateCache() {
-    Random64 rnd(1);
-    KeyGen keygen;
-    for (uint64_t i = 0; i < 10 * FLAGS_cache_size; i += FLAGS_value_bytes) {
-      cache_->Insert(keygen.GetRand(rnd, max_key_, max_log_), createValue(rnd),
-                     helperCallback, FLAGS_value_bytes);
-    }
-  }
-
-  bool Run() {
-    ROCKSDB_NAMESPACE::Env* env = ROCKSDB_NAMESPACE::Env::Default();
-    const auto& clock = env->GetSystemClock();
-
-    PrintEnv();
-    SharedState shared(this);
-    std::vector<std::unique_ptr<ThreadState> > threads(FLAGS_threads);
-    for (uint32_t i = 0; i < FLAGS_threads; i++) {
-      threads[i].reset(new ThreadState(i, &shared));
-      env->StartThread(ThreadBody, threads[i].get());
-    }
-    {
-      MutexLock l(shared.GetMutex());
-      while (!shared.AllInitialized()) {
-        shared.GetCondVar()->Wait();
-      }
-      // Record start time
-      uint64_t start_time = clock->NowMicros();
-
-      // Start all threads
-      shared.SetStart();
-      shared.GetCondVar()->SignalAll();
-
-      // Wait threads to complete
-      while (!shared.AllDone()) {
-        shared.GetCondVar()->Wait();
-      }
-
-      // Record end time
-      uint64_t end_time = clock->NowMicros();
-      double elapsed = static_cast<double>(end_time - start_time) * 1e-6;
-      uint32_t qps = static_cast<uint32_t>(
-          static_cast<double>(FLAGS_threads * FLAGS_ops_per_thread) / elapsed);
-      fprintf(stdout, "Complete in %.3f s; QPS = %u\n", elapsed, qps);
-
-      Stats merge_stats;
-      for (uint32_t i = 0; i < FLAGS_threads; ++i) {
-        merge_stats.Merge(threads[i]->stats);
-      }
-      merge_stats.Report();
-    }
-    return true;
-  }
-
- private:
-  std::shared_ptr<Cache> cache_;
-  const uint64_t max_key_;
-  // Cumulative thresholds in the space of a random uint64_t
-  const uint64_t lookup_insert_threshold_;
-  const uint64_t insert_threshold_;
-  const uint64_t lookup_threshold_;
-  const uint64_t erase_threshold_;
-  const bool skewed_;
-  int max_log_;
-
-  static void ThreadBody(void* v) {
-    ThreadState* thread = static_cast<ThreadState*>(v);
-    SharedState* shared = thread->shared;
-
-    {
-      MutexLock l(shared->GetMutex());
-      shared->IncInitialized();
-      if (shared->AllInitialized()) {
-        shared->GetCondVar()->SignalAll();
-      }
-      while (!shared->Started()) {
-        shared->GetCondVar()->Wait();
-      }
-    }
-    thread->shared->GetCacheBench()->OperateCache(thread);
-
-    {
-      MutexLock l(shared->GetMutex());
-      shared->IncDone();
-      if (shared->AllDone()) {
-        shared->GetCondVar()->SignalAll();
-      }
-    }
-  }
-
-  void OperateCache(ThreadState* thread) {
-    // To use looked-up values
-    uint64_t result = 0;
-    // To hold handles for a non-trivial amount of time
-    Cache::Handle* handle = nullptr;
-    KeyGen gen;
-    ROCKSDB_NAMESPACE::Env* env = ROCKSDB_NAMESPACE::Env::Default();
-    SystemClock* clock = env->GetSystemClock().get();
-    for (uint64_t i = 0; i < FLAGS_ops_per_thread; i++) {
-      Slice key = gen.GetRand(thread->rnd, max_key_, max_log_);
-      uint64_t random_op = thread->rnd.Next();
-      Cache::CreateCallback create_cb =
-          [](void* buf, size_t size, void** out_obj, size_t* charge) -> Status {
-        *out_obj = reinterpret_cast<void*>(new char[size]);
-        memcpy(*out_obj, buf, size);
-        *charge = size;
-        return Status::OK();
-      };
-
-      if (random_op < lookup_insert_threshold_) {
-        if (handle) {
-          cache_->Release(handle);
-          handle = nullptr;
-        }
-        // do lookup
-        {
-          uint64_t elapsed = 0;
-          {
-            StopWatch sw(clock, nullptr, 0, &elapsed);
-            handle = cache_->Lookup(key, helperCallback, create_cb,
-                                    Cache::Priority::LOW, true);
-          }
-          thread->stats.AddLookupUs(elapsed);
-        }
-        if (handle) {
-          thread->stats.AddHits(1);
-          // do something with the data
-          result += NPHash64(static_cast<char*>(cache_->Value(handle)),
-                             FLAGS_value_bytes);
-        } else {
-          thread->stats.AddMisses(1);
-          // do insert
-          {
-            uint64_t elapsed = 0;
-            {
-              StopWatch sw(clock, nullptr, 0, &elapsed);
-              cache_->Insert(key, createValue(thread->rnd), helperCallback,
-                             FLAGS_value_bytes, &handle);
-            }
-            thread->stats.AddInsertUs(elapsed);
-          }
-        }
-      } else if (random_op < insert_threshold_) {
-        if (handle) {
-          cache_->Release(handle);
-          handle = nullptr;
-        }
-        // do insert
-        {
-          uint64_t elapsed = 0;
-          {
-            StopWatch sw(clock, nullptr, 0, &elapsed);
-            cache_->Insert(key, createValue(thread->rnd), helperCallback,
-                           FLAGS_value_bytes, &handle);
-          }
-          thread->stats.AddInsertUs(elapsed);
-        }
-      } else if (random_op < lookup_threshold_) {
-        if (handle) {
-          cache_->Release(handle);
-          handle = nullptr;
-        }
-        // do lookup
-        {
-          uint64_t elapsed = 0;
-          {
-            StopWatch sw(clock, nullptr, 0, &elapsed);
-            handle = cache_->Lookup(key, helperCallback, create_cb,
-                                    Cache::Priority::LOW, true);
-          }
-          thread->stats.AddLookupUs(elapsed);
-        }
-        if (handle) {
-          thread->stats.AddHits(1);
-          // do something with the data
-          result += NPHash64(static_cast<char*>(cache_->Value(handle)),
-                             FLAGS_value_bytes);
-        }
-      } else if (random_op < erase_threshold_) {
-        // do erase
-        cache_->Erase(key);
-      } else {
-        // Should be extremely unlikely (noop)
-        assert(random_op >= kHundredthUint64 * 100U);
-      }
-    }
-    if (handle) {
-      cache_->Release(handle);
-      handle = nullptr;
-    }
-  }
-
-  void PrintEnv() const {
-    printf("RocksDB version     : %d.%d\n", kMajorVersion, kMinorVersion);
-    printf("Number of threads   : %u\n", FLAGS_threads);
-    printf("Ops per thread      : %" PRIu64 "\n", FLAGS_ops_per_thread);
-    printf("Cache size          : %" PRIu64 "\n", FLAGS_cache_size);
-    printf("Num shard bits      : %u\n", FLAGS_num_shard_bits);
-    printf("Max key             : %" PRIu64 "\n", max_key_);
-    printf("Resident ratio      : %g\n", FLAGS_resident_ratio);
-    printf("Skew degree         : %u\n", FLAGS_skew);
-    printf("Populate cache      : %d\n", int{FLAGS_populate_cache});
-    printf("Lookup+Insert pct   : %u%%\n", FLAGS_lookup_insert_percent);
-    printf("Insert percentage   : %u%%\n", FLAGS_insert_percent);
-    printf("Lookup percentage   : %u%%\n", FLAGS_lookup_percent);
-    printf("Erase percentage    : %u%%\n", FLAGS_erase_percent);
-    printf("----------------------------\n");
-  }
-};
-
-int cache_bench_tool(int argc, char** argv) {
-  ParseCommandLineFlags(&argc, &argv, true);
-
-  if (FLAGS_threads <= 0) {
-    fprintf(stderr, "threads number <= 0\n");
-    exit(1);
-  }
-
-  ROCKSDB_NAMESPACE::CacheBench bench;
-  if (FLAGS_populate_cache) {
-    bench.PopulateCache();
-    printf("Population complete\n");
-    printf("----------------------------\n");
-  }
-  if (bench.Run()) {
-    return 0;
-  } else {
-    return 1;
-  }
-}
-}  // namespace ROCKSDB_NAMESPACE
-#endif
@@ -271,27 +271,7 @@ class ClockCacheShard final : public CacheShard {
  Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
                void (*deleter)(const Slice& key, void* value),
                Cache::Handle** handle, Cache::Priority priority) override;
-  Status Insert(const Slice& key, uint32_t hash, void* value,
-                Cache::CacheItemHelperCallback helper_cb, size_t charge,
-                Cache::Handle** handle, Cache::Priority priority) override {
-    Cache::DeletionCallback delete_cb;
-    (*helper_cb)(nullptr, nullptr, &delete_cb);
-    return Insert(key, hash, value, charge, delete_cb, handle, priority);
-  }
  Cache::Handle* Lookup(const Slice& key, uint32_t hash) override;
-  Cache::Handle* Lookup(const Slice& key, uint32_t hash,
-                        Cache::CacheItemHelperCallback /*helper_cb*/,
-                        const Cache::CreateCallback& /*create_cb*/,
-                        Cache::Priority /*priority*/, bool /*wait*/) override {
-    return Lookup(key, hash);
-  }
-  bool Release(Cache::Handle* handle, bool /*useful*/,
-               bool force_erase) override {
-    return Release(handle, force_erase);
-  }
-  bool isReady(Cache::Handle* /*handle*/) override { return true; }
-  void Wait(Cache::Handle* /*handle*/) override {}
-
  // If the entry in in cache, increase reference count and return true.
  // Return false otherwise.
  //
@@ -768,8 +748,6 @@ class ClockCache final : public ShardedCache {

  void DisownData() override { shards_ = nullptr; }

-  void WaitAll(std::vector<Handle*>& /*handles*/) override {}
-
 private:
  ClockCacheShard* shards_;
 };
@@ -97,8 +97,7 @@ void LRUHandleTable::Resize() {
 LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
                             double high_pri_pool_ratio,
                             bool use_adaptive_mutex,
-                             CacheMetadataChargePolicy metadata_charge_policy,
-                             const std::shared_ptr<TieredCache>& tiered_cache)
+                             CacheMetadataChargePolicy metadata_charge_policy)
    : capacity_(0),
      high_pri_pool_usage_(0),
      strict_capacity_limit_(strict_capacity_limit),
@@ -106,8 +105,7 @@ LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
      high_pri_pool_capacity_(0),
      usage_(0),
      lru_usage_(0),
-      mutex_(use_adaptive_mutex),
-      tiered_cache_(tiered_cache) {
+      mutex_(use_adaptive_mutex) {
  set_metadata_charge_policy(metadata_charge_policy);
  // Make empty circular linked list
  lru_.next = &lru_;
@@ -258,14 +256,8 @@ void LRUCacheShard::SetCapacity(size_t capacity) {
    EvictFromLRU(0, &last_reference_list);
  }

-  // Try to insert the evicted entries into tiered cache
  // Free the entries outside of mutex for performance reasons
  for (auto entry : last_reference_list) {
-    if (tiered_cache_ && entry->IsTieredCacheCompatible() &&
-        !entry->IsPromoted()) {
-      tiered_cache_->Insert(entry->key(), entry->value, entry->info_.helper_cb)
-          .PermitUncheckedError();
-    }
    entry->Free();
  }
 }
@@ -275,126 +267,17 @@ void LRUCacheShard::SetStrictCapacityLimit(bool strict_capacity_limit) {
  strict_capacity_limit_ = strict_capacity_limit;
 }

-Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle) {
-  Status s = Status::OK();
-  autovector<LRUHandle*> last_reference_list;
-  size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);
-
-  {
-    MutexLock l(&mutex_);
-
-    // Free the space following strict LRU policy until enough space
-    // is freed or the lru list is empty
-    EvictFromLRU(total_charge, &last_reference_list);
-
-    if ((usage_ + total_charge) > capacity_ &&
-        (strict_capacity_limit_ || handle == nullptr)) {
-      if (handle == nullptr) {
-        // Don't insert the entry but still return ok, as if the entry inserted
-        // into cache and get evicted immediately.
-        e->SetInCache(false);
-        last_reference_list.push_back(e);
-      } else {
-        delete[] reinterpret_cast<char*>(e);
-        *handle = nullptr;
-        s = Status::Incomplete("Insert failed due to LRU cache being full.");
-      }
-    } else {
-      // Insert into the cache. Note that the cache might get larger than its
-      // capacity if not enough space was freed up.
-      LRUHandle* old = table_.Insert(e);
-      usage_ += total_charge;
-      if (old != nullptr) {
-        s = Status::OkOverwritten();
-        assert(old->InCache());
-        old->SetInCache(false);
-        if (!old->HasRefs()) {
-          // old is on LRU because it's in cache and its reference count is 0
-          LRU_Remove(old);
-          size_t old_total_charge =
-              old->CalcTotalCharge(metadata_charge_policy_);
-          assert(usage_ >= old_total_charge);
-          usage_ -= old_total_charge;
-          last_reference_list.push_back(old);
-        }
-      }
-      if (handle == nullptr) {
-        LRU_Insert(e);
-      } else {
-        e->Ref();
-        *handle = reinterpret_cast<Cache::Handle*>(e);
-      }
-    }
-  }
-
-  // Try to insert the evicted entries into NVM cache
-  // Free the entries here outside of mutex for performance reasons
-  for (auto entry : last_reference_list) {
-    if (tiered_cache_ && entry->IsTieredCacheCompatible() &&
-        !entry->IsPromoted()) {
-      tiered_cache_->Insert(entry->key(), entry->value, entry->info_.helper_cb)
-          .PermitUncheckedError();
-    }
-    entry->Free();
-  }
-
-  return s;
-}
-
-Cache::Handle* LRUCacheShard::Lookup(
-    const Slice& key, uint32_t hash,
-    ShardedCache::CacheItemHelperCallback helper_cb,
-    const ShardedCache::CreateCallback& create_cb, Cache::Priority priority,
-    bool wait) {
-  LRUHandle* e = nullptr;
-  {
-    MutexLock l(&mutex_);
-    e = table_.Lookup(key, hash);
-    if (e != nullptr) {
-      assert(e->InCache());
-      if (!e->HasRefs()) {
-        // The entry is in LRU since it's in hash and has no external references
-        LRU_Remove(e);
-      }
-      e->Ref();
-      e->SetHit();
-    }
-  }
-
-  // If handle table lookup failed, then allocate a handle outside the
-  // mutex if we're going to lookup in the NVM cache
-  // Only support synchronous for now
-  // TODO: Support asynchronous lookup in NVM cache
-  if (!e && tiered_cache_ && helper_cb && wait) {
-    assert(create_cb);
-    std::unique_ptr<TieredCacheHandle> tiered_handle =
-        tiered_cache_->Lookup(key, create_cb, wait);
-    if (tiered_handle != nullptr) {
-      e = reinterpret_cast<LRUHandle*>(
-          new char[sizeof(LRUHandle) - 1 + key.size()]);
-
-      e->flags = 0;
-      e->SetPromoted(true);
-      e->SetTieredCacheCompatible(true);
-      e->info_.helper_cb = helper_cb;
-      e->key_length = key.size();
-      e->hash = hash;
-      e->refs = 0;
-      e->next = e->prev = nullptr;
-      e->SetInCache(true);
-      e->SetPriority(priority);
-      memcpy(e->key_data, key.data(), key.size());
-
-      e->value = tiered_handle->Value();
-      e->charge = tiered_handle->Size();
-
-      // This call could nullify e if the cache is over capacity and
-      // strict_capacity_limit_ is true. In such a case, the caller will try
-      // to insert later, which might again fail, but its ok as this should
-      // not be common
-      InsertItem(e, reinterpret_cast<Cache::Handle**>(&e))
-          .PermitUncheckedError();
+Cache::Handle* LRUCacheShard::Lookup(const Slice& key, uint32_t hash) {
+  MutexLock l(&mutex_);
+  LRUHandle* e = table_.Lookup(key, hash);
+  if (e != nullptr) {
+    assert(e->InCache());
+    if (!e->HasRefs()) {
+      // The entry is in LRU since it's in hash and has no external references
+      LRU_Remove(e);
    }
+    e->Ref();
+    e->SetHit();
  }
  return reinterpret_cast<Cache::Handle*>(e);
 }
@@ -455,32 +338,81 @@ bool LRUCacheShard::Release(Cache::Handle* handle, bool force_erase) {
 Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
                             size_t charge,
                             void (*deleter)(const Slice& key, void* value),
-                             Cache::CacheItemHelperCallback helper_cb,
                             Cache::Handle** handle, Cache::Priority priority) {
  // Allocate the memory here outside of the mutex
  // If the cache is full, we'll have to release it
  // It shouldn't happen very often though.
  LRUHandle* e = reinterpret_cast<LRUHandle*>(
      new char[sizeof(LRUHandle) - 1 + key.size()]);
+  Status s = Status::OK();
+  autovector<LRUHandle*> last_reference_list;

  e->value = value;
-  e->flags = 0;
-  if (helper_cb) {
-    e->SetTieredCacheCompatible(true);
-    e->info_.helper_cb = helper_cb;
-  } else {
-    e->info_.deleter = deleter;
-  }
+  e->deleter = deleter;
  e->charge = charge;
  e->key_length = key.size();
+  e->flags = 0;
  e->hash = hash;
  e->refs = 0;
  e->next = e->prev = nullptr;
  e->SetInCache(true);
  e->SetPriority(priority);
  memcpy(e->key_data, key.data(), key.size());
+  size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);

-  return InsertItem(e, handle);
+  {
+    MutexLock l(&mutex_);
+
+    // Free the space following strict LRU policy until enough space
+    // is freed or the lru list is empty
+    EvictFromLRU(total_charge, &last_reference_list);
+
+    if ((usage_ + total_charge) > capacity_ &&
+        (strict_capacity_limit_ || handle == nullptr)) {
+      if (handle == nullptr) {
+        // Don't insert the entry but still return ok, as if the entry inserted
+        // into cache and get evicted immediately.
+        e->SetInCache(false);
+        last_reference_list.push_back(e);
+      } else {
+        delete[] reinterpret_cast<char*>(e);
+        *handle = nullptr;
+        s = Status::Incomplete("Insert failed due to LRU cache being full.");
+      }
+    } else {
+      // Insert into the cache. Note that the cache might get larger than its
+      // capacity if not enough space was freed up.
+      LRUHandle* old = table_.Insert(e);
+      usage_ += total_charge;
+      if (old != nullptr) {
+        s = Status::OkOverwritten();
+        assert(old->InCache());
+        old->SetInCache(false);
+        if (!old->HasRefs()) {
+          // old is on LRU because it's in cache and its reference count is 0
+          LRU_Remove(old);
+          size_t old_total_charge =
+              old->CalcTotalCharge(metadata_charge_policy_);
+          assert(usage_ >= old_total_charge);
+          usage_ -= old_total_charge;
+          last_reference_list.push_back(old);
+        }
+      }
+      if (handle == nullptr) {
+        LRU_Insert(e);
+      } else {
+        e->Ref();
+        *handle = reinterpret_cast<Cache::Handle*>(e);
+      }
+    }
+  }
+
+  // Free the entries here outside of mutex for performance reasons
+  for (auto entry : last_reference_list) {
+    entry->Free();
+  }
+
+  return s;
 }

 void LRUCacheShard::Erase(const Slice& key, uint32_t hash) {
@@ -536,8 +468,7 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
                   bool strict_capacity_limit, double high_pri_pool_ratio,
                   std::shared_ptr<MemoryAllocator> allocator,
                   bool use_adaptive_mutex,
-                   CacheMetadataChargePolicy metadata_charge_policy,
-                   const std::shared_ptr<TieredCache>& tiered_cache)
+                   CacheMetadataChargePolicy metadata_charge_policy)
    : ShardedCache(capacity, num_shard_bits, strict_capacity_limit,
                   std::move(allocator)) {
  num_shards_ = 1 << num_shard_bits;
@@ -547,7 +478,7 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
  for (int i = 0; i < num_shards_; i++) {
    new (&shards_[i])
        LRUCacheShard(per_shard, strict_capacity_limit, high_pri_pool_ratio,
-                      use_adaptive_mutex, metadata_charge_policy, tiered_cache);
+                      use_adaptive_mutex, metadata_charge_policy);
  }
 }

@@ -612,12 +543,19 @@ double LRUCache::GetHighPriPoolRatio() {
  return result;
 }

+std::shared_ptr<Cache> NewLRUCache(const LRUCacheOptions& cache_opts) {
+  return NewLRUCache(cache_opts.capacity, cache_opts.num_shard_bits,
+                     cache_opts.strict_capacity_limit,
+                     cache_opts.high_pri_pool_ratio,
+                     cache_opts.memory_allocator, cache_opts.use_adaptive_mutex,
+                     cache_opts.metadata_charge_policy);
+}
+
 std::shared_ptr<Cache> NewLRUCache(
    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
    double high_pri_pool_ratio,
    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    const std::shared_ptr<TieredCache>& tiered_cache) {
+    CacheMetadataChargePolicy metadata_charge_policy) {
  if (num_shard_bits >= 20) {
    return nullptr;  // the cache cannot be sharded into too many fine pieces
  }
@@ -630,25 +568,7 @@ std::shared_ptr<Cache> NewLRUCache(
  }
  return std::make_shared<LRUCache>(
      capacity, num_shard_bits, strict_capacity_limit, high_pri_pool_ratio,
-      std::move(memory_allocator), use_adaptive_mutex, metadata_charge_policy,
-      tiered_cache);
+      std::move(memory_allocator), use_adaptive_mutex, metadata_charge_policy);
 }

-std::shared_ptr<Cache> NewLRUCache(const LRUCacheOptions& cache_opts) {
-  return NewLRUCache(
-      cache_opts.capacity, cache_opts.num_shard_bits,
-      cache_opts.strict_capacity_limit, cache_opts.high_pri_pool_ratio,
-      cache_opts.memory_allocator, cache_opts.use_adaptive_mutex,
-      cache_opts.metadata_charge_policy, cache_opts.tiered_cache);
-}
-
-std::shared_ptr<Cache> NewLRUCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy) {
-  return NewLRUCache(capacity, num_shard_bits, strict_capacity_limit,
-                     high_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-                     metadata_charge_policy, nullptr);
-}
 }  // namespace ROCKSDB_NAMESPACE
@@ -11,9 +11,9 @@
 #include <string>

 #include "cache/sharded_cache.h"
+
 #include "port/malloc.h"
 #include "port/port.h"
-#include "rocksdb/tiered_cache.h"
 #include "util/autovector.h"

 namespace ROCKSDB_NAMESPACE {
@@ -49,14 +49,7 @@ namespace ROCKSDB_NAMESPACE {

 struct LRUHandle {
  void* value;
-  union Info {
-    Info() {}
-    ~Info() {}
-    void (*deleter)(const Slice&, void* value);
-    ShardedCache::CacheItemHelperCallback helper_cb;
-    // This needs to be explicitly constructed and destructed
-    std::unique_ptr<TieredCacheHandle> tiered_handle;
-  } info_;
+  void (*deleter)(const Slice&, void* value);
  LRUHandle* next_hash;
  LRUHandle* next;
  LRUHandle* prev;
@@ -76,12 +69,6 @@ struct LRUHandle {
    IN_HIGH_PRI_POOL = (1 << 2),
    // Whether this entry has had any lookups (hits).
    HAS_HIT = (1 << 3),
-    // Can this be inserted into the tiered cache
-    IS_TIERED_CACHE_COMPATIBLE = (1 << 4),
-    // Is the handle still being read from a lower tier
-    IS_PENDING = (1 << 5),
-    // Has the item been promoted from a lower tier
-    IS_PROMOTED = (1 << 6),
  };

  uint8_t flags;
@@ -108,11 +95,6 @@ struct LRUHandle {
  bool IsHighPri() const { return flags & IS_HIGH_PRI; }
  bool InHighPriPool() const { return flags & IN_HIGH_PRI_POOL; }
  bool HasHit() const { return flags & HAS_HIT; }
-  bool IsTieredCacheCompatible() const {
-    return flags & IS_TIERED_CACHE_COMPATIBLE;
-  }
-  bool IsPending() const { return flags & IS_PENDING; }
-  bool IsPromoted() const { return flags & IS_PROMOTED; }

  void SetInCache(bool in_cache) {
    if (in_cache) {
@@ -140,38 +122,10 @@ struct LRUHandle {

  void SetHit() { flags |= HAS_HIT; }

-  void SetTieredCacheCompatible(bool tiered) {
-    if (tiered) {
-      flags |= IS_TIERED_CACHE_COMPATIBLE;
-    } else {
-      flags &= ~IS_TIERED_CACHE_COMPATIBLE;
-    }
-  }
-
-  void SetIncomplete(bool incomp) {
-    if (incomp) {
-      flags |= IS_PENDING;
-    } else {
-      flags &= ~IS_PENDING;
-    }
-  }
-
-  void SetPromoted(bool promoted) {
-    if (promoted) {
-      flags |= IS_PROMOTED;
-    } else {
-      flags &= ~IS_PROMOTED;
-    }
-  }
-
  void Free() {
    assert(refs == 0);
-    if (!IsTieredCacheCompatible() && info_.deleter) {
-      (*info_.deleter)(key(), value);
-    } else if (IsTieredCacheCompatible()) {
-      ShardedCache::DeletionCallback del_cb;
-      (*info_.helper_cb)(nullptr, nullptr, &del_cb);
-      (*del_cb)(key(), value);
+    if (deleter) {
+      (*deleter)(key(), value);
    }
    delete[] reinterpret_cast<char*>(this);
  }
@@ -239,8 +193,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
 public:
  LRUCacheShard(size_t capacity, bool strict_capacity_limit,
                double high_pri_pool_ratio, bool use_adaptive_mutex,
-                CacheMetadataChargePolicy metadata_charge_policy,
-                const std::shared_ptr<TieredCache>& tiered_cache);
+                CacheMetadataChargePolicy metadata_charge_policy);
  virtual ~LRUCacheShard() override = default;

  // Separate from constructor so caller can easily make an array of LRUCache
@@ -259,32 +212,8 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
                        size_t charge,
                        void (*deleter)(const Slice& key, void* value),
                        Cache::Handle** handle,
-                        Cache::Priority priority) override {
-    return Insert(key, hash, value, charge, deleter, nullptr, handle, priority);
-  }
-  virtual Status Insert(const Slice& key, uint32_t hash, void* value,
-                        Cache::CacheItemHelperCallback helper_cb, size_t charge,
-                        Cache::Handle** handle,
-                        Cache::Priority priority) override {
-    return Insert(key, hash, value, charge, nullptr, helper_cb, handle,
-                  priority);
-  }
-  // If helper_cb is null, the values of the following arguments don't
-  // matter
-  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash,
-                                ShardedCache::CacheItemHelperCallback helper_cb,
-                                const ShardedCache::CreateCallback& create_cb,
-                                ShardedCache::Priority priority,
-                                bool wait) override;
-  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash) override {
-    return Lookup(key, hash, nullptr, nullptr, Cache::Priority::LOW, true);
-  }
-  virtual bool Release(Cache::Handle* handle, bool /*useful*/,
-                       bool force_erase) override {
-    return Release(handle, force_erase);
-  }
-  virtual bool isReady(Cache::Handle* /*handle*/) override { return true; }
-  virtual void Wait(Cache::Handle* /*handle*/) override {}
+                        Cache::Priority priority) override;
+  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash) override;
  virtual bool Ref(Cache::Handle* handle) override;
  virtual bool Release(Cache::Handle* handle,
                       bool force_erase = false) override;
@@ -310,15 +239,10 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  //  not threadsafe
  size_t TEST_GetLRUSize();

-  //  Retrieves high pri pool ratio
+  //  Retrives high pri pool ratio
  double GetHighPriPoolRatio();

 private:
-  Status InsertItem(LRUHandle* item, Cache::Handle** handle);
-  Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
-                void (*deleter)(const Slice& key, void* value),
-                Cache::CacheItemHelperCallback helper_cb,
-                Cache::Handle** handle, Cache::Priority priority);
  void LRU_Remove(LRUHandle* e);
  void LRU_Insert(LRUHandle* e);

@@ -379,8 +303,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  // We don't count mutex_ as the cache's internal state so semantically we
  // don't mind mutex_ invoking the non-const actions.
  mutable port::Mutex mutex_;
-
-  std::shared_ptr<TieredCache> tiered_cache_;
 };

 class LRUCache
@@ -394,8 +316,7 @@ class LRUCache
           std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
           bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
           CacheMetadataChargePolicy metadata_charge_policy =
-               kDontChargeCacheMetadata,
-           const std::shared_ptr<TieredCache>& tiered_cache = nullptr);
+               kDontChargeCacheMetadata);
  virtual ~LRUCache();
  virtual const char* Name() const override { return "LRUCache"; }
  virtual CacheShard* GetShard(int shard) override;
@@ -404,11 +325,10 @@ class LRUCache
  virtual size_t GetCharge(Handle* handle) const override;
  virtual uint32_t GetHash(Handle* handle) const override;
  virtual void DisownData() override;
-  virtual void WaitAll(std::vector<Handle*>& /*handles*/) override {}

  //  Retrieves number of elements in LRU, for unit test purpose only
  size_t TEST_GetLRUSize();
-  //  Retrieves high pri pool ratio
+  //  Retrives high pri pool ratio
  double GetHighPriPoolRatio();

 private:
@@ -7,12 +7,8 @@

 #include <string>
 #include <vector>
-
 #include "port/port.h"
-#include "rocksdb/cache.h"
 #include "test_util/testharness.h"
-#include "util/coding.h"
-#include "util/random.h"

 namespace ROCKSDB_NAMESPACE {

@@ -34,9 +30,9 @@ class LRUCacheTest : public testing::Test {
    DeleteCache();
    cache_ = reinterpret_cast<LRUCacheShard*>(
        port::cacheline_aligned_alloc(sizeof(LRUCacheShard)));
-    new (cache_) LRUCacheShard(
-        capacity, false /*strict_capcity_limit*/, high_pri_pool_ratio,
-        use_adaptive_mutex, kDontChargeCacheMetadata, nullptr /*tiered_cache*/);
+    new (cache_) LRUCacheShard(capacity, false /*strict_capcity_limit*/,
+                               high_pri_pool_ratio, use_adaptive_mutex,
+                               kDontChargeCacheMetadata);
  }

  void Insert(const std::string& key,
@@ -195,175 +191,6 @@ TEST_F(LRUCacheTest, EntriesWithPriority) {
  ValidateLRUList({"e", "f", "g", "Z", "d"}, 2);
 }

-class TestTieredCache : public TieredCache {
- public:
-  TestTieredCache(size_t capacity) : num_inserts_(0), num_lookups_(0) {
-    cache_ = NewLRUCache(capacity, 0, false, 0.5, nullptr,
-                         kDefaultToAdaptiveMutex, kDontChargeCacheMetadata);
-  }
-  ~TestTieredCache() { cache_.reset(); }
-
-  std::string Name() override { return "TestTieredCache"; }
-
-  Status Insert(const Slice& key, void* value,
-                Cache::CacheItemHelperCallback helper_cb) override {
-    Cache::SizeCallback size_cb;
-    Cache::SaveToCallback save_cb;
-    size_t size;
-    char* buf;
-    Status s;
-
-    num_inserts_++;
-    (*helper_cb)(&size_cb, &save_cb, nullptr);
-    size = (*size_cb)(value);
-    buf = new char[size + sizeof(uint64_t)];
-    EncodeFixed64(buf, size);
-    s = (*save_cb)(value, 0, size, buf + sizeof(uint64_t));
-    EXPECT_OK(s);
-    return cache_->Insert(key, buf, size,
-                          [](const Slice& /*key*/, void* val) -> void {
-                            delete[] reinterpret_cast<char*>(val);
-                          });
-  }
-
-  std::unique_ptr<TieredCacheHandle> Lookup(
-      const Slice& key, const Cache::CreateCallback& create_cb,
-      bool /*wait*/) override {
-    std::unique_ptr<TieredCacheHandle> tiered_handle;
-    Cache::Handle* handle = cache_->Lookup(key);
-    num_lookups_++;
-    if (handle) {
-      void* value;
-      size_t charge;
-      char* ptr = (char*)cache_->Value(handle);
-      size_t size = DecodeFixed64(ptr);
-      ptr += sizeof(uint64_t);
-      Status s = create_cb(ptr, size, &value, &charge);
-      EXPECT_OK(s);
-      tiered_handle.reset(
-          new TestTieredCacheHandle(cache_.get(), handle, value, charge));
-    }
-    return tiered_handle;
-  }
-
-  void Erase(const Slice& /*key*/) override {}
-
-  void WaitAll(std::vector<TieredCacheHandle*> /*handles*/) override {}
-
-  std::string GetPrintableOptions() const override { return ""; }
-
-  uint32_t num_inserts() { return num_inserts_; }
-
-  uint32_t num_lookups() { return num_lookups_; }
-
- private:
-  class TestTieredCacheHandle : public TieredCacheHandle {
-   public:
-    TestTieredCacheHandle(Cache* cache, Cache::Handle* handle, void* value,
-                          size_t size)
-        : cache_(cache), handle_(handle), value_(value), size_(size) {}
-    ~TestTieredCacheHandle() { cache_->Release(handle_); }
-
-    bool isReady() override { return true; }
-
-    void Wait() override {}
-
-    void* Value() override { return value_; }
-
-    size_t Size() override { return size_; }
-
-   private:
-    Cache* cache_;
-    Cache::Handle* handle_;
-    void* value_;
-    size_t size_;
-  };
-
-  std::shared_ptr<Cache> cache_;
-  uint32_t num_inserts_;
-  uint32_t num_lookups_;
-};
-
-TEST_F(LRUCacheTest, TestTieredCache) {
-  LRUCacheOptions opts(1024, 0, false, 0.5, nullptr, kDefaultToAdaptiveMutex,
-                       kDontChargeCacheMetadata);
-  std::shared_ptr<TestTieredCache> tiered_cache(new TestTieredCache(2048));
-  opts.tiered_cache = tiered_cache;
-  std::shared_ptr<Cache> cache = NewLRUCache(opts);
-
-  class TestItem {
-   public:
-    TestItem(const char* buf, size_t size) : buf_(new char[size]), size_(size) {
-      memcpy(buf_.get(), buf, size);
-    }
-    ~TestItem() {}
-
-    char* Buf() { return buf_.get(); }
-    size_t Size() { return size_; }
-
-   private:
-    std::unique_ptr<char[]> buf_;
-    size_t size_;
-  };
-
-  Cache::CacheItemHelperCallback helper_cb =
-      [](Cache::SizeCallback* size_cb, Cache::SaveToCallback* saveto_cb,
-         Cache::DeletionCallback* del_cb) -> void {
-    if (size_cb) {
-      *size_cb = [](void* obj) -> size_t {
-        return reinterpret_cast<TestItem*>(obj)->Size();
-      };
-    }
-    if (saveto_cb) {
-      *saveto_cb = [](void* obj, size_t offset, size_t size,
-                      void* out) -> Status {
-        TestItem* item = reinterpret_cast<TestItem*>(obj);
-        char* buf = item->Buf();
-        EXPECT_EQ(size, item->Size());
-        EXPECT_EQ(offset, 0);
-        memcpy(out, buf, size);
-        return Status::OK();
-      };
-    }
-    if (del_cb) {
-      *del_cb = [](const Slice& /*key*/, void* obj) -> void {
-        delete reinterpret_cast<TestItem*>(obj);
-      };
-    }
-  };
-
-  int create_count = 0;
-  Cache::CreateCallback test_item_creator =
-      [&create_count](void* buf, size_t size, void** out_obj,
-                      size_t* charge) -> Status {
-    create_count++;
-    *out_obj = reinterpret_cast<void*>(new TestItem((char*)buf, size));
-    *charge = size;
-    return Status::OK();
-  };
-
-  Random rnd(301);
-  std::string str1 = rnd.RandomString(1020);
-  TestItem* item1 = new TestItem(str1.data(), str1.length());
-  ASSERT_OK(cache->Insert("k1", item1, helper_cb, str1.length()));
-  std::string str2 = rnd.RandomString(1020);
-  TestItem* item2 = new TestItem(str2.data(), str2.length());
-  // k2 should be demoted to NVM
-  ASSERT_OK(cache->Insert("k2", item2, helper_cb, str2.length()));
-
-  Cache::Handle* handle;
-  handle = cache->Lookup("k2", helper_cb, test_item_creator,
-                         Cache::Priority::LOW, true);
-  ASSERT_NE(handle, nullptr);
-  cache->Release(handle);
-  // This lookup should promote k1 and demote k2
-  handle = cache->Lookup("k1", helper_cb, test_item_creator,
-                         Cache::Priority::LOW, true);
-  ASSERT_NE(handle, nullptr);
-  cache->Release(handle);
-  ASSERT_EQ(tiered_cache->num_inserts(), 2u);
-  ASSERT_EQ(tiered_cache->num_lookups(), 1u);
-}
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -51,39 +51,11 @@ Status ShardedCache::Insert(const Slice& key, void* value, size_t charge,
      ->Insert(key, hash, value, charge, deleter, handle, priority);
 }

-Status ShardedCache::Insert(const Slice& key, void* value,
-                            CacheItemHelperCallback helper_cb, size_t charge,
-                            Handle** handle, Priority priority) {
-  uint32_t hash = HashSlice(key);
-  return GetShard(Shard(hash))
-      ->Insert(key, hash, value, helper_cb, charge, handle, priority);
-}
-
 Cache::Handle* ShardedCache::Lookup(const Slice& key, Statistics* /*stats*/) {
  uint32_t hash = HashSlice(key);
  return GetShard(Shard(hash))->Lookup(key, hash);
 }

-Cache::Handle* ShardedCache::Lookup(const Slice& key,
-                                    CacheItemHelperCallback helper_cb,
-                                    const CreateCallback& create_cb,
-                                    Priority priority, bool wait,
-                                    Statistics* /*stats*/) {
-  uint32_t hash = HashSlice(key);
-  return GetShard(Shard(hash))
-      ->Lookup(key, hash, helper_cb, create_cb, priority, wait);
-}
-
-bool ShardedCache::isReady(Handle* handle) {
-  uint32_t hash = GetHash(handle);
-  return GetShard(Shard(hash))->isReady(handle);
-}
-
-void ShardedCache::Wait(Handle* handle) {
-  uint32_t hash = GetHash(handle);
-  GetShard(Shard(hash))->Wait(handle);
-}
-
 bool ShardedCache::Ref(Handle* handle) {
  uint32_t hash = GetHash(handle);
  return GetShard(Shard(hash))->Ref(handle);
@@ -94,11 +66,6 @@ bool ShardedCache::Release(Handle* handle, bool force_erase) {
  return GetShard(Shard(hash))->Release(handle, force_erase);
 }

-bool ShardedCache::Release(Handle* handle, bool useful, bool force_erase) {
-  uint32_t hash = GetHash(handle);
-  return GetShard(Shard(hash))->Release(handle, useful, force_erase);
-}
-
 void ShardedCache::Erase(const Slice& key) {
  uint32_t hash = HashSlice(key);
  GetShard(Shard(hash))->Erase(key, hash);
@@ -28,20 +28,9 @@ class CacheShard {
                        size_t charge,
                        void (*deleter)(const Slice& key, void* value),
                        Cache::Handle** handle, Cache::Priority priority) = 0;
-  virtual Status Insert(const Slice& key, uint32_t hash, void* value,
-                        Cache::CacheItemHelperCallback helper_cb, size_t charge,
-                        Cache::Handle** handle, Cache::Priority priority) = 0;
  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash) = 0;
-  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash,
-                                Cache::CacheItemHelperCallback helper_cb,
-                                const Cache::CreateCallback& create_cb,
-                                Cache::Priority priority, bool wait) = 0;
-  virtual bool Release(Cache::Handle* handle, bool useful,
-                       bool force_erase) = 0;
-  virtual bool isReady(Cache::Handle* handle) = 0;
-  virtual void Wait(Cache::Handle* handle) = 0;
  virtual bool Ref(Cache::Handle* handle) = 0;
-  virtual bool Release(Cache::Handle* handle, bool force_erase) = 0;
+  virtual bool Release(Cache::Handle* handle, bool force_erase = false) = 0;
  virtual void Erase(const Slice& key, uint32_t hash) = 0;
  virtual void SetCapacity(size_t capacity) = 0;
  virtual void SetStrictCapacityLimit(bool strict_capacity_limit) = 0;
@@ -73,7 +62,6 @@ class ShardedCache : public Cache {
  virtual const CacheShard* GetShard(int shard) const = 0;
  virtual void* Value(Handle* handle) override = 0;
  virtual size_t GetCharge(Handle* handle) const override = 0;
-  virtual void WaitAll(std::vector<Handle*>& handles) override = 0;

  virtual uint32_t GetHash(Handle* handle) const = 0;
  virtual void DisownData() override = 0;
@@ -84,18 +72,7 @@ class ShardedCache : public Cache {
  virtual Status Insert(const Slice& key, void* value, size_t charge,
                        void (*deleter)(const Slice& key, void* value),
                        Handle** handle, Priority priority) override;
-  virtual Status Insert(const Slice& key, void* value,
-                        CacheItemHelperCallback helper_cb, size_t chargge,
-                        Handle** handle = nullptr,
-                        Priority priority = Priority::LOW) override;
  virtual Handle* Lookup(const Slice& key, Statistics* stats) override;
-  virtual Handle* Lookup(const Slice& key, CacheItemHelperCallback helper_cb,
-                         const CreateCallback& create_cb, Priority priority,
-                         bool wait, Statistics* stats = nullptr) override;
-  virtual bool Release(Handle* handle, bool useful,
-                       bool force_erase = false) override;
-  virtual bool isReady(Handle* handle) override;
-  virtual void Wait(Handle* handle) override;
  virtual bool Ref(Handle* handle) override;
  virtual bool Release(Handle* handle, bool force_erase = false) override;
  virtual void Erase(const Slice& key) override;
@@ -190,7 +190,7 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
      std::move(file), blob_file_paths_->back(), *file_options_,
      immutable_cf_options_->clock, io_tracer_, statistics,
      immutable_cf_options_->listeners,
-      immutable_cf_options_->file_checksum_gen_factory.get(),
+      immutable_cf_options_->file_checksum_gen_factory,
      tmp_set.Contains(FileType::kBlobFile)));

  constexpr bool do_flush = false;
@@ -306,6 +306,7 @@ Status BlobFileBuilder::CloseBlobFile() {
                 " total blobs, %" PRIu64 " total bytes",
                 column_family_name_.c_str(), job_id_, blob_file_number,
                 blob_count_, blob_bytes_);
+
  if (blob_callback_) {
    s = blob_callback_->OnBlobFileCompleted(blob_file_paths_->back());
  }
@@ -16,14 +16,6 @@ namespace ROCKSDB_NAMESPACE {

 class BlobFileCompletionCallback {
 public:
-#ifdef ROCKSDB_LITE
-  BlobFileCompletionCallback(SstFileManager* /*sst_file_manager*/,
-                             InstrumentedMutex* /*mutex*/,
-                             ErrorHandler* /*error_handler*/) {}
-  Status OnBlobFileCompleted(const std::string& /*file_name*/) {
-    return Status::OK();
-  }
-#else
  BlobFileCompletionCallback(SstFileManager* sst_file_manager,
                             InstrumentedMutex* mutex,
                             ErrorHandler* error_handler)
@@ -33,6 +25,8 @@ class BlobFileCompletionCallback {

  Status OnBlobFileCompleted(const std::string& file_name) {
    Status s;
+
+#ifndef ROCKSDB_LITE
    auto sfm = static_cast<SstFileManagerImpl*>(sst_file_manager_);
    if (sfm) {
      // Report new blob files to SstFileManagerImpl
@@ -45,6 +39,9 @@ class BlobFileCompletionCallback {
        error_handler_->SetBGError(s, BackgroundErrorReason::kFlush);
      }
    }
+#else
+    (void)file_name;
+#endif  // ROCKSDB_LITE
    return s;
  }

@@ -52,6 +49,5 @@ class BlobFileCompletionCallback {
  SstFileManager* sst_file_manager_;
  InstrumentedMutex* mutex_;
  ErrorHandler* error_handler_;
-#endif  // ROCKSDB_LITE
 };
 }  // namespace ROCKSDB_NAMESPACE
@@ -120,7 +120,7 @@ Status BlobFileReader::OpenFile(
  file_reader->reset(new RandomAccessFileReader(
      std::move(file), blob_file_path, immutable_cf_options.clock, io_tracer,
      immutable_cf_options.statistics, BLOB_DB_BLOB_FILE_READ_MICROS,
-      blob_file_read_hist, immutable_cf_options.rate_limiter.get(),
+      blob_file_read_hist, immutable_cf_options.rate_limiter,
      immutable_cf_options.listeners));

  return Status::OK();
@@ -223,7 +223,7 @@ TEST_F(DBBlobBasicTest, GenerateIOTracing) {
    std::unique_ptr<TraceWriter> trace_writer;
    ASSERT_OK(
        NewFileTraceWriter(env_, EnvOptions(), trace_file, &trace_writer));
-    ASSERT_OK(db_->StartIOTrace(TraceOptions(), std::move(trace_writer)));
+    ASSERT_OK(db_->StartIOTrace(env_, TraceOptions(), std::move(trace_writer)));

    constexpr char key[] = "key";
    constexpr char blob_value[] = "blob_value";
@@ -236,7 +236,7 @@ TEST_F(DBBlobBasicTest, GenerateIOTracing) {
    ASSERT_OK(env_->FileExists(trace_file));
  }
  {
-    // Parse trace file to check file operations related to blob files are
+    // Parse trace file to check file opertions related to blob files are
    // recorded.
    std::unique_ptr<TraceReader> trace_reader;
    ASSERT_OK(
@@ -267,49 +267,6 @@ TEST_F(DBBlobBasicTest, GenerateIOTracing) {
 }
 #endif  // !ROCKSDB_LITE

-TEST_F(DBBlobBasicTest, BestEffortsRecovery_MissingNewestBlobFile) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-  options.create_if_missing = true;
-  Reopen(options);
-
-  ASSERT_OK(dbfull()->DisableFileDeletions());
-  constexpr int kNumTableFiles = 2;
-  for (int i = 0; i < kNumTableFiles; ++i) {
-    for (char ch = 'a'; ch != 'c'; ++ch) {
-      std::string key(1, ch);
-      ASSERT_OK(Put(key, "value" + std::to_string(i)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  Close();
-
-  std::vector<std::string> files;
-  ASSERT_OK(env_->GetChildren(dbname_, &files));
-  std::string blob_file_path;
-  uint64_t max_blob_file_num = kInvalidBlobFileNumber;
-  for (const auto& fname : files) {
-    uint64_t file_num = 0;
-    FileType type;
-    if (ParseFileName(fname, &file_num, /*info_log_name_prefix=*/"", &type) &&
-        type == kBlobFile) {
-      if (file_num > max_blob_file_num) {
-        max_blob_file_num = file_num;
-        blob_file_path = dbname_ + "/" + fname;
-      }
-    }
-  }
-  ASSERT_OK(env_->DeleteFile(blob_file_path));
-
-  options.best_efforts_recovery = true;
-  Reopen(options);
-  std::string value;
-  ASSERT_OK(db_->Get(ReadOptions(), "a", &value));
-  ASSERT_EQ("value" + std::to_string(kNumTableFiles - 2), value);
-}
-
 class DBBlobBasicIOErrorTest : public DBBlobBasicTest,
                               public testing::WithParamInterface<std::string> {
 protected:
@@ -52,8 +52,8 @@ TableBuilder* NewTableBuilder(
        int_tbl_prop_collector_factories,
    uint32_t column_family_id, const std::string& column_family_name,
    WritableFileWriter* file, const CompressionType compression_type,
-    const CompressionOptions& compression_opts, int level,
-    const bool skip_filters, const uint64_t creation_time,
+    uint64_t sample_for_compression, const CompressionOptions& compression_opts,
+    int level, const bool skip_filters, const uint64_t creation_time,
    const uint64_t oldest_key_time, const uint64_t target_file_size,
    const uint64_t file_creation_time, const std::string& db_id,
    const std::string& db_session_id) {
@@ -63,10 +63,10 @@ TableBuilder* NewTableBuilder(
  return ioptions.table_factory->NewTableBuilder(
      TableBuilderOptions(ioptions, moptions, internal_comparator,
                          int_tbl_prop_collector_factories, compression_type,
-                          compression_opts, skip_filters, column_family_name,
-                          level, creation_time, oldest_key_time,
-                          target_file_size, file_creation_time, db_id,
-                          db_session_id),
+                          sample_for_compression, compression_opts,
+                          skip_filters, column_family_name, level,
+                          creation_time, oldest_key_time, target_file_size,
+                          file_creation_time, db_id, db_session_id),
      column_family_id, file);
 }

@@ -85,10 +85,11 @@ Status BuildTable(
    std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
    SnapshotChecker* snapshot_checker, const CompressionType compression,
-    const CompressionOptions& compression_opts, bool paranoid_file_checks,
-    InternalStats* internal_stats, TableFileCreationReason reason,
-    IOStatus* io_status, const std::shared_ptr<IOTracer>& io_tracer,
-    EventLogger* event_logger, int job_id, const Env::IOPriority io_priority,
+    uint64_t sample_for_compression, const CompressionOptions& compression_opts,
+    bool paranoid_file_checks, InternalStats* internal_stats,
+    TableFileCreationReason reason, IOStatus* io_status,
+    const std::shared_ptr<IOTracer>& io_tracer, EventLogger* event_logger,
+    int job_id, const Env::IOPriority io_priority,
    TableProperties* table_properties, int level, const uint64_t creation_time,
    const uint64_t oldest_key_time, Env::WriteLifeTimeHint write_hint,
    const uint64_t file_creation_time, const std::string& db_id,
@@ -156,19 +157,20 @@ Status BuildTable(
      file_writer.reset(new WritableFileWriter(
          std::move(file), fname, file_options, ioptions.clock, io_tracer,
          ioptions.statistics, ioptions.listeners,
-          ioptions.file_checksum_gen_factory.get(),
+          ioptions.file_checksum_gen_factory,
          tmp_set.Contains(FileType::kTableFile)));

      builder = NewTableBuilder(
          ioptions, mutable_cf_options, internal_comparator,
          int_tbl_prop_collector_factories, column_family_id,
-          column_family_name, file_writer.get(), compression, compression_opts,
-          level, false /* skip_filters */, creation_time, oldest_key_time,
+          column_family_name, file_writer.get(), compression,
+          sample_for_compression, compression_opts, level,
+          false /* skip_filters */, creation_time, oldest_key_time,
          0 /*target_file_size*/, file_creation_time, db_id, db_session_id);
    }

    MergeHelper merge(env, internal_comparator.user_comparator(),
-                      ioptions.merge_operator.get(), nullptr, ioptions.info_log,
+                      ioptions.merge_operator, nullptr, ioptions.info_log,
                      true /* internal key corruption is not ok */,
                      snapshots.empty() ? 0 : snapshots.back(),
                      snapshot_checker);
@@ -50,6 +50,7 @@ TableBuilder* NewTableBuilder(
        int_tbl_prop_collector_factories,
    uint32_t column_family_id, const std::string& column_family_name,
    WritableFileWriter* file, const CompressionType compression_type,
+    const uint64_t sample_for_compression,
    const CompressionOptions& compression_opts, int level,
    const bool skip_filters = false, const uint64_t creation_time = 0,
    const uint64_t oldest_key_time = 0, const uint64_t target_file_size = 0,
@@ -79,6 +80,7 @@ extern Status BuildTable(
    std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
    SnapshotChecker* snapshot_checker, const CompressionType compression,
+    const uint64_t sample_for_compression,
    const CompressionOptions& compression_opts, bool paranoid_file_checks,
    InternalStats* internal_stats, TableFileCreationReason reason,
    IOStatus* io_status, const std::shared_ptr<IOTracer>& io_tracer,
@@ -79,8 +79,6 @@ using ROCKSDB_NAMESPACE::IngestExternalFileOptions;
 using ROCKSDB_NAMESPACE::Iterator;
 using ROCKSDB_NAMESPACE::LiveFileMetaData;
 using ROCKSDB_NAMESPACE::Logger;
-using ROCKSDB_NAMESPACE::LRUCacheOptions;
-using ROCKSDB_NAMESPACE::MemoryAllocator;
 using ROCKSDB_NAMESPACE::MemoryUtil;
 using ROCKSDB_NAMESPACE::MergeOperator;
 using ROCKSDB_NAMESPACE::NewBloomFilterPolicy;
@@ -152,12 +150,6 @@ struct rocksdb_filelock_t        { FileLock*         rep; };
 struct rocksdb_logger_t {
  std::shared_ptr<Logger> rep;
 };
-struct rocksdb_lru_cache_options_t {
-  LRUCacheOptions rep;
-};
-struct rocksdb_memory_allocator_t {
-  std::shared_ptr<MemoryAllocator> rep;
-};
 struct rocksdb_cache_t {
  std::shared_ptr<Cache> rep;
 };
@@ -2690,59 +2682,6 @@ unsigned char rocksdb_options_get_skip_checking_sst_file_sizes_on_db_open(
  return opt->rep.skip_checking_sst_file_sizes_on_db_open;
 }

-/* Blob Options Settings */
-void rocksdb_options_set_enable_blob_files(rocksdb_options_t* opt,
-                                           unsigned char val) {
-  opt->rep.enable_blob_files = val;
-}
-extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_enable_blob_files(
-    rocksdb_options_t* opt) {
-  return opt->rep.enable_blob_files;
-}
-
-void rocksdb_options_set_min_blob_size(rocksdb_options_t* opt, uint64_t val) {
-  opt->rep.min_blob_size = val;
-}
-
-uint64_t rocksdb_options_get_min_blob_size(rocksdb_options_t* opt) {
-  return opt->rep.min_blob_size;
-}
-
-void rocksdb_options_set_blob_file_size(rocksdb_options_t* opt, uint64_t val) {
-  opt->rep.blob_file_size = val;
-}
-
-uint64_t rocksdb_options_get_blob_file_size(rocksdb_options_t* opt) {
-  return opt->rep.blob_file_size;
-}
-
-void rocksdb_options_set_blob_compression_type(rocksdb_options_t* opt,
-                                               int val) {
-  opt->rep.blob_compression_type = static_cast<CompressionType>(val);
-}
-
-int rocksdb_options_get_blob_compression_type(rocksdb_options_t* opt) {
-  return opt->rep.blob_compression_type;
-}
-
-void rocksdb_options_set_enable_blob_gc(rocksdb_options_t* opt,
-                                        unsigned char val) {
-  opt->rep.enable_blob_garbage_collection = val;
-}
-
-unsigned char rocksdb_options_get_enable_blob_gc(rocksdb_options_t* opt) {
-  return opt->rep.enable_blob_garbage_collection;
-}
-
-void rocksdb_options_set_blob_gc_age_cutoff(rocksdb_options_t* opt,
-                                            double val) {
-  opt->rep.blob_garbage_collection_age_cutoff = val;
-}
-
-double rocksdb_options_get_blob_gc_age_cutoff(rocksdb_options_t* opt) {
-  return opt->rep.blob_garbage_collection_age_cutoff;
-}
-
 void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int n) {
  opt->rep.num_levels = n;
 }
@@ -4163,58 +4102,16 @@ unsigned char rocksdb_flushoptions_get_wait(rocksdb_flushoptions_t* opt) {
  return opt->rep.wait;
 }

-rocksdb_memory_allocator_t* rocksdb_jemalloc_nodump_allocator_create(
-    char** errptr) {
-  rocksdb_memory_allocator_t* allocator = new rocksdb_memory_allocator_t;
-  ROCKSDB_NAMESPACE::JemallocAllocatorOptions options;
-  SaveError(errptr, ROCKSDB_NAMESPACE::NewJemallocNodumpAllocator(
-                        options, &allocator->rep));
-  return allocator;
-}
-
-void rocksdb_memory_allocator_destroy(rocksdb_memory_allocator_t* allocator) {
-  delete allocator;
-}
-
-rocksdb_lru_cache_options_t* rocksdb_lru_cache_options_create() {
-  return new rocksdb_lru_cache_options_t;
-}
-
-void rocksdb_lru_cache_options_destroy(rocksdb_lru_cache_options_t* opt) {
-  delete opt;
-}
-
-void rocksdb_lru_cache_options_set_capacity(rocksdb_lru_cache_options_t* opt,
-                                            size_t capacity) {
-  opt->rep.capacity = capacity;
-}
-
-void rocksdb_lru_cache_options_set_memory_allocator(
-    rocksdb_lru_cache_options_t* opt, rocksdb_memory_allocator_t* allocator) {
-  opt->rep.memory_allocator = allocator->rep;
-}
-
 rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity) {
  rocksdb_cache_t* c = new rocksdb_cache_t;
  c->rep = NewLRUCache(capacity);
  return c;
 }

-rocksdb_cache_t* rocksdb_cache_create_lru_opts(
-    rocksdb_lru_cache_options_t* opt) {
-  rocksdb_cache_t* c = new rocksdb_cache_t;
-  c->rep = NewLRUCache(opt->rep);
-  return c;
-}
-
 void rocksdb_cache_destroy(rocksdb_cache_t* cache) {
  delete cache;
 }

-void rocksdb_cache_disown_data(rocksdb_cache_t* cache) {
-  cache->rep->DisownData();
-}
-
 void rocksdb_cache_set_capacity(rocksdb_cache_t* cache, size_t capacity) {
  cache->rep->SetCapacity(capacity);
 }
@@ -4893,10 +4790,7 @@ void rocksdb_transaction_destroy(rocksdb_transaction_t* txn) {

 const rocksdb_snapshot_t* rocksdb_transaction_get_snapshot(
    rocksdb_transaction_t* txn) {
-  // This will be freed later on using free, so use malloc here to avoid a
-  // mismatch
-  rocksdb_snapshot_t* result =
-      (rocksdb_snapshot_t*)malloc(sizeof(rocksdb_snapshot_t));
+  rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
  result->rep = txn->rep->GetSnapshot();
  return result;
 }
@@ -1759,25 +1759,6 @@ int main(int argc, char** argv) {
    rocksdb_options_set_atomic_flush(o, 1);
    CheckCondition(1 == rocksdb_options_get_atomic_flush(o));

-    /* Blob Options */
-    rocksdb_options_set_enable_blob_files(o, 1);
-    CheckCondition(1 == rocksdb_options_get_enable_blob_files(o));
-
-    rocksdb_options_set_min_blob_size(o, 29);
-    CheckCondition(29 == rocksdb_options_get_min_blob_size(o));
-
-    rocksdb_options_set_blob_file_size(o, 30);
-    CheckCondition(30 == rocksdb_options_get_blob_file_size(o));
-
-    rocksdb_options_set_blob_compression_type(o, 4);
-    CheckCondition(4 == rocksdb_options_get_blob_compression_type(o));
-
-    rocksdb_options_set_enable_blob_gc(o, 1);
-    CheckCondition(1 == rocksdb_options_get_enable_blob_gc(o));
-
-    rocksdb_options_set_blob_gc_age_cutoff(o, 0.75);
-    CheckCondition(0.75 == rocksdb_options_get_blob_gc_age_cutoff(o));
-
    // Create a copy that should be equal to the original.
    rocksdb_options_t* copy;
    copy = rocksdb_options_create_copy(o);
@@ -2381,37 +2362,6 @@ int main(int argc, char** argv) {
    rocksdb_cache_destroy(co);
  }

-  StartPhase("jemalloc_nodump_allocator");
-  {
-    rocksdb_memory_allocator_t* allocator;
-    allocator = rocksdb_jemalloc_nodump_allocator_create(&err);
-    if (err != NULL) {
-      // not supported on all platforms, allow unsupported error
-      const char* ni = "Not implemented: ";
-      size_t ni_len = strlen(ni);
-      size_t err_len = strlen(err);
-
-      CheckCondition(err_len >= ni_len);
-      CheckCondition(memcmp(ni, err, ni_len) == 0);
-      Free(&err);
-    } else {
-      rocksdb_cache_t* co;
-      rocksdb_lru_cache_options_t* copts;
-
-      copts = rocksdb_lru_cache_options_create();
-
-      rocksdb_lru_cache_options_set_capacity(copts, 100);
-      rocksdb_lru_cache_options_set_memory_allocator(copts, allocator);
-
-      co = rocksdb_cache_create_lru_opts(copts);
-      CheckCondition(100 == rocksdb_cache_get_capacity(co));
-
-      rocksdb_cache_destroy(co);
-      rocksdb_lru_cache_options_destroy(copts);
-    }
-    rocksdb_memory_allocator_destroy(allocator);
-  }
-
  StartPhase("env");
  {
    rocksdb_env_t* e;
@@ -2919,7 +2869,6 @@ int main(int argc, char** argv) {
  rocksdb_readoptions_destroy(roptions);
  rocksdb_writeoptions_destroy(woptions);
  rocksdb_compactoptions_destroy(coptions);
-  rocksdb_cache_disown_data(cache);
  rocksdb_cache_destroy(cache);
  rocksdb_comparator_destroy(cmp);
  rocksdb_dbpath_destroy(dbpath);
@@ -1355,12 +1355,6 @@ Status ColumnFamilyData::ValidateOptions(
        "[0.0, 1.0].");
  }

-  if (cf_options.compaction_style == kCompactionStyleFIFO &&
-      db_options.max_open_files != -1 && cf_options.ttl > 0) {
-    return Status::NotSupported(
-        "FIFO compaction only supported with max_open_files = -1.");
-  }
-
  return s;
 }

@@ -253,7 +253,7 @@ extern Status CheckCFPathsSupported(const DBOptions& db_options,

 extern ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
                                           const ColumnFamilyOptions& src);
-// Wrap user defined table properties collector factories `from cf_options`
+// Wrap user defined table proproties collector factories `from cf_options`
 // into internal ones in int_tbl_prop_collector_factories. Add a system internal
 // one too.
 extern void GetIntTblPropCollectorFactory(
@@ -441,7 +441,7 @@ class ColumnFamilyData {
  // Get SuperVersion stored in thread local storage. If it does not exist,
  // get a reference from a current SuperVersion.
  SuperVersion* GetThreadLocalSuperVersion(DBImpl* db);
-  // Try to return SuperVersion back to thread local storage. Return true on
+  // Try to return SuperVersion back to thread local storage. Retrun true on
  // success and false on failure. It fails when the thread local storage
  // contains anything other than SuperVersion::kSVInUse flag.
  bool ReturnThreadLocalSuperVersion(SuperVersion* sv);
@@ -118,78 +118,6 @@ TEST_F(CompactFilesTest, L0ConflictsFiles) {
  delete db;
 }

-TEST_F(CompactFilesTest, MultipleLevel) {
-  Options options;
-  options.create_if_missing = true;
-  options.level_compaction_dynamic_level_bytes = true;
-  options.num_levels = 6;
-  // Add listener
-  FlushedFileCollector* collector = new FlushedFileCollector();
-  options.listeners.emplace_back(collector);
-
-  DB* db = nullptr;
-  DestroyDB(db_name_, options);
-  Status s = DB::Open(options, db_name_, &db);
-  ASSERT_OK(s);
-  ASSERT_NE(db, nullptr);
-
-  // create couple files in L0, L3, L4 and L5
-  for (int i = 5; i > 2; --i) {
-    collector->ClearFlushedFiles();
-    ASSERT_OK(db->Put(WriteOptions(), ToString(i), ""));
-    ASSERT_OK(db->Flush(FlushOptions()));
-    auto l0_files = collector->GetFlushedFiles();
-    ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files, i));
-
-    std::string prop;
-    ASSERT_TRUE(
-        db->GetProperty("rocksdb.num-files-at-level" + ToString(i), &prop));
-    ASSERT_EQ("1", prop);
-  }
-  ASSERT_OK(db->Put(WriteOptions(), ToString(0), ""));
-  ASSERT_OK(db->Flush(FlushOptions()));
-
-  ColumnFamilyMetaData meta;
-  db->GetColumnFamilyMetaData(&meta);
-  // Compact files except the file in L3
-  std::vector<std::string> files;
-  for (int i = 0; i < 6; ++i) {
-    if (i == 3) continue;
-    for (auto& file : meta.levels[i].files) {
-      files.push_back(file.db_path + "/" + file.name);
-    }
-  }
-
-  SyncPoint::GetInstance()->LoadDependency({
-      {"CompactionJob::Run():Start", "CompactFilesTest.MultipleLevel:0"},
-      {"CompactFilesTest.MultipleLevel:1", "CompactFilesImpl:3"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  std::thread thread([&] {
-    TEST_SYNC_POINT("CompactFilesTest.MultipleLevel:0");
-    ASSERT_OK(db->Put(WriteOptions(), "bar", "v2"));
-    ASSERT_OK(db->Put(WriteOptions(), "foo", "v2"));
-    ASSERT_OK(db->Flush(FlushOptions()));
-    TEST_SYNC_POINT("CompactFilesTest.MultipleLevel:1");
-  });
-
-  // Compaction cannot move up the data to higher level
-  // here we have input file from level 5, so the output level has to be >= 5
-  for (int invalid_output_level = 0; invalid_output_level < 5;
-       invalid_output_level++) {
-    s = db->CompactFiles(CompactionOptions(), files, invalid_output_level);
-    std::cout << s.ToString() << std::endl;
-    ASSERT_TRUE(s.IsInvalidArgument());
-  }
-
-  ASSERT_OK(db->CompactFiles(CompactionOptions(), files, 5));
-  SyncPoint::GetInstance()->DisableProcessing();
-  thread.join();
-
-  delete db;
-}
-
 TEST_F(CompactFilesTest, ObsoleteFiles) {
  Options options;
  // to trigger compaction more easily
@@ -4,7 +4,7 @@
 //  (found in the LICENSE.Apache file in the root directory).

 #ifndef ROCKSDB_LITE
-#include "db/db_impl/compacted_db_impl.h"
+#include "db/compacted_db_impl.h"

 #include "db/db_impl/db_impl.h"
 #include "db/version_set.h"
@@ -17,13 +17,11 @@ extern void MarkKeyMayExist(void* arg);
 extern bool SaveValue(void* arg, const ParsedInternalKey& parsed_key,
                      const Slice& v, bool hit_and_return);

-CompactedDBImpl::CompactedDBImpl(const DBOptions& options,
-                                 const std::string& dbname)
-    : DBImpl(options, dbname, /*seq_per_batch*/ false, +/*batch_per_txn*/ true,
-             /*read_only*/ true),
-      cfd_(nullptr),
-      version_(nullptr),
-      user_comparator_(nullptr) {}
+CompactedDBImpl::CompactedDBImpl(
+  const DBOptions& options, const std::string& dbname)
+  : DBImpl(options, dbname), cfd_(nullptr), version_(nullptr),
+    user_comparator_(nullptr) {
+}

 CompactedDBImpl::~CompactedDBImpl() {
 }
@@ -80,7 +78,6 @@ std::vector<Status> CompactedDBImpl::MultiGet(const ReadOptions& options,
                             nullptr, nullptr, nullptr, true, nullptr, nullptr);
      LookupKey lkey(keys[idx], kMaxSequenceNumber);
      Status s = r->Get(options, lkey.internal_key(), &get_context, nullptr);
-      assert(static_cast<size_t>(idx) < statuses.size());
      if (!s.ok() && !s.IsNotFound()) {
        statuses[idx] = s;
      } else {
@@ -18,7 +18,7 @@ class CompactedDBImpl : public DBImpl {
  CompactedDBImpl(const CompactedDBImpl&) = delete;
  void operator=(const CompactedDBImpl&) = delete;

-  ~CompactedDBImpl() override;
+  virtual ~CompactedDBImpl();

  static Status Open(const Options& options, const std::string& dbname,
                     DB** dbptr);
@@ -519,7 +519,7 @@ uint64_t Compaction::OutputFilePreallocationSize() const {

  // Over-estimate slightly so we don't end up just barely crossing
  // the threshold
-  // No point to preallocate more than 1GB.
+  // No point to prellocate more than 1GB.
  return std::min(uint64_t{1073741824},
                  preallocation_size + (preallocation_size / 10));
 }
@@ -341,7 +341,7 @@ class Compaction {
  const uint32_t output_path_id_;
  CompressionType output_compression_;
  CompressionOptions output_compression_opts_;
-  // If true, then the compaction can be done by simply deleting input files.
+  // If true, then the comaction can be done by simply deleting input files.
  const bool deletion_compaction_;

  // Compaction input files organized by level. Constant after construction
@@ -135,7 +135,7 @@ CompactionIterator::CompactionIterator(
 }

 CompactionIterator::~CompactionIterator() {
-  // input_ Iterator lifetime is longer than pinned_iters_mgr_ lifetime
+  // input_ Iteartor lifetime is longer than pinned_iters_mgr_ lifetime
  input_->SetPinnedItersMgr(nullptr);
 }

@@ -38,7 +38,7 @@ class NoMergingMergeOp : public MergeOperator {

 // Compaction filter that gets stuck when it sees a particular key,
 // then gets unstuck when told to.
-// Always returns Decision::kRemove.
+// Always returns Decition::kRemove.
 class StallingFilter : public CompactionFilter {
 public:
  Decision FilterV2(int /*level*/, const Slice& key, ValueType /*type*/,
@@ -189,7 +189,7 @@ class FakeCompaction : public CompactionIterator::CompactionProxy {
  bool is_allow_ingest_behind = false;
 };

-// A simplified snapshot checker which assumes each snapshot has a global
+// A simplifed snapshot checker which assumes each snapshot has a global
 // last visible sequence.
 class TestSnapshotChecker : public SnapshotChecker {
 public:
@@ -711,7 +711,7 @@ TEST_P(CompactionIteratorTest, ZeroOutSequenceAtBottomLevel) {
  RunTest({test::KeyStr("a", 1, kTypeValue), test::KeyStr("b", 2, kTypeValue)},
          {"v1", "v2"},
          {test::KeyStr("a", 0, kTypeValue), test::KeyStr("b", 2, kTypeValue)},
-          {"v1", "v2"}, kMaxSequenceNumber /*last_committed_seq*/,
+          {"v1", "v2"}, kMaxSequenceNumber /*last_commited_seq*/,
          nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
          true /*bottommost_level*/);
 }
@@ -720,14 +720,15 @@ TEST_P(CompactionIteratorTest, ZeroOutSequenceAtBottomLevel) {
 // permanently.
 TEST_P(CompactionIteratorTest, RemoveDeletionAtBottomLevel) {
  AddSnapshot(1);
-  RunTest(
-      {test::KeyStr("a", 1, kTypeDeletion), test::KeyStr("b", 3, kTypeDeletion),
-       test::KeyStr("b", 1, kTypeValue)},
-      {"", "", ""},
-      {test::KeyStr("b", 3, kTypeDeletion), test::KeyStr("b", 0, kTypeValue)},
-      {"", ""}, kMaxSequenceNumber /*last_committed_seq*/,
-      nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
-      true /*bottommost_level*/);
+  RunTest({test::KeyStr("a", 1, kTypeDeletion),
+           test::KeyStr("b", 3, kTypeDeletion),
+           test::KeyStr("b", 1, kTypeValue)},
+          {"", "", ""},
+          {test::KeyStr("b", 3, kTypeDeletion),
+           test::KeyStr("b", 0, kTypeValue)},
+          {"", ""},
+          kMaxSequenceNumber /*last_commited_seq*/, nullptr /*merge_operator*/,
+          nullptr /*compaction_filter*/, true /*bottommost_level*/);
 }

 // In bottommost level, single deletions earlier than earliest snapshot can be
@@ -737,7 +738,7 @@ TEST_P(CompactionIteratorTest, RemoveSingleDeletionAtBottomLevel) {
  RunTest({test::KeyStr("a", 1, kTypeSingleDeletion),
           test::KeyStr("b", 2, kTypeSingleDeletion)},
          {"", ""}, {test::KeyStr("b", 2, kTypeSingleDeletion)}, {""},
-          kMaxSequenceNumber /*last_committed_seq*/, nullptr /*merge_operator*/,
+          kMaxSequenceNumber /*last_commited_seq*/, nullptr /*merge_operator*/,
          nullptr /*compaction_filter*/, true /*bottommost_level*/);
 }

@@ -894,7 +895,7 @@ TEST_F(CompactionIteratorWithSnapshotCheckerTest,
          {"v1", "v2", "v3"},
          {test::KeyStr("a", 0, kTypeValue), test::KeyStr("b", 2, kTypeValue),
           test::KeyStr("c", 3, kTypeValue)},
-          {"v1", "v2", "v3"}, kMaxSequenceNumber /*last_committed_seq*/,
+          {"v1", "v2", "v3"}, kMaxSequenceNumber /*last_commited_seq*/,
          nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
          true /*bottommost_level*/);
 }
@@ -905,7 +906,9 @@ TEST_F(CompactionIteratorWithSnapshotCheckerTest,
  RunTest(
      {test::KeyStr("a", 1, kTypeDeletion), test::KeyStr("b", 2, kTypeDeletion),
       test::KeyStr("c", 3, kTypeDeletion)},
-      {"", "", ""}, {}, {"", ""}, kMaxSequenceNumber /*last_committed_seq*/,
+      {"", "", ""},
+      {},
+      {"", ""}, kMaxSequenceNumber /*last_commited_seq*/,
      nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
      true /*bottommost_level*/);
 }
@@ -913,14 +916,15 @@ TEST_F(CompactionIteratorWithSnapshotCheckerTest,
 TEST_F(CompactionIteratorWithSnapshotCheckerTest,
       NotRemoveDeletionIfValuePresentToEarlierSnapshot) {
  AddSnapshot(2,1);
-  RunTest({test::KeyStr("a", 4, kTypeDeletion),
-           test::KeyStr("a", 1, kTypeValue), test::KeyStr("b", 3, kTypeValue)},
-          {"", "", ""},
-          {test::KeyStr("a", 4, kTypeDeletion),
-           test::KeyStr("a", 0, kTypeValue), test::KeyStr("b", 3, kTypeValue)},
-          {"", "", ""}, kMaxSequenceNumber /*last_committed_seq*/,
-          nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
-          true /*bottommost_level*/);
+  RunTest(
+      {test::KeyStr("a", 4, kTypeDeletion), test::KeyStr("a", 1, kTypeValue),
+          test::KeyStr("b", 3, kTypeValue)},
+      {"", "", ""},
+      {test::KeyStr("a", 4, kTypeDeletion), test::KeyStr("a", 0, kTypeValue),
+            test::KeyStr("b", 3, kTypeValue)},
+      {"", "", ""}, kMaxSequenceNumber /*last_commited_seq*/,
+      nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
+      true /*bottommost_level*/);
 }

 TEST_F(CompactionIteratorWithSnapshotCheckerTest,
@@ -932,7 +936,7 @@ TEST_F(CompactionIteratorWithSnapshotCheckerTest,
          {"", "", ""},
          {test::KeyStr("b", 2, kTypeSingleDeletion),
           test::KeyStr("c", 3, kTypeSingleDeletion)},
-          {"", ""}, kMaxSequenceNumber /*last_committed_seq*/,
+          {"", ""}, kMaxSequenceNumber /*last_commited_seq*/,
          nullptr /*merge_operator*/, nullptr /*compaction_filter*/,
          true /*bottommost_level*/);
 }
@@ -982,8 +986,8 @@ TEST_F(CompactionIteratorWithSnapshotCheckerTest,
 }

 // Compaction filter should keep uncommitted key as-is, and
-//   * Convert the latest value to deletion, and/or
-//   * if latest value is a merge, apply filter to all subsequent merges.
+//   * Convert the latest velue to deletion, and/or
+//   * if latest value is a merge, apply filter to all suequent merges.

 TEST_F(CompactionIteratorWithSnapshotCheckerTest, CompactionFilter_Value) {
  std::unique_ptr<CompactionFilter> compaction_filter(
@@ -150,7 +150,7 @@ struct CompactionJob::SubcompactionState {
      // This subcompaction's output could be empty if compaction was aborted
      // before this subcompaction had a chance to generate any output files.
      // When subcompactions are executed sequentially this is more likely and
-      // will be particularly likely for the later subcompactions to be empty.
+      // will be particulalry likely for the later subcompactions to be empty.
      // Once they are run in parallel however it should be much rarer.
      return nullptr;
    } else {
@@ -312,19 +312,14 @@ CompactionJob::CompactionJob(
    const std::atomic<int>* manual_compaction_paused, const std::string& db_id,
    const std::string& db_session_id, std::string full_history_ts_low,
    BlobFileCompletionCallback* blob_callback)
-    : compact_(new CompactionState(compaction)),
-      compaction_stats_(compaction->compaction_reason(), 1),
-      db_options_(db_options),
-      log_buffer_(log_buffer),
-      output_directory_(output_directory),
-      stats_(stats),
-      bottommost_level_(false),
-      write_hint_(Env::WLTH_NOT_SET),
-      job_id_(job_id),
+    : job_id_(job_id),
+      compact_(new CompactionState(compaction)),
      compaction_job_stats_(compaction_job_stats),
+      compaction_stats_(compaction->compaction_reason(), 1),
      dbname_(dbname),
      db_id_(db_id),
      db_session_id_(db_session_id),
+      db_options_(db_options),
      file_options_(file_options),
      env_(db_options.env),
      io_tracer_(io_tracer),
@@ -335,8 +330,11 @@ CompactionJob::CompactionJob(
      shutting_down_(shutting_down),
      manual_compaction_paused_(manual_compaction_paused),
      preserve_deletes_seqnum_(preserve_deletes_seqnum),
+      log_buffer_(log_buffer),
      db_directory_(db_directory),
+      output_directory_(output_directory),
      blob_output_directory_(blob_output_directory),
+      stats_(stats),
      db_mutex_(db_mutex),
      db_error_handler_(db_error_handler),
      existing_snapshots_(std::move(existing_snapshots)),
@@ -344,8 +342,10 @@ CompactionJob::CompactionJob(
      snapshot_checker_(snapshot_checker),
      table_cache_(std::move(table_cache)),
      event_logger_(event_logger),
+      bottommost_level_(false),
      paranoid_file_checks_(paranoid_file_checks),
      measure_io_stats_(measure_io_stats),
+      write_hint_(Env::WLTH_NOT_SET),
      thread_pri_(thread_pri),
      full_history_ts_low_(std::move(full_history_ts_low)),
      blob_callback_(blob_callback) {
@@ -410,7 +410,7 @@ void CompactionJob::Prepare() {
  AutoThreadOperationStageUpdater stage_updater(
      ThreadStatus::STAGE_COMPACTION_PREPARE);

-  // Generate file_levels_ for compaction before making Iterator
+  // Generate file_levels_ for compaction berfore making Iterator
  auto* c = compact_->compaction;
  assert(c->column_family_data() != nullptr);
  assert(c->column_family_data()->current()->storage_info()->NumLevelFiles(
@@ -965,7 +965,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  }

  MergeHelper merge(
-      env_, cfd->user_comparator(), cfd->ioptions()->merge_operator.get(),
+      env_, cfd->user_comparator(), cfd->ioptions()->merge_operator,
      compaction_filter, db_options_.info_log.get(),
      false /* internal key corruption is expected */,
      existing_snapshots_.empty() ? 0 : existing_snapshots_.back(),
@@ -1550,7 +1550,9 @@ Status CompactionJob::FinishCompactionOutputFile(
  FileDescriptor output_fd;
  uint64_t oldest_blob_file_number = kInvalidBlobFileNumber;
  if (meta != nullptr) {
-    fname = GetTableFileName(meta->fd.GetNumber());
+    fname =
+        TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
+                      meta->fd.GetNumber(), meta->fd.GetPathId());
    output_fd = meta->fd;
    oldest_blob_file_number = meta->oldest_blob_file_number;
  } else {
@@ -1670,7 +1672,9 @@ Status CompactionJob::OpenCompactionOutputFile(
  assert(sub_compact->builder == nullptr);
  // no need to lock because VersionSet::next_file_number_ is atomic
  uint64_t file_number = versions_->NewFileNumber();
-  std::string fname = GetTableFileName(file_number);
+  std::string fname =
+      TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
+                    file_number, sub_compact->compaction->output_path_id());
  // Fire events.
  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
 #ifndef ROCKSDB_LITE
@@ -1766,6 +1770,7 @@ Status CompactionJob::OpenCompactionOutputFile(
      cfd->internal_comparator(), cfd->int_tbl_prop_collector_factories(),
      cfd->GetID(), cfd->GetName(), sub_compact->outfile.get(),
      sub_compact->compaction->output_compression(),
+      0 /*sample_for_compression */,
      sub_compact->compaction->output_compression_opts(),
      sub_compact->compaction->output_level(), skip_filters,
      oldest_ancester_time, 0 /* oldest_key_time */,
@@ -1933,132 +1938,4 @@ void CompactionJob::LogCompaction() {
  }
 }

-std::string CompactionJob::GetTableFileName(uint64_t file_number) {
-  return TableFileName(compact_->compaction->immutable_cf_options()->cf_paths,
-                       file_number, compact_->compaction->output_path_id());
-}
-
-std::string CompactionServiceCompactionJob::GetTableFileName(
-    uint64_t file_number) {
-  return MakeTableFileName(output_path_, file_number);
-}
-
-CompactionServiceCompactionJob::CompactionServiceCompactionJob(
-    int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
-    const FileOptions& file_options, VersionSet* versions,
-    const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
-    FSDirectory* output_directory, Statistics* stats,
-    InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
-    std::vector<SequenceNumber> existing_snapshots,
-    std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
-    const std::string& dbname, const std::shared_ptr<IOTracer>& io_tracer,
-    const std::string& db_id, const std::string& db_session_id,
-    const std::string& output_path,
-    const CompactionServiceInput& compaction_service_input,
-    CompactionServiceResult* compaction_service_result)
-    : CompactionJob(
-          job_id, compaction, db_options, file_options, versions, shutting_down,
-          0, log_buffer, nullptr, output_directory, nullptr, stats, db_mutex,
-          db_error_handler, existing_snapshots, kMaxSequenceNumber, nullptr,
-          table_cache, event_logger,
-          compaction->mutable_cf_options()->paranoid_file_checks,
-          compaction->mutable_cf_options()->report_bg_io_stats, dbname,
-          &(compaction_service_result->stats), Env::Priority::USER, io_tracer,
-          nullptr, db_id, db_session_id,
-          compaction->column_family_data()->GetFullHistoryTsLow()),
-      output_path_(output_path),
-      compaction_input_(compaction_service_input),
-      compaction_result_(compaction_service_result) {}
-
-Status CompactionServiceCompactionJob::Run() {
-  AutoThreadOperationStageUpdater stage_updater(
-      ThreadStatus::STAGE_COMPACTION_RUN);
-
-  auto* c = compact_->compaction;
-  assert(c->column_family_data() != nullptr);
-  assert(c->column_family_data()->current()->storage_info()->NumLevelFiles(
-             compact_->compaction->level()) > 0);
-
-  write_hint_ =
-      c->column_family_data()->CalculateSSTWriteHint(c->output_level());
-  bottommost_level_ = c->bottommost_level();
-
-  compact_->sub_compact_states.emplace_back(c, compaction_input_.begin,
-                                            compaction_input_.end,
-                                            compaction_input_.approx_size);
-
-  log_buffer_->FlushBufferToLog();
-  LogCompaction();
-  const uint64_t start_micros = db_options_.clock->NowMicros();
-  // Pick the only sub-compaction we should have
-  assert(compact_->sub_compact_states.size() == 1);
-  SubcompactionState* sub_compact = compact_->sub_compact_states.data();
-
-  ProcessKeyValueCompaction(sub_compact);
-
-  compaction_stats_.micros = db_options_.clock->NowMicros() - start_micros;
-  compaction_stats_.cpu_micros = sub_compact->compaction_job_stats.cpu_micros;
-
-  RecordTimeToHistogram(stats_, COMPACTION_TIME, compaction_stats_.micros);
-  RecordTimeToHistogram(stats_, COMPACTION_CPU_TIME,
-                        compaction_stats_.cpu_micros);
-
-  Status status = sub_compact->status;
-  IOStatus io_s = sub_compact->io_status;
-
-  if (io_status_.ok()) {
-    io_status_ = io_s;
-  }
-
-  if (status.ok()) {
-    constexpr IODebugContext* dbg = nullptr;
-
-    if (output_directory_) {
-      io_s = output_directory_->Fsync(IOOptions(), dbg);
-    }
-  }
-  if (io_status_.ok()) {
-    io_status_ = io_s;
-  }
-  if (status.ok()) {
-    status = io_s;
-  }
-  if (status.ok()) {
-    // TODO: Add verify_table() and VerifyCompactionFileConsistency()
-  }
-
-  // Finish up all book-keeping to unify the subcompaction results
-  AggregateStatistics();
-  UpdateCompactionStats();
-
-  compaction_result_->bytes_written = IOSTATS(bytes_written);
-  compaction_result_->bytes_read = IOSTATS(bytes_read);
-  RecordCompactionIOStats();
-
-  LogFlush(db_options_.info_log);
-  compact_->status = status;
-  compact_->status.PermitUncheckedError();
-
-  // Build compaction result
-  compaction_result_->output_level = compact_->compaction->output_level();
-  compaction_result_->output_path = output_path_;
-  for (const auto& output_file : sub_compact->outputs) {
-    auto& meta = output_file.meta;
-    compaction_result_->output_files.emplace_back(
-        MakeTableFileName(meta.fd.GetNumber()), meta.fd.smallest_seqno,
-        meta.fd.largest_seqno, meta.smallest.Encode().ToString(),
-        meta.largest.Encode().ToString(), meta.oldest_ancester_time,
-        meta.file_creation_time, output_file.validator.GetHash(),
-        meta.marked_for_compaction);
-  }
-  compaction_result_->num_output_records = sub_compact->num_output_records;
-  compaction_result_->total_bytes = sub_compact->total_bytes;
-
-  return status;
-}
-
-void CompactionServiceCompactionJob::CleanupCompaction() {
-  CompactionJob::CleanupCompaction();
-}
-
 }  // namespace ROCKSDB_NAMESPACE
@@ -84,7 +84,7 @@ class CompactionJob {
      std::string full_history_ts_low = "",
      BlobFileCompletionCallback* blob_callback = nullptr);

-  virtual ~CompactionJob();
+  ~CompactionJob();

  // no copy/move
  CompactionJob(CompactionJob&& job) = delete;
@@ -107,35 +107,11 @@ class CompactionJob {
  // Return the IO status
  IOStatus io_status() const { return io_status_; }

- protected:
+ private:
  struct SubcompactionState;
-  // CompactionJob state
-  struct CompactionState;

  void AggregateStatistics();
-  void UpdateCompactionStats();
-  void LogCompaction();
-  void RecordCompactionIOStats();
-  void CleanupCompaction();

-  // Call compaction filter. Then iterate through input and compact the
-  // kv-pairs
-  void ProcessKeyValueCompaction(SubcompactionState* sub_compact);
-
-  CompactionState* compact_;
-  InternalStats::CompactionStats compaction_stats_;
-  const ImmutableDBOptions& db_options_;
-  LogBuffer* log_buffer_;
-  FSDirectory* output_directory_;
-  Statistics* stats_;
-  // Is this compaction creating a file in the bottom most level?
-  bool bottommost_level_;
-
-  Env::WriteLifeTimeHint write_hint_;
-
-  IOStatus io_status_;
-
- private:
  // Generates a histogram representing potential divisions of key ranges from
  // the input. It adds the starting and/or ending keys of certain input files
  // to the working set and then finds the approximate size of data in between
@@ -146,6 +122,9 @@ class CompactionJob {
  // update the thread status for starting a compaction.
  void ReportStartedCompaction(Compaction* compaction);
  void AllocateCompactionOutputFileNumbers();
+  // Call compaction filter. Then iterate through input and compact the
+  // kv-pairs
+  void ProcessKeyValueCompaction(SubcompactionState* sub_compact);

  Status FinishCompactionOutputFile(
      const Status& input_status, SubcompactionState* sub_compact,
@@ -153,23 +132,33 @@ class CompactionJob {
      CompactionIterationStats* range_del_out_stats,
      const Slice* next_table_min_key = nullptr);
  Status InstallCompactionResults(const MutableCFOptions& mutable_cf_options);
+  void RecordCompactionIOStats();
  Status OpenCompactionOutputFile(SubcompactionState* sub_compact);
+  void CleanupCompaction();
  void UpdateCompactionJobStats(
    const InternalStats::CompactionStats& stats) const;
  void RecordDroppedKeys(const CompactionIterationStats& c_iter_stats,
                         CompactionJobStats* compaction_job_stats = nullptr);

+  void UpdateCompactionStats();
  void UpdateCompactionInputStatsHelper(
      int* num_files, uint64_t* bytes_read, int input_level);

+  void LogCompaction();
+
  int job_id_;

+  // CompactionJob state
+  struct CompactionState;
+  CompactionState* compact_;
  CompactionJobStats* compaction_job_stats_;
+  InternalStats::CompactionStats compaction_stats_;

  // DBImpl state
  const std::string& dbname_;
  const std::string db_id_;
  const std::string db_session_id_;
+  const ImmutableDBOptions& db_options_;
  const FileOptions file_options_;

  Env* env_;
@@ -181,8 +170,11 @@ class CompactionJob {
  const std::atomic<bool>* shutting_down_;
  const std::atomic<int>* manual_compaction_paused_;
  const SequenceNumber preserve_deletes_seqnum_;
+  LogBuffer* log_buffer_;
  FSDirectory* db_directory_;
+  FSDirectory* output_directory_;
  FSDirectory* blob_output_directory_;
+  Statistics* stats_;
  InstrumentedMutex* db_mutex_;
  ErrorHandler* db_error_handler_;
  // If there were two snapshots with seq numbers s1 and
@@ -202,128 +194,19 @@ class CompactionJob {

  EventLogger* event_logger_;

+  // Is this compaction creating a file in the bottom most level?
+  bool bottommost_level_;
  bool paranoid_file_checks_;
  bool measure_io_stats_;
  // Stores the Slices that designate the boundaries for each subcompaction
  std::vector<Slice> boundaries_;
  // Stores the approx size of keys covered in the range of each subcompaction
  std::vector<uint64_t> sizes_;
+  Env::WriteLifeTimeHint write_hint_;
  Env::Priority thread_pri_;
+  IOStatus io_status_;
  std::string full_history_ts_low_;
  BlobFileCompletionCallback* blob_callback_;
-
-  // Get table file name in where it's outputting to, which should also be in
-  // `output_directory_`.
-  virtual std::string GetTableFileName(uint64_t file_number);
-};
-
-// CompactionServiceInput is used the pass compaction information between two
-// db instances. It contains the information needed to do a compaction. It
-// doesn't contain the LSM tree information, which is passed though MANIFEST
-// file.
-struct CompactionServiceInput {
-  ColumnFamilyDescriptor column_family;
-
-  DBOptions db_options;
-
-  std::vector<SequenceNumber> snapshots;
-
-  // SST files for compaction, it should already be expended to include all the
-  // files needed for this compaction, for both input level files and output
-  // level files.
-  std::vector<std::string> input_files;
-  int output_level;
-
-  // information for subcompaction
-  Slice* begin = nullptr;
-  Slice* end = nullptr;
-  uint64_t approx_size = 0;
-};
-
-// CompactionServiceOutputFile is the metadata for the output SST file
-struct CompactionServiceOutputFile {
-  std::string file_name;
-  SequenceNumber smallest_seqno;
-  SequenceNumber largest_seqno;
-  std::string smallest_internal_key;
-  std::string largest_internal_key;
-  uint64_t oldest_ancester_time;
-  uint64_t file_creation_time;
-  uint64_t paranoid_hash;
-  bool marked_for_compaction;
-
-  CompactionServiceOutputFile() = default;
-  CompactionServiceOutputFile(
-      const std::string& name, SequenceNumber smallest, SequenceNumber largest,
-      std::string _smallest_internal_key, std::string _largest_internal_key,
-      uint64_t _oldest_ancester_time, uint64_t _file_creation_time,
-      uint64_t _paranoid_hash, bool _marked_for_compaction)
-      : file_name(name),
-        smallest_seqno(smallest),
-        largest_seqno(largest),
-        smallest_internal_key(std::move(_smallest_internal_key)),
-        largest_internal_key(std::move(_largest_internal_key)),
-        oldest_ancester_time(_oldest_ancester_time),
-        file_creation_time(_file_creation_time),
-        paranoid_hash(_paranoid_hash),
-        marked_for_compaction(_marked_for_compaction) {}
-};
-
-// CompactionServiceResult contains the compaction result from a different db
-// instance, with these information, the primary db instance with write
-// permission is able to install the result to the DB.
-struct CompactionServiceResult {
-  std::vector<CompactionServiceOutputFile> output_files;
-  int output_level;
-
-  // location of the output files
-  std::string output_path;
-
-  // some statistics about the compaction
-  uint64_t num_output_records;
-  uint64_t total_bytes;
-  uint64_t bytes_read;
-  uint64_t bytes_written;
-  CompactionJobStats stats;
-};
-
-// CompactionServiceCompactionJob is an read-only compaction job, it takes
-// input information from `compaction_service_input` and put result information
-// in `compaction_service_result`, the SST files are generated to `output_path`.
-class CompactionServiceCompactionJob : private CompactionJob {
- public:
-  CompactionServiceCompactionJob(
-      int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
-      const FileOptions& file_options, VersionSet* versions,
-      const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
-      FSDirectory* output_directory, Statistics* stats,
-      InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
-      std::vector<SequenceNumber> existing_snapshots,
-      std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
-      const std::string& dbname, const std::shared_ptr<IOTracer>& io_tracer,
-      const std::string& db_id, const std::string& db_session_id,
-      const std::string& output_path,
-      const CompactionServiceInput& compaction_service_input,
-      CompactionServiceResult* compaction_service_result);
-
-  // Run the compaction in current thread and return the result
-  Status Run();
-
-  void CleanupCompaction();
-
-  IOStatus io_status() const { return CompactionJob::io_status(); }
-
- private:
-  // Get table file name in output_path
-  std::string GetTableFileName(uint64_t file_number) override;
-  // Specific the compaction output path, otherwise it uses default DB path
-  const std::string output_path_;
-
-  // Compaction job input
-  const CompactionServiceInput& compaction_input_;
-
-  // Compaction job result
-  CompactionServiceResult* compaction_result_;
 };

 }  // namespace ROCKSDB_NAMESPACE
@@ -1004,7 +1004,6 @@ Status CompactionPicker::SanitizeCompactionInputFiles(
  // any currently-existing files.
  for (auto file_num : *input_files) {
    bool found = false;
-    int input_file_level = -1;
    for (const auto& level_meta : cf_meta.levels) {
      for (const auto& file_meta : level_meta.files) {
        if (file_num == TableFileNameToNumber(file_meta.name)) {
@@ -1014,7 +1013,6 @@ Status CompactionPicker::SanitizeCompactionInputFiles(
                                   " is already being compacted.");
          }
          found = true;
-          input_file_level = level_meta.level;
          break;
        }
      }
@@ -1027,13 +1025,6 @@ Status CompactionPicker::SanitizeCompactionInputFiles(
          "Specified compaction input file " + MakeTableFileName("", file_num) +
          " does not exist in column family " + cf_meta.name + ".");
    }
-    if (input_file_level > output_level) {
-      return Status::InvalidArgument(
-          "Cannot compact file to up level, input file: " +
-          MakeTableFileName("", file_num) + " level " +
-          ToString(input_file_level) + " > output level " +
-          ToString(output_level));
-    }
  }

  return Status::OK();
@@ -650,7 +650,7 @@ TEST_F(CompactionPickerTest, UniversalPeriodicCompaction3) {

 TEST_F(CompactionPickerTest, UniversalPeriodicCompaction4) {
  // The case where universal periodic compaction couldn't form
-  // a compaction that includes any file marked for periodic compaction.
+  // a compaction that inlcudes any file marked for periodic compaction.
  // Right now we form the compaction anyway if it is more than one
  // sorted run. Just put the case here to validate that it doesn't
  // crash.
@@ -800,7 +800,7 @@ TEST_F(CompactionPickerTest, CompactionPriMinOverlapping2) {
  Add(2, 6U, "150", "175",
      60000000U);  // Overlaps with file 26, 27, total size 521M
  Add(2, 7U, "176", "200", 60000000U);  // Overlaps with file 27, 28, total size
-                                        // 520M, the smallest overlapping
+                                        // 520M, the smalelst overlapping
  Add(2, 8U, "201", "300",
      60000000U);  // Overlaps with file 28, 29, total size 521M

@@ -1228,7 +1228,7 @@ TEST_F(CompactionPickerTest, NotScheduleL1IfL0WithHigherPri1) {
  Add(0, 32U, "001", "400", 1000000000U, 0, 0);
  Add(0, 33U, "001", "400", 1000000000U, 0, 0);

-  // L1 total size 2GB, score 2.2. If one file being compacted, score 1.1.
+  // L1 total size 2GB, score 2.2. If one file being comapcted, score 1.1.
  Add(1, 4U, "050", "300", 1000000000U, 0, 0);
  file_map_[4u].first->being_compacted = true;
  Add(1, 5U, "301", "350", 1000000000U, 0, 0);
@@ -1261,7 +1261,7 @@ TEST_F(CompactionPickerTest, NotScheduleL1IfL0WithHigherPri2) {
  Add(0, 32U, "001", "400", 1000000000U, 0, 0);
  Add(0, 33U, "001", "400", 1000000000U, 0, 0);

-  // L1 total size 2GB, score 2.2. If one file being compacted, score 1.1.
+  // L1 total size 2GB, score 2.2. If one file being comapcted, score 1.1.
  Add(1, 4U, "050", "300", 1000000000U, 0, 0);
  Add(1, 5U, "301", "350", 1000000000U, 0, 0);

@@ -733,7 +733,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
 }

 // Look at overall size amplification. If size amplification
-// exceeds the configured value, then do a compaction
+// exceeeds the configured value, then do a compaction
 // of the candidate files all the way upto the earliest
 // base file (overrides configured values of file-size ratios,
 // min_merge_width and max_merge_width).
@@ -2820,7 +2820,6 @@ class DBBasicTestMultiGet : public DBTestBase {

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

-    using Cache::Insert;
    Status Insert(const Slice& key, void* value, size_t charge,
                  void (*deleter)(const Slice& key, void* value),
                  Handle** handle = nullptr,
@@ -2829,7 +2828,6 @@ class DBBasicTestMultiGet : public DBTestBase {
      return target_->Insert(key, value, charge, deleter, handle, priority);
    }

-    using Cache::Lookup;
    Handle* Lookup(const Slice& key, Statistics* stats = nullptr) override {
      num_lookups_++;
      Handle* handle = target_->Lookup(key, stats);
@@ -446,7 +446,6 @@ class MockCache : public LRUCache {
                 false /*strict_capacity_limit*/, 0.0 /*high_pri_pool_ratio*/) {
  }

-  using ShardedCache::Insert;
  Status Insert(const Slice& key, void* value, size_t charge,
                void (*deleter)(const Slice& key, void* value), Handle** handle,
                Priority priority) override {
@@ -534,7 +533,6 @@ class LookupLiarCache : public CacheWrapper {
  explicit LookupLiarCache(std::shared_ptr<Cache> target)
      : CacheWrapper(std::move(target)) {}

-  using Cache::Lookup;
  Handle* Lookup(const Slice& key, Statistics* stats) override {
    if (nth_lookup_not_found_ == 1) {
      nth_lookup_not_found_ = 0;
@@ -810,7 +810,6 @@ class TestingContextCustomFilterPolicy
 TEST_F(DBBloomFilterTest, ContextCustomFilterPolicy) {
  for (bool fifo : {true, false}) {
    Options options = CurrentOptions();
-    options.max_open_files = fifo ? -1 : options.max_open_files;
    options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
    options.compaction_style =
        fifo ? kCompactionStyleFIFO : kCompactionStyleLevel;
@@ -821,7 +820,6 @@ TEST_F(DBBloomFilterTest, ContextCustomFilterPolicy) {
    table_options.format_version = 5;
    options.table_factory.reset(NewBlockBasedTableFactory(table_options));

-    TryReopen(options);
    CreateAndReopenWithCF({fifo ? "abe" : "bob"}, options);

    const int maxKey = 10000;
@@ -166,66 +166,6 @@ TEST_F(DBFlushTest, FlushInLowPriThreadPool) {
  ASSERT_EQ(1, num_compactions);
 }

-// Test when flush job is submitted to low priority thread pool and when DB is
-// closed in the meanwhile, CloseHelper doesn't hang.
-TEST_F(DBFlushTest, CloseDBWhenFlushInLowPri) {
-  Options options = CurrentOptions();
-  options.max_background_flushes = 1;
-  options.max_total_wal_size = 8192;
-
-  DestroyAndReopen(options);
-  CreateColumnFamilies({"cf1", "cf2"}, options);
-
-  env_->SetBackgroundThreads(0, Env::HIGH);
-  env_->SetBackgroundThreads(1, Env::LOW);
-  test::SleepingBackgroundTask sleeping_task_low;
-  int num_flushes = 0;
-
-  SyncPoint::GetInstance()->SetCallBack("DBImpl::BGWorkFlush",
-                                        [&](void* /*arg*/) { ++num_flushes; });
-
-  int num_low_flush_unscheduled = 0;
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::UnscheduleLowFlushCallback", [&](void* /*arg*/) {
-        num_low_flush_unscheduled++;
-        // There should be one flush job in low pool that needs to be
-        // unscheduled
-        ASSERT_EQ(num_low_flush_unscheduled, 1);
-      });
-
-  int num_high_flush_unscheduled = 0;
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::UnscheduleHighFlushCallback", [&](void* /*arg*/) {
-        num_high_flush_unscheduled++;
-        // There should be no flush job in high pool
-        ASSERT_EQ(num_high_flush_unscheduled, 0);
-      });
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(Put(0, "key1", DummyString(8192)));
-  // Block thread so that flush cannot be run and can be removed from the queue
-  // when called Unschedule.
-  env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
-                 Env::Priority::LOW);
-  sleeping_task_low.WaitUntilSleeping();
-
-  // Trigger flush and flush job will be scheduled to LOW priority thread.
-  ASSERT_OK(Put(0, "key2", DummyString(8192)));
-
-  // Close DB and flush job in low priority queue will be removed without
-  // running.
-  Close();
-  sleeping_task_low.WakeUp();
-  sleeping_task_low.WaitUntilDone();
-  ASSERT_EQ(0, num_flushes);
-
-  TryReopenWithColumnFamilies({"default", "cf1", "cf2"}, options);
-  ASSERT_OK(Put(0, "key3", DummyString(8192)));
-  ASSERT_OK(Flush(0));
-  ASSERT_EQ(1, num_flushes);
-}
-
 TEST_F(DBFlushTest, ManualFlushWithMinWriteBufferNumberToMerge) {
  Options options = CurrentOptions();
  options.write_buffer_size = 100;
@@ -146,11 +146,10 @@ void DumpSupportInfo(Logger* logger) {
 }  // namespace

 DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
-               const bool seq_per_batch, const bool batch_per_txn,
-               bool read_only)
+               const bool seq_per_batch, const bool batch_per_txn)
    : dbname_(dbname),
      own_info_log_(options.info_log == nullptr),
-      initial_db_options_(SanitizeOptions(dbname, options, read_only)),
+      initial_db_options_(SanitizeOptions(dbname, options)),
      env_(initial_db_options_.env),
      io_tracer_(std::make_shared<IOTracer>()),
      immutable_db_options_(initial_db_options_),
@@ -160,17 +159,14 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      mutex_(stats_, immutable_db_options_.clock, DB_MUTEX_WAIT_MICROS,
             immutable_db_options_.use_adaptive_mutex),
      default_cf_handle_(nullptr),
-      error_handler_(this, immutable_db_options_, &mutex_),
-      event_logger_(immutable_db_options_.info_log.get()),
      max_total_in_memory_state_(0),
      file_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
      file_options_for_compaction_(fs_->OptimizeForCompactionTableWrite(
          file_options_, immutable_db_options_)),
      seq_per_batch_(seq_per_batch),
      batch_per_txn_(batch_per_txn),
-      next_job_id_(1),
-      shutting_down_(false),
      db_lock_(nullptr),
+      shutting_down_(false),
      manual_compaction_paused_(false),
      bg_cv_(&mutex_),
      logfile_number_(0),
@@ -197,6 +193,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      pending_purge_obsolete_files_(0),
      delete_obsolete_files_last_run_(immutable_db_options_.clock->NowMicros()),
      last_stats_dump_time_microsec_(0),
+      next_job_id_(1),
      has_unpersisted_data_(false),
      unable_to_release_oldest_log_(false),
      num_running_ingest_file_(0),
@@ -204,6 +201,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      wal_manager_(immutable_db_options_, file_options_, io_tracer_,
                   seq_per_batch),
 #endif  // ROCKSDB_LITE
+      event_logger_(immutable_db_options_.info_log.get()),
      bg_work_paused_(0),
      bg_compaction_paused_(0),
      refitting_level_(false),
@@ -232,6 +230,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      own_sfm_(options.sst_file_manager == nullptr),
      preserve_deletes_(options.preserve_deletes),
      closed_(false),
+      error_handler_(this, immutable_db_options_, &mutex_),
      atomic_flush_install_cv_(&mutex_),
      blob_callback_(immutable_db_options_.sst_file_manager.get(), &mutex_,
                     &error_handler_) {
@@ -270,10 +269,6 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
  // we won't drop any deletion markers until SetPreserveDeletesSequenceNumber()
  // is called by client and this seqnum is advanced.
  preserve_deletes_seqnum_.store(0);
-
-  if (write_buffer_manager_) {
-    wbm_stall_.reset(new WBMStallInterface());
-  }
 }

 Status DBImpl::Resume() {
@@ -527,11 +522,15 @@ Status DBImpl::CloseHelper() {
  // marker. After this we do a variant of the waiting and unschedule work
  // (to consider: moving all the waiting into CancelAllBackgroundWork(true))
  CancelAllBackgroundWork(false);
-  mutex_.Lock();
-  env_->UnSchedule(this, Env::Priority::BOTTOM);
-  env_->UnSchedule(this, Env::Priority::LOW);
-  env_->UnSchedule(this, Env::Priority::HIGH);
+  int bottom_compactions_unscheduled =
+      env_->UnSchedule(this, Env::Priority::BOTTOM);
+  int compactions_unscheduled = env_->UnSchedule(this, Env::Priority::LOW);
+  int flushes_unscheduled = env_->UnSchedule(this, Env::Priority::HIGH);
  Status ret = Status::OK();
+  mutex_.Lock();
+  bg_bottom_compaction_scheduled_ -= bottom_compactions_unscheduled;
+  bg_compaction_scheduled_ -= compactions_unscheduled;
+  bg_flush_scheduled_ -= flushes_unscheduled;

  // Wait for background work to finish
  while (bg_bottom_compaction_scheduled_ || bg_compaction_scheduled_ ||
@@ -664,10 +663,6 @@ Status DBImpl::CloseHelper() {
    }
  }

-  if (write_buffer_manager_ && wbm_stall_) {
-    write_buffer_manager_->RemoveDBFromQueue(wbm_stall_.get());
-  }
-
  if (ret.IsAborted()) {
    // Reserve IsAborted() error for those where users didn't release
    // certain resource and they can release them and come back and
@@ -697,8 +692,8 @@ void DBImpl::MaybeIgnoreError(Status* s) const {
 }

 const Status DBImpl::CreateArchivalDirectory() {
-  if (immutable_db_options_.WAL_ttl_seconds > 0 ||
-      immutable_db_options_.WAL_size_limit_MB > 0) {
+  if (immutable_db_options_.wal_ttl_seconds > 0 ||
+      immutable_db_options_.wal_size_limit_mb > 0) {
    std::string archivalPath = ArchivalDirectory(immutable_db_options_.wal_dir);
    return env_->CreateDirIfMissing(archivalPath);
  }
@@ -3154,7 +3149,7 @@ SystemClock* DBImpl::GetSystemClock() const {

 #ifndef ROCKSDB_LITE

-Status DBImpl::StartIOTrace(const TraceOptions& trace_options,
+Status DBImpl::StartIOTrace(Env* /*env*/, const TraceOptions& trace_options,
                            std::unique_ptr<TraceWriter>&& trace_writer) {
  assert(trace_writer != nullptr);
  return io_tracer_->StartIOTrace(GetSystemClock(), trace_options,
@@ -129,8 +129,7 @@ class Directories {
 class DBImpl : public DB {
 public:
  DBImpl(const DBOptions& options, const std::string& dbname,
-         const bool seq_per_batch = false, const bool batch_per_txn = true,
-         bool read_only = false);
+         const bool seq_per_batch = false, const bool batch_per_txn = true);
  // No copying allowed
  DBImpl(const DBImpl&) = delete;
  void operator=(const DBImpl&) = delete;
@@ -470,7 +469,7 @@ class DBImpl : public DB {
  Status EndBlockCacheTrace() override;

  using DB::StartIOTrace;
-  Status StartIOTrace(const TraceOptions& options,
+  Status StartIOTrace(Env* env, const TraceOptions& options,
                      std::unique_ptr<TraceWriter>&& trace_writer) override;

  using DB::EndIOTrace;
@@ -1048,56 +1047,6 @@ class DBImpl : public DB {
  // flush LOG out of application buffer
  void FlushInfoLog();

-  // Interface to block and signal the DB in case of stalling writes by
-  // WriteBufferManager. Each DBImpl object contains ptr to WBMStallInterface.
-  // When DB needs to be blocked or signalled by WriteBufferManager,
-  // state_ is changed accordingly.
-  class WBMStallInterface : public StallInterface {
-   public:
-    enum State {
-      BLOCKED = 0,
-      RUNNING,
-    };
-
-    WBMStallInterface() : state_cv_(&state_mutex_) {
-      MutexLock lock(&state_mutex_);
-      state_ = State::RUNNING;
-    }
-
-    void SetState(State state) {
-      MutexLock lock(&state_mutex_);
-      state_ = state;
-    }
-
-    // Change the state_ to State::BLOCKED and wait until its state is
-    // changed by WriteBufferManager. When stall is cleared, Signal() is
-    // called to change the state and unblock the DB.
-    void Block() override {
-      MutexLock lock(&state_mutex_);
-      while (state_ == State::BLOCKED) {
-        TEST_SYNC_POINT("WBMStallInterface::BlockDB");
-        state_cv_.Wait();
-      }
-    }
-
-    // Called from WriteBufferManager. This function changes the state_
-    // to State::RUNNING indicating the stall is cleared and DB can proceed.
-    void Signal() override {
-      MutexLock lock(&state_mutex_);
-      state_ = State::RUNNING;
-      state_cv_.Signal();
-    }
-
-   private:
-    // Conditional variable and mutex to block and
-    // signal the DB during stalling process.
-    port::Mutex state_mutex_;
-    port::CondVar state_cv_;
-    // state represting whether DB is running or blocked because of stall by
-    // WriteBufferManager.
-    State state_;
-  };
-
 protected:
  const std::string dbname_;
  std::string db_id_;
@@ -1130,14 +1079,6 @@ class DBImpl : public DB {
  ColumnFamilyHandleImpl* default_cf_handle_;
  InternalStats* default_cf_internal_stats_;

-  // table_cache_ provides its own synchronization
-  std::shared_ptr<Cache> table_cache_;
-
-  ErrorHandler error_handler_;
-
-  // Unified interface for logging events
-  EventLogger event_logger_;
-
  // only used for dynamically adjusting max_total_wal_size. it is a sum of
  // [write_buffer_size * max_write_buffer_number] over all column families
  uint64_t max_total_in_memory_state_;
@@ -1168,12 +1109,6 @@ class DBImpl : public DB {
  // Default: true
  const bool batch_per_txn_;

-  // Each flush or compaction gets its own job id. this counter makes sure
-  // they're unique
-  std::atomic<int> next_job_id_;
-
-  std::atomic<bool> shutting_down_;
-
  // Except in DB::Open(), WriteOptionsFile can only be called when:
  // Persist options to options file.
  // If need_mutex_lock = false, the method will lock DB mutex.
@@ -1301,7 +1236,7 @@ class DBImpl : public DB {
  virtual bool OwnTablesAndLogs() const { return true; }

  // Set DB identity file, and write DB ID to manifest if necessary.
-  Status SetDBId(bool read_only);
+  Status SetDBId();

  // REQUIRES: db mutex held when calling this function, but the db mutex can
  // be released and re-acquired. Db mutex will be held when the function
@@ -1373,7 +1308,6 @@ class DBImpl : public DB {

  struct LogFileNumberSize {
    explicit LogFileNumberSize(uint64_t _number) : number(_number) {}
-    LogFileNumberSize() {}
    void AddSize(uint64_t new_size) { size += new_size; }
    uint64_t number;
    uint64_t size = 0;
@@ -1479,7 +1413,6 @@ class DBImpl : public DB {
    DBImpl* db;
    // background compaction takes ownership of `prepicked_compaction`.
    PrepickedCompaction* prepicked_compaction;
-    Env::Priority compaction_pri_;
  };

  // Initialize the built-in column family for persistent stats. Depending on
@@ -1574,12 +1507,6 @@ class DBImpl : public DB {
  Status WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
                                     MemTable* mem, VersionEdit* edit);

-  // Get the size of a log file and, if truncate is true, truncate the
-  // log file to its actual size, thereby freeing preallocated space.
-  // Return success even if truncate fails
-  Status GetLogSizeAndMaybeTruncate(uint64_t wal_number, bool truncate,
-                                    LogFileNumberSize* log);
-
  // Restore alive_log_files_ and total_log_size_ after recovery.
  // It needs to run only when there's no flush during recovery
  // (e.g. avoid_flush_during_recovery=true). May also trigger flush
@@ -1590,10 +1517,6 @@ class DBImpl : public DB {
  //            `num_bytes` going through.
  Status DelayWrite(uint64_t num_bytes, const WriteOptions& write_options);

-  // Begin stalling of writes when memory usage increases beyond a certain
-  // threshold.
-  void WriteBufferManagerStallWrites();
-
  Status ThrottleLowPriWritesIfNeeded(const WriteOptions& write_options,
                                      WriteBatch* my_batch);

@@ -1673,7 +1596,7 @@ class DBImpl : public DB {
  Status SwitchWAL(WriteContext* write_context);

  // REQUIRES: mutex locked and in write thread.
-  Status HandleWriteBufferManagerFlush(WriteContext* write_context);
+  Status HandleWriteBufferFull(WriteContext* write_context);

  // REQUIRES: mutex locked
  Status PreprocessWrite(const WriteOptions& write_options, bool* need_log_sync,
@@ -1954,6 +1877,9 @@ class DBImpl : public DB {

  Status IncreaseFullHistoryTsLow(ColumnFamilyData* cfd, std::string ts_low);

+  // table_cache_ provides its own synchronization
+  std::shared_ptr<Cache> table_cache_;
+
  // Lock over the persistent DB state.  Non-nullptr iff successfully acquired.
  FileLock* db_lock_;

@@ -1967,6 +1893,8 @@ class DBImpl : public DB {
  // mutex_, the order should be first mutex_ and then log_write_mutex_.
  InstrumentedMutex log_write_mutex_;

+  std::atomic<bool> shutting_down_;
+
  // If zero, manual compactions are allowed to proceed. If non-zero, manual
  // compactions may still be running, but will quickly fail with
  // `Status::Incomplete`. The value indicates how many threads have paused
@@ -2175,6 +2103,10 @@ class DBImpl : public DB {
  // Number of threads intending to write to memtable
  std::atomic<size_t> pending_memtable_writes_ = {};

+  // Each flush or compaction gets its own job id. this counter makes sure
+  // they're unique
+  std::atomic<int> next_job_id_;
+
  // A flag indicating whether the current rocksdb database has any
  // data that is not yet persisted into either WAL or SST file.
  // Used when disableWAL is true.
@@ -2203,6 +2135,9 @@ class DBImpl : public DB {
  WalManager wal_manager_;
 #endif  // ROCKSDB_LITE

+  // Unified interface for logging events
+  EventLogger event_logger_;
+
  // A value of > 0 temporarily disables scheduling of background work
  int bg_work_paused_;

@@ -2270,6 +2205,8 @@ class DBImpl : public DB {
  // Flag to check whether Close() has been called on this DB
  bool closed_;

+  ErrorHandler error_handler_;
+
  // Conditional variable to coordinate installation of atomic flush results.
  // With atomic flush, each bg thread installs the result of flushing multiple
  // column families, and different threads can flush different column
@@ -2284,16 +2221,11 @@ class DBImpl : public DB {
  bool wal_in_db_path_;

  BlobFileCompletionCallback blob_callback_;
-
-  // Pointer to WriteBufferManager stalling interface.
-  std::unique_ptr<StallInterface> wbm_stall_;
 };

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

-extern DBOptions SanitizeOptions(const std::string& db, const DBOptions& src,
-                                 bool read_only = false);
+extern DBOptions SanitizeOptions(const std::string& db, const DBOptions& src);

 extern CompressionType GetCompressionFlush(
    const ImmutableCFOptions& ioptions,
@@ -803,10 +803,6 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
                            ColumnFamilyHandle* column_family,
                            const Slice* begin_without_ts,
                            const Slice* end_without_ts) {
-  if (manual_compaction_paused_.load(std::memory_order_acquire) > 0) {
-    return Status::Incomplete(Status::SubCode::kManualCompactionPaused);
-  }
-
  const Comparator* const ucmp = column_family->GetComparator();
  assert(ucmp);
  size_t ts_sz = ucmp->timestamp_size();
@@ -1745,7 +1741,6 @@ Status DBImpl::RunManualCompaction(
      }
      ca = new CompactionArg;
      ca->db = this;
-      ca->compaction_pri_ = Env::Priority::LOW;
      ca->prepicked_compaction = new PrepickedCompaction;
      ca->prepicked_compaction->manual_compaction_state = &manual;
      ca->prepicked_compaction->compaction = compaction;
@@ -2277,7 +2272,6 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
         unscheduled_compactions_ > 0) {
    CompactionArg* ca = new CompactionArg;
    ca->db = this;
-    ca->compaction_pri_ = Env::Priority::LOW;
    ca->prepicked_compaction = nullptr;
    bg_compaction_scheduled_++;
    unscheduled_compactions_--;
@@ -2465,16 +2459,7 @@ void DBImpl::BGWorkPurge(void* db) {
 }

 void DBImpl::UnscheduleCompactionCallback(void* arg) {
-  CompactionArg* ca_ptr = reinterpret_cast<CompactionArg*>(arg);
-  Env::Priority compaction_pri = ca_ptr->compaction_pri_;
-  if (Env::Priority::BOTTOM == compaction_pri) {
-    // Decrement bg_bottom_compaction_scheduled_ if priority is BOTTOM
-    ca_ptr->db->bg_bottom_compaction_scheduled_--;
-  } else if (Env::Priority::LOW == compaction_pri) {
-    // Decrement bg_compaction_scheduled_ if priority is LOW
-    ca_ptr->db->bg_compaction_scheduled_--;
-  }
-  CompactionArg ca = *(ca_ptr);
+  CompactionArg ca = *(reinterpret_cast<CompactionArg*>(arg));
  delete reinterpret_cast<CompactionArg*>(arg);
  if (ca.prepicked_compaction != nullptr) {
    if (ca.prepicked_compaction->compaction != nullptr) {
@@ -2486,14 +2471,6 @@ void DBImpl::UnscheduleCompactionCallback(void* arg) {
 }

 void DBImpl::UnscheduleFlushCallback(void* arg) {
-  // Decrement bg_flush_scheduled_ in flush callback
-  reinterpret_cast<FlushThreadArg*>(arg)->db_->bg_flush_scheduled_--;
-  Env::Priority flush_pri = reinterpret_cast<FlushThreadArg*>(arg)->thread_pri_;
-  if (Env::Priority::LOW == flush_pri) {
-    TEST_SYNC_POINT("DBImpl::UnscheduleLowFlushCallback");
-  } else if (Env::Priority::HIGH == flush_pri) {
-    TEST_SYNC_POINT("DBImpl::UnscheduleHighFlushCallback");
-  }
  delete reinterpret_cast<FlushThreadArg*>(arg);
  TEST_SYNC_POINT("DBImpl::UnscheduleFlushCallback");
 }
@@ -3098,7 +3075,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    TEST_SYNC_POINT("DBImpl::BackgroundCompaction:ForwardToBottomPriPool");
    CompactionArg* ca = new CompactionArg;
    ca->db = this;
-    ca->compaction_pri_ = Env::Priority::BOTTOM;
    ca->prepicked_compaction = new PrepickedCompaction;
    ca->prepicked_compaction->compaction = c.release();
    ca->prepicked_compaction->manual_compaction_state = nullptr;
@@ -558,8 +558,8 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
    }

 #ifndef ROCKSDB_LITE
-    if (type == kWalFile && (immutable_db_options_.WAL_ttl_seconds > 0 ||
-                             immutable_db_options_.WAL_size_limit_MB > 0)) {
+    if (type == kWalFile && (immutable_db_options_.wal_ttl_seconds > 0 ||
+                             immutable_db_options_.wal_size_limit_mb > 0)) {
      wal_manager_.ArchiveWALFile(fname, number);
      continue;
    }
@@ -854,7 +854,7 @@ uint64_t PrecomputeMinLogNumberToKeep2PC(
  return min_log_number_to_keep;
 }

-Status DBImpl::SetDBId(bool read_only) {
+Status DBImpl::SetDBId() {
  Status s;
  // Happens when immutable_db_options_.write_dbid_to_manifest is set to true
  // the very first time.
@@ -865,15 +865,9 @@ Status DBImpl::SetDBId(bool read_only) {
    // it is no longer available then at this point DB ID is not in Identity
    // file or Manifest.
    if (s.IsNotFound()) {
-      // Create a new DB ID, saving to file only if allowed
-      if (read_only) {
-        db_id_ = env_->GenerateUniqueId();
-        return Status::OK();
-      } else {
-        s = SetIdentityFile(env_, dbname_);
-        if (!s.ok()) {
-          return s;
-        }
+      s = SetIdentityFile(env_, dbname_);
+      if (!s.ok()) {
+        return s;
      }
    } else if (!s.ok()) {
      assert(s.IsIOError());
@@ -890,7 +884,7 @@ Status DBImpl::SetDBId(bool read_only) {
                                 mutable_cf_options, &edit, &mutex_, nullptr,
                                 /* new_descriptor_log */ false);
    }
-  } else if (!read_only) {
+  } else {
    s = SetIdentityFile(env_, dbname_, db_id_);
  }
  return s;
@@ -24,17 +24,15 @@
 #include "util/rate_limiter.h"

 namespace ROCKSDB_NAMESPACE {
-Options SanitizeOptions(const std::string& dbname, const Options& src,
-                        bool read_only) {
-  auto db_options = SanitizeOptions(dbname, DBOptions(src), read_only);
+Options SanitizeOptions(const std::string& dbname, const Options& src) {
+  auto db_options = SanitizeOptions(dbname, DBOptions(src));
  ImmutableDBOptions immutable_db_options(db_options);
  auto cf_options =
      SanitizeOptions(immutable_db_options, ColumnFamilyOptions(src));
  return Options(db_options, cf_options);
 }

-DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src,
-                          bool read_only) {
+DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src) {
  DBOptions result(src);

  if (result.env == nullptr) {
@@ -52,7 +50,7 @@ DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src,
                             &result.max_open_files);
  }

-  if (result.info_log == nullptr && !read_only) {
+  if (result.info_log == nullptr) {
    Status s = CreateLoggerFromOptions(dbname, result, &result.info_log);
    if (!s.ok()) {
      // No place suitable for logging
@@ -493,7 +491,7 @@ Status DBImpl::Recover(
  if (!s.ok()) {
    return s;
  }
-  s = SetDBId(read_only);
+  s = SetDBId();
  if (s.ok() && !read_only) {
    s = DeleteUnreferencedSstFiles();
  }
@@ -1252,16 +1250,8 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
    }
  }

-  if (status.ok()) {
-    if (data_seen && !flushed) {
-      status = RestoreAliveLogFiles(wal_numbers);
-    } else {
-      // If there's no data in the WAL, or we flushed all the data, still
-      // truncate the log file. If the process goes into a crash loop before
-      // the file is deleted, the preallocated space will never get freed.
-      GetLogSizeAndMaybeTruncate(wal_numbers.back(), true, nullptr)
-          .PermitUncheckedError();
-    }
+  if (status.ok() && data_seen && !flushed) {
+    status = RestoreAliveLogFiles(wal_numbers);
  }

  event_logger_.Log() << "job" << job_id << "event"
@@ -1270,40 +1260,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
  return status;
 }

-Status DBImpl::GetLogSizeAndMaybeTruncate(uint64_t wal_number, bool truncate,
-                                          LogFileNumberSize* log_ptr) {
-  LogFileNumberSize log(wal_number);
-  std::string fname = LogFileName(immutable_db_options_.wal_dir, wal_number);
-  Status s;
-  // This gets the appear size of the wals, not including preallocated space.
-  s = env_->GetFileSize(fname, &log.size);
-  if (s.ok() && truncate) {
-    std::unique_ptr<FSWritableFile> last_log;
-    Status truncate_status = fs_->ReopenWritableFile(
-        fname,
-        fs_->OptimizeForLogWrite(
-            file_options_,
-            BuildDBOptions(immutable_db_options_, mutable_db_options_)),
-        &last_log, nullptr);
-    if (truncate_status.ok()) {
-      truncate_status = last_log->Truncate(log.size, IOOptions(), nullptr);
-    }
-    if (truncate_status.ok()) {
-      truncate_status = last_log->Close(IOOptions(), nullptr);
-    }
-    // Not a critical error if fail to truncate.
-    if (!truncate_status.ok()) {
-      ROCKS_LOG_WARN(immutable_db_options_.info_log,
-                     "Failed to truncate log #%" PRIu64 ": %s", wal_number,
-                     truncate_status.ToString().c_str());
-    }
-  }
-  if (log_ptr) {
-    *log_ptr = log;
-  }
-  return s;
-}
-
 Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
  if (wal_numbers.empty()) {
    return Status::OK();
@@ -1319,17 +1275,39 @@ Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
  total_log_size_ = 0;
  log_empty_ = false;
  for (auto wal_number : wal_numbers) {
-    // We preallocate space for wals, but then after a crash and restart, those
-    // preallocated space are not needed anymore. It is likely only the last
-    // log has such preallocated space, so we only truncate for the last log.
-    LogFileNumberSize log;
-    s = GetLogSizeAndMaybeTruncate(
-        wal_number, /*truncate=*/(wal_number == wal_numbers.back()), &log);
+    LogFileNumberSize log(wal_number);
+    std::string fname = LogFileName(immutable_db_options_.wal_dir, wal_number);
+    // This gets the appear size of the wals, not including preallocated space.
+    s = env_->GetFileSize(fname, &log.size);
    if (!s.ok()) {
      break;
    }
    total_log_size_ += log.size;
    alive_log_files_.push_back(log);
+    // We preallocate space for wals, but then after a crash and restart, those
+    // preallocated space are not needed anymore. It is likely only the last
+    // log has such preallocated space, so we only truncate for the last log.
+    if (wal_number == wal_numbers.back()) {
+      std::unique_ptr<FSWritableFile> last_log;
+      Status truncate_status = fs_->ReopenWritableFile(
+          fname,
+          fs_->OptimizeForLogWrite(
+              file_options_,
+              BuildDBOptions(immutable_db_options_, mutable_db_options_)),
+          &last_log, nullptr);
+      if (truncate_status.ok()) {
+        truncate_status = last_log->Truncate(log.size, IOOptions(), nullptr);
+      }
+      if (truncate_status.ok()) {
+        truncate_status = last_log->Close(IOOptions(), nullptr);
+      }
+      // Not a critical error if fail to truncate.
+      if (!truncate_status.ok()) {
+        ROCKS_LOG_WARN(immutable_db_options_.info_log,
+                       "Failed to truncate log #%" PRIu64 ": %s", wal_number,
+                       truncate_status.ToString().c_str());
+      }
+    }
  }
  if (two_write_queues_) {
    log_write_mutex_.Unlock();
@@ -1401,10 +1379,11 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
          cfd->GetID(), cfd->GetName(), snapshot_seqs,
          earliest_write_conflict_snapshot, snapshot_checker,
          GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
+          mutable_cf_options.sample_for_compression,
          mutable_cf_options.compression_opts, paranoid_file_checks,
          cfd->internal_stats(), TableFileCreationReason::kRecovery, &io_s,
          io_tracer_, &event_logger_, job_id, Env::IO_HIGH,
-          nullptr /* table_properties */, 0 /* level */, current_time,
+          nullptr /* table_properties */, -1 /* level */, current_time,
          0 /* oldest_key_time */, write_hint, 0 /* file_creation_time */,
          db_id_, db_session_id_, nullptr /*full_history_ts_low*/,
          &blob_callback_);
@@ -6,7 +6,7 @@
 #include "db/db_impl/db_impl_readonly.h"

 #include "db/arena_wrapped_db_iter.h"
-#include "db/db_impl/compacted_db_impl.h"
+#include "db/compacted_db_impl.h"
 #include "db/db_impl/db_impl.h"
 #include "db/db_iter.h"
 #include "db/merge_context.h"
@@ -19,8 +19,7 @@ namespace ROCKSDB_NAMESPACE {

 DBImplReadOnly::DBImplReadOnly(const DBOptions& db_options,
                               const std::string& dbname)
-    : DBImpl(db_options, dbname, /*seq_per_batch*/ false,
-             /*batch_per_txn*/ true, /*read_only*/ true) {
+    : DBImpl(db_options, dbname) {
  ROCKS_LOG_INFO(immutable_db_options_.info_log,
                 "Opening the db in read only mode");
  LogFlush(immutable_db_options_.info_log);
@@ -132,8 +131,8 @@ Status DBImplReadOnly::NewIterators(
 }

 namespace {
-// Return OK if dbname exists in the file system or create it if
-// create_if_missing
+// Return OK if dbname exists in the file system
+// or create_if_missing is false
 Status OpenForReadOnlyCheckExistence(const DBOptions& db_options,
                                     const std::string& dbname) {
  Status s;
@@ -144,9 +143,6 @@ Status OpenForReadOnlyCheckExistence(const DBOptions& db_options,
    uint64_t manifest_file_number;
    s = VersionSet::GetCurrentManifestPath(dbname, fs.get(), &manifest_path,
                                           &manifest_file_number);
-  } else {
-    // Historic behavior that doesn't necessarily make sense
-    s = db_options.env->CreateDirIfMissing(dbname);
  }
  return s;
 }
@@ -154,6 +150,7 @@ Status OpenForReadOnlyCheckExistence(const DBOptions& db_options,

 Status DB::OpenForReadOnly(const Options& options, const std::string& dbname,
                           DB** dbptr, bool /*error_if_wal_file_exists*/) {
+  // If dbname does not exist in the file system, should not do anything
  Status s = OpenForReadOnlyCheckExistence(options, dbname);
  if (!s.ok()) {
    return s;
@@ -17,10 +17,8 @@ namespace ROCKSDB_NAMESPACE {

 #ifndef ROCKSDB_LITE
 DBImplSecondary::DBImplSecondary(const DBOptions& db_options,
-                                 const std::string& dbname,
-                                 std::string secondary_path)
-    : DBImpl(db_options, dbname, false, true, true),
-      secondary_path_(std::move(secondary_path)) {
+                                 const std::string& dbname)
+    : DBImpl(db_options, dbname) {
  ROCKS_LOG_INFO(immutable_db_options_.info_log,
                 "Opening the db in secondary mode");
  LogFlush(immutable_db_options_.info_log);
@@ -619,7 +617,7 @@ Status DB::OpenAsSecondary(
  }

  handles->clear();
-  DBImplSecondary* impl = new DBImplSecondary(tmp_opts, dbname, secondary_path);
+  DBImplSecondary* impl = new DBImplSecondary(tmp_opts, dbname);
  impl->versions_.reset(new ReactiveVersionSet(
      dbname, &impl->immutable_db_options_, impl->file_options_,
      impl->table_cache_.get(), impl->write_buffer_manager_,
@@ -665,86 +663,6 @@ Status DB::OpenAsSecondary(
  }
  return s;
 }
-
-Status DBImplSecondary::CompactWithoutInstallation(
-    ColumnFamilyHandle* cfh, const CompactionServiceInput& input,
-    CompactionServiceResult* result) {
-  InstrumentedMutexLock l(&mutex_);
-  auto cfd = static_cast_with_check<ColumnFamilyHandleImpl>(cfh)->cfd();
-  if (!cfd) {
-    return Status::InvalidArgument("Cannot find column family" +
-                                   cfh->GetName());
-  }
-
-  std::unordered_set<uint64_t> input_set;
-  for (const auto& file_name : input.input_files) {
-    input_set.insert(TableFileNameToNumber(file_name));
-  }
-
-  auto* version = cfd->current();
-
-  ColumnFamilyMetaData cf_meta;
-  version->GetColumnFamilyMetaData(&cf_meta);
-
-  const MutableCFOptions* mutable_cf_options = cfd->GetLatestMutableCFOptions();
-  ColumnFamilyOptions cf_options = cfd->GetLatestCFOptions();
-  VersionStorageInfo* vstorage = version->storage_info();
-
-  // Use comp_options to reuse some CompactFiles functions
-  CompactionOptions comp_options;
-  comp_options.compression = kDisableCompressionOption;
-  comp_options.output_file_size_limit = MaxFileSizeForLevel(
-      *mutable_cf_options, input.output_level, cf_options.compaction_style,
-      vstorage->base_level(), cf_options.level_compaction_dynamic_level_bytes);
-
-  std::vector<CompactionInputFiles> input_files;
-  Status s = cfd->compaction_picker()->GetCompactionInputsFromFileNumbers(
-      &input_files, &input_set, vstorage, comp_options);
-  if (!s.ok()) {
-    return s;
-  }
-
-  std::unique_ptr<Compaction> c;
-  assert(cfd->compaction_picker());
-  c.reset(cfd->compaction_picker()->CompactFiles(
-      comp_options, input_files, input.output_level, vstorage,
-      *mutable_cf_options, mutable_db_options_, 0));
-  assert(c != nullptr);
-
-  c->SetInputVersion(version);
-
-  // Create output directory if it's not existed yet
-  std::unique_ptr<FSDirectory> output_dir;
-  s = CreateAndNewDirectory(fs_.get(), secondary_path_, &output_dir);
-  if (!s.ok()) {
-    return s;
-  }
-
-  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL,
-                       immutable_db_options_.info_log.get());
-
-  const int job_id = next_job_id_.fetch_add(1);
-
-  CompactionServiceCompactionJob compaction_job(
-      job_id, c.get(), immutable_db_options_, file_options_for_compaction_,
-      versions_.get(), &shutting_down_, &log_buffer, output_dir.get(), stats_,
-      &mutex_, &error_handler_, input.snapshots, table_cache_, &event_logger_,
-      dbname_, io_tracer_, db_id_, db_session_id_, secondary_path_, input,
-      result);
-
-  mutex_.Unlock();
-  s = compaction_job.Run();
-  mutex_.Lock();
-
-  // clean up
-  compaction_job.io_status().PermitUncheckedError();
-  compaction_job.CleanupCompaction();
-  c->ReleaseCompactionFiles(s);
-  c.reset();
-
-  return s;
-}
-
 #else   // !ROCKSDB_LITE

 Status DB::OpenAsSecondary(const Options& /*options*/,
@@ -71,8 +71,7 @@ class LogReaderContainer {
 // effort attempts to catch up with the primary.
 class DBImplSecondary : public DBImpl {
 public:
-  DBImplSecondary(const DBOptions& options, const std::string& dbname,
-                  std::string secondary_path);
+  DBImplSecondary(const DBOptions& options, const std::string& dbname);
  ~DBImplSecondary() override;

  // Recover by replaying MANIFEST and WAL. Also initialize manifest_reader_
@@ -223,14 +222,6 @@ class DBImplSecondary : public DBImpl {
  // not flag the missing file as inconsistency.
  Status CheckConsistency() override;

-#ifndef NDEBUG
-  Status TEST_CompactWithoutInstallation(ColumnFamilyHandle* cfh,
-                                         const CompactionServiceInput& input,
-                                         CompactionServiceResult* result) {
-    return CompactWithoutInstallation(cfh, input, result);
-  }
-#endif  // NDEBUG
-
 protected:
  // ColumnFamilyCollector is a write batch handler which does nothing
  // except recording unique column family IDs
@@ -325,13 +316,6 @@ class DBImplSecondary : public DBImpl {
                         std::unordered_set<ColumnFamilyData*>* cfds_changed,
                         JobContext* job_context);

-  // Run compaction without installation, the output files will be placed in the
-  // secondary DB path. The LSM tree won't be changed, the secondary DB is still
-  // in read-only mode.
-  Status CompactWithoutInstallation(ColumnFamilyHandle* cfh,
-                                    const CompactionServiceInput& input,
-                                    CompactionServiceResult* result);
-
  std::unique_ptr<log::FragmentBufferedReader> manifest_reader_;
  std::unique_ptr<log::Reader::Reporter> manifest_reporter_;
  std::unique_ptr<Status> manifest_reader_status_;
@@ -342,8 +326,6 @@ class DBImplSecondary : public DBImpl {

  // Current WAL number replayed for each column family.
  std::unordered_map<ColumnFamilyData*, uint64_t> cfd_to_current_log_;
-
-  const std::string secondary_path_;
 };

 }  // namespace ROCKSDB_NAMESPACE
@@ -937,7 +937,7 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
    // be flushed. We may end up with flushing much more DBs than needed. It's
    // suboptimal but still correct.
    WaitForPendingWrites();
-    status = HandleWriteBufferManagerFlush(write_context);
+    status = HandleWriteBufferFull(write_context);
  }

  if (UNLIKELY(status.ok() && !trim_history_scheduler_.Empty())) {
@@ -964,20 +964,6 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
    PERF_TIMER_START(write_pre_and_post_process_time);
  }

-  // If memory usage exceeded beyond a certain threshold,
-  // write_buffer_manager_->ShouldStall() returns true to all threads writing to
-  // all DBs and writers will be stalled.
-  // It does soft checking because WriteBufferManager::buffer_limit_ has already
-  // exceeded at this point so no new write (including current one) will go
-  // through until memory usage is decreased.
-  if (UNLIKELY(status.ok() && write_buffer_manager_->ShouldStall())) {
-    if (write_options.no_slowdown) {
-      status = Status::Incomplete("Write stall");
-    } else {
-      WriteBufferManagerStallWrites();
-    }
-  }
-
  if (status.ok() && *need_log_sync) {
    // Wait until the parallel syncs are finished. Any sync process has to sync
    // the front log too so it is enough to check the status of front()
@@ -1362,20 +1348,20 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
      if (!immutable_db_options_.atomic_flush) {
        FlushRequest flush_req;
        GenerateFlushRequest({cfd}, &flush_req);
-        SchedulePendingFlush(flush_req, FlushReason::kWalFull);
+        SchedulePendingFlush(flush_req, FlushReason::kWriteBufferManager);
      }
    }
    if (immutable_db_options_.atomic_flush) {
      FlushRequest flush_req;
      GenerateFlushRequest(cfds, &flush_req);
-      SchedulePendingFlush(flush_req, FlushReason::kWalFull);
+      SchedulePendingFlush(flush_req, FlushReason::kWriteBufferManager);
    }
    MaybeScheduleFlushOrCompaction();
  }
  return status;
 }

-Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
+Status DBImpl::HandleWriteBufferFull(WriteContext* write_context) {
  mutex_.AssertHeld();
  assert(write_context != nullptr);
  Status status;
@@ -1387,7 +1373,7 @@ Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
  // suboptimal but still correct.
  ROCKS_LOG_INFO(
      immutable_db_options_.info_log,
-      "Flushing column family with oldest memtable entry. Write buffers are "
+      "Flushing column family with oldest memtable entry. Write buffer is "
      "using %" ROCKSDB_PRIszt " bytes out of a total of %" ROCKSDB_PRIszt ".",
      write_buffer_manager_->memory_usage(),
      write_buffer_manager_->buffer_size());
@@ -1448,13 +1434,13 @@ Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
      if (!immutable_db_options_.atomic_flush) {
        FlushRequest flush_req;
        GenerateFlushRequest({cfd}, &flush_req);
-        SchedulePendingFlush(flush_req, FlushReason::kWriteBufferManager);
+        SchedulePendingFlush(flush_req, FlushReason::kWriteBufferFull);
      }
    }
    if (immutable_db_options_.atomic_flush) {
      FlushRequest flush_req;
      GenerateFlushRequest(cfds, &flush_req);
-      SchedulePendingFlush(flush_req, FlushReason::kWriteBufferManager);
+      SchedulePendingFlush(flush_req, FlushReason::kWriteBufferFull);
    }
    MaybeScheduleFlushOrCompaction();
  }
@@ -1550,29 +1536,6 @@ Status DBImpl::DelayWrite(uint64_t num_bytes,
  return s;
 }

-// REQUIRES: mutex_ is held
-// REQUIRES: this thread is currently at the front of the writer queue
-void DBImpl::WriteBufferManagerStallWrites() {
-  mutex_.AssertHeld();
-  // First block future writer threads who want to add themselves to the queue
-  // of WriteThread.
-  write_thread_.BeginWriteStall();
-  mutex_.Unlock();
-
-  // Change the state to State::Blocked.
-  static_cast<WBMStallInterface*>(wbm_stall_.get())
-      ->SetState(WBMStallInterface::State::BLOCKED);
-  // Then WriteBufferManager will add DB instance to its queue
-  // and block this thread by calling WBMStallInterface::Block().
-  write_buffer_manager_->BeginWriteStall(wbm_stall_.get());
-  wbm_stall_->Block();
-
-  mutex_.Lock();
-  // Stall has ended. Signal writer threads so that they can add
-  // themselves to the WriteThread queue for writes.
-  write_thread_.EndWriteStall();
-}
-
 Status DBImpl::ThrottleLowPriWritesIfNeeded(const WriteOptions& write_options,
                                            WriteBatch* my_batch) {
  assert(write_options.low_pri);
@@ -45,10 +45,10 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
               ColumnFamilyData* cfd, bool expose_blob_index)
    : prefix_extractor_(mutable_cf_options.prefix_extractor.get()),
      env_(_env),
-      clock_(cf_options.clock),
+      clock_(_env->GetSystemClock().get()),
      logger_(cf_options.info_log),
      user_comparator_(cmp),
-      merge_operator_(cf_options.merge_operator.get()),
+      merge_operator_(cf_options.merge_operator),
      iter_(iter),
      version_(version),
      read_callback_(read_callback),
@@ -1343,7 +1343,7 @@ void DBIter::Seek(const Slice& target) {
  // we need to find out the next key that is visible to the user.
  ClearSavedValue();
  if (prefix_same_as_start_) {
-    // The case where the iterator needs to be invalidated if it has exhausted
+    // The case where the iterator needs to be invalidated if it has exausted
    // keys within the same prefix of the seek key.
    assert(prefix_extractor_ != nullptr);
    Slice target_prefix = prefix_extractor_->Transform(target);
@@ -1418,7 +1418,7 @@ void DBIter::SeekForPrev(const Slice& target) {
  // backward direction.
  ClearSavedValue();
  if (prefix_same_as_start_) {
-    // The case where the iterator needs to be invalidated if it has exhausted
+    // The case where the iterator needs to be invalidated if it has exausted
    // keys within the same prefix of the seek key.
    assert(prefix_extractor_ != nullptr);
    Slice target_prefix = prefix_extractor_->Transform(target);
@@ -235,7 +235,7 @@ class DBIter final : public Iterator {
  // If `skipping_saved_key` is true, the function will keep iterating until it
  // finds a user key that is larger than `saved_key_`.
  // If `prefix` is not null, the iterator needs to stop when all keys for the
-  // prefix are exhausted and the iterator is set to invalid.
+  // prefix are exhausted and the interator is set to invalid.
  bool FindNextUserEntry(bool skipping_saved_key, const Slice* prefix);
  // Internal implementation of FindNextUserEntry().
  bool FindNextUserEntryInternal(bool skipping_saved_key, const Slice* prefix);
@@ -1175,61 +1175,6 @@ class CountingDeleteTabPropCollectorFactory
  }
 };

-class BlockCountingTablePropertiesCollector : public TablePropertiesCollector {
- public:
-  static const std::string kNumSampledBlocksPropertyName;
-
-  const char* Name() const override {
-    return "BlockCountingTablePropertiesCollector";
-  }
-
-  Status Finish(UserCollectedProperties* properties) override {
-    (*properties)[kNumSampledBlocksPropertyName] =
-        ToString(num_sampled_blocks_);
-    return Status::OK();
-  }
-
-  Status AddUserKey(const Slice& /*user_key*/, const Slice& /*value*/,
-                    EntryType /*type*/, SequenceNumber /*seq*/,
-                    uint64_t /*file_size*/) override {
-    return Status::OK();
-  }
-
-  void BlockAdd(uint64_t /* block_raw_bytes */,
-                uint64_t block_compressed_bytes_fast,
-                uint64_t block_compressed_bytes_slow) override {
-    if (block_compressed_bytes_fast > 0 || block_compressed_bytes_slow > 0) {
-      num_sampled_blocks_++;
-    }
-  }
-
-  UserCollectedProperties GetReadableProperties() const override {
-    return UserCollectedProperties{
-        {kNumSampledBlocksPropertyName, ToString(num_sampled_blocks_)},
-    };
-  }
-
- private:
-  uint32_t num_sampled_blocks_ = 0;
-};
-
-const std::string
-    BlockCountingTablePropertiesCollector::kNumSampledBlocksPropertyName =
-        "NumSampledBlocks";
-
-class BlockCountingTablePropertiesCollectorFactory
-    : public TablePropertiesCollectorFactory {
- public:
-  const char* Name() const override {
-    return "BlockCountingTablePropertiesCollectorFactory";
-  }
-
-  TablePropertiesCollector* CreateTablePropertiesCollector(
-      TablePropertiesCollectorFactory::Context /* context */) override {
-    return new BlockCountingTablePropertiesCollector();
-  }
-};
-
 #ifndef ROCKSDB_LITE
 TEST_F(DBPropertiesTest, GetUserDefinedTableProperties) {
  Options options = CurrentOptions();
@@ -1468,132 +1413,6 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
  }
 }

-// Excluded from RocksDB lite tests due to `GetPropertiesOfAllTables()` usage.
-TEST_F(DBPropertiesTest, BlockAddForCompressionSampling) {
-  // Sampled compression requires at least one of the following four types.
-  if (!Snappy_Supported() && !Zlib_Supported() && !LZ4_Supported() &&
-      !ZSTD_Supported()) {
-    return;
-  }
-
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.table_properties_collector_factories.emplace_back(
-      std::make_shared<BlockCountingTablePropertiesCollectorFactory>());
-
-  for (bool sample_for_compression : {false, true}) {
-    // For simplicity/determinism, sample 100% when enabled, or 0% when disabled
-    options.sample_for_compression = sample_for_compression ? 1 : 0;
-
-    DestroyAndReopen(options);
-
-    // Setup the following LSM:
-    //
-    // L0_0 ["a", "b"]
-    // L1_0 ["a", "b"]
-    //
-    // L0_0 was created by flush. L1_0 was created by compaction. Each file
-    // contains one data block.
-    for (int i = 0; i < 3; ++i) {
-      ASSERT_OK(Put("a", "val"));
-      ASSERT_OK(Put("b", "val"));
-      ASSERT_OK(Flush());
-      if (i == 1) {
-        ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-      }
-    }
-
-    // A `BlockAdd()` should have been seen for files generated by flush or
-    // compaction when `sample_for_compression` is enabled.
-    TablePropertiesCollection file_to_props;
-    ASSERT_OK(db_->GetPropertiesOfAllTables(&file_to_props));
-    ASSERT_EQ(2, file_to_props.size());
-    for (const auto& file_and_props : file_to_props) {
-      auto& user_props = file_and_props.second->user_collected_properties;
-      ASSERT_TRUE(user_props.find(BlockCountingTablePropertiesCollector::
-                                      kNumSampledBlocksPropertyName) !=
-                  user_props.end());
-      ASSERT_EQ(user_props.at(BlockCountingTablePropertiesCollector::
-                                  kNumSampledBlocksPropertyName),
-                ToString(sample_for_compression ? 1 : 0));
-    }
-  }
-}
-
-class CompressionSamplingDBPropertiesTest
-    : public DBPropertiesTest,
-      public ::testing::WithParamInterface<bool> {
- public:
-  CompressionSamplingDBPropertiesTest() : fast_(GetParam()) {}
-
- protected:
-  const bool fast_;
-};
-
-INSTANTIATE_TEST_CASE_P(CompressionSamplingDBPropertiesTest,
-                        CompressionSamplingDBPropertiesTest, ::testing::Bool());
-
-// Excluded from RocksDB lite tests due to `GetPropertiesOfAllTables()` usage.
-TEST_P(CompressionSamplingDBPropertiesTest,
-       EstimateDataSizeWithCompressionSampling) {
-  Options options = CurrentOptions();
-  if (fast_) {
-    // One of the following light compression libraries must be present.
-    if (LZ4_Supported()) {
-      options.compression = kLZ4Compression;
-    } else if (Snappy_Supported()) {
-      options.compression = kSnappyCompression;
-    } else {
-      return;
-    }
-  } else {
-    // One of the following heavy compression libraries must be present.
-    if (ZSTD_Supported()) {
-      options.compression = kZSTD;
-    } else if (Zlib_Supported()) {
-      options.compression = kZlibCompression;
-    } else {
-      return;
-    }
-  }
-  options.disable_auto_compactions = true;
-  // For simplicity/determinism, sample 100%.
-  options.sample_for_compression = 1;
-  Reopen(options);
-
-  // Setup the following LSM:
-  //
-  // L0_0 ["a", "b"]
-  // L1_0 ["a", "b"]
-  //
-  // L0_0 was created by flush. L1_0 was created by compaction. Each file
-  // contains one data block. The value consists of compressible data so the
-  // data block should be stored compressed.
-  std::string val(1024, 'a');
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_OK(Put("a", val));
-    ASSERT_OK(Put("b", val));
-    ASSERT_OK(Flush());
-    if (i == 1) {
-      ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-    }
-  }
-
-  TablePropertiesCollection file_to_props;
-  ASSERT_OK(db_->GetPropertiesOfAllTables(&file_to_props));
-  ASSERT_EQ(2, file_to_props.size());
-  for (const auto& file_and_props : file_to_props) {
-    ASSERT_GT(file_and_props.second->data_size, 0);
-    if (fast_) {
-      ASSERT_EQ(file_and_props.second->data_size,
-                file_and_props.second->fast_compression_estimated_data_size);
-    } else {
-      ASSERT_EQ(file_and_props.second->data_size,
-                file_and_props.second->slow_compression_estimated_data_size);
-    }
-  }
-}
-
 TEST_F(DBPropertiesTest, EstimateNumKeysUnderflow) {
  Options options = CurrentOptions();
  Reopen(options);
@@ -1626,7 +1445,6 @@ TEST_F(DBPropertiesTest, EstimateOldestKeyTime) {

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

@@ -147,206 +147,6 @@ TEST_F(DBSecondaryTest, ReopenAsSecondary) {
  ASSERT_EQ(2, count);
 }

-TEST_F(DBSecondaryTest, SimpleInternalCompaction) {
-  Options options;
-  options.env = env_;
-  Reopen(options);
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(Flush());
-  }
-  CompactionServiceInput input;
-
-  ColumnFamilyMetaData meta;
-  db_->GetColumnFamilyMetaData(&meta);
-  for (auto& file : meta.levels[0].files) {
-    ASSERT_EQ(0, meta.levels[0].level);
-    input.input_files.push_back(file.name);
-  }
-  ASSERT_EQ(input.input_files.size(), 3);
-
-  input.output_level = 1;
-  Close();
-
-  options.max_open_files = -1;
-  OpenSecondary(options);
-  auto cfh = db_secondary_->DefaultColumnFamily();
-
-  CompactionServiceResult result;
-  ASSERT_OK(db_secondary_full()->TEST_CompactWithoutInstallation(cfh, input,
-                                                                 &result));
-
-  ASSERT_EQ(result.output_files.size(), 1);
-  InternalKey smallest, largest;
-  smallest.DecodeFrom(result.output_files[0].smallest_internal_key);
-  largest.DecodeFrom(result.output_files[0].largest_internal_key);
-  ASSERT_EQ(smallest.user_key().ToString(), "bar");
-  ASSERT_EQ(largest.user_key().ToString(), "foo");
-  ASSERT_EQ(result.output_level, 1);
-  ASSERT_EQ(result.output_path, this->secondary_path_);
-  ASSERT_EQ(result.num_output_records, 2);
-  ASSERT_GT(result.bytes_written, 0);
-}
-
-TEST_F(DBSecondaryTest, InternalCompactionMultiLevels) {
-  Options options;
-  options.env = env_;
-  options.disable_auto_compactions = true;
-  Reopen(options);
-  const int kRangeL2 = 10;
-  const int kRangeL1 = 30;
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put(Key(i * kRangeL2), "value" + ToString(i)));
-    ASSERT_OK(Put(Key((i + 1) * kRangeL2 - 1), "value" + ToString(i)));
-    ASSERT_OK(Flush());
-  }
-  MoveFilesToLevel(2);
-  for (int i = 0; i < 5; i++) {
-    ASSERT_OK(Put(Key(i * kRangeL1), "value" + ToString(i)));
-    ASSERT_OK(Put(Key((i + 1) * kRangeL1 - 1), "value" + ToString(i)));
-    ASSERT_OK(Flush());
-  }
-  MoveFilesToLevel(1);
-  for (int i = 0; i < 4; i++) {
-    ASSERT_OK(Put(Key(i * 30), "value" + ToString(i)));
-    ASSERT_OK(Put(Key(i * 30 + 50), "value" + ToString(i)));
-    ASSERT_OK(Flush());
-  }
-
-  ColumnFamilyMetaData meta;
-  db_->GetColumnFamilyMetaData(&meta);
-
-  // pick 2 files on level 0 for compaction, which has 3 overlap files on L1
-  CompactionServiceInput input1;
-  input1.input_files.push_back(meta.levels[0].files[2].name);
-  input1.input_files.push_back(meta.levels[0].files[3].name);
-  input1.input_files.push_back(meta.levels[1].files[0].name);
-  input1.input_files.push_back(meta.levels[1].files[1].name);
-  input1.input_files.push_back(meta.levels[1].files[2].name);
-
-  input1.output_level = 1;
-
-  options.max_open_files = -1;
-  Close();
-
-  OpenSecondary(options);
-  auto cfh = db_secondary_->DefaultColumnFamily();
-  CompactionServiceResult result;
-  ASSERT_OK(db_secondary_full()->TEST_CompactWithoutInstallation(cfh, input1,
-                                                                 &result));
-
-  // pick 2 files on level 1 for compaction, which has 6 overlap files on L2
-  CompactionServiceInput input2;
-  input2.input_files.push_back(meta.levels[1].files[1].name);
-  input2.input_files.push_back(meta.levels[1].files[2].name);
-  for (int i = 3; i < 9; i++) {
-    input2.input_files.push_back(meta.levels[2].files[i].name);
-  }
-
-  input2.output_level = 2;
-  ASSERT_OK(db_secondary_full()->TEST_CompactWithoutInstallation(cfh, input2,
-                                                                 &result));
-
-  CloseSecondary();
-
-  // delete all l2 files, without update manifest
-  for (auto& file : meta.levels[2].files) {
-    ASSERT_OK(env_->DeleteFile(dbname_ + file.name));
-  }
-  OpenSecondary(options);
-  cfh = db_secondary_->DefaultColumnFamily();
-  Status s = db_secondary_full()->TEST_CompactWithoutInstallation(cfh, input2,
-                                                                  &result);
-  ASSERT_TRUE(s.IsInvalidArgument());
-
-  // TODO: L0 -> L1 compaction should success, currently version is not built
-  // if files is missing.
-  //  ASSERT_OK(db_secondary_full()->TEST_CompactWithoutInstallation(cfh,
-  //  input1, &result));
-}
-
-TEST_F(DBSecondaryTest, InternalCompactionCompactedFiles) {
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(Flush());
-  }
-  CompactionServiceInput input;
-
-  ColumnFamilyMetaData meta;
-  db_->GetColumnFamilyMetaData(&meta);
-  for (auto& file : meta.levels[0].files) {
-    ASSERT_EQ(0, meta.levels[0].level);
-    input.input_files.push_back(file.name);
-  }
-  ASSERT_EQ(input.input_files.size(), 3);
-
-  input.output_level = 1;
-
-  // trigger compaction to delete the files for secondary instance compaction
-  ASSERT_OK(Put("foo", "foo_value" + std::to_string(3)));
-  ASSERT_OK(Put("bar", "bar_value" + std::to_string(3)));
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  Close();
-
-  options.max_open_files = -1;
-  OpenSecondary(options);
-  auto cfh = db_secondary_->DefaultColumnFamily();
-
-  CompactionServiceResult result;
-  Status s =
-      db_secondary_full()->TEST_CompactWithoutInstallation(cfh, input, &result);
-  ASSERT_TRUE(s.IsInvalidArgument());
-}
-
-TEST_F(DBSecondaryTest, InternalCompactionMissingFiles) {
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(Flush());
-  }
-  CompactionServiceInput input;
-
-  ColumnFamilyMetaData meta;
-  db_->GetColumnFamilyMetaData(&meta);
-  for (auto& file : meta.levels[0].files) {
-    ASSERT_EQ(0, meta.levels[0].level);
-    input.input_files.push_back(file.name);
-  }
-  ASSERT_EQ(input.input_files.size(), 3);
-
-  input.output_level = 1;
-
-  Close();
-
-  ASSERT_OK(env_->DeleteFile(dbname_ + input.input_files[0]));
-
-  options.max_open_files = -1;
-  OpenSecondary(options);
-  auto cfh = db_secondary_->DefaultColumnFamily();
-
-  CompactionServiceResult result;
-  Status s =
-      db_secondary_full()->TEST_CompactWithoutInstallation(cfh, input, &result);
-  ASSERT_TRUE(s.IsInvalidArgument());
-
-  input.input_files.erase(input.input_files.begin());
-
-  ASSERT_OK(db_secondary_full()->TEST_CompactWithoutInstallation(cfh, input,
-                                                                 &result));
-}
-
 TEST_F(DBSecondaryTest, OpenAsSecondary) {
  Options options;
  options.env = env_;
@@ -561,7 +561,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFilesWithGC) {
  constexpr Slice* end = nullptr;

  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), begin, end));
-  sfm->WaitForEmptyTrash();

  ASSERT_EQ(Get(first_key), first_value);
  ASSERT_EQ(Get(second_key), second_value);
@@ -594,7 +593,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFilesWithGC) {

  Close();
  ASSERT_OK(DestroyDB(dbname_, options));
-  sfm->WaitForEmptyTrash();
  ASSERT_EQ(files_deleted, 5);
  ASSERT_EQ(files_scheduled_to_delete, 5);

@@ -753,11 +751,10 @@ TEST_F(DBSSTTest, RateLimitedWALDelete) {
 }

 class DBWALTestWithParam
-    : public DBTestBase,
+    : public DBSSTTest,
      public testing::WithParamInterface<std::tuple<std::string, bool>> {
 public:
-  explicit DBWALTestWithParam()
-      : DBTestBase("/db_wal_test_with_params", /*env_do_fsync=*/true) {
+  DBWALTestWithParam() {
    wal_dir_ = std::get<0>(GetParam());
    wal_dir_same_as_dbname_ = std::get<1>(GetParam());
  }
@@ -1091,12 +1088,6 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowedWithBlobFiles) {
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
      "BuildTable::AfterDeleteFile",
      [&](void* /*arg*/) { delete_blob_file = true; });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency({
-      {
-          "BuildTable::AfterDeleteFile",
-          "DBSSTTest::DBWithMaxSpaceAllowedWithBlobFiles:1",
-      },
-  });

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

@@ -1104,8 +1095,6 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowedWithBlobFiles) {
  // This flush will fail
  ASSERT_NOK(Flush());
  ASSERT_TRUE(max_allowed_space_reached);
-
-  TEST_SYNC_POINT("DBSSTTest::DBWithMaxSpaceAllowedWithBlobFiles:1");
  ASSERT_TRUE(delete_blob_file);
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
 }
@@ -908,9 +908,6 @@ TEST_F(DBTest, FlushSchedule) {
      static_cast<int64_t>(options.write_buffer_size);
  options.max_write_buffer_number = 2;
  options.write_buffer_size = 120 * 1024;
-  auto flush_listener = std::make_shared<FlushCounterListener>();
-  flush_listener->expected_flush_reason = FlushReason::kWriteBufferFull;
-  options.listeners.push_back(flush_listener);
  CreateAndReopenWithCF({"pikachu"}, options);
  std::vector<port::Thread> threads;

@@ -3507,21 +3504,17 @@ TEST_F(DBTest, FIFOCompactionStyleWithCompactionAndDelete) {
 }

 // Check that FIFO-with-TTL is not supported with max_open_files != -1.
-// Github issue #8014
 TEST_F(DBTest, FIFOCompactionWithTTLAndMaxOpenFilesTest) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleFIFO;
  options.create_if_missing = true;
  options.ttl = 600;  // seconds

-  // TTL is not supported with max_open_files != -1.
-  options.max_open_files = 0;
-  ASSERT_TRUE(TryReopen(options).IsNotSupported());
-
+  // TTL is now supported with max_open_files != -1.
  options.max_open_files = 100;
-  ASSERT_TRUE(TryReopen(options).IsNotSupported());
+  options = CurrentOptions(options);
+  ASSERT_OK(TryReopen(options));

-  // TTL is supported with unlimited max_open_files
  options.max_open_files = -1;
  ASSERT_OK(TryReopen(options));
 }
@@ -6701,19 +6694,20 @@ TEST_F(DBTest, MemoryUsageWithMaxWriteBufferSizeToMaintain) {
  Reopen(options);
  Random rnd(301);
  bool memory_limit_exceeded = false;
-
-  ColumnFamilyData* cfd =
-      static_cast<ColumnFamilyHandleImpl*>(db_->DefaultColumnFamily())->cfd();
-
+  uint64_t size_all_mem_table = 0;
+  uint64_t cur_active_mem = 0;
  for (int i = 0; i < 1000; i++) {
    std::string value = rnd.RandomString(1000);
    ASSERT_OK(Put("keykey_" + std::to_string(i), value));

    dbfull()->TEST_WaitForFlushMemTable();

-    const uint64_t cur_active_mem = cfd->mem()->ApproximateMemoryUsage();
-    const uint64_t size_all_mem_table =
-        cur_active_mem + cfd->imm()->ApproximateMemoryUsage();
+    ASSERT_TRUE(db_->GetIntProperty(db_->DefaultColumnFamily(),
+                                    DB::Properties::kSizeAllMemTables,
+                                    &size_all_mem_table));
+    ASSERT_TRUE(db_->GetIntProperty(db_->DefaultColumnFamily(),
+                                    DB::Properties::kCurSizeActiveMemTable,
+                                    &cur_active_mem));

    // Errors out if memory usage keeps on increasing beyond the limit.
    // Once memory limit exceeds,  memory_limit_exceeded  is set and if
@@ -344,10 +344,6 @@ class DBTestSharedWriteBufferAcrossCFs
 TEST_P(DBTestSharedWriteBufferAcrossCFs, SharedWriteBufferAcrossCFs) {
  Options options = CurrentOptions();
  options.arena_block_size = 4096;
-  auto flush_listener = std::make_shared<FlushCounterListener>();
-  options.listeners.push_back(flush_listener);
-  // Don't trip the listener at shutdown.
-  options.avoid_flush_during_shutdown = true;

  // Avoid undeterministic value by malloc_usable_size();
  // Force arena block size to 1
@@ -391,7 +387,6 @@ TEST_P(DBTestSharedWriteBufferAcrossCFs, SharedWriteBufferAcrossCFs) {

  // Create some data and flush "default" and "nikitich" so that they
  // are newer CFs created.
-  flush_listener->expected_flush_reason = FlushReason::kManualFlush;
  ASSERT_OK(Put(3, Key(1), DummyString(1), wo));
  Flush(3);
  ASSERT_OK(Put(3, Key(1), DummyString(1), wo));
@@ -402,7 +397,6 @@ TEST_P(DBTestSharedWriteBufferAcrossCFs, SharedWriteBufferAcrossCFs) {
  ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
            static_cast<uint64_t>(1));

-  flush_listener->expected_flush_reason = FlushReason::kWriteBufferManager;
  ASSERT_OK(Put(3, Key(1), DummyString(30000), wo));
  if (cost_cache_) {
    ASSERT_GE(cache->GetUsage(), 256 * 1024);
@@ -527,10 +521,6 @@ TEST_F(DBTest2, SharedWriteBufferLimitAcrossDB) {
  std::string dbname2 = test::PerThreadDBPath("db_shared_wb_db2");
  Options options = CurrentOptions();
  options.arena_block_size = 4096;
-  auto flush_listener = std::make_shared<FlushCounterListener>();
-  options.listeners.push_back(flush_listener);
-  // Don't trip the listener at shutdown.
-  options.avoid_flush_during_shutdown = true;
  // Avoid undeterministic value by malloc_usable_size();
  // Force arena block size to 1
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
@@ -568,7 +558,6 @@ TEST_F(DBTest2, SharedWriteBufferLimitAcrossDB) {
  };

  // Trigger a flush on cf2
-  flush_listener->expected_flush_reason = FlushReason::kWriteBufferManager;
  ASSERT_OK(Put(2, Key(1), DummyString(70000), wo));
  wait_flush();
  ASSERT_OK(Put(0, Key(1), DummyString(20000), wo));
@@ -4127,7 +4116,7 @@ TEST_F(DBTest2, TraceWithFilter) {

  // Open another db, replay, and verify the data
  std::string value;
-  std::string dbname2 = test::PerThreadDBPath(env_, "db_replay");
+  std::string dbname2 = test::TmpDir(env_) + "/db_replay";
  ASSERT_OK(DestroyDB(dbname2, options));

  // Using a different name than db2, to pacify infer's use-after-lifetime
@@ -4178,7 +4167,7 @@ TEST_F(DBTest2, TraceWithFilter) {
  ASSERT_OK(DestroyDB(dbname2, options));

  // Set up a new db.
-  std::string dbname3 = test::PerThreadDBPath(env_, "db_not_trace_read");
+  std::string dbname3 = test::TmpDir(env_) + "/db_not_trace_read";
  ASSERT_OK(DestroyDB(dbname3, options));

  DB* db3_init = nullptr;
@@ -4595,7 +4584,7 @@ TEST_F(DBTest2, MultiDBParallelOpenTest) {
  Options options = CurrentOptions();
  std::vector<std::string> dbnames;
  for (int i = 0; i < kNumDbs; ++i) {
-    dbnames.emplace_back(test::PerThreadDBPath(env_, "db" + ToString(i)));
+    dbnames.emplace_back(test::TmpDir(env_) + "/db" + ToString(i));
    ASSERT_OK(DestroyDB(dbnames.back(), options));
  }

@@ -488,7 +488,6 @@ Options DBTestBase::GetOptions(
    }
    case kFIFOCompaction: {
      options.compaction_style = kCompactionStyleFIFO;
-      options.max_open_files = -1;
      break;
    }
    case kBlockBasedTableWithPrefixHashIndex: {
@@ -378,20 +378,14 @@ class SpecialEnv : public EnvWrapper {
        return Append(data);
      }
      Status Truncate(uint64_t size) override { return base_->Truncate(size); }
-      void PrepareWrite(size_t offset, size_t len) override {
-        base_->PrepareWrite(offset, len);
-      }
-      void SetPreallocationBlockSize(size_t size) override {
-        base_->SetPreallocationBlockSize(size);
-      }
      Status Close() override {
 // SyncPoint is not supported in Released Windows Mode.
 #if !(defined NDEBUG) || !defined(OS_WIN)
        // Check preallocation size
-        size_t block_size, last_allocated_block;
-        base_->GetPreallocationStatus(&block_size, &last_allocated_block);
+        // preallocation size is never passed to base file.
+        size_t preallocation_size = preallocation_block_size();
        TEST_SYNC_POINT_CALLBACK("DBTestWalFile.GetPreallocationStatus",
-                                 &block_size);
+                                 &preallocation_size);
 #endif  // !(defined NDEBUG) || !defined(OS_WIN)

        return base_->Close();
@@ -782,17 +776,6 @@ class OnFileDeletionListener : public EventListener {
  size_t matched_count_;
  std::string expected_file_name_;
 };
-
-class FlushCounterListener : public EventListener {
- public:
-  std::atomic<int> count{0};
-  std::atomic<FlushReason> expected_flush_reason{FlushReason::kOthers};
-
-  void OnFlushBegin(DB* /*db*/, const FlushJobInfo& flush_job_info) override {
-    count++;
-    ASSERT_EQ(expected_flush_reason.load(), flush_job_info.flush_reason);
-  }
-};
 #endif

 // A test merge operator mimics put but also fails if one of merge operands is
@@ -826,7 +809,6 @@ class CacheWrapper : public Cache {

  const char* Name() const override { return target_->Name(); }

-  using Cache::Insert;
  Status Insert(const Slice& key, void* value, size_t charge,
                void (*deleter)(const Slice& key, void* value),
                Handle** handle = nullptr,
@@ -834,14 +816,12 @@ class CacheWrapper : public Cache {
    return target_->Insert(key, value, charge, deleter, handle, priority);
  }

-  using Cache::Lookup;
  Handle* Lookup(const Slice& key, Statistics* stats = nullptr) override {
    return target_->Lookup(key, stats);
  }

  bool Ref(Handle* handle) override { return target_->Ref(handle); }

-  using Cache::Release;
  bool Release(Handle* handle, bool force_erase = false) override {
    return target_->Release(handle, force_erase);
  }
@@ -24,37 +24,13 @@ class DBWALTestBase : public DBTestBase {

 #if defined(ROCKSDB_PLATFORM_POSIX)
 public:
-#if defined(ROCKSDB_FALLOCATE_PRESENT)
-  bool IsFallocateSupported() {
-    // Test fallocate support of running file system.
-    // Skip this test if fallocate is not supported.
-    std::string fname_test_fallocate = dbname_ + "/preallocate_testfile";
-    int fd = -1;
-    do {
-      fd = open(fname_test_fallocate.c_str(), O_CREAT | O_RDWR | O_TRUNC, 0644);
-    } while (fd < 0 && errno == EINTR);
-    assert(fd > 0);
-    int alloc_status = fallocate(fd, 0, 0, 1);
-    int err_number = errno;
-    close(fd);
-    assert(env_->DeleteFile(fname_test_fallocate) == Status::OK());
-    if (err_number == ENOSYS || err_number == EOPNOTSUPP) {
-      fprintf(stderr, "Skipped preallocated space check: %s\n",
-              errnoStr(err_number).c_str());
-      return false;
-    }
-    assert(alloc_status == 0);
-    return true;
-  }
-#endif  // ROCKSDB_FALLOCATE_PRESENT
-
  uint64_t GetAllocatedFileSize(std::string file_name) {
    struct stat sbuf;
    int err = stat(file_name.c_str(), &sbuf);
    assert(err == 0);
    return sbuf.st_blocks * 512;
  }
-#endif  // ROCKSDB_PLATFORM_POSIX
+#endif
 };

 class DBWALTest : public DBWALTestBase {
@@ -1801,8 +1777,19 @@ TEST_P(DBWALTestWithParamsVaryingRecoveryMode,
 // avoid_flush_during_recovery=true.
 // Flush should trigger if max_total_wal_size is reached.
 TEST_F(DBWALTest, RestoreTotalLogSizeAfterRecoverWithoutFlush) {
-  auto test_listener = std::make_shared<FlushCounterListener>();
-  test_listener->expected_flush_reason = FlushReason::kWalFull;
+  class TestFlushListener : public EventListener {
+   public:
+    std::atomic<int> count{0};
+
+    TestFlushListener() = default;
+
+    void OnFlushBegin(DB* /*db*/, const FlushJobInfo& flush_job_info) override {
+      count++;
+      ASSERT_EQ(FlushReason::kWriteBufferManager, flush_job_info.flush_reason);
+    }
+  };
+  std::shared_ptr<TestFlushListener> test_listener =
+      std::make_shared<TestFlushListener>();

  constexpr size_t kKB = 1024;
  constexpr size_t kMB = 1024 * 1024;
@@ -1862,9 +1849,23 @@ TEST_F(DBWALTest, TruncateLastLogAfterRecoverWithoutFlush) {
    ROCKSDB_GTEST_SKIP("Test requires non-mem environment");
    return;
  }
-  if (!IsFallocateSupported()) {
+  // Test fallocate support of running file system.
+  // Skip this test if fallocate is not supported.
+  std::string fname_test_fallocate = dbname_ + "/preallocate_testfile";
+  int fd = -1;
+  do {
+    fd = open(fname_test_fallocate.c_str(), O_CREAT | O_RDWR | O_TRUNC, 0644);
+  } while (fd < 0 && errno == EINTR);
+  ASSERT_GT(fd, 0);
+  int alloc_status = fallocate(fd, 0, 0, 1);
+  int err_number = errno;
+  close(fd);
+  ASSERT_OK(options.env->DeleteFile(fname_test_fallocate));
+  if (err_number == ENOSYS || err_number == EOPNOTSUPP) {
+    fprintf(stderr, "Skipped preallocated space check: %s\n", strerror(err_number));
    return;
  }
+  ASSERT_EQ(0, alloc_status);

  DestroyAndReopen(options);
  size_t preallocated_size =
@@ -1887,120 +1888,6 @@ TEST_F(DBWALTest, TruncateLastLogAfterRecoverWithoutFlush) {
  ASSERT_LT(GetAllocatedFileSize(dbname_ + file_before->PathName()),
            preallocated_size);
 }
-// Tests that we will truncate the preallocated space of the last log from
-// previous.
-TEST_F(DBWALTest, TruncateLastLogAfterRecoverWithFlush) {
-  constexpr size_t kKB = 1024;
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.avoid_flush_during_recovery = false;
-  options.avoid_flush_during_shutdown = true;
-  if (mem_env_) {
-    ROCKSDB_GTEST_SKIP("Test requires non-mem environment");
-    return;
-  }
-  if (!IsFallocateSupported()) {
-    return;
-  }
-
-  DestroyAndReopen(options);
-  size_t preallocated_size =
-      dbfull()->TEST_GetWalPreallocateBlockSize(options.write_buffer_size);
-  ASSERT_OK(Put("foo", "v1"));
-  VectorLogPtr log_files_before;
-  ASSERT_OK(dbfull()->GetSortedWalFiles(log_files_before));
-  ASSERT_EQ(1, log_files_before.size());
-  auto& file_before = log_files_before[0];
-  ASSERT_LT(file_before->SizeFileBytes(), 1 * kKB);
-  ASSERT_GE(GetAllocatedFileSize(dbname_ + file_before->PathName()),
-            preallocated_size);
-  // The log file has preallocated space.
-  Close();
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::PurgeObsoleteFiles:Begin",
-        "DBWALTest::TruncateLastLogAfterRecoverWithFlush:AfterRecover"},
-       {"DBWALTest::TruncateLastLogAfterRecoverWithFlush:AfterTruncate",
-        "DBImpl::DeleteObsoleteFileImpl::BeforeDeletion"}});
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  port::Thread reopen_thread([&]() { Reopen(options); });
-
-  TEST_SYNC_POINT(
-      "DBWALTest::TruncateLastLogAfterRecoverWithFlush:AfterRecover");
-  // After the flush during Open, the log file should get deleted.  However,
-  // if  the process is in a crash loop, the log file may not get
-  // deleted and thte preallocated space will keep accumulating. So we need
-  // to ensure it gets trtuncated.
-  EXPECT_LT(GetAllocatedFileSize(dbname_ + file_before->PathName()),
-            preallocated_size);
-  TEST_SYNC_POINT(
-      "DBWALTest::TruncateLastLogAfterRecoverWithFlush:AfterTruncate");
-  reopen_thread.join();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_F(DBWALTest, TruncateLastLogAfterRecoverWALEmpty) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.avoid_flush_during_recovery = false;
-  if (mem_env_ || encrypted_env_) {
-    ROCKSDB_GTEST_SKIP("Test requires non-mem/non-encrypted  environment");
-    return;
-  }
-  if (!IsFallocateSupported()) {
-    return;
-  }
-
-  DestroyAndReopen(options);
-  size_t preallocated_size =
-      dbfull()->TEST_GetWalPreallocateBlockSize(options.write_buffer_size);
-  Close();
-  std::vector<std::string> filenames;
-  std::string last_log;
-  uint64_t last_log_num = 0;
-  ASSERT_OK(env_->GetChildren(dbname_, &filenames));
-  for (auto fname : filenames) {
-    uint64_t number;
-    FileType type;
-    if (ParseFileName(fname, &number, &type, nullptr)) {
-      if (type == kWalFile && number > last_log_num) {
-        last_log = fname;
-      }
-    }
-  }
-  ASSERT_NE(last_log, "");
-  last_log = dbname_ + '/' + last_log;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::PurgeObsoleteFiles:Begin",
-        "DBWALTest::TruncateLastLogAfterRecoverWithFlush:AfterRecover"},
-       {"DBWALTest::TruncateLastLogAfterRecoverWithFlush:AfterTruncate",
-        "DBImpl::DeleteObsoleteFileImpl::BeforeDeletion"}});
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "PosixWritableFile::Close",
-      [](void* arg) { *(reinterpret_cast<size_t*>(arg)) = 0; });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  // Preallocate space for the empty log file. This could happen if WAL data
-  // was buffered in memory and the process crashed.
-  std::unique_ptr<WritableFile> log_file;
-  ASSERT_OK(env_->ReopenWritableFile(last_log, &log_file, EnvOptions()));
-  log_file->SetPreallocationBlockSize(preallocated_size);
-  log_file->PrepareWrite(0, 4096);
-  log_file.reset();
-
-  ASSERT_GE(GetAllocatedFileSize(last_log), preallocated_size);
-
-  port::Thread reopen_thread([&]() { Reopen(options); });
-
-  TEST_SYNC_POINT(
-      "DBWALTest::TruncateLastLogAfterRecoverWithFlush:AfterRecover");
-  // The preallocated space should be truncated.
-  EXPECT_LT(GetAllocatedFileSize(last_log), preallocated_size);
-  TEST_SYNC_POINT(
-      "DBWALTest::TruncateLastLogAfterRecoverWithFlush:AfterTruncate");
-  reopen_thread.join();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-}
 #endif  // ROCKSDB_FALLOCATE_PRESENT
 #endif  // ROCKSDB_PLATFORM_POSIX

@@ -1,801 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "db/db_test_util.h"
-#include "db/write_thread.h"
-#include "port/stack_trace.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class DBWriteBufferManagerTest : public DBTestBase,
-                                 public testing::WithParamInterface<bool> {
- public:
-  DBWriteBufferManagerTest()
-      : DBTestBase("/db_write_buffer_manager_test", /*env_do_fsync=*/false) {}
-  bool cost_cache_;
-};
-
-TEST_P(DBWriteBufferManagerTest, SharedBufferAcrossCFs1) {
-  Options options = CurrentOptions();
-  options.arena_block_size = 4096;
-  options.write_buffer_size = 500000;  // this is never hit
-  std::shared_ptr<Cache> cache = NewLRUCache(4 * 1024 * 1024, 2);
-  ASSERT_LT(cache->GetUsage(), 256 * 1024);
-  cost_cache_ = GetParam();
-
-  if (cost_cache_) {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, cache, true));
-  } else {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, nullptr, true));
-  }
-
-  WriteOptions wo;
-  wo.disableWAL = true;
-
-  CreateAndReopenWithCF({"cf1", "cf2", "cf3"}, options);
-  ASSERT_OK(Put(3, Key(1), DummyString(1), wo));
-  Flush(3);
-  ASSERT_OK(Put(3, Key(1), DummyString(1), wo));
-  ASSERT_OK(Put(0, Key(1), DummyString(1), wo));
-  Flush(0);
-
-  // Write to "Default", "cf2" and "cf3".
-  ASSERT_OK(Put(3, Key(1), DummyString(30000), wo));
-  ASSERT_OK(Put(0, Key(1), DummyString(40000), wo));
-  ASSERT_OK(Put(2, Key(1), DummyString(1), wo));
-
-  ASSERT_OK(Put(3, Key(2), DummyString(40000), wo));
-  // WriteBufferManager::buffer_size_ has exceeded after the previous write is
-  // completed.
-
-  // This make sures write will go through and if stall was in effect, it will
-  // end.
-  ASSERT_OK(Put(0, Key(2), DummyString(1), wo));
-}
-
-// Test Single DB with multiple writer threads get blocked when
-// WriteBufferManager execeeds buffer_size_ and flush is waiting to be
-// finished.
-TEST_P(DBWriteBufferManagerTest, SharedWriteBufferAcrossCFs2) {
-  Options options = CurrentOptions();
-  options.arena_block_size = 4096;
-  options.write_buffer_size = 500000;  // this is never hit
-  std::shared_ptr<Cache> cache = NewLRUCache(4 * 1024 * 1024, 2);
-  ASSERT_LT(cache->GetUsage(), 256 * 1024);
-  cost_cache_ = GetParam();
-
-  if (cost_cache_) {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, cache, true));
-  } else {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, nullptr, true));
-  }
-  WriteOptions wo;
-  wo.disableWAL = true;
-
-  CreateAndReopenWithCF({"cf1", "cf2", "cf3"}, options);
-  ASSERT_OK(Put(3, Key(1), DummyString(1), wo));
-  Flush(3);
-  ASSERT_OK(Put(3, Key(1), DummyString(1), wo));
-  ASSERT_OK(Put(0, Key(1), DummyString(1), wo));
-  Flush(0);
-
-  // Write to "Default", "cf2" and "cf3". No flush will be triggered.
-  ASSERT_OK(Put(3, Key(1), DummyString(30000), wo));
-  ASSERT_OK(Put(0, Key(1), DummyString(40000), wo));
-  ASSERT_OK(Put(2, Key(1), DummyString(1), wo));
-
-  ASSERT_OK(Put(3, Key(2), DummyString(40000), wo));
-  // WriteBufferManager::buffer_size_ has exceeded after the previous write is
-  // completed.
-
-  std::unordered_set<WriteThread::Writer*> w_set;
-  std::vector<port::Thread> threads;
-  int wait_count_db = 0;
-  int num_writers = 4;
-  InstrumentedMutex mutex;
-  InstrumentedCondVar cv(&mutex);
-  std::atomic<int> thread_num(0);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0",
-        "DBImpl::BackgroundCallFlush:start"}});
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WBMStallInterface::BlockDB", [&](void*) {
-        InstrumentedMutexLock lock(&mutex);
-        wait_count_db++;
-        cv.SignalAll();
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WriteThread::WriteStall::Wait", [&](void* arg) {
-        InstrumentedMutexLock lock(&mutex);
-        WriteThread::Writer* w = reinterpret_cast<WriteThread::Writer*>(arg);
-        w_set.insert(w);
-        // Allow the flush to continue if all writer threads are blocked.
-        if (w_set.size() == (unsigned long)num_writers) {
-          TEST_SYNC_POINT(
-              "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  bool s = true;
-
-  std::function<void(int)> writer = [&](int cf) {
-    int a = thread_num.fetch_add(1);
-    std::string key = "foo" + std::to_string(a);
-    Status tmp = Put(cf, Slice(key), DummyString(1), wo);
-    InstrumentedMutexLock lock(&mutex);
-    s = s && tmp.ok();
-  };
-
-  // Flow:
-  // main_writer thread will write but will be blocked (as Flush will on hold,
-  // buffer_size_ has exceeded, thus will create stall in effect).
-  //  |
-  //  |
-  //  multiple writer threads will be created to write across multiple columns
-  //  and they will be blocked.
-  //  |
-  //  |
-  //  Last writer thread will write and when its blocked it will signal Flush to
-  //  continue to clear the stall.
-
-  threads.emplace_back(writer, 1);
-  // Wait untill first thread (main_writer) writing to DB is blocked and then
-  // create the multiple writers which will be blocked from getting added to the
-  // queue because stall is in effect.
-  {
-    InstrumentedMutexLock lock(&mutex);
-    while (wait_count_db != 1) {
-      cv.Wait();
-    }
-  }
-  for (int i = 0; i < num_writers; i++) {
-    threads.emplace_back(writer, i % 4);
-  }
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  ASSERT_TRUE(s);
-
-  // Number of DBs blocked.
-  ASSERT_EQ(wait_count_db, 1);
-  // Number of Writer threads blocked.
-  ASSERT_EQ(w_set.size(), num_writers);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// Test multiple DBs get blocked when WriteBufferManager limit exceeds and flush
-// is waiting to be finished but DBs tries to write meanwhile.
-TEST_P(DBWriteBufferManagerTest, SharedWriteBufferLimitAcrossDB) {
-  std::vector<std::string> dbnames;
-  std::vector<DB*> dbs;
-  int num_dbs = 3;
-
-  for (int i = 0; i < num_dbs; i++) {
-    dbs.push_back(nullptr);
-    dbnames.push_back(
-        test::PerThreadDBPath("db_shared_wb_db" + std::to_string(i)));
-  }
-
-  Options options = CurrentOptions();
-  options.arena_block_size = 4096;
-  options.write_buffer_size = 500000;  // this is never hit
-  std::shared_ptr<Cache> cache = NewLRUCache(4 * 1024 * 1024, 2);
-  ASSERT_LT(cache->GetUsage(), 256 * 1024);
-  cost_cache_ = GetParam();
-
-  if (cost_cache_) {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, cache, true));
-  } else {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, nullptr, true));
-  }
-  CreateAndReopenWithCF({"cf1", "cf2"}, options);
-
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(DestroyDB(dbnames[i], options));
-    ASSERT_OK(DB::Open(options, dbnames[i], &(dbs[i])));
-  }
-  WriteOptions wo;
-  wo.disableWAL = true;
-
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(dbs[i]->Put(wo, Key(1), DummyString(20000)));
-  }
-  // Insert to db_.
-  ASSERT_OK(Put(0, Key(1), DummyString(30000), wo));
-
-  // WriteBufferManager Limit exceeded.
-  std::vector<port::Thread> threads;
-  int wait_count_db = 0;
-  InstrumentedMutex mutex;
-  InstrumentedCondVar cv(&mutex);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0",
-        "DBImpl::BackgroundCallFlush:start"}});
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WBMStallInterface::BlockDB", [&](void*) {
-        {
-          InstrumentedMutexLock lock(&mutex);
-          wait_count_db++;
-          cv.Signal();
-          // Since this is the last DB, signal Flush to continue.
-          if (wait_count_db == num_dbs + 1) {
-            TEST_SYNC_POINT(
-                "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-          }
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  bool s = true;
-
-  // Write to DB.
-  std::function<void(DB*)> write_db = [&](DB* db) {
-    Status tmp = db->Put(wo, Key(3), DummyString(1));
-    InstrumentedMutexLock lock(&mutex);
-    s = s && tmp.ok();
-  };
-
-  // Flow:
-  // db_ will write and will be blocked (as Flush will on hold and will create
-  // stall in effect).
-  //  |
-  //  multiple dbs writers will be created to write to that db and they will be
-  //  blocked.
-  //  |
-  //  |
-  //  Last writer will write and when its blocked it will signal Flush to
-  //  continue to clear the stall.
-
-  threads.emplace_back(write_db, db_);
-  // Wait untill first DB is blocked and then create the multiple writers for
-  // different DBs which will be blocked from getting added to the queue because
-  // stall is in effect.
-  {
-    InstrumentedMutexLock lock(&mutex);
-    while (wait_count_db != 1) {
-      cv.Wait();
-    }
-  }
-  for (int i = 0; i < num_dbs; i++) {
-    threads.emplace_back(write_db, dbs[i]);
-  }
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  ASSERT_TRUE(s);
-  ASSERT_EQ(num_dbs + 1, wait_count_db);
-  // Clean up DBs.
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(dbs[i]->Close());
-    ASSERT_OK(DestroyDB(dbnames[i], options));
-    delete dbs[i];
-  }
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// Test multiple threads writing across multiple DBs and multiple columns get
-// blocked when stall by WriteBufferManager is in effect.
-TEST_P(DBWriteBufferManagerTest, SharedWriteBufferLimitAcrossDB1) {
-  std::vector<std::string> dbnames;
-  std::vector<DB*> dbs;
-  int num_dbs = 3;
-
-  for (int i = 0; i < num_dbs; i++) {
-    dbs.push_back(nullptr);
-    dbnames.push_back(
-        test::PerThreadDBPath("db_shared_wb_db" + std::to_string(i)));
-  }
-
-  Options options = CurrentOptions();
-  options.arena_block_size = 4096;
-  options.write_buffer_size = 500000;  // this is never hit
-  std::shared_ptr<Cache> cache = NewLRUCache(4 * 1024 * 1024, 2);
-  ASSERT_LT(cache->GetUsage(), 256 * 1024);
-  cost_cache_ = GetParam();
-
-  if (cost_cache_) {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, cache, true));
-  } else {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, nullptr, true));
-  }
-  CreateAndReopenWithCF({"cf1", "cf2"}, options);
-
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(DestroyDB(dbnames[i], options));
-    ASSERT_OK(DB::Open(options, dbnames[i], &(dbs[i])));
-  }
-  WriteOptions wo;
-  wo.disableWAL = true;
-
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(dbs[i]->Put(wo, Key(1), DummyString(20000)));
-  }
-  // Insert to db_.
-  ASSERT_OK(Put(0, Key(1), DummyString(30000), wo));
-
-  // WriteBufferManager::buffer_size_ has exceeded after the previous write to
-  // dbs[0] is completed.
-  std::vector<port::Thread> threads;
-  int wait_count_db = 0;
-  InstrumentedMutex mutex;
-  InstrumentedCondVar cv(&mutex);
-  std::unordered_set<WriteThread::Writer*> w_set;
-  std::vector<port::Thread> writer_threads;
-  std::atomic<int> thread_num(0);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0",
-        "DBImpl::BackgroundCallFlush:start"}});
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WBMStallInterface::BlockDB", [&](void*) {
-        {
-          InstrumentedMutexLock lock(&mutex);
-          wait_count_db++;
-          thread_num.fetch_add(1);
-          cv.Signal();
-          // Allow the flush to continue if all writer threads are blocked.
-          if (thread_num.load(std::memory_order_relaxed) == 2 * num_dbs + 1) {
-            TEST_SYNC_POINT(
-                "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-          }
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WriteThread::WriteStall::Wait", [&](void* arg) {
-        WriteThread::Writer* w = reinterpret_cast<WriteThread::Writer*>(arg);
-        {
-          InstrumentedMutexLock lock(&mutex);
-          w_set.insert(w);
-          thread_num.fetch_add(1);
-          // Allow the flush continue if all writer threads are blocked.
-          if (thread_num.load(std::memory_order_relaxed) == 2 * num_dbs + 1) {
-            TEST_SYNC_POINT(
-                "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-          }
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  bool s1 = true, s2 = true;
-  // Write to multiple columns of db_.
-  std::function<void(int)> write_cf = [&](int cf) {
-    Status tmp = Put(cf, Key(3), DummyString(1), wo);
-    InstrumentedMutexLock lock(&mutex);
-    s1 = s1 && tmp.ok();
-  };
-  // Write to multiple DBs.
-  std::function<void(DB*)> write_db = [&](DB* db) {
-    Status tmp = db->Put(wo, Key(3), DummyString(1));
-    InstrumentedMutexLock lock(&mutex);
-    s2 = s2 && tmp.ok();
-  };
-
-  // Flow:
-  // thread will write to db_ will be blocked (as Flush will on hold,
-  // buffer_size_ has exceeded and will create stall in effect).
-  //  |
-  //  |
-  //  multiple writers threads writing to different DBs and to db_ across
-  //  multiple columns will be created and they will be blocked due to stall.
-  //  |
-  //  |
-  //  Last writer thread will write and when its blocked it will signal Flush to
-  //  continue to clear the stall.
-  threads.emplace_back(write_db, db_);
-  // Wait untill first thread is blocked and then create the multiple writer
-  // threads.
-  {
-    InstrumentedMutexLock lock(&mutex);
-    while (wait_count_db != 1) {
-      cv.Wait();
-    }
-  }
-
-  for (int i = 0; i < num_dbs; i++) {
-    // Write to multiple columns of db_.
-    writer_threads.emplace_back(write_cf, i % 3);
-    // Write to different dbs.
-    threads.emplace_back(write_db, dbs[i]);
-  }
-  for (auto& t : threads) {
-    t.join();
-  }
-  for (auto& t : writer_threads) {
-    t.join();
-  }
-
-  ASSERT_TRUE(s1);
-  ASSERT_TRUE(s2);
-
-  // Number of DBs blocked.
-  ASSERT_EQ(num_dbs + 1, wait_count_db);
-  // Number of Writer threads blocked.
-  ASSERT_EQ(w_set.size(), num_dbs);
-  // Clean up DBs.
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(dbs[i]->Close());
-    ASSERT_OK(DestroyDB(dbnames[i], options));
-    delete dbs[i];
-  }
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// Test multiple threads writing across multiple columns of db_ by passing
-// different values to WriteOption.no_slown_down.
-TEST_P(DBWriteBufferManagerTest, MixedSlowDownOptionsSingleDB) {
-  Options options = CurrentOptions();
-  options.arena_block_size = 4096;
-  options.write_buffer_size = 500000;  // this is never hit
-  std::shared_ptr<Cache> cache = NewLRUCache(4 * 1024 * 1024, 2);
-  ASSERT_LT(cache->GetUsage(), 256 * 1024);
-  cost_cache_ = GetParam();
-
-  if (cost_cache_) {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, cache, true));
-  } else {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, nullptr, true));
-  }
-  WriteOptions wo;
-  wo.disableWAL = true;
-
-  CreateAndReopenWithCF({"cf1", "cf2", "cf3"}, options);
-
-  ASSERT_OK(Put(3, Key(1), DummyString(1), wo));
-  Flush(3);
-  ASSERT_OK(Put(3, Key(1), DummyString(1), wo));
-  ASSERT_OK(Put(0, Key(1), DummyString(1), wo));
-  Flush(0);
-
-  // Write to "Default", "cf2" and "cf3". No flush will be triggered.
-  ASSERT_OK(Put(3, Key(1), DummyString(30000), wo));
-  ASSERT_OK(Put(0, Key(1), DummyString(40000), wo));
-  ASSERT_OK(Put(2, Key(1), DummyString(1), wo));
-  ASSERT_OK(Put(3, Key(2), DummyString(40000), wo));
-
-  // WriteBufferManager::buffer_size_ has exceeded after the previous write to
-  // db_ is completed.
-
-  std::unordered_set<WriteThread::Writer*> w_slowdown_set;
-  std::vector<port::Thread> threads;
-  int wait_count_db = 0;
-  int num_writers = 4;
-  InstrumentedMutex mutex;
-  InstrumentedCondVar cv(&mutex);
-  std::atomic<int> thread_num(0);
-  std::atomic<int> w_no_slowdown(0);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0",
-        "DBImpl::BackgroundCallFlush:start"}});
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WBMStallInterface::BlockDB", [&](void*) {
-        {
-          InstrumentedMutexLock lock(&mutex);
-          wait_count_db++;
-          cv.SignalAll();
-        }
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WriteThread::WriteStall::Wait", [&](void* arg) {
-        {
-          InstrumentedMutexLock lock(&mutex);
-          WriteThread::Writer* w = reinterpret_cast<WriteThread::Writer*>(arg);
-          w_slowdown_set.insert(w);
-          // Allow the flush continue if all writer threads are blocked.
-          if (w_slowdown_set.size() + (unsigned long)w_no_slowdown.load(
-                                          std::memory_order_relaxed) ==
-              (unsigned long)num_writers) {
-            TEST_SYNC_POINT(
-                "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-          }
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  bool s1 = true, s2 = true;
-
-  std::function<void(int)> write_slow_down = [&](int cf) {
-    int a = thread_num.fetch_add(1);
-    std::string key = "foo" + std::to_string(a);
-    WriteOptions write_op;
-    write_op.no_slowdown = false;
-    Status tmp = Put(cf, Slice(key), DummyString(1), write_op);
-    InstrumentedMutexLock lock(&mutex);
-    s1 = s1 && tmp.ok();
-  };
-
-  std::function<void(int)> write_no_slow_down = [&](int cf) {
-    int a = thread_num.fetch_add(1);
-    std::string key = "foo" + std::to_string(a);
-    WriteOptions write_op;
-    write_op.no_slowdown = true;
-    Status tmp = Put(cf, Slice(key), DummyString(1), write_op);
-    {
-      InstrumentedMutexLock lock(&mutex);
-      s2 = s2 && !tmp.ok();
-      w_no_slowdown.fetch_add(1);
-      // Allow the flush continue if all writer threads are blocked.
-      if (w_slowdown_set.size() +
-              (unsigned long)w_no_slowdown.load(std::memory_order_relaxed) ==
-          (unsigned long)num_writers) {
-        TEST_SYNC_POINT(
-            "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-      }
-    }
-  };
-
-  // Flow:
-  // main_writer thread will write but will be blocked (as Flush will on hold,
-  // buffer_size_ has exceeded, thus will create stall in effect).
-  //  |
-  //  |
-  //  multiple writer threads will be created to write across multiple columns
-  //  with different values of WriteOptions.no_slowdown. Some of them will
-  //  be blocked and some of them will return with Incomplete status.
-  //  |
-  //  |
-  //  Last writer thread will write and when its blocked/return it will signal
-  //  Flush to continue to clear the stall.
-  threads.emplace_back(write_slow_down, 1);
-  // Wait untill first thread (main_writer) writing to DB is blocked and then
-  // create the multiple writers which will be blocked from getting added to the
-  // queue because stall is in effect.
-  {
-    InstrumentedMutexLock lock(&mutex);
-    while (wait_count_db != 1) {
-      cv.Wait();
-    }
-  }
-
-  for (int i = 0; i < num_writers; i += 2) {
-    threads.emplace_back(write_no_slow_down, (i) % 4);
-    threads.emplace_back(write_slow_down, (i + 1) % 4);
-  }
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  ASSERT_TRUE(s1);
-  ASSERT_TRUE(s2);
-  // Number of DBs blocked.
-  ASSERT_EQ(wait_count_db, 1);
-  // Number of Writer threads blocked.
-  ASSERT_EQ(w_slowdown_set.size(), num_writers / 2);
-  // Number of Writer threads with WriteOptions.no_slowdown = true.
-  ASSERT_EQ(w_no_slowdown.load(std::memory_order_relaxed), num_writers / 2);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// Test multiple threads writing across multiple columns of db_ and different
-// dbs by passing different values to WriteOption.no_slown_down.
-TEST_P(DBWriteBufferManagerTest, MixedSlowDownOptionsMultipleDB) {
-  std::vector<std::string> dbnames;
-  std::vector<DB*> dbs;
-  int num_dbs = 4;
-
-  for (int i = 0; i < num_dbs; i++) {
-    dbs.push_back(nullptr);
-    dbnames.push_back(
-        test::PerThreadDBPath("db_shared_wb_db" + std::to_string(i)));
-  }
-
-  Options options = CurrentOptions();
-  options.arena_block_size = 4096;
-  options.write_buffer_size = 500000;  // this is never hit
-  std::shared_ptr<Cache> cache = NewLRUCache(4 * 1024 * 1024, 2);
-  ASSERT_LT(cache->GetUsage(), 256 * 1024);
-  cost_cache_ = GetParam();
-
-  if (cost_cache_) {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, cache, true));
-  } else {
-    options.write_buffer_manager.reset(
-        new WriteBufferManager(100000, nullptr, true));
-  }
-  CreateAndReopenWithCF({"cf1", "cf2"}, options);
-
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(DestroyDB(dbnames[i], options));
-    ASSERT_OK(DB::Open(options, dbnames[i], &(dbs[i])));
-  }
-  WriteOptions wo;
-  wo.disableWAL = true;
-
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(dbs[i]->Put(wo, Key(1), DummyString(20000)));
-  }
-  // Insert to db_.
-  ASSERT_OK(Put(0, Key(1), DummyString(30000), wo));
-
-  // WriteBufferManager::buffer_size_ has exceeded after the previous write to
-  // dbs[0] is completed.
-  std::vector<port::Thread> threads;
-  int wait_count_db = 0;
-  InstrumentedMutex mutex;
-  InstrumentedCondVar cv(&mutex);
-  std::unordered_set<WriteThread::Writer*> w_slowdown_set;
-  std::vector<port::Thread> writer_threads;
-  std::atomic<int> thread_num(0);
-  std::atomic<int> w_no_slowdown(0);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0",
-        "DBImpl::BackgroundCallFlush:start"}});
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WBMStallInterface::BlockDB", [&](void*) {
-        InstrumentedMutexLock lock(&mutex);
-        wait_count_db++;
-        cv.Signal();
-        // Allow the flush continue if all writer threads are blocked.
-        if (w_slowdown_set.size() +
-                (unsigned long)(w_no_slowdown.load(std::memory_order_relaxed) +
-                                wait_count_db) ==
-            (unsigned long)(2 * num_dbs + 1)) {
-          TEST_SYNC_POINT(
-              "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-        }
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "WriteThread::WriteStall::Wait", [&](void* arg) {
-        WriteThread::Writer* w = reinterpret_cast<WriteThread::Writer*>(arg);
-        InstrumentedMutexLock lock(&mutex);
-        w_slowdown_set.insert(w);
-        // Allow the flush continue if all writer threads are blocked.
-        if (w_slowdown_set.size() +
-                (unsigned long)(w_no_slowdown.load(std::memory_order_relaxed) +
-                                wait_count_db) ==
-            (unsigned long)(2 * num_dbs + 1)) {
-          TEST_SYNC_POINT(
-              "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  bool s1 = true, s2 = true;
-  std::function<void(DB*)> write_slow_down = [&](DB* db) {
-    int a = thread_num.fetch_add(1);
-    std::string key = "foo" + std::to_string(a);
-    WriteOptions write_op;
-    write_op.no_slowdown = false;
-    Status tmp = db->Put(write_op, Slice(key), DummyString(1));
-    InstrumentedMutexLock lock(&mutex);
-    s1 = s1 && tmp.ok();
-  };
-
-  std::function<void(DB*)> write_no_slow_down = [&](DB* db) {
-    int a = thread_num.fetch_add(1);
-    std::string key = "foo" + std::to_string(a);
-    WriteOptions write_op;
-    write_op.no_slowdown = true;
-    Status tmp = db->Put(write_op, Slice(key), DummyString(1));
-    {
-      InstrumentedMutexLock lock(&mutex);
-      s2 = s2 && !tmp.ok();
-      w_no_slowdown.fetch_add(1);
-      if (w_slowdown_set.size() +
-              (unsigned long)(w_no_slowdown.load(std::memory_order_relaxed) +
-                              wait_count_db) ==
-          (unsigned long)(2 * num_dbs + 1)) {
-        TEST_SYNC_POINT(
-            "DBWriteBufferManagerTest::SharedWriteBufferAcrossCFs:0");
-      }
-    }
-  };
-
-  // Flow:
-  // first thread will write but will be blocked (as Flush will on hold,
-  // buffer_size_ has exceeded, thus will create stall in effect).
-  //  |
-  //  |
-  //  multiple writer threads will be created to write across multiple columns
-  //  of db_ and different DBs with different values of
-  //  WriteOptions.no_slowdown. Some of them will be blocked and some of them
-  //  will return with Incomplete status.
-  //  |
-  //  |
-  //  Last writer thread will write and when its blocked/return it will signal
-  //  Flush to continue to clear the stall.
-  threads.emplace_back(write_slow_down, db_);
-  // Wait untill first thread writing to DB is blocked and then
-  // create the multiple writers.
-  {
-    InstrumentedMutexLock lock(&mutex);
-    while (wait_count_db != 1) {
-      cv.Wait();
-    }
-  }
-
-  for (int i = 0; i < num_dbs; i += 2) {
-    // Write to multiple columns of db_.
-    writer_threads.emplace_back(write_slow_down, db_);
-    writer_threads.emplace_back(write_no_slow_down, db_);
-    // Write to different DBs.
-    threads.emplace_back(write_slow_down, dbs[i]);
-    threads.emplace_back(write_no_slow_down, dbs[i + 1]);
-  }
-
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  for (auto& t : writer_threads) {
-    t.join();
-  }
-
-  ASSERT_TRUE(s1);
-  ASSERT_TRUE(s2);
-  // Number of DBs blocked.
-  ASSERT_EQ((num_dbs / 2) + 1, wait_count_db);
-  // Number of writer threads writing to db_ blocked from getting added to the
-  // queue.
-  ASSERT_EQ(w_slowdown_set.size(), num_dbs / 2);
-  // Number of threads with WriteOptions.no_slowdown = true.
-  ASSERT_EQ(w_no_slowdown.load(std::memory_order_relaxed), num_dbs);
-
-  // Clean up DBs.
-  for (int i = 0; i < num_dbs; i++) {
-    ASSERT_OK(dbs[i]->Close());
-    ASSERT_OK(DestroyDB(dbnames[i], options));
-    delete dbs[i];
-  }
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-INSTANTIATE_TEST_CASE_P(DBWriteBufferManagerTest, DBWriteBufferManagerTest,
-                        testing::Bool());
-
-}  // namespace ROCKSDB_NAMESPACE
-
-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
-int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -616,7 +616,7 @@ class IterKey {
  void EnlargeBuffer(size_t key_size);
 };

-// Convert from a SliceTransform of user keys, to a SliceTransform of
+// Convert from a SliceTranform of user keys, to a SliceTransform of
 // user keys.
 class InternalKeySliceTransform : public SliceTransform {
 public:
@@ -103,7 +103,7 @@ class ErrorHandler {
    bool auto_recovery_;
    bool recovery_in_prog_;
    // A flag to indicate that for the soft error, we should not allow any
-    // background work except the work is from recovery.
+    // backrgound work execpt the work is from recovery.
    bool soft_error_no_bg_work_;

    // Used to store the context for recover, such as flush reason.
@@ -1744,14 +1744,14 @@ TEST_F(DBErrorHandlingFSTest, FLushWritNoWALRetryableErrorAutoRecover1) {
                   ERROR_HANDLER_BG_RETRYABLE_IO_ERROR_COUNT));
  ASSERT_EQ(1, options.statistics->getAndResetTickerCount(
                   ERROR_HANDLER_AUTORESUME_COUNT));
-  ASSERT_LE(0, options.statistics->getAndResetTickerCount(
+  ASSERT_EQ(2, options.statistics->getAndResetTickerCount(
                   ERROR_HANDLER_AUTORESUME_RETRY_TOTAL_COUNT));
-  ASSERT_LE(0, options.statistics->getAndResetTickerCount(
+  ASSERT_EQ(0, options.statistics->getAndResetTickerCount(
                   ERROR_HANDLER_AUTORESUME_SUCCESS_COUNT));
  HistogramData autoresume_retry;
  options.statistics->histogramData(ERROR_HANDLER_AUTORESUME_RETRY_COUNT,
                                    &autoresume_retry);
-  ASSERT_GE(autoresume_retry.max, 0);
+  ASSERT_EQ(autoresume_retry.max, 2);
  ASSERT_OK(Put(Key(2), "val2", wo));
  s = Flush();
  // Since auto resume fails, the bg error is not cleand, flush will
@@ -125,12 +125,8 @@ void EventHelpers::LogAndNotifyTableFileCreationFinished(
              << table_properties.compression_options << "creation_time"
              << table_properties.creation_time << "oldest_key_time"
              << table_properties.oldest_key_time << "file_creation_time"
-              << table_properties.file_creation_time
-              << "slow_compression_estimated_data_size"
-              << table_properties.slow_compression_estimated_data_size
-              << "fast_compression_estimated_data_size"
-              << table_properties.fast_compression_estimated_data_size
-              << "db_id" << table_properties.db_id << "db_session_id"
+              << table_properties.file_creation_time << "db_id"
+              << table_properties.db_id << "db_session_id"
              << table_properties.db_session_id;

      // user collected properties
@@ -40,25 +40,16 @@ Status ExternalSstFileIngestionJob::Prepare(
    if (!status.ok()) {
      return status;
    }
+    files_to_ingest_.push_back(file_to_ingest);
+  }

-    if (file_to_ingest.cf_id !=
+  for (const IngestedFileInfo& f : files_to_ingest_) {
+    if (f.cf_id !=
            TablePropertiesCollectorFactory::Context::kUnknownColumnFamily &&
-        file_to_ingest.cf_id != cfd_->GetID()) {
+        f.cf_id != cfd_->GetID()) {
      return Status::InvalidArgument(
          "External file column family id don't match");
    }
-
-    if (file_to_ingest.num_entries == 0 &&
-        file_to_ingest.num_range_deletions == 0) {
-      return Status::InvalidArgument("File contain no entries");
-    }
-
-    if (!file_to_ingest.smallest_internal_key.Valid() ||
-        !file_to_ingest.largest_internal_key.Valid()) {
-      return Status::Corruption("Generated table have corrupted keys");
-    }
-
-    files_to_ingest_.emplace_back(std::move(file_to_ingest));
  }

  const Comparator* ucmp = cfd_->internal_comparator().user_comparator();
@@ -92,6 +83,16 @@ Status ExternalSstFileIngestionJob::Prepare(
    return Status::NotSupported("Files have overlapping ranges");
  }

+  for (IngestedFileInfo& f : files_to_ingest_) {
+    if (f.num_entries == 0 && f.num_range_deletions == 0) {
+      return Status::InvalidArgument("File contain no entries");
+    }
+
+    if (!f.smallest_internal_key.Valid() || !f.largest_internal_key.Valid()) {
+      return Status::Corruption("Generated table have corrupted keys");
+    }
+  }
+
  // Copy/Move external files into DB
  std::unordered_set<size_t> ingestion_path_ids;
  for (IngestedFileInfo& f : files_to_ingest_) {
@@ -16,7 +16,6 @@
 #include "rocksdb/sst_file_writer.h"
 #include "test_util/testutil.h"
 #include "util/random.h"
-#include "util/thread_guard.h"
 #include "utilities/fault_injection_env.h"

 namespace ROCKSDB_NAMESPACE {
@@ -1306,38 +1305,38 @@ TEST_F(ExternalSSTFileTest, PickedLevelBug) {

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

+  // While writing the MANIFEST start a thread that will ask for compaction
  Status bg_compact_status;
+  ROCKSDB_NAMESPACE::port::Thread bg_compact([&]() {
+    bg_compact_status =
+        db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
+  });
+  TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:2");
+
+  // Start a thread that will ingest a new file
  Status bg_addfile_status;
+  ROCKSDB_NAMESPACE::port::Thread bg_addfile([&]() {
+    file_keys = {1, 2, 3};
+    bg_addfile_status = GenerateAndAddExternalFile(options, file_keys, 1);
+  });

-  {
-    // While writing the MANIFEST start a thread that will ask for compaction
-    ThreadGuard bg_compact(port::Thread([&]() {
-      bg_compact_status =
-          db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-    }));
-    TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:2");
+  // Wait for AddFile to start picking levels and writing MANIFEST
+  TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:0");

-    // Start a thread that will ingest a new file
-    ThreadGuard bg_addfile(port::Thread([&]() {
-      file_keys = {1, 2, 3};
-      bg_addfile_status = GenerateAndAddExternalFile(options, file_keys, 1);
-    }));
+  TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:3");

-    // Wait for AddFile to start picking levels and writing MANIFEST
-    TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:0");
+  // We need to verify that no compactions can run while AddFile is
+  // ingesting the files into the levels it find suitable. So we will
+  // wait for 2 seconds to give a chance for compactions to run during
+  // this period, and then make sure that no compactions where able to run
+  env_->SleepForMicroseconds(1000000 * 2);
+  ASSERT_FALSE(bg_compact_started.load());

-    TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:3");
+  // Hold AddFile from finishing writing the MANIFEST
+  TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:1");

-    // We need to verify that no compactions can run while AddFile is
-    // ingesting the files into the levels it find suitable. So we will
-    // wait for 2 seconds to give a chance for compactions to run during
-    // this period, and then make sure that no compactions where able to run
-    env_->SleepForMicroseconds(1000000 * 2);
-    ASSERT_FALSE(bg_compact_started.load());
-
-    // Hold AddFile from finishing writing the MANIFEST
-    TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:1");
-  }
+  bg_addfile.join();
+  bg_compact.join();

  ASSERT_OK(bg_addfile_status);
  ASSERT_OK(bg_compact_status);
@@ -75,8 +75,6 @@ const char* GetFlushReasonString (FlushReason flush_reason) {
      return "Manual Flush";
    case FlushReason::kErrorRecovery:
      return "Error Recovery";
-    case FlushReason::kWalFull:
-      return "WAL Full";
    default:
      return "Invalid";
  }
@@ -413,7 +411,8 @@ Status FlushJob::WriteLevel0Table() {
          cfd_->internal_comparator(), cfd_->int_tbl_prop_collector_factories(),
          cfd_->GetID(), cfd_->GetName(), existing_snapshots_,
          earliest_write_conflict_snapshot_, snapshot_checker_,
-          output_compression_, mutable_cf_options_.compression_opts,
+          output_compression_, mutable_cf_options_.sample_for_compression,
+          mutable_cf_options_.compression_opts,
          mutable_cf_options_.paranoid_file_checks, cfd_->internal_stats(),
          TableFileCreationReason::kFlush, &io_s, io_tracer_, event_logger_,
          job_context_->job_id, Env::IO_HIGH, &table_properties_, 0 /* level */,
@@ -426,7 +426,7 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
      if (seek_to_first) {
        l0_iters_[i]->SeekToFirst();
      } else {
-        // If the target key passes over the largest key, we are sure Next()
+        // If the target key passes over the larget key, we are sure Next()
        // won't go over this file.
        if (user_comparator_->Compare(target_user_key,
                                      l0[i]->largest.user_key()) > 0) {
@@ -751,24 +751,21 @@ bool InternalStats::HandleBackgroundErrors(uint64_t* value, DBImpl* /*db*/,
 bool InternalStats::HandleCurSizeActiveMemTable(uint64_t* value, DBImpl* /*db*/,
                                                Version* /*version*/) {
  // Current size of the active memtable
-  // Using ApproximateMemoryUsageFast to avoid the need for synchronization
-  *value = cfd_->mem()->ApproximateMemoryUsageFast();
+  *value = cfd_->mem()->ApproximateMemoryUsage();
  return true;
 }

 bool InternalStats::HandleCurSizeAllMemTables(uint64_t* value, DBImpl* /*db*/,
                                              Version* /*version*/) {
  // Current size of the active memtable + immutable memtables
-  // Using ApproximateMemoryUsageFast to avoid the need for synchronization
-  *value = cfd_->mem()->ApproximateMemoryUsageFast() +
+  *value = cfd_->mem()->ApproximateMemoryUsage() +
           cfd_->imm()->ApproximateUnflushedMemTablesMemoryUsage();
  return true;
 }

 bool InternalStats::HandleSizeAllMemTables(uint64_t* value, DBImpl* /*db*/,
                                           Version* /*version*/) {
-  // Using ApproximateMemoryUsageFast to avoid the need for synchronization
-  *value = cfd_->mem()->ApproximateMemoryUsageFast() +
+  *value = cfd_->mem()->ApproximateMemoryUsage() +
           cfd_->imm()->ApproximateMemoryUsage();
  return true;
 }
@@ -961,7 +958,7 @@ bool InternalStats::HandleEstimateOldestKeyTime(uint64_t* value, DBImpl* /*db*/,

 bool InternalStats::HandleBlockCacheStat(Cache** block_cache) {
  assert(block_cache != nullptr);
-  auto* table_factory = cfd_->ioptions()->table_factory.get();
+  auto* table_factory = cfd_->ioptions()->table_factory;
  assert(table_factory != nullptr);
  *block_cache =
      table_factory->GetOptions<Cache>(TableFactory::kBlockCacheOpts());
@@ -59,7 +59,7 @@ ImmutableMemTableOptions::ImmutableMemTableOptions(
      inplace_callback(ioptions.inplace_callback),
      max_successive_merges(mutable_cf_options.max_successive_merges),
      statistics(ioptions.statistics),
-      merge_operator(ioptions.merge_operator.get()),
+      merge_operator(ioptions.merge_operator),
      info_log(ioptions.info_log),
      allow_data_in_errors(ioptions.allow_data_in_errors) {}

@@ -106,7 +106,7 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
      flush_state_(FLUSH_NOT_REQUESTED),
      clock_(ioptions.clock),
      insert_with_hint_prefix_extractor_(
-          ioptions.memtable_insert_with_hint_prefix_extractor.get()),
+          ioptions.memtable_insert_with_hint_prefix_extractor),
      oldest_key_time_(std::numeric_limits<uint64_t>::max()),
      atomic_flush_seqno_(kMaxSequenceNumber),
      approximate_memory_usage_(0) {
@@ -72,7 +72,7 @@ using MultiGetRange = MultiGetContext::Range;
 // Note:  Many of the methods in this class have comments indicating that
 // external synchronization is required as these methods are not thread-safe.
 // It is up to higher layers of code to decide how to prevent concurrent
-// invocation of these methods.  This is usually done by acquiring either
+// invokation of these methods.  This is usually done by acquiring either
 // the db mutex or the single writer thread.
 //
 // Some of these methods are documented to only require external
@@ -139,7 +139,7 @@ class MemTable {
  // operations on the same MemTable (unless this Memtable is immutable).
  size_t ApproximateMemoryUsage();

-  // As a cheap version of `ApproximateMemoryUsage()`, this function doesn't
+  // As a cheap version of `ApproximateMemoryUsage()`, this function doens't
  // require external synchronization. The value may be less accurate though
  size_t ApproximateMemoryUsageFast() const {
    return approximate_memory_usage_.load(std::memory_order_relaxed);
@@ -533,7 +533,7 @@ class MemTable {
  SequenceNumber atomic_flush_seqno_;

  // keep track of memory usage in table_, arena_, and range_del_table_.
-  // Gets refreshed inside `ApproximateMemoryUsage()` or `ShouldFlushNow`
+  // Gets refrshed inside `ApproximateMemoryUsage()` or `ShouldFlushNow`
  std::atomic<uint64_t> approximate_memory_usage_;

 #ifndef ROCKSDB_LITE
@@ -521,7 +521,7 @@ void MemTableList::Add(MemTable* m, autovector<MemTable*>* to_delete) {
  InstallNewVersion();
  // this method is used to move mutable memtable into an immutable list.
  // since mutable memtable is already refcounted by the DBImpl,
-  // and when moving to the immutable list we don't unref it,
+  // and when moving to the imutable list we don't unref it,
  // we don't have to ref the memtable here. we just take over the
  // reference from the DBImpl.
  current_->Add(m, to_delete);
@@ -33,13 +33,11 @@ class OutputValidator {
    return GetHash() == other_validator.GetHash();
  }

+ private:
  // Not (yet) intended to be persisted, so subject to change
  // without notice between releases.
  uint64_t GetHash() const { return paranoid_hash_; }

-  void SetHash(uint64_t hash) { paranoid_hash_ = hash; }
-
- private:
  const InternalKeyComparator& icmp_;
  std::string prev_key_;
  uint64_t paranoid_hash_ = 0;
@@ -43,12 +43,12 @@ class TruncatedRangeDelIterator {

  void InternalNext();

-  // Seeks to the tombstone with the highest visible sequence number that covers
+  // Seeks to the tombstone with the highest viisble sequence number that covers
  // target (a user key). If no such tombstone exists, the position will be at
  // the earliest tombstone that ends after target.
  void Seek(const Slice& target);

-  // Seeks to the tombstone with the highest visible sequence number that covers
+  // Seeks to the tombstone with the highest viisble sequence number that covers
  // target (a user key). If no such tombstone exists, the position will be at
  // the latest tombstone that starts before target.
  void SeekForPrev(const Slice& target);
@@ -447,12 +447,13 @@ class Repairer {
          nullptr /* blob_file_additions */, cfd->internal_comparator(),
          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
          {}, kMaxSequenceNumber, snapshot_checker, kNoCompression,
-          CompressionOptions(), false, nullptr /* internal_stats */,
-          TableFileCreationReason::kRecovery, &io_s, nullptr /*IOTracer*/,
-          nullptr /* event_logger */, 0 /* job_id */, Env::IO_HIGH,
-          nullptr /* table_properties */, -1 /* level */, current_time,
-          0 /* oldest_key_time */, write_hint, 0 /* file_creation_time */,
-          "DB Repairer" /* db_id */, db_session_id_);
+          0 /* sample_for_compression */, CompressionOptions(), false,
+          nullptr /* internal_stats */, TableFileCreationReason::kRecovery,
+          &io_s, nullptr /*IOTracer*/, nullptr /* event_logger */,
+          0 /* job_id */, Env::IO_HIGH, nullptr /* table_properties */,
+          -1 /* level */, current_time, 0 /* oldest_key_time */, write_hint,
+          0 /* file_creation_time */, "DB Repairer" /* db_id */,
+          db_session_id_);
      ROCKS_LOG_INFO(db_options_.info_log,
                     "Log #%" PRIu64 ": %d ops saved to Table #%" PRIu64 " %s",
                     log, counter, meta.fd.GetNumber(),
@@ -23,7 +23,7 @@ class SnapshotImpl : public Snapshot {
  SequenceNumber number_;  // const after creation
  // It indicates the smallest uncommitted data at the time the snapshot was
  // taken. This is currently used by WritePrepared transactions to limit the
-  // scope of queries to IsInSnapshot.
+  // scope of queries to IsInSnpashot.
  SequenceNumber min_uncommitted_ = kMinUnCommittedSeq;

  virtual SequenceNumber GetSequenceNumber() const override { return number_; }
@@ -130,7 +130,7 @@ Status TableCache::GetTableReader(
        new RandomAccessFileReader(
            std::move(file), fname, ioptions_.clock, io_tracer_,
            record_read_stats ? ioptions_.statistics : nullptr, SST_READ_MICROS,
-            file_read_hist, ioptions_.rate_limiter.get(), ioptions_.listeners));
+            file_read_hist, ioptions_.rate_limiter, ioptions_.listeners));
    s = ioptions_.table_factory->NewTableReader(
        ro,
        TableReaderOptions(ioptions_, prefix_extractor, file_options,
@@ -183,7 +183,7 @@ class TableCache {

  Cache* get_cache() const { return cache_; }

-  // Capacity of the backing Cache that indicates infinite TableCache capacity.
+  // Capacity of the backing Cache that indicates inifinite TableCache capacity.
  // For example when max_open_files is -1 we set the backing Cache to this.
  static const int kInfiniteCapacity = 0x400000;

@@ -43,10 +43,10 @@ Status UserKeyTablePropertiesCollector::InternalAdd(const Slice& key,
 }

 void UserKeyTablePropertiesCollector::BlockAdd(
-    uint64_t block_raw_bytes, uint64_t block_compressed_bytes_fast,
-    uint64_t block_compressed_bytes_slow) {
-  return collector_->BlockAdd(block_raw_bytes, block_compressed_bytes_fast,
-                              block_compressed_bytes_slow);
+    uint64_t bLockRawBytes, uint64_t blockCompressedBytesFast,
+    uint64_t blockCompressedBytesSlow) {
+  return collector_->BlockAdd(bLockRawBytes, blockCompressedBytesFast,
+                              blockCompressedBytesSlow);
 }

 Status UserKeyTablePropertiesCollector::Finish(
@@ -27,9 +27,9 @@ class IntTblPropCollector {
  virtual Status InternalAdd(const Slice& key, const Slice& value,
                             uint64_t file_size) = 0;

-  virtual void BlockAdd(uint64_t block_raw_bytes,
-                        uint64_t block_compressed_bytes_fast,
-                        uint64_t block_compressed_bytes_slow) = 0;
+  virtual void BlockAdd(uint64_t blockRawBytes,
+                        uint64_t blockCompressedBytesFast,
+                        uint64_t blockCompressedBytesSlow) = 0;

  virtual UserCollectedProperties GetReadableProperties() const = 0;

@@ -64,9 +64,9 @@ class UserKeyTablePropertiesCollector : public IntTblPropCollector {
  virtual Status InternalAdd(const Slice& key, const Slice& value,
                             uint64_t file_size) override;

-  virtual void BlockAdd(uint64_t block_raw_bytes,
-                        uint64_t block_compressed_bytes_fast,
-                        uint64_t block_compressed_bytes_slow) override;
+  virtual void BlockAdd(uint64_t blockRawBytes,
+                        uint64_t blockCompressedBytesFast,
+                        uint64_t blockCompressedBytesSlow) override;

  virtual Status Finish(UserCollectedProperties* properties) override;

@@ -55,7 +55,8 @@ void MakeBuilder(const Options& options, const ImmutableCFOptions& ioptions,
  builder->reset(NewTableBuilder(
      ioptions, moptions, internal_comparator, int_tbl_prop_collector_factories,
      kTestColumnFamilyId, kTestColumnFamilyName, writable->get(),
-      options.compression, options.compression_opts, unknown_level));
+      options.compression, options.sample_for_compression,
+      options.compression_opts, unknown_level));
 }
 }  // namespace

@@ -175,9 +176,9 @@ class RegularKeysStartWithAInternal : public IntTblPropCollector {
    return Status::OK();
  }

-  void BlockAdd(uint64_t /* block_raw_bytes */,
-                uint64_t /* block_compressed_bytes_fast */,
-                uint64_t /* block_compressed_bytes_slow */) override {
+  void BlockAdd(uint64_t /* blockRawBytes */,
+                uint64_t /* blockCompressedBytesFast */,
+                uint64_t /* blockCompressedBytesSlow */) override {
    // Nothing to do.
    return;
  }
@@ -517,28 +517,6 @@ class VersionBuilder::Rep {
    return meta->oldest_blob_file_number;
  }

-  uint64_t GetMinOldestBlobFileNumber() const {
-    uint64_t min_oldest_blob_file_num = std::numeric_limits<uint64_t>::max();
-    for (int level = 0; level < num_levels_; ++level) {
-      const auto& base_files = base_vstorage_->LevelFiles(level);
-      for (const auto* fmeta : base_files) {
-        assert(fmeta);
-        min_oldest_blob_file_num =
-            std::min(min_oldest_blob_file_num, fmeta->oldest_blob_file_number);
-      }
-      const auto& added_files = levels_[level].added_files;
-      for (const auto& elem : added_files) {
-        assert(elem.second);
-        min_oldest_blob_file_num = std::min(
-            min_oldest_blob_file_num, elem.second->oldest_blob_file_number);
-      }
-    }
-    if (min_oldest_blob_file_num == std::numeric_limits<uint64_t>::max()) {
-      min_oldest_blob_file_num = kInvalidBlobFileNumber;
-    }
-    return min_oldest_blob_file_num;
-  }
-
  Status ApplyFileDeletion(int level, uint64_t file_number) {
    assert(level != VersionStorageInfo::FileLocation::Invalid().GetLevel());

@@ -856,7 +834,7 @@ class VersionBuilder::Rep {
    }
  }

-  // Save the current state in *vstorage.
+  // Save the current state in *v.
  Status SaveTo(VersionStorageInfo* vstorage) {
    Status s = CheckConsistency(base_vstorage_);
    if (!s.ok()) {
@@ -1074,10 +1052,6 @@ Status VersionBuilder::LoadTableHandlers(
      is_initial_load, prefix_extractor, max_file_size_for_l0_meta_pin);
 }

-uint64_t VersionBuilder::GetMinOldestBlobFileNumber() const {
-  return rep_->GetMinOldestBlobFileNumber();
-}
-
 BaseReferencedVersionBuilder::BaseReferencedVersionBuilder(
    ColumnFamilyData* cfd)
    : version_builder_(new VersionBuilder(
@@ -44,7 +44,6 @@ class VersionBuilder {
                           bool is_initial_load,
                           const SliceTransform* prefix_extractor,
                           size_t max_file_size_for_l0_meta_pin);
-  uint64_t GetMinOldestBlobFileNumber() const;

 private:
  class Rep;
@@ -74,7 +74,7 @@ enum NewFileCustomTag : uint32_t {
  kNeedCompaction = 2,
  // Since Manifest is not entirely forward-compatible, we currently encode
  // kMinLogNumberToKeep as part of NewFile as a hack. This should be removed
-  // when manifest becomes forward-compatible.
+  // when manifest becomes forward-comptabile.
  kMinLogNumberToKeepHack = 3,
  kOldestBlobFileNumber = 4,
  kOldestAncesterTime = 5,
@@ -195,7 +195,7 @@ struct FileMetaData {

  // The file could be the compaction output from other SST files, which could
  // in turn be outputs for compact older SST files. We track the memtable
-  // flush timestamp for the oldest SST file that eventually contribute data
+  // flush timestamp for the oldest SST file that eventaully contribute data
  // to this file. 0 means the information is not available.
  uint64_t oldest_ancester_time = kUnknownOldestAncesterTime;

@@ -11,8 +11,6 @@

 #include <cinttypes>

-#include "db/blob/blob_file_cache.h"
-#include "db/blob/blob_file_reader.h"
 #include "monitoring/persistent_stats_history.h"

 namespace ROCKSDB_NAMESPACE {
@@ -131,14 +129,14 @@ Status FileChecksumRetriever::ApplyVersionEdit(VersionEdit& edit,
 VersionEditHandler::VersionEditHandler(
    bool read_only, std::vector<ColumnFamilyDescriptor> column_families,
    VersionSet* version_set, bool track_missing_files,
-    bool no_error_if_files_missing, const std::shared_ptr<IOTracer>& io_tracer,
-    bool skip_load_table_files)
+    bool no_error_if_table_files_missing,
+    const std::shared_ptr<IOTracer>& io_tracer, bool skip_load_table_files)
    : VersionEditHandlerBase(),
      read_only_(read_only),
      column_families_(std::move(column_families)),
      version_set_(version_set),
      track_missing_files_(track_missing_files),
-      no_error_if_files_missing_(no_error_if_files_missing),
+      no_error_if_table_files_missing_(no_error_if_table_files_missing),
      io_tracer_(io_tracer),
      skip_load_table_files_(skip_load_table_files),
      initialized_(false) {
@@ -303,14 +301,6 @@ bool VersionEditHandler::HasMissingFiles() const {
      break;
    }
  }
-  if (!ret) {
-    for (const auto& elem : cf_to_missing_blob_files_high_) {
-      if (elem.second != kInvalidBlobFileNumber) {
-        ret = true;
-        break;
-      }
-    }
-  }
  return ret;
 }

@@ -447,8 +437,6 @@ ColumnFamilyData* VersionEditHandler::CreateCfAndInit(
  if (track_missing_files_) {
    cf_to_missing_files_.emplace(edit.column_family_,
                                 std::unordered_set<uint64_t>());
-    cf_to_missing_blob_files_high_.emplace(edit.column_family_,
-                                           kInvalidBlobFileNumber);
  }
  return cfd;
 }
@@ -462,12 +450,6 @@ ColumnFamilyData* VersionEditHandler::DestroyCfAndCleanup(
    auto missing_files_iter = cf_to_missing_files_.find(edit.column_family_);
    assert(missing_files_iter != cf_to_missing_files_.end());
    cf_to_missing_files_.erase(missing_files_iter);
-
-    auto missing_blob_files_high_iter =
-        cf_to_missing_blob_files_high_.find(edit.column_family_);
-    assert(missing_blob_files_high_iter !=
-           cf_to_missing_blob_files_high_.end());
-    cf_to_missing_blob_files_high_.erase(missing_blob_files_high_iter);
  }
  ColumnFamilyData* ret =
      version_set_->GetColumnFamilySet()->GetColumnFamily(edit.column_family_);
@@ -523,7 +505,8 @@ Status VersionEditHandler::LoadTables(ColumnFamilyData* cfd,
      prefetch_index_and_filter_in_cache, is_initial_load,
      cfd->GetLatestMutableCFOptions()->prefix_extractor.get(),
      MaxFileSizeForL0MetaPin(*cfd->GetLatestMutableCFOptions()));
-  if ((s.IsPathNotFound() || s.IsCorruption()) && no_error_if_files_missing_) {
+  if ((s.IsPathNotFound() || s.IsCorruption()) &&
+      no_error_if_table_files_missing_) {
    s = Status::OK();
  }
  if (!s.ok() && !version_set_->db_options_->paranoid_checks) {
@@ -553,13 +536,9 @@ Status VersionEditHandler::ExtractInfoFromVersionEdit(ColumnFamilyData* cfd,
    }
    if (edit.has_comparator_ &&
        edit.comparator_ != cfd->user_comparator()->Name()) {
-      if (!cf_to_cmp_names_) {
-        s = Status::InvalidArgument(
-            cfd->user_comparator()->Name(),
-            "does not match existing comparator " + edit.comparator_);
-      } else {
-        cf_to_cmp_names_->emplace(cfd->GetID(), edit.comparator_);
-      }
+      s = Status::InvalidArgument(
+          cfd->user_comparator()->Name(),
+          "does not match existing comparator " + edit.comparator_);
    }
    if (edit.HasFullHistoryTsLow()) {
      const std::string& new_ts = edit.GetFullHistoryTsLow();
@@ -597,7 +576,7 @@ VersionEditHandlerPointInTime::VersionEditHandlerPointInTime(
    VersionSet* version_set, const std::shared_ptr<IOTracer>& io_tracer)
    : VersionEditHandler(read_only, column_families, version_set,
                         /*track_missing_files=*/true,
-                         /*no_error_if_files_missing=*/true, io_tracer) {}
+                         /*no_error_if_table_files_missing=*/true, io_tracer) {}

 VersionEditHandlerPointInTime::~VersionEditHandlerPointInTime() {
  for (const auto& elem : versions_) {
@@ -647,29 +626,7 @@ Status VersionEditHandlerPointInTime::MaybeCreateVersion(
  auto missing_files_iter = cf_to_missing_files_.find(cfd->GetID());
  assert(missing_files_iter != cf_to_missing_files_.end());
  std::unordered_set<uint64_t>& missing_files = missing_files_iter->second;
-
-  auto missing_blob_files_high_iter =
-      cf_to_missing_blob_files_high_.find(cfd->GetID());
-  assert(missing_blob_files_high_iter != cf_to_missing_blob_files_high_.end());
-  const uint64_t prev_missing_blob_file_high =
-      missing_blob_files_high_iter->second;
-
-  VersionBuilder* builder = nullptr;
-
-  if (prev_missing_blob_file_high != kInvalidBlobFileNumber) {
-    auto builder_iter = builders_.find(cfd->GetID());
-    assert(builder_iter != builders_.end());
-    builder = builder_iter->second->version_builder();
-    assert(builder != nullptr);
-  }
-
-  // At this point, we have not yet applied the new version edits read from the
-  // MANIFEST. We check whether we have any missing table and blob files.
-  const bool prev_has_missing_files =
-      !missing_files.empty() ||
-      (prev_missing_blob_file_high != kInvalidBlobFileNumber &&
-       prev_missing_blob_file_high >= builder->GetMinOldestBlobFileNumber());
-
+  const bool prev_has_missing_files = !missing_files.empty();
  for (const auto& file : edit.GetDeletedFiles()) {
    uint64_t file_num = file.second;
    auto fiter = missing_files.find(file_num);
@@ -677,8 +634,6 @@ Status VersionEditHandlerPointInTime::MaybeCreateVersion(
      missing_files.erase(fiter);
    }
  }
-
-  assert(!cfd->ioptions()->cf_paths.empty());
  Status s;
  for (const auto& elem : edit.GetNewFiles()) {
    const FileMetaData& meta = elem.second;
@@ -694,60 +649,17 @@ Status VersionEditHandlerPointInTime::MaybeCreateVersion(
      break;
    }
  }
-
-  uint64_t missing_blob_file_num = prev_missing_blob_file_high;
-  for (const auto& elem : edit.GetBlobFileAdditions()) {
-    uint64_t file_num = elem.GetBlobFileNumber();
-    s = VerifyBlobFile(cfd, file_num, elem);
-    if (s.IsPathNotFound() || s.IsNotFound() || s.IsCorruption()) {
-      missing_blob_file_num = std::max(missing_blob_file_num, file_num);
-      s = Status::OK();
-    } else if (!s.ok()) {
-      break;
-    }
-  }
-
-  bool has_missing_blob_files = false;
-  if (missing_blob_file_num != kInvalidBlobFileNumber &&
-      missing_blob_file_num >= prev_missing_blob_file_high) {
-    missing_blob_files_high_iter->second = missing_blob_file_num;
-    has_missing_blob_files = true;
-  } else if (missing_blob_file_num < prev_missing_blob_file_high) {
-    assert(false);
-  }
-
-  // We still have not applied the new version edit, but have tried to add new
-  // table and blob files after verifying their presence and consistency.
-  // Therefore, we know whether we will see new missing table and blob files
-  // later after actually applying the version edit. We perform the check here
-  // and record the result.
-  const bool has_missing_files =
-      !missing_files.empty() || has_missing_blob_files;
-
  bool missing_info = !version_edit_params_.has_log_number_ ||
                      !version_edit_params_.has_next_file_number_ ||
                      !version_edit_params_.has_last_sequence_;

-  // Create version before apply edit. The version will represent the state
-  // before applying the version edit.
-  // A new version will created if:
-  // 1) no error has occurred so far, and
-  // 2) log_number_, next_file_number_ and last_sequence_ are known, and
-  // 3) any of the following:
-  //   a) no missing file before, but will have missing file(s) after applying
-  //      this version edit.
-  //   b) no missing file after applying the version edit, and the caller
-  //      explicitly request that a new version be created.
+  // Create version before apply edit
  if (s.ok() && !missing_info &&
-      ((has_missing_files && !prev_has_missing_files) ||
-       (!has_missing_files && force_create_version))) {
-    if (!builder) {
-      auto builder_iter = builders_.find(cfd->GetID());
-      assert(builder_iter != builders_.end());
-      builder = builder_iter->second->version_builder();
-      assert(builder);
-    }
-
+      ((!missing_files.empty() && !prev_has_missing_files) ||
+       (missing_files.empty() && force_create_version))) {
+    auto builder_iter = builders_.find(cfd->GetID());
+    assert(builder_iter != builders_.end());
+    auto* builder = builder_iter->second->version_builder();
    auto* version = new Version(cfd, version_set_, version_set_->file_options_,
                                *cfd->GetLatestMutableCFOptions(), io_tracer_,
                                version_set_->current_version_number_++);
@@ -775,22 +687,6 @@ Status VersionEditHandlerPointInTime::VerifyFile(const std::string& fpath,
  return version_set_->VerifyFileMetadata(fpath, fmeta);
 }

-Status VersionEditHandlerPointInTime::VerifyBlobFile(
-    ColumnFamilyData* cfd, uint64_t blob_file_num,
-    const BlobFileAddition& blob_addition) {
-  BlobFileCache* blob_file_cache = cfd->blob_file_cache();
-  assert(blob_file_cache);
-  CacheHandleGuard<BlobFileReader> blob_file_reader;
-  Status s =
-      blob_file_cache->GetBlobFileReader(blob_file_num, &blob_file_reader);
-  if (!s.ok()) {
-    return s;
-  }
-  // TODO: verify checksum
-  (void)blob_addition;
-  return s;
-}
-
 Status ManifestTailer::Initialize() {
  if (Mode::kRecovery == mode_) {
    return VersionEditHandler::Initialize();
@@ -893,21 +789,13 @@ void DumpManifestHandler::CheckIterationResult(const log::Reader& reader,
    fprintf(stdout, "%s\n", s->ToString().c_str());
    return;
  }
-  assert(cf_to_cmp_names_);
  for (auto* cfd : *(version_set_->column_family_set_)) {
    fprintf(stdout,
            "--------------- Column family \"%s\"  (ID %" PRIu32
            ") --------------\n",
            cfd->GetName().c_str(), cfd->GetID());
    fprintf(stdout, "log number: %" PRIu64 "\n", cfd->GetLogNumber());
-    auto it = cf_to_cmp_names_->find(cfd->GetID());
-    if (it != cf_to_cmp_names_->end()) {
-      fprintf(stdout,
-              "comparator: <%s>, but the comparator object is not available.\n",
-              it->second.c_str());
-    } else {
-      fprintf(stdout, "comparator: %s\n", cfd->user_comparator()->Name());
-    }
+    fprintf(stdout, "comparator: %s\n", cfd->user_comparator()->Name());
    assert(cfd->current());
    fprintf(stdout, "%s \n", cfd->current()->DebugString(hex_).c_str());
  }
@@ -97,7 +97,7 @@ using VersionBuilderUPtr = std::unique_ptr<BaseReferencedVersionBuilder>;
 // 1. Create an object of VersionEditHandler or its subclasses.
 //    VersionEditHandler handler(read_only, column_families, version_set,
 //                               track_missing_files,
-//                               no_error_if_files_missing);
+//                               no_error_if_table_files_missing);
 // 2. Status s = handler.Iterate(reader, &db_id);
 // 3. Check s and handle possible errors.
 //
@@ -109,10 +109,10 @@ class VersionEditHandler : public VersionEditHandlerBase {
      bool read_only,
      const std::vector<ColumnFamilyDescriptor>& column_families,
      VersionSet* version_set, bool track_missing_files,
-      bool no_error_if_files_missing,
+      bool no_error_if_table_files_missing,
      const std::shared_ptr<IOTracer>& io_tracer)
      : VersionEditHandler(read_only, column_families, version_set,
-                           track_missing_files, no_error_if_files_missing,
+                           track_missing_files, no_error_if_table_files_missing,
                           io_tracer, /*skip_load_table_files=*/false) {}

  ~VersionEditHandler() override {}
@@ -133,7 +133,7 @@ class VersionEditHandler : public VersionEditHandlerBase {
  explicit VersionEditHandler(
      bool read_only, std::vector<ColumnFamilyDescriptor> column_families,
      VersionSet* version_set, bool track_missing_files,
-      bool no_error_if_files_missing,
+      bool no_error_if_table_files_missing,
      const std::shared_ptr<IOTracer>& io_tracer, bool skip_load_table_files);

  Status ApplyVersionEdit(VersionEdit& edit, ColumnFamilyData** cfd) override;
@@ -183,12 +183,10 @@ class VersionEditHandler : public VersionEditHandlerBase {
  const bool track_missing_files_;
  std::unordered_map<uint32_t, std::unordered_set<uint64_t>>
      cf_to_missing_files_;
-  std::unordered_map<uint32_t, uint64_t> cf_to_missing_blob_files_high_;
-  bool no_error_if_files_missing_;
+  bool no_error_if_table_files_missing_;
  std::shared_ptr<IOTracer> io_tracer_;
  bool skip_load_table_files_;
  bool initialized_;
-  std::unique_ptr<std::unordered_map<uint32_t, std::string>> cf_to_cmp_names_;

 private:
  Status ExtractInfoFromVersionEdit(ColumnFamilyData* cfd,
@@ -215,8 +213,6 @@ class VersionEditHandlerPointInTime : public VersionEditHandler {
                            bool force_create_version) override;
  virtual Status VerifyFile(const std::string& fpath,
                            const FileMetaData& fmeta);
-  virtual Status VerifyBlobFile(ColumnFamilyData* cfd, uint64_t blob_file_num,
-                                const BlobFileAddition& blob_addition);

  std::unordered_map<uint32_t, Version*> versions_;
 };
@@ -271,14 +267,12 @@ class DumpManifestHandler : public VersionEditHandler {
      : VersionEditHandler(
            /*read_only=*/true, column_families, version_set,
            /*track_missing_files=*/false,
-            /*no_error_if_files_missing=*/false, io_tracer,
+            /*no_error_if_table_files_missing=*/false, io_tracer,
            /*skip_load_table_files=*/true),
        verbose_(verbose),
        hex_(hex),
        json_(json),
-        count_(0) {
-    cf_to_cmp_names_.reset(new std::unordered_map<uint32_t, std::string>());
-  }
+        count_(0) {}

  ~DumpManifestHandler() override {}

@@ -408,7 +408,7 @@ class FilePickerMultiGet {
  int GetCurrentLevel() const { return curr_level_; }

  // Iterates through files in the current level until it finds a file that
-  // contains at least one key from the MultiGet batch
+  // contains atleast one key from the MultiGet batch
  bool GetNextFileInLevelWithKeys(MultiGetRange* next_file_range,
                                  size_t* file_index, FdWithKeyRange** fd,
                                  bool* is_last_key_in_file) {
@@ -1768,8 +1768,8 @@ Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
                                       : cfd_->ioptions()->statistics),
      table_cache_((cfd_ == nullptr) ? nullptr : cfd_->table_cache()),
      blob_file_cache_(cfd_ ? cfd_->blob_file_cache() : nullptr),
-      merge_operator_(
-          (cfd_ == nullptr) ? nullptr : cfd_->ioptions()->merge_operator.get()),
+      merge_operator_((cfd_ == nullptr) ? nullptr
+                                        : cfd_->ioptions()->merge_operator),
      storage_info_(
          (cfd_ == nullptr) ? nullptr : &cfd_->internal_comparator(),
          (cfd_ == nullptr) ? nullptr : cfd_->user_comparator(),
@@ -2786,7 +2786,7 @@ struct Fsize {
  FileMetaData* file;
 };

-// Comparator that is used to sort files based on their size
+// Compator that is used to sort files based on their size
 // In normal mode: descending size
 bool CompareCompensatedSizeDescending(const Fsize& first, const Fsize& second) {
  return (first.file->compensated_file_size >
@@ -3206,7 +3206,7 @@ void VersionStorageInfo::GetCleanInputsWithinInterval(
 // specified range. From that file, iterate backwards and
 // forwards to find all overlapping files.
 // if within_range is set, then only store the maximum clean inputs
-// within range [begin, end]. "clean" means there is a boundary
+// within range [begin, end]. "clean" means there is a boudnary
 // between the files in "*inputs" and the surrounding files
 void VersionStorageInfo::GetOverlappingInputsRangeBinarySearch(
    int level, const InternalKey* begin, const InternalKey* end,
@@ -3517,7 +3517,7 @@ void VersionStorageInfo::CalculateBaseBytes(const ImmutableCFOptions& ioptions,
        //   1. the L0 size is larger than level size base, or
        //   2. number of L0 files reaches twice the L0->L1 compaction trigger
        // We don't do this otherwise to keep the LSM-tree structure stable
-        // unless the L0 compaction is backlogged.
+        // unless the L0 compation is backlogged.
        base_level_size = l0_size;
        if (base_level_ == num_levels_ - 1) {
          level_multiplier_ = 1.0;
@@ -4391,7 +4391,7 @@ Status VersionSet::ProcessManifestWrites(
  return s;
 }

-// 'datas' is grammatically incorrect. We still use this notation to indicate
+// 'datas' is gramatically incorrect. We still use this notation to indicate
 // that this variable represents a collection of column_family_data.
 Status VersionSet::LogAndApply(
    const autovector<ColumnFamilyData*>& column_family_datas,
@@ -4527,6 +4527,60 @@ Status VersionSet::LogAndApplyHelper(ColumnFamilyData* cfd,
  return builder ? builder->Apply(edit) : Status::OK();
 }

+Status VersionSet::ExtractInfoFromVersionEdit(
+    ColumnFamilyData* cfd, const VersionEdit& from_edit,
+    VersionEditParams* version_edit_params) {
+  if (cfd != nullptr) {
+    if (from_edit.has_db_id_) {
+      version_edit_params->SetDBId(from_edit.db_id_);
+    }
+    if (from_edit.has_log_number_) {
+      if (cfd->GetLogNumber() > from_edit.log_number_) {
+        ROCKS_LOG_WARN(
+            db_options_->info_log,
+            "MANIFEST corruption detected, but ignored - Log numbers in "
+            "records NOT monotonically increasing");
+      } else {
+        cfd->SetLogNumber(from_edit.log_number_);
+        version_edit_params->SetLogNumber(from_edit.log_number_);
+      }
+    }
+    if (from_edit.has_comparator_ &&
+        from_edit.comparator_ != cfd->user_comparator()->Name()) {
+      return Status::InvalidArgument(
+          cfd->user_comparator()->Name(),
+          "does not match existing comparator " + from_edit.comparator_);
+    }
+    if (from_edit.HasFullHistoryTsLow()) {
+      const std::string& new_ts = from_edit.GetFullHistoryTsLow();
+      cfd->SetFullHistoryTsLow(new_ts);
+    }
+  }
+
+  if (from_edit.has_prev_log_number_) {
+    version_edit_params->SetPrevLogNumber(from_edit.prev_log_number_);
+  }
+
+  if (from_edit.has_next_file_number_) {
+    version_edit_params->SetNextFile(from_edit.next_file_number_);
+  }
+
+  if (from_edit.has_max_column_family_) {
+    version_edit_params->SetMaxColumnFamily(from_edit.max_column_family_);
+  }
+
+  if (from_edit.has_min_log_number_to_keep_) {
+    version_edit_params->min_log_number_to_keep_ =
+        std::max(version_edit_params->min_log_number_to_keep_,
+                 from_edit.min_log_number_to_keep_);
+  }
+
+  if (from_edit.has_last_sequence_) {
+    version_edit_params->SetLastSequence(from_edit.last_sequence_);
+  }
+  return Status::OK();
+}
+
 Status VersionSet::GetCurrentManifestPath(const std::string& dbname,
                                          FileSystem* fs,
                                          std::string* manifest_path,
@@ -4593,10 +4647,10 @@ Status VersionSet::Recover(
    reporter.status = &log_read_status;
    log::Reader reader(nullptr, std::move(manifest_file_reader), &reporter,
                       true /* checksum */, 0 /* log_number */);
-    VersionEditHandler handler(read_only, column_families,
-                               const_cast<VersionSet*>(this),
-                               /*track_missing_files=*/false,
-                               /*no_error_if_files_missing=*/false, io_tracer_);
+    VersionEditHandler handler(
+        read_only, column_families, const_cast<VersionSet*>(this),
+        /*track_missing_files=*/false,
+        /*no_error_if_table_files_missing=*/false, io_tracer_);
    handler.Iterate(reader, &log_read_status);
    s = handler.status();
    if (s.ok()) {
@@ -4779,7 +4833,7 @@ Status VersionSet::TryRecoverFromOneManifest(
 Status VersionSet::ListColumnFamilies(std::vector<std::string>* column_families,
                                      const std::string& dbname,
                                      FileSystem* fs) {
-  // these are just for performance reasons, not correctness,
+  // these are just for performance reasons, not correcntes,
  // so we're fine using the defaults
  FileOptions soptions;
  // Read "CURRENT" file, which contains a pointer to the current manifest file
@@ -4920,7 +4974,7 @@ Status VersionSet::ReduceNumberOfLevels(const std::string& dbname,
 }

 // Get the checksum information including the checksum and checksum function
-// name of all SST and blob files in VersionSet. Store the information in
+// name of all SST files in VersionSet. Store the information in
 // FileChecksumList which contains a map from file number to its checksum info.
 // If DB is not running, make sure call VersionSet::Recover() to load the file
 // metadata from Manifest to VersionSet before calling this function.
@@ -4937,7 +4991,6 @@ Status VersionSet::GetLiveFilesChecksumInfo(FileChecksumList* checksum_list) {
    if (cfd->IsDropped() || !cfd->initialized()) {
      continue;
    }
-    /* SST files */
    for (int level = 0; level < cfd->NumberLevels(); level++) {
      for (const auto& file :
           cfd->current()->storage_info()->LevelFiles(level)) {
@@ -4945,36 +4998,17 @@ Status VersionSet::GetLiveFilesChecksumInfo(FileChecksumList* checksum_list) {
                                                 file->file_checksum,
                                                 file->file_checksum_func_name);
        if (!s.ok()) {
-          return s;
+          break;
        }
      }
-    }
-
-    /* Blob files */
-    const auto& blob_files = cfd->current()->storage_info()->GetBlobFiles();
-    for (const auto& pair : blob_files) {
-      const uint64_t blob_file_number = pair.first;
-      const auto& meta = pair.second;
-
-      assert(meta);
-      assert(blob_file_number == meta->GetBlobFileNumber());
-
-      std::string checksum_value = meta->GetChecksumValue();
-      std::string checksum_method = meta->GetChecksumMethod();
-      assert(checksum_value.empty() == checksum_method.empty());
-      if (meta->GetChecksumMethod().empty()) {
-        checksum_value = kUnknownFileChecksum;
-        checksum_method = kUnknownFileChecksumFuncName;
-      }
-
-      s = checksum_list->InsertOneFileChecksum(blob_file_number, checksum_value,
-                                               checksum_method);
      if (!s.ok()) {
-        return s;
+        break;
      }
    }
+    if (!s.ok()) {
+      break;
+    }
  }
-
  return s;
 }

@@ -5502,6 +5536,20 @@ bool VersionSet::VerifyCompactionFileConsistency(Compaction* c) {
        "[%s] compaction output being applied to a different base version from"
        " input version",
        c->column_family_data()->GetName().c_str());
+
+    if (vstorage->compaction_style_ == kCompactionStyleLevel &&
+        c->start_level() == 0 && c->num_input_levels() > 2U) {
+      // We are doing a L0->base_level compaction. The assumption is if
+      // base level is not L1, levels from L1 to base_level - 1 is empty.
+      // This is ensured by having one compaction from L0 going on at the
+      // same time in level-based compaction. So that during the time, no
+      // compaction/flush can put files to those levels.
+      for (int l = c->start_level() + 1; l < c->output_level(); l++) {
+        if (vstorage->NumLevelFiles(l) != 0) {
+          return false;
+        }
+      }
+    }
  }

  for (size_t input = 0; input < c->num_input_levels(); ++input) {
@@ -1331,6 +1331,10 @@ class VersionSet {
  ColumnFamilyData* CreateColumnFamily(const ColumnFamilyOptions& cf_options,
                                       const VersionEdit* edit);

+  Status ExtractInfoFromVersionEdit(ColumnFamilyData* cfd,
+                                    const VersionEdit& from_edit,
+                                    VersionEditParams* version_edit_params);
+
  Status VerifyFileMetadata(const std::string& fpath,
                            const FileMetaData& meta) const;

@@ -2781,7 +2781,7 @@ class VersionSetTestMissingFiles : public VersionSetTestBase,
          TableBuilderOptions(
              immutable_cf_options_, mutable_cf_options_, *internal_comparator_,
              &int_tbl_prop_collector_factories, kNoCompression,
-              CompressionOptions(),
+              /*_sample_for_compression=*/0, CompressionOptions(),
              /*_skip_filters=*/false, info.column_family, info.level),
          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily,
          fwriter.get()));
@@ -2793,9 +2793,11 @@ class VersionSetTestMissingFiles : public VersionSetTestBase,
      s = fs_->GetFileSize(fname, IOOptions(), &file_size, nullptr);
      ASSERT_OK(s);
      ASSERT_NE(0, file_size);
-      file_metas->emplace_back(file_num, /*file_path_id=*/0, file_size, ikey,
-                               ikey, 0, 0, false, 0, 0, 0, kUnknownFileChecksum,
-                               kUnknownFileChecksumFuncName);
+      FileMetaData meta;
+      meta = FileMetaData(file_num, /*file_path_id=*/0, file_size, ikey, ikey,
+                          0, 0, false, 0, 0, 0, kUnknownFileChecksum,
+                          kUnknownFileChecksumFuncName);
+      file_metas->emplace_back(meta);
    }
  }

@@ -134,8 +134,8 @@ Status WalManager::GetUpdatesSince(
 //    b. get sorted non-empty archived logs
 //    c. delete what should be deleted
 void WalManager::PurgeObsoleteWALFiles() {
-  bool const ttl_enabled = db_options_.WAL_ttl_seconds > 0;
-  bool const size_limit_enabled = db_options_.WAL_size_limit_MB > 0;
+  bool const ttl_enabled = db_options_.wal_ttl_seconds > 0;
+  bool const size_limit_enabled = db_options_.wal_size_limit_mb > 0;
  if (!ttl_enabled && !size_limit_enabled) {
    return;
  }
@@ -150,7 +150,7 @@ void WalManager::PurgeObsoleteWALFiles() {
  }
  uint64_t const now_seconds = static_cast<uint64_t>(current_time);
  uint64_t const time_to_check = (ttl_enabled && !size_limit_enabled)
-                                     ? db_options_.WAL_ttl_seconds / 2
+                                     ? db_options_.wal_ttl_seconds / 2
                                     : kDefaultIntervalToDeleteObsoleteWAL;

  if (purge_wal_files_last_run_ + time_to_check > now_seconds) {
@@ -185,7 +185,7 @@ void WalManager::PurgeObsoleteWALFiles() {
                         s.ToString().c_str());
          continue;
        }
-        if (now_seconds - file_m_time > db_options_.WAL_ttl_seconds) {
+        if (now_seconds - file_m_time > db_options_.wal_ttl_seconds) {
          s = DeleteDBFile(&db_options_, file_path, archival_dir, false,
                           /*force_fg=*/!wal_in_db_path_);
          if (!s.ok()) {
@@ -234,8 +234,8 @@ void WalManager::PurgeObsoleteWALFiles() {
    return;
  }

-  size_t const files_keep_num = static_cast<size_t>(
-      db_options_.WAL_size_limit_MB * 1024 * 1024 / log_file_size);
+  size_t const files_keep_num =
+      static_cast<size_t>(db_options_.wal_size_limit_mb * 1024 * 1024 / log_file_size);
  if (log_files_num <= files_keep_num) {
    return;
  }
@@ -217,8 +217,8 @@ int CountRecords(TransactionLogIterator* iter) {
 }  // namespace

 TEST_F(WalManagerTest, WALArchivalSizeLimit) {
-  db_options_.WAL_ttl_seconds = 0;
-  db_options_.WAL_size_limit_MB = 1000;
+  db_options_.wal_ttl_seconds = 0;
+  db_options_.wal_size_limit_mb = 1000;
  Init();

  // TEST : Create WalManager with huge size limit and no ttl.
@@ -226,7 +226,7 @@ TEST_F(WalManagerTest, WALArchivalSizeLimit) {
  // Count the archived log files that survived.
  // Assert that all of them did.
  // Change size limit. Re-open WalManager.
-  // Assert that archive is not greater than WAL_size_limit_MB after
+  // Assert that archive is not greater than wal_size_limit_mb after
  // PurgeObsoleteWALFiles()
  // Set ttl and time_to_check_ to small values. Re-open db.
  // Assert that there are no archived logs left.
@@ -238,14 +238,14 @@ TEST_F(WalManagerTest, WALArchivalSizeLimit) {
      ListSpecificFiles(env_.get(), archive_dir, kWalFile);
  ASSERT_EQ(log_files.size(), 20U);

-  db_options_.WAL_size_limit_MB = 8;
+  db_options_.wal_size_limit_mb = 8;
  Reopen();
  wal_manager_->PurgeObsoleteWALFiles();

  uint64_t archive_size = GetLogDirSize(archive_dir, env_.get());
-  ASSERT_TRUE(archive_size <= db_options_.WAL_size_limit_MB * 1024 * 1024);
+  ASSERT_TRUE(archive_size <= db_options_.wal_size_limit_mb * 1024 * 1024);

-  db_options_.WAL_ttl_seconds = 1;
+  db_options_.wal_ttl_seconds = 1;
  env_->FakeSleepForMicroseconds(2 * 1000 * 1000);
  Reopen();
  wal_manager_->PurgeObsoleteWALFiles();
@@ -255,7 +255,7 @@ TEST_F(WalManagerTest, WALArchivalSizeLimit) {
 }

 TEST_F(WalManagerTest, WALArchivalTtl) {
-  db_options_.WAL_ttl_seconds = 1000;
+  db_options_.wal_ttl_seconds = 1000;
  Init();

  // TEST : Create WalManager with a ttl and no size limit.
@@ -271,7 +271,7 @@ TEST_F(WalManagerTest, WALArchivalTtl) {
      ListSpecificFiles(env_.get(), archive_dir, kWalFile);
  ASSERT_GT(log_files.size(), 0U);

-  db_options_.WAL_ttl_seconds = 1;
+  db_options_.wal_ttl_seconds = 1;
  env_->FakeSleepForMicroseconds(3 * 1000 * 1000);
  Reopen();
  wal_manager_->PurgeObsoleteWALFiles();
@@ -241,7 +241,6 @@ bool WriteThread::LinkOne(Writer* w, std::atomic<Writer*>* newest_writer) {
        MutexLock lock(&stall_mu_);
        writers = newest_writer->load(std::memory_order_relaxed);
        if (writers == &write_stall_dummy_) {
-          TEST_SYNC_POINT_CALLBACK("WriteThread::WriteStall::Wait", w);
          stall_cv_.Wait();
          // Load newest_writers_ again since it may have changed
          writers = newest_writer->load(std::memory_order_relaxed);
@@ -30,7 +30,7 @@ enum ROCKSDB_NAMESPACE::ChecksumType checksum_type_e =
    ROCKSDB_NAMESPACE::kCRC32c;
 enum RepFactory FLAGS_rep_factory = kSkipList;
 std::vector<double> sum_probs(100001);
-constexpr int64_t zipf_sum_size = 100000;
+int64_t zipf_sum_size = 100000;

 namespace ROCKSDB_NAMESPACE {

@@ -233,15 +233,6 @@ size_t GenerateValue(uint32_t rand, char* v, size_t max_sz) {
  return value_sz;  // the size of the value set.
 }

-std::string NowNanosStr() {
-  uint64_t t = db_stress_env->NowNanos();
-  std::string ret;
-  PutFixed64(&ret, t);
-  return ret;
-}
-
-std::string GenerateTimestampForRead() { return NowNanosStr(); }
-
 namespace {

 class MyXXH64Checksum : public FileChecksumGenerator {
@@ -260,11 +260,9 @@ DECLARE_bool(enable_compaction_filter);
 DECLARE_bool(paranoid_file_checks);
 DECLARE_uint64(batch_protection_bytes_per_key);

-DECLARE_uint64(user_timestamp_size);
-
-constexpr long KB = 1024;
-constexpr int kRandomValueMaxFactor = 3;
-constexpr int kValueMaxLen = 100;
+const long KB = 1024;
+const int kRandomValueMaxFactor = 3;
+const int kValueMaxLen = 100;

 // wrapped posix or hdfs environment
 extern ROCKSDB_NAMESPACE::Env* db_stress_env;
@@ -563,9 +561,6 @@ extern StressTest* CreateNonBatchedOpsStressTest();
 extern void InitializeHotKeyGenerator(double alpha);
 extern int64_t GetOneHotKeyID(double rand_seed, int64_t max_key);

-extern std::string GenerateTimestampForRead();
-extern std::string NowNanosStr();
-
 std::shared_ptr<FileChecksumGenFactory> GetFileChecksumImpl(
    const std::string& name);
 }  // namespace ROCKSDB_NAMESPACE
Author	SHA1	Message	Date
Zhichao Cao	fd8247b1be	update HISTORY.md and bump version for 6.19.4	2021-04-23 15:42:04 -07:00
Zhichao Cao	fe352574b4	Fix the false positive alert of CF consistency check in WAL recovery (#8207 ) Summary: In current RocksDB, in recover the information form WAL, we do the consistency check for each column family when one WAL file is corrupted and PointInTimeRecovery is set. However, it will report a false positive alert on "SST file is ahead of WALs" when one of the CF current log number is greater than the corrupted WAL number (CF contains the data beyond the corrupted WAl) due to a new column family creation during flush. In this case, a new WAL is created (it is empty) during a flush. Also, due to some reason (e.g., storage issue or crash happens before SyncCloseLog is called), the old WAL is corrupted. The new CF has no data, therefore, it does not have the consistency issue. Fix: when checking cfd->GetLogNumber() > corrupted_wal_number also check cfd->GetLiveSstFilesSize() > 0. So the CFs with no SST file data will skip the check here. Note potential ignored inconsistency caused due to fix: empty CF can also be caused by write+delete. In this case, after flush, there is no SST files being generated. However, this CF still have the log in the WAL. When the WAL is corrupted, the DB might be inconsistent. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8207 Test Plan: added unit test, make crash_test Reviewed By: riversand963 Differential Revision: D27898839 Pulled By: zhichao-cao fbshipit-source-id: 931fc2d8b92dd00b4169bf84b94e712fd688a83e	2021-04-23 15:39:35 -07:00
Andrew Kryczka	6fbe42a6fd	Fix seqno in ingested file boundary key metadata (#8209 ) Summary: Fixes https://github.com/facebook/rocksdb/issues/6245. Adapted from https://github.com/facebook/rocksdb/issues/8201 and https://github.com/facebook/rocksdb/issues/8205. Previously we were writing the ingested file's smallest/largest internal keys with sequence number zero, or `kMaxSequenceNumber` in case of range tombstone. The former (sequence number zero) is incorrect and can lead to files being incorrectly ordered. The fix in this PR is to overwrite boundary keys that have sequence number zero with the ingested file's assigned sequence number. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8209 Test Plan: repro unit test Reviewed By: riversand963 Differential Revision: D27885678 Pulled By: ajkr fbshipit-source-id: 4a9f2c6efdfff81c3a9923e915ea88b250ee7b6a	2021-04-23 15:37:41 -07:00
Andrew Gallagher	e6c47cd6cc	Cleanup include (#8208 ) Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/8208 Make include of "file_system.h" use the same include path as everywhere else. Reviewed By: riversand963, akankshamahajan15 Differential Revision: D27881606 fbshipit-source-id: fc1e076229fde21041a813c655ce017b5070c8b3	2021-04-20 15:24:25 -07:00
Yanqin Jin	645c445978	Bump version	2021-04-19 19:57:42 -07:00
Yanqin Jin	f952de5be2	Handle rename() failure in non-local FS (#8192 ) Summary: In a distributed environment, a file `rename()` operation can succeed on server (remote) side, but the client can somehow return non-ok status to RocksDB. Possible reasons include network partition, connection issue, etc. This happens in `rocksdb::SetCurrentFile()`, which can be called in `LogAndApply() -> ProcessManifestWrites()` if RocksDB tries to switch to a new MANIFEST. We currently always delete the new MANIFEST if an error occurs. This is problematic in distributed world. If the server-side successfully updates the CURRENT file via renaming, then a subsequent `DB::Open()` will try to look for the new MANIFEST and fail. As a fix, we can track the execution result of IO operations on the new MANIFEST. - If IO operations on the new MANIFEST fail, then we know the CURRENT must point to the original MANIFEST. Therefore, it is safe to remove the new MANIFEST. - If IO operations on the new MANIFEST all succeed, but somehow we end up in the clean up code block, then we do not know whether CURRENT points to the new or old MANIFEST. (For local POSIX-compliant FS, it should still point to old MANIFEST, but it does not matter if we keep the new MANIFEST.) Therefore, we keep the new MANIFEST. - Any future `LogAndApply()` will switch to a new MANIFEST and update CURRENT. - If process reopens the db immediately after the failure, then the CURRENT file can point to either the new MANIFEST or the old one, both of which exist. Therefore, recovery can succeed and ignore the other. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8192 Test Plan: make check Reviewed By: zhichao-cao Differential Revision: D27804648 Pulled By: riversand963 fbshipit-source-id: 9c16f2a5ce41bc6aadf085e48449b19ede8423e4	2021-04-19 19:56:59 -07:00
Adam Retter	4362985805	Fix Windows strcmp for Unicode (#8190 ) Summary: The code for strcmp that was present does work when compiled for Windows unicode file paths. Needs backporting to: * 6.17.fb * 6.18.fb * 6.19.fb Pull Request resolved: https://github.com/facebook/rocksdb/pull/8190 Reviewed By: akankshamahajan15 Differential Revision: D27765588 Pulled By: jay-zhuang fbshipit-source-id: 89f8a5ac61fd7edc758340dfd335b0a5f96dae6e	2021-04-19 08:41:06 -07:00
Yanqin Jin	85cdad116b	Update history and bump version	2021-04-08 11:26:13 -07:00
Yanqin Jin	07e3794972	Fix a bug for SeekForPrev with partitioned filter and prefix (#8137 ) Summary: According to https://github.com/facebook/rocksdb/issues/5907, each filter partition "should include the bloom of the prefix of the last key in the previous partition" so that SeekForPrev() in prefix mode can return correct result. The prefix of the last key in the previous partition does not necessarily have the same prefix as the first key in the current partition. Regardless of the first key in current partition, the prefix of the last key in the previous partition should be added. The existing code, however, does not follow this. Furthermore, there is another issue: when finishing current filter partition, `FullFilterBlockBuilder::AddPrefix()` is called for the first key in next filter partition, which effectively overwrites `last_prefix_str_` prematurely. Consequently, when the filter block builder proceeds to the next partition, `last_prefix_str_` will be the prefix of its first key, leaving no way of adding the bloom of the prefix of the last key of the previous partition. Prefix extractor is FixedLength.2. ``` [ filter part 1 ] [ filter part 2 ] abc d ``` When SeekForPrev("abcd"), checking the filter partition will land on filter part 2 because "abcd" > "abc" but smaller than "d". If the filter in filter part 2 happens to return false for the test for "ab", then SeekForPrev("abcd") will build incorrect iterator tree in non-total-order mode. Also fix a unit test which starts to fail following this PR. `InDomain` should not fail due to assertion error when checking on an arbitrary key. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8137 Test Plan: ``` make check ``` Without this fix, the following command will fail pretty soon. ``` ./db_stress --acquire_snapshot_one_in=10000 --avoid_flush_during_recovery=0 \ --avoid_unnecessary_blocking_io=0 --backup_max_size=104857600 --backup_one_in=0 \ --batch_protection_bytes_per_key=0 --block_size=16384 --bloom_bits=17 \ --bottommost_compression_type=disable --cache_index_and_filter_blocks=1 --cache_size=1048576 \ --checkpoint_one_in=0 --checksum_type=kxxHash64 --clear_column_family_one_in=0 \ --compact_files_one_in=1000000 --compact_range_one_in=1000000 --compaction_ttl=0 \ --compression_max_dict_buffer_bytes=0 --compression_max_dict_bytes=0 \ --compression_parallel_threads=1 --compression_type=zstd --compression_zstd_max_train_bytes=0 \ --continuous_verification_interval=0 --db=/dev/shm/rocksdb/rocksdb_crashtest_whitebox \ --db_write_buffer_size=8388608 --delpercent=5 --delrangepercent=0 --destroy_db_initially=0 --enable_blob_files=0 \ --enable_compaction_filter=0 --enable_pipelined_write=1 --file_checksum_impl=big --flush_one_in=1000000 \ --format_version=5 --get_current_wal_file_one_in=0 --get_live_files_one_in=1000000 --get_property_one_in=1000000 \ --get_sorted_wal_files_one_in=0 --index_block_restart_interval=4 --index_type=2 --ingest_external_file_one_in=0 \ --iterpercent=10 --key_len_percent_dist=1,30,69 --level_compaction_dynamic_level_bytes=True \ --log2_keys_per_lock=10 --long_running_snapshots=1 --mark_for_compaction_one_file_in=0 \ --max_background_compactions=20 --max_bytes_for_level_base=10485760 --max_key=100000000 --max_key_len=3 \ --max_manifest_file_size=1073741824 --max_write_batch_group_size_bytes=16777216 --max_write_buffer_number=3 \ --max_write_buffer_size_to_maintain=8388608 --memtablerep=skip_list --mmap_read=1 --mock_direct_io=False \ --nooverwritepercent=0 --open_files=500000 --ops_per_thread=20000000 --optimize_filters_for_memory=0 --paranoid_file_checks=1 --partition_filters=1 --partition_pinning=0 --pause_background_one_in=1000000 \ --periodic_compaction_seconds=0 --prefixpercent=5 --progress_reports=0 --read_fault_one_in=0 --read_only=0 \ --readpercent=45 --recycle_log_file_num=0 --reopen=20 --secondary_catch_up_one_in=0 \ --snapshot_hold_ops=100000 --sst_file_manager_bytes_per_sec=104857600 \ --sst_file_manager_bytes_per_truncate=0 --subcompactions=2 --sync=0 --sync_fault_injection=False \ --target_file_size_base=2097152 --target_file_size_multiplier=2 --test_batches_snapshots=0 --test_cf_consistency=0 \ --top_level_index_pinning=0 --unpartitioned_pinning=1 --use_blob_db=0 --use_block_based_filter=0 \ --use_direct_io_for_flush_and_compaction=0 --use_direct_reads=0 --use_full_merge_v1=0 --use_merge=0 \ --use_multiget=0 --use_ribbon_filter=0 --use_txn=0 --user_timestamp_size=8 --verify_checksum=1 \ --verify_checksum_one_in=1000000 --verify_db_one_in=100000 --write_buffer_size=4194304 \ --write_dbid_to_manifest=1 --writepercent=35 ``` Reviewed By: pdillinger Differential Revision: D27553054 Pulled By: riversand963 fbshipit-source-id: 60e391e4a2d8d98a9a3172ec5d6176b90ec3de98	2021-04-08 11:21:00 -07:00
Adam Retter	1624f20934	Update ZStd. Fixes an issue with Make 3.82 (#8155 ) Summary: The previous version of ZStd doesn't build correctly with Make 3.82. Updating it resolves the issue. jay-zhuang This also needs to be cherry-picked to: 1. 6.17.fb 2. 6.18.fb 3. 6.19.fb Pull Request resolved: https://github.com/facebook/rocksdb/pull/8155 Reviewed By: riversand963 Differential Revision: D27596460 Pulled By: ajkr fbshipit-source-id: ac8492245e6273f54efcc1587346a797a91c9441	2021-04-08 09:04:45 -07:00
Andrew Gallagher	1e96a70be4	Use `include_paths` instead of raw `-I` in TARGETS (#8143 ) Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/8143 The latter assume the location of the compile root, which can break if the build root changes. Switch to the slightly more intelligent `include_paths`, which should provide the same functionality, but do with independent of include root. Reviewed By: riversand963 Differential Revision: D27535869 fbshipit-source-id: 0129e47c0ce23e08528c9139114a591c14866fa8	2021-04-05 14:38:18 -07:00
Andrew Kryczka	efe9d5c823	update HISTORY.md and bump version for 6.19.1	2021-04-01 10:01:18 -07:00
Andrew Kryczka	a265ac75ab	Fix compression dictionary sampling with dedicated range tombstone SSTs (#8141 ) Summary: Return early in case there are zero data blocks when `BlockBasedTableBuilder::EnterUnbuffered()` is called. This crash can only be triggered by applying dictionary compression to SST files that contain only range tombstones. It cannot be triggered by a low buffer limit alone since we only consider entering unbuffered mode after buffering a data block causing the limit to be breached, or `Finish()`ing the file. It also cannot be triggered by a totally empty file because those go through `Abandon()` rather than `Finish()` so unbuffered mode is never entered. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8141 Test Plan: added a unit test that repro'd the "Floating point exception" Reviewed By: riversand963 Differential Revision: D27495640 Pulled By: ajkr fbshipit-source-id: a463cfba476919dc5c5c380800a75a86c31ffa23	2021-04-01 10:00:27 -07:00
Adam Retter	9435b2e959	range_tree requires GNU libc on ppc64 (#8070 ) Summary: If the platform is ppc64 and the libc is not GNU libc, then we exclude the range_tree from compilation. See https://jira.percona.com/browse/PS-7559 Pull Request resolved: https://github.com/facebook/rocksdb/pull/8070 Reviewed By: jay-zhuang Differential Revision: D27246004 Pulled By: mrambacher fbshipit-source-id: 59d8433242ce7ce608988341becb4f83312445f5	2021-03-30 16:04:52 -07:00
Zhichao Cao	0f8c041ea7	Remove disabled tests (#8123 ) Summary: Remove disabled tests Pull Request resolved: https://github.com/facebook/rocksdb/pull/8123 Test Plan: make check Reviewed By: ltamasi Differential Revision: D27367066 Pulled By: zhichao-cao fbshipit-source-id: 71fa1d492d9b0144decff0a1d0e0ef25c0ecc4ba	2021-03-28 23:06:08 -07:00
Jay Zhuang	9da6019f9d	Avoid checking errno on success call (#8119 ) Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/8119 Reviewed By: sushilpa Differential Revision: D27365407 Pulled By: jay-zhuang fbshipit-source-id: 327c09bf76834ce0be4287680640adc8b88bcec2	2021-03-28 23:05:56 -07:00
Zhichao Cao	d5e2462946	Fix flush no wal IO error bug (#8107 ) Summary: There is bug in the current code base introduced in https://github.com/facebook/rocksdb/issues/8049 , we still set the SST file write IO Error only case as hard error. Fix it by removing the logic. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8107 Test Plan: make check, error_handler_fs_test Reviewed By: anand1976 Differential Revision: D27321422 Pulled By: zhichao-cao fbshipit-source-id: c014afc1553ca66b655e3bbf9d0bf6eb417ccf94	2021-03-25 21:52:27 -07:00
Zhichao Cao	5b3ebdc3d1	Added append with checksum handoff API to hdfs (#8084 ) Summary: Added append with checksum handoff API to hdfs Pull Request resolved: https://github.com/facebook/rocksdb/pull/8084 Test Plan: make check Reviewed By: ajkr Differential Revision: D27237823 Pulled By: zhichao-cao fbshipit-source-id: 93b38db23b1811a6daa049afb89240089ec6f67c	2021-03-23 17:25:42 -07:00